government / src / lisp2gov / extensions_test.go

@ a94ce18dbaa3c27d01f1491d51ec12c5767daf6d | history


package lisp2gov

import (
	"bytes"
	"crypto/x509"
	"encoding/asn1"
	"testing"

	"nmyk.io/government/ast"
	"nmyk.io/government/sexpr"
)

func TestPolicyMappingsEncoding(t *testing.T) {
	type mapping struct{ Issuer, Subject asn1.ObjectIdentifier }
	want, err := asn1.Marshal([]mapping{
		{asn1.ObjectIdentifier{1, 2, 3}, asn1.ObjectIdentifier{1, 2, 4}},
		{asn1.ObjectIdentifier{1, 2, 3}, asn1.ObjectIdentifier{2, 999, 1}},
	})
	if err != nil {
		t.Fatal(err)
	}
	oid := func(s string) x509.OID {
		o, err := x509.ParseOID(s)
		if err != nil {
			t.Fatal(err)
		}
		return o
	}
	ext, err := policyMappingsExtension([]x509.PolicyMapping{
		{IssuerDomainPolicy: oid("1.2.3"), SubjectDomainPolicy: oid("1.2.4")},
		{IssuerDomainPolicy: oid("1.2.3"), SubjectDomainPolicy: oid("2.999.1")},
	})
	if err != nil {
		t.Fatal(err)
	}
	if !bytes.Equal(ext.Value, want) {
		t.Errorf("% x\nwant % x", ext.Value, want)
	}
	if !ext.Id.Equal(asn1.ObjectIdentifier{2, 5, 29, 33}) || !ext.Critical {
		t.Errorf("extension %v critical=%v", ext.Id, ext.Critical)
	}
}

func TestPolicyMappingsRejectsEmpty(t *testing.T) {
	if _, err := policyMappingsExtension(nil); err == nil {
		t.Error("empty policyMappings accepted; RFC 5280 requires at least one")
	}
}

func buildChain(t *testing.T, src string) ([]*x509.Certificate, ast.Layers) {
	t.Helper()
	certs, err := compileCerts(src, Options{Name: "mappings"})
	if err != nil {
		t.Fatal(err)
	}
	forms, err := sexpr.ReadAll(src)
	if err != nil {
		t.Fatal(err)
	}
	tree, err := ast.ToTree(forms)
	if err != nil {
		t.Fatal(err)
	}
	layers, err := ast.Layer(tree)
	if err != nil {
		t.Fatal(err)
	}
	return certs, layers
}

func TestMappingsSurviveParsing(t *testing.T) {
	certs, layers := buildChain(t, "(+ 1 (* 2 3))")
	if len(certs) != 4 {
		t.Fatalf("%d certs, want anchor + 3", len(certs))
	}
	for i, c := range certs[1:] {
		// Re-parse from the raw bytes, as the interpreter will.
		parsed, err := x509.ParseCertificate(c.Raw)
		if err != nil {
			t.Fatal(err)
		}
		if len(parsed.UnhandledCriticalExtensions) != 0 {
			t.Errorf("cert %d: unhandled critical extensions %v", i+1, parsed.UnhandledCriticalExtensions)
		}
		want, err := mappingsFor(layers.Edges[i])
		if err != nil {
			t.Fatal(err)
		}
		if len(parsed.PolicyMappings) != len(want) {
			t.Errorf("cert %d: %d mappings, want %d", i+1, len(parsed.PolicyMappings), len(want))
			continue
		}
		for j, m := range parsed.PolicyMappings {
			if !m.IssuerDomainPolicy.Equal(want[j].IssuerDomainPolicy) || !m.SubjectDomainPolicy.Equal(want[j].SubjectDomainPolicy) {
				t.Errorf("cert %d mapping %d: %s -> %s, want %s -> %s", i+1, j,
					m.IssuerDomainPolicy, m.SubjectDomainPolicy, want[j].IssuerDomainPolicy, want[j].SubjectDomainPolicy)
			}
		}
		if err := parsed.CheckSignatureFrom(certs[i]); err != nil {
			t.Errorf("cert %d: %v", i+1, err)
		}
	}
	// The design's worked example: cert 1 maps the outer list to its three
	// elements, cert 2 maps the inner list to its three.
	if n := len(certs[1].PolicyMappings); n != 3 {
		t.Errorf("cert 1 has %d mappings, want 3", n)
	}
	if n := len(certs[2].PolicyMappings); n != 3 {
		t.Errorf("cert 2 has %d mappings, want 3", n)
	}
}

func TestMappingsRejectedOnLastCert(t *testing.T) {
	p, err := Options{Name: "x"}.profile()
	if err != nil {
		t.Fatal(err)
	}
	anchor, err := newAnchor(p)
	if err != nil {
		t.Fatal(err)
	}
	a, _ := x509.ParseOID("1.2.3")
	_, err = newCert(p, 1, true, nil, []x509.PolicyMapping{{IssuerDomainPolicy: a, SubjectDomainPolicy: a}}, anchor)
	if err == nil {
		t.Error("last cert accepted mappings")
	}
}

func TestCertificatePoliciesEncoding(t *testing.T) {
	type policyInformation struct{ ID asn1.ObjectIdentifier }
	want, err := asn1.Marshal([]policyInformation{{asn1.ObjectIdentifier{1, 2, 3}}, {asn1.ObjectIdentifier{2, 5, 29, 32, 0}}})
	if err != nil {
		t.Fatal(err)
	}
	ext, err := certificatePoliciesExtension([]policyInfo{{id: mustOID("1.2.3")}, {id: anyPolicy}})
	if err != nil {
		t.Fatal(err)
	}
	if !bytes.Equal(ext.Value, want) {
		t.Errorf("% x\nwant % x", ext.Value, want)
	}
	if !ext.Id.Equal(asn1.ObjectIdentifier{2, 5, 29, 32}) || ext.Critical {
		t.Errorf("extension %v critical=%v", ext.Id, ext.Critical)
	}
	if _, err := certificatePoliciesExtension(nil); err == nil {
		t.Error("empty certificatePolicies accepted; RFC 5280 requires at least one")
	}
}

func TestPoliciesSurviveParsing(t *testing.T) {
	certs, layers := buildChain(t, "(+ 1 (* 2 3)) x")
	if certs[0].Policies != nil {
		t.Error("the anchor has policies")
	}

	parsed, err := x509.ParseCertificate(certs[1].Raw)
	if err != nil {
		t.Fatal(err)
	}
	if len(parsed.Policies) != len(layers.Nodes[0]) {
		t.Fatalf("cert 1 has %d policies, want %d", len(parsed.Policies), len(layers.Nodes[0]))
	}
	for i, p := range parsed.Policies {
		want, _ := layers.Nodes[0][i].OID()
		if !p.Equal(want) {
			t.Errorf("cert 1 policy %d = %s, want %s", i, p, want)
		}
		// The 128-bit GOV arc survives the trip through hand-written DER
		// and Go's parser.
		if _, _, _, err := ast.DecodeOID(p); err != nil {
			t.Errorf("cert 1 policy %d: %v", i, err)
		}
	}

	for i := 2; i < len(certs); i++ {
		parsed, err := x509.ParseCertificate(certs[i].Raw)
		if err != nil {
			t.Fatal(err)
		}
		if len(parsed.Policies) != 1 || !parsed.Policies[0].Equal(anyPolicy) {
			t.Errorf("cert %d policies = %v, want only anyPolicy", i, parsed.Policies)
		}
	}
}