@ de62e8f8076f6010f59527991dbc61d7625a603e | history
package lisp2gov
import (
"bytes"
"crypto/x509"
"encoding/asn1"
"testing"
"government/ast"
"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")
}
}
// buildChain makes the full chain for src by hand, ahead of Compile in
// step 22: cert 1 lists the top-level nodes, the rest assert anyPolicy,
// and every cert but the last carries its layer's mappings.
func buildChain(t *testing.T, src string) ([]*x509.Certificate, ast.Layers) {
t.Helper()
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)
}
anyPolicy, _ := x509.ParseOID("2.5.29.32.0")
prev, err := newAnchor(DefaultSeed, "mappings")
if err != nil {
t.Fatal(err)
}
certs := []*x509.Certificate{prev.cert}
n := layers.Depth()
for i := 1; i <= n; i++ {
policies := []x509.OID{anyPolicy}
if i == 1 {
policies = nil
for _, node := range layers.Nodes[0] {
oid, err := node.OID()
if err != nil {
t.Fatal(err)
}
policies = append(policies, oid)
}
}
mappings, err := mappingsFor(layers.Edges[i-1])
if err != nil {
t.Fatal(err)
}
next, err := newCert(DefaultSeed, "mappings", i, i == n, policies, mappings, prev)
if err != nil {
t.Fatal(err)
}
certs = append(certs, next.cert)
prev = next
}
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) {
anchor, err := newAnchor(DefaultSeed, "x")
if err != nil {
t.Fatal(err)
}
a, _ := x509.ParseOID("1.2.3")
_, err = newCert(DefaultSeed, "x", 1, true, nil, []x509.PolicyMapping{{IssuerDomainPolicy: a, SubjectDomainPolicy: a}}, anchor)
if err == nil {
t.Error("last cert accepted mappings")
}
}