government / ratify / repeal_test.go

@ 1e3679e075694dda43bb3b82dd39f993c8e7705a | history


package ratify

import (
	"crypto/ed25519"
	"crypto/rand"
	"crypto/sha256"
	"crypto/x509"
	"encoding/pem"
	"math/big"
	"strconv"
	"testing"
	"time"

	"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, Issued: 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))
	}
}