backup.gno

  1package memba_notes_v1
  2
  3import (
  4	"bytes"
  5	"chain/runtime"
  6	"crypto/bech32"
  7	"crypto/sha256"
  8	"encoding/binary"
  9	"encoding/hex"
 10	"gno.land/p/samcrew/avl"
 11	keys "gno.land/r/samcrew/enckeys_v1"
 12	"strconv"
 13	"strings"
 14)
 15
 16const MaxBackupBytes = 365
 17
 18type backupRecord struct {
 19	Record               []byte
 20	Mode                 uint8
 21	Generation, Revision uint64
 22	PublicKeyHash        []byte
 23	Last                 receipt
 24}
 25
 26var backupLatest = avl.NewTree()
 27var backups = avl.NewTree()
 28
 29// A wallet-protected historical backup cannot become Vault-safe by relabelling.
 30var standardBackupKeys = avl.NewTree()
 31
 32func backupKey(who address, generation uint64) string {
 33	s := strconv.FormatUint(generation, 10)
 34	return string(who) + ":" + strings.Repeat("0", 20-len(s)) + s
 35}
 36func backupText(record []byte, pos, cap int) (string, int) {
 37	if pos+4 > len(record) {
 38		panic("notes: backup truncated")
 39	}
 40	size := int(binary.BigEndian.Uint32(record[pos : pos+4]))
 41	pos += 4
 42	if size < 1 || size > cap || pos+size > len(record) {
 43		panic("notes: backup text length")
 44	}
 45	for _, b := range record[pos : pos+size] {
 46		if b < 33 || b > 126 {
 47			panic("notes: backup ascii")
 48		}
 49	}
 50	return string(record[pos : pos+size]), pos + size
 51}
 52func validateBackup(who address, record []byte) (uint8, uint64, []byte) {
 53	if len(record) < 185 || len(record) > MaxBackupBytes || string(record[:4]) != "MNKB" || record[4] != 1 || record[5] != 1 {
 54		panic("notes: backup format")
 55	}
 56	mode := record[6]
 57	kdf := record[7]
 58	memory := binary.BigEndian.Uint32(record[8:12])
 59	passes := binary.BigEndian.Uint32(record[12:16])
 60	lanes := record[16]
 61	if !(mode == 1 && kdf == 1 && memory == 0 && passes == 0 && lanes == 0 || mode == 2 && kdf == 2 && memory == 65536 && passes == 3 && lanes == 1) {
 62		panic("notes: backup kdf profile")
 63	}
 64	chain, pos := backupText(record, 33, 64)
 65	realmPath, pos := backupText(record, pos, 128)
 66	if chain != runtime.ChainID() || realmPath != RealmPath || len(record) != pos+132 {
 67		panic("notes: backup network/length")
 68	}
 69	encoded, err := bech32.EncodeFromBase256("g", record[pos:pos+20])
 70	if err != nil || address(encoded) != who {
 71		panic("notes: backup address")
 72	}
 73	pos += 20
 74	generation := binary.BigEndian.Uint64(record[pos : pos+8])
 75	pos += 8
 76	hash := record[pos : pos+32]
 77	pk, gen, active := keys.GetKey(who, keys.SuiteXWingV1)
 78	h := sha256.Sum256(pk)
 79	if generation == 0 || generation != gen || !active || !bytes.Equal(hash, h[:]) {
 80		panic("notes: backup registry identity")
 81	}
 82	return mode, generation, copied(hash)
 83}
 84func SetSeedBackup(cur realm, baseRevision uint64, record []byte, opID [16]byte) {
 85	who := enter(cur, false)
 86	defer leave()
 87	if !cur.Previous().IsUserCall() {
 88		panic("notes: backup directly from account")
 89	}
 90	if opID == ([16]byte{}) || baseRevision == ^uint64(0) {
 91		panic("notes: invalid backup operation")
 92	}
 93	var revision uint64
 94	if v, ok := backupLatest.Get(string(who)); ok {
 95		r := v.(*backupRecord)
 96		revision = r.Revision
 97		if r.Last.Operation == opID {
 98			panic("notes: operation id reused")
 99		}
100	}
101	if revision != baseRevision {
102		panic("notes: stale backup revision")
103	}
104	mode, generation, hash := validateBackup(who, record)
105	exposureKey := string(who) + ":" + hex.EncodeToString(hash)
106	if mode == 2 {
107		if _, seen := standardBackupKeys.Get(exposureKey); seen {
108			panic("notes: vault requires independent identity")
109		}
110	} else {
111		standardBackupKeys.Set(exposureKey, true)
112	}
113	r := &backupRecord{copied(record), mode, generation, revision + 1, hash, receipt{opID, who, runtime.ChainHeight()}}
114	backups.Set(backupKey(who, generation), r)
115	backupLatest.Set(string(who), r)
116}
117func backupJSON(r *backupRecord, withRecord bool) string {
118	s := `{"mode":` + strconv.Itoa(int(r.Mode)) + `,"suite":"xwing-v1","generation":` + u(r.Generation) + `,"revision":` + u(r.Revision) + `,"public_key_hash":` + blob(r.PublicKeyHash) + `,"op_id":` + q(idText(r.Last.Operation)) + `,"actor":` + q(string(r.Last.Actor)) + `,"height":` + q(strconv.FormatInt(r.Last.Height, 10))
119	if withRecord {
120		s += `,"record":` + blob(r.Record)
121	}
122	return s + `}`
123}
124func SeedBackupJSON(who address) string {
125	v, ok := backupLatest.Get(string(keys.CanonicalAddress(who)))
126	if !ok {
127		return "null"
128	}
129	return backupJSON(v.(*backupRecord), true)
130}
131func SeedBackupAtJSON(who address, generation uint64) string {
132	v, ok := backups.Get(backupKey(keys.CanonicalAddress(who), generation))
133	if !ok {
134		return "null"
135	}
136	return backupJSON(v.(*backupRecord), true)
137}
138func SeedBackupsJSON(who address, cursor uint64, limit int) string {
139	who = keys.CanonicalAddress(who)
140	if limit < 1 || limit > MaxPage {
141		panic("notes: page limit")
142	}
143	items := []string{}
144	var next uint64
145	backups.Iterate(backupKey(who, cursor), string(who)+":\xff", func(k string, v interface{}) bool {
146		r := v.(*backupRecord)
147		if r.Generation <= cursor {
148			return false
149		}
150		items = append(items, backupJSON(r, false))
151		next = r.Generation
152		return len(items) == limit
153	})
154	if len(items) < limit {
155		next = 0
156	}
157	return `{"items":[` + strings.Join(items, ",") + `],"next_cursor":` + u(next) + `}`
158}