cert

README

Certificates

A certificate consists of

• a tree.
• a signature on the tree root hash valid under some public key.
• an optional delegation that links that public key to root public key.

Read More

• Certified Data
• Certification

Documentation

Index

• func Lookup(path [][]byte, node Node) []byte
• func Serialize(node Node) ([]byte, error)
• type Certificate
• type Delegation
• type Empty
  • func (e Empty) Reconstruct() [32]byte
  • func (e Empty) String() string
• type Fork
  • func (f Fork) Reconstruct() [32]byte
  • func (f Fork) String() string
• type HashTree
  • func NewHashTree(root Node) HashTree
  • func (t HashTree) Digest() [32]byte
• type Label
  • func (l Label) String() string
• type LabelResult
• type Labeled
  • func (l Labeled) Reconstruct() [32]byte
  • func (l Labeled) String() string
• type Leaf
  • func (l Leaf) Reconstruct() [32]byte
  • func (l Leaf) String() string
• type Node
  • func Deserialize(data []byte) (Node, error)
  • func DeserializeNode(s []interface{}) (Node, error)
• type Pruned
  • func (p Pruned) Reconstruct() [32]byte
  • func (p Pruned) String() string

Examples

• Deserialize
• Lookup
• Pruned
• Serialize

Functions

func Lookup

func Lookup(path [][]byte, node Node) []byte

Example

package main

import (
	"fmt"

	cert "github.com/aviate-labs/certificate-go"
)

func main() {
	fmt.Println(string(cert.Lookup(path("a", "x"), tree)))
	fmt.Println(string(cert.Lookup(path("a", "y"), tree)))
	fmt.Println(string(cert.Lookup(path("b"), tree)))
	fmt.Println(string(cert.Lookup(path("d"), tree)))
}

func path(p ...string) [][]byte {
	var path [][]byte
	for _, p := range p {
		path = append(path, []byte(p))
	}
	return path
}

Output:

hello
world
good
morning

func Serialize

func Serialize(node Node) ([]byte, error)

Example

package main

import (
	"fmt"

	cert "github.com/aviate-labs/certificate-go"
)

var tree = cert.Fork{
	LeftTree: cert.Fork{
		LeftTree: cert.Labeled{
			Label: []byte("a"),
			Tree: cert.Fork{
				LeftTree: cert.Fork{
					LeftTree: cert.Labeled{
						Label: []byte("x"),
						Tree:  cert.Leaf("hello"),
					},
					RightTree: cert.Empty{},
				},
				RightTree: cert.Labeled{
					Label: []byte("y"),
					Tree:  cert.Leaf("world"),
				},
			},
		},
		RightTree: cert.Labeled{
			Label: []byte("b"),
			Tree:  cert.Leaf("good"),
		},
	},
	RightTree: cert.Fork{
		LeftTree: cert.Labeled{
			Label: []byte("c"),
			Tree:  cert.Empty{},
		},
		RightTree: cert.Labeled{
			Label: []byte("d"),
			Tree:  cert.Leaf("morning"),
		},
	},
}

func main() {
	b, _ := cert.Serialize(tree)
	fmt.Printf("%x", b)
}

Output:

8301830183024161830183018302417882034568656c6c6f810083024179820345776f726c6483024162820344676f6f648301830241638100830241648203476d6f726e696e67

Types

type Certificate

type Certificate struct {
	Tree       HashTree
	Signature  []byte
	Delegation *Delegation
}

type Delegation

type Delegation struct {
	SubnetId principal.Principal
	// The nested certificate typically does not itself again contain a
	// delegation, although there is no reason why agents should enforce that
	// property.
	Certificate Certificate
}

type Empty

type Empty struct{}

func (Empty) Reconstruct

func (e Empty) Reconstruct() [32]byte

func (Empty) String

func (e Empty) String() string

type Fork

type Fork struct {
	LeftTree  Node
	RightTree Node
}

func (Fork) Reconstruct

func (f Fork) Reconstruct() [32]byte

func (Fork) String

func (f Fork) String() string

type HashTree

type HashTree struct {
	// contains filtered or unexported fields
}

func NewHashTree

func NewHashTree(root Node) HashTree

func (HashTree) Digest

func (t HashTree) Digest() [32]byte

type Label

type Label []byte

func (Label) String

func (l Label) String() string

type LabelResult

type LabelResult string

const (
	Absent   LabelResult = "absent"
	Continue LabelResult = "continue"
	Found    LabelResult = "found"
	Unknown  LabelResult = "unknown"
)

type Labeled

type Labeled struct {
	Label Label
	Tree  Node
}

func (Labeled) Reconstruct

func (l Labeled) Reconstruct() [32]byte

func (Labeled) String

func (l Labeled) String() string

type Leaf

type Leaf []byte

func (Leaf) Reconstruct

func (l Leaf) Reconstruct() [32]byte

func (Leaf) String

func (l Leaf) String() string

type Node

type Node interface {
	Reconstruct() [32]byte
	fmt.Stringer
}

func Deserialize

func Deserialize(data []byte) (Node, error)

Example

package main

import (
	"encoding/hex"
	"fmt"

	cert "github.com/aviate-labs/certificate-go"
)

func main() {
	data, _ := hex.DecodeString("8301830183024161830183018302417882034568656c6c6f810083024179820345776f726c6483024162820344676f6f648301830241638100830241648203476d6f726e696e67")
	fmt.Println(cert.Deserialize(data))
}

Output:

{{a:{{x:hello|∅}|y:world}|b:good}|{c:∅|d:morning}} <nil>

func DeserializeNode

func DeserializeNode(s []interface{}) (Node, error)

type Pruned

type Pruned [32]byte

Example

package main

import (
	"encoding/hex"
	"fmt"

	cert "github.com/aviate-labs/certificate-go"
)

var pruned = cert.Fork{
	LeftTree: cert.Fork{
		LeftTree: cert.Labeled{
			Label: []byte("a"),
			Tree: cert.Fork{
				LeftTree: cert.Pruned(h2b("1B4FEFF9BEF8131788B0C9DC6DBAD6E81E524249C879E9F10F71CE3749F5A638")),
				RightTree: cert.Labeled{
					Label: []byte("y"),
					Tree:  cert.Leaf("world"),
				},
			},
		},
		RightTree: cert.Labeled{
			Label: []byte("b"),
			Tree:  cert.Pruned(h2b("7B32AC0C6BA8CE35AC82C255FC7906F7FC130DAB2A090F80FE12F9C2CAE83BA6")),
		},
	},
	RightTree: cert.Fork{
		LeftTree: cert.Pruned(h2b("EC8324B8A1F1AC16BD2E806EDBA78006479C9877FED4EB464A25485465AF601D")),
		RightTree: cert.Labeled{
			Label: []byte("d"),
			Tree:  cert.Leaf("morning"),
		},
	},
}

func main() {
	fmt.Printf("%X", pruned.Reconstruct())
}

func h2b(s string) [32]byte {
	var bs [32]byte
	b, _ := hex.DecodeString(s)
	copy(bs[:], b)
	return bs
}

Output:

EB5C5B2195E62D996B84C9BCC8259D19A83786A2F59E0878CEC84C811F669AA0

func (Pruned) Reconstruct

func (p Pruned) Reconstruct() [32]byte

func (Pruned) String

func (p Pruned) String() string