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