plugeth/trie/proof.go

153 lines
4.6 KiB
Go
Raw Normal View History

2016-04-14 16:18:24 +00:00
// Copyright 2015 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// The go-ethereum library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
2015-09-09 01:35:41 +00:00
package trie
import (
"bytes"
"fmt"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/ethdb"
"github.com/ethereum/go-ethereum/log"
2015-09-09 01:35:41 +00:00
"github.com/ethereum/go-ethereum/rlp"
)
// Prove constructs a merkle proof for key. The result contains all encoded nodes
// on the path to the value at key. The value itself is also included in the last
// node and can be retrieved by verifying the proof.
2015-09-09 01:35:41 +00:00
//
// If the trie does not contain a value for key, the returned proof contains all
// nodes of the longest existing prefix of the key (at least the root node), ending
// with the node that proves the absence of the key.
func (t *Trie) Prove(key []byte, fromLevel uint, proofDb ethdb.KeyValueWriter) error {
2015-09-09 01:35:41 +00:00
// Collect all nodes on the path to key.
key = keybytesToHex(key)
var nodes []node
2015-09-09 01:35:41 +00:00
tn := t.root
for len(key) > 0 && tn != nil {
2015-09-09 01:35:41 +00:00
switch n := tn.(type) {
case *shortNode:
2015-09-09 01:35:41 +00:00
if len(key) < len(n.Key) || !bytes.Equal(n.Key, key[:len(n.Key)]) {
// The trie doesn't contain the key.
tn = nil
} else {
tn = n.Val
key = key[len(n.Key):]
2015-09-09 01:35:41 +00:00
}
nodes = append(nodes, n)
case *fullNode:
tn = n.Children[key[0]]
2015-09-09 01:35:41 +00:00
key = key[1:]
nodes = append(nodes, n)
case hashNode:
var err error
tn, err = t.resolveHash(n, nil)
if err != nil {
log.Error(fmt.Sprintf("Unhandled trie error: %v", err))
return err
}
2015-09-09 01:35:41 +00:00
default:
panic(fmt.Sprintf("%T: invalid node: %v", tn, tn))
}
}
hasher := newHasher(false)
defer returnHasherToPool(hasher)
2018-11-16 14:35:39 +00:00
2015-09-09 01:35:41 +00:00
for i, n := range nodes {
if fromLevel > 0 {
fromLevel--
continue
}
var hn node
n, hn = hasher.proofHash(n)
if hash, ok := hn.(hashNode); ok || i == 0 {
2015-09-09 01:35:41 +00:00
// If the node's database encoding is a hash (or is the
// root node), it becomes a proof element.
enc, _ := rlp.EncodeToBytes(n)
if !ok {
hash = hasher.hashData(enc)
}
proofDb.Put(hash, enc)
2015-09-09 01:35:41 +00:00
}
}
return nil
2015-09-09 01:35:41 +00:00
}
// Prove constructs a merkle proof for key. The result contains all encoded nodes
// on the path to the value at key. The value itself is also included in the last
// node and can be retrieved by verifying the proof.
//
// If the trie does not contain a value for key, the returned proof contains all
// nodes of the longest existing prefix of the key (at least the root node), ending
// with the node that proves the absence of the key.
func (t *SecureTrie) Prove(key []byte, fromLevel uint, proofDb ethdb.KeyValueWriter) error {
return t.trie.Prove(key, fromLevel, proofDb)
}
// VerifyProof checks merkle proofs. The given proof must contain the value for
// key in a trie with the given root hash. VerifyProof returns an error if the
// proof contains invalid trie nodes or the wrong value.
func VerifyProof(rootHash common.Hash, key []byte, proofDb ethdb.KeyValueReader) (value []byte, nodes int, err error) {
key = keybytesToHex(key)
wantHash := rootHash
for i := 0; ; i++ {
buf, _ := proofDb.Get(wantHash[:])
if buf == nil {
return nil, i, fmt.Errorf("proof node %d (hash %064x) missing", i, wantHash)
2015-09-09 01:35:41 +00:00
}
n, err := decodeNode(wantHash[:], buf)
2015-09-09 01:35:41 +00:00
if err != nil {
return nil, i, fmt.Errorf("bad proof node %d: %v", i, err)
2015-09-09 01:35:41 +00:00
}
keyrest, cld := get(n, key)
switch cld := cld.(type) {
case nil:
// The trie doesn't contain the key.
return nil, i, nil
2015-09-09 01:35:41 +00:00
case hashNode:
key = keyrest
copy(wantHash[:], cld)
2015-09-09 01:35:41 +00:00
case valueNode:
return cld, i + 1, nil
2015-09-09 01:35:41 +00:00
}
}
}
func get(tn node, key []byte) ([]byte, node) {
for {
2015-09-09 01:35:41 +00:00
switch n := tn.(type) {
case *shortNode:
2015-09-09 01:35:41 +00:00
if len(key) < len(n.Key) || !bytes.Equal(n.Key, key[:len(n.Key)]) {
return nil, nil
}
tn = n.Val
key = key[len(n.Key):]
case *fullNode:
tn = n.Children[key[0]]
2015-09-09 01:35:41 +00:00
key = key[1:]
case hashNode:
return key, n
case nil:
return key, nil
case valueNode:
return nil, n
2015-09-09 01:35:41 +00:00
default:
panic(fmt.Sprintf("%T: invalid node: %v", tn, tn))
}
}
}