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'
)
