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