1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
package trillian
import (
"context"
"fmt"
"github.com/golang/glog"
"github.com/google/trillian"
ttypes "github.com/google/trillian/types"
"github.com/system-transparency/stfe/types"
"google.golang.org/grpc/codes"
)
// Client is a wrapper around the Trillian gRPC client
type Client struct {
// TreeID is a Merkle tree identifier that Trillian uses
TreeID int64
// GRPC is a Trillian gRPC client
GRPC trillian.TrillianLogClient
}
func (c *Client) AddLeaf(ctx context.Context, req *types.LeafRequest) error {
leaf := types.Leaf{
Message: req.Message,
SigIdent: types.SigIdent{
Signature: req.Signature,
KeyHash: types.Hash(req.VerificationKey[:]),
},
}
serialized := leaf.Marshal()
glog.V(3).Infof("queueing leaf request: %x", types.HashLeaf(serialized))
rsp, err := c.GRPC.QueueLeaf(ctx, &trillian.QueueLeafRequest{
LogId: c.TreeID,
Leaf: &trillian.LogLeaf{
LeafValue: serialized,
},
})
if err != nil {
return fmt.Errorf("backend failure: %v", err)
}
if rsp == nil {
return fmt.Errorf("no response")
}
if rsp.QueuedLeaf == nil {
return fmt.Errorf("no queued leaf")
}
if codes.Code(rsp.QueuedLeaf.GetStatus().GetCode()) == codes.AlreadyExists {
return fmt.Errorf("leaf is already queued or included")
}
return nil
}
func (c *Client) GetTreeHead(ctx context.Context) (*types.TreeHead, error) {
rsp, err := c.GRPC.GetLatestSignedLogRoot(ctx, &trillian.GetLatestSignedLogRootRequest{
LogId: c.TreeID,
})
if err != nil {
return nil, fmt.Errorf("backend failure: %v", err)
}
if rsp == nil {
return nil, fmt.Errorf("no response")
}
if rsp.SignedLogRoot == nil {
return nil, fmt.Errorf("no signed log root")
}
if rsp.SignedLogRoot.LogRoot == nil {
return nil, fmt.Errorf("no log root")
}
var r ttypes.LogRootV1
if err := r.UnmarshalBinary(rsp.SignedLogRoot.LogRoot); err != nil {
return nil, fmt.Errorf("no log root: unmarshal failed: %v", err)
}
if len(r.RootHash) != types.HashSize {
return nil, fmt.Errorf("unexpected hash length: %d", len(r.RootHash))
}
return treeHeadFromLogRoot(&r), nil
}
func (c *Client) GetConsistencyProof(ctx context.Context, req *types.ConsistencyProofRequest) (*types.ConsistencyProof, error) {
rsp, err := c.GRPC.GetConsistencyProof(ctx, &trillian.GetConsistencyProofRequest{
LogId: c.TreeID,
FirstTreeSize: int64(req.OldSize),
SecondTreeSize: int64(req.NewSize),
})
if err != nil {
return nil, fmt.Errorf("backend failure: %v", err)
}
if rsp == nil {
return nil, fmt.Errorf("no response")
}
if rsp.Proof == nil {
return nil, fmt.Errorf("no consistency proof")
}
if len(rsp.Proof.Hashes) == 0 {
return nil, fmt.Errorf("not a consistency proof: empty")
}
path, err := nodePathFromHashes(rsp.Proof.Hashes)
if err != nil {
return nil, fmt.Errorf("not a consistency proof: %v", err)
}
return &types.ConsistencyProof{
OldSize: req.OldSize,
NewSize: req.NewSize,
Path: path,
}, nil
}
func (c *Client) GetInclusionProof(ctx context.Context, req *types.InclusionProofRequest) (*types.InclusionProof, error) {
rsp, err := c.GRPC.GetInclusionProofByHash(ctx, &trillian.GetInclusionProofByHashRequest{
LogId: c.TreeID,
LeafHash: req.LeafHash[:],
TreeSize: int64(req.TreeSize),
OrderBySequence: true,
})
if err != nil {
return nil, fmt.Errorf("backend failure: %v", err)
}
if rsp == nil {
return nil, fmt.Errorf("no response")
}
if len(rsp.Proof) != 1 {
return nil, fmt.Errorf("bad proof count: %d", len(rsp.Proof))
}
proof := rsp.Proof[0]
if len(proof.Hashes) == 0 {
return nil, fmt.Errorf("not an inclusion proof: empty")
}
path, err := nodePathFromHashes(proof.Hashes)
if err != nil {
return nil, fmt.Errorf("not an inclusion proof: %v", err)
}
return &types.InclusionProof{
TreeSize: req.TreeSize,
LeafIndex: uint64(proof.LeafIndex),
Path: path,
}, nil
}
func (c *Client) GetLeaves(ctx context.Context, req *types.LeavesRequest) (*types.LeafList, error) {
return nil, fmt.Errorf("TODO")
}
|
