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'
def test_bad_hex(): # try to add bad hex mt = MerkleTools() try: mt.add_leaf('nothexandnothashed') assert False # should not get here! except: pass
def verify(self): if not self.zonefile: return False self.__Fetch_Merkle_root() DNS_record = self.zonefile['record'] target_hash = hashlib.sha256(DNS_record).hexdigest() mt = MerkleTools() return mt.validate_proof(self.zonefile['proof'], target_hash, self.root)
def test_sha384(): mt = MerkleTools(hash_type='sha384') mt.add_leaves([ bytes.fromhex( '84ae8c6367d64899aef44a951edfa4833378b9e213f916c5eb8492cc37cb951c726e334dace7dbe4bb1dc80c1efe33d0' ), bytes.fromhex( '368c89a00446010def75ad7b179cea9a3d24f8cbb7e2755a28638d194809e7b614eb45453665032860b6c1a135fb6e8b' ) ]) mt.make_tree() assert mt.merkle_root == bytes.fromhex( 'c363aa3b824e3f3b927034fab826eff61a9bfa2030ae9fc4598992edf9f3e42f8b497d6742946caf7a771429eb1745cf' ) assert mt.get_proof(0)[0]['right'] == bytes.fromhex( '368c89a00446010def75ad7b179cea9a3d24f8cbb7e2755a28638d194809e7b614eb45453665032860b6c1a135fb6e8b' ) is_valid = mt.validate_proof( mt.get_proof(0), bytes.fromhex( '84ae8c6367d64899aef44a951edfa4833378b9e213f916c5eb8492cc37cb951c726e334dace7dbe4bb1dc80c1efe33d0' ), bytes.fromhex( 'c363aa3b824e3f3b927034fab826eff61a9bfa2030ae9fc4598992edf9f3e42f8b497d6742946caf7a771429eb1745cf' )) assert is_valid == True
def test_sha512(): mt = MerkleTools(hash_type='sha512') mt.add_leaves([ bytes.fromhex( 'c0a8907588c1da716ce31cbef05da1a65986ec23afb75cd42327634dd53d754be6c00a22d6862a42be5f51187a8dff695c530a797f7704e4eb4b473a14ab416e' ), bytes.fromhex( 'df1e07eccb2a2d4e1b30d11e646ba13ddc426c1aefbefcff3639405762f216fdcc40a684f3d1855e6d465f99fd9547e53fa8a485f18649fedec5448b45963976' ) ]) mt.make_tree() assert mt.merkle_root == bytes.fromhex( 'd9d27704a3a785d204257bfa2b217a1890e55453b6686f091fa1be8aa2b265bc06c285a909459996e093546677c3f392458d7b1fc34a994a86689ed4100e8337' ) assert mt.get_proof(0)[0]['right'] == bytes.fromhex( 'df1e07eccb2a2d4e1b30d11e646ba13ddc426c1aefbefcff3639405762f216fdcc40a684f3d1855e6d465f99fd9547e53fa8a485f18649fedec5448b45963976' ) is_valid = mt.validate_proof( mt.get_proof(0), bytes.fromhex( 'c0a8907588c1da716ce31cbef05da1a65986ec23afb75cd42327634dd53d754be6c00a22d6862a42be5f51187a8dff695c530a797f7704e4eb4b473a14ab416e' ), bytes.fromhex( 'd9d27704a3a785d204257bfa2b217a1890e55453b6686f091fa1be8aa2b265bc06c285a909459996e093546677c3f392458d7b1fc34a994a86689ed4100e8337' )) assert is_valid == True
def test_sha3_384(): mt = MerkleTools(hash_type='sha3_384') mt.add_leaves([ bytes.fromhex( 'e222605f939aa69b964a0a03d7075676bb3dbb40c3bd10b22f0adcb149434e7c1085c206f0e3371470a49817aa6d5b16' ), bytes.fromhex( 'ae331b6f8643ed7e404471c81be9a74f73fc84ffd5140a0ec9aa8596fa0d0a2ded5f7b780bb2fbfc4e2226ee2a04a2fa' ) ]) mt.make_tree() assert mt.merkle_root == bytes.fromhex( 'bd54df0015fa0d4fee713fbf5c8ae232c93239c75fb9d41c7dd7a9278711764a6ee83c81766b3945ed94030254537b57' ) assert mt.get_proof(0)[0]['right'] == bytes.fromhex( 'ae331b6f8643ed7e404471c81be9a74f73fc84ffd5140a0ec9aa8596fa0d0a2ded5f7b780bb2fbfc4e2226ee2a04a2fa' ) is_valid = mt.validate_proof( mt.get_proof(0), bytes.fromhex( 'e222605f939aa69b964a0a03d7075676bb3dbb40c3bd10b22f0adcb149434e7c1085c206f0e3371470a49817aa6d5b16' ), bytes.fromhex( 'bd54df0015fa0d4fee713fbf5c8ae232c93239c75fb9d41c7dd7a9278711764a6ee83c81766b3945ed94030254537b57' )) assert is_valid == True
def test_sha3_512(): mt = MerkleTools(hash_type='sha3_512') mt.add_leaves([ bytes.fromhex( '004a237ea808cd9375ee9db9f85625948a890c54e2c30f736f54c969074eb56f0ff3d43dafb4b40d5d974acc1c2a68c046fa4d7c2c20cab6df956514040d0b8b' ), bytes.fromhex( '0b43a85d08c05252d0e23c96bc6b1bda11dfa787049ff452b3c86f4c6135e870c058c05131f199ef8619cfac937a736bbc936a667e4d96a5bf68e4056ce5fdce' ) ]) mt.make_tree() assert mt.merkle_root == bytes.fromhex( '3dff3f19b67628591d294cba2c07ed20d20d83e1624af8c1dca8fcf096127b9f86435e2d6a84ca4cee526525cacd1c628bf06ee938983413afafbb4598c5862a' ) assert mt.get_proof(0)[0]['right'] == bytes.fromhex( '0b43a85d08c05252d0e23c96bc6b1bda11dfa787049ff452b3c86f4c6135e870c058c05131f199ef8619cfac937a736bbc936a667e4d96a5bf68e4056ce5fdce' ) is_valid = mt.validate_proof( mt.get_proof(0), bytes.fromhex( '004a237ea808cd9375ee9db9f85625948a890c54e2c30f736f54c969074eb56f0ff3d43dafb4b40d5d974acc1c2a68c046fa4d7c2c20cab6df956514040d0b8b' ), bytes.fromhex( '3dff3f19b67628591d294cba2c07ed20d20d83e1624af8c1dca8fcf096127b9f86435e2d6a84ca4cee526525cacd1c628bf06ee938983413afafbb4598c5862a' )) assert is_valid == True
def verify(): if request.method == 'POST': if 'json' not in request.files or 'pdf' not in request.files: flash("All files not selected", "danger") return render_template('verify.html') jsonFile = request.files['json'] pdf = request.files['pdf'] if jsonFile.filename == '' or pdf.filename == '': flash("All files not selected", "danger") return render_template('verify.html') if jsonFile and allowed_verification_file( jsonFile.filename) and pdf and allowed_verification_file( pdf.filename): json_name = secure_filename(jsonFile.filename) jsonFile.save(os.path.join(app.config['JSON_FOLDER'], json_name)) pdf_name = secure_filename(pdf.filename) pdf.save(os.path.join(app.config['RESUME_FOLDER'], pdf_name)) resumeJsonData = ResumeParser.parse( os.path.join(app.config['RESUME_FOLDER'], pdf_name)) with open(os.path.join(app.config['JSON_FOLDER'], json_name)) as receiptJson: receiptJsonData = json.loads(receiptJson.read()) if resumeJsonData["cpi"] != receiptJsonData[ "cpi"] or resumeJsonData["name"] != receiptJsonData[ "name"] or resumeJsonData["year"] != receiptJsonData[ "year"]: flash("Details don't match", "danger") else: mt = MerkleTools(hash_type='sha3_256') data = receiptJsonData['studentId'] + receiptJsonData[ 'cpi'] + receiptJsonData['name'] + receiptJsonData[ 'year'] + receiptJsonData['institution'] data = data.encode() data = hashlib.sha3_256(data).hexdigest() # print(mt.validate_proof(receiptJsonData['merklePath'], data)) merkleRoot = mt.validate_proof(receiptJsonData['merklePath'], data) res = False try: bc = Blockchain("VJTI") res = bc.verifyBatchMerkleRoot( receiptJsonData["institution"], receiptJsonData["year"], merkleRoot) except: print("Error occurred") if res is True: flash("Details verified successfully using the Blockchain", "success") else: flash("Details don't match", "danger") return render_template('verify.html')
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 test_bad_proof(): bLeft = 'a292780cc748697cb499fdcc8cb89d835609f11e502281dfe3f6690b1cc23dcb' bRight = 'cb4990b9a8936bbc137ddeb6dcab4620897b099a450ecdc5f3e86ef4b3a7135c' mt = MerkleTools() mt.add_leaf(bLeft) mt.add_leaf(bRight) mt.make_tree() proof = mt.get_proof(1) is_valid = mt.validate_proof(proof, bRight, bLeft) assert not is_valid
def merkle(seq_no): data = read_seq_no(seq_no) if not data: raise Exception("No data") commit = data['COMMIT']['data'] commit_dict = msgpack.unpackb(bytes.fromhex(commit)) mt = MerkleTools(hash_type=commit_dict[b'hash_type'].decode('ascii')) mt.leaves = commit_dict[b'leaves'] mt.make_tree() assert mt.merkle_root == commit_dict[b'root'] return mt
def __init__(self, index): # Block Header self.index = index self.timestamp = time() self.block_hash = None self.previous_hash = None self.nonce = 0 self.next_block = None self.merkle_tree = MerkleTools() # Transaction self.transactions = []
def reset_chains(self): """ reset the state of the application. """ self.bdomainschain = Blockchain() self.bobjectschain = Blockchain() self.bdomainstree = MerkleTools(hash_type="md5") self.bobjectstree = MerkleTools(hash_type="md5") self.db0domains = DB0() self.db0objects = DB0() self.users = {} self.groups = {} self.acls = {} self.acis = {}
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 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 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()
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_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 __init__(self, program, bootstrapping_key): """ Initializes the Sputnik Engine with a Program and a FHE bootstrapping key. """ self.program = program self.bootstrapping_key = bootstrapping_key # Merkle-tree for verification self.merkle = MerkleTools(hash_type='SHA256') # Setup NuFHE self.thr = any_api().Thread.create(interactive=True) self.rng = numpy.random.RandomState() self.pp = nufhe.performance_parameters(single_kernel_bootstrap=False, transforms_per_block=1)
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_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_proof_nodes(): bLeft = 'a292780cc748697cb499fdcc8cb89d835609f11e502281dfe3f6690b1cc23dcb' bRight = 'cb4990b9a8936bbc137ddeb6dcab4620897b099a450ecdc5f3e86ef4b3a7135c' mRoot = hashlib.sha256( bytearray.fromhex(bLeft) + bytearray.fromhex(bRight)).hexdigest() mt = MerkleTools() mt.add_leaf(bLeft) mt.add_leaf(bRight) mt.make_tree() proof = mt.get_proof(0) assert proof[0][ 'right'] == 'cb4990b9a8936bbc137ddeb6dcab4620897b099a450ecdc5f3e86ef4b3a7135c' proof = mt.get_proof(1) assert proof[0][ 'left'] == 'a292780cc748697cb499fdcc8cb89d835609f11e502281dfe3f6690b1cc23dcb'
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_get_proof(): mt = MerkleTools() mt.add_leaf("tierion") mt.add_leaf(["bitcoin", "blockchain"]) mt.make_tree() proof_1 = mt.get_proof(1) for p in proof_1: if 'left' in p: assert p[ 'left'] == '2da7240f6c88536be72abe9f04e454c6478ee29709fc3729ddfb942f804fbf08' else: assert p[ 'right'] == 'ef7797e13d3a75526946a3bcf00daec9fc9c9c4d51ddc7cc5df888f74dd434d1'
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
def inMerkleTree(self, transaction): if self.notInTree: return False return MerkleTools().validate_proof( self.hashList, sha256(str(transaction).encode('utf-8')).hexdigest(), self.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 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 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_get_proof(): mt = MerkleTools() mt.add_leaf("tierion", do_hash=True) mt.add_leaves(["bitcoin", "blockchain"], do_hash=True) mt.make_tree() proof_1 = mt.get_proof(1) for p in proof_1: try: assert p['left'] == bytes.fromhex( '2da7240f6c88536be72abe9f04e454c6478ee29709fc3729ddfb942f804fbf08' ) except: assert p['right'] == bytes.fromhex( 'ef7797e13d3a75526946a3bcf00daec9fc9c9c4d51ddc7cc5df888f74dd434d1' )