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