def test_build_tree():
mt = MerkleTools()
mt.add_leaf("tierion", do_hash=True)
mt.add_leaf(["bitcoin", "blockchain"], do_hash=True)
mt.make_tree()
assert mt.is_ready == True
mt.get_merkle_root(
) == '765f15d171871b00034ee55e48ffdf76afbc44ed0bcff5c82f31351d333c2ed1'
class MerkleTreeGenerator(object):
def __init__(self):
self.tree = MerkleTools(hash_type='sha256')
def populate(self, node_generator):
"""
Populate Merkle Tree with data from node_generator. This requires that node_generator yield byte[] elements.
Hashes, computes hex digest, and adds it to the Merkle Tree
:param node_generator:
:return:
"""
for data in node_generator:
hashed = hash_byte_array(data)
self.tree.add_leaf(hashed)
def get_blockchain_data(self):
"""
Finalize tree and return byte array to issue on blockchain
:return:
"""
self.tree.make_tree()
merkle_root = self.tree.get_merkle_root()
return h2b(ensure_string(merkle_root))
def get_proof_generator(self, tx_id, chain=Chain.bitcoin_mainnet):
"""
Returns a generator (1-time iterator) of proofs in insertion order.
:param tx_id: blockchain transaction id
:return:
"""
root = ensure_string(self.tree.get_merkle_root())
node_count = len(self.tree.leaves)
for index in range(0, node_count):
proof = self.tree.get_proof(index)
proof2 = []
for p in proof:
dict2 = dict()
for key, value in p.items():
dict2[key] = ensure_string(value)
proof2.append(dict2)
target_hash = ensure_string(self.tree.get_leaf(index))
merkle_proof = {
"type": ['MerkleProof2017', 'Extension'],
"merkleRoot":
root,
"targetHash":
target_hash,
"proof":
proof2,
"anchors": [{
"sourceId": to_source_id(tx_id, chain),
"type": chain.blockchain_type.external_display_value,
"chain": chain.external_display_value
}]
}
yield merkle_proof
def test_basics():
bLeft = 'a292780cc748697cb499fdcc8cb89d835609f11e502281dfe3f6690b1cc23dcb'
bRight = 'cb4990b9a8936bbc137ddeb6dcab4620897b099a450ecdc5f3e86ef4b3a7135c'
mRoot = hashlib.sha256(
bytearray.fromhex(bLeft) + bytearray.fromhex(bRight)).hexdigest()
# tree with no leaves
mt = MerkleTools()
mt.make_tree()
assert mt.get_merkle_root() is None
# tree with hex add_leaf
mt.add_leaf([bLeft, bRight])
mt.make_tree()
assert mt.get_merkle_root() == mRoot
def test_unhashed_leaves():
mt = MerkleTools()
mt.add_leaf('a', True)
mt.add_leaf('b', True)
mt.add_leaf('c', True)
mt.add_leaf('d', True)
mt.add_leaf('e', True)
mt.make_tree()
assert mt.get_merkle_root(
) == 'd71f8983ad4ee170f8129f1ebcdd7440be7798d8e1c80420bf11f1eced610dba'
mt.reset_tree()
mt.add_leaf(['a', 'b', 'c', 'd', 'e'], True)
mt.make_tree()
assert mt.get_merkle_root(
) == 'd71f8983ad4ee170f8129f1ebcdd7440be7798d8e1c80420bf11f1eced610dba'
def calculate_merkle_root(hashes):
mt = MerkleTools(hash_type='sha3_256')
for h in hashes:
mt.add_leaf(h)
mt.make_tree()
return mt.get_merkle_root()
def test_one_leaf():
# make tree with one leaf
mt = MerkleTools()
mt.add_leaf([
'ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb',
])
mt.make_tree()
assert mt.get_merkle_root(
) == 'ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb'
def create_merkle_root(tx_set):
# Merkle root 생성
mt = MerkleTools(hash_type='sha256')
for tx in tx_set:
mt.add_leaf(str(tx), True)
mt.make_tree()
root_value = mt.get_merkle_root()
return root_value
def gen_merkle_tree(tx_list):
mt = MerkleTools(hash_type="sha256")
mt.add_leaf(tx_list, True)
mt.make_tree()
for index in range(0, mt.leaves.__len__()):
logger.info("Transaction" + str(index) + ": " + mt.get_leaf(index))
while not mt.is_ready:
logger.error("mt is not ready!")
return mt.get_merkle_root()
def test_md5_tree():
bLeftmd5 = '0cc175b9c0f1b6a831c399e269772661'
bRightmd5 = '92eb5ffee6ae2fec3ad71c777531578f'
mRootmd5 = hashlib.md5(
bytearray.fromhex(bLeftmd5) +
bytearray.fromhex(bRightmd5)).hexdigest()
mt = MerkleTools('md5')
mt.add_leaf([bLeftmd5, bRightmd5])
mt.make_tree()
assert mt.get_merkle_root() == mRootmd5
def test_5_leaves():
mt = MerkleTools()
mt.add_leaf([
'ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb',
'3e23e8160039594a33894f6564e1b1348bbd7a0088d42c4acb73eeaed59c009d',
'2e7d2c03a9507ae265ecf5b5356885a53393a2029d241394997265a1a25aefc6',
'18ac3e7343f016890c510e93f935261169d9e3f565436429830faf0934f4f8e4',
'3f79bb7b435b05321651daefd374cdc681dc06faa65e374e38337b88ca046dea'
])
mt.make_tree()
assert mt.get_merkle_root(
) == 'd71f8983ad4ee170f8129f1ebcdd7440be7798d8e1c80420bf11f1eced610dba'
def to_merkle_tree(list_of_transactions):
merkle_tree = MerkleTools()
for tx in list_of_transactions:
print("tx: ", type(tx))
print(tx)
if isinstance(tx, Transaction):
merkle_tree.add_leaf(tx.signature, True)
else:
merkle_tree.add_leaf(tx['signature'], True)
merkle_tree.make_tree()
return merkle_tree.get_merkle_root()
def generate_block_candidate(request, miner_address):
# Get unconfirmed transactions
transaction_list = Transaction.objects.filter(
transfer_successful=False).exclude(
from_address=settings.GENESIS_ADDRESS)
last_mined_block = Block.objects.last()
if not last_mined_block:
last_mined_block = GenesisBlock.objects.last()
# add Coinbase transaction
coinbase_transaction = generate_coinbase_transaction(
miner_address, last_mined_block.index + 1)
merkle_tree = MerkleTools()
for transaction in transaction_list:
merkle_tree.add_leaf(transaction.transaction_data_hash)
merkle_tree.add_leaf(coinbase_transaction['transaction_data_hash'])
merkle_tree.make_tree()
if merkle_tree.is_ready:
merkle_root = merkle_tree.get_merkle_root()
else:
return False
block_data_hash = hashlib.sha256(
("1" + str(merkle_root) + str(last_mined_block.difficulty) +
last_mined_block.block_hash + miner_address).encode('utf-8'))
pre_block_header = {
'index': str(last_mined_block.index + 1),
'hash_merkle_root': merkle_root,
'difficulty': settings.DIFFICULTY, # HARDCODED
'hash_prev_block': last_mined_block.block_hash,
'mined_by': miner_address,
'block_data_hash': block_data_hash.hexdigest(),
'nonce': 0,
'time': datetime.today().isoformat(),
}
BlockCandidate.objects.create(
index=last_mined_block.index +
1, # if mined successfully, this will be the index
block_data_hash=block_data_hash.hexdigest(
), # Merkle root included here
prev_block_hash=last_mined_block.block_hash,
difficulty=last_mined_block.difficulty,
transactions=serialize_transactions(transaction_list,
coinbase_transaction))
print("--------------------------------------------------------")
return HttpResponse(json.dumps(pre_block_header))
def test_sha224():
mt = MerkleTools(hash_type='sha224')
mt.add_leaf([
'90a3ed9e32b2aaf4c61c410eb925426119e1a9dc53d4286ade99a809',
'35f757ad7f998eb6dd3dd1cd3b5c6de97348b84a951f13de25355177'
])
mt.make_tree()
assert mt.get_merkle_root(
) == 'f48bc49bb77d3a3b1c8f8a70db693f41d879189cd1919f8326067ad7'
assert mt.get_proof(0)[0][
'right'] == '35f757ad7f998eb6dd3dd1cd3b5c6de97348b84a951f13de25355177'
is_valid = mt.validate_proof(
mt.get_proof(0),
'90a3ed9e32b2aaf4c61c410eb925426119e1a9dc53d4286ade99a809',
'f48bc49bb77d3a3b1c8f8a70db693f41d879189cd1919f8326067ad7')
assert is_valid == True
def test_sha256():
mt = MerkleTools(hash_type='sha256')
mt.add_leaf([
'1516f000de6cff5c8c63eef081ebcec2ad2fdcf7034db16045d024a90341e07d',
'e20af19f85f265579ead2578859bf089c92b76a048606983ad83f27ba8f32f1a'
])
mt.make_tree()
assert mt.get_merkle_root(
) == '77c654b3d1605f78ed091cbd420c939c3feff7d57dc30c171fa45a5a3c81fd7d'
assert mt.get_proof(0)[0][
'right'] == 'e20af19f85f265579ead2578859bf089c92b76a048606983ad83f27ba8f32f1a'
is_valid = mt.validate_proof(
mt.get_proof(0),
'1516f000de6cff5c8c63eef081ebcec2ad2fdcf7034db16045d024a90341e07d',
'77c654b3d1605f78ed091cbd420c939c3feff7d57dc30c171fa45a5a3c81fd7d')
assert is_valid == True
def test_sha3_256():
mt = MerkleTools(hash_type='sha3_256')
mt.add_leaf([
'1d7d4ea1cc029ca460e486642830c284657ea0921235c46298b51f0ed1bb7bf7',
'89b9e14eae37e999b096a6f604adefe7feea4dc240ccecb5e4e92785cffc7070'
])
mt.make_tree()
assert mt.get_merkle_root(
) == '6edf674f5ce762e096c3081aee2a0a977732e07f4d704baf34f5e3804db03343'
assert mt.get_proof(0)[0][
'right'] == '89b9e14eae37e999b096a6f604adefe7feea4dc240ccecb5e4e92785cffc7070'
is_valid = mt.validate_proof(
mt.get_proof(0),
'1d7d4ea1cc029ca460e486642830c284657ea0921235c46298b51f0ed1bb7bf7',
'6edf674f5ce762e096c3081aee2a0a977732e07f4d704baf34f5e3804db03343')
assert is_valid == True
def test_sha3_224():
mt = MerkleTools(hash_type='sha3_224')
mt.add_leaf([
'6ed712b9472b671fd70bb950dc4ccfce197c92a7969f6bc2aa6b6d9f',
'08db5633d406804d044a3e67683e179b5ee51249ed2139c239d1e65a'
])
mt.make_tree()
assert mt.get_merkle_root(
) == '674bc9f53d5c666174cdd3ccb9df04768dfb7759655e7d937aef0c3a'
assert mt.get_proof(0)[0][
'right'] == '08db5633d406804d044a3e67683e179b5ee51249ed2139c239d1e65a'
is_valid = mt.validate_proof(
mt.get_proof(0),
'6ed712b9472b671fd70bb950dc4ccfce197c92a7969f6bc2aa6b6d9f',
'674bc9f53d5c666174cdd3ccb9df04768dfb7759655e7d937aef0c3a')
assert is_valid == True
def test_sha3_512():
mt = MerkleTools(hash_type='sha3_512')
mt.add_leaf([
'004a237ea808cd9375ee9db9f85625948a890c54e2c30f736f54c969074eb56f0ff3d43dafb4b40d5d974acc1c2a68c046fa4d7c2c20cab6df956514040d0b8b',
'0b43a85d08c05252d0e23c96bc6b1bda11dfa787049ff452b3c86f4c6135e870c058c05131f199ef8619cfac937a736bbc936a667e4d96a5bf68e4056ce5fdce'
])
mt.make_tree()
assert mt.get_merkle_root(
) == '3dff3f19b67628591d294cba2c07ed20d20d83e1624af8c1dca8fcf096127b9f86435e2d6a84ca4cee526525cacd1c628bf06ee938983413afafbb4598c5862a'
assert mt.get_proof(0)[0][
'right'] == '0b43a85d08c05252d0e23c96bc6b1bda11dfa787049ff452b3c86f4c6135e870c058c05131f199ef8619cfac937a736bbc936a667e4d96a5bf68e4056ce5fdce'
is_valid = mt.validate_proof(
mt.get_proof(0),
'004a237ea808cd9375ee9db9f85625948a890c54e2c30f736f54c969074eb56f0ff3d43dafb4b40d5d974acc1c2a68c046fa4d7c2c20cab6df956514040d0b8b',
'3dff3f19b67628591d294cba2c07ed20d20d83e1624af8c1dca8fcf096127b9f86435e2d6a84ca4cee526525cacd1c628bf06ee938983413afafbb4598c5862a'
)
assert is_valid == True
def test_sha3_384():
mt = MerkleTools(hash_type='sha3_384')
mt.add_leaf([
'e222605f939aa69b964a0a03d7075676bb3dbb40c3bd10b22f0adcb149434e7c1085c206f0e3371470a49817aa6d5b16',
'ae331b6f8643ed7e404471c81be9a74f73fc84ffd5140a0ec9aa8596fa0d0a2ded5f7b780bb2fbfc4e2226ee2a04a2fa'
])
mt.make_tree()
assert mt.get_merkle_root(
) == 'bd54df0015fa0d4fee713fbf5c8ae232c93239c75fb9d41c7dd7a9278711764a6ee83c81766b3945ed94030254537b57'
assert mt.get_proof(0)[0][
'right'] == 'ae331b6f8643ed7e404471c81be9a74f73fc84ffd5140a0ec9aa8596fa0d0a2ded5f7b780bb2fbfc4e2226ee2a04a2fa'
is_valid = mt.validate_proof(
mt.get_proof(0),
'e222605f939aa69b964a0a03d7075676bb3dbb40c3bd10b22f0adcb149434e7c1085c206f0e3371470a49817aa6d5b16',
'bd54df0015fa0d4fee713fbf5c8ae232c93239c75fb9d41c7dd7a9278711764a6ee83c81766b3945ed94030254537b57'
)
assert is_valid == True
def test_sha512():
mt = MerkleTools(hash_type='sha512')
mt.add_leaf([
'c0a8907588c1da716ce31cbef05da1a65986ec23afb75cd42327634dd53d754be6c00a22d6862a42be5f51187a8dff695c530a797f7704e4eb4b473a14ab416e',
'df1e07eccb2a2d4e1b30d11e646ba13ddc426c1aefbefcff3639405762f216fdcc40a684f3d1855e6d465f99fd9547e53fa8a485f18649fedec5448b45963976'
])
mt.make_tree()
assert mt.get_merkle_root(
) == 'd9d27704a3a785d204257bfa2b217a1890e55453b6686f091fa1be8aa2b265bc06c285a909459996e093546677c3f392458d7b1fc34a994a86689ed4100e8337'
assert mt.get_proof(0)[0][
'right'] == 'df1e07eccb2a2d4e1b30d11e646ba13ddc426c1aefbefcff3639405762f216fdcc40a684f3d1855e6d465f99fd9547e53fa8a485f18649fedec5448b45963976'
is_valid = mt.validate_proof(
mt.get_proof(0),
'c0a8907588c1da716ce31cbef05da1a65986ec23afb75cd42327634dd53d754be6c00a22d6862a42be5f51187a8dff695c530a797f7704e4eb4b473a14ab416e',
'd9d27704a3a785d204257bfa2b217a1890e55453b6686f091fa1be8aa2b265bc06c285a909459996e093546677c3f392458d7b1fc34a994a86689ed4100e8337'
)
assert is_valid == True
def test_sha384():
mt = MerkleTools(hash_type='sha384')
mt.add_leaf([
'84ae8c6367d64899aef44a951edfa4833378b9e213f916c5eb8492cc37cb951c726e334dace7dbe4bb1dc80c1efe33d0',
'368c89a00446010def75ad7b179cea9a3d24f8cbb7e2755a28638d194809e7b614eb45453665032860b6c1a135fb6e8b'
])
mt.make_tree()
assert mt.get_merkle_root(
) == 'c363aa3b824e3f3b927034fab826eff61a9bfa2030ae9fc4598992edf9f3e42f8b497d6742946caf7a771429eb1745cf'
assert mt.get_proof(0)[0][
'right'] == '368c89a00446010def75ad7b179cea9a3d24f8cbb7e2755a28638d194809e7b614eb45453665032860b6c1a135fb6e8b'
is_valid = mt.validate_proof(
mt.get_proof(0),
'84ae8c6367d64899aef44a951edfa4833378b9e213f916c5eb8492cc37cb951c726e334dace7dbe4bb1dc80c1efe33d0',
'c363aa3b824e3f3b927034fab826eff61a9bfa2030ae9fc4598992edf9f3e42f8b497d6742946caf7a771429eb1745cf'
)
assert is_valid == True
def create_merkle_tree(matches, date):
"""
Here the merkle tree is created based on the given list with matches.
The package MerkleTools is being used to generate the Merkle Tree
The matches will first be "flattened" into a string and receive the date to make
these unique, so no the same hash will be generated, in for example: a rematch fight
"""
# get date and format the data
merkle_datalist = []
for match in matches:
merkle_datalist.append(f"{date}{str(match)}")
# make the tree
try:
mt = MerkleTools()
mt.add_leaf(merkle_datalist, True)
mt.make_tree()
return mt.get_merkle_root()
except Exception:
return None
class Block:
def __init__(self,
hash_str,
previous,
nonce,
height,
merkle_root=None,
transactions=None):
self.hash_str = hash_str
self.previous = previous
self.nonce = nonce
self.height = height
self.transactions = [] if transactions is None else transactions
self.merkle_root = merkle_root
self._mt = MerkleTools()
def add_transaction(self, transaction):
self.transactions.append(transaction)
self._mt.add_leaf(str(transaction.serialize()), True)
self._mt.make_tree()
self.merkle_root = self._mt.get_merkle_root()
def serialize(self):
return {
'hash': self.hash_str,
'previous': self.previous.hash_str if self.previous else None,
'nonce': self.nonce,
'height': self.height,
'merkle_root': self.merkle_root,
'transactions': [t.serialize() for t in self.transactions]
}
@classmethod
def deserialize(cls, serialized_block, previous):
return cls(serialized_block['hash'], previous,
serialized_block['nonce'], serialized_block['height'],
serialized_block['merkle_root'], [
Transaction.deserialize(t)
for t in serialized_block['transactions']
])
mempool = list(map(str, temp.split(",")))
mt = MerkleTools(hash_type="sha256")
s=input("Enter txn id to check:")
txn= str(s)
for i in range(len(mempool)):
mt.add_leaf(mempool[i])
mt.make_tree()
proof=mt.get_proof(mempool.index(txn)+1)
if mt.validate_proof(proof, mt.get_leaf(mempool.index(txn)+1), mt.get_merkle_root())==True:
print("Transaction is in mempool")
print("Witness:", proof)
else:
print("Transaction not in mempool")
def main():
# get paramters and contract details
# print(contractHash)
#preprocess_queue = queue.LifoQueue()
#inference_queue = queue.LifoQueue()
preprocess_queue = mp.Queue()
inference_queue = mp.Queue()
# postprocess_queue = Queue()
p1 = mp.Process(target=inference, args=(preprocess_queue, inference_queue))
p2 = mp.Process(target=preprocessing, args=(preprocess_queue, ))
#p1 = Process(target=dummy)
#p2 = Process(target=dummy)
# p3 = Process(target=Show_Image_mp, args=(Processed_frames, show, Final_frames))
p1.start()
p2.start()
# p3.start()
sk = SigningKey(Parameters.private_key_contractor)
contractHash = Helperfunctions.hashContract().encode('latin1')
dont_show = Parameters.dont_show
merkle_tree_interval = OutsourceContract.merkle_tree_interval
hostname = Parameters.ip_outsourcer # Use to receive from other computer
port = Parameters.port_outsourcer
sendingPort = Parameters.sendingPort
#import tensorflow as tf
# time.sleep(1.0)
# configure responder
responder = re.Responder(hostname, sendingPort)
# statistics info
moving_average_points = 50
# statistics
moving_average_fps = MovingAverage(moving_average_points)
moving_average_receive_time = MovingAverage(moving_average_points)
moving_average_decompress_time = MovingAverage(moving_average_points)
# moving_average_model_load_image_time = MovingAverage(moving_average_points)
moving_average_img_preprocessing_time = MovingAverage(
moving_average_points)
moving_average_model_inference_time = MovingAverage(moving_average_points)
moving_average_img_postprocessing_time = MovingAverage(
moving_average_points)
moving_average_reply_time = MovingAverage(moving_average_points)
moving_average_image_show_time = MovingAverage(moving_average_points)
moving_average_verify_image_sig_time = MovingAverage(moving_average_points)
moving_average_response_signing_time = MovingAverage(moving_average_points)
image_count = 0
a = 0
b = 0
if merkle_tree_interval > 0:
mt = MerkleTools()
mtOld = MerkleTools()
interval_count = 0
mtOld_leaf_indices = {}
mt_leaf_indices = {}
# rendundancy_counter = 0
# rendundancy_counter2 = 0
current_challenge = 1
merkle_root = ''
# stringsend = ''
last_challenge = 0
image_showed_time = time.perf_counter() # init
while True:
# start_time = time.perf_counter()
if not inference_queue.empty():
queueData = inference_queue.get()
while not inference_queue.empty():
queueData = inference_queue.get()
start_time = image_showed_time
# # boxes, scores, classes, valid_detections, name, original_image
#queueData=inference_queue.get()
#inference_queue.task_done()
# boxes=queueData[0]
# scores=queueData[1]
# classes=queueData[2]
# valid_detections=queueData[3]
# name = queueData[4]
# original_image = queueData[5]
boxtext = queueData[0]
image = queueData[1]
name = queueData[2]
if merkle_tree_interval > 0:
outsorucer_signature = name[:-5]
outsourcer_image_count = name[-5]
outsourcer_number_of_outputs_received = name[-4]
outsourcer_random_number = name[-3]
outsourcer_interval_count = name[-2]
outsourcer_time_to_challenge = bool(name[-1])
received_time = time.perf_counter()
image_preprocessing_time = time.perf_counter()
decompressed_time = time.perf_counter()
verify_time = time.perf_counter()
# inference
# region
# endregion
model_inferenced_time = time.perf_counter()
# image postprocessing
# region
h = time.perf_counter()
# endregion
if merkle_tree_interval == 0:
boxtext = 'Image' + str(name[-2]) + ':;' + boxtext
else:
boxtext = 'Image' + str(
outsourcer_image_count) + ':;' + boxtext
image_postprocessing_time = time.perf_counter()
# sign message ->need to add image_count/interval_count (for merkle tree sig), contract hash to output and verificaton
if merkle_tree_interval == 0:
# sig = sk.sign_deterministic(boxtext.encode('latin1'))
sig = sk.sign(boxtext.encode('latin1') +
contractHash).signature
# sig = list(sig)
sig = sig.decode('latin1')
# send reply
responder.respond(boxtext + ';--' + sig)
else:
# print(image_count)
# add leafs dynamiclly to merkle tree
mt.add_leaf(boxtext, True)
# remember indices for challenge
mt_leaf_indices[
outsourcer_image_count] = image_count % merkle_tree_interval
# print(image_count % merkle_tree_interval)
response = boxtext
# time to send a new merkle root
# e.g. if inervall = 128 then all respones from 0-127 are added to the merkle tree
if image_count > 1 and (image_count +
1) % merkle_tree_interval == 0:
# print(image_count)
a = time.perf_counter()
# rendundancy_counter = 2
mt.make_tree()
merkle_root = mt.get_merkle_root()
sig = sk.sign(
merkle_root.encode('latin1') + bytes(interval_count) +
contractHash).signature # sign merkle root
# resond with merkle root
response += ';--' + str(merkle_root) + \
';--' + sig.decode('latin1')
interval_count += 1
mtOld = mt # save old merkle tree for challenge
# mtOld_leaf_indices.clear() # clear old indices
mtOld_leaf_indices.clear()
mtOld_leaf_indices = mt_leaf_indices.copy(
) # save old indices for challenge
# print(mtOld_leaf_indices)
mt_leaf_indices.clear() # clear for new indices
# mt_leaf_indices = {}
mt = MerkleTools(
) # construct new merkle tree for next interval
te = time.perf_counter() - a
# print('1', te, image_count)
else:
# if this is true then the outsourcer has not received the merkle root yet -> send again
if interval_count > outsourcer_image_count:
sig = sk.sign(
merkle_root.encode('latin1') +
bytes(interval_count) +
contractHash).signature # sign merkle root
response += ';--' + str(merkle_root) + \
';--' + sig.decode('latin1')
# print('2', image_count)
else: # in this case outsourcer has confirmed to have recieved the merkle root
# in this case outsourcer has sent a challenge to meet with the old merkle tree, give outsourcer 3 frames time to confirm challenge received before sending again
if outsourcer_time_to_challenge and image_count - last_challenge > 3:
last_challenge = image_count
if outsourcer_random_number in mtOld_leaf_indices:
# if challenge can be found, send proof back
outsourcer_random_number_index = mtOld_leaf_indices[
outsourcer_random_number]
else:
# if challenge index cannot be found return leaf 0
outsourcer_random_number_index = 0
# print('proof index not found')
proofs = mtOld.get_proof(
outsourcer_random_number_index)
stringsend = ''
for proof in proofs:
stringsend += ';--' # indicate start of proof
stringsend += proof.__str__() # send proof
stringsend += ';--'
# send leaf
stringsend += mtOld.get_leaf(
outsourcer_random_number_index)
stringsend += ';--'
stringsend += mtOld.get_merkle_root() # send root
stringarr = []
stringarr = stringsend.split(';--')
leaf_node = stringarr[-2]
root_node = stringarr[-1]
proof_string = stringarr[0:-2]
# sign proof and contract details
sig = sk.sign(
str(stringarr[1:]).encode('latin1') +
bytes(interval_count - 1) +
contractHash).signature
# print(str(stringarr).encode('latin1') + bytes(interval_count-1) + contractHash)
# print(stringarr)
# attach signature
response += ';--' + sig.decode('latin1')
response += stringsend # attach challenge response to response
# print('3', te, image_count)
responder.respond(response)
response_signing_time = time.perf_counter()
# print(response_signing_time- image_postprocessing_time)
replied_time = time.perf_counter()
# display image
if not dont_show:
# image.show()
image = cv2.cvtColor(np.array(image), cv2.COLOR_BGR2RGB)
cv2.imshow('raspberrypi', image)
if cv2.waitKey(1) == ord('q'):
responder.respond('abort12345:6')
sys.exit(
'Contract aborted: Contractor ended contract according to custom'
)
image_showed_time = time.perf_counter()
# statistics
moving_average_fps.add(1 / (image_showed_time - start_time))
moving_average_receive_time.add(received_time - start_time)
moving_average_decompress_time.add(decompressed_time -
received_time)
moving_average_verify_image_sig_time.add(verify_time -
decompressed_time)
moving_average_img_preprocessing_time.add(
image_preprocessing_time - verify_time)
moving_average_model_inference_time.add(model_inferenced_time -
image_preprocessing_time)
moving_average_img_postprocessing_time.add(
image_postprocessing_time - model_inferenced_time)
moving_average_response_signing_time.add(
response_signing_time -
image_postprocessing_time) # adjust for merkle root
moving_average_reply_time.add(replied_time - response_signing_time)
moving_average_image_show_time.add(image_showed_time -
replied_time)
total_time=moving_average_receive_time.get_moving_average() \
+ moving_average_decompress_time.get_moving_average() \
+ moving_average_verify_image_sig_time.get_moving_average() \
+ moving_average_img_preprocessing_time.get_moving_average() \
+ moving_average_model_inference_time.get_moving_average() \
+ moving_average_img_postprocessing_time.get_moving_average() \
+ moving_average_response_signing_time.get_moving_average() \
+ moving_average_reply_time.get_moving_average() \
+ moving_average_image_show_time.get_moving_average()
if (image_count == 800):
a = time.perf_counter()
if (image_count == 1200):
a = time.perf_counter() - a
print(a)
# terminal prints
if image_count % 20 == 0:
print(
" total: %4.1fms (%4.1ffps) "
" receiving %4.1f (%4.1f%%) "
" decoding %4.1f (%4.1f%%) "
" verifying %4.1f (%4.1f%%) "
" preprocessing %4.1f (%4.1f%%) "
" model inference %4.1f (%4.1f%%) "
" postprocessing %4.1f (%4.1f%%) "
" signing %4.1f (%4.1f%%) "
" replying %4.1f (%4.1f%%) "
" display %4.1f (%4.1f%%) " % (
1000 / moving_average_fps.get_moving_average(),
moving_average_fps.get_moving_average(),
moving_average_receive_time.get_moving_average() *
1000,
moving_average_receive_time.get_moving_average() /
total_time * 100,
moving_average_decompress_time.get_moving_average() *
1000,
moving_average_decompress_time.get_moving_average() /
total_time * 100,
moving_average_verify_image_sig_time.
get_moving_average() * 1000,
moving_average_verify_image_sig_time.
get_moving_average() / total_time * 100,
moving_average_img_preprocessing_time.
get_moving_average() * 1000,
moving_average_img_preprocessing_time.
get_moving_average() / total_time * 100,
moving_average_model_inference_time.get_moving_average(
) * 1000,
moving_average_model_inference_time.get_moving_average(
) / total_time * 100,
moving_average_img_postprocessing_time.
get_moving_average() * 1000,
moving_average_img_postprocessing_time.
get_moving_average() / total_time * 100,
moving_average_response_signing_time.
get_moving_average() * 1000,
moving_average_response_signing_time.
get_moving_average() / total_time * 100,
moving_average_reply_time.get_moving_average() * 1000,
moving_average_reply_time.get_moving_average() /
total_time * 100,
moving_average_image_show_time.get_moving_average() *
1000,
moving_average_image_show_time.get_moving_average() /
total_time * 100,
),
end='\r')
# counter
image_count += 1
class ChainPointV2(object):
def __init__(self, hash_type="sha256"):
self.hash_type = hash_type.lower()
self.mk = MerkleTools(hash_type)
'''Wraps merkletools method'''
def reset_tree(self):
self.mk.reset_tree()
'''Wraps merkletools method'''
def add_leaf(self, values, do_hash=False):
self.mk.add_leaf(values, do_hash)
'''Wraps merkletools method'''
def get_leaf(self, index):
return self.mk.get_leaf(index)
'''Wraps merkletools method'''
def get_leaf_count(self):
return self.mk.get_leaf_count()
'''Wraps merkletools method'''
def get_tree_ready_state(self):
return self.mk.get_tree_ready_state()
'''Wraps merkletools method'''
def make_tree(self):
self.mk.make_tree()
'''Wraps merkletools method'''
def get_merkle_root(self):
return self.mk.get_merkle_root()
'''Wraps merkletools method'''
def get_proof(self, index):
return self.mk.get_proof(index)
'''Wraps merkletools method'''
def validate_proof(self, proof, target_hash, merkle_root):
return self.mk.validate_proof(proof, target_hash, merkle_root)
def get_chainpoint_hash_type(self):
return CHAINPOINT_HASH_TYPES[self.hash_type]
'''
Returns the chainpoint v2 blockchain receipt for specific leaf
Currently only works for BTC anchors
'''
def get_receipt(self, index, btc_source_id):
if self.get_tree_ready_state():
return {
"@context": CHAINPOINT_CONTEXT,
"type": self.get_chainpoint_hash_type(),
"targetHash": self.get_leaf(index),
"merkleRoot": self.get_merkle_root(),
"proof": self.get_proof(index),
"anchors": [{
"type": "BTCOpReturn",
"sourceId": btc_source_id
}]
}
else:
return None
'''
Validates a chainpoint receipt. Currently only for BTC anchors
receipt is the chainpoint_proof metadata from the pdf file.
certificate_hash is the hash of the certificate after we removed the
chainpoint_proof metadata
issuer_identifier is a fixed 8 bytes issuer code that displays on the
blockchain
testnet specifies if testnet or mainnet was used
'''
# TODO consider using exceptions instead of (bool, text) tuples; this is
# really only needed for valid but soon to expire
def validate_receipt(self,
receipt,
certificate_hash,
issuer_identifier='',
testnet=False):
# check context and hash type
if (receipt['@context'].lower() != CHAINPOINT_CONTEXT):
return False, "wrong chainpoint context"
if (receipt['type'] not in CHAINPOINT_HASH_TYPES.values()):
return False, "type not in CHAINPOINT_HASH_TYPES"
target_hash = receipt['targetHash']
merkle_root = receipt['merkleRoot']
proof = receipt['proof']
# validate actual hash
if target_hash.lower() != certificate_hash.lower():
return False, "certificate hash is different than the one in receipt"
# validate merkle proof
if (not self.validate_proof(proof, target_hash, merkle_root)):
return False, "certificate's hash is not in merkle root"
txid = self.get_txid_from_receipt(receipt)
# validate anchor
op_return_hex = network_utils.get_op_return_hex_from_blockchain(
txid, testnet)
# ignore issuer_identifier for now (it is string in CRED but used to be
# hex so we need a smart way to get it) -- TODO: obsolete it !!!
#issuer_id_hex = utils.text_to_hex(issuer_identifier)
# if op_return starts with CRED it is using the meta-protocol
op_dict = cred_protocol.parse_op_return_hex(op_return_hex)
if op_dict:
version_hex = op_dict['version']
command_hex = op_dict['cmd']
# could check if it is equal to issuer_id_hex
issuer_hex = op_dict['data']['issuer_identifier']
# get merkle root
hash_hex = op_dict['data']['merkle_root']
# if issue with expiry get expiry date
if command_hex == cred_protocol.hex_op('op_issue_abs_expiry'):
expiry_hex = op_return_hex[96:116]
else:
expiry_hex = None
#print(version_hex)
#print(command_hex)
#print(issuer_hex)
#print(hash_hex)
#print(merkle_root.lower())
# otherwise op_return should be fixed to 7 bytes or 14 hex chars (old prefix method)
else:
ignore_hex_chars = 14
hash_hex = op_return_hex[ignore_hex_chars:]
if (not merkle_root.lower() == hash_hex.lower()):
return False, "certificate's merkle root is different than the one in the blockchain"
# only for CRED protocol certificates check expiration date if
# issued with expiry date
if op_dict and expiry_hex:
expiry = utils.hex_to_int(expiry_hex)
if expiry > int(time.time()):
return True, "valid until: " + str(expiry)
else:
return False, "certificate expired at: " + str(expiry)
return True, None
# def get_op_return_hex_from_blockchain(self, txid, testnet):
# # uses blockcypher API for now -- TODO: expand to consult multiple services
# if testnet:
# blockcypher_url = "https://api.blockcypher.com/v1/btc/test3/txs/" + txid
# else:
# blockcypher_url = "https://api.blockcypher.com/v1/btc/main/txs/" + txid
#
# response = requests.get(blockcypher_url).json()
# outputs = response['outputs']
# hash_hex = ""
# for o in outputs:
# script = o['script']
# if script.startswith('6a'):
# # when > 75 op_pushdata1 (4c) is used before length
# if script.startswith('6a4c'):
# # 2 for 1 byte op_return + 2 for 1 byte op_pushdata1 + 2 for 1 byte data length
# ignore_hex_chars = 6
# else:
# # 2 for 1 byte op_return + 2 for 1 byte data length
# ignore_hex_chars = 4
#
# hash_hex = script[ignore_hex_chars:]
# break
# return hash_hex
def get_txid_from_receipt(self, receipt):
# get anchor
# TODO currently gets only the first valid (BTC) anchor
anchors = receipt['anchors']
txid = ''
for a in anchors:
if a['type'] in CHAINPOINT_ANCHOR_TYPES.values():
txid = a['sourceId']
break
return txid
class ChainPointV2(object):
def __init__(self, hash_type="sha256"):
self.hash_type = hash_type.lower()
self.mk = MerkleTools(hash_type)
'''Wraps merkletools method'''
def reset_tree(self):
self.mk.reset_tree()
'''Wraps merkletools method'''
def add_leaf(self, values, do_hash=False):
self.mk.add_leaf(values, do_hash)
'''Wraps merkletools method'''
def get_leaf(self, index):
return self.mk.get_leaf(index)
'''Wraps merkletools method'''
def get_leaf_count(self):
return self.mk.get_leaf_count()
'''Wraps merkletools method'''
def get_tree_ready_state(self):
return self.mk.get_tree_ready_state()
'''Wraps merkletools method'''
def make_tree(self):
self.mk.make_tree()
'''Wraps merkletools method'''
def get_merkle_root(self):
return self.mk.get_merkle_root()
'''Wraps merkletools method'''
def get_proof(self, index):
return self.mk.get_proof(index)
'''Wraps merkletools method'''
def validate_proof(self, proof, target_hash, merkle_root):
return self.mk.validate_proof(proof, target_hash, merkle_root)
def get_chainpoint_hash_type(self):
return CHAINPOINT_HASH_TYPES[self.hash_type]
'''
Returns the chainpoint v2 blockchain receipt for specific leaf
Currently only works for bitcoin and litecoin anchors
'''
def get_receipt(self, index, source_id, chain, testnet):
chain_type = utils.get_chain_type(chain, testnet)
if(chain_type is not None and self.get_tree_ready_state()):
return {
"@context": CHAINPOINT_CONTEXT,
"type": self.get_chainpoint_hash_type(),
"targetHash": self.get_leaf(index),
"merkleRoot": self.get_merkle_root(),
"proof": self.get_proof(index),
"anchors": [
{
"type": CHAINPOINT_ANCHOR_TYPES[chain_type],
"sourceId": source_id
}
]
}
else:
return None
'''
Validates a chainpoint receipt. Currently for BTC and LTC anchors
receipt is the chainpoint_proof metadata from the pdf file.
certificate_hash is the hash of the certificate after we removed the
chainpoint_proof metadata
issuer_identifier is a fixed 8 bytes issuer code that displays on the
blockchain
'''
# TODO consider using exceptions instead of (bool, text) tuples; this is
# really only needed for valid but soon to expire
def validate_receipt(self, receipt, op_return_hex, certificate_hash, issuer_identifier=''):
# check context and hash type
if(receipt['@context'].lower() != CHAINPOINT_CONTEXT):
return False, "wrong chainpoint context"
if(receipt['type'] not in CHAINPOINT_HASH_TYPES.values()):
return False, "chainpoint type not in CHAINPOINT_HASH_TYPES"
# currently only one anchor at a time is allowed; thus 0
if(receipt['anchors'][0]['type'] not in CHAINPOINT_ANCHOR_TYPES.values()):
return False, "anchor type not in CHAINPOINT_ANCHOR_TYPES"
target_hash = receipt['targetHash']
merkle_root = receipt['merkleRoot']
proof = receipt['proof']
# validate actual hash
if target_hash.lower() != certificate_hash.lower():
return False, "certificate hash is different than the one in receipt"
# validate merkle proof
if(not self.validate_proof(proof, target_hash, merkle_root)):
return False, "certificate's hash is not in merkle root"
# ignore issuer_identifier for now (it is string in CRED but used to be
# hex so we need a smart way to get it) -- TODO: obsolete it !!!
#issuer_id_hex = utils.text_to_hex(issuer_identifier)
# if op_return starts with CRED it is using the meta-protocol
op_dict = cred_protocol.parse_op_return_hex(op_return_hex)
if op_dict:
version_hex = op_dict['version']
command_hex = op_dict['cmd']
# could check if it is equal to issuer_id_hex
issuer_hex = op_dict['data']['issuer_identifier']
# get merkle root
hash_hex = op_dict['data']['merkle_root']
# if issue with expiry get expiry date
if command_hex == cred_protocol.hex_op('op_issue_abs_expiry'):
expiry_hex = op_return_hex[96:116]
else:
expiry_hex = None
#print(version_hex)
#print(command_hex)
#print(issuer_hex)
#print(hash_hex)
#print(merkle_root.lower())
# otherwise op_return should be fixed to 7 bytes or 14 hex chars (old prefix method)
else:
ignore_hex_chars = 14
hash_hex = op_return_hex[ignore_hex_chars:]
if(not merkle_root.lower() == hash_hex.lower()):
return False, "certificate's merkle root is different than the one in the blockchain"
# only for CRED protocol certificates check expiration date if
# issued with expiry date
if op_dict and expiry_hex:
expiry = utils.hex_to_int(expiry_hex)
if expiry > int(time.time()):
return True, "valid until: " + str(expiry)
else:
return False, "certificate expired at: " + str(expiry)
return True, None
# TODO: DELETE - NOT USED ANYWHERE !!
def get_chain_testnet_txid_from_receipt(self, receipt):
# get anchor
# TODO currently gets only the first valid anchor
anchors = receipt['anchors']
chain = ''
testnet = False
txid = ''
for a in anchors:
if a['type'] in CHAINPOINT_ANCHOR_TYPES.values():
if(a['type'] == 'BTCOpReturn'):
chain = 'bitcoin'
testnet = False
elif(a['type'] == 'LTCOpReturn'):
chain = 'litecoin'
testnet = False
elif(a['type'] == 'BTCTestnetOpReturn'):
chain = 'bitcoin'
testnet = True
elif(a['type'] == 'LTCTestnetOpReturn'):
chain = 'litecoin'
testnet = True
txid = a['sourceId']
break
return chain, testnet, txid
def _run3(self, merkle_tree_interval, contractHash, hostname, sendingPort):
self._readyToReceive.set()
sk = SigningKey(Parameters.private_key_self)
dont_show = Parameters.dont_show
if Parameters.is_contractor == True:
display_name = 'Contractor'
else:
display_name = 'Verifier'
responder = re.Responder(hostname, sendingPort)
if merkle_tree_interval > 0:
mt = MerkleTools()
mtOld = MerkleTools()
interval_count = 0
mtOld_leaf_indices = {}
mt_leaf_indices = {}
current_challenge = 1
merkle_root = ''
last_challenge = 0
while not self._stop:
self._received.wait()
self._received.clear()
boxtext = self._data3[0]
image = self._data3[1]
name = self._data3[2]
self._image_count = self._data3[3]
if merkle_tree_interval == 0:
sig = sk.sign(boxtext.encode('latin1') +
contractHash).signature
sig = sig.decode('latin1')
# send reply
responder.respond(boxtext + ';--' + sig)
else:
image_count = self._image_count
outsorucer_signature = name[:-5]
outsourcer_image_count = name[-5]
outsourcer_number_of_outputs_received = name[-4]
outsourcer_random_number = name[-3]
outsourcer_interval_count = name[-2]
outsourcer_time_to_challenge = bool(name[-1])
mt.add_leaf(boxtext, True)
mt_leaf_indices[
outsourcer_image_count] = image_count % merkle_tree_interval
response = boxtext
# time to send a new merkle root
# e.g. if inervall = 128 then all respones from 0-127 are added to the merkle tree
if image_count > 1 and (image_count +
1) % merkle_tree_interval == 0:
mt.make_tree()
merkle_root = mt.get_merkle_root()
sig = sk.sign(
merkle_root.encode('latin1') + bytes(interval_count) +
contractHash).signature # sign merkle root
# resond with merkle root
response += ';--' + str(merkle_root) + \
';--' + sig.decode('latin1')
interval_count += 1
mtOld = mt # save old merkle tree for challenge
mtOld_leaf_indices.clear()
mtOld_leaf_indices = mt_leaf_indices.copy(
) # save old indices for challenge
mt_leaf_indices.clear() # clear for new indices
mt = MerkleTools(
) # construct new merkle tree for next interval
else:
# if this is true then the outsourcer has not received the merkle root yet -> send again
if interval_count > outsourcer_image_count:
sig = sk.sign(
merkle_root.encode('latin1') +
bytes(interval_count) +
contractHash).signature # sign merkle root
response += ';--' + str(merkle_root) + \
';--' + sig.decode('latin1')
else: # in this case outsourcer has confirmed to have recieved the merkle root
# in this case outsourcer has sent a challenge to meet with the old merkle tree, give outsourcer 3 frames time to confirm challenge received before sending again
if outsourcer_time_to_challenge and image_count - last_challenge > 3:
last_challenge = image_count
if outsourcer_random_number in mtOld_leaf_indices:
# if challenge can be found, send proof back
outsourcer_random_number_index = mtOld_leaf_indices[
outsourcer_random_number]
else:
# if challenge index cannot be found return leaf 0
outsourcer_random_number_index = 0
proofs = mtOld.get_proof(
outsourcer_random_number_index)
stringsend = ''
for proof in proofs:
stringsend += ';--' # indicate start of proof
stringsend += proof.__str__() # send proof
stringsend += ';--'
# send leaf
stringsend += mtOld.get_leaf(
outsourcer_random_number_index)
stringsend += ';--'
stringsend += mtOld.get_merkle_root() # send root
stringarr = []
stringarr = stringsend.split(';--')
leaf_node = stringarr[-2]
root_node = stringarr[-1]
proof_string = stringarr[0:-2]
sig = sk.sign(
str(stringarr[1:]).encode('latin1') +
bytes(interval_count - 1) + contractHash
).signature # sign proof and contract details
# attach signature
response += ';--' + sig.decode('latin1')
response += stringsend # attach challenge response to response
responder.respond(response)
# display image
if not dont_show:
# image.show()
image = cv2.cvtColor(np.array(image), cv2.COLOR_BGR2RGB)
cv2.imshow(display_name, image)
if cv2.waitKey(1) == ord('q'):
responder.respond('abort12345:6')
if self._stop:
sys.exit(self._stop_message)
else:
self._stop = True
self._stop_message = 'Contract aborted: Contractor ended contract according to custom'
print(self._stop_message)
sys.exit(self._stop_message)
self._readyToReceive.set()
class Smartmeter():
'''A class define what each noeud can do in the consenus process'''
def __init__(self, me):
'''Initialisation some attributes'''
self.me = me # id of smart meter
self.users = 12 # number of smart meters in the network
# list_reputation = []
self.peers = 4 # number of peers (P% best nodes)
def get_list_from_bloc(self):
''' Get the reputation list from the last bloc in the blockchain '''
self.loop = asyncio.get_event_loop()
self.cli = Client(
net_profile="/home/Adel/Desktop/PFE/Two_Chain_Network_Template/pfe-project/sdk/MyNetwork.json")
self.org1_admin = self.cli.get_user('org1.dz', 'Admin')
self.cli.new_channel("firstchannel")
# first get the hash by calling 'query_info'
self.response = self.loop.run_until_complete(self.cli.query_info(
requestor=self.org1_admin,
channel_name='firstchannel',
peers=['peer0.org1.dz'],
decode=True
))
self.test_hash = self.response.currentBlockHash
self.response = self.loop.run_until_complete(self.cli.query_block_by_hash(
requestor=self.org1_admin,
channel_name='firstchannel',
peers=['peer0.org1.dz'],
block_hash=self.test_hash,
decode=True
))
self.List_rep_bloc_byte = \
self.response.get('data').get('data')[0].get('payload').get('data').get('actions')[0].get('payload').get(
'action').get(
'proposal_response_payload').get('extension').get('results').get('ns_rwset')[0].get('rwset').get(
'writes')[
0].get('value')
self.List_rep_bloc_str = self.List_rep_bloc_byte.decode("UTF-8") # convert byte to string
self.List_rep_bloc_dic = ast.literal_eval(self.List_rep_bloc_str) # convert dictionary string to dictionary
for self.k, self.v in self.List_rep_bloc_dic.items():
if self.k == 'Liste des reputations':
self.List_rep_bloc = ast.literal_eval(self.v) # convert list from str -> list
#str to int
#for self.i in range(0, len(self.List_rep_bloc)):
# self.List_rep_bloc[self.i] = int(self.List_rep_bloc[self.i])
return self.List_rep_bloc
def get_leader_and_p(self, reputation_list_bloc):
''' return the leader and the P% nodes based on the reputation list in the last bloc in the blockchain '''
self.list_reputation_slice = reputation_list_bloc[:]
self.leader_id = self.list_reputation_slice.index(
max(self.list_reputation_slice)) # 1er min id of node -leader- (men les P%) that has max reputation.
self.list_p = []
self.list_p.append(self.leader_id)
self.list_reputation_slice[self.leader_id] = 0
for i in range(0, self.peers - 1):
self.p_id = self.list_reputation_slice.index(max(
self.list_reputation_slice)) # p_1 i.e P%_1 - premier noeud du p% - (# 2eme min id of node (men les P%) that has max reputation.)
self.list_p.append(self.p_id) # list_p contient le id du leader et les id des P%.
self.list_reputation_slice[self.p_id] = 0
return self.list_p
def send_mesure_to_p(self, user, list_p):
'''Send data to all P% -normalment to all nodes-'''
self.loop = asyncio.get_event_loop()
self.cli = Client(
net_profile="/home/Adel/Desktop/PFE/Two_Chain_Network_Template/pfe-project/sdk/MyNetwork.json")
self.org1_admin = self.cli.get_user('org1.dz', user) # user = User1 or User2 ...
# Make the client know there is a channel in the network
self.cli.new_channel('secondchannel')
self.my_data = str(random.randint(2, 22)) + "kw" # data consumed by the SM
# my_reputation = str(list_reputation[Me]) #reputation of this SM. On envoi pas la reputation.
for i in range(0, self.peers):
'''Send data consumed by this SM
To all the peers in the network (P%)
car c eux qui font la verification du bloc
'''
self.args = ['SM' + str(list_p[i]), str(self.me), str(self.my_data)]
# The response should be true if succeed
self.response = self.loop.run_until_complete(
self.cli.chaincode_invoke(
requestor=self.org1_admin,
channel_name='secondchannel',
peers=['peer' + str(i) + '.org1.dz'],
args=self.args,
fcn='NewData',
cc_name='test_cc2',
transient_map=None, # optional, for private data
wait_for_event=True,
)
)
def retrieve_merkle_data(self, user, list_p):
self.ret = ""
self.loop = asyncio.get_event_loop()
self.cli = Client(net_profile="/home/Adel/Desktop/PFE/Two_Chain_Network_Template/pfe-project/sdk/MyNetwork.json")
self.org1_admin = self.cli.get_user('org1.dz', user) # user = User1 or User2 ...
# Make the client know there is a channel in the network
self.cli.new_channel('secondchannel')
self.list_pp = list_p[:]
self.list_data_retrived = []
#del self.list_pp[0]
if 1 == 1:
# self.list_data_retrived = []
self.args = ['SM' + str(self.list_pp[0])]
self.lead_me = '0' # l'id du peer qui est relier avec le leader
for i in range(0, 2):
# The response should be true if succeed
self.response = self.loop.run_until_complete(self.cli.chaincode_query(
requestor=self.org1_admin,
fcn="GetData",
channel_name='secondchannel',
peers=['peer' + self.lead_me + '.org1.dz'],
args=self.args,
cc_name='test_cc2'
))
self.response = json.loads(self.response)
self.list_data_retrived.append(self.response)
if self.me == self.list_pp[0] or self.me not in self.list_pp:
break
self.args = ['SM' + str(self.me)]
self.lead_me = str(self.list_pp.index(self.me)) # mon id in str to use it in cli.chaincode_query "peers"
#self.response = json.loads(self.response)
#
#self.list_data_retrived.append(self.response)
#
# print(self.list_data_retrived)
if self.me in self.list_pp and self.me != self.list_pp[0]:
if (self.list_data_retrived[0]['MerklerootDATA'] == self.list_data_retrived[1]['MerklerootDATA']):
self.ret = "true"
else:
self.ret = "false"
return (self.list_data_retrived[0]['Consommations'], self.list_data_retrived[0]['MerklerootDATA'], self.list_data_retrived[0]['Timestamp'], self.ret)
def send_vote_b1(self, user, list_p, result_comparaison):
''' every user from P% send votes about the validation of B1 (merkle root local comparer avec merkle root du leader)'''
self.list_pp = list_p[:]
del self.list_pp[0]
if self.me in self.list_pp:
if result_comparaison == "true":
self.vote = "accepter"
elif result_comparaison == "false":
self.vote = "rejeter"
self.loop = asyncio.get_event_loop()
self.cli = Client(net_profile="/home/Adel/Desktop/PFE/Two_Chain_Network_Template/pfe-project/sdk/MyNetwork.json")
self.org1_admin = self.cli.get_user('org1.dz', user) # user = User1 or User2 ...
# Make the client know there is a channel in the network
self.cli.new_channel('secondchannel')
self.args = ["B1_votes", str(self.me), self.vote]
# The response should be true if succeed
self.response = self.loop.run_until_complete(self.cli.chaincode_invoke(
requestor=self.org1_admin,
fcn='Votes',
channel_name='secondchannel',
peers=['peer0.org1.dz'], # the peer of the leader
args=self.args,
cc_name='test_cc2',
transient_map=None,
wait_for_event=True,
))
def retrieve_vote_b1(self, user):
'''Every user retrieve the list of validation of B1 that contain the votes of P%, and if B1 is valid or not'''
self.loop = asyncio.get_event_loop()
self.cli = Client(net_profile="/home/Adel/Desktop/PFE/Two_Chain_Network_Template/pfe-project/sdk/MyNetwork.json")
self.org1_admin = self.cli.get_user('org1.dz', user) # user = User1 or User2 ...
# Make the client know there is a channel in the network
self.cli.new_channel('secondchannel')
self.args = ['B1_votes']
# The response should be true if succeed
self.response = self.loop.run_until_complete(self.cli.chaincode_query(
requestor=self.org1_admin,
fcn='GetVotes',
channel_name='secondchannel',
peers=['peer0.org1.dz'],
args=self.args,
cc_name='test_cc2'
))
self.response = ast.literal_eval(self.response) # convert dictionary string to dictionary
return self.response["List Votes"] # return List
def maj_reputations(self, List, List_vote, leader):
'''mise a jour de la liste des reputations'''
self.validation_bloc = List_vote[-1]
self.List_copy = List[:]
if self.validation_bloc == 'valide':
self.List_copy [leader] = self.List_copy [leader] + 10
for self.i in range(0, len(List_vote)):
if List_vote[self.i] == 'accepter':
self.List_copy[self.i] = self.List_copy[self.i] + 10
elif List_vote[self.i] == 'rejeter':
self.List_copy[self.i] = self.List_copy[self.i] - 10
if self.validation_bloc == 'notvalide':
self.List_copy [leader] = self.List_copy [leader] - 10
for self.i in range(0, len(List_vote)):
if List_vote[self.i] == 'accepter':
self.List_copy[self.i] = self.List_copy[self.i] - 10
elif List_vote[self.i] == 'rejeter':
self.List_copy[self.i] = self.List_copy[self.i] + 10
for self.i in range(0, len(List)):
if self.List_copy[self.i] > 100:
self.List_copy[self.i] = 100
elif self.List_copy[self.i] < 0:
self.List_copy[self.i] = 0
return self.List_copy
def select_new_leader(self, p_leader, validation_b1, liste_vote_b1):
'''change leader only if the validation of bloc B1 (validation_b1) is = notvalid '''
self.new_leader = p_leader[0]
self.p_leader_new = p_leader[:]
self.boo = 1
if validation_b1 == 'notvalid':
while self.boo:
self.ancien_leader = self.p_leader_new.pop(0)
self.p_leader_new.append(self.ancien_leader)
self.new_leader = self.p_leader_new[0]
if list_vote_b1[self.new_leader] == 'rejeter':
self.boo = 0
return (self.p_leader_new, self.new_leader)
def calculate_merkle_reputations(self, p_leader_new, list_rep_updated):
'''Calculer le merkle root de la liste des reputations par chaque noeud des P%'''
self.liste_maj_rep = list_rep_updated[:]
self.mt = MerkleTools(hash_type="sha256")
for self.i in range(0, len(self.liste_maj_rep)):
self.liste_maj_rep[self.i] = str(self.liste_maj_rep[self.i])
self.mt.add_leaf(self.liste_maj_rep, True)
self.mt.make_tree()
self.is_ready = self.mt.is_ready
self.root_value = self.mt.get_merkle_root()
return self.root_value
def send_maj_reputations(self, user, p_leader, p_leader_new, liste_maj_rep_hash):
# mypeer is the peer of the user(node) from the updated list p_leader "p_leader_new".
'''send the new reputations list to the actual peer of the leader in order to make a merkle root for it'''
if self.me == p_leader_new[0]:
self.loop = asyncio.get_event_loop()
self.cli = Client(net_profile="/home/Adel/Desktop/PFE/Two_Chain_Network_Template/pfe-project/sdk/MyNetwork.json")
self.org1_admin = self.cli.get_user('org1.dz', user) # user = User1 or User2 ...
# Make the client know there is a channel in the network
self.cli.new_channel('secondchannel')
self.mypeer = p_leader.index(p_leader_new[0])
self.args = ["hash_reputations", liste_maj_rep_hash]
# The response should be true if succeed
self.response = self.loop.run_until_complete(self.cli.chaincode_invoke(
requestor=self.org1_admin,
fcn='NewRep',
channel_name='secondchannel',
peers=['peer'+str(self.mypeer)+'.org1.dz'], # the peer of the leader
args=self.args,
cc_name='test_cc2',
transient_map=None,
wait_for_event=True,
))
def retrieve_merkle_reputations(self, user, p_leader, p_leader_new, local_hash_rep):
# l'id du peer qui est relier avec le leader
'''recuperer le merkle root de la liste de reputations a partir du peer du leader'''
self.result_comparaison2 = ""
self.loop = asyncio.get_event_loop()
self.cli = Client(net_profile="/home/Adel/Desktop/PFE/Two_Chain_Network_Template/pfe-project/sdk/MyNetwork.json")
self.org1_admin = self.cli.get_user('org1.dz', user) # user = User1 or User2 ...
# Make the client know there is a channel in the network
self.cli.new_channel('secondchannel')
self.list_pp = p_leader_new[:]
del self.list_pp[0]
if self.me in self.list_pp:
self.list_data_retrived = []
self.args = ["hash_reputations"]
self.peer_leader = p_leader.index(p_leader_new[0])
# The response should be true if succeed
self.response = self.loop.run_until_complete(self.cli.chaincode_query(
requestor=self.org1_admin,
fcn='GetRep',
channel_name='secondchannel',
peers=['peer' + str(self.peer_leader) + '.org1.dz'],
args=self.args,
cc_name='test_cc2'
))
#self.lead_me = str(self.list_pp.index(self.me) + 1) # mon id in str to use it in cli.chaincode_query "peers"
self.response = json.loads(self.response)
#print(type(self.response))
#self.list_data_retrived.append(self.response)
#
# print(self.list_data_retrived)
if self.response['MerklerootReputations'] == local_hash_rep:
self.result_comparaison2 = "true"
else:
self.result_comparaison2 = "false"
return self.result_comparaison2
def send_vote_b2(self, user, list_p, result_comparaison):
''' every user from P% send votes about the validation of B2 (merkle root local comparer avec merkle root du leader)'''
self.list_pp = list_p[:]
del self.list_pp[0]
if self.me in self.list_pp:
if result_comparaison == "true":
self.vote = "accepter"
elif result_comparaison == "false":
self.vote = "rejeter"
self.loop = asyncio.get_event_loop()
self.cli = Client(net_profile="/home/Adel/Desktop/PFE/Two_Chain_Network_Template/pfe-project/sdk/MyNetwork.json")
self.org1_admin = self.cli.get_user('org1.dz', user) # user = User1 or User2 ...
# Make the client know there is a channel in the network
self.cli.new_channel('secondchannel')
self.args = ["B2_votes", str(self.me), self.vote]
# The response should be true if succeed
self.response = self.loop.run_until_complete(self.cli.chaincode_invoke(
requestor=self.org1_admin,
fcn='Votes',
channel_name='secondchannel',
peers=['peer0.org1.dz'], # the peer of the leader "not necessarly"
args=self.args,
cc_name='test_cc2',
transient_map=None,
wait_for_event=True,
))
def retrieve_vote_b2(self, user):
'''Every user retrieve the list of validation of B2 that contain the votes of P%, and if B1 is valid or not'''
self.loop = asyncio.get_event_loop()
self.cli = Client(net_profile="/home/Adel/Desktop/PFE/Two_Chain_Network_Template/pfe-project/sdk/MyNetwork.json")
self.org1_admin = self.cli.get_user('org1.dz', user) # user = User1 or User2 ...
# Make the client know there is a channel in the network
self.cli.new_channel('secondchannel')
self.args = ["B2_votes"]
# The response should be true if succeed
self.response = self.loop.run_until_complete(self.cli.chaincode_query(
requestor=self.org1_admin,
fcn='GetVotes',
channel_name='secondchannel',
peers=['peer0.org1.dz'],
args=self.args,
cc_name='test_cc2',
))
self.response = ast.literal_eval(self.response) # convert dictionary string to dictionary
return self.response["List Votes"] # return List
def validation_b2(self,user, state_b2, state_b1, p_leader_new, time, data, mr_data, list_reputations, mr_reputations):
''' '''
self.value = ""
self.k = 0
if state_b2 == 'notvalide':
self.value = 'notvalide'
elif state_b2 == 'valide' and state_b1 == 'valide':
self.value = 'valide'
self.k = 1
elif state_b2 == 'valide' and state_b1 == 'notvalide':
self.value = 'valide'
self.k = 1
for self.i in range(0, len(data)):
data[self.i] = "0"
self.mt = MerkleTools(hash_type="sha256")
self.mt.add_leaf(data, True)
self.mt.make_tree()
mr_data = self.mt.get_merkle_root()
#print(self.value)
#print(p_leader_new[0])
if self.k == 1 and self.me == p_leader_new[0]:
#print(self.value)
#print(p_leader_new[0])
self.loop = asyncio.get_event_loop()
self.cli = Client(net_profile="/home/Adel/Desktop/PFE/Two_Chain_Network_Template/pfe-project/sdk/MyNetwork.json")
self.org1_admin = self.cli.get_user('org1.dz', user) # user = User1 or User2 ...
# Make the client know there is a channel in the network
self.cli.new_channel('firstchannel')
self.args = [str(time), str(data), str(mr_data), str(list_reputations), str(mr_reputations)]
# The response should be true if succeed
self.response = self.loop.run_until_complete(self.cli.chaincode_invoke(
requestor=self.org1_admin,
fcn='NewData',
channel_name='firstchannel',
peers=['peer0.org1.dz'],
args=self.args,
cc_name='first_chaincode',
transient_map=None,
wait_for_event=True,
))
#print(self.response)
#exit()
return self.value
myMerkleT = MerkleTools(hash_type="sha256") # This will make use of SHA256
myMerkleT.add_leaf(["Security", "Room14", "Professor"], True) # My first leaves.
myMerkleT.add_leaf(["Room12", "blockchain", "Python"], True) # This adds three leaves to the Tree.
myMerkleT.add_leaf(["Name:Justice", "Course:Computer Science"], True) # Another three leaves.
myMerkleT.make_tree() # Creating the Merkle Tree.
print('')
numberOfLeaves = myMerkleT.get_leaf_count()
print("The number of leaves of this tree is: ", numberOfLeaves)
print("root:", myMerkleT.get_merkle_root())
print("The value at leaf 2 is: ", myMerkleT.get_leaf(2))
print("The array of hash objects for the leaf at index 2 is: ", myMerkleT.get_proof(2))
print('')
print('************************ Merkle Proof ****************************')
print(myMerkleT.validate_proof(myMerkleT.get_proof(2), myMerkleT.get_leaf(2), myMerkleT.get_merkle_root())) # True
print('************************ Merkle Proof ****************************')
TestData = ["My Professor is helping me to learn well."]
def DataTest(testItem):
dataPrep = str(json.dumps(TestData))
testItem = (sha256(dataPrep.encode())).hexdigest()
class MerkleTreeGenerator(object):
def __init__(self):
self.tree = MerkleTools(hash_type='sha256')
def populate(self, node_generator):
"""
Populate Merkle Tree with data from node_generator. This requires that node_generator yield byte[] elements.
Hashes, computes hex digest, and adds it to the Merkle Tree
:param node_generator:
:return:
"""
for data in node_generator:
hashed = hash_byte_array(data)
self.tree.add_leaf(hashed)
def get_blockchain_data(self):
"""
Finalize tree and return byte array to issue on blockchain
:return:
"""
self.tree.make_tree()
merkle_root = self.tree.get_merkle_root()
return h2b(ensure_string(merkle_root))
def get_proof_generator(self,
tx_id,
app_config,
verification_method,
chain=Chain.bitcoin_mainnet):
"""
Returns a generator (1-time iterator) of proofs in insertion order.
:param tx_id: blockchain transaction id
:return:
"""
root = ensure_string(self.tree.get_merkle_root())
node_count = len(self.tree.leaves)
for index in range(0, node_count):
proof = self.tree.get_proof(index)
proof2 = []
#Change back to smart contract proof & verification
for p in proof:
dict2 = dict()
for key, value in p.items():
dict2[key] = ensure_string(value)
proof2.append(dict2)
target_hash = ensure_string(self.tree.get_leaf(index))
"""
Add additional parameters for smart contract certification
"""
if app_config.issuing_method == "smart_contract":
from cert_issuer.blockchain_handlers.ethereum_sc.ens import ENSConnector
ens = ENSConnector(app_config)
abi = ens.get_abi()
mp2019 = MerkleProof2019()
print(helpers.tx_to_blink(chain, tx_id))
merkle_json = {
"path": proof2,
"merkleRoot": root,
"targetHash": target_hash,
#Possibly adjust anchor to merkle_proof dict
"anchors": [helpers.tx_to_blink(chain, tx_id)]
}
logging.info('merkle_json: %s', str(merkle_json))
proof_value = mp2019.encode(merkle_json)
merkle_proof = {
"type": "MerkleProof2019",
"created": datetime.now().isoformat(),
"proofValue": proof_value.decode('utf8'),
"proofPurpose": "assertionMethod",
"verificationMethod": verification_method,
#Add ENS name for issuer validation
"ens_name": app_config.ens_name
}
#Uncomment after checking verification
"""
"anchors": [{
#helpers.tx_to_blink(chain, tx_id),
"sourceId": to_source_id(tx_id, chain),
"type": "ETHSmartContract",
"contract_address": app_config.contract_address,
"ens_name": app_config.ens_name,
"contract_abi": abi
}]
"""
else:
mp2019 = MerkleProof2019()
merkle_json = {
"path": proof2,
"merkleRoot": root,
"targetHash": target_hash,
"anchors": [helpers.tx_to_blink(chain, tx_id)]
}
logging.info('merkle_json: %s', str(merkle_json))
proof_value = mp2019.encode(merkle_json)
merkle_proof = {
"type": "MerkleProof2019",
"created": datetime.now().isoformat(),
"proofValue": proof_value.decode('utf8'),
"proofPurpose": "assertionMethod",
"verificationMethod": verification_method
}
yield merkle_proof
