package requests import ( "fmt" "io" "strconv" "strings" "git.sigsum.org/sigsum-go/pkg/ascii" "git.sigsum.org/sigsum-go/pkg/hex" "git.sigsum.org/sigsum-go/pkg/types" ) type Leaf struct { ShardHint uint64 `ascii:"shard_hint"` Preimage types.Hash `ascii:"preimage"` Signature types.Signature `ascii:"signature"` VerificationKey types.PublicKey `ascii:"verification_key"` DomainHint string `ascii:"domain_hint"` } type Leaves struct { StartSize uint64 EndSize uint64 } type InclusionProof struct { TreeSize uint64 LeafHash types.Hash } type ConsistencyProof struct { OldSize uint64 NewSize uint64 } type Cosignature struct { Cosignature types.Signature `ascii:"cosignature"` KeyHash types.Hash `ascii:"key_hash"` } func (req *Leaf) ToASCII(w io.Writer) error { return ascii.StdEncoding.Serialize(w, req) } // ToURL encodes request parameters at the end of a slash-terminated URL func (req *Leaves) ToURL(url string) string { return url + fmt.Sprintf("%d/%d", req.StartSize, req.EndSize) } // ToURL encodes request parameters at the end of a slash-terminated URL func (req *InclusionProof) ToURL(url string) string { return url + fmt.Sprintf("%d/%s", req.TreeSize, hex.Serialize(req.LeafHash[:])) } // ToURL encodes request parameters at the end of a slash-terminated URL func (req *ConsistencyProof) ToURL(url string) string { return url + fmt.Sprintf("%d/%d", req.OldSize, req.NewSize) } func (req *Cosignature) ToASCII(w io.Writer) error { return ascii.StdEncoding.Serialize(w, req) } func (req *Leaf) FromASCII(r io.Reader) error { return ascii.StdEncoding.Deserialize(r, req) } // FromURL parses request parameters from a URL that is not slash-terminated func (req *Leaves) FromURL(url string) (err error) { split := strings.Split(url, "/") if len(split) < 2 { return fmt.Errorf("not enough input") } startSize := split[len(split)-2] if req.StartSize, err = strconv.ParseUint(startSize, 10, 64); err != nil { return err } endSize := split[len(split)-1] if req.EndSize, err = strconv.ParseUint(endSize, 10, 64); err != nil { return err } return nil } // FromURL parses request parameters from a URL that is not slash-terminated func (req *InclusionProof) FromURL(url string) (err error) { split := strings.Split(url, "/") if len(split) < 2 { return fmt.Errorf("not enough input") } treeSize := split[len(split)-2] if req.TreeSize, err = strconv.ParseUint(treeSize, 10, 64); err != nil { return err } b, err := hex.Deserialize(split[len(split)-1]) if err != nil { return err } if n := len(b); n != types.HashSize { return fmt.Errorf("invalid hash size %d", n) } copy(req.LeafHash[:], b) return nil } // FromURL parses request parameters from a URL that is not slash-terminated func (req *ConsistencyProof) FromURL(url string) (err error) { split := strings.Split(url, "/") if len(split) < 2 { return fmt.Errorf("not enough input") } oldSize := split[len(split)-2] if req.OldSize, err = strconv.ParseUint(oldSize, 10, 64); err != nil { return err } newSize := split[len(split)-1] if req.NewSize, err = strconv.ParseUint(newSize, 10, 64); err != nil { return err } return nil } func (req *Cosignature) FromASCII(r io.Reader) error { return ascii.StdEncoding.Deserialize(r, req) }