DateKeys/internal/cms/cert_test.go

package cms_test

import (
	"bytes"
	"crypto/sha256"
	"encoding/asn1"
	"testing"
	"time"

	"g.activething.com/go/DateKeys/internal/cms"
	"g.activething.com/go/DateKeys/internal/cms/cmstest"
)

// The profile of the certificate (spec §29.10): what a certificate made field
// by field gives, and each rule that a certificate can break.
func TestCertProfile(t *testing.T) {
	spec := cmstest.CertSpec{CN: "Ana López", From: time.Date(2021, 2, 3, 4, 5, 6, 0, time.UTC), To: time.Date(2051, 2, 3, 4, 5, 6, 0, time.UTC), Serial: cmstest.Int(0x1234)}
	s := cmstest.NewCert(spec, ecKey)
	c, err := cms.ParseCert(s.Cert.Raw)
	if err != nil {
		t.Fatal(err)
	}
	if c.Hash != sha256.Sum256(s.Cert.Raw) || !bytes.Equal(c.Raw, s.Cert.Raw) || !bytes.Equal(c.Serial, []byte{0x12, 0x34}) ||
		!bytes.Equal(c.RawIssuer, s.Cert.RawIssuer) || !bytes.Equal(c.RawSubject, s.Cert.RawIssuer) || !bytes.Equal(c.SKI, s.Cert.SubjectKeyId) ||
		!c.NotBefore.Equal(spec.From) || !c.NotAfter.Equal(spec.To) || !bytes.Equal(c.SPKI, cmstest.SPKI(ecKey.Public())) {
		t.Errorf("the fields: %+v", c)
	}
	// The validity is inclusive (RFC 5280 4.1.2.5).
	for at, want := range map[time.Time]bool{
		spec.From: true, spec.From.Add(-time.Nanosecond): false, spec.To: true, spec.To.Add(time.Nanosecond): false, now: true,
	} {
		if c.ValidAt(at) != want {
			t.Errorf("valid at %v: %v", at, !want)
		}
	}

	raw := s.Cert.Raw
	tbs := func(i int) []int { return []int{0, i} }
	time1 := cmstest.UTCTime("200101000000Z")
	for name, b := range map[string][]byte{
		"a SET":                                  cmstest.Edit(raw, cmstest.Retag(0x31)),
		"a fourth element":                       cmstest.Edit(raw, cmstest.Append(cmstest.Null())),
		"tbsCertificate as a SET":                cmstest.Edit(raw, cmstest.Retag(0x31), 0),
		"signatureAlgorithm as a SET":            cmstest.Edit(raw, cmstest.Retag(0x31), 1),
		"the signature as an OCTET STRING":       cmstest.Edit(raw, cmstest.Retag(0x04), 2),
		"no version: a certificate of v1":        cert(cmstest.CertSpec{NoVersion: true}),
		"version 1 with extensions":              cert(cmstest.CertSpec{NoVersion: true, After: [][]byte{cmstest.Null()}}),
		"the version written as 1":               cert(cmstest.CertSpec{Version: cmstest.TLV(0xa0, cmstest.Int(0))}),
		"the version written as 2":               cert(cmstest.CertSpec{Version: cmstest.TLV(0xa0, cmstest.Int(1))}),
		"the version as [1]":                     cert(cmstest.CertSpec{Version: cmstest.TLV(0xa1, cmstest.Int(2))}),
		"the version of two INTEGERs":            cert(cmstest.CertSpec{Version: cmstest.TLV(0xa0, cmstest.Int(2), cmstest.Int(2))}),
		"a tbsCertificate without its SPKI":      cmstest.Edit(raw, func(b []byte) []byte { return cmstest.Seq(cmstest.Children(b)[:6]...) }, 0),
		"the serial as an OCTET STRING":          cert(cmstest.CertSpec{Serial: cmstest.Octets([]byte{1})}),
		"the signature of tbs as a SET":          cmstest.Edit(raw, cmstest.Retag(0x31), tbs(2)...),
		"the issuer as a SET":                    cmstest.Edit(raw, cmstest.Retag(0x31), tbs(3)...),
		"the validity as a SET":                  cmstest.Edit(raw, cmstest.Retag(0x31), tbs(4)...),
		"the subject as a SET":                   cmstest.Edit(raw, cmstest.Retag(0x31), tbs(5)...),
		"the SPKI as a SET":                      cmstest.Edit(raw, cmstest.Retag(0x31), tbs(6)...),
		"a validity of three times":              cmstest.Edit(raw, cmstest.Append(time1), tbs(4)...),
		"a validity of one time":                 cmstest.Edit(raw, cmstest.Replace(cmstest.Seq(time1)), tbs(4)...),
		"notBefore with a fraction":              cert(cmstest.CertSpec{NotBefore: cmstest.GeneralizedTime("20200101000000.5Z")}),
		"notAfter with a fraction":               cert(cmstest.CertSpec{NotAfter: cmstest.GeneralizedTime("20391231235959.5Z")}),
		"notBefore an INTEGER":                   cert(cmstest.CertSpec{NotBefore: cmstest.Int(1)}),
		"notAfter that is not a time":            cert(cmstest.CertSpec{NotAfter: cmstest.UTCTime("not a time!!Z")}),
		"subjectUniqueID before issuerUniqueID":  cert(cmstest.CertSpec{UniqueIDs: [][]byte{cmstest.TLV(0x82, []byte{0, 2}), cmstest.TLV(0x81, []byte{0, 1})}}),
		"the extensions as [4]":                  cert(cmstest.CertSpec{NoExtensions: true, After: [][]byte{cmstest.TLV(0xa4, cmstest.Seq(cmstest.ExtKeyUsage()))}}),
		"an element after the extensions":        cert(cmstest.CertSpec{After: [][]byte{cmstest.Null()}}),
		"[3] of two SEQUENCEs":                   cert(cmstest.CertSpec{NoExtensions: true, After: [][]byte{cmstest.TLV(0xa3, cmstest.Seq(cmstest.ExtKeyUsage()), cmstest.Seq(cmstest.ExtKeyUsage()))}}),
		"[3] holding a SET":                      cert(cmstest.CertSpec{NoExtensions: true, After: [][]byte{cmstest.TLV(0xa3, cmstest.Set(0x31, cmstest.ExtKeyUsage()))}}),
		"an empty [3]":                           cert(cmstest.CertSpec{NoExtensions: true, After: [][]byte{cmstest.TLV(0xa3)}}),
		"no Extension":                           cert(cmstest.CertSpec{Extensions: [][]byte{}}),
		"an Extension as a SET":                  cert(cmstest.CertSpec{Extensions: [][]byte{cmstest.TLV(0x31, cmstest.OID(oidX), cmstest.Octets(nil))}}),
		"an Extension that is an INTEGER":        cert(cmstest.CertSpec{Extensions: [][]byte{cmstest.Int(1)}}),
		"an Extension of only its type":          cert(cmstest.CertSpec{Extensions: [][]byte{cmstest.Seq(cmstest.OID(oidX))}}),
		"an empty Extension":                     cert(cmstest.CertSpec{Extensions: [][]byte{cmstest.Seq()}}),
		"an Extension of four elements":          cert(cmstest.CertSpec{Extensions: [][]byte{cmstest.Seq(cmstest.OID(oidX), cmstest.Bool(true), cmstest.Octets(nil), cmstest.Octets(nil))}}),
		"an Extension whose type is an INTEGER":  cert(cmstest.CertSpec{Extensions: [][]byte{cmstest.Seq(cmstest.Int(1), cmstest.Octets(nil))}}),
		"an Extension whose value is not OCTETS": cert(cmstest.CertSpec{Extensions: [][]byte{cmstest.Seq(cmstest.OID(oidX), cmstest.BitString(nil))}}),
		"an Extension critical by an INTEGER":    cert(cmstest.CertSpec{Extensions: [][]byte{cmstest.Seq(cmstest.OID(oidX), cmstest.Int(1), cmstest.Octets(nil))}}),
		"an extension twice":                     cert(cmstest.CertSpec{Extensions: [][]byte{cmstest.ExtKeyUsage(), cmstest.ExtKeyUsage()}}),
		"subjectKeyIdentifier twice":             cert(cmstest.CertSpec{Extensions: [][]byte{cmstest.ExtSKI([]byte{1}), cmstest.ExtSKI([]byte{2})}}),
		"a subjectKeyIdentifier not in DER":      cert(cmstest.CertSpec{Extensions: [][]byte{cmstest.Extension(cmstest.OIDSKI, false, []byte{0x04, 0x01, 0x07, 0x00})}}),
		"a subjectKeyIdentifier an INTEGER":      cert(cmstest.CertSpec{Extensions: [][]byte{cmstest.Extension(cmstest.OIDSKI, false, cmstest.Int(7))}}),
		"an empty subjectKeyIdentifier":          cert(cmstest.CertSpec{Extensions: [][]byte{cmstest.ExtSKI(nil)}}),
		"a subjectKeyIdentifier of no bytes":     cert(cmstest.CertSpec{Extensions: [][]byte{cmstest.Extension(cmstest.OIDSKI, false, nil)}}),
	} {
		if _, err := cms.ParseCert(b); err == nil {
			t.Errorf("%s: accepted", name)
		}
	}
	// A name that breaks the profile, as the subject beside a good issuer,
	// and as the issuer beside a good subject.
	good := cmstest.Name(cmstest.ATV(cmstest.OIDCommonName, cmstest.UTF8("A")))
	for name, n := range map[string][]byte{
		"an RDN as a SEQUENCE":                 cmstest.NameOf(cmstest.Seq(cmstest.ATV(cmstest.OIDCommonName, cmstest.UTF8("A")))),
		"an empty RDN":                         cmstest.NameOf(cmstest.RDN()),
		"an RDN that is an INTEGER":            cmstest.NameOf(cmstest.Int(1)),
		"an AttributeTypeAndValue as a SET":    cmstest.NameOf(cmstest.RDN(cmstest.TLV(0x31, cmstest.OID(cmstest.OIDCommonName), cmstest.UTF8("A")))),
		"an AttributeTypeAndValue of three":    cmstest.NameOf(cmstest.RDN(cmstest.Seq(cmstest.OID(cmstest.OIDCommonName), cmstest.UTF8("A"), cmstest.Null()))),
		"an AttributeTypeAndValue of one":      cmstest.NameOf(cmstest.RDN(cmstest.Seq(cmstest.OID(cmstest.OIDCommonName)))),
		"an AttributeTypeAndValue primitive":   cmstest.NameOf(cmstest.RDN(cmstest.Int(3))),
		"an attribute type that is an INTEGER": cmstest.NameOf(cmstest.RDN(cmstest.Seq(cmstest.Int(3), cmstest.UTF8("A")))),
	} {
		if _, err := cms.ParseCert(cert(cmstest.CertSpec{Subject: n, Issuer: good})); err == nil {
			t.Errorf("the subject, %s: accepted", name)
		}
		if _, err := cms.ParseCert(cert(cmstest.CertSpec{Subject: good, Issuer: n})); err == nil {
			t.Errorf("the issuer, %s: accepted", name)
		}
	}
	// What the profile accepts: both unique identifiers, no extensions in a
	// certificate of version 3, a critical subjectKeyIdentifier, an unknown
	// extension, a GeneralizedTime before 2050, and any signature.
	for name, spec := range map[string]cmstest.CertSpec{
		"both unique identifiers":         {UniqueIDs: [][]byte{cmstest.TLV(0x81, []byte{0, 1}), cmstest.TLV(0x82, []byte{0, 2})}},
		"only subjectUniqueID":            {UniqueIDs: [][]byte{cmstest.TLV(0x82, []byte{0, 2})}, NoExtensions: true},
		"no extensions":                   {NoExtensions: true},
		"a critical subjectKeyIdentifier": {Extensions: [][]byte{cmstest.Extension(cmstest.OIDSKI, true, cmstest.Octets([]byte{9}))}},
		"an unknown extension":            {Extensions: [][]byte{cmstest.Extension(oidX, false, nil), cmstest.ExtSKI([]byte{9})}},
		"a GeneralizedTime in 2030":       {NotAfter: cmstest.GeneralizedTime("20300101000000Z")},
		"a signature that is no one's":    {Signature: cmstest.BitString([]byte("not a signature"))},
		"another signature algorithm":     {SigAlg: cmstest.AlgID(asn1.ObjectIdentifier{1, 2, 3}, cmstest.Int(7))},
		"an empty name":                   {Subject: cmstest.NameOf(), Issuer: cmstest.NameOf()},
	} {
		c, err := cms.ParseCert(cert(spec))
		if err != nil {
			t.Errorf("%s: %v", name, err)
			continue
		}
		if name == "a critical subjectKeyIdentifier" && !bytes.Equal(c.SKI, []byte{9}) || name == "no extensions" && c.SKI != nil {
			t.Errorf("%s: SKI %x", name, c.SKI)
		}
	}
}

var oidX = asn1.ObjectIdentifier{1, 2, 3, 4, 5}

// A NumericString is DER, and a certificate whose name holds one, as the INN
// of a Russian certificate, meets the profile: its value is no text, and the
// signature verifies (spec §29.10).
func TestNumericStringInName(t *testing.T) {
	inn := cmstest.ATV(asn1.ObjectIdentifier{1, 2, 643, 3, 131, 1, 1}, cmstest.Numeric("123456789012"))
	s := cmstest.NewCert(cmstest.CertSpec{Subject: cmstest.Name(cn(cmstest.UTF8("Ivan Petrov")), inn)}, ecKey)
	if si := signerOf(t, "a NumericString", cmstest.Signature(msg, cmstest.Options{}, s)); si.Check(msg) != cms.Valid || si.Cert.Holder() != "Ivan Petrov" {
		t.Errorf("a NumericString beside the commonName: %v %q", si.Check(msg), si.Cert.Holder())
	}
	if c := subject(cn(cmstest.Numeric("12345"))); c.Holder() != "" {
		t.Errorf("a commonName in a NumericString: %q", c.Holder())
	}
}

// cert returns the DER of the certificate of spec, of the key ecKey.
func cert(spec cmstest.CertSpec) []byte { return cmstest.NewCert(spec, ecKey).Cert.Raw }

// subject is a certificate of ecKey whose subject has the attributes given,
// each in a RelativeDistinguishedName of its own.
func subject(atvs ...[]byte) *cms.Cert {
	return parsed(cmstest.CertSpec{Subject: cmstest.Name(atvs...)})
}

func parsed(spec cmstest.CertSpec) *cms.Cert {
	c, err := cms.ParseCert(cert(spec))
	if err != nil {
		panic(err)
	}
	return c
}

func cn(v []byte) []byte      { return cmstest.ATV(cmstest.OIDCommonName, v) }
func given(v []byte) []byte   { return cmstest.ATV(cmstest.OIDGivenName, v) }
func surname(v []byte) []byte { return cmstest.ATV(cmstest.OIDSurname, v) }
func org(v []byte) []byte     { return cmstest.ATV(cmstest.OIDOrganization, v) }

// The text of a name (spec §29.10): only of the five string types, in their
// alphabets, nothing removed, never from an attribute that appears twice; and
// the holder (spec §29.7): givenName and surname before commonName.
func TestCertNames(t *testing.T) {
	utf8 := cmstest.UTF8
	for name, tc := range map[string]struct {
		c    *cms.Cert
		want string
	}{
		"a UTF8String":                              {subject(cn(utf8("Ana López"))), "Ana López"},
		"a UTF8String that is not UTF-8":            {subject(cn(utf8("Ana \xff"))), ""},
		"a UTF8String with a BOM, kept":             {subject(cn(utf8("\xef\xbb\xbfAna"))), "\xef\xbb\xbfAna"},
		"a PrintableString of its whole alphabet":   {subject(cn(cmstest.Printable("Ana O'Neil (1+2), x-y./:=? Z9"))), "Ana O'Neil (1+2), x-y./:=? Z9"},
		"a PrintableString with an underscore":      {subject(cn(cmstest.Printable("Ana_Lopez"))), ""},
		"a PrintableString with an at sign":         {subject(cn(cmstest.Printable("ana@example.com"))), ""},
		"a PrintableString with a tilde":            {subject(cn(cmstest.Printable("Ana~"))), ""},
		"a PrintableString with an ampersand":       {subject(cn(cmstest.Printable("A&B"))), ""},
		"a PrintableString with an asterisk":        {subject(cn(cmstest.Printable("A*B"))), ""},
		"a PrintableString with a byte of 0xe9":     {subject(cn(cmstest.Printable("L\xe9a"))), ""},
		"an IA5String":                              {subject(cn(cmstest.IA5("ana@example.com"))), "ana@example.com"},
		"an IA5String with a byte of 0x80":          {subject(cn(cmstest.IA5("Ana\x80"))), ""},
		"a TeletexString in ASCII":                  {subject(cn(cmstest.Teletex("Ana Lopez"))), "Ana Lopez"},
		"a TeletexString with a byte of 0xe9":       {subject(cn(cmstest.Teletex("L\xe9a"))), ""},
		"a BMPString":                               {subject(cn(cmstest.BMPText("Ana López"))), "Ana López"},
		"a BMPString above the surrogates":          {subject(cn(cmstest.BMPText("Ａna ￥"))), "Ａna ￥"},
		"a BMPString of odd length":                 {subject(cn(cmstest.BMP([]byte{0, 'A', 0}))), ""},
		"a BMPString with a surrogate pair":         {subject(cn(cmstest.BMPText("Ana \U0001F600"))), ""},
		"a BMPString with a low surrogate":          {subject(cn(cmstest.BMP([]byte{0, 'A', 0xdc, 0}))), ""},
		"a BMPString with a high surrogate":         {subject(cn(cmstest.BMP([]byte{0xd8, 0, 0, 'A'}))), ""},
		"a VisibleString":                           {subject(cn(cmstest.Visible("Ana"))), ""},
		"a UniversalString":                         {subject(cn(cmstest.TLV(0x1c, []byte{0, 0, 0, 'A'}))), ""},
		"a NumericString":                           {subject(cn(cmstest.Numeric("12345"))), ""},
		"two commonNames":                           {subject(cn(utf8("Ana")), cn(utf8("Luis"))), ""},
		"two commonNames in one RDN":                {parsed(cmstest.CertSpec{Subject: cmstest.NameOf(cmstest.RDN(cn(utf8("Ana")), cn(utf8("Luis"))))}), ""},
		"a commonName in an RDN of two attributes":  {parsed(cmstest.CertSpec{Subject: cmstest.NameOf(cmstest.RDN(org(utf8("Banco")), cn(utf8("Ana"))))}), "Ana"},
		"no commonName":                             {subject(org(utf8("Banco"))), ""},
		"givenName, surname and the NIF in the CN":  {subject(cn(utf8("ESPAÑOL ESPAÑOL JUAN - 12345678Z")), given(utf8("JUAN")), surname(utf8("ESPAÑOL ESPAÑOL"))), "JUAN ESPAÑOL ESPAÑOL"},
		"givenName and surname without a CN":        {subject(given(utf8("Ana")), surname(utf8("López"))), "Ana López"},
		"only a givenName":                          {subject(cn(utf8("Ana López")), given(utf8("Ana"))), "Ana López"},
		"only a surname":                            {subject(cn(utf8("Ana López")), surname(utf8("López"))), "Ana López"},
		"an empty givenName":                        {subject(cn(utf8("Ana López")), given(utf8("")), surname(utf8("López"))), "Ana López"},
		"an empty surname":                          {subject(cn(utf8("Ana López")), given(utf8("Ana")), surname(utf8(""))), "Ana López"},
		"a givenName that is not UTF-8":             {subject(cn(utf8("Ana López")), given(utf8("An\xff")), surname(utf8("López"))), "Ana López"},
		"a surname that is not UTF-8":               {subject(cn(utf8("Ana López")), given(utf8("Ana")), surname(utf8("L\xff"))), "Ana López"},
		"a givenName that is no text":               {subject(cn(utf8("Ana López")), given(cmstest.Visible("Ana")), surname(utf8("López"))), "Ana López"},
		"two givenNames":                            {subject(cn(utf8("Ana López")), given(utf8("Ana")), given(utf8("Eva")), surname(utf8("López"))), "Ana López"},
		"a givenName with an escape, not the CN":    {subject(cn(utf8("Ana López")), given(utf8("Ana\x1b")), surname(utf8("López"))), "Ana\x1b López"},
		"a commonName with an escape, kept as text": {subject(cn(utf8("Ana\x1b[31m"))), "Ana\x1b[31m"},
	} {
		if got := tc.c.Holder(); got != tc.want {
			t.Errorf("%s: holder %q, want %q", name, got, tc.want)
		}
	}
	// The issuer: its commonName, or its organizationName without one; ""
	// with neither, the caller showing then the hash of the name.
	issuer := func(atvs ...[]byte) *cms.Cert {
		return parsed(cmstest.CertSpec{Issuer: cmstest.Name(atvs...)})
	}
	for name, tc := range map[string]struct {
		c    *cms.Cert
		want string
	}{
		"a commonName":                          {issuer(org(utf8("Banco")), cn(utf8("CA de prueba"))), "CA de prueba"},
		"an organizationName without a CN":      {issuer(org(utf8("Banco S.A."))), "Banco S.A."},
		"a commonName with an escape, kept":     {issuer(org(utf8("Banco")), cn(utf8("CA\x1b"))), "CA\x1b"},
		"a commonName not UTF-8, then the O":    {issuer(org(utf8("Banco")), cn(utf8("C\xff"))), "Banco"},
		"two commonNames, then the O":           {issuer(org(utf8("Banco")), cn(utf8("A")), cn(utf8("B"))), "Banco"},
		"an organizationName that is not UTF-8": {issuer(org(utf8("B\xff"))), ""},
		"neither":                               {issuer(cmstest.ATV(cmstest.OIDCountry, cmstest.Printable("ES"))), ""},
		"an organizationName that is not text":  {issuer(org(cmstest.Visible("Banco"))), ""},
	} {
		if got := tc.c.IssuerName(); got != tc.want {
			t.Errorf("issuer, %s: %q, want %q", name, got, tc.want)
		}
	}
}