Jae Kwon
9 years ago
9 changed files with 371 additions and 78 deletions
Split View
Diff Options
-
+13 -8binary/int.go
-
+1 -1binary/int_test.go
-
+4 -0common/random.go
-
+28 -0common/test/mutate.go
-
+107 -55merkle/iavl_node.go
-
+137 -0merkle/iavl_proof.go
-
+71 -5merkle/iavl_test.go
-
+6 -5merkle/iavl_tree.go
-
+4 -4merkle/types.go
+ 13
- 8
binary/int.go
View File
+ 1
- 1
binary/int_test.go
View File
+ 4
- 0
common/random.go
View File
+ 28
- 0
common/test/mutate.go
View File
| @ -0,0 +1,28 @@ | |||
| package test | |||
| import ( | |||
| . "github.com/tendermint/tendermint/common" | |||
| ) | |||
| // Contract: !bytes.Equal(input, output) && len(input) >= len(output) | |||
| func MutateByteSlice(bytez []byte) []byte { | |||
| // If bytez is empty, panic | |||
| if len(bytez) == 0 { | |||
| panic("Cannot mutate an empty bytez") | |||
| } | |||
| // Copy bytez | |||
| mBytez := make([]byte, len(bytez)) | |||
| copy(mBytez, bytez) | |||
| bytez = mBytez | |||
| // Try a random mutation | |||
| switch RandInt() % 2 { | |||
| case 0: // Mutate a single byte | |||
| bytez[RandInt()%len(bytez)] += byte(RandInt()%255 + 1) | |||
| case 1: // Remove an arbitrary byte | |||
| pos := RandInt() % len(bytez) | |||
| bytez = append(bytez[:pos], bytez[pos+1:]...) | |||
| } | |||
| return bytez | |||
| } | |||
+ 107
- 55
merkle/iavl_node.go
View File
+ 137
- 0
merkle/iavl_proof.go
View File
| @ -0,0 +1,137 @@ | |||
| package merkle | |||
| import ( | |||
| "bytes" | |||
| "crypto/sha256" | |||
| "github.com/tendermint/tendermint/binary" | |||
| . "github.com/tendermint/tendermint/common" | |||
| ) | |||
| type IAVLProof struct { | |||
| Root []byte | |||
| Branches []IAVLProofBranch | |||
| Leaf IAVLProofLeaf | |||
| } | |||
| func (proof *IAVLProof) Verify() bool { | |||
| hash := proof.Leaf.Hash() | |||
| // fmt.Printf("leaf hash: %X\n", hash) | |||
| for i := len(proof.Branches) - 1; 0 <= i; i-- { | |||
| hash = proof.Branches[i].Hash(hash) | |||
| // fmt.Printf("branch hash: %X\n", hash) | |||
| } | |||
| // fmt.Printf("root: %X, computed: %X\n", proof.Root, hash) | |||
| return bytes.Equal(proof.Root, hash) | |||
| } | |||
| type IAVLProofBranch struct { | |||
| Height uint8 | |||
| Size uint | |||
| Left []byte | |||
| Right []byte | |||
| } | |||
| func (branch IAVLProofBranch) Hash(childHash []byte) []byte { | |||
| hasher := sha256.New() | |||
| buf := new(bytes.Buffer) | |||
| n, err := int64(0), error(nil) | |||
| binary.WriteUint8(branch.Height, buf, &n, &err) | |||
| binary.WriteUvarint(branch.Size, buf, &n, &err) | |||
| if branch.Left == nil { | |||
| binary.WriteByteSlice(childHash, buf, &n, &err) | |||
| binary.WriteByteSlice(branch.Right, buf, &n, &err) | |||
| } else { | |||
| binary.WriteByteSlice(branch.Left, buf, &n, &err) | |||
| binary.WriteByteSlice(childHash, buf, &n, &err) | |||
| } | |||
| if err != nil { | |||
| panic(Fmt("Failed to hash IAVLProofBranch: %v", err)) | |||
| } | |||
| // fmt.Printf("Branch hash bytes: %X\n", buf.Bytes()) | |||
| hasher.Write(buf.Bytes()) | |||
| return hasher.Sum(nil) | |||
| } | |||
| type IAVLProofLeaf struct { | |||
| KeyBytes []byte | |||
| ValueBytes []byte | |||
| } | |||
| func (leaf IAVLProofLeaf) Hash() []byte { | |||
| hasher := sha256.New() | |||
| buf := new(bytes.Buffer) | |||
| n, err := int64(0), error(nil) | |||
| binary.WriteUint8(0, buf, &n, &err) | |||
| binary.WriteUvarint(1, buf, &n, &err) | |||
| binary.WriteByteSlice(leaf.KeyBytes, buf, &n, &err) | |||
| binary.WriteByteSlice(leaf.ValueBytes, buf, &n, &err) | |||
| if err != nil { | |||
| panic(Fmt("Failed to hash IAVLProofLeaf: %v", err)) | |||
| } | |||
| // fmt.Printf("Leaf hash bytes: %X\n", buf.Bytes()) | |||
| hasher.Write(buf.Bytes()) | |||
| return hasher.Sum(nil) | |||
| } | |||
| func (node *IAVLNode) constructProof(t *IAVLTree, key interface{}, proof *IAVLProof) (exists bool) { | |||
| if node.height == 0 { | |||
| if t.keyCodec.Compare(node.key, key) == 0 { | |||
| keyBuf, valueBuf := new(bytes.Buffer), new(bytes.Buffer) | |||
| n, err := int64(0), error(nil) | |||
| t.keyCodec.Encode(node.key, keyBuf, &n, &err) | |||
| if err != nil { | |||
| panic(Fmt("Failed to encode node.key: %v", err)) | |||
| } | |||
| t.valueCodec.Encode(node.value, valueBuf, &n, &err) | |||
| if err != nil { | |||
| panic(Fmt("Failed to encode node.value: %v", err)) | |||
| } | |||
| leaf := IAVLProofLeaf{ | |||
| KeyBytes: keyBuf.Bytes(), | |||
| ValueBytes: valueBuf.Bytes(), | |||
| } | |||
| proof.Leaf = leaf | |||
| return true | |||
| } else { | |||
| return false | |||
| } | |||
| } else { | |||
| if t.keyCodec.Compare(key, node.key) < 0 { | |||
| branch := IAVLProofBranch{ | |||
| Height: node.height, | |||
| Size: node.size, | |||
| Left: nil, | |||
| Right: node.getRightNode(t).hash, | |||
| } | |||
| if node.getRightNode(t).hash == nil { | |||
| // fmt.Println(node.getRightNode(t)) | |||
| panic("WTF") | |||
| } | |||
| proof.Branches = append(proof.Branches, branch) | |||
| return node.getLeftNode(t).constructProof(t, key, proof) | |||
| } else { | |||
| branch := IAVLProofBranch{ | |||
| Height: node.height, | |||
| Size: node.size, | |||
| Left: node.getLeftNode(t).hash, | |||
| Right: nil, | |||
| } | |||
| proof.Branches = append(proof.Branches, branch) | |||
| return node.getRightNode(t).constructProof(t, key, proof) | |||
| } | |||
| } | |||
| } | |||
| // Returns nil if key is not in tree. | |||
| func (t *IAVLTree) ConstructProof(key interface{}) *IAVLProof { | |||
| if t.root == nil { | |||
| return nil | |||
| } | |||
| t.root.hashWithCount(t) // Ensure that all hashes are calculated. | |||
| proof := &IAVLProof{ | |||
| Root: t.root.hash, | |||
| } | |||
| t.root.constructProof(t, key, proof) | |||
| return proof | |||
| } | |||