@ 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)
}
}
}