Browse Source
Merge remote-tracking branch 'census/master'
Signed-off-by: p4u <p4u@dabax.net>feature_chain_module
p4u
5 years ago
7 changed files with 772 additions and 1 deletions
Unified View
Diff Options
-
+131 -0LICENSE
-
+7 -1README.md
-
+128 -0cmd/censushttp/README.md
-
+37 -0cmd/censushttp/censushttp.go
-
+309 -0service/censusmanager.go
-
+22 -0tree/README.md
-
+138 -0tree/tree.go
@ -0,0 +1,128 @@ |
|||||
|
## Census HTTP service |
||||
|
|
||||
|
Reference implementation of a voting census service running on the Vocdoni platform |
||||
|
|
||||
|
## Compile |
||||
|
|
||||
|
In a GO ready environment: |
||||
|
|
||||
|
``` |
||||
|
go get -u github.com/vocdoni/dvote-census/... |
||||
|
go build -o censusHttpService github.com/vocdoni/dvote-census/cmd/censushttp |
||||
|
``` |
||||
|
|
||||
|
## Usage |
||||
|
|
||||
|
`./censusHttpService <port> <censusId>[:pubKey] [<censusId>[:pubKey] ...]` |
||||
|
|
||||
|
Example |
||||
|
|
||||
|
``` |
||||
|
./censusHttpService 1500 Got_Favorite |
||||
|
2019/02/12 10:20:16 Starting process HTTP service on port 1500 for namespace GoT_Favorite |
||||
|
2019/02/12 10:20:16 Starting server in http mode |
||||
|
``` |
||||
|
|
||||
|
## API |
||||
|
|
||||
|
A HTTP jSON endpoint is available with the following possible fields: `censusId`, `claimData`, `rootHash` and `proofData`. |
||||
|
|
||||
|
If `pubKey` has been configured for a specific `censusId`, then two more methods are available (`timeStamp` and `signature`) to provide authentication. |
||||
|
|
||||
|
The next table shows the available methods and its relation with the fields. |
||||
|
|
||||
|
| method | censusId | claimData | rootHash | proofData | protected? | description | |
||||
|
|------------|-----------|-----------|----------|-----------|------------|------------| |
||||
|
| `addCLaim` | mandatory | mandatory | none | none | yes | adds a new claim to the merkle tree | |
||||
|
| `getRoot` | mandatory | none | none | none | no | get the current merkletree root hash |
||||
|
| `genProof` | mandatory | mandatory | optional | none | no | generate the merkle proof for a given claim |
||||
|
| `checkProof` | mandatory | mandatory | optional | mandatory | no | check a claim and its merkle proof |
||||
|
| `getIdx` | mandatory | mandatory | optional | none | no | get the merkletree data index of a given claim |
||||
|
| `dump` | mandatory | none | optional | none | yes | list the contents of the census for a given hash |
||||
|
|
||||
|
|
||||
|
## Signature |
||||
|
|
||||
|
The signature provides authentication by signing a concatenation of the following strings (even if empty) without spaces: `censusId rootHash claimData timeStamp`. |
||||
|
|
||||
|
The `timeStamp` when received on the server side must not differ more than 10 seconds from the current UNIX time. |
||||
|
|
||||
|
## Examples |
||||
|
|
||||
|
#### add claims |
||||
|
|
||||
|
Add two new claims, one for `Jon Snow` and another for `Tyrion`. |
||||
|
``` |
||||
|
curl -d '{"censusID":"GoT_Favorite","claimData":"Jon Snow"}' http://localhost:1500/addClaim |
||||
|
|
||||
|
{"error":false,"response":""} |
||||
|
``` |
||||
|
|
||||
|
``` |
||||
|
curl -d '{"censusID":"GoT_Favorite","claimData":"Tyrion"}' http://localhost:1500/addClaim |
||||
|
|
||||
|
{"error":false,"response":""} |
||||
|
``` |
||||
|
|
||||
|
In case signature is enabled: |
||||
|
|
||||
|
``` |
||||
|
curl -d '{ |
||||
|
"censusID":"GoT_Favorite", |
||||
|
"claimData":"Jon Snow", |
||||
|
"timeStamp":"1547814675", |
||||
|
"signature":"a117c4ce12b29090884112ffe57e664f007e7ef142a1679996e2d34fd2b852fe76966e47932f1e9d3a54610d0f361383afe2d9aab096e15d136c236abb0a0d0e" }' http://localhost:1500/addClaim |
||||
|
|
||||
|
{"error":false,"response":""} |
||||
|
``` |
||||
|
|
||||
|
|
||||
|
#### generate proof |
||||
|
|
||||
|
Generate a merkle proof for the claim `Jon Snow` |
||||
|
|
||||
|
``` |
||||
|
curl -d '{"censusID":"GoT_Favorite","claimData":"Jon Snow"}' http://localhost:1500/genProof |
||||
|
|
||||
|
{"error":false,"response":"0x000200000000000000000000000000000000000000000000000000000000000212f8134039730791388a9bd0460f9fbd0757327212a64b3a2b0f0841ce561ee3"} |
||||
|
``` |
||||
|
|
||||
|
If `rootHash` is specified, the proof will be calculated for the given root hash. |
||||
|
|
||||
|
#### get root |
||||
|
|
||||
|
The previous merkle proof is valid only for the current root hash. Let's get it |
||||
|
|
||||
|
``` |
||||
|
curl -d '{"censusID":"GoT_Favorite"}' http://localhost:1500/getRoot |
||||
|
|
||||
|
{"error":false,"response":"0x2f0ddde5cb995eae23dc3b75a5c0333f1cc89b73f3a00b0fe71996fb90fef04b"} |
||||
|
``` |
||||
|
|
||||
|
|
||||
|
#### check proof |
||||
|
|
||||
|
Now let's check if the proof is valid |
||||
|
|
||||
|
``` |
||||
|
curl -d '{ |
||||
|
"censusID":"GoT_Favorite","claimData":"Jon Snow", |
||||
|
"rootHash":"0x2f0ddde5cb995eae23dc3b75a5c0333f1cc89b73f3a00b0fe71996fb90fef04b", |
||||
|
"proofData":"0x000200000000000000000000000000000000000000000000000000000000000212f8134039730791388a9bd0460f9fbd0757327212a64b3a2b0f0841ce561ee3"}' http://localhost:1500/checkProof |
||||
|
|
||||
|
{"error":false,"response":"valid"} |
||||
|
``` |
||||
|
|
||||
|
If `rootHash` is not specified, the current root hash is used. |
||||
|
|
||||
|
#### dump |
||||
|
|
||||
|
Dump contents of a specific censusId (values) |
||||
|
|
||||
|
``` |
||||
|
curl -d '{"censusID":"GoT_Favorite"}' http://localhost:1500/dump |
||||
|
|
||||
|
{"error":false,"response":"[\"Tyrion\",\"Jon Snow\"]"} |
||||
|
``` |
||||
|
|
||||
|
If `rootHash` is specified, dump will return the values for the merkle tree with the given root hash. |
||||
@ -0,0 +1,37 @@ |
|||||
|
package main |
||||
|
|
||||
|
import ( |
||||
|
"log" |
||||
|
"os" |
||||
|
"strconv" |
||||
|
"strings" |
||||
|
|
||||
|
censusmanager "github.com/vocdoni/dvote-census/service" |
||||
|
) |
||||
|
|
||||
|
func main() { |
||||
|
if len(os.Args) < 2 { |
||||
|
log.Fatal("Usage: " + os.Args[0] + |
||||
|
" <port> <namespace>[:pubKey] [<namespace>[:pubKey]]...") |
||||
|
os.Exit(2) |
||||
|
} |
||||
|
port, err := strconv.Atoi(os.Args[1]) |
||||
|
if err != nil { |
||||
|
log.Fatal(err) |
||||
|
os.Exit(2) |
||||
|
} |
||||
|
for i := 2; i < len(os.Args); i++ { |
||||
|
s := strings.Split(os.Args[i], ":") |
||||
|
ns := s[0] |
||||
|
pubK := "" |
||||
|
if len(s) > 1 { |
||||
|
pubK = s[1] |
||||
|
log.Printf("Public Key authentication enabled on namespace %s\n", ns) |
||||
|
} |
||||
|
censusmanager.AddNamespace(ns, pubK) |
||||
|
log.Printf("Starting process HTTP service on port %d for namespace %s\n", |
||||
|
port, ns) |
||||
|
} |
||||
|
censusmanager.Listen(port, "http") |
||||
|
|
||||
|
} |
||||
@ -0,0 +1,309 @@ |
|||||
|
package censusmanager |
||||
|
|
||||
|
import ( |
||||
|
"encoding/json" |
||||
|
"fmt" |
||||
|
"log" |
||||
|
"net/http" |
||||
|
"strconv" |
||||
|
"time" |
||||
|
|
||||
|
tree "github.com/vocdoni/dvote-census/tree" |
||||
|
signature "github.com/vocdoni/dvote-relay/crypto/signature" |
||||
|
) |
||||
|
|
||||
|
const hashSize = 32 |
||||
|
const authTimeWindow = 10 // Time window (seconds) in which TimeStamp will be accepted if auth enabled
|
||||
|
var MkTrees map[string]*tree.Tree // MerkleTree dvote-census library
|
||||
|
var Signatures map[string]string |
||||
|
var Signature signature.SignKeys // Signature dvote-relay library
|
||||
|
|
||||
|
type Claim struct { |
||||
|
CensusID string `json:"censusId"` // References to MerkleTree namespace
|
||||
|
RootHash string `json:"rootHash"` // References to MerkleTree rootHash
|
||||
|
ClaimData string `json:"claimData"` // Data to add to the MerkleTree
|
||||
|
ProofData string `json:"proofData"` // MerkleProof to check
|
||||
|
TimeStamp string `json:"timeStamp"` // Unix TimeStamp in seconds
|
||||
|
Signature string `json:"signature"` // Signature as Hexadecimal String
|
||||
|
} |
||||
|
|
||||
|
type Result struct { |
||||
|
Error bool `json:"error"` |
||||
|
Response string `json:"response"` |
||||
|
} |
||||
|
|
||||
|
func AddNamespace(name, pubKey string) { |
||||
|
if len(MkTrees) == 0 { |
||||
|
MkTrees = make(map[string]*tree.Tree) |
||||
|
} |
||||
|
if len(Signatures) == 0 { |
||||
|
Signatures = make(map[string]string) |
||||
|
} |
||||
|
|
||||
|
mkTree := tree.Tree{} |
||||
|
mkTree.Init(name) |
||||
|
MkTrees[name] = &mkTree |
||||
|
Signatures[name] = pubKey |
||||
|
} |
||||
|
|
||||
|
func reply(resp *Result, w http.ResponseWriter) { |
||||
|
err := json.NewEncoder(w).Encode(resp) |
||||
|
if err != nil { |
||||
|
http.Error(w, err.Error(), 500) |
||||
|
} else { |
||||
|
w.Header().Set("content-type", "application/json") |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func checkRequest(w http.ResponseWriter, req *http.Request) bool { |
||||
|
if req.Body == nil { |
||||
|
http.Error(w, "Please send a request body", 400) |
||||
|
return false |
||||
|
} |
||||
|
return true |
||||
|
} |
||||
|
|
||||
|
func checkAuth(timestamp, signature, pubKey, message string) bool { |
||||
|
if len(pubKey) < 1 { |
||||
|
return true |
||||
|
} |
||||
|
currentTime := int64(time.Now().Unix()) |
||||
|
timeStampRemote, err := strconv.ParseInt(timestamp, 10, 32) |
||||
|
if err != nil { |
||||
|
log.Printf("Cannot parse timestamp data %s\n", err) |
||||
|
return false |
||||
|
} |
||||
|
if timeStampRemote < currentTime+authTimeWindow && |
||||
|
timeStampRemote > currentTime-authTimeWindow { |
||||
|
v, err := Signature.Verify(message, signature, pubKey) |
||||
|
if err != nil { |
||||
|
log.Printf("Verification error: %s\n", err) |
||||
|
} |
||||
|
return v |
||||
|
} |
||||
|
return false |
||||
|
} |
||||
|
|
||||
|
func claimHandler(w http.ResponseWriter, req *http.Request, op string) { |
||||
|
var c Claim |
||||
|
var resp Result |
||||
|
|
||||
|
if ok := checkRequest(w, req); !ok { |
||||
|
return |
||||
|
} |
||||
|
// Decode JSON
|
||||
|
err := json.NewDecoder(req.Body).Decode(&c) |
||||
|
if err != nil { |
||||
|
http.Error(w, err.Error(), 400) |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
// Process data
|
||||
|
log.Printf("censusId:{%s} rootHash:{%s} claimData:{%s} proofData:{%s} timeStamp:{%s} signature:{%s}\n", |
||||
|
c.CensusID, c.RootHash, c.ClaimData, c.ProofData, c.TimeStamp, c.Signature) |
||||
|
authString := fmt.Sprintf("%s%s%s%s", c.CensusID, c.RootHash, c.ClaimData, c.TimeStamp) |
||||
|
resp.Error = false |
||||
|
resp.Response = "" |
||||
|
censusFound := false |
||||
|
if len(c.CensusID) > 0 { |
||||
|
_, censusFound = MkTrees[c.CensusID] |
||||
|
} |
||||
|
if !censusFound { |
||||
|
resp.Error = true |
||||
|
resp.Response = "censusId not valid or not found" |
||||
|
reply(&resp, w) |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
if op == "add" { |
||||
|
if auth := checkAuth(c.TimeStamp, c.Signature, Signatures[c.CensusID], authString); auth { |
||||
|
err = MkTrees[c.CensusID].AddClaim([]byte(c.ClaimData)) |
||||
|
} else { |
||||
|
resp.Error = true |
||||
|
resp.Response = "invalid authentication" |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if op == "gen" { |
||||
|
var t *tree.Tree |
||||
|
var err error |
||||
|
if len(c.RootHash) > 1 { //if rootHash specified
|
||||
|
t, err = MkTrees[c.CensusID].Snapshot(c.RootHash) |
||||
|
if err != nil { |
||||
|
log.Printf("Snapshot error: %s", err.Error()) |
||||
|
resp.Error = true |
||||
|
resp.Response = "invalid root hash" |
||||
|
reply(&resp, w) |
||||
|
return |
||||
|
} |
||||
|
} else { //if rootHash not specified use current tree
|
||||
|
t = MkTrees[c.CensusID] |
||||
|
} |
||||
|
resp.Response, err = t.GenProof([]byte(c.ClaimData)) |
||||
|
if err != nil { |
||||
|
resp.Error = true |
||||
|
resp.Response = err.Error() |
||||
|
reply(&resp, w) |
||||
|
return |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if op == "root" { |
||||
|
resp.Response = MkTrees[c.CensusID].GetRoot() |
||||
|
} |
||||
|
|
||||
|
if op == "idx" { |
||||
|
|
||||
|
} |
||||
|
|
||||
|
if op == "dump" { |
||||
|
var t *tree.Tree |
||||
|
if auth := checkAuth(c.TimeStamp, c.Signature, Signatures[c.CensusID], authString); !auth { |
||||
|
resp.Error = true |
||||
|
resp.Response = "invalid authentication" |
||||
|
reply(&resp, w) |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
if len(c.RootHash) > 1 { //if rootHash specified
|
||||
|
t, err = MkTrees[c.CensusID].Snapshot(c.RootHash) |
||||
|
if err != nil { |
||||
|
log.Printf("Snapshot error: %s", err.Error()) |
||||
|
resp.Error = true |
||||
|
resp.Response = "invalid root hash" |
||||
|
reply(&resp, w) |
||||
|
return |
||||
|
} |
||||
|
} else { //if rootHash not specified use current merkletree
|
||||
|
t = MkTrees[c.CensusID] |
||||
|
} |
||||
|
|
||||
|
//dump the claim data and return it
|
||||
|
values, err := t.Dump() |
||||
|
if err != nil { |
||||
|
resp.Error = true |
||||
|
resp.Response = err.Error() |
||||
|
} else { |
||||
|
jValues, err := json.Marshal(values) |
||||
|
if err != nil { |
||||
|
resp.Error = true |
||||
|
resp.Response = err.Error() |
||||
|
} else { |
||||
|
resp.Response = fmt.Sprintf("%s", jValues) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if op == "check" { |
||||
|
if len(c.ProofData) < 1 { |
||||
|
resp.Error = true |
||||
|
resp.Response = "proofData not provided" |
||||
|
reply(&resp, w) |
||||
|
return |
||||
|
} |
||||
|
var t *tree.Tree |
||||
|
if len(c.RootHash) > 1 { //if rootHash specified
|
||||
|
t, err = MkTrees[c.CensusID].Snapshot(c.RootHash) |
||||
|
if err != nil { |
||||
|
log.Printf("Snapshot error: %s", err.Error()) |
||||
|
resp.Error = true |
||||
|
resp.Response = "invalid root hash" |
||||
|
reply(&resp, w) |
||||
|
return |
||||
|
} |
||||
|
} else { //if rootHash not specified use current merkletree
|
||||
|
t = MkTrees[c.CensusID] |
||||
|
} |
||||
|
|
||||
|
validProof, err := t.CheckProof([]byte(c.ClaimData), c.ProofData) |
||||
|
if err != nil { |
||||
|
resp.Error = true |
||||
|
resp.Response = err.Error() |
||||
|
reply(&resp, w) |
||||
|
return |
||||
|
} |
||||
|
if validProof { |
||||
|
resp.Response = "valid" |
||||
|
} else { |
||||
|
resp.Response = "invalid" |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
reply(&resp, w) |
||||
|
} |
||||
|
|
||||
|
func addCorsHeaders(w *http.ResponseWriter, req *http.Request) { |
||||
|
(*w).Header().Set("Access-Control-Allow-Origin", "*") |
||||
|
(*w).Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS") |
||||
|
(*w).Header().Set("Access-Control-Allow-Headers", "Accept, Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization") |
||||
|
} |
||||
|
|
||||
|
func Listen(port int, proto string) { |
||||
|
srv := &http.Server{ |
||||
|
Addr: fmt.Sprintf(":%d", port), |
||||
|
ReadHeaderTimeout: 4 * time.Second, |
||||
|
ReadTimeout: 4 * time.Second, |
||||
|
WriteTimeout: 4 * time.Second, |
||||
|
IdleTimeout: 3 * time.Second, |
||||
|
} |
||||
|
|
||||
|
http.HandleFunc("/addClaim", func(w http.ResponseWriter, r *http.Request) { |
||||
|
addCorsHeaders(&w, r) |
||||
|
|
||||
|
if r.Method == http.MethodPost { |
||||
|
claimHandler(w, r, "add") |
||||
|
} else if r.Method != http.MethodOptions { |
||||
|
http.Error(w, "Not found", http.StatusNotFound) |
||||
|
} |
||||
|
}) |
||||
|
http.HandleFunc("/genProof", func(w http.ResponseWriter, r *http.Request) { |
||||
|
addCorsHeaders(&w, r) |
||||
|
|
||||
|
if r.Method == http.MethodPost { |
||||
|
claimHandler(w, r, "gen") |
||||
|
} else if r.Method != http.MethodOptions { |
||||
|
http.Error(w, "Not found", http.StatusNotFound) |
||||
|
} |
||||
|
}) |
||||
|
http.HandleFunc("/checkProof", func(w http.ResponseWriter, r *http.Request) { |
||||
|
addCorsHeaders(&w, r) |
||||
|
|
||||
|
if r.Method == http.MethodPost { |
||||
|
claimHandler(w, r, "check") |
||||
|
} else if r.Method != http.MethodOptions { |
||||
|
http.Error(w, "Not found", http.StatusNotFound) |
||||
|
} |
||||
|
}) |
||||
|
http.HandleFunc("/getRoot", func(w http.ResponseWriter, r *http.Request) { |
||||
|
addCorsHeaders(&w, r) |
||||
|
|
||||
|
if r.Method == http.MethodPost { |
||||
|
claimHandler(w, r, "root") |
||||
|
} else if r.Method != http.MethodOptions { |
||||
|
http.Error(w, "Not found", http.StatusNotFound) |
||||
|
} |
||||
|
}) |
||||
|
http.HandleFunc("/dump", func(w http.ResponseWriter, r *http.Request) { |
||||
|
addCorsHeaders(&w, r) |
||||
|
|
||||
|
if r.Method == http.MethodPost { |
||||
|
claimHandler(w, r, "dump") |
||||
|
} else if r.Method != http.MethodOptions { |
||||
|
http.Error(w, "Not found", http.StatusNotFound) |
||||
|
} |
||||
|
}) |
||||
|
|
||||
|
if proto == "https" { |
||||
|
log.Print("Starting server in https mode") |
||||
|
if err := srv.ListenAndServeTLS("server.crt", "server.key"); err != nil { |
||||
|
panic(err) |
||||
|
} |
||||
|
} |
||||
|
if proto == "http" { |
||||
|
log.Print("Starting server in http mode") |
||||
|
srv.SetKeepAlivesEnabled(false) |
||||
|
if err := srv.ListenAndServe(); err != nil { |
||||
|
panic(err) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,22 @@ |
|||||
|
## dvote Tree |
||||
|
|
||||
|
Implementation of dvote tree structure. Currently based on iden3 merkle tree. |
||||
|
|
||||
|
Example of usage: |
||||
|
|
||||
|
``` |
||||
|
T := tree.Tree |
||||
|
if T.Init() != nil { fmt.Println("Cannot create tree database") } |
||||
|
err := T.AddClaim([]byte("Hello you!")) |
||||
|
if err != nil { |
||||
|
fmt.Println("Claim already exist") |
||||
|
} |
||||
|
mpHex, err := T.GenProof([]byte("Hello you!")) |
||||
|
fmt.Println(mpHex) |
||||
|
fmt.Println(T.CheckProof([]byte("Hello you!"), mpHex)) |
||||
|
T.Close() |
||||
|
``` |
||||
|
|
||||
|
#### To-Do |
||||
|
|
||||
|
Avoid duplicates on dump/snapshot |
||||
@ -0,0 +1,138 @@ |
|||||
|
package tree |
||||
|
|
||||
|
import ( |
||||
|
"bytes" |
||||
|
"errors" |
||||
|
"fmt" |
||||
|
"os/user" |
||||
|
|
||||
|
common3 "github.com/iden3/go-iden3/common" |
||||
|
mkcore "github.com/iden3/go-iden3/core" |
||||
|
db "github.com/iden3/go-iden3/db" |
||||
|
merkletree "github.com/iden3/go-iden3/merkletree" |
||||
|
) |
||||
|
|
||||
|
type Tree struct { |
||||
|
Storage string |
||||
|
Tree *merkletree.MerkleTree |
||||
|
DbStorage *db.LevelDbStorage |
||||
|
} |
||||
|
|
||||
|
func (t *Tree) Init(namespace string) error { |
||||
|
if len(t.Storage) < 1 { |
||||
|
if len(namespace) < 1 { |
||||
|
return errors.New("namespace not valid") |
||||
|
} |
||||
|
usr, err := user.Current() |
||||
|
if err == nil { |
||||
|
t.Storage = usr.HomeDir + "/.dvote/census/" + namespace |
||||
|
} else { |
||||
|
t.Storage = "./dvoteTree/" + namespace |
||||
|
} |
||||
|
} |
||||
|
mtdb, err := db.NewLevelDbStorage(t.Storage, false) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
mt, err := merkletree.NewMerkleTree(mtdb, 140) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
t.DbStorage = mtdb |
||||
|
t.Tree = mt |
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
func (t *Tree) Close() { |
||||
|
defer t.Tree.Storage().Close() |
||||
|
} |
||||
|
|
||||
|
func (t *Tree) GetClaim(data []byte) (*mkcore.ClaimBasic, error) { |
||||
|
if len(data) > 496/8 { |
||||
|
return nil, errors.New("claim data too large") |
||||
|
} |
||||
|
for i := len(data); i <= 496/8; i++ { |
||||
|
data = append(data, '\x00') |
||||
|
} |
||||
|
var indexSlot [400 / 8]byte |
||||
|
var dataSlot [496 / 8]byte |
||||
|
copy(indexSlot[:], data[:400/8]) |
||||
|
copy(dataSlot[:], data[:496/8]) |
||||
|
e := mkcore.NewClaimBasic(indexSlot, dataSlot) |
||||
|
return e, nil |
||||
|
} |
||||
|
|
||||
|
func (t *Tree) AddClaim(data []byte) error { |
||||
|
e, err := t.GetClaim(data) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
return t.Tree.Add(e.Entry()) |
||||
|
} |
||||
|
|
||||
|
func (t *Tree) GenProof(data []byte) (string, error) { |
||||
|
e, err := t.GetClaim(data) |
||||
|
if err != nil { |
||||
|
return "", err |
||||
|
} |
||||
|
mp, err := t.Tree.GenerateProof(e.Entry().HIndex()) |
||||
|
if err != nil { |
||||
|
return "", err |
||||
|
} |
||||
|
mpHex := common3.HexEncode(mp.Bytes()) |
||||
|
return mpHex, nil |
||||
|
} |
||||
|
|
||||
|
func (t *Tree) CheckProof(data []byte, mpHex string) (bool, error) { |
||||
|
mpBytes, err := common3.HexDecode(mpHex) |
||||
|
if err != nil { |
||||
|
return false, err |
||||
|
} |
||||
|
mp, err := merkletree.NewProofFromBytes(mpBytes) |
||||
|
if err != nil { |
||||
|
return false, err |
||||
|
} |
||||
|
e, err := t.GetClaim(data) |
||||
|
if err != nil { |
||||
|
return false, err |
||||
|
} |
||||
|
return merkletree.VerifyProof(t.Tree.RootKey(), mp, |
||||
|
e.Entry().HIndex(), e.Entry().HValue()), nil |
||||
|
} |
||||
|
|
||||
|
func (t *Tree) GetRoot() string { |
||||
|
return common3.HexEncode(t.Tree.RootKey().Bytes()) |
||||
|
} |
||||
|
|
||||
|
func (t *Tree) GetIndex(data []byte) (string, error) { |
||||
|
e, err := t.GetClaim(data) |
||||
|
if err != nil { |
||||
|
return "", err |
||||
|
} |
||||
|
index, err := t.Tree.GetDataByIndex(e.Entry().HIndex()) |
||||
|
return index.String(), err |
||||
|
} |
||||
|
|
||||
|
func (t *Tree) Dump() ([]string, error) { |
||||
|
var response []string |
||||
|
err := t.Tree.Walk(nil, func(n *merkletree.Node) { |
||||
|
if n.Type == merkletree.NodeTypeLeaf { |
||||
|
data := bytes.Trim(n.Value()[65:], "\x00") |
||||
|
response = append(response, fmt.Sprintf("%s", data)) |
||||
|
} |
||||
|
}) |
||||
|
return response, err |
||||
|
} |
||||
|
|
||||
|
func (t *Tree) Snapshot(root string) (*Tree, error) { |
||||
|
var rootHash merkletree.Hash |
||||
|
snapshotTree := new(Tree) |
||||
|
rootBytes, err := common3.HexDecode(root) |
||||
|
if err != nil { |
||||
|
return snapshotTree, err |
||||
|
} |
||||
|
copy(rootHash[:32], rootBytes) |
||||
|
mt, err := t.Tree.Snapshot(&rootHash) |
||||
|
snapshotTree.Tree = mt |
||||
|
return snapshotTree, err |
||||
|
} |
||||