@ 675167640370859e58d24a1f76126760c2e61968 | history
package ratify
import (
"crypto/ed25519"
"crypto/rand"
"crypto/sha256"
"crypto/x509"
"encoding/pem"
"math/big"
"strconv"
"testing"
"time"
"nmyk.io/government/lisp2gov"
)
var (
feb = time.Date(2027, 2, 1, 0, 0, 0, 0, time.UTC)
mar = time.Date(2027, 3, 1, 0, 0, 0, 0, time.UTC)
apr = time.Date(2027, 4, 1, 0, 0, 0, 0, time.UTC)
jun = time.Date(2027, 6, 1, 0, 0, 0, 0, time.UTC)
jul = time.Date(2027, 7, 1, 0, 0, 0, 0, time.UTC)
ever = time.Date(9999, 12, 31, 23, 59, 59, 0, time.UTC)
)
func program(t *testing.T, name string, seed *[32]byte) ([]byte, []*x509.Certificate) {
t.Helper()
data, err := lisp2gov.Compile("(+ 1 (* 2 3))", lisp2gov.Options{Name: name, Seed: seed})
if err != nil {
t.Fatal(err)
}
certs, err := Load(data)
if err != nil {
t.Fatal(err)
}
certs, err = Order(certs)
if err != nil {
t.Fatal(err)
}
return data, certs
}
// repealOf repeals the cert at depth, signed by its issuer. lisp2gov only
// ever repeals depth 1, but a CRL from any cert of the chain is a valid
// repeal, so these are made by hand with the same key derivation.
func repealOf(t *testing.T, certs []*x509.Certificate, depth int, seed *[32]byte, at, next time.Time) []byte {
t.Helper()
s := lisp2gov.DefaultSeed
if seed != nil {
s = *seed
}
key := ed25519.NewKeyFromSeed(s[:])
if depth > 1 {
h := sha256.Sum256([]byte(string(s[:]) + "GOVERNMENT" + strconv.Itoa(depth-1)))
key = ed25519.NewKeyFromSeed(h[:])
}
der, err := x509.CreateRevocationList(rand.Reader, &x509.RevocationList{
Number: big.NewInt(feb.Unix()), ThisUpdate: feb, NextUpdate: next,
RevokedCertificateEntries: []x509.RevocationListEntry{{
SerialNumber: certs[depth].SerialNumber, RevocationTime: at, ReasonCode: Reasons["superseded"],
}},
}, certs[depth-1], key)
if err != nil {
t.Fatal(err)
}
return pem.EncodeToMemory(&pem.Block{Type: "X509 CRL", Bytes: der})
}
// TestRepealsFromTheCompiler checks the CRLs lisp2gov writes, not just
// hand-made ones.
func TestRepealsFromTheCompiler(t *testing.T) {
_, certs := program(t, "p", nil)
crl, err := lisp2gov.Repeal(certs, lisp2gov.RepealOptions{Reason: Reasons["superseded"], At: mar, LastUpdate: feb, NextUpdate: ever})
if err != nil {
t.Fatal(err)
}
crls, err := LoadCRLs(crl)
if err != nil {
t.Fatal(err)
}
checkCode(t, "compiler repeal", CheckRepeals(certs, crls, apr), ErrRepealed, "depth 1 repealed 2027-03-01 (superseded)")
}
func TestRepeals(t *testing.T) {
data, certs := program(t, "p", nil)
other := [32]byte{8}
_, impostor := program(t, "p", &other) // same names, another key
_, foreign := program(t, "q", &other) // another program altogether
// A CRL from the right issuer that names no cert of this program.
anchorKey := ed25519.NewKeyFromSeed(lisp2gov.DefaultSeed[:])
der, err := x509.CreateRevocationList(rand.Reader, &x509.RevocationList{
Number: big.NewInt(1), ThisUpdate: feb, NextUpdate: ever,
RevokedCertificateEntries: []x509.RevocationListEntry{{SerialNumber: big.NewInt(99), RevocationTime: feb}},
}, certs[0], anchorKey)
if err != nil {
t.Fatal(err)
}
unrelated := pem.EncodeToMemory(&pem.Block{Type: "X509 CRL", Bytes: der})
tests := []struct {
name string
crls [][]byte
at time.Time
code string
msg string
}{
{"no repeals", nil, apr, "", ""},
{"repeal depth 1", [][]byte{repealOf(t, certs, 1, nil, mar, ever)}, apr, ErrRepealed, "depth 1 repealed 2027-03-01 (superseded)"},
{"repeal depth 2", [][]byte{repealOf(t, certs, 2, nil, mar, ever)}, apr, ErrRepealed, "depth 2 repealed"},
{"repeal depth 3", [][]byte{repealOf(t, certs, 3, nil, mar, ever)}, apr, ErrRepealed, "depth 3 repealed"},
{"scheduled, before its date", [][]byte{repealOf(t, certs, 2, nil, mar, ever)}, feb, "", ""},
{"scheduled, on its date", [][]byte{repealOf(t, certs, 2, nil, mar, ever)}, mar, ErrRepealed, "depth 2 repealed"},
{"scheduled, after its date", [][]byte{repealOf(t, certs, 2, nil, mar, ever)}, apr, ErrRepealed, "depth 2 repealed"},
{"stale", [][]byte{repealOf(t, certs, 2, nil, ever, jun)}, jul, ErrStaleRepeals, "depth 1 went stale 2027-06-01T00:00:00Z"},
{"fresh until nextUpdate", [][]byte{repealOf(t, certs, 2, nil, ever, jun)}, jun, "", ""},
{"signed by the wrong key", [][]byte{repealOf(t, impostor, 2, &other, mar, ever)}, apr, ErrTampered, "repeal list from depth 1 fails"},
{"from another program", [][]byte{repealOf(t, foreign, 2, &other, mar, ever)}, apr, ErrForeign, "not part of this program"},
{"names no cert of ours", [][]byte{unrelated}, apr, "", ""},
{"one of several repeals", [][]byte{unrelated, repealOf(t, certs, 3, nil, mar, ever)}, apr, ErrRepealed, "depth 3 repealed"},
{"not a CRL", [][]byte{data}, apr, ErrMalformed, "not CERTIFICATE"},
{"empty file", [][]byte{nil}, apr, ErrMalformed, "no X509 CRL"},
}
for _, tt := range tests {
_, err := Ratify(data, Options{At: tt.at, CRLs: tt.crls})
checkCode(t, tt.name, err, tt.code, tt.msg)
}
}
func TestReasonNames(t *testing.T) {
names := ReasonNames()
if names[0] != "unspecified" || names[len(names)-1] != "aACompromise" || len(names) != 10 {
t.Errorf("ReasonNames = %v", names)
}
if reasonName(4) != "superseded" || reasonName(7) != "reason 7" {
t.Errorf("reasonName(4) = %s, reasonName(7) = %s", reasonName(4), reasonName(7))
}
}