Go signature verification

mkdir -p build
go build -o build/go-verify go/verify.go

./build/go-verify vectors/positive.key.json vectors/positive.envelope.json
./build/go-verify vectors/tampered.key.json vectors/tampered.envelope.json
./build/go-verify vectors/expired.key.json vectors/expired.envelope.json
python3 selftest.py --command ./build/go-verify

// KDPika signature authenticity only. Go 1.22+, standard library only.
// Run: go run verify.go key.json envelope.json. Output signature_valid=true/false.
// Independently trust key.json. Check expiry and binding before granting access.
package main

import (
    "bytes"
    "crypto/ed25519"
    "crypto/sha256"
    "encoding/base64"
    "encoding/hex"
    "encoding/json"
    "fmt"
    "io"
    "os"
    "sort"
    "strconv"
    "strings"
    "unicode/utf8"
)

// encoding/json replaces lone surrogate escapes with U+FFFD. Reject them first
// so malformed input cannot verify as a signed literal replacement character.
func validEscapes(raw []byte) bool {
    inString:=false
    for i:=0;i<len(raw);i++ {
        if raw[i]=='"' { inString=!inString;continue }
        if !inString || raw[i]!='\\' { continue }
        i++;if i>=len(raw) { return false }
        if raw[i]!='u' { continue }
        if i+4>=len(raw) { return false }
        cp,err:=strconv.ParseUint(string(raw[i+1:i+5]),16,16);if err!=nil { return false };i+=4
        if cp>=0xd800 && cp<=0xdbff {
            if i+6>=len(raw) || raw[i+1]!='\\' || raw[i+2]!='u' { return false }
            low,err:=strconv.ParseUint(string(raw[i+3:i+7]),16,16)
            if err!=nil || low<0xdc00 || low>0xdfff { return false };i+=6
        } else if cp>=0xdc00 && cp<=0xdfff { return false }
    }
    return true
}

func parse(raw []byte) (any, error) {
    if len(raw) > 1048576 || !utf8.Valid(raw) || !validEscapes(raw) { return nil, fmt.Errorf("invalid JSON size or Unicode") }
    decoder := json.NewDecoder(bytes.NewReader(raw)); decoder.UseNumber()
    var value func(int) (any, error)
    value = func(depth int) (any, error) {
        if depth > 64 { return nil, fmt.Errorf("JSON exceeds 64 levels") }
        token, err := decoder.Token(); if err != nil { return nil, err }
        if delim, ok := token.(json.Delim); ok {
            switch delim {
            case '{':
                result := map[string]any{}
                for decoder.More() {
                    keyToken, err := decoder.Token(); if err != nil { return nil, err }
                    key, ok := keyToken.(string); if !ok { return nil, fmt.Errorf("invalid key") }
                    if _, exists := result[key]; exists { return nil, fmt.Errorf("duplicate property") }
                    child, err := value(depth+1); if err != nil { return nil, err }; result[key] = child
                }
                end, err := decoder.Token(); if err != nil || end != json.Delim('}') { return nil, fmt.Errorf("invalid object") }
                return result, nil
            case '[':
                result := []any{}
                for decoder.More() { child, err := value(depth+1); if err != nil { return nil, err }; result = append(result, child) }
                end, err := decoder.Token(); if err != nil || end != json.Delim(']') { return nil, fmt.Errorf("invalid array") }
                return result, nil
            default: return nil, fmt.Errorf("unexpected delimiter")
            }
        }
        return token, nil
    }
    result, err := value(0); if err != nil { return nil, err }
    if _, err = decoder.Token(); err != io.EOF { return nil, fmt.Errorf("trailing JSON") }
    return result, nil
}
func quote(value string) string {
    var out bytes.Buffer; encoder := json.NewEncoder(&out); encoder.SetEscapeHTML(false)
    if err := encoder.Encode(value); err != nil { panic(err) }; return strings.TrimSuffix(out.String(), "\n")
}
func canonical(value any) string {
    switch v := value.(type) {
    case map[string]any:
        keys := make([]string,0,len(v)); for k := range v { keys=append(keys,k) }; sort.Strings(keys)
        parts := make([]string,0,len(keys)); for _,k := range keys { parts=append(parts,quote(k)+":"+canonical(v[k])) }
        return "{"+strings.Join(parts,",")+"}"
    case []any:
        parts:=make([]string,len(v)); for i,child:=range v { parts[i]=canonical(child) }; return "["+strings.Join(parts,",")+"]"
    case json.Number: return string(v)
    case string: return quote(v)
    case bool: if v { return "true" }; return "false"
    case nil: return "null"
    default: panic("unsupported JSON value")
    }
}
func decode(value any, size int) ([]byte,error) {
    text,ok:=value.(string); if !ok { return nil,fmt.Errorf("invalid base64url") }
    raw,err:=base64.RawURLEncoding.Strict().DecodeString(text)
    if err!=nil || len(raw)!=size || base64.RawURLEncoding.EncodeToString(raw)!=text { return nil,fmt.Errorf("invalid base64url length") }; return raw,nil
}
func VerifyEnvelope(keyRaw, envRaw []byte) (valid bool) {
    defer func(){ if recover()!=nil { valid=false } }()
    k,err:=parse(keyRaw); if err!=nil { return false }; e,err:=parse(envRaw); if err!=nil { return false }
    key,ok:=k.(map[string]any); if !ok { return false }; env,ok:=e.(map[string]any); if !ok { return false }
    pub,err:=decode(key["public_key"],32); if err!=nil { return false }; sum:=sha256.Sum256(pub); id:="ed25519_"+hex.EncodeToString(sum[:])[:16]
    payload,ok:=env["payload"].(map[string]any)
    if !ok || key["algorithm"]!="Ed25519" || key["encoding"]!="base64url" || key["key_id"]!=id || env["algorithm"]!="Ed25519" || env["key_id"]!=id { return false }
    signature,err:=decode(env["signature"],64); if err!=nil { return false }
    return ed25519.Verify(pub,[]byte(canonical(payload)),signature)
}
func main() {
    valid:=false
    if len(os.Args)==3 {
        key,err1:=os.ReadFile(os.Args[1]); env,err2:=os.ReadFile(os.Args[2]); if err1==nil && err2==nil { valid=VerifyEnvelope(key,env) }
    }
    fmt.Printf("signature_valid=%t\n",valid); if !valid { os.Exit(1) }
}