Go

module example.com/silvector-quickstart

go 1.22

// Silvector quickstart for Go 1.22 or later. Standard library only.
// Run: go run .
package main

import (
	"bytes"
	"crypto/ed25519"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
	"slices"
	"strings"
	"time"
	"unicode/utf16"
)

type receipt struct {
	Body map[string]any `json:"body"`
	Sig  string         `json:"sig"`
}

type jwk struct {
	Kty string `json:"kty"`
	Crv string `json:"crv"`
	Kid string `json:"kid"`
	X   string `json:"x"`
}

// writeString escapes the way JavaScript's JSON.stringify does, which the signer uses.
// encoding/json differs: it escapes U+2028, U+2029 and HTML characters.
func writeString(buf *bytes.Buffer, s string) {
	buf.WriteByte('"')
	for _, r := range s {
		switch r {
		case '"':
			buf.WriteString(`\"`)
		case '\\':
			buf.WriteString(`\\`)
		case '\b':
			buf.WriteString(`\b`)
		case '\f':
			buf.WriteString(`\f`)
		case '\n':
			buf.WriteString(`\n`)
		case '\r':
			buf.WriteString(`\r`)
		case '\t':
			buf.WriteString(`\t`)
		default:
			if r < 0x20 {
				fmt.Fprintf(buf, `\u%04x`, r)
			} else {
				buf.WriteRune(r)
			}
		}
	}
	buf.WriteByte('"')
}

// compareUTF16 orders keys by UTF-16 code unit, as JavaScript sorts them. Go's string
// order is by UTF-8 byte, which differs for characters outside the Basic Multilingual Plane.
func compareUTF16(a, b string) int {
	return slices.Compare(utf16.Encode([]rune(a)), utf16.Encode([]rune(b)))
}

// canonical writes JSON with keys sorted, no whitespace and integers only:
// the exact bytes the receipt signature covers.
func canonical(buf *bytes.Buffer, value any) error {
	switch v := value.(type) {
	case nil:
		buf.WriteString("null")
	case bool:
		fmt.Fprintf(buf, "%t", v)
	case json.Number:
		if strings.ContainsAny(v.String(), ".eE") {
			return fmt.Errorf("receipts carry integers only, got %s", v)
		}
		if v.String() == "-0" {
			buf.WriteString("0")
		} else {
			buf.WriteString(v.String())
		}
	case string:
		writeString(buf, v)
	case []any:
		buf.WriteByte('[')
		for i, item := range v {
			if i > 0 {
				buf.WriteByte(',')
			}
			if err := canonical(buf, item); err != nil {
				return err
			}
		}
		buf.WriteByte(']')
	case map[string]any:
		keys := make([]string, 0, len(v))
		for k := range v {
			keys = append(keys, k)
		}
		slices.SortFunc(keys, compareUTF16)
		buf.WriteByte('{')
		for i, k := range keys {
			if i > 0 {
				buf.WriteByte(',')
			}
			if err := canonical(buf, k); err != nil {
				return err
			}
			buf.WriteByte(':')
			if err := canonical(buf, v[k]); err != nil {
				return err
			}
		}
		buf.WriteByte('}')
	default:
		return fmt.Errorf("unexpected JSON value %T", value)
	}
	return nil
}

func verifies(r receipt, key jwk) bool {
	pub, err := base64.RawURLEncoding.DecodeString(key.X)
	if err != nil || len(pub) != ed25519.PublicKeySize {
		return false
	}
	sig, err := base64.RawURLEncoding.DecodeString(r.Sig)
	if err != nil {
		return false
	}
	var msg bytes.Buffer
	if err := canonical(&msg, r.Body); err != nil {
		return false
	}
	return ed25519.Verify(pub, msg.Bytes(), sig)
}

func getJSON(client *http.Client, req *http.Request, out any) error {
	res, err := client.Do(req)
	if err != nil {
		return err
	}
	defer res.Body.Close()
	if res.StatusCode != http.StatusOK {
		return fmt.Errorf("%s returned %d", req.URL.Path, res.StatusCode)
	}
	dec := json.NewDecoder(res.Body)
	dec.UseNumber()
	return dec.Decode(out)
}

func run() (bool, error) {
	api := os.Getenv("SILVECTOR_API")
	if api == "" {
		api = "https://api.silvector.com"
	}
	client := &http.Client{Timeout: 15 * time.Second}

	// 1. Ask for a decision. The response carries a signed receipt.
	checkReq, _ := http.NewRequest(http.MethodPost, api+"/v1/check", strings.NewReader(`{"method":"GET","path":"/pricing"}`))
	checkReq.Header.Set("content-type", "application/json")
	var decision struct {
		ReceiptID string  `json:"receiptId"`
		Receipt   receipt `json:"receipt"`
	}
	if err := getJSON(client, checkReq, &decision); err != nil {
		return false, err
	}
	r := decision.Receipt

	// 2. Fetch the published keys.
	jwksReq, _ := http.NewRequest(http.MethodGet, api+"/.well-known/jwks.json", nil)
	var jwks struct {
		Keys []jwk `json:"keys"`
	}
	if err := getJSON(client, jwksReq, &jwks); err != nil {
		return false, err
	}
	var keys []jwk
	for _, k := range jwks.Keys {
		if k.Kty == "OKP" && k.Crv == "Ed25519" {
			keys = append(keys, k)
		}
	}

	// 3. Verify with the one key whose kid equals the receipt's agent_kid. Other published
	// keys sign other things, so never fall back to them.
	var key *jwk
	for i := range keys {
		if keys[i].Kid == r.Body["agent_kid"] {
			key = &keys[i]
			break
		}
	}
	verified := key != nil && verifies(r, *key)

	// 4. Change one field and check that the signature no longer holds.
	tamperedBody := map[string]any{}
	for k, v := range r.Body {
		tamperedBody[k] = v
	}
	if r.Body["outcome"] == "allow" {
		tamperedBody["outcome"] = "deny"
	} else {
		tamperedBody["outcome"] = "allow"
	}
	tampered := receipt{Body: tamperedBody, Sig: r.Sig}
	tamperedVerifies := key != nil && verifies(tampered, *key)

	fmt.Printf("receipt: %s\n", decision.ReceiptID)
	fmt.Printf("outcome: %v (rule %v)\n", r.Body["outcome"], r.Body["rule_id"])
	if key != nil {
		fmt.Printf("key: %s\n", key.Kid)
	} else {
		fmt.Printf("key: none published for %v\n", r.Body["agent_kid"])
	}
	fmt.Printf("verified: %t\n", verified)
	fmt.Printf("tampered copy verifies: %t\n", tamperedVerifies)
	fmt.Println("evidence grade: rung 2 Operational, confidence none, uncalibrated (assigned by the docs, not a signed field)")
	return verified && !tamperedVerifies, nil
}

func main() {
	ok, err := run()
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
	if !ok {
		os.Exit(1)
	}
}

go run .