def test_verify_leaf_inclusion_bad_proof(self):
verifier = merkle.MerkleVerifier(HexTreeHasher())
# Expect this test to fail by providing an incorrect root hash.
sth = self.STH(self.zeros, self.tree_size)
self.assertRaises(error.ProofError, verifier.verify_leaf_inclusion,
self.raw_hex_leaf, self.leaf_index,
self.sha256_audit_path, sth)
def test_verify_leaf_inclusion_single_node_in_tree(self):
# If there is only one entry in the tree, the tree root hash should be
# equal to the leaf hash.
verifier = merkle.MerkleVerifier(HexTreeHasher())
sth = self.STH(self.leaf_hash, 1)
self.assertTrue(
verifier.verify_leaf_inclusion(self.raw_hex_leaf, 0, [], sth))
def test_verify_leaf_inclusion_throws_on_bad_indices(self):
verifier = merkle.MerkleVerifier(HexTreeHasher())
sth = self.STH("", 6)
self.assertRaises(ValueError, verifier.verify_leaf_inclusion, "", -3,
[], sth)
negative_sth = self.STH("", -3)
self.assertRaises(ValueError, verifier.verify_leaf_inclusion, "", 3,
[], negative_sth)
def test_calculate_root_too_short_proof(self):
verifier = merkle.MerkleVerifier(HexTreeHasher())
leaf_index = self.leaf_index + int(
math.pow(2,
len(self.sha256_audit_path) + 1))
self.assertRaises(error.ProofError,
verifier._calculate_root_hash_from_audit_path,
self.leaf_hash, leaf_index,
self.sha256_audit_path[:], self.tree_size)
def test_verify_leaf_inclusion_incorrect_length_proof(self):
verifier = merkle.MerkleVerifier(HexTreeHasher())
sth = self.STH(self.zeros, 4)
# Too long a proof
self.assertRaises(error.ProofError, verifier.verify_leaf_inclusion,
self.ones, 0, [self.zeros, self.zeros, self.zeros],
sth)
# Too short a proof
self.assertRaises(error.ProofError, verifier.verify_leaf_inclusion,
self.ones, 0, [self.zeros], sth)
def test_verify_tree_consistency_proof_too_short(self):
verifier = merkle.MerkleVerifier(HexTreeHasher())
self.assertRaises(
error.ProofError, verifier.verify_tree_consistency, 6, 8,
"76e67dadbcdf1e10e1b74ddc608abd2f98dfb16fbce75277b5232a127f2087ef",
"5dc9da79a70659a9ad559cb701ded9a2ab9d823aad2f4960cfe370eff4604328",
[
"0ebc5d3437fbe2db158b9f126a1d118e308181031d0a949f8dededebc558ef6a",
"ca854ea128ed050b41b35ffc1b87b8eb2bde461e9e3b5596ece6b9d5975a0ae0"
])
def test_verify_tree_consistency_newer_tree_is_smaller(self):
verifier = merkle.MerkleVerifier(HexTreeHasher())
self.assertRaises(
ValueError, verifier.verify_tree_consistency, 5, 2,
"4e3bbb1f7b478dcfe71fb631631519a3bca12c9aefca1612bfce4c13a86264d4",
"fac54203e7cc696cf0dfcb42c92a1d9dbaf70ad9e621f4bd8d98662f00e3c125",
[
"5f083f0a1a33ca076a95279832580db3e0ef4584bdff1f54c8a360f50de3031e",
"bc1a0643b12e4d2d7c77918f44e0f4f79a838b6cf9ec5b5c283e1f4d88599e6b"
])
def test_verify_tree_consistency_always_accepts_empty_tree(self):
verifier = merkle.MerkleVerifier(HexTreeHasher())
# Give some bogus proof too; it should be ignored.
self.assertTrue(
verifier.verify_tree_consistency(
0, 1,
"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
"6e340b9cffb37a989ca544e6bb780a2c78901d3fb33738768511a30617afa01d",
[
"6e340b9cffb37a989ca544e6bb780a2c78901d3fb33738768511a30617afa01d"
]))
def test_verify_tree_consistency_bad_first_hash(self):
verifier = merkle.MerkleVerifier(HexTreeHasher())
# A bit has been flipped in the first hash.
self.assertRaises(
error.ConsistencyError, verifier.verify_tree_consistency, 6, 8,
"76e67dadbcdf1e10e1b74ddc608abd2f98dfb16fbce75277b5232a127f2087ee",
"5dc9da79a70659a9ad559cb701ded9a2ab9d823aad2f4960cfe370eff4604328",
[
"0ebc5d3437fbe2db158b9f126a1d118e308181031d0a949f8dededebc558ef6a",
"ca854ea128ed050b41b35ffc1b87b8eb2bde461e9e3b5596ece6b9d5975a0ae0",
"d37ee418976dd95753c1c73862b9398fa2a2cf9b4ff0fdfe8b30cd95209614b7"
])
def test_verify_leaf_inclusion_rightmost_node_in_unbalanced_odd_tree(self):
# Show that verify_leaf_inclusion works when required to check a proof
# for the right-most, even-indexed node: In a tree of 5 nodes, ask for
# inclusion proof check for leaf 4 (the 5th).
verifier = merkle.MerkleVerifier(HexTreeHasher())
hh = HexTreeHasher()
h_s1 = hh.hash_leaf(self.ones)
h_root = hh.hash_children(self.zeros, h_s1)
sth = self.STH(h_root, 5)
self.assertTrue(
verifier.verify_leaf_inclusion(self.ones, 4, [
self.zeros,
], sth))
def test_verify_leaf_inclusion_rightmost_node_in_tree(self):
# Show that verify_leaf_inclusion works when required to check a proof
# for the right-most node: In a tree of 8 nodes, ask for inclusion
# proof check for leaf 7.
verifier = merkle.MerkleVerifier(HexTreeHasher())
hh = HexTreeHasher()
h_s1 = hh.hash_leaf(self.ones)
h_c3 = hh.hash_children(self.zeros, h_s1)
h_c2 = hh.hash_children(self.zeros, h_c3)
h_root = hh.hash_children(self.zeros, h_c2)
sth = self.STH(h_root, 8)
self.assertTrue(
verifier.verify_leaf_inclusion(
self.ones, 7, [self.zeros, self.zeros, self.zeros], sth))
def test_verify_tree_consistency_for_equal_tree_sizes(self):
verifier = merkle.MerkleVerifier(HexTreeHasher())
# Equal tree sizes and hashes, and a bogus proof that should be ignored.
self.assertTrue(
verifier.verify_tree_consistency(
3, 3,
"6e340b9cffb37a989ca544e6bb780a2c78901d3fb33738768511a30617afa01d",
"6e340b9cffb37a989ca544e6bb780a2c78901d3fb33738768511a30617afa01d",
[
"6e340b9cffb37a989ca544e6bb780a2c78901d3fb33738768511a30617afa01d"
]))
# Equal tree sizes but different hashes.
self.assertRaises(
error.ConsistencyError, verifier.verify_tree_consistency, 3, 3,
"6e340b9cffb37a989ca544e6bb780a2c78901d3fb33738768511a30617afa01e",
"6e340b9cffb37a989ca544e6bb780a2c78901d3fb33738768511a30617afa01d",
[])
def test_tree_consistency_proof_generated(self):
"""Test consistency proof generation.
Consistency proof generation correctness test for generated proofs.
"""
leaves = []
for i in range(128):
leaves.append(chr(i) * 32)
tree = leveldb_merkle_tree.LeveldbMerkleTree(leaves=leaves, db=self.db)
verifier = merkle.MerkleVerifier()
for i in range(1, tree.tree_size):
for j in range(i):
consistency_proof = tree.get_consistency_proof(j, i)
self.assertTrue(verifier.verify_tree_consistency(
j, i, tree.get_root_hash(j), tree.get_root_hash(i),
consistency_proof))
tree.close()
def test_tree_inclusion_proof_generated(self):
"""Test inclusion proof generation.
Test inclusion proof generation correctness for generated proofs.
"""
leaves = []
leaf_hashes = []
hasher = merkle.TreeHasher()
for i in range(128):
leaves.append(chr(i) * 32)
leaf_hashes.append(hasher.hash_leaf(leaves[-1]))
tree = leveldb_merkle_tree.LeveldbMerkleTree(leaves=leaves, db=self.db)
verifier = merkle.MerkleVerifier()
for i in range(1, tree.tree_size):
for j in range(i):
audit_path = tree.get_inclusion_proof(j, i)
dummy_sth = DummySTH(i, tree.get_root_hash(i))
verifier.verify_leaf_hash_inclusion(
leaf_hashes[j], j, audit_path, dummy_sth)
tree.close()
def test_tree_inclusion_proof_precomputed(self):
"""Test inclusion proof generation.
Test inclusion proof generation correctness test for known-good
proofs.
"""
tree = leveldb_merkle_tree.LeveldbMerkleTree(leaves=TEST_VECTOR_DATA, db=self.db)
verifier = merkle.MerkleVerifier()
for v in PRECOMPUTED_PATH_TEST_VECTORS:
audit_path = tree.get_inclusion_proof(v.leaf, v.tree_size_snapshot)
self.assertEqual(len(audit_path), v.path_length)
self.assertEqual(audit_path, v.path)
leaf_data = TEST_VECTOR_DATA[v.leaf]
leaf_hash = merkle.TreeHasher().hash_leaf(leaf_data)
dummy_sth = DummySTH(v.tree_size_snapshot,
tree.get_root_hash(v.tree_size_snapshot))
if v.tree_size_snapshot > 0:
verifier.verify_leaf_hash_inclusion(
leaf_hash, v.leaf, audit_path, dummy_sth)
tree.close()
def test_verify_leaf_inclusion_all_nodes_all_tree_sizes_up_to_4(self):
leaves = ["aa", "bb", "cc", "dd"]
hh = HexTreeHasher()
leaf_hashes = [hh.hash_leaf(l) for l in leaves]
hc = hh.hash_children
proofs_per_tree_size = {
1: [[]],
2: [[leaf_hashes[1]], [leaf_hashes[0]]],
3: [
[leaf_hashes[1], leaf_hashes[2]], # leaf 0
[leaf_hashes[0], leaf_hashes[2]], # leaf 1
[hc(leaf_hashes[0], leaf_hashes[1])]
], # leaf 2
4: [
[leaf_hashes[1],
hc(leaf_hashes[2], leaf_hashes[3])], # leaf 0
[leaf_hashes[0],
hc(leaf_hashes[2], leaf_hashes[3])], # leaf 1
[leaf_hashes[3],
hc(leaf_hashes[0], leaf_hashes[1])], # leaf 2
[leaf_hashes[2],
hc(leaf_hashes[0], leaf_hashes[1])], # leaf 3
]
}
tree = merkle.CompactMerkleTree(hasher=HexTreeHasher())
verifier = merkle.MerkleVerifier(HexTreeHasher())
# Increase the tree by one leaf each time
for i in range(4):
tree.append(leaves[i])
tree_size = i + 1
# ... and check inclusion proof validates for each node
# of the tree
for j in range(tree_size):
proof = proofs_per_tree_size[tree_size][j]
sth = self.STH(tree.root_hash(), tree_size)
self.assertTrue(
verifier.verify_leaf_inclusion(leaves[j], j, proof, sth))
def test_verify_leaf_inclusion_good_proof(self):
verifier = merkle.MerkleVerifier(HexTreeHasher())
sth = self.STH(self.expected_root_hash, self.tree_size)
self.assertTrue(
verifier.verify_leaf_inclusion(self.raw_hex_leaf, self.leaf_index,
self.sha256_audit_path, sth))
def test_calculate_root_hash_good_proof(self):
verifier = merkle.MerkleVerifier(HexTreeHasher())
self.assertEqual(
verifier._calculate_root_hash_from_audit_path(
self.leaf_hash, self.leaf_index, self.sha256_audit_path[:],
self.tree_size), self.expected_root_hash)
def test_verify_tree_consistency(self):
verifier = merkle.MerkleVerifier(HexTreeHasher())
for test_vector in MerkleVerifierTest.sha256_proofs:
self.assertTrue(verifier.verify_tree_consistency(*test_vector))
IMT = in_memory_merkle_tree.InMemoryMerkleTree(leaves=LEAVES)
print "Root hash in InMemoryMerkleTree: " + IMT.get_root_hash().encode('hex')
shutil.rmtree("./merkle_db", ignore_errors=True)
LMT = leveldb_merkle_tree.LeveldbMerkleTree(leaves=LEAVES)
# LMT.extend(LEAVES)
print "Root hash in LeveldbMerkleTree: " + LMT.get_root_hash().encode('hex')
# check that root hashes are identical
print "Are the two root hashes identical? %s: " % (IMT.get_root_hash()
== LMT.get_root_hash())
# check that consistency proof is working and identical
MV = merkle.MerkleVerifier()
const_proof = LMT.get_consistency_proof(TEST_LEAF)
print "Consistency proof for subtree at leaf %s:\n%s" % (
TEST_LEAF, encode_byte_list(const_proof))
print "Is consistency proof correct?: %s" % MV.verify_tree_consistency(
TEST_LEAF, NUM_LEAVES, IMT.get_root_hash(TEST_LEAF), LMT.get_root_hash(),
const_proof)
# check that inclusion proof is working and identical
leaf_hash = LMT.get_leaf(TEST_LEAF)
incl_proof = LMT.get_inclusion_proof(TEST_LEAF)
print "Inclusion proof for leaf %s:\n%s" % (TEST_LEAF,
encode_byte_list(incl_proof))
print "Are inclusion proofs from InMemoryMerkleTree and LeveldbMerkleTree identical?: %s" % (
IMT.get_inclusion_proof(TEST_LEAF, NUM_LEAVES) == incl_proof)
print "Is inclusion proof correct?: %s" % MV.verify_leaf_hash_inclusion(
def setUp(self):
self.verifier = merkle.MerkleVerifier(HexTreeHasher())
self.STH = namedtuple("STH", ["sha256_root_hash", "tree_size"])
self.ones = "11" * 32
self.zeros = "00" * 32
