src/crypto/x509/x509_test.go

   1 // Copyright 2009 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package x509
   6
   7 import (
   8         "bytes"
   9         "crypto"
  10         "crypto/dsa"
  11         "crypto/ecdh"
  12         "crypto/ecdsa"
  13         "crypto/ed25519"
  14         "crypto/elliptic"
  15         "crypto/rand"
  16         "crypto/rsa"
  17         _ "crypto/sha256"
  18         _ "crypto/sha512"
  19         "crypto/x509/pkix"
  20         "encoding/asn1"
  21         "encoding/base64"
  22         "encoding/hex"
  23         "encoding/pem"
  24         "fmt"
  25         "internal/testenv"
  26         "io"
  27         "math"
  28         "math/big"
  29         "net"
  30         "net/url"
  31         "os/exec"
  32         "reflect"
  33         "runtime"
  34         "slices"
  35         "strings"
  36         "testing"
  37         "time"
  38 )
  39
  40 func TestParsePKCS1PrivateKey(t *testing.T) {
  41         block, _ := pem.Decode([]byte(pemPrivateKey))
  42         priv, err := ParsePKCS1PrivateKey(block.Bytes)
  43         if err != nil {
  44                 t.Errorf("Failed to parse private key: %s", err)
  45                 return
  46         }
  47         if priv.PublicKey.N.Cmp(rsaPrivateKey.PublicKey.N) != 0 ||
  48                 priv.PublicKey.E != rsaPrivateKey.PublicKey.E ||
  49                 priv.D.Cmp(rsaPrivateKey.D) != 0 ||
  50                 priv.Primes[0].Cmp(rsaPrivateKey.Primes[0]) != 0 ||
  51                 priv.Primes[1].Cmp(rsaPrivateKey.Primes[1]) != 0 {
  52                 t.Errorf("got:%+v want:%+v", priv, rsaPrivateKey)
  53         }
  54
  55         // This private key includes an invalid prime that
  56         // rsa.PrivateKey.Validate should reject.
  57         data := []byte("0\x16\x02\x00\x02\x02\u007f\x00\x02\x0200\x02\x0200\x02\x02\x00\x01\x02\x02\u007f\x00")
  58         if _, err := ParsePKCS1PrivateKey(data); err == nil {
  59                 t.Errorf("parsing invalid private key did not result in an error")
  60         }
  61 }
  62
  63 func TestPKCS1MismatchPublicKeyFormat(t *testing.T) {
  64
  65         const pkixPublicKey = "30820122300d06092a864886f70d01010105000382010f003082010a0282010100dd5a0f37d3ca5232852ccc0e81eebec270e2f2c6c44c6231d852971a0aad00aa7399e9b9de444611083c59ea919a9d76c20a7be131a99045ec19a7bb452d647a72429e66b87e28be9e8187ed1d2a2a01ef3eb2360706bd873b07f2d1f1a72337aab5ec94e983e39107f52c480d404915e84d75a3db2cfd601726a128cb1d7f11492d4bdb53272e652276667220795c709b8a9b4af6489cbf48bb8173b8fb607c834a71b6e8bf2d6aab82af3c8ad7ce16d8dcf58373a6edc427f7484d09744d4c08f4e19ed07adbf6cb31243bc5d0d1145e77a08a6fc5efd208eca67d6abf2d6f38f58b6fdd7c28774fb0cc03fc4935c6e074842d2e1479d3d8787249258719f90203010001"
  66         const errorContains = "use ParsePKIXPublicKey instead"
  67         derBytes, _ := hex.DecodeString(pkixPublicKey)
  68         _, err := ParsePKCS1PublicKey(derBytes)
  69         if !strings.Contains(err.Error(), errorContains) {
  70                 t.Errorf("expected error containing %q, got %s", errorContains, err)
  71         }
  72 }
  73
  74 func TestMarshalInvalidPublicKey(t *testing.T) {
  75         _, err := MarshalPKIXPublicKey(&ecdsa.PublicKey{})
  76         if err == nil {
  77                 t.Errorf("expected error, got MarshalPKIXPublicKey success")
  78         }
  79         _, err = MarshalPKIXPublicKey(&ecdsa.PublicKey{
  80                 Curve: elliptic.P256(),
  81                 X:     big.NewInt(1), Y: big.NewInt(2),
  82         })
  83         if err == nil {
  84                 t.Errorf("expected error, got MarshalPKIXPublicKey success")
  85         }
  86 }
  87
  88 func testParsePKIXPublicKey(t *testing.T, pemBytes string) (pub any) {
  89         block, _ := pem.Decode([]byte(pemBytes))
  90         pub, err := ParsePKIXPublicKey(block.Bytes)
  91         if err != nil {
  92                 t.Fatalf("Failed to parse public key: %s", err)
  93         }
  94
  95         pubBytes2, err := MarshalPKIXPublicKey(pub)
  96         if err != nil {
  97                 t.Errorf("Failed to marshal public key for the second time: %s", err)
  98                 return
  99         }
 100         if !bytes.Equal(pubBytes2, block.Bytes) {
 101                 t.Errorf("Reserialization of public key didn't match. got %x, want %x", pubBytes2, block.Bytes)
 102         }
 103         return
 104 }
 105
 106 func TestParsePKIXPublicKey(t *testing.T) {
 107         t.Run("RSA", func(t *testing.T) {
 108                 pub := testParsePKIXPublicKey(t, pemPublicKey)
 109                 _, ok := pub.(*rsa.PublicKey)
 110                 if !ok {
 111                         t.Errorf("Value returned from ParsePKIXPublicKey was not an RSA public key")
 112                 }
 113         })
 114         t.Run("Ed25519", func(t *testing.T) {
 115                 pub := testParsePKIXPublicKey(t, pemEd25519Key)
 116                 _, ok := pub.(ed25519.PublicKey)
 117                 if !ok {
 118                         t.Errorf("Value returned from ParsePKIXPublicKey was not an Ed25519 public key")
 119                 }
 120         })
 121         t.Run("X25519", func(t *testing.T) {
 122                 pub := testParsePKIXPublicKey(t, pemX25519Key)
 123                 k, ok := pub.(*ecdh.PublicKey)
 124                 if !ok || k.Curve() != ecdh.X25519() {
 125                         t.Errorf("Value returned from ParsePKIXPublicKey was not an X25519 public key")
 126                 }
 127         })
 128 }
 129
 130 var pemPublicKey = `-----BEGIN PUBLIC KEY-----
 131 MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA3VoPN9PKUjKFLMwOge6+
 132 wnDi8sbETGIx2FKXGgqtAKpzmem53kRGEQg8WeqRmp12wgp74TGpkEXsGae7RS1k
 133 enJCnma4fii+noGH7R0qKgHvPrI2Bwa9hzsH8tHxpyM3qrXslOmD45EH9SxIDUBJ
 134 FehNdaPbLP1gFyahKMsdfxFJLUvbUycuZSJ2ZnIgeVxwm4qbSvZInL9Iu4FzuPtg
 135 fINKcbbovy1qq4KvPIrXzhbY3PWDc6btxCf3SE0JdE1MCPThntB62/bLMSQ7xdDR
 136 FF53oIpvxe/SCOymfWq/LW849Ytv3Xwod0+wzAP8STXG4HSELS4UedPYeHJJJYcZ
 137 +QIDAQAB
 138 -----END PUBLIC KEY-----
 139 `
 140
 141 var pemPrivateKey = testingKey(`
 142 -----BEGIN RSA TESTING KEY-----
 143 MIICXAIBAAKBgQCxoeCUW5KJxNPxMp+KmCxKLc1Zv9Ny+4CFqcUXVUYH69L3mQ7v
 144 IWrJ9GBfcaA7BPQqUlWxWM+OCEQZH1EZNIuqRMNQVuIGCbz5UQ8w6tS0gcgdeGX7
 145 J7jgCQ4RK3F/PuCM38QBLaHx988qG8NMc6VKErBjctCXFHQt14lerd5KpQIDAQAB
 146 AoGAYrf6Hbk+mT5AI33k2Jt1kcweodBP7UkExkPxeuQzRVe0KVJw0EkcFhywKpr1
 147 V5eLMrILWcJnpyHE5slWwtFHBG6a5fLaNtsBBtcAIfqTQ0Vfj5c6SzVaJv0Z5rOd
 148 7gQF6isy3t3w9IF3We9wXQKzT6q5ypPGdm6fciKQ8RnzREkCQQDZwppKATqQ41/R
 149 vhSj90fFifrGE6aVKC1hgSpxGQa4oIdsYYHwMzyhBmWW9Xv/R+fPyr8ZwPxp2c12
 150 33QwOLPLAkEA0NNUb+z4ebVVHyvSwF5jhfJxigim+s49KuzJ1+A2RaSApGyBZiwS
 151 rWvWkB471POAKUYt5ykIWVZ83zcceQiNTwJBAMJUFQZX5GDqWFc/zwGoKkeR49Yi
 152 MTXIvf7Wmv6E++eFcnT461FlGAUHRV+bQQXGsItR/opIG7mGogIkVXa3E1MCQARX
 153 AAA7eoZ9AEHflUeuLn9QJI/r0hyQQLEtrpwv6rDT1GCWaLII5HJ6NUFVf4TTcqxo
 154 6vdM4QGKTJoO+SaCyP0CQFdpcxSAuzpFcKv0IlJ8XzS/cy+mweCMwyJ1PFEc4FX6
 155 wg/HcAJWY60xZTJDFN+Qfx8ZQvBEin6c2/h+zZi5IVY=
 156 -----END RSA TESTING KEY-----
 157 `)
 158
 159 // pemEd25519Key is the example from RFC 8410, Section 4.
 160 var pemEd25519Key = `
 161 -----BEGIN PUBLIC KEY-----
 162 MCowBQYDK2VwAyEAGb9ECWmEzf6FQbrBZ9w7lshQhqowtrbLDFw4rXAxZuE=
 163 -----END PUBLIC KEY-----
 164 `
 165
 166 // pemX25519Key was generated from pemX25519Key with "openssl pkey -pubout".
 167 var pemX25519Key = `
 168 -----BEGIN PUBLIC KEY-----
 169 MCowBQYDK2VuAyEA5yGXrH/6OzxuWEhEWS01/f4OP+Of3Yrddy6/J1kDTVM=
 170 -----END PUBLIC KEY-----
 171 `
 172
 173 func TestPKIXMismatchPublicKeyFormat(t *testing.T) {
 174
 175         const pkcs1PublicKey = "308201080282010100817cfed98bcaa2e2a57087451c7674e0c675686dc33ff1268b0c2a6ee0202dec710858ee1c31bdf5e7783582e8ca800be45f3275c6576adc35d98e26e95bb88ca5beb186f853b8745d88bc9102c5f38753bcda519fb05948d5c77ac429255ff8aaf27d9f45d1586e95e2e9ba8a7cb771b8a09dd8c8fed3f933fd9b439bc9f30c475953418ef25f71a2b6496f53d94d39ce850aa0cc75d445b5f5b4f4ee4db78ab197a9a8d8a852f44529a007ac0ac23d895928d60ba538b16b0b087a7f903ed29770e215019b77eaecc360f35f7ab11b6d735978795b2c4a74e5bdea4dc6594cd67ed752a108e666729a753ab36d6c4f606f8760f507e1765be8cd744007e629020103"
 176         const errorContains = "use ParsePKCS1PublicKey instead"
 177         derBytes, _ := hex.DecodeString(pkcs1PublicKey)
 178         _, err := ParsePKIXPublicKey(derBytes)
 179         if !strings.Contains(err.Error(), errorContains) {
 180                 t.Errorf("expected error containing %q, got %s", errorContains, err)
 181         }
 182 }
 183
 184 var testPrivateKey *rsa.PrivateKey
 185
 186 func init() {
 187         block, _ := pem.Decode([]byte(pemPrivateKey))
 188
 189         var err error
 190         if testPrivateKey, err = ParsePKCS1PrivateKey(block.Bytes); err != nil {
 191                 panic("Failed to parse private key: " + err.Error())
 192         }
 193 }
 194
 195 func bigFromString(s string) *big.Int {
 196         ret := new(big.Int)
 197         ret.SetString(s, 10)
 198         return ret
 199 }
 200
 201 func fromBase10(base10 string) *big.Int {
 202         i := new(big.Int)
 203         i.SetString(base10, 10)
 204         return i
 205 }
 206
 207 func bigFromHexString(s string) *big.Int {
 208         ret := new(big.Int)
 209         ret.SetString(s, 16)
 210         return ret
 211 }
 212
 213 var rsaPrivateKey = &rsa.PrivateKey{
 214         PublicKey: rsa.PublicKey{
 215                 N: bigFromString("124737666279038955318614287965056875799409043964547386061640914307192830334599556034328900586693254156136128122194531292927142396093148164407300419162827624945636708870992355233833321488652786796134504707628792159725681555822420087112284637501705261187690946267527866880072856272532711620639179596808018872997"),
 216                 E: 65537,
 217         },
 218         D: bigFromString("69322600686866301945688231018559005300304807960033948687567105312977055197015197977971637657636780793670599180105424702854759606794705928621125408040473426339714144598640466128488132656829419518221592374964225347786430566310906679585739468938549035854760501049443920822523780156843263434219450229353270690889"),
 219         Primes: []*big.Int{
 220                 bigFromString("11405025354575369741595561190164746858706645478381139288033759331174478411254205003127028642766986913445391069745480057674348716675323735886284176682955723"),
 221                 bigFromString("10937079261204603443118731009201819560867324167189758120988909645641782263430128449826989846631183550578761324239709121189827307416350485191350050332642639"),
 222         },
 223 }
 224
 225 func TestMarshalRSAPrivateKey(t *testing.T) {
 226         priv := &rsa.PrivateKey{
 227                 PublicKey: rsa.PublicKey{
 228                         N: fromBase10("16346378922382193400538269749936049106320265317511766357599732575277382844051791096569333808598921852351577762718529818072849191122419410612033592401403764925096136759934497687765453905884149505175426053037420486697072448609022753683683718057795566811401938833367954642951433473337066311978821180526439641496973296037000052546108507805269279414789035461158073156772151892452251106173507240488993608650881929629163465099476849643165682709047462010581308719577053905787496296934240246311806555924593059995202856826239801816771116902778517096212527979497399966526283516447337775509777558018145573127308919204297111496233"),
 229                         E: 3,
 230                 },
 231                 D: fromBase10("10897585948254795600358846499957366070880176878341177571733155050184921896034527397712889205732614568234385175145686545381899460748279607074689061600935843283397424506622998458510302603922766336783617368686090042765718290914099334449154829375179958369993407724946186243249568928237086215759259909861748642124071874879861299389874230489928271621259294894142840428407196932444474088857746123104978617098858619445675532587787023228852383149557470077802718705420275739737958953794088728369933811184572620857678792001136676902250566845618813972833750098806496641114644760255910789397593428910198080271317419213080834885003"),
 232                 Primes: []*big.Int{
 233                         fromBase10("1025363189502892836833747188838978207017355117492483312747347695538428729137306368764177201532277413433182799108299960196606011786562992097313508180436744488171474690412562218914213688661311117337381958560443"),
 234                         fromBase10("3467903426626310123395340254094941045497208049900750380025518552334536945536837294961497712862519984786362199788654739924501424784631315081391467293694361474867825728031147665777546570788493758372218019373"),
 235                         fromBase10("4597024781409332673052708605078359346966325141767460991205742124888960305710298765592730135879076084498363772408626791576005136245060321874472727132746643162385746062759369754202494417496879741537284589047"),
 236                 },
 237         }
 238
 239         derBytes := MarshalPKCS1PrivateKey(priv)
 240
 241         priv2, err := ParsePKCS1PrivateKey(derBytes)
 242         if err != nil {
 243                 t.Errorf("error parsing serialized key: %s", err)
 244                 return
 245         }
 246         if priv.PublicKey.N.Cmp(priv2.PublicKey.N) != 0 ||
 247                 priv.PublicKey.E != priv2.PublicKey.E ||
 248                 priv.D.Cmp(priv2.D) != 0 ||
 249                 len(priv2.Primes) != 3 ||
 250                 priv.Primes[0].Cmp(priv2.Primes[0]) != 0 ||
 251                 priv.Primes[1].Cmp(priv2.Primes[1]) != 0 ||
 252                 priv.Primes[2].Cmp(priv2.Primes[2]) != 0 {
 253                 t.Errorf("got:%+v want:%+v", priv, priv2)
 254         }
 255 }
 256
 257 func TestMarshalRSAPublicKey(t *testing.T) {
 258         pub := &rsa.PublicKey{
 259                 N: fromBase10("16346378922382193400538269749936049106320265317511766357599732575277382844051791096569333808598921852351577762718529818072849191122419410612033592401403764925096136759934497687765453905884149505175426053037420486697072448609022753683683718057795566811401938833367954642951433473337066311978821180526439641496973296037000052546108507805269279414789035461158073156772151892452251106173507240488993608650881929629163465099476849643165682709047462010581308719577053905787496296934240246311806555924593059995202856826239801816771116902778517096212527979497399966526283516447337775509777558018145573127308919204297111496233"),
 260                 E: 3,
 261         }
 262         derBytes := MarshalPKCS1PublicKey(pub)
 263         pub2, err := ParsePKCS1PublicKey(derBytes)
 264         if err != nil {
 265                 t.Errorf("ParsePKCS1PublicKey: %s", err)
 266         }
 267         if pub.N.Cmp(pub2.N) != 0 || pub.E != pub2.E {
 268                 t.Errorf("ParsePKCS1PublicKey = %+v, want %+v", pub, pub2)
 269         }
 270
 271         // It's never been documented that asn1.Marshal/Unmarshal on rsa.PublicKey works,
 272         // but it does, and we know of code that depends on it.
 273         // Lock that in, even though we'd prefer that people use MarshalPKCS1PublicKey and ParsePKCS1PublicKey.
 274         derBytes2, err := asn1.Marshal(*pub)
 275         if err != nil {
 276                 t.Errorf("Marshal(rsa.PublicKey): %v", err)
 277         } else if !bytes.Equal(derBytes, derBytes2) {
 278                 t.Errorf("Marshal(rsa.PublicKey) = %x, want %x", derBytes2, derBytes)
 279         }
 280         pub3 := new(rsa.PublicKey)
 281         rest, err := asn1.Unmarshal(derBytes, pub3)
 282         if err != nil {
 283                 t.Errorf("Unmarshal(rsa.PublicKey): %v", err)
 284         }
 285         if len(rest) != 0 || pub.N.Cmp(pub3.N) != 0 || pub.E != pub3.E {
 286                 t.Errorf("Unmarshal(rsa.PublicKey) = %+v, %q want %+v, %q", pub, rest, pub2, []byte(nil))
 287         }
 288
 289         publicKeys := []struct {
 290                 derBytes          []byte
 291                 expectedErrSubstr string
 292         }{
 293                 {
 294                         derBytes: []byte{
 295                                 0x30, 6, // SEQUENCE, 6 bytes
 296                                 0x02, 1, // INTEGER, 1 byte
 297                                 17,
 298                                 0x02, 1, // INTEGER, 1 byte
 299                                 3, // 3
 300                         },
 301                 }, {
 302                         derBytes: []byte{
 303                                 0x30, 6, // SEQUENCE
 304                                 0x02, 1, // INTEGER, 1 byte
 305                                 0xff,    // -1
 306                                 0x02, 1, // INTEGER, 1 byte
 307                                 3,
 308                         },
 309                         expectedErrSubstr: "zero or negative",
 310                 }, {
 311                         derBytes: []byte{
 312                                 0x30, 6, // SEQUENCE
 313                                 0x02, 1, // INTEGER, 1 byte
 314                                 17,
 315                                 0x02, 1, // INTEGER, 1 byte
 316                                 0xff, // -1
 317                         },
 318                         expectedErrSubstr: "zero or negative",
 319                 }, {
 320                         derBytes: []byte{
 321                                 0x30, 6, // SEQUENCE
 322                                 0x02, 1, // INTEGER, 1 byte
 323                                 17,
 324                                 0x02, 1, // INTEGER, 1 byte
 325                                 3,
 326                                 1,
 327                         },
 328                         expectedErrSubstr: "trailing data",
 329                 }, {
 330                         derBytes: []byte{
 331                                 0x30, 9, // SEQUENCE
 332                                 0x02, 1, // INTEGER, 1 byte
 333                                 17,
 334                                 0x02, 4, // INTEGER, 4 bytes
 335                                 0x7f, 0xff, 0xff, 0xff,
 336                         },
 337                 }, {
 338                         derBytes: []byte{
 339                                 0x30, 10, // SEQUENCE
 340                                 0x02, 1, // INTEGER, 1 byte
 341                                 17,
 342                                 0x02, 5, // INTEGER, 5 bytes
 343                                 0x00, 0x80, 0x00, 0x00, 0x00,
 344                         },
 345                         // On 64-bit systems, encoding/asn1 will accept the
 346                         // public exponent, but ParsePKCS1PublicKey will return
 347                         // an error. On 32-bit systems, encoding/asn1 will
 348                         // return the error. The common substring of both error
 349                         // is the word “large”.
 350                         expectedErrSubstr: "large",
 351                 },
 352         }
 353
 354         for i, test := range publicKeys {
 355                 shouldFail := len(test.expectedErrSubstr) > 0
 356                 pub, err := ParsePKCS1PublicKey(test.derBytes)
 357                 if shouldFail {
 358                         if err == nil {
 359                                 t.Errorf("#%d: unexpected success, got %#v", i, pub)
 360                         } else if !strings.Contains(err.Error(), test.expectedErrSubstr) {
 361                                 t.Errorf("#%d: expected error containing %q, got %s", i, test.expectedErrSubstr, err)
 362                         }
 363                 } else {
 364                         if err != nil {
 365                                 t.Errorf("#%d: unexpected failure: %s", i, err)
 366                                 continue
 367                         }
 368                         reserialized := MarshalPKCS1PublicKey(pub)
 369                         if !bytes.Equal(reserialized, test.derBytes) {
 370                                 t.Errorf("#%d: failed to reserialize: got %x, expected %x", i, reserialized, test.derBytes)
 371                         }
 372                 }
 373         }
 374 }
 375
 376 type matchHostnamesTest struct {
 377         pattern, host string
 378         ok            bool
 379 }
 380
 381 var matchHostnamesTests = []matchHostnamesTest{
 382         {"a.b.c", "a.b.c", true},
 383         {"a.b.c", "b.b.c", false},
 384         {"", "b.b.c", false},
 385         {"a.b.c", "", false},
 386         {"example.com", "example.com", true},
 387         {"example.com", "www.example.com", false},
 388         {"*.example.com", "example.com", false},
 389         {"*.example.com", "www.example.com", true},
 390         {"*.example.com", "www.example.com.", true},
 391         {"*.example.com", "xyz.www.example.com", false},
 392         {"*.example.com", "https://www.example.com", false}, // Issue 27591
 393         {"*.example..com", "www.example..com", false},
 394         {"www.example..com", "www.example..com", true},
 395         {"*.*.example.com", "xyz.www.example.com", false},
 396         {"*.www.*.com", "xyz.www.example.com", false},
 397         {"*bar.example.com", "foobar.example.com", false},
 398         {"f*.example.com", "foobar.example.com", false},
 399         {"www.example.com", "*.example.com", false},
 400         {"", ".", false},
 401         {".", "", false},
 402         {".", ".", false},
 403         {"example.com", "example.com.", true},
 404         {"example.com.", "example.com", false},
 405         {"example.com.", "example.com.", true}, // perfect matches allow trailing dots in patterns
 406         {"*.com.", "example.com.", false},
 407         {"*.com.", "example.com", false},
 408         {"*.com", "example.com", true},
 409         {"*.com", "example.com.", true},
 410         {"foo:bar", "foo:bar", true},
 411         {"*.foo:bar", "xxx.foo:bar", false},
 412         {"*.2.3.4", "1.2.3.4", false},
 413         {"*.2.3.4", "[1.2.3.4]", false},
 414         {"*:4860:4860::8888", "2001:4860:4860::8888", false},
 415         {"*:4860:4860::8888", "[2001:4860:4860::8888]", false},
 416         {"2001:4860:4860::8888", "2001:4860:4860::8888", false},
 417         {"2001:4860:4860::8888", "[2001:4860:4860::8888]", false},
 418         {"[2001:4860:4860::8888]", "2001:4860:4860::8888", false},
 419         {"[2001:4860:4860::8888]", "[2001:4860:4860::8888]", false},
 420 }
 421
 422 func TestMatchHostnames(t *testing.T) {
 423         for i, test := range matchHostnamesTests {
 424                 c := &Certificate{DNSNames: []string{test.pattern}}
 425                 r := c.VerifyHostname(test.host) == nil
 426                 if r != test.ok {
 427                         t.Errorf("#%d mismatch got: %t want: %t when matching '%s' against '%s'", i, r, test.ok, test.host, test.pattern)
 428                 }
 429         }
 430 }
 431
 432 func TestMatchIP(t *testing.T) {
 433         // Check that pattern matching is working.
 434         c := &Certificate{
 435                 DNSNames: []string{"*.foo.bar.baz"},
 436                 Subject: pkix.Name{
 437                         CommonName: "*.foo.bar.baz",
 438                 },
 439         }
 440         err := c.VerifyHostname("quux.foo.bar.baz")
 441         if err != nil {
 442                 t.Fatalf("VerifyHostname(quux.foo.bar.baz): %v", err)
 443         }
 444
 445         // But check that if we change it to be matching against an IP address,
 446         // it is rejected.
 447         c = &Certificate{
 448                 DNSNames: []string{"*.2.3.4"},
 449                 Subject: pkix.Name{
 450                         CommonName: "*.2.3.4",
 451                 },
 452         }
 453         err = c.VerifyHostname("1.2.3.4")
 454         if err == nil {
 455                 t.Fatalf("VerifyHostname(1.2.3.4) should have failed, did not")
 456         }
 457
 458         c = &Certificate{
 459                 IPAddresses: []net.IP{net.ParseIP("127.0.0.1"), net.ParseIP("::1")},
 460         }
 461         err = c.VerifyHostname("127.0.0.1")
 462         if err != nil {
 463                 t.Fatalf("VerifyHostname(127.0.0.1): %v", err)
 464         }
 465         err = c.VerifyHostname("::1")
 466         if err != nil {
 467                 t.Fatalf("VerifyHostname(::1): %v", err)
 468         }
 469         err = c.VerifyHostname("[::1]")
 470         if err != nil {
 471                 t.Fatalf("VerifyHostname([::1]): %v", err)
 472         }
 473 }
 474
 475 func TestCertificateParse(t *testing.T) {
 476         s, _ := base64.StdEncoding.DecodeString(certBytes)
 477         certs, err := ParseCertificates(s)
 478         if err != nil {
 479                 t.Error(err)
 480         }
 481         if len(certs) != 2 {
 482                 t.Errorf("Wrong number of certs: got %d want 2", len(certs))
 483                 return
 484         }
 485
 486         err = certs[0].CheckSignatureFrom(certs[1])
 487         if err != nil {
 488                 t.Error(err)
 489         }
 490
 491         if err := certs[0].VerifyHostname("mail.google.com"); err != nil {
 492                 t.Error(err)
 493         }
 494
 495         const expectedExtensions = 10
 496         if n := len(certs[0].Extensions); n != expectedExtensions {
 497                 t.Errorf("want %d extensions, got %d", expectedExtensions, n)
 498         }
 499 }
 500
 501 func TestCertificateEqualOnNil(t *testing.T) {
 502         cNonNil := new(Certificate)
 503         var cNil1, cNil2 *Certificate
 504         if !cNil1.Equal(cNil2) {
 505                 t.Error("Nil certificates: cNil1 is not equal to cNil2")
 506         }
 507         if !cNil2.Equal(cNil1) {
 508                 t.Error("Nil certificates: cNil2 is not equal to cNil1")
 509         }
 510         if cNil1.Equal(cNonNil) {
 511                 t.Error("Unexpectedly cNil1 is equal to cNonNil")
 512         }
 513         if cNonNil.Equal(cNil1) {
 514                 t.Error("Unexpectedly cNonNil is equal to cNil1")
 515         }
 516 }
 517
 518 func TestMismatchedSignatureAlgorithm(t *testing.T) {
 519         der, _ := pem.Decode([]byte(rsaPSSSelfSignedPEM))
 520         if der == nil {
 521                 t.Fatal("Failed to find PEM block")
 522         }
 523
 524         cert, err := ParseCertificate(der.Bytes)
 525         if err != nil {
 526                 t.Fatal(err)
 527         }
 528
 529         if err = cert.CheckSignature(ECDSAWithSHA256, nil, nil); err == nil {
 530                 t.Fatal("CheckSignature unexpectedly return no error")
 531         }
 532
 533         const expectedSubstring = " but have public key of type "
 534         if !strings.Contains(err.Error(), expectedSubstring) {
 535                 t.Errorf("Expected error containing %q, but got %q", expectedSubstring, err)
 536         }
 537 }
 538
 539 var certBytes = "MIIE0jCCA7qgAwIBAgIQWcvS+TTB3GwCAAAAAGEAWzANBgkqhkiG9w0BAQsFADBCMQswCQYD" +
 540         "VQQGEwJVUzEeMBwGA1UEChMVR29vZ2xlIFRydXN0IFNlcnZpY2VzMRMwEQYDVQQDEwpHVFMg" +
 541         "Q0EgMU8xMB4XDTIwMDQwMTEyNTg1NloXDTIwMDYyNDEyNTg1NlowaTELMAkGA1UEBhMCVVMx" +
 542         "EzARBgNVBAgTCkNhbGlmb3JuaWExFjAUBgNVBAcTDU1vdW50YWluIFZpZXcxEzARBgNVBAoT" +
 543         "Ckdvb2dsZSBMTEMxGDAWBgNVBAMTD21haWwuZ29vZ2xlLmNvbTBZMBMGByqGSM49AgEGCCqG" +
 544         "SM49AwEHA0IABO+dYiPnkFl+cZVf6mrWeNp0RhQcJSBGH+sEJxjvc+cYlW3QJCnm57qlpFdd" +
 545         "pz3MPyVejvXQdM6iI1mEWP4C2OujggJmMIICYjAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAww" +
 546         "CgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAdBgNVHQ4EFgQUI6pZhnQ/lQgmPDwSKR2A54G7" +
 547         "AS4wHwYDVR0jBBgwFoAUmNH4bhDrz5vsYJ8YkBug630J/SswZAYIKwYBBQUHAQEEWDBWMCcG" +
 548         "CCsGAQUFBzABhhtodHRwOi8vb2NzcC5wa2kuZ29vZy9ndHMxbzEwKwYIKwYBBQUHMAKGH2h0" +
 549         "dHA6Ly9wa2kuZ29vZy9nc3IyL0dUUzFPMS5jcnQwLAYDVR0RBCUwI4IPbWFpbC5nb29nbGUu" +
 550         "Y29tghBpbmJveC5nb29nbGUuY29tMCEGA1UdIAQaMBgwCAYGZ4EMAQICMAwGCisGAQQB1nkC" +
 551         "BQMwLwYDVR0fBCgwJjAkoCKgIIYeaHR0cDovL2NybC5wa2kuZ29vZy9HVFMxTzEuY3JsMIIB" +
 552         "AwYKKwYBBAHWeQIEAgSB9ASB8QDvAHYAsh4FzIuizYogTodm+Su5iiUgZ2va+nDnsklTLe+L" +
 553         "kF4AAAFxNgmxKgAABAMARzBFAiEA12/OHdTGXQ3qHHC3NvYCyB8aEz/+ZFOLCAI7lhqj28sC" +
 554         "IG2/7Yz2zK6S6ai+dH7cTMZmoFGo39gtaTqtZAqEQX7nAHUAXqdz+d9WwOe1Nkh90EngMnqR" +
 555         "mgyEoRIShBh1loFxRVgAAAFxNgmxTAAABAMARjBEAiA7PNq+MFfv6O9mBkxFViS2TfU66yRB" +
 556         "/njcebWglLQjZQIgOyRKhxlEizncFRml7yn4Bg48ktXKGjo+uiw6zXEINb0wDQYJKoZIhvcN" +
 557         "AQELBQADggEBADM2Rh306Q10PScsolYMxH1B/K4Nb2WICvpY0yDPJFdnGjqCYym196TjiEvs" +
 558         "R6etfeHdyzlZj6nh82B4TVyHjiWM02dQgPalOuWQcuSy0OvLh7F1E7CeHzKlczdFPBTOTdM1" +
 559         "RDTxlvw1bAqc0zueM8QIAyEy3opd7FxAcGQd5WRIJhzLBL+dbbMOW/LTeW7cm/Xzq8cgCybN" +
 560         "BSZAvhjseJ1L29OlCTZL97IfnX0IlFQzWuvvHy7V2B0E3DHlzM0kjwkkCKDUUp/wajv2NZKC" +
 561         "TkhEyERacZRKc9U0ADxwsAzHrdz5+5zfD2usEV/MQ5V6d8swLXs+ko0X6swrd4YCiB8wggRK" +
 562         "MIIDMqADAgECAg0B47SaoY2KqYElaVC4MA0GCSqGSIb3DQEBCwUAMEwxIDAeBgNVBAsTF0ds" +
 563         "b2JhbFNpZ24gUm9vdCBDQSAtIFIyMRMwEQYDVQQKEwpHbG9iYWxTaWduMRMwEQYDVQQDEwpH" +
 564         "bG9iYWxTaWduMB4XDTE3MDYxNTAwMDA0MloXDTIxMTIxNTAwMDA0MlowQjELMAkGA1UEBhMC" +
 565         "VVMxHjAcBgNVBAoTFUdvb2dsZSBUcnVzdCBTZXJ2aWNlczETMBEGA1UEAxMKR1RTIENBIDFP" +
 566         "MTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANAYz0XUi83TnORA73603WkhG8nP" +
 567         "PI5MdbkPMRmEPZ48Ke9QDRCTbwWAgJ8qoL0SSwLhPZ9YFiT+MJ8LdHdVkx1L903hkoIQ9lGs" +
 568         "DMOyIpQPNGuYEEnnC52DOd0gxhwt79EYYWXnI4MgqCMS/9Ikf9Qv50RqW03XUGawr55CYwX7" +
 569         "4BzEY2Gvn2oz/2KXvUjZ03wUZ9x13C5p6PhteGnQtxAFuPExwjsk/RozdPgj4OxrGYoWxuPN" +
 570         "pM0L27OkWWA4iDutHbnGjKdTG/y82aSrvN08YdeTFZjugb2P4mRHIEAGTtesl+i5wFkSoUkl" +
 571         "I+TtcDQspbRjfPmjPYPRzW0krAcCAwEAAaOCATMwggEvMA4GA1UdDwEB/wQEAwIBhjAdBgNV" +
 572         "HSUEFjAUBggrBgEFBQcDAQYIKwYBBQUHAwIwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4E" +
 573         "FgQUmNH4bhDrz5vsYJ8YkBug630J/SswHwYDVR0jBBgwFoAUm+IHV2ccHsBqBt5ZtJot39wZ" +
 574         "hi4wNQYIKwYBBQUHAQEEKTAnMCUGCCsGAQUFBzABhhlodHRwOi8vb2NzcC5wa2kuZ29vZy9n" +
 575         "c3IyMDIGA1UdHwQrMCkwJ6AloCOGIWh0dHA6Ly9jcmwucGtpLmdvb2cvZ3NyMi9nc3IyLmNy" +
 576         "bDA/BgNVHSAEODA2MDQGBmeBDAECAjAqMCgGCCsGAQUFBwIBFhxodHRwczovL3BraS5nb29n" +
 577         "L3JlcG9zaXRvcnkvMA0GCSqGSIb3DQEBCwUAA4IBAQAagD42efvzLqlGN31eVBY1rsdOCJn+" +
 578         "vdE0aSZSZgc9CrpJy2L08RqO/BFPaJZMdCvTZ96yo6oFjYRNTCBlD6WW2g0W+Gw7228EI4hr" +
 579         "OmzBYL1on3GO7i1YNAfw1VTphln9e14NIZT1jMmo+NjyrcwPGvOap6kEJ/mjybD/AnhrYbrH" +
 580         "NSvoVvpPwxwM7bY8tEvq7czhPOzcDYzWPpvKQliLzBYhF0C8otZm79rEFVvNiaqbCSbnMtIN" +
 581         "bmcgAlsQsJAJnAwfnq3YO+qh/GzoEFwIUhlRKnG7rHq13RXtK8kIKiyKtKYhq2P/11JJUNCJ" +
 582         "t63yr/tQri/hlQ3zRq2dnPXK"
 583
 584 func parseCIDR(s string) *net.IPNet {
 585         _, net, err := net.ParseCIDR(s)
 586         if err != nil {
 587                 panic(err)
 588         }
 589         return net
 590 }
 591
 592 func parseURI(s string) *url.URL {
 593         uri, err := url.Parse(s)
 594         if err != nil {
 595                 panic(err)
 596         }
 597         return uri
 598 }
 599
 600 func TestCreateSelfSignedCertificate(t *testing.T) {
 601         random := rand.Reader
 602
 603         ecdsaPriv, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
 604         if err != nil {
 605                 t.Fatalf("Failed to generate ECDSA key: %s", err)
 606         }
 607
 608         ed25519Pub, ed25519Priv, err := ed25519.GenerateKey(random)
 609         if err != nil {
 610                 t.Fatalf("Failed to generate Ed25519 key: %s", err)
 611         }
 612
 613         tests := []struct {
 614                 name      string
 615                 pub, priv any
 616                 checkSig  bool
 617                 sigAlgo   SignatureAlgorithm
 618         }{
 619                 {"RSA/RSA", &testPrivateKey.PublicKey, testPrivateKey, true, SHA384WithRSA},
 620                 {"RSA/ECDSA", &testPrivateKey.PublicKey, ecdsaPriv, false, ECDSAWithSHA384},
 621                 {"ECDSA/RSA", &ecdsaPriv.PublicKey, testPrivateKey, false, SHA256WithRSA},
 622                 {"ECDSA/ECDSA", &ecdsaPriv.PublicKey, ecdsaPriv, true, ECDSAWithSHA256},
 623                 {"RSAPSS/RSAPSS", &testPrivateKey.PublicKey, testPrivateKey, true, SHA256WithRSAPSS},
 624                 {"ECDSA/RSAPSS", &ecdsaPriv.PublicKey, testPrivateKey, false, SHA256WithRSAPSS},
 625                 {"RSAPSS/ECDSA", &testPrivateKey.PublicKey, ecdsaPriv, false, ECDSAWithSHA384},
 626                 {"Ed25519", ed25519Pub, ed25519Priv, true, PureEd25519},
 627         }
 628
 629         testExtKeyUsage := []ExtKeyUsage{ExtKeyUsageClientAuth, ExtKeyUsageServerAuth}
 630         testUnknownExtKeyUsage := []asn1.ObjectIdentifier{[]int{1, 2, 3}, []int{2, 59, 1}}
 631         extraExtensionData := []byte("extra extension")
 632
 633         for _, test := range tests {
 634                 commonName := "test.example.com"
 635                 template := Certificate{
 636                         SerialNumber: big.NewInt(1),
 637                         Subject: pkix.Name{
 638                                 CommonName:   commonName,
 639                                 Organization: []string{"Σ Acme Co"},
 640                                 Country:      []string{"US"},
 641                                 ExtraNames: []pkix.AttributeTypeAndValue{
 642                                         {
 643                                                 Type:  []int{2, 5, 4, 42},
 644                                                 Value: "Gopher",
 645                                         },
 646                                         // This should override the Country, above.
 647                                         {
 648                                                 Type:  []int{2, 5, 4, 6},
 649                                                 Value: "NL",
 650                                         },
 651                                 },
 652                         },
 653                         NotBefore: time.Unix(1000, 0),
 654                         NotAfter:  time.Unix(100000, 0),
 655
 656                         SignatureAlgorithm: test.sigAlgo,
 657
 658                         SubjectKeyId: []byte{1, 2, 3, 4},
 659                         KeyUsage:     KeyUsageCertSign,
 660
 661                         ExtKeyUsage:        testExtKeyUsage,
 662                         UnknownExtKeyUsage: testUnknownExtKeyUsage,
 663
 664                         BasicConstraintsValid: true,
 665                         IsCA:                  true,
 666
 667                         OCSPServer:            []string{"http://ocsp.example.com"},
 668                         IssuingCertificateURL: []string{"http://crt.example.com/ca1.crt"},
 669
 670                         DNSNames:       []string{"test.example.com"},
 671                         EmailAddresses: []string{"gopher@golang.org"},
 672                         IPAddresses:    []net.IP{net.IPv4(127, 0, 0, 1).To4(), net.ParseIP("2001:4860:0:2001::68")},
 673                         URIs:           []*url.URL{parseURI("https://foo.com/wibble#foo")},
 674
 675                         PolicyIdentifiers:       []asn1.ObjectIdentifier{[]int{1, 2, 3}},
 676                         Policies:                []OID{mustNewOIDFromInts(t, []uint64{1, 2, 3, math.MaxUint32, math.MaxUint64})},
 677                         PermittedDNSDomains:     []string{".example.com", "example.com"},
 678                         ExcludedDNSDomains:      []string{"bar.example.com"},
 679                         PermittedIPRanges:       []*net.IPNet{parseCIDR("192.168.1.1/16"), parseCIDR("1.2.3.4/8")},
 680                         ExcludedIPRanges:        []*net.IPNet{parseCIDR("2001:db8::/48")},
 681                         PermittedEmailAddresses: []string{"foo@example.com"},
 682                         ExcludedEmailAddresses:  []string{".example.com", "example.com"},
 683                         PermittedURIDomains:     []string{".bar.com", "bar.com"},
 684                         ExcludedURIDomains:      []string{".bar2.com", "bar2.com"},
 685
 686                         CRLDistributionPoints: []string{"http://crl1.example.com/ca1.crl", "http://crl2.example.com/ca1.crl"},
 687
 688                         ExtraExtensions: []pkix.Extension{
 689                                 {
 690                                         Id:    []int{1, 2, 3, 4},
 691                                         Value: extraExtensionData,
 692                                 },
 693                                 // This extension should override the SubjectKeyId, above.
 694                                 {
 695                                         Id:       oidExtensionSubjectKeyId,
 696                                         Critical: false,
 697                                         Value:    []byte{0x04, 0x04, 4, 3, 2, 1},
 698                                 },
 699                         },
 700                 }
 701
 702                 derBytes, err := CreateCertificate(random, &template, &template, test.pub, test.priv)
 703                 if err != nil {
 704                         t.Errorf("%s: failed to create certificate: %s", test.name, err)
 705                         continue
 706                 }
 707
 708                 cert, err := ParseCertificate(derBytes)
 709                 if err != nil {
 710                         t.Errorf("%s: failed to parse certificate: %s", test.name, err)
 711                         continue
 712                 }
 713
 714                 if len(cert.PolicyIdentifiers) != 1 || !cert.PolicyIdentifiers[0].Equal(template.PolicyIdentifiers[0]) {
 715                         t.Errorf("%s: failed to parse policy identifiers: got:%#v want:%#v", test.name, cert.PolicyIdentifiers, template.PolicyIdentifiers)
 716                 }
 717
 718                 if len(cert.PermittedDNSDomains) != 2 || cert.PermittedDNSDomains[0] != ".example.com" || cert.PermittedDNSDomains[1] != "example.com" {
 719                         t.Errorf("%s: failed to parse name constraints: %#v", test.name, cert.PermittedDNSDomains)
 720                 }
 721
 722                 if len(cert.ExcludedDNSDomains) != 1 || cert.ExcludedDNSDomains[0] != "bar.example.com" {
 723                         t.Errorf("%s: failed to parse name constraint exclusions: %#v", test.name, cert.ExcludedDNSDomains)
 724                 }
 725
 726                 if len(cert.PermittedIPRanges) != 2 || cert.PermittedIPRanges[0].String() != "192.168.0.0/16" || cert.PermittedIPRanges[1].String() != "1.0.0.0/8" {
 727                         t.Errorf("%s: failed to parse IP constraints: %#v", test.name, cert.PermittedIPRanges)
 728                 }
 729
 730                 if len(cert.ExcludedIPRanges) != 1 || cert.ExcludedIPRanges[0].String() != "2001:db8::/48" {
 731                         t.Errorf("%s: failed to parse IP constraint exclusions: %#v", test.name, cert.ExcludedIPRanges)
 732                 }
 733
 734                 if len(cert.PermittedEmailAddresses) != 1 || cert.PermittedEmailAddresses[0] != "foo@example.com" {
 735                         t.Errorf("%s: failed to parse permitted email addresses: %#v", test.name, cert.PermittedEmailAddresses)
 736                 }
 737
 738                 if len(cert.ExcludedEmailAddresses) != 2 || cert.ExcludedEmailAddresses[0] != ".example.com" || cert.ExcludedEmailAddresses[1] != "example.com" {
 739                         t.Errorf("%s: failed to parse excluded email addresses: %#v", test.name, cert.ExcludedEmailAddresses)
 740                 }
 741
 742                 if len(cert.PermittedURIDomains) != 2 || cert.PermittedURIDomains[0] != ".bar.com" || cert.PermittedURIDomains[1] != "bar.com" {
 743                         t.Errorf("%s: failed to parse permitted URIs: %#v", test.name, cert.PermittedURIDomains)
 744                 }
 745
 746                 if len(cert.ExcludedURIDomains) != 2 || cert.ExcludedURIDomains[0] != ".bar2.com" || cert.ExcludedURIDomains[1] != "bar2.com" {
 747                         t.Errorf("%s: failed to parse excluded URIs: %#v", test.name, cert.ExcludedURIDomains)
 748                 }
 749
 750                 if cert.Subject.CommonName != commonName {
 751                         t.Errorf("%s: subject wasn't correctly copied from the template. Got %s, want %s", test.name, cert.Subject.CommonName, commonName)
 752                 }
 753
 754                 if len(cert.Subject.Country) != 1 || cert.Subject.Country[0] != "NL" {
 755                         t.Errorf("%s: ExtraNames didn't override Country", test.name)
 756                 }
 757
 758                 for _, ext := range cert.Extensions {
 759                         if ext.Id.Equal(oidExtensionSubjectAltName) {
 760                                 if ext.Critical {
 761                                         t.Fatal("SAN extension is marked critical")
 762                                 }
 763                         }
 764                 }
 765
 766                 found := false
 767                 for _, atv := range cert.Subject.Names {
 768                         if atv.Type.Equal([]int{2, 5, 4, 42}) {
 769                                 found = true
 770                                 break
 771                         }
 772                 }
 773                 if !found {
 774                         t.Errorf("%s: Names didn't contain oid 2.5.4.42 from ExtraNames", test.name)
 775                 }
 776
 777                 if cert.Issuer.CommonName != commonName {
 778                         t.Errorf("%s: issuer wasn't correctly copied from the template. Got %s, want %s", test.name, cert.Issuer.CommonName, commonName)
 779                 }
 780
 781                 if cert.SignatureAlgorithm != test.sigAlgo {
 782                         t.Errorf("%s: SignatureAlgorithm wasn't copied from template. Got %v, want %v", test.name, cert.SignatureAlgorithm, test.sigAlgo)
 783                 }
 784
 785                 if !reflect.DeepEqual(cert.ExtKeyUsage, testExtKeyUsage) {
 786                         t.Errorf("%s: extkeyusage wasn't correctly copied from the template. Got %v, want %v", test.name, cert.ExtKeyUsage, testExtKeyUsage)
 787                 }
 788
 789                 if !reflect.DeepEqual(cert.UnknownExtKeyUsage, testUnknownExtKeyUsage) {
 790                         t.Errorf("%s: unknown extkeyusage wasn't correctly copied from the template. Got %v, want %v", test.name, cert.UnknownExtKeyUsage, testUnknownExtKeyUsage)
 791                 }
 792
 793                 if !reflect.DeepEqual(cert.OCSPServer, template.OCSPServer) {
 794                         t.Errorf("%s: OCSP servers differ from template. Got %v, want %v", test.name, cert.OCSPServer, template.OCSPServer)
 795                 }
 796
 797                 if !reflect.DeepEqual(cert.IssuingCertificateURL, template.IssuingCertificateURL) {
 798                         t.Errorf("%s: Issuing certificate URLs differ from template. Got %v, want %v", test.name, cert.IssuingCertificateURL, template.IssuingCertificateURL)
 799                 }
 800
 801                 if !reflect.DeepEqual(cert.DNSNames, template.DNSNames) {
 802                         t.Errorf("%s: SAN DNS names differ from template. Got %v, want %v", test.name, cert.DNSNames, template.DNSNames)
 803                 }
 804
 805                 if !reflect.DeepEqual(cert.EmailAddresses, template.EmailAddresses) {
 806                         t.Errorf("%s: SAN emails differ from template. Got %v, want %v", test.name, cert.EmailAddresses, template.EmailAddresses)
 807                 }
 808
 809                 if len(cert.URIs) != 1 || cert.URIs[0].String() != "https://foo.com/wibble#foo" {
 810                         t.Errorf("%s: URIs differ from template. Got %v, want %v", test.name, cert.URIs, template.URIs)
 811                 }
 812
 813                 if !reflect.DeepEqual(cert.IPAddresses, template.IPAddresses) {
 814                         t.Errorf("%s: SAN IPs differ from template. Got %v, want %v", test.name, cert.IPAddresses, template.IPAddresses)
 815                 }
 816
 817                 if !reflect.DeepEqual(cert.CRLDistributionPoints, template.CRLDistributionPoints) {
 818                         t.Errorf("%s: CRL distribution points differ from template. Got %v, want %v", test.name, cert.CRLDistributionPoints, template.CRLDistributionPoints)
 819                 }
 820
 821                 if !bytes.Equal(cert.SubjectKeyId, []byte{4, 3, 2, 1}) {
 822                         t.Errorf("%s: ExtraExtensions didn't override SubjectKeyId", test.name)
 823                 }
 824
 825                 if !bytes.Contains(derBytes, extraExtensionData) {
 826                         t.Errorf("%s: didn't find extra extension in DER output", test.name)
 827                 }
 828
 829                 if test.checkSig {
 830                         err = cert.CheckSignatureFrom(cert)
 831                         if err != nil {
 832                                 t.Errorf("%s: signature verification failed: %s", test.name, err)
 833                         }
 834                 }
 835         }
 836 }
 837
 838 // Self-signed certificate using ECDSA with SHA1 & secp256r1
 839 var ecdsaSHA1CertPem = `
 840 -----BEGIN CERTIFICATE-----
 841 MIICDjCCAbUCCQDF6SfN0nsnrjAJBgcqhkjOPQQBMIGPMQswCQYDVQQGEwJVUzET
 842 MBEGA1UECAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNTW91bnRhaW4gVmlldzEVMBMG
 843 A1UECgwMR29vZ2xlLCBJbmMuMRcwFQYDVQQDDA53d3cuZ29vZ2xlLmNvbTEjMCEG
 844 CSqGSIb3DQEJARYUZ29sYW5nLWRldkBnbWFpbC5jb20wHhcNMTIwNTIwMjAyMDUw
 845 WhcNMjIwNTE4MjAyMDUwWjCBjzELMAkGA1UEBhMCVVMxEzARBgNVBAgMCkNhbGlm
 846 b3JuaWExFjAUBgNVBAcMDU1vdW50YWluIFZpZXcxFTATBgNVBAoMDEdvb2dsZSwg
 847 SW5jLjEXMBUGA1UEAwwOd3d3Lmdvb2dsZS5jb20xIzAhBgkqhkiG9w0BCQEWFGdv
 848 bGFuZy1kZXZAZ21haWwuY29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE/Wgn
 849 WQDo5+bz71T0327ERgd5SDDXFbXLpzIZDXTkjpe8QTEbsF+ezsQfrekrpDPC4Cd3
 850 P9LY0tG+aI8IyVKdUjAJBgcqhkjOPQQBA0gAMEUCIGlsqMcRqWVIWTD6wXwe6Jk2
 851 DKxL46r/FLgJYnzBEH99AiEA3fBouObsvV1R3oVkb4BQYnD4/4LeId6lAT43YvyV
 852 a/A=
 853 -----END CERTIFICATE-----
 854 `
 855
 856 // Self-signed certificate using ECDSA with SHA256 & secp256r1
 857 var ecdsaSHA256p256CertPem = `
 858 -----BEGIN CERTIFICATE-----
 859 MIICDzCCAbYCCQDlsuMWvgQzhTAKBggqhkjOPQQDAjCBjzELMAkGA1UEBhMCVVMx
 860 EzARBgNVBAgMCkNhbGlmb3JuaWExFjAUBgNVBAcMDU1vdW50YWluIFZpZXcxFTAT
 861 BgNVBAoMDEdvb2dsZSwgSW5jLjEXMBUGA1UEAwwOd3d3Lmdvb2dsZS5jb20xIzAh
 862 BgkqhkiG9w0BCQEWFGdvbGFuZy1kZXZAZ21haWwuY29tMB4XDTEyMDUyMTAwMTkx
 863 NloXDTIyMDUxOTAwMTkxNlowgY8xCzAJBgNVBAYTAlVTMRMwEQYDVQQIDApDYWxp
 864 Zm9ybmlhMRYwFAYDVQQHDA1Nb3VudGFpbiBWaWV3MRUwEwYDVQQKDAxHb29nbGUs
 865 IEluYy4xFzAVBgNVBAMMDnd3dy5nb29nbGUuY29tMSMwIQYJKoZIhvcNAQkBFhRn
 866 b2xhbmctZGV2QGdtYWlsLmNvbTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABPMt
 867 2ErhxAty5EJRu9yM+MTy+hUXm3pdW1ensAv382KoGExSXAFWP7pjJnNtHO+XSwVm
 868 YNtqjcAGFKpweoN//kQwCgYIKoZIzj0EAwIDRwAwRAIgIYSaUA/IB81gjbIw/hUV
 869 70twxJr5EcgOo0hLp3Jm+EYCIFDO3NNcgmURbJ1kfoS3N/0O+irUtoPw38YoNkqJ
 870 h5wi
 871 -----END CERTIFICATE-----
 872 `
 873
 874 // Self-signed certificate using ECDSA with SHA256 & secp384r1
 875 var ecdsaSHA256p384CertPem = `
 876 -----BEGIN CERTIFICATE-----
 877 MIICSjCCAdECCQDje/no7mXkVzAKBggqhkjOPQQDAjCBjjELMAkGA1UEBhMCVVMx
 878 EzARBgNVBAgMCkNhbGlmb3JuaWExFjAUBgNVBAcMDU1vdW50YWluIFZpZXcxFDAS
 879 BgNVBAoMC0dvb2dsZSwgSW5jMRcwFQYDVQQDDA53d3cuZ29vZ2xlLmNvbTEjMCEG
 880 CSqGSIb3DQEJARYUZ29sYW5nLWRldkBnbWFpbC5jb20wHhcNMTIwNTIxMDYxMDM0
 881 WhcNMjIwNTE5MDYxMDM0WjCBjjELMAkGA1UEBhMCVVMxEzARBgNVBAgMCkNhbGlm
 882 b3JuaWExFjAUBgNVBAcMDU1vdW50YWluIFZpZXcxFDASBgNVBAoMC0dvb2dsZSwg
 883 SW5jMRcwFQYDVQQDDA53d3cuZ29vZ2xlLmNvbTEjMCEGCSqGSIb3DQEJARYUZ29s
 884 YW5nLWRldkBnbWFpbC5jb20wdjAQBgcqhkjOPQIBBgUrgQQAIgNiAARRuzRNIKRK
 885 jIktEmXanNmrTR/q/FaHXLhWRZ6nHWe26Fw7Rsrbk+VjGy4vfWtNn7xSFKrOu5ze
 886 qxKnmE0h5E480MNgrUiRkaGO2GMJJVmxx20aqkXOk59U8yGA4CghE6MwCgYIKoZI
 887 zj0EAwIDZwAwZAIwBZEN8gvmRmfeP/9C1PRLzODIY4JqWub2PLRT4mv9GU+yw3Gr
 888 PU9A3CHMdEcdw/MEAjBBO1lId8KOCh9UZunsSMfqXiVurpzmhWd6VYZ/32G+M+Mh
 889 3yILeYQzllt/g0rKVRk=
 890 -----END CERTIFICATE-----
 891 `
 892
 893 // Self-signed certificate using ECDSA with SHA384 & secp521r1
 894 var ecdsaSHA384p521CertPem = `
 895 -----BEGIN CERTIFICATE-----
 896 MIICljCCAfcCCQDhp1AFD/ahKjAKBggqhkjOPQQDAzCBjjELMAkGA1UEBhMCVVMx
 897 EzARBgNVBAgMCkNhbGlmb3JuaWExFjAUBgNVBAcMDU1vdW50YWluIFZpZXcxFDAS
 898 BgNVBAoMC0dvb2dsZSwgSW5jMRcwFQYDVQQDDA53d3cuZ29vZ2xlLmNvbTEjMCEG
 899 CSqGSIb3DQEJARYUZ29sYW5nLWRldkBnbWFpbC5jb20wHhcNMTIwNTIxMTUwNDI5
 900 WhcNMjIwNTE5MTUwNDI5WjCBjjELMAkGA1UEBhMCVVMxEzARBgNVBAgMCkNhbGlm
 901 b3JuaWExFjAUBgNVBAcMDU1vdW50YWluIFZpZXcxFDASBgNVBAoMC0dvb2dsZSwg
 902 SW5jMRcwFQYDVQQDDA53d3cuZ29vZ2xlLmNvbTEjMCEGCSqGSIb3DQEJARYUZ29s
 903 YW5nLWRldkBnbWFpbC5jb20wgZswEAYHKoZIzj0CAQYFK4EEACMDgYYABACqx9Rv
 904 IssRs1LWYcNN+WffwlHw4Tv3y8/LIAA9MF1ZScIonU9nRMxt4a2uGJVCPDw6JHpz
 905 PaYc0E9puLoE9AfKpwFr59Jkot7dBg55SKPEFkddoip/rvmN7NPAWjMBirOwjOkm
 906 8FPthvPhGPqsu9AvgVuHu3PosWiHGNrhh379pva8MzAKBggqhkjOPQQDAwOBjAAw
 907 gYgCQgEHNmswkUdPpHqrVxp9PvLVl+xxPuHBkT+75z9JizyxtqykHQo9Uh6SWCYH
 908 BF9KLolo01wMt8DjoYP5Fb3j5MH7xwJCAbWZzTOp4l4DPkIvAh4LeC4VWbwPPyqh
 909 kBg71w/iEcSY3wUKgHGcJJrObZw7wys91I5kENljqw/Samdr3ka+jBJa
 910 -----END CERTIFICATE-----
 911 `
 912
 913 var ecdsaTests = []struct {
 914         sigAlgo SignatureAlgorithm
 915         pemCert string
 916 }{
 917         {ECDSAWithSHA256, ecdsaSHA256p256CertPem},
 918         {ECDSAWithSHA256, ecdsaSHA256p384CertPem},
 919         {ECDSAWithSHA384, ecdsaSHA384p521CertPem},
 920 }
 921
 922 func TestECDSA(t *testing.T) {
 923         for i, test := range ecdsaTests {
 924                 pemBlock, _ := pem.Decode([]byte(test.pemCert))
 925                 cert, err := ParseCertificate(pemBlock.Bytes)
 926                 if err != nil {
 927                         t.Errorf("%d: failed to parse certificate: %s", i, err)
 928                         continue
 929                 }
 930                 if sa := cert.SignatureAlgorithm; sa != test.sigAlgo {
 931                         t.Errorf("%d: signature algorithm is %v, want %v", i, sa, test.sigAlgo)
 932                 }
 933                 if parsedKey, ok := cert.PublicKey.(*ecdsa.PublicKey); !ok {
 934                         t.Errorf("%d: wanted an ECDSA public key but found: %#v", i, parsedKey)
 935                 }
 936                 if pka := cert.PublicKeyAlgorithm; pka != ECDSA {
 937                         t.Errorf("%d: public key algorithm is %v, want ECDSA", i, pka)
 938                 }
 939                 if err = cert.CheckSignatureFrom(cert); err != nil {
 940                         t.Errorf("%d: certificate verification failed: %s", i, err)
 941                 }
 942         }
 943 }
 944
 945 // Self-signed certificate using DSA with SHA1
 946 var dsaCertPem = `-----BEGIN CERTIFICATE-----
 947 MIIEDTCCA82gAwIBAgIJALHPghaoxeDhMAkGByqGSM44BAMweTELMAkGA1UEBhMC
 948 VVMxCzAJBgNVBAgTAk5DMQ8wDQYDVQQHEwZOZXd0b24xFDASBgNVBAoTC0dvb2ds
 949 ZSwgSW5jMRIwEAYDVQQDEwlKb24gQWxsaWUxIjAgBgkqhkiG9w0BCQEWE2pvbmFs
 950 bGllQGdvb2dsZS5jb20wHhcNMTEwNTE0MDMwMTQ1WhcNMTEwNjEzMDMwMTQ1WjB5
 951 MQswCQYDVQQGEwJVUzELMAkGA1UECBMCTkMxDzANBgNVBAcTBk5ld3RvbjEUMBIG
 952 A1UEChMLR29vZ2xlLCBJbmMxEjAQBgNVBAMTCUpvbiBBbGxpZTEiMCAGCSqGSIb3
 953 DQEJARYTam9uYWxsaWVAZ29vZ2xlLmNvbTCCAbcwggEsBgcqhkjOOAQBMIIBHwKB
 954 gQC8hLUnQ7FpFYu4WXTj6DKvXvz8QrJkNJCVMTpKAT7uBpobk32S5RrPKXocd4gN
 955 8lyGB9ggS03EVlEwXvSmO0DH2MQtke2jl9j1HLydClMf4sbx5V6TV9IFw505U1iW
 956 jL7awRMgxge+FsudtJK254FjMFo03ZnOQ8ZJJ9E6AEDrlwIVAJpnBn9moyP11Ox5
 957 Asc/5dnjb6dPAoGBAJFHd4KVv1iTVCvEG6gGiYop5DJh28hUQcN9kul+2A0yPUSC
 958 X93oN00P8Vh3eYgSaCWZsha7zDG53MrVJ0Zf6v/X/CoZNhLldeNOepivTRAzn+Rz
 959 kKUYy5l1sxYLHQKF0UGNCXfFKZT0PCmgU+PWhYNBBMn6/cIh44vp85ideo5CA4GE
 960 AAKBgFmifCafzeRaohYKXJgMGSEaggCVCRq5xdyDCat+wbOkjC4mfG01/um3G8u5
 961 LxasjlWRKTR/tcAL7t0QuokVyQaYdVypZXNaMtx1db7YBuHjj3aP+8JOQRI9xz8c
 962 bp5NDJ5pISiFOv4p3GZfqZPcqckDt78AtkQrmnal2txhhjF6o4HeMIHbMB0GA1Ud
 963 DgQWBBQVyyr7hO11ZFFpWX50298Sa3V+rzCBqwYDVR0jBIGjMIGggBQVyyr7hO11
 964 ZFFpWX50298Sa3V+r6F9pHsweTELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAk5DMQ8w
 965 DQYDVQQHEwZOZXd0b24xFDASBgNVBAoTC0dvb2dsZSwgSW5jMRIwEAYDVQQDEwlK
 966 b24gQWxsaWUxIjAgBgkqhkiG9w0BCQEWE2pvbmFsbGllQGdvb2dsZS5jb22CCQCx
 967 z4IWqMXg4TAMBgNVHRMEBTADAQH/MAkGByqGSM44BAMDLwAwLAIUPtn/5j8Q1jJI
 968 7ggOIsgrhgUdjGQCFCsmDq1H11q9+9Wp9IMeGrTSKHIM
 969 -----END CERTIFICATE-----
 970 `
 971
 972 func TestParseCertificateWithDsaPublicKey(t *testing.T) {
 973         expectedKey := &dsa.PublicKey{
 974                 Parameters: dsa.Parameters{
 975                         P: bigFromHexString("00BC84B52743B169158BB85974E3E832AF5EFCFC42B264349095313A4A013EEE069A1B937D92E51ACF297A1C77880DF25C8607D8204B4DC45651305EF4A63B40C7D8C42D91EDA397D8F51CBC9D0A531FE2C6F1E55E9357D205C39D395358968CBEDAC11320C607BE16CB9DB492B6E78163305A34DD99CE43C64927D13A0040EB97"),
 976                         Q: bigFromHexString("009A67067F66A323F5D4EC7902C73FE5D9E36FA74F"),
 977                         G: bigFromHexString("009147778295BF5893542BC41BA806898A29E43261DBC85441C37D92E97ED80D323D44825FDDE8374D0FF15877798812682599B216BBCC31B9DCCAD527465FEAFFD7FC2A193612E575E34E7A98AF4D10339FE47390A518CB9975B3160B1D0285D1418D0977C52994F43C29A053E3D685834104C9FAFDC221E38BE9F3989D7A8E42"),
 978                 },
 979                 Y: bigFromHexString("59A27C269FCDE45AA2160A5C980C19211A820095091AB9C5DC8309AB7EC1B3A48C2E267C6D35FEE9B71BCBB92F16AC8E559129347FB5C00BEEDD10BA8915C90698755CA965735A32DC7575BED806E1E38F768FFBC24E41123DC73F1C6E9E4D0C9E692128853AFE29DC665FA993DCA9C903B7BF00B6442B9A76A5DADC6186317A"),
 980         }
 981         pemBlock, _ := pem.Decode([]byte(dsaCertPem))
 982         cert, err := ParseCertificate(pemBlock.Bytes)
 983         if err != nil {
 984                 t.Fatalf("Failed to parse certificate: %s", err)
 985         }
 986         if cert.PublicKeyAlgorithm != DSA {
 987                 t.Errorf("Parsed key algorithm was not DSA")
 988         }
 989         parsedKey, ok := cert.PublicKey.(*dsa.PublicKey)
 990         if !ok {
 991                 t.Fatalf("Parsed key was not a DSA key: %s", err)
 992         }
 993         if expectedKey.Y.Cmp(parsedKey.Y) != 0 ||
 994                 expectedKey.P.Cmp(parsedKey.P) != 0 ||
 995                 expectedKey.Q.Cmp(parsedKey.Q) != 0 ||
 996                 expectedKey.G.Cmp(parsedKey.G) != 0 {
 997                 t.Fatal("Parsed key differs from expected key")
 998         }
 999 }
1000
1001 func TestParseCertificateWithDSASignatureAlgorithm(t *testing.T) {
1002         pemBlock, _ := pem.Decode([]byte(dsaCertPem))
1003         cert, err := ParseCertificate(pemBlock.Bytes)
1004         if err != nil {
1005                 t.Fatalf("Failed to parse certificate: %s", err)
1006         }
1007         if cert.SignatureAlgorithm != DSAWithSHA1 {
1008                 t.Errorf("Parsed signature algorithm was not DSAWithSHA1")
1009         }
1010 }
1011
1012 func TestVerifyCertificateWithDSASignature(t *testing.T) {
1013         pemBlock, _ := pem.Decode([]byte(dsaCertPem))
1014         cert, err := ParseCertificate(pemBlock.Bytes)
1015         if err != nil {
1016                 t.Fatalf("Failed to parse certificate: %s", err)
1017         }
1018         // test cert is self-signed
1019         if err = cert.CheckSignatureFrom(cert); err == nil {
1020                 t.Fatalf("Expected error verifying DSA certificate")
1021         }
1022 }
1023
1024 var rsaPSSSelfSignedPEM = `-----BEGIN CERTIFICATE-----
1025 MIIGHjCCA9KgAwIBAgIBdjBBBgkqhkiG9w0BAQowNKAPMA0GCWCGSAFlAwQCAQUA
1026 oRwwGgYJKoZIhvcNAQEIMA0GCWCGSAFlAwQCAQUAogMCASAwbjELMAkGA1UEBhMC
1027 SlAxHDAaBgNVBAoME0phcGFuZXNlIEdvdmVybm1lbnQxKDAmBgNVBAsMH1RoZSBN
1028 aW5pc3RyeSBvZiBGb3JlaWduIEFmZmFpcnMxFzAVBgNVBAMMDmUtcGFzc3BvcnRD
1029 U0NBMB4XDTEzMDUxNDA1MDczMFoXDTI5MDUxNDA1MDczMFowbjELMAkGA1UEBhMC
1030 SlAxHDAaBgNVBAoME0phcGFuZXNlIEdvdmVybm1lbnQxKDAmBgNVBAsMH1RoZSBN
1031 aW5pc3RyeSBvZiBGb3JlaWduIEFmZmFpcnMxFzAVBgNVBAMMDmUtcGFzc3BvcnRD
1032 U0NBMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAx/E3WRVxcCDXhoST
1033 8nVSLjW6hwM4Ni99AegWzcGtfGFo0zjFA1Cl5URqxauvYu3gQgQHBGA1CovWeGrl
1034 yVSRzOL1imcYsSgLOcnhVYB3Xcrof4ebv9+W+TwNdc9YzAwcj8rNd5nP6PKXIQ+W
1035 PCkEOXdyb80YEnxuT+NPjkVfFSPBS7QYZpvT2fwy4fZ0eh48253+7VleSmTO0mqj
1036 7TlzaG56q150SLZbhpOd8jD8bM/wACnLCPR88wj4hCcDLEwoLyY85HJCTIQQMnoT
1037 UpqyzEeupPREIm6yi4d8C9YqIWFn2YTnRcWcmMaJLzq+kYwKoudfnoC6RW2vzZXn
1038 defQs68IZuK+uALu9G3JWGPgu0CQGj0JNDT8zkiDV++4eNrZczWKjr1YnAL+VbLK
1039 bApwL2u19l2WDpfUklimhWfraqHNIUKU6CjZOG31RzXcplIj0mtqs0E1r7r357Es
1040 yFoB28iNo4cz1lCulh0E4WJzWzLZcT4ZspHHRCFyvYnXoibXEV1nULq8ByKKG0FS
1041 7nn4SseoV+8PvjHLPhmHGMvi4mxkbcXdV3wthHT1/HXdqY84A4xHWt1+sB/TpTek
1042 tDhFlEfcUygvTu58UtOnysomOVVeERmi7WSujfzKsGJAJYeetiA5R+zX7BxeyFVE
1043 qW0zh1Tkwh0S8LRe5diJh4+6FG0CAwEAAaNfMF0wHQYDVR0OBBYEFD+oahaikBTV
1044 Urk81Uz7kRS2sx0aMA4GA1UdDwEB/wQEAwIBBjAYBgNVHSAEETAPMA0GCyqDCIaP
1045 fgYFAQEBMBIGA1UdEwEB/wQIMAYBAf8CAQAwQQYJKoZIhvcNAQEKMDSgDzANBglg
1046 hkgBZQMEAgEFAKEcMBoGCSqGSIb3DQEBCDANBglghkgBZQMEAgEFAKIDAgEgA4IC
1047 AQAaxWBQn5CZuNBfyzL57mn31ukHUFd61OMROSX3PT7oCv1Dy+C2AdRlxOcbN3/n
1048 li0yfXUUqiY3COlLAHKRlkr97mLtxEFoJ0R8nVN2IQdChNQM/XSCzSGyY8NVa1OR
1049 TTpEWLnexJ9kvIdbFXwUqdTnAkOI0m7Rg8j+E+lRRHg1xDAA1qKttrtUj3HRQWf3
1050 kNTu628SiMvap6aIdncburaK56MP7gkR1Wr/ichOfjIA3Jgw2PapI31i0GqeMd66
1051 U1+lC9FeyMAJpuSVp/SoiYzYo+79SFcVoM2yw3yAnIKg7q9GLYYqzncdykT6C06c
1052 15gWFI6igmReAsD9ITSvYh0jLrLHfEYcPTOD3ZXJ4EwwHtWSoO3gq1EAtOYKu/Lv
1053 C8zfBsZcFdsHvsSiYeBU8Oioe42mguky3Ax9O7D805Ek6R68ra07MW/G4YxvV7IN
1054 2BfSaYy8MX9IG0ZMIOcoc0FeF5xkFmJ7kdrlTaJzC0IE9PNxNaH5QnOAFB8vxHcO
1055 FioUxb6UKdHcPLR1VZtAdTdTMjSJxUqD/35Cdfqs7oDJXz8f6TXO2Tdy6G++YUs9
1056 qsGZWxzFvvkXUkQSl0dQQ5jO/FtUJcAVXVVp20LxPemfatAHpW31WdJYeWSQWky2
1057 +f9b5TXKXVyjlUL7uHxowWrT2AtTchDH22wTEtqLEF9Z3Q==
1058 -----END CERTIFICATE-----`
1059
1060 // openssl req -newkey rsa:2048 -keyout test.key -sha256 -sigopt \
1061 // rsa_padding_mode:pss -sigopt rsa_pss_saltlen:32 -sigopt rsa_mgf1_md:sha256 \
1062 // -x509 -days 3650 -nodes -subj '/C=US/ST=CA/L=SF/O=Test/CN=Test' -out \
1063 // test.pem
1064 var rsaPSSSelfSignedOpenSSL110PEM = `-----BEGIN CERTIFICATE-----
1065 MIIDwDCCAnigAwIBAgIJAM9LAMHTE5xpMD0GCSqGSIb3DQEBCjAwoA0wCwYJYIZI
1066 AWUDBAIBoRowGAYJKoZIhvcNAQEIMAsGCWCGSAFlAwQCAaIDAgEgMEUxCzAJBgNV
1067 BAYTAlVTMQswCQYDVQQIDAJDQTELMAkGA1UEBwwCU0YxDTALBgNVBAoMBFRlc3Qx
1068 DTALBgNVBAMMBFRlc3QwHhcNMTgwMjIyMjIxMzE4WhcNMjgwMjIwMjIxMzE4WjBF
1069 MQswCQYDVQQGEwJVUzELMAkGA1UECAwCQ0ExCzAJBgNVBAcMAlNGMQ0wCwYDVQQK
1070 DARUZXN0MQ0wCwYDVQQDDARUZXN0MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB
1071 CgKCAQEA4Zrsydod+GoTAJLLutWNF87qhhVPBsK1zB1Gj+NAAe4+VbrZ1E41H1wp
1072 qITx7DA8DRtJEf+NqrTAnAdZWBG/tAOA5LfXVax0ZSQtLnYLSeylLoMtDyY3eFAj
1073 TmuTOoyVy6raktowCnHCh01NsstqqTfrx6SbmzOmDmKTkq/I+7K0MCVsn41xRDVM
1074 +ShD0WGFGioEGoiWnFSWupxJDA3Q6jIDEygVwNKHwnhv/2NgG2kqZzrZSQA67en0
1075 iKAXtoDNPpmyD5oS9YbEJ+2Nbm7oLeON30i6kZvXKIzJXx+UWViazHZqnsi5rQ8G
1076 RHF+iVFXsqd0MzDKmkKOT5FDhrsbKQIDAQABo1MwUTAdBgNVHQ4EFgQU9uFY/nlg
1077 gLH00NBnr/o7QvpN9ugwHwYDVR0jBBgwFoAU9uFY/nlggLH00NBnr/o7QvpN9ugw
1078 DwYDVR0TAQH/BAUwAwEB/zA9BgkqhkiG9w0BAQowMKANMAsGCWCGSAFlAwQCAaEa
1079 MBgGCSqGSIb3DQEBCDALBglghkgBZQMEAgGiAwIBIAOCAQEAhJzpwxBNGKvzKWDe
1080 WLqv6RMrl/q4GcH3b7M9wjxe0yOm4F+Tb2zJ7re4h+D39YkJf8cX1NV9UQVu6z4s
1081 Fvo2kmlR0qZOXAg5augmCQ1xS0WHFoF6B52anNzHkZQbAIYJ3kGoFsUHzs7Sz7F/
1082 656FsRpHA9UzJQ3avPPMrA4Y4aoJ7ANJ6XIwTrdWrhULOVuvYRLCl4CdTVztVFX6
1083 wxX8nS1ISYd8jXPUMgsBKVbWufvLoIymMJW8CZbpprVZel5zFn0bmPrON8IHS30w
1084 Gs+ITJjKEnZgXmAQ25SLKVzkZkBcGANs2GsdHNJ370Puisy0FIPD2NXR5uASAf7J
1085 +w9fjQ==
1086 -----END CERTIFICATE-----`
1087
1088 func TestRSAPSSSelfSigned(t *testing.T) {
1089         for i, pemBlock := range []string{rsaPSSSelfSignedPEM, rsaPSSSelfSignedOpenSSL110PEM} {
1090                 der, _ := pem.Decode([]byte(pemBlock))
1091                 if der == nil {
1092                         t.Errorf("#%d: failed to find PEM block", i)
1093                         continue
1094                 }
1095
1096                 cert, err := ParseCertificate(der.Bytes)
1097                 if err != nil {
1098                         t.Errorf("#%d: failed to parse: %s", i, err)
1099                         continue
1100                 }
1101
1102                 if err = cert.CheckSignatureFrom(cert); err != nil {
1103                         t.Errorf("#%d: signature check failed: %s", i, err)
1104                         continue
1105                 }
1106         }
1107 }
1108
1109 const ed25519Certificate = `
1110 Certificate:
1111     Data:
1112         Version: 3 (0x2)
1113         Serial Number:
1114             0c:83:d8:21:2b:82:cb:23:98:23:63:e2:f7:97:8a:43:5b:f3:bd:92
1115         Signature Algorithm: ED25519
1116         Issuer: CN = Ed25519 test certificate
1117         Validity
1118             Not Before: May  6 17:27:16 2019 GMT
1119             Not After : Jun  5 17:27:16 2019 GMT
1120         Subject: CN = Ed25519 test certificate
1121         Subject Public Key Info:
1122             Public Key Algorithm: ED25519
1123                 ED25519 Public-Key:
1124                 pub:
1125                     36:29:c5:6c:0d:4f:14:6c:81:d0:ff:75:d3:6a:70:
1126                     5f:69:cd:0f:4d:66:d5:da:98:7e:82:49:89:a3:8a:
1127                     3c:fa
1128         X509v3 extensions:
1129             X509v3 Subject Key Identifier:
1130                 09:3B:3A:9D:4A:29:D8:95:FF:68:BE:7B:43:54:72:E0:AD:A2:E3:AE
1131             X509v3 Authority Key Identifier:
1132                 keyid:09:3B:3A:9D:4A:29:D8:95:FF:68:BE:7B:43:54:72:E0:AD:A2:E3:AE
1133
1134             X509v3 Basic Constraints: critical
1135                 CA:TRUE
1136     Signature Algorithm: ED25519
1137          53:a5:58:1c:2c:3b:2a:9e:ac:9d:4e:a5:1d:5f:5d:6d:a6:b5:
1138          08:de:12:82:f3:97:20:ae:fa:d8:98:f4:1a:83:32:6b:91:f5:
1139          24:1d:c4:20:7f:2c:e2:4d:da:13:3b:6d:54:1a:d2:a8:28:dc:
1140          60:b9:d4:f4:78:4b:3c:1c:91:00
1141 -----BEGIN CERTIFICATE-----
1142 MIIBWzCCAQ2gAwIBAgIUDIPYISuCyyOYI2Pi95eKQ1vzvZIwBQYDK2VwMCMxITAf
1143 BgNVBAMMGEVkMjU1MTkgdGVzdCBjZXJ0aWZpY2F0ZTAeFw0xOTA1MDYxNzI3MTZa
1144 Fw0xOTA2MDUxNzI3MTZaMCMxITAfBgNVBAMMGEVkMjU1MTkgdGVzdCBjZXJ0aWZp
1145 Y2F0ZTAqMAUGAytlcAMhADYpxWwNTxRsgdD/ddNqcF9pzQ9NZtXamH6CSYmjijz6
1146 o1MwUTAdBgNVHQ4EFgQUCTs6nUop2JX/aL57Q1Ry4K2i464wHwYDVR0jBBgwFoAU
1147 CTs6nUop2JX/aL57Q1Ry4K2i464wDwYDVR0TAQH/BAUwAwEB/zAFBgMrZXADQQBT
1148 pVgcLDsqnqydTqUdX11tprUI3hKC85cgrvrYmPQagzJrkfUkHcQgfyziTdoTO21U
1149 GtKoKNxgudT0eEs8HJEA
1150 -----END CERTIFICATE-----`
1151
1152 func TestEd25519SelfSigned(t *testing.T) {
1153         der, _ := pem.Decode([]byte(ed25519Certificate))
1154         if der == nil {
1155                 t.Fatalf("Failed to find PEM block")
1156         }
1157
1158         cert, err := ParseCertificate(der.Bytes)
1159         if err != nil {
1160                 t.Fatalf("Failed to parse: %s", err)
1161         }
1162
1163         if cert.PublicKeyAlgorithm != Ed25519 {
1164                 t.Fatalf("Parsed key algorithm was not Ed25519")
1165         }
1166         parsedKey, ok := cert.PublicKey.(ed25519.PublicKey)
1167         if !ok {
1168                 t.Fatalf("Parsed key was not an Ed25519 key: %s", err)
1169         }
1170         if len(parsedKey) != ed25519.PublicKeySize {
1171                 t.Fatalf("Invalid Ed25519 key")
1172         }
1173
1174         if err = cert.CheckSignatureFrom(cert); err != nil {
1175                 t.Fatalf("Signature check failed: %s", err)
1176         }
1177 }
1178
1179 const pemCertificate = `-----BEGIN CERTIFICATE-----
1180 MIIDATCCAemgAwIBAgIRAKQkkrFx1T/dgB/Go/xBM5swDQYJKoZIhvcNAQELBQAw
1181 EjEQMA4GA1UEChMHQWNtZSBDbzAeFw0xNjA4MTcyMDM2MDdaFw0xNzA4MTcyMDM2
1182 MDdaMBIxEDAOBgNVBAoTB0FjbWUgQ28wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAw
1183 ggEKAoIBAQDAoJtjG7M6InsWwIo+l3qq9u+g2rKFXNu9/mZ24XQ8XhV6PUR+5HQ4
1184 jUFWC58ExYhottqK5zQtKGkw5NuhjowFUgWB/VlNGAUBHtJcWR/062wYrHBYRxJH
1185 qVXOpYKbIWwFKoXu3hcpg/CkdOlDWGKoZKBCwQwUBhWE7MDhpVdQ+ZljUJWL+FlK
1186 yQK5iRsJd5TGJ6VUzLzdT4fmN2DzeK6GLeyMpVpU3sWV90JJbxWQ4YrzkKzYhMmB
1187 EcpXTG2wm+ujiHU/k2p8zlf8Sm7VBM/scmnMFt0ynNXop4FWvJzEm1G0xD2t+e2I
1188 5Utr04dOZPCgkm++QJgYhtZvgW7ZZiGTAgMBAAGjUjBQMA4GA1UdDwEB/wQEAwIF
1189 oDATBgNVHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMBsGA1UdEQQUMBKC
1190 EHRlc3QuZXhhbXBsZS5jb20wDQYJKoZIhvcNAQELBQADggEBADpqKQxrthH5InC7
1191 X96UP0OJCu/lLEMkrjoEWYIQaFl7uLPxKH5AmQPH4lYwF7u7gksR7owVG9QU9fs6
1192 1fK7II9CVgCd/4tZ0zm98FmU4D0lHGtPARrrzoZaqVZcAvRnFTlPX5pFkPhVjjai
1193 /mkxX9LpD8oK1445DFHxK5UjLMmPIIWd8EOi+v5a+hgGwnJpoW7hntSl8kHMtTmy
1194 fnnktsblSUV4lRCit0ymC7Ojhe+gzCCwkgs5kDzVVag+tnl/0e2DloIjASwOhpbH
1195 KVcg7fBd484ht/sS+l0dsB4KDOSpd8JzVDMF8OZqlaydizoJO0yWr9GbCN1+OKq5
1196 EhLrEqU=
1197 -----END CERTIFICATE-----`
1198
1199 const ed25519CRLCertificate = `
1200 Certificate:
1201 Data:
1202         Version: 3 (0x2)
1203         Serial Number:
1204                 7a:07:a0:9d:14:04:16:fc:1f:d8:e5:fe:d1:1d:1f:8d
1205         Signature Algorithm: ED25519
1206         Issuer: CN = Ed25519 CRL Test CA
1207         Validity
1208                 Not Before: Oct 30 01:20:20 2019 GMT
1209                 Not After : Dec 31 23:59:59 9999 GMT
1210         Subject: CN = Ed25519 CRL Test CA
1211         Subject Public Key Info:
1212                 Public Key Algorithm: ED25519
1213                         ED25519 Public-Key:
1214                         pub:
1215                                 95:73:3b:b0:06:2a:31:5a:b6:a7:a6:6e:ef:71:df:
1216                                 ac:6f:6b:39:03:85:5e:63:4b:f8:a6:0f:68:c6:6f:
1217                                 75:21
1218         X509v3 extensions:
1219                 X509v3 Key Usage: critical
1220                         Digital Signature, Certificate Sign, CRL Sign
1221                 X509v3 Extended Key Usage:
1222                         TLS Web Client Authentication, TLS Web Server Authentication, OCSP Signing
1223                 X509v3 Basic Constraints: critical
1224                         CA:TRUE
1225                 X509v3 Subject Key Identifier:
1226                         B7:17:DA:16:EA:C5:ED:1F:18:49:44:D3:D2:E3:A0:35:0A:81:93:60
1227                 X509v3 Authority Key Identifier:
1228                         keyid:B7:17:DA:16:EA:C5:ED:1F:18:49:44:D3:D2:E3:A0:35:0A:81:93:60
1229
1230 Signature Algorithm: ED25519
1231          fc:3e:14:ea:bb:70:c2:6f:38:34:70:bc:c8:a7:f4:7c:0d:1e:
1232          28:d7:2a:9f:22:8a:45:e8:02:76:84:1e:2d:64:2d:1e:09:b5:
1233          29:71:1f:95:8a:4e:79:87:51:60:9a:e7:86:40:f6:60:c7:d1:
1234          ee:68:76:17:1d:90:cc:92:93:07
1235 -----BEGIN CERTIFICATE-----
1236 MIIBijCCATygAwIBAgIQegegnRQEFvwf2OX+0R0fjTAFBgMrZXAwHjEcMBoGA1UE
1237 AxMTRWQyNTUxOSBDUkwgVGVzdCBDQTAgFw0xOTEwMzAwMTIwMjBaGA85OTk5MTIz
1238 MTIzNTk1OVowHjEcMBoGA1UEAxMTRWQyNTUxOSBDUkwgVGVzdCBDQTAqMAUGAytl
1239 cAMhAJVzO7AGKjFatqembu9x36xvazkDhV5jS/imD2jGb3Uho4GNMIGKMA4GA1Ud
1240 DwEB/wQEAwIBhjAnBgNVHSUEIDAeBggrBgEFBQcDAgYIKwYBBQUHAwEGCCsGAQUF
1241 BwMJMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFLcX2hbqxe0fGElE09LjoDUK
1242 gZNgMB8GA1UdIwQYMBaAFLcX2hbqxe0fGElE09LjoDUKgZNgMAUGAytlcANBAPw+
1243 FOq7cMJvODRwvMin9HwNHijXKp8iikXoAnaEHi1kLR4JtSlxH5WKTnmHUWCa54ZA
1244 9mDH0e5odhcdkMySkwc=
1245 -----END CERTIFICATE-----`
1246
1247 var ed25519CRLKey = testingKey(`-----BEGIN TEST KEY-----
1248 MC4CAQAwBQYDK2VwBCIEINdKh2096vUBYu4EIFpjShsUSh3vimKya1sQ1YTT4RZG
1249 -----END TEST KEY-----`)
1250
1251 func TestCRLCreation(t *testing.T) {
1252         block, _ := pem.Decode([]byte(pemPrivateKey))
1253         privRSA, _ := ParsePKCS1PrivateKey(block.Bytes)
1254         block, _ = pem.Decode([]byte(pemCertificate))
1255         certRSA, _ := ParseCertificate(block.Bytes)
1256
1257         block, _ = pem.Decode([]byte(ed25519CRLKey))
1258         privEd25519, _ := ParsePKCS8PrivateKey(block.Bytes)
1259         block, _ = pem.Decode([]byte(ed25519CRLCertificate))
1260         certEd25519, _ := ParseCertificate(block.Bytes)
1261
1262         tests := []struct {
1263                 name string
1264                 priv any
1265                 cert *Certificate
1266         }{
1267                 {"RSA CA", privRSA, certRSA},
1268                 {"Ed25519 CA", privEd25519, certEd25519},
1269         }
1270
1271         loc := time.FixedZone("Oz/Atlantis", int((2 * time.Hour).Seconds()))
1272
1273         now := time.Unix(1000, 0).In(loc)
1274         nowUTC := now.UTC()
1275         expiry := time.Unix(10000, 0)
1276
1277         revokedCerts := []pkix.RevokedCertificate{
1278                 {
1279                         SerialNumber:   big.NewInt(1),
1280                         RevocationTime: nowUTC,
1281                 },
1282                 {
1283                         SerialNumber: big.NewInt(42),
1284                         // RevocationTime should be converted to UTC before marshaling.
1285                         RevocationTime: now,
1286                 },
1287         }
1288         expectedCerts := []pkix.RevokedCertificate{
1289                 {
1290                         SerialNumber:   big.NewInt(1),
1291                         RevocationTime: nowUTC,
1292                 },
1293                 {
1294                         SerialNumber:   big.NewInt(42),
1295                         RevocationTime: nowUTC,
1296                 },
1297         }
1298
1299         for _, test := range tests {
1300                 crlBytes, err := test.cert.CreateCRL(rand.Reader, test.priv, revokedCerts, now, expiry)
1301                 if err != nil {
1302                         t.Errorf("%s: error creating CRL: %s", test.name, err)
1303                 }
1304
1305                 parsedCRL, err := ParseDERCRL(crlBytes)
1306                 if err != nil {
1307                         t.Errorf("%s: error reparsing CRL: %s", test.name, err)
1308                 }
1309                 if !reflect.DeepEqual(parsedCRL.TBSCertList.RevokedCertificates, expectedCerts) {
1310                         t.Errorf("%s: RevokedCertificates mismatch: got %v; want %v.", test.name,
1311                                 parsedCRL.TBSCertList.RevokedCertificates, expectedCerts)
1312                 }
1313         }
1314 }
1315
1316 func fromBase64(in string) []byte {
1317         out := make([]byte, base64.StdEncoding.DecodedLen(len(in)))
1318         n, err := base64.StdEncoding.Decode(out, []byte(in))
1319         if err != nil {
1320                 panic("failed to base64 decode")
1321         }
1322         return out[:n]
1323 }
1324
1325 func TestParseDERCRL(t *testing.T) {
1326         derBytes := fromBase64(derCRLBase64)
1327         certList, err := ParseDERCRL(derBytes)
1328         if err != nil {
1329                 t.Errorf("error parsing: %s", err)
1330                 return
1331         }
1332         numCerts := len(certList.TBSCertList.RevokedCertificates)
1333         expected := 88
1334         if numCerts != expected {
1335                 t.Errorf("bad number of revoked certificates. got: %d want: %d", numCerts, expected)
1336         }
1337
1338         if certList.HasExpired(time.Unix(1302517272, 0)) {
1339                 t.Errorf("CRL has expired (but shouldn't have)")
1340         }
1341
1342         // Can't check the signature here without a package cycle.
1343 }
1344
1345 func TestCRLWithoutExpiry(t *testing.T) {
1346         derBytes := fromBase64("MIHYMIGZMAkGByqGSM44BAMwEjEQMA4GA1UEAxMHQ2FybERTUxcNOTkwODI3MDcwMDAwWjBpMBMCAgDIFw05OTA4MjIwNzAwMDBaMBMCAgDJFw05OTA4MjIwNzAwMDBaMBMCAgDTFw05OTA4MjIwNzAwMDBaMBMCAgDSFw05OTA4MjIwNzAwMDBaMBMCAgDUFw05OTA4MjQwNzAwMDBaMAkGByqGSM44BAMDLwAwLAIUfmVSdjP+NHMX0feW+aDU2G1cfT0CFAJ6W7fVWxjBz4fvftok8yqDnDWh")
1347         certList, err := ParseDERCRL(derBytes)
1348         if err != nil {
1349                 t.Fatal(err)
1350         }
1351         if !certList.TBSCertList.NextUpdate.IsZero() {
1352                 t.Errorf("NextUpdate is not the zero value")
1353         }
1354 }
1355
1356 func TestParsePEMCRL(t *testing.T) {
1357         pemBytes := fromBase64(pemCRLBase64)
1358         certList, err := ParseCRL(pemBytes)
1359         if err != nil {
1360                 t.Errorf("error parsing: %s", err)
1361                 return
1362         }
1363         numCerts := len(certList.TBSCertList.RevokedCertificates)
1364         expected := 2
1365         if numCerts != expected {
1366                 t.Errorf("bad number of revoked certificates. got: %d want: %d", numCerts, expected)
1367         }
1368
1369         if certList.HasExpired(time.Unix(1302517272, 0)) {
1370                 t.Errorf("CRL has expired (but shouldn't have)")
1371         }
1372
1373         // Can't check the signature here without a package cycle.
1374 }
1375
1376 func TestImports(t *testing.T) {
1377         if testing.Short() {
1378                 t.Skip("skipping in -short mode")
1379         }
1380         testenv.MustHaveGoRun(t)
1381
1382         if out, err := exec.Command(testenv.GoToolPath(t), "run", "x509_test_import.go").CombinedOutput(); err != nil {
1383                 t.Errorf("failed to run x509_test_import.go: %s\n%s", err, out)
1384         }
1385 }
1386
1387 const derCRLBase64 = "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"
1388
1389 const pemCRLBase64 = "LS0tLS1CRUdJTiBYNTA5IENSTC0tLS0tDQpNSUlCOWpDQ0FWOENBUUV3RFFZSktvWklodmNOQVFFRkJRQXdiREVhTUJnR0ExVUVDaE1SVWxOQklGTmxZM1Z5DQphWFI1SUVsdVl5NHhIakFjQmdOVkJBTVRGVkpUUVNCUWRXSnNhV01nVW05dmRDQkRRU0IyTVRFdU1Dd0dDU3FHDQpTSWIzRFFFSkFSWWZjbk5oYTJWdmJuSnZiM1J6YVdkdVFISnpZWE5sWTNWeWFYUjVMbU52YlJjTk1URXdNakl6DQpNVGt5T0RNd1doY05NVEV3T0RJeU1Ua3lPRE13V2pDQmpEQktBaEVBckRxb2g5RkhKSFhUN09QZ3V1bjQrQmNODQpNRGt4TVRBeU1UUXlOekE1V2pBbU1Bb0dBMVVkRlFRRENnRUpNQmdHQTFVZEdBUVJHQTh5TURBNU1URXdNakUwDQpNalExTlZvd1BnSVJBTEd6blowOTVQQjVhQU9MUGc1N2ZNTVhEVEF5TVRBeU16RTBOVEF4TkZvd0dqQVlCZ05WDQpIUmdFRVJnUE1qQXdNakV3TWpNeE5EVXdNVFJhb0RBd0xqQWZCZ05WSFNNRUdEQVdnQlQxVERGNlVRTS9MTmVMDQpsNWx2cUhHUXEzZzltekFMQmdOVkhSUUVCQUlDQUlRd0RRWUpLb1pJaHZjTkFRRUZCUUFEZ1lFQUZVNUFzNk16DQpxNVBSc2lmYW9iUVBHaDFhSkx5QytNczVBZ2MwYld5QTNHQWR4dXI1U3BQWmVSV0NCamlQL01FSEJXSkNsQkhQDQpHUmNxNXlJZDNFakRrYUV5eFJhK2k2N0x6dmhJNmMyOUVlNks5cFNZd2ppLzdSVWhtbW5Qclh0VHhsTDBsckxyDQptUVFKNnhoRFJhNUczUUE0Q21VZHNITnZicnpnbUNZcHZWRT0NCi0tLS0tRU5EIFg1MDkgQ1JMLS0tLS0NCg0K"
1390
1391 func TestCreateCertificateRequest(t *testing.T) {
1392         random := rand.Reader
1393
1394         ecdsa256Priv, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
1395         if err != nil {
1396                 t.Fatalf("Failed to generate ECDSA key: %s", err)
1397         }
1398
1399         ecdsa384Priv, err := ecdsa.GenerateKey(elliptic.P384(), rand.Reader)
1400         if err != nil {
1401                 t.Fatalf("Failed to generate ECDSA key: %s", err)
1402         }
1403
1404         ecdsa521Priv, err := ecdsa.GenerateKey(elliptic.P521(), rand.Reader)
1405         if err != nil {
1406                 t.Fatalf("Failed to generate ECDSA key: %s", err)
1407         }
1408
1409         _, ed25519Priv, err := ed25519.GenerateKey(random)
1410         if err != nil {
1411                 t.Fatalf("Failed to generate Ed25519 key: %s", err)
1412         }
1413
1414         tests := []struct {
1415                 name    string
1416                 priv    any
1417                 sigAlgo SignatureAlgorithm
1418         }{
1419                 {"RSA", testPrivateKey, SHA256WithRSA},
1420                 {"ECDSA-256", ecdsa256Priv, ECDSAWithSHA256},
1421                 {"ECDSA-384", ecdsa384Priv, ECDSAWithSHA256},
1422                 {"ECDSA-521", ecdsa521Priv, ECDSAWithSHA256},
1423                 {"Ed25519", ed25519Priv, PureEd25519},
1424         }
1425
1426         for _, test := range tests {
1427                 template := CertificateRequest{
1428                         Subject: pkix.Name{
1429                                 CommonName:   "test.example.com",
1430                                 Organization: []string{"Σ Acme Co"},
1431                         },
1432                         SignatureAlgorithm: test.sigAlgo,
1433                         DNSNames:           []string{"test.example.com"},
1434                         EmailAddresses:     []string{"gopher@golang.org"},
1435                         IPAddresses:        []net.IP{net.IPv4(127, 0, 0, 1).To4(), net.ParseIP("2001:4860:0:2001::68")},
1436                 }
1437
1438                 derBytes, err := CreateCertificateRequest(random, &template, test.priv)
1439                 if err != nil {
1440                         t.Errorf("%s: failed to create certificate request: %s", test.name, err)
1441                         continue
1442                 }
1443
1444                 out, err := ParseCertificateRequest(derBytes)
1445                 if err != nil {
1446                         t.Errorf("%s: failed to create certificate request: %s", test.name, err)
1447                         continue
1448                 }
1449
1450                 err = out.CheckSignature()
1451                 if err != nil {
1452                         t.Errorf("%s: failed to check certificate request signature: %s", test.name, err)
1453                         continue
1454                 }
1455
1456                 if out.Subject.CommonName != template.Subject.CommonName {
1457                         t.Errorf("%s: output subject common name and template subject common name don't match", test.name)
1458                 } else if len(out.Subject.Organization) != len(template.Subject.Organization) {
1459                         t.Errorf("%s: output subject organisation and template subject organisation don't match", test.name)
1460                 } else if len(out.DNSNames) != len(template.DNSNames) {
1461                         t.Errorf("%s: output DNS names and template DNS names don't match", test.name)
1462                 } else if len(out.EmailAddresses) != len(template.EmailAddresses) {
1463                         t.Errorf("%s: output email addresses and template email addresses don't match", test.name)
1464                 } else if len(out.IPAddresses) != len(template.IPAddresses) {
1465                         t.Errorf("%s: output IP addresses and template IP addresses names don't match", test.name)
1466                 }
1467         }
1468 }
1469
1470 func marshalAndParseCSR(t *testing.T, template *CertificateRequest) *CertificateRequest {
1471         derBytes, err := CreateCertificateRequest(rand.Reader, template, testPrivateKey)
1472         if err != nil {
1473                 t.Fatal(err)
1474         }
1475
1476         csr, err := ParseCertificateRequest(derBytes)
1477         if err != nil {
1478                 t.Fatal(err)
1479         }
1480
1481         return csr
1482 }
1483
1484 func TestCertificateRequestOverrides(t *testing.T) {
1485         sanContents, err := marshalSANs([]string{"foo.example.com"}, nil, nil, nil)
1486         if err != nil {
1487                 t.Fatal(err)
1488         }
1489
1490         template := CertificateRequest{
1491                 Subject: pkix.Name{
1492                         CommonName:   "test.example.com",
1493                         Organization: []string{"Σ Acme Co"},
1494                 },
1495                 DNSNames: []string{"test.example.com"},
1496
1497                 // An explicit extension should override the DNSNames from the
1498                 // template.
1499                 ExtraExtensions: []pkix.Extension{
1500                         {
1501                                 Id:       oidExtensionSubjectAltName,
1502                                 Value:    sanContents,
1503                                 Critical: true,
1504                         },
1505                 },
1506         }
1507
1508         csr := marshalAndParseCSR(t, &template)
1509
1510         if len(csr.DNSNames) != 1 || csr.DNSNames[0] != "foo.example.com" {
1511                 t.Errorf("Extension did not override template. Got %v\n", csr.DNSNames)
1512         }
1513
1514         if len(csr.Extensions) != 1 || !csr.Extensions[0].Id.Equal(oidExtensionSubjectAltName) || !csr.Extensions[0].Critical {
1515                 t.Errorf("SAN extension was not faithfully copied, got %#v", csr.Extensions)
1516         }
1517
1518         // If there is already an attribute with X.509 extensions then the
1519         // extra extensions should be added to it rather than creating a CSR
1520         // with two extension attributes.
1521
1522         template.Attributes = []pkix.AttributeTypeAndValueSET{
1523                 {
1524                         Type: oidExtensionRequest,
1525                         Value: [][]pkix.AttributeTypeAndValue{
1526                                 {
1527                                         {
1528                                                 Type:  oidExtensionAuthorityInfoAccess,
1529                                                 Value: []byte("foo"),
1530                                         },
1531                                 },
1532                         },
1533                 },
1534         }
1535
1536         csr = marshalAndParseCSR(t, &template)
1537         if l := len(csr.Attributes); l != 1 {
1538                 t.Errorf("incorrect number of attributes: %d\n", l)
1539         }
1540
1541         if !csr.Attributes[0].Type.Equal(oidExtensionRequest) ||
1542                 len(csr.Attributes[0].Value) != 1 ||
1543                 len(csr.Attributes[0].Value[0]) != 2 {
1544                 t.Errorf("bad attributes: %#v\n", csr.Attributes)
1545         }
1546
1547         sanContents2, err := marshalSANs([]string{"foo2.example.com"}, nil, nil, nil)
1548         if err != nil {
1549                 t.Fatal(err)
1550         }
1551
1552         // Extensions in Attributes should override those in ExtraExtensions.
1553         template.Attributes[0].Value[0] = append(template.Attributes[0].Value[0], pkix.AttributeTypeAndValue{
1554                 Type:  oidExtensionSubjectAltName,
1555                 Value: sanContents2,
1556         })
1557
1558         csr = marshalAndParseCSR(t, &template)
1559
1560         if len(csr.DNSNames) != 1 || csr.DNSNames[0] != "foo2.example.com" {
1561                 t.Errorf("Attributes did not override ExtraExtensions. Got %v\n", csr.DNSNames)
1562         }
1563 }
1564
1565 func TestParseCertificateRequest(t *testing.T) {
1566         for _, csrBase64 := range csrBase64Array {
1567                 csrBytes := fromBase64(csrBase64)
1568                 csr, err := ParseCertificateRequest(csrBytes)
1569                 if err != nil {
1570                         t.Fatalf("failed to parse CSR: %s", err)
1571                 }
1572
1573                 if len(csr.EmailAddresses) != 1 || csr.EmailAddresses[0] != "gopher@golang.org" {
1574                         t.Errorf("incorrect email addresses found: %v", csr.EmailAddresses)
1575                 }
1576
1577                 if len(csr.DNSNames) != 1 || csr.DNSNames[0] != "test.example.com" {
1578                         t.Errorf("incorrect DNS names found: %v", csr.DNSNames)
1579                 }
1580
1581                 if len(csr.Subject.Country) != 1 || csr.Subject.Country[0] != "AU" {
1582                         t.Errorf("incorrect Subject name: %v", csr.Subject)
1583                 }
1584
1585                 found := false
1586                 for _, e := range csr.Extensions {
1587                         if e.Id.Equal(oidExtensionBasicConstraints) {
1588                                 found = true
1589                                 break
1590                         }
1591                 }
1592                 if !found {
1593                         t.Errorf("basic constraints extension not found in CSR")
1594                 }
1595         }
1596 }
1597
1598 func TestCriticalFlagInCSRRequestedExtensions(t *testing.T) {
1599         // This CSR contains an extension request where the extensions have a
1600         // critical flag in them. In the past we failed to handle this.
1601         const csrBase64 = "MIICrTCCAZUCAQIwMzEgMB4GA1UEAwwXU0NFUCBDQSBmb3IgRGV2ZWxlciBTcmwxDzANBgNVBAsMBjQzNTk3MTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALFMAJ7Zy9YyfgbNlbUWAW0LalNRMPs7aXmLANsCpjhnw3lLlfDPaLeWyKh1nK5I5ojaJOW6KIOSAcJkDUe3rrE0wR0RVt3UxArqs0R/ND3u5Q+bDQY2X1HAFUHzUzcdm5JRAIA355v90teMckaWAIlkRQjDE22Lzc6NAl64KOd1rqOUNj8+PfX6fSo20jm94Pp1+a6mfk3G/RUWVuSm7owO5DZI/Fsi2ijdmb4NUar6K/bDKYTrDFkzcqAyMfP3TitUtBp19Mp3B1yAlHjlbp/r5fSSXfOGHZdgIvp0WkLuK2u5eQrX5l7HMB/5epgUs3HQxKY6ljhh5wAjDwz//LsCAwEAAaA1MDMGCSqGSIb3DQEJDjEmMCQwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAoQwDQYJKoZIhvcNAQEFBQADggEBAAMq3bxJSPQEgzLYR/yaVvgjCDrc3zUbIwdOis6Go06Q4RnjH5yRaSZAqZQTDsPurQcnz2I39VMGEiSkFJFavf4QHIZ7QFLkyXadMtALc87tm17Ej719SbHcBSSZayR9VYJUNXRLayI6HvyUrmqcMKh+iX3WY3ICr59/wlM0tYa8DYN4yzmOa2Onb29gy3YlaF5A2AKAMmk003cRT9gY26mjpv7d21czOSSeNyVIoZ04IR9ee71vWTMdv0hu/af5kSjQ+ZG5/Qgc0+mnECLz/1gtxt1srLYbtYQ/qAY8oX1DCSGFS61tN/vl+4cxGMD/VGcGzADRLRHSlVqy2Qgss6Q="
1602
1603         csrBytes := fromBase64(csrBase64)
1604         csr, err := ParseCertificateRequest(csrBytes)
1605         if err != nil {
1606                 t.Fatalf("failed to parse CSR: %s", err)
1607         }
1608
1609         expected := []struct {
1610                 Id    asn1.ObjectIdentifier
1611                 Value []byte
1612         }{
1613                 {oidExtensionBasicConstraints, fromBase64("MAYBAf8CAQA=")},
1614                 {oidExtensionKeyUsage, fromBase64("AwIChA==")},
1615         }
1616
1617         if n := len(csr.Extensions); n != len(expected) {
1618                 t.Fatalf("expected to find %d extensions but found %d", len(expected), n)
1619         }
1620
1621         for i, extension := range csr.Extensions {
1622                 if !extension.Id.Equal(expected[i].Id) {
1623                         t.Fatalf("extension #%d has unexpected type %v (expected %v)", i, extension.Id, expected[i].Id)
1624                 }
1625
1626                 if !bytes.Equal(extension.Value, expected[i].Value) {
1627                         t.Fatalf("extension #%d has unexpected contents %x (expected %x)", i, extension.Value, expected[i].Value)
1628                 }
1629         }
1630 }
1631
1632 // serialiseAndParse generates a self-signed certificate from template and
1633 // returns a parsed version of it.
1634 func serialiseAndParse(t *testing.T, template *Certificate) *Certificate {
1635         derBytes, err := CreateCertificate(rand.Reader, template, template, &testPrivateKey.PublicKey, testPrivateKey)
1636         if err != nil {
1637                 t.Fatalf("failed to create certificate: %s", err)
1638                 return nil
1639         }
1640
1641         cert, err := ParseCertificate(derBytes)
1642         if err != nil {
1643                 t.Fatalf("failed to parse certificate: %s", err)
1644                 return nil
1645         }
1646
1647         return cert
1648 }
1649
1650 func TestMaxPathLenNotCA(t *testing.T) {
1651         template := &Certificate{
1652                 SerialNumber: big.NewInt(1),
1653                 Subject: pkix.Name{
1654                         CommonName: "Σ Acme Co",
1655                 },
1656                 NotBefore: time.Unix(1000, 0),
1657                 NotAfter:  time.Unix(100000, 0),
1658
1659                 BasicConstraintsValid: true,
1660                 IsCA:                  false,
1661         }
1662         if m := serialiseAndParse(t, template).MaxPathLen; m != -1 {
1663                 t.Errorf("MaxPathLen should be -1 when IsCa is false, got %d", m)
1664         }
1665
1666         template.MaxPathLen = -1
1667         if m := serialiseAndParse(t, template).MaxPathLen; m != -1 {
1668                 t.Errorf("MaxPathLen should be -1 when IsCa is false and MaxPathLen set to -1, got %d", m)
1669         }
1670
1671         template.MaxPathLen = 5
1672         if _, err := CreateCertificate(rand.Reader, template, template, &testPrivateKey.PublicKey, testPrivateKey); err == nil {
1673                 t.Error("specifying a MaxPathLen when IsCA is false should fail")
1674         }
1675
1676         template.MaxPathLen = 0
1677         template.MaxPathLenZero = true
1678         if _, err := CreateCertificate(rand.Reader, template, template, &testPrivateKey.PublicKey, testPrivateKey); err == nil {
1679                 t.Error("setting MaxPathLenZero when IsCA is false should fail")
1680         }
1681
1682         template.BasicConstraintsValid = false
1683         if m := serialiseAndParse(t, template).MaxPathLen; m != 0 {
1684                 t.Errorf("Bad MaxPathLen should be ignored if BasicConstraintsValid is false, got %d", m)
1685         }
1686 }
1687
1688 func TestMaxPathLen(t *testing.T) {
1689         template := &Certificate{
1690                 SerialNumber: big.NewInt(1),
1691                 Subject: pkix.Name{
1692                         CommonName: "Σ Acme Co",
1693                 },
1694                 NotBefore: time.Unix(1000, 0),
1695                 NotAfter:  time.Unix(100000, 0),
1696
1697                 BasicConstraintsValid: true,
1698                 IsCA:                  true,
1699         }
1700
1701         cert1 := serialiseAndParse(t, template)
1702         if m := cert1.MaxPathLen; m != -1 {
1703                 t.Errorf("Omitting MaxPathLen didn't turn into -1, got %d", m)
1704         }
1705         if cert1.MaxPathLenZero {
1706                 t.Errorf("Omitting MaxPathLen resulted in MaxPathLenZero")
1707         }
1708
1709         template.MaxPathLen = 1
1710         cert2 := serialiseAndParse(t, template)
1711         if m := cert2.MaxPathLen; m != 1 {
1712                 t.Errorf("Setting MaxPathLen didn't work. Got %d but set 1", m)
1713         }
1714         if cert2.MaxPathLenZero {
1715                 t.Errorf("Setting MaxPathLen resulted in MaxPathLenZero")
1716         }
1717
1718         template.MaxPathLen = 0
1719         template.MaxPathLenZero = true
1720         cert3 := serialiseAndParse(t, template)
1721         if m := cert3.MaxPathLen; m != 0 {
1722                 t.Errorf("Setting MaxPathLenZero didn't work, got %d", m)
1723         }
1724         if !cert3.MaxPathLenZero {
1725                 t.Errorf("Setting MaxPathLen to zero didn't result in MaxPathLenZero")
1726         }
1727 }
1728
1729 func TestNoAuthorityKeyIdInSelfSignedCert(t *testing.T) {
1730         template := &Certificate{
1731                 SerialNumber: big.NewInt(1),
1732                 Subject: pkix.Name{
1733                         CommonName: "Σ Acme Co",
1734                 },
1735                 NotBefore: time.Unix(1000, 0),
1736                 NotAfter:  time.Unix(100000, 0),
1737
1738                 BasicConstraintsValid: true,
1739                 IsCA:                  true,
1740                 SubjectKeyId:          []byte{1, 2, 3, 4},
1741         }
1742
1743         if cert := serialiseAndParse(t, template); len(cert.AuthorityKeyId) != 0 {
1744                 t.Fatalf("self-signed certificate contained default authority key id")
1745         }
1746
1747         template.AuthorityKeyId = []byte{1, 2, 3, 4}
1748         if cert := serialiseAndParse(t, template); len(cert.AuthorityKeyId) == 0 {
1749                 t.Fatalf("self-signed certificate erased explicit authority key id")
1750         }
1751 }
1752
1753 func TestNoSubjectKeyIdInCert(t *testing.T) {
1754         template := &Certificate{
1755                 SerialNumber: big.NewInt(1),
1756                 Subject: pkix.Name{
1757                         CommonName: "Σ Acme Co",
1758                 },
1759                 NotBefore: time.Unix(1000, 0),
1760                 NotAfter:  time.Unix(100000, 0),
1761
1762                 BasicConstraintsValid: true,
1763                 IsCA:                  true,
1764         }
1765         if cert := serialiseAndParse(t, template); len(cert.SubjectKeyId) == 0 {
1766                 t.Fatalf("self-signed certificate did not generate subject key id using the public key")
1767         }
1768
1769         template.IsCA = false
1770         if cert := serialiseAndParse(t, template); len(cert.SubjectKeyId) != 0 {
1771                 t.Fatalf("self-signed certificate generated subject key id when it isn't a CA")
1772         }
1773
1774         template.SubjectKeyId = []byte{1, 2, 3, 4}
1775         if cert := serialiseAndParse(t, template); len(cert.SubjectKeyId) == 0 {
1776                 t.Fatalf("self-signed certificate erased explicit subject key id")
1777         }
1778 }
1779
1780 func TestASN1BitLength(t *testing.T) {
1781         tests := []struct {
1782                 bytes  []byte
1783                 bitLen int
1784         }{
1785                 {nil, 0},
1786                 {[]byte{0x00}, 0},
1787                 {[]byte{0x00, 0x00}, 0},
1788                 {[]byte{0xf0}, 4},
1789                 {[]byte{0x88}, 5},
1790                 {[]byte{0xff}, 8},
1791                 {[]byte{0xff, 0x80}, 9},
1792                 {[]byte{0xff, 0x81}, 16},
1793         }
1794
1795         for i, test := range tests {
1796                 if got := asn1BitLength(test.bytes); got != test.bitLen {
1797                         t.Errorf("#%d: calculated bit-length of %d for %x, wanted %d", i, got, test.bytes, test.bitLen)
1798                 }
1799         }
1800 }
1801
1802 func TestVerifyEmptyCertificate(t *testing.T) {
1803         if _, err := new(Certificate).Verify(VerifyOptions{}); err != errNotParsed {
1804                 t.Errorf("Verifying empty certificate resulted in unexpected error: %q (wanted %q)", err, errNotParsed)
1805         }
1806 }
1807
1808 func TestInsecureAlgorithmErrorString(t *testing.T) {
1809         tests := []struct {
1810                 sa   SignatureAlgorithm
1811                 want string
1812         }{
1813                 {MD5WithRSA, "x509: cannot verify signature: insecure algorithm MD5-RSA"},
1814                 {SHA1WithRSA, "x509: cannot verify signature: insecure algorithm SHA1-RSA (temporarily override with GODEBUG=x509sha1=1)"},
1815                 {ECDSAWithSHA1, "x509: cannot verify signature: insecure algorithm ECDSA-SHA1 (temporarily override with GODEBUG=x509sha1=1)"},
1816                 {MD2WithRSA, "x509: cannot verify signature: insecure algorithm MD2-RSA"},
1817                 {-1, "x509: cannot verify signature: insecure algorithm -1"},
1818                 {0, "x509: cannot verify signature: insecure algorithm 0"},
1819                 {9999, "x509: cannot verify signature: insecure algorithm 9999"},
1820         }
1821         for i, tt := range tests {
1822                 if got := fmt.Sprint(InsecureAlgorithmError(tt.sa)); got != tt.want {
1823                         t.Errorf("%d. mismatch.\n got: %s\nwant: %s\n", i, got, tt.want)
1824                 }
1825         }
1826 }
1827
1828 // These CSR was generated with OpenSSL:
1829 //
1830 //      openssl req -out CSR.csr -new -sha256 -nodes -keyout privateKey.key -config openssl.cnf
1831 //
1832 // With openssl.cnf containing the following sections:
1833 //
1834 //      [ v3_req ]
1835 //      basicConstraints = CA:FALSE
1836 //      keyUsage = nonRepudiation, digitalSignature, keyEncipherment
1837 //      subjectAltName = email:gopher@golang.org,DNS:test.example.com
1838 //      [ req_attributes ]
1839 //      challengePassword = ignored challenge
1840 //      unstructuredName  = ignored unstructured name
1841 var csrBase64Array = [...]string{
1842         // Just [ v3_req ]
1843         "MIIDHDCCAgQCAQAwfjELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDEUMBIGA1UEAwwLQ29tbW9uIE5hbWUxITAfBgkqhkiG9w0BCQEWEnRlc3RAZW1haWwuYWRkcmVzczCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAK1GY4YFx2ujlZEOJxQVYmsjUnLsd5nFVnNpLE4cV+77sgv9NPNlB8uhn3MXt5leD34rm/2BisCHOifPucYlSrszo2beuKhvwn4+2FxDmWtBEMu/QA16L5IvoOfYZm/gJTsPwKDqvaR0tTU67a9OtxwNTBMI56YKtmwd/o8d3hYv9cg+9ZGAZ/gKONcg/OWYx/XRh6bd0g8DMbCikpWgXKDsvvK1Nk+VtkDO1JxuBaj4Lz/p/MifTfnHoqHxWOWl4EaTs4Ychxsv34/rSj1KD1tJqorIv5Xv2aqv4sjxfbrYzX4kvS5SC1goIovLnhj5UjmQ3Qy8u65eow/LLWw+YFcCAwEAAaBZMFcGCSqGSIb3DQEJDjFKMEgwCQYDVR0TBAIwADALBgNVHQ8EBAMCBeAwLgYDVR0RBCcwJYERZ29waGVyQGdvbGFuZy5vcmeCEHRlc3QuZXhhbXBsZS5jb20wDQYJKoZIhvcNAQELBQADggEBAB6VPMRrchvNW61Tokyq3ZvO6/NoGIbuwUn54q6l5VZW0Ep5Nq8juhegSSnaJ0jrovmUgKDN9vEo2KxuAtwG6udS6Ami3zP+hRd4k9Q8djJPb78nrjzWiindLK5Fps9U5mMoi1ER8ViveyAOTfnZt/jsKUaRsscY2FzE9t9/o5moE6LTcHUS4Ap1eheR+J72WOnQYn3cifYaemsA9MJuLko+kQ6xseqttbh9zjqd9fiCSh/LNkzos9c+mg2yMADitaZinAh+HZi50ooEbjaT3erNq9O6RqwJlgD00g6MQdoz9bTAryCUhCQfkIaepmQ7BxS0pqWNW3MMwfDwx/Snz6g=",
1844         // Both [ v3_req ] and [ req_attributes ]
1845         "MIIDaTCCAlECAQAwfjELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDEUMBIGA1UEAwwLQ29tbW9uIE5hbWUxITAfBgkqhkiG9w0BCQEWEnRlc3RAZW1haWwuYWRkcmVzczCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAK1GY4YFx2ujlZEOJxQVYmsjUnLsd5nFVnNpLE4cV+77sgv9NPNlB8uhn3MXt5leD34rm/2BisCHOifPucYlSrszo2beuKhvwn4+2FxDmWtBEMu/QA16L5IvoOfYZm/gJTsPwKDqvaR0tTU67a9OtxwNTBMI56YKtmwd/o8d3hYv9cg+9ZGAZ/gKONcg/OWYx/XRh6bd0g8DMbCikpWgXKDsvvK1Nk+VtkDO1JxuBaj4Lz/p/MifTfnHoqHxWOWl4EaTs4Ychxsv34/rSj1KD1tJqorIv5Xv2aqv4sjxfbrYzX4kvS5SC1goIovLnhj5UjmQ3Qy8u65eow/LLWw+YFcCAwEAAaCBpTAgBgkqhkiG9w0BCQcxEwwRaWdub3JlZCBjaGFsbGVuZ2UwKAYJKoZIhvcNAQkCMRsMGWlnbm9yZWQgdW5zdHJ1Y3R1cmVkIG5hbWUwVwYJKoZIhvcNAQkOMUowSDAJBgNVHRMEAjAAMAsGA1UdDwQEAwIF4DAuBgNVHREEJzAlgRFnb3BoZXJAZ29sYW5nLm9yZ4IQdGVzdC5leGFtcGxlLmNvbTANBgkqhkiG9w0BAQsFAAOCAQEAgxe2N5O48EMsYE7o0rZBB0wi3Ov5/yYfnmmVI22Y3sP6VXbLDW0+UWIeSccOhzUCcZ/G4qcrfhhx6gTZTeA01nP7TdTJURvWAH5iFqj9sQ0qnLq6nEcVHij3sG6M5+BxAIVClQBk6lTCzgphc835Fjj6qSLuJ20XHdL5UfUbiJxx299CHgyBRL+hBUIPfz8p+ZgamyAuDLfnj54zzcRVyLlrmMLNPZNll1Q70RxoU6uWvLH8wB8vQe3Q/guSGubLyLRTUQVPh+dw1L4t8MKFWfX/48jwRM4gIRHFHPeAAE9D9YAoqdIvj/iFm/eQ++7DP8MDwOZWsXeB6jjwHuLmkQ==",
1846 }
1847
1848 var md5cert = `
1849 -----BEGIN CERTIFICATE-----
1850 MIIB4TCCAUoCCQCfmw3vMgPS5TANBgkqhkiG9w0BAQQFADA1MQswCQYDVQQGEwJB
1851 VTETMBEGA1UECBMKU29tZS1TdGF0ZTERMA8GA1UEChMITUQ1IEluYy4wHhcNMTUx
1852 MjAzMTkyOTMyWhcNMjkwODEyMTkyOTMyWjA1MQswCQYDVQQGEwJBVTETMBEGA1UE
1853 CBMKU29tZS1TdGF0ZTERMA8GA1UEChMITUQ1IEluYy4wgZ8wDQYJKoZIhvcNAQEB
1854 BQADgY0AMIGJAoGBANrq2nhLQj5mlXbpVX3QUPhfEm/vdEqPkoWtR/jRZIWm4WGf
1855 Wpq/LKHJx2Pqwn+t117syN8l4U5unyAi1BJSXjBwPZNd7dXjcuJ+bRLV7FZ/iuvs
1856 cfYyQQFTxan4TaJMd0x1HoNDbNbjHa02IyjjYE/r3mb/PIg+J2t5AZEh80lPAgMB
1857 AAEwDQYJKoZIhvcNAQEEBQADgYEAjGzp3K3ey/YfKHohf33yHHWd695HQxDAP+wY
1858 cs9/TAyLR+gJzJP7d18EcDDLJWVi7bhfa4EAD86di05azOh9kWSn4b3o9QYRGCSw
1859 GNnI3Zk0cwNKA49hZntKKiy22DhRk7JAHF01d6Bu3KkHkmENrtJ+zj/+159WAnUa
1860 qViorq4=
1861 -----END CERTIFICATE-----
1862 `
1863
1864 func TestMD5(t *testing.T) {
1865         pemBlock, _ := pem.Decode([]byte(md5cert))
1866         cert, err := ParseCertificate(pemBlock.Bytes)
1867         if err != nil {
1868                 t.Fatalf("failed to parse certificate: %s", err)
1869         }
1870         if sa := cert.SignatureAlgorithm; sa != MD5WithRSA {
1871                 t.Errorf("signature algorithm is %v, want %v", sa, MD5WithRSA)
1872         }
1873         if err = cert.CheckSignatureFrom(cert); err == nil {
1874                 t.Fatalf("certificate verification succeeded incorrectly")
1875         }
1876         if _, ok := err.(InsecureAlgorithmError); !ok {
1877                 t.Fatalf("certificate verification returned %v (%T), wanted InsecureAlgorithmError", err, err)
1878         }
1879 }
1880
1881 func TestSHA1(t *testing.T) {
1882         pemBlock, _ := pem.Decode([]byte(ecdsaSHA1CertPem))
1883         cert, err := ParseCertificate(pemBlock.Bytes)
1884         if err != nil {
1885                 t.Fatalf("failed to parse certificate: %s", err)
1886         }
1887         if sa := cert.SignatureAlgorithm; sa != ECDSAWithSHA1 {
1888                 t.Errorf("signature algorithm is %v, want %v", sa, ECDSAWithSHA1)
1889         }
1890         if err = cert.CheckSignatureFrom(cert); err == nil {
1891                 t.Fatalf("certificate verification succeeded incorrectly")
1892         }
1893         if _, ok := err.(InsecureAlgorithmError); !ok {
1894                 t.Fatalf("certificate verification returned %v (%T), wanted InsecureAlgorithmError", err, err)
1895         }
1896
1897         t.Setenv("GODEBUG", "x509sha1=1")
1898         if err = cert.CheckSignatureFrom(cert); err != nil {
1899                 t.Fatalf("SHA-1 certificate did not verify with GODEBUG=x509sha1=1: %v", err)
1900         }
1901 }
1902
1903 // certMissingRSANULL contains an RSA public key where the AlgorithmIdentifier
1904 // parameters are omitted rather than being an ASN.1 NULL.
1905 const certMissingRSANULL = `
1906 -----BEGIN CERTIFICATE-----
1907 MIIB7TCCAVigAwIBAgIBADALBgkqhkiG9w0BAQUwJjEQMA4GA1UEChMHQWNtZSBD
1908 bzESMBAGA1UEAxMJMTI3LjAuMC4xMB4XDTExMTIwODA3NTUxMloXDTEyMTIwNzA4
1909 MDAxMlowJjEQMA4GA1UEChMHQWNtZSBDbzESMBAGA1UEAxMJMTI3LjAuMC4xMIGc
1910 MAsGCSqGSIb3DQEBAQOBjAAwgYgCgYBO0Hsx44Jk2VnAwoekXh6LczPHY1PfZpIG
1911 hPZk1Y/kNqcdK+izIDZFI7Xjla7t4PUgnI2V339aEu+H5Fto5OkOdOwEin/ekyfE
1912 ARl6vfLcPRSr0FTKIQzQTW6HLlzF0rtNS0/Otiz3fojsfNcCkXSmHgwa2uNKWi7e
1913 E5xMQIhZkwIDAQABozIwMDAOBgNVHQ8BAf8EBAMCAKAwDQYDVR0OBAYEBAECAwQw
1914 DwYDVR0jBAgwBoAEAQIDBDALBgkqhkiG9w0BAQUDgYEANh+zegx1yW43RmEr1b3A
1915 p0vMRpqBWHyFeSnIyMZn3TJWRSt1tukkqVCavh9a+hoV2cxVlXIWg7nCto/9iIw4
1916 hB2rXZIxE0/9gzvGnfERYraL7KtnvshksBFQRlgXa5kc0x38BvEO5ZaoDPl4ILdE
1917 GFGNEH5PlGffo05wc46QkYU=
1918 -----END CERTIFICATE-----`
1919
1920 func TestRSAMissingNULLParameters(t *testing.T) {
1921         block, _ := pem.Decode([]byte(certMissingRSANULL))
1922         if _, err := ParseCertificate(block.Bytes); err == nil {
1923                 t.Error("unexpected success when parsing certificate with missing RSA NULL parameter")
1924         } else if !strings.Contains(err.Error(), "missing NULL") {
1925                 t.Errorf("unrecognised error when parsing certificate with missing RSA NULL parameter: %s", err)
1926         }
1927 }
1928
1929 const certISOOID = `
1930 -----BEGIN CERTIFICATE-----
1931 MIIB5TCCAVKgAwIBAgIQtwyL3RPWV7dJQp34HwZG9DAJBgUrDgMCHQUAMBExDzAN
1932 BgNVBAMTBm15dGVzdDAeFw0xNjA4MDkyMjExMDVaFw0zOTEyMzEyMzU5NTlaMBEx
1933 DzANBgNVBAMTBm15dGVzdDCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEArzIH
1934 GsyDB3ohIGkkvijF2PTRUX1bvOtY1eUUpjwHyu0twpAKSuaQv2Ha+/63+aHe8O86
1935 BT+98wjXFX6RFSagtAujo80rIF2dSm33BGt18pDN8v6zp93dnAm0jRaSQrHJ75xw
1936 5O+S1oEYR1LtUoFJy6qB104j6aINBAgOiLIKiMkCAwEAAaNGMEQwQgYDVR0BBDsw
1937 OYAQVuYVQ/WDjdGSkZRlTtJDNKETMBExDzANBgNVBAMTBm15dGVzdIIQtwyL3RPW
1938 V7dJQp34HwZG9DAJBgUrDgMCHQUAA4GBABngrSkH7vG5lY4sa4AZF59lAAXqBVJE
1939 J4TBiKC62hCdZv18rBleP6ETfhbPg7pTs8p4ebQbpmtNxRS9Lw3MzQ8Ya5Ybwzj2
1940 NwBSyCtCQl7mrEg4nJqJl4A2EUhnET/oVxU0oTV/SZ3ziGXcY1oG1s6vidV7TZTu
1941 MCRtdSdaM7g3
1942 -----END CERTIFICATE-----`
1943
1944 func TestISOOIDInCertificate(t *testing.T) {
1945         block, _ := pem.Decode([]byte(certISOOID))
1946         if cert, err := ParseCertificate(block.Bytes); err != nil {
1947                 t.Errorf("certificate with ISO OID failed to parse: %s", err)
1948         } else if cert.SignatureAlgorithm == UnknownSignatureAlgorithm {
1949                 t.Errorf("ISO OID not recognised in certificate")
1950         }
1951 }
1952
1953 // certMultipleRDN contains a RelativeDistinguishedName with two elements (the
1954 // common name and serial number). This particular certificate was the first
1955 // such certificate in the “Pilot” Certificate Transparency log.
1956 const certMultipleRDN = `
1957 -----BEGIN CERTIFICATE-----
1958 MIIFRzCCBC+gAwIBAgIEOl59NTANBgkqhkiG9w0BAQUFADA9MQswCQYDVQQGEwJz
1959 aTEbMBkGA1UEChMSc3RhdGUtaW5zdGl0dXRpb25zMREwDwYDVQQLEwhzaWdvdi1j
1960 YTAeFw0xMjExMTYxMDUyNTdaFw0xNzExMTYxMjQ5MDVaMIGLMQswCQYDVQQGEwJz
1961 aTEbMBkGA1UEChMSc3RhdGUtaW5zdGl0dXRpb25zMRkwFwYDVQQLExB3ZWItY2Vy
1962 dGlmaWNhdGVzMRAwDgYDVQQLEwdTZXJ2ZXJzMTIwFAYDVQQFEw0xMjM2NDg0MDEw
1963 MDEwMBoGA1UEAxMTZXBvcnRhbC5tc3MuZWR1cy5zaTCCASIwDQYJKoZIhvcNAQEB
1964 BQADggEPADCCAQoCggEBAMrNkZH9MPuBTjMGNk3sJX8V+CkFx/4ru7RTlLS6dlYM
1965 098dtSfJ3s2w0p/1NB9UmR8j0yS0Kg6yoZ3ShsSO4DWBtcQD8820a6BYwqxxQTNf
1966 HSRZOc+N/4TQrvmK6t4k9Aw+YEYTMrWOU4UTeyhDeCcUsBdh7HjfWsVaqNky+2sv
1967 oic3zP5gF+2QfPkvOoHT3FLR8olNhViIE6Kk3eFIEs4dkq/ZzlYdLb8pHQoj/sGI
1968 zFmA5AFvm1HURqOmJriFjBwaCtn8AVEYOtQrnUCzJYu1ex8azyS2ZgYMX0u8A5Z/
1969 y2aMS/B2W+H79WcgLpK28vPwe7vam0oFrVytAd+u65ECAwEAAaOCAf4wggH6MA4G
1970 A1UdDwEB/wQEAwIFoDBABgNVHSAEOTA3MDUGCisGAQQBr1kBAwMwJzAlBggrBgEF
1971 BQcCARYZaHR0cDovL3d3dy5jYS5nb3Yuc2kvY3BzLzAfBgNVHREEGDAWgRRwb2Rw
1972 b3JhLm1pemtzQGdvdi5zaTCB8QYDVR0fBIHpMIHmMFWgU6BRpE8wTTELMAkGA1UE
1973 BhMCc2kxGzAZBgNVBAoTEnN0YXRlLWluc3RpdHV0aW9uczERMA8GA1UECxMIc2ln
1974 b3YtY2ExDjAMBgNVBAMTBUNSTDM5MIGMoIGJoIGGhldsZGFwOi8veDUwMC5nb3Yu
1975 c2kvb3U9c2lnb3YtY2Esbz1zdGF0ZS1pbnN0aXR1dGlvbnMsYz1zaT9jZXJ0aWZp
1976 Y2F0ZVJldm9jYXRpb25MaXN0P2Jhc2WGK2h0dHA6Ly93d3cuc2lnb3YtY2EuZ292
1977 LnNpL2NybC9zaWdvdi1jYS5jcmwwKwYDVR0QBCQwIoAPMjAxMjExMTYxMDUyNTda
1978 gQ8yMDE3MTExNjEyNDkwNVowHwYDVR0jBBgwFoAUHvjUU2uzgwbpBAZXAvmlv8ZY
1979 PHIwHQYDVR0OBBYEFGI1Duuu+wTGDZka/xHNbwcbM69ZMAkGA1UdEwQCMAAwGQYJ
1980 KoZIhvZ9B0EABAwwChsEVjcuMQMCA6gwDQYJKoZIhvcNAQEFBQADggEBAHny0K1y
1981 BQznrzDu3DDpBcGYguKU0dvU9rqsV1ua4nxkriSMWjgsX6XJFDdDW60I3P4VWab5
1982 ag5fZzbGqi8kva/CzGgZh+CES0aWCPy+4Gb8lwOTt+854/laaJvd6kgKTER7z7U9
1983 9C86Ch2y4sXNwwwPJ1A9dmrZJZOcJjS/WYZgwaafY2Hdxub5jqPE5nehwYUPVu9R
1984 uH6/skk4OEKcfOtN0hCnISOVuKYyS4ANARWRG5VGHIH06z3lGUVARFRJ61gtAprd
1985 La+fgSS+LVZ+kU2TkeoWAKvGq8MAgDq4D4Xqwekg7WKFeuyusi/NI5rm40XgjBMF
1986 DF72IUofoVt7wo0=
1987 -----END CERTIFICATE-----`
1988
1989 func TestMultipleRDN(t *testing.T) {
1990         block, _ := pem.Decode([]byte(certMultipleRDN))
1991         cert, err := ParseCertificate(block.Bytes)
1992         if err != nil {
1993                 t.Fatalf("certificate with two elements in an RDN failed to parse: %v", err)
1994         }
1995
1996         if want := "eportal.mss.edus.si"; cert.Subject.CommonName != want {
1997                 t.Errorf("got common name of %q, but want %q", cert.Subject.CommonName, want)
1998         }
1999
2000         if want := "1236484010010"; cert.Subject.SerialNumber != want {
2001                 t.Errorf("got serial number of %q, but want %q", cert.Subject.SerialNumber, want)
2002         }
2003 }
2004
2005 func TestSystemCertPool(t *testing.T) {
2006         if runtime.GOOS == "windows" || runtime.GOOS == "darwin" || runtime.GOOS == "ios" {
2007                 t.Skip("not implemented on Windows (Issue 16736, 18609) or darwin (Issue 46287)")
2008         }
2009         a, err := SystemCertPool()
2010         if err != nil {
2011                 t.Fatal(err)
2012         }
2013         b, err := SystemCertPool()
2014         if err != nil {
2015                 t.Fatal(err)
2016         }
2017         if !certPoolEqual(a, b) {
2018                 t.Fatal("two calls to SystemCertPool had different results")
2019         }
2020         if ok := b.AppendCertsFromPEM([]byte(`
2021 -----BEGIN CERTIFICATE-----
2022 MIIDBjCCAe6gAwIBAgIRANXM5I3gjuqDfTp/PYrs+u8wDQYJKoZIhvcNAQELBQAw
2023 EjEQMA4GA1UEChMHQWNtZSBDbzAeFw0xODAzMjcxOTU2MjFaFw0xOTAzMjcxOTU2
2024 MjFaMBIxEDAOBgNVBAoTB0FjbWUgQ28wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAw
2025 ggEKAoIBAQDK+9m3rjsO2Djes6bIYQZ3eV29JF09ZrjOrEHLtaKrD6/acsoSoTsf
2026 cQr+rzzztdB5ijWXCS64zo/0OiqBeZUNZ67jVdToa9qW5UYe2H0Y+ZNdfA5GYMFD
2027 yk/l3/uBu3suTZPfXiW2TjEi27Q8ruNUIZ54DpTcs6y2rBRFzadPWwn/VQMlvRXM
2028 jrzl8Y08dgnYmaAHprxVzwMXcQ/Brol+v9GvjaH1DooHqkn8O178wsPQNhdtvN01
2029 IXL46cYdcUwWrE/GX5u+9DaSi+0KWxAPQ+NVD5qUI0CKl4714yGGh7feXMjJdHgl
2030 VG4QJZlJvC4FsURgCHJT6uHGIelnSwhbAgMBAAGjVzBVMA4GA1UdDwEB/wQEAwIF
2031 oDATBgNVHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMCAGA1UdEQQZMBeC
2032 FVRlc3RTeXN0ZW1DZXJ0UG9vbC5nbzANBgkqhkiG9w0BAQsFAAOCAQEAwuSRx/VR
2033 BKh2ICxZjL6jBwk/7UlU1XKbhQD96RqkidDNGEc6eLZ90Z5XXTurEsXqdm5jQYPs
2034 1cdcSW+fOSMl7MfW9e5tM66FaIPZl9rKZ1r7GkOfgn93xdLAWe8XHd19xRfDreub
2035 YC8DVqgLASOEYFupVSl76ktPfxkU5KCvmUf3P2PrRybk1qLGFytGxfyice2gHSNI
2036 gify3K/+H/7wCkyFW4xYvzl7WW4mXxoqPRPjQt1J423DhnnQ4G1P8V/vhUpXNXOq
2037 N9IEPnWuihC09cyx/WMQIUlWnaQLHdfpPS04Iez3yy2PdfXJzwfPrja7rNE+skK6
2038 pa/O1nF0AfWOpw==
2039 -----END CERTIFICATE-----
2040         `)); !ok {
2041                 t.Fatal("AppendCertsFromPEM failed")
2042         }
2043         if reflect.DeepEqual(a, b) {
2044                 t.Fatal("changing one pool modified the other")
2045         }
2046 }
2047
2048 const emptyNameConstraintsPEM = `
2049 -----BEGIN CERTIFICATE-----
2050 MIIC1jCCAb6gAwIBAgICEjQwDQYJKoZIhvcNAQELBQAwKDEmMCQGA1UEAxMdRW1w
2051 dHkgbmFtZSBjb25zdHJhaW50cyBpc3N1ZXIwHhcNMTMwMjAxMDAwMDAwWhcNMjAw
2052 NTMwMTA0ODM4WjAhMR8wHQYDVQQDExZFbXB0eSBuYW1lIGNvbnN0cmFpbnRzMIIB
2053 IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwriElUIt3LCqmJObs+yDoWPD
2054 F5IqgWk6moIobYjPfextZiYU6I3EfvAwoNxPDkN2WowcocUZMJbEeEq5ebBksFnx
2055 f12gBxlIViIYwZAzu7aFvhDMyPKQI3C8CG0ZSC9ABZ1E3umdA3CEueNOmP/TChNq
2056 Cl23+BG1Qb/PJkpAO+GfpWSVhTcV53Mf/cKvFHcjGNrxzdSoq9fyW7a6gfcGEQY0
2057 LVkmwFWUfJ0wT8kaeLr0E0tozkIfo01KNWNzv6NcYP80QOBRDlApWu9ODmEVJHPD
2058 blx4jzTQ3JLa+4DvBNOjVUOp+mgRmjiW0rLdrxwOxIqIOwNjweMCp/hgxX/hTQID
2059 AQABoxEwDzANBgNVHR4EBjAEoAChADANBgkqhkiG9w0BAQsFAAOCAQEAWG+/zUMH
2060 QhP8uNCtgSHyim/vh7wminwAvWgMKxlkLBFns6nZeQqsOV1lABY7U0Zuoqa1Z5nb
2061 6L+iJa4ElREJOi/erLc9uLwBdDCAR0hUTKD7a6i4ooS39DTle87cUnj0MW1CUa6H
2062 v5SsvpYW+1XleYJk/axQOOTcy4Es53dvnZsjXH0EA/QHnn7UV+JmlE3rtVxcYp6M
2063 LYPmRhTioROA/drghicRkiu9hxdPyxkYS16M5g3Zj30jdm+k/6C6PeNtN9YmOOga
2064 nCOSyFYfGhqOANYzpmuV+oIedAsPpIbfIzN8njYUs1zio+1IoI4o8ddM9sCbtPU8
2065 o+WoY6IsCKXV/g==
2066 -----END CERTIFICATE-----`
2067
2068 func TestEmptyNameConstraints(t *testing.T) {
2069         block, _ := pem.Decode([]byte(emptyNameConstraintsPEM))
2070         _, err := ParseCertificate(block.Bytes)
2071         if err == nil {
2072                 t.Fatal("unexpected success")
2073         }
2074
2075         const expected = "empty name constraints"
2076         if str := err.Error(); !strings.Contains(str, expected) {
2077                 t.Errorf("expected %q in error but got %q", expected, str)
2078         }
2079 }
2080
2081 func TestPKIXNameString(t *testing.T) {
2082         der, err := base64.StdEncoding.DecodeString(certBytes)
2083         if err != nil {
2084                 t.Fatal(err)
2085         }
2086         certs, err := ParseCertificates(der)
2087         if err != nil {
2088                 t.Fatal(err)
2089         }
2090
2091         // Check that parsed non-standard attributes are printed.
2092         rdns := pkix.Name{
2093                 Locality: []string{"Gophertown"},
2094                 ExtraNames: []pkix.AttributeTypeAndValue{
2095                         {Type: asn1.ObjectIdentifier([]int{1, 2, 3, 4, 5}), Value: "golang.org"}},
2096         }.ToRDNSequence()
2097         nn := pkix.Name{}
2098         nn.FillFromRDNSequence(&rdns)
2099
2100         // Check that zero-length non-nil ExtraNames hide Names.
2101         extra := []pkix.AttributeTypeAndValue{
2102                 {Type: asn1.ObjectIdentifier([]int{1, 2, 3, 4, 5}), Value: "backing array"}}
2103         extraNotNil := pkix.Name{
2104                 Locality:   []string{"Gophertown"},
2105                 ExtraNames: extra[:0],
2106                 Names: []pkix.AttributeTypeAndValue{
2107                         {Type: asn1.ObjectIdentifier([]int{1, 2, 3, 4, 5}), Value: "golang.org"}},
2108         }
2109
2110         tests := []struct {
2111                 dn   pkix.Name
2112                 want string
2113         }{
2114                 {nn, "L=Gophertown,1.2.3.4.5=#130a676f6c616e672e6f7267"},
2115                 {extraNotNil, "L=Gophertown"},
2116                 {pkix.Name{
2117                         CommonName:         "Steve Kille",
2118                         Organization:       []string{"Isode Limited"},
2119                         OrganizationalUnit: []string{"RFCs"},
2120                         Locality:           []string{"Richmond"},
2121                         Province:           []string{"Surrey"},
2122                         StreetAddress:      []string{"The Square"},
2123                         PostalCode:         []string{"TW9 1DT"},
2124                         SerialNumber:       "RFC 2253",
2125                         Country:            []string{"GB"},
2126                 }, "SERIALNUMBER=RFC 2253,CN=Steve Kille,OU=RFCs,O=Isode Limited,POSTALCODE=TW9 1DT,STREET=The Square,L=Richmond,ST=Surrey,C=GB"},
2127                 {certs[0].Subject,
2128                         "CN=mail.google.com,O=Google LLC,L=Mountain View,ST=California,C=US"},
2129                 {pkix.Name{
2130                         Organization: []string{"#Google, Inc. \n-> 'Alphabet\" "},
2131                         Country:      []string{"US"},
2132                 }, "O=\\#Google\\, Inc. \n-\\> 'Alphabet\\\"\\ ,C=US"},
2133                 {pkix.Name{
2134                         CommonName:   "foo.com",
2135                         Organization: []string{"Gopher Industries"},
2136                         ExtraNames: []pkix.AttributeTypeAndValue{
2137                                 {Type: asn1.ObjectIdentifier([]int{2, 5, 4, 3}), Value: "bar.com"}},
2138                 }, "CN=bar.com,O=Gopher Industries"},
2139                 {pkix.Name{
2140                         Locality: []string{"Gophertown"},
2141                         ExtraNames: []pkix.AttributeTypeAndValue{
2142                                 {Type: asn1.ObjectIdentifier([]int{1, 2, 3, 4, 5}), Value: "golang.org"}},
2143                 }, "1.2.3.4.5=#130a676f6c616e672e6f7267,L=Gophertown"},
2144                 // If there are no ExtraNames, the Names are printed instead.
2145                 {pkix.Name{
2146                         Locality: []string{"Gophertown"},
2147                         Names: []pkix.AttributeTypeAndValue{
2148                                 {Type: asn1.ObjectIdentifier([]int{1, 2, 3, 4, 5}), Value: "golang.org"}},
2149                 }, "L=Gophertown,1.2.3.4.5=#130a676f6c616e672e6f7267"},
2150                 // If there are both, print only the ExtraNames.
2151                 {pkix.Name{
2152                         Locality: []string{"Gophertown"},
2153                         ExtraNames: []pkix.AttributeTypeAndValue{
2154                                 {Type: asn1.ObjectIdentifier([]int{1, 2, 3, 4, 5}), Value: "golang.org"}},
2155                         Names: []pkix.AttributeTypeAndValue{
2156                                 {Type: asn1.ObjectIdentifier([]int{1, 2, 3, 4, 6}), Value: "example.com"}},
2157                 }, "1.2.3.4.5=#130a676f6c616e672e6f7267,L=Gophertown"},
2158         }
2159
2160         for i, test := range tests {
2161                 if got := test.dn.String(); got != test.want {
2162                         t.Errorf("#%d: String() = \n%s\n, want \n%s", i, got, test.want)
2163                 }
2164         }
2165
2166         if extra[0].Value != "backing array" {
2167                 t.Errorf("the backing array of an empty ExtraNames got modified by String")
2168         }
2169 }
2170
2171 func TestRDNSequenceString(t *testing.T) {
2172         // Test some extra cases that get lost in pkix.Name conversions such as
2173         // multi-valued attributes.
2174
2175         var (
2176                 oidCountry            = []int{2, 5, 4, 6}
2177                 oidOrganization       = []int{2, 5, 4, 10}
2178                 oidOrganizationalUnit = []int{2, 5, 4, 11}
2179                 oidCommonName         = []int{2, 5, 4, 3}
2180         )
2181
2182         tests := []struct {
2183                 seq  pkix.RDNSequence
2184                 want string
2185         }{
2186                 {
2187                         seq: pkix.RDNSequence{
2188                                 pkix.RelativeDistinguishedNameSET{
2189                                         pkix.AttributeTypeAndValue{Type: oidCountry, Value: "US"},
2190                                 },
2191                                 pkix.RelativeDistinguishedNameSET{
2192                                         pkix.AttributeTypeAndValue{Type: oidOrganization, Value: "Widget Inc."},
2193                                 },
2194                                 pkix.RelativeDistinguishedNameSET{
2195                                         pkix.AttributeTypeAndValue{Type: oidOrganizationalUnit, Value: "Sales"},
2196                                         pkix.AttributeTypeAndValue{Type: oidCommonName, Value: "J. Smith"},
2197                                 },
2198                         },
2199                         want: "OU=Sales+CN=J. Smith,O=Widget Inc.,C=US",
2200                 },
2201         }
2202
2203         for i, test := range tests {
2204                 if got := test.seq.String(); got != test.want {
2205                         t.Errorf("#%d: String() = \n%s\n, want \n%s", i, got, test.want)
2206                 }
2207         }
2208 }
2209
2210 const criticalNameConstraintWithUnknownTypePEM = `
2211 -----BEGIN CERTIFICATE-----
2212 MIIC/TCCAeWgAwIBAgICEjQwDQYJKoZIhvcNAQELBQAwKDEmMCQGA1UEAxMdRW1w
2213 dHkgbmFtZSBjb25zdHJhaW50cyBpc3N1ZXIwHhcNMTMwMjAxMDAwMDAwWhcNMjAw
2214 NTMwMTA0ODM4WjAhMR8wHQYDVQQDExZFbXB0eSBuYW1lIGNvbnN0cmFpbnRzMIIB
2215 IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwriElUIt3LCqmJObs+yDoWPD
2216 F5IqgWk6moIobYjPfextZiYU6I3EfvAwoNxPDkN2WowcocUZMJbEeEq5ebBksFnx
2217 f12gBxlIViIYwZAzu7aFvhDMyPKQI3C8CG0ZSC9ABZ1E3umdA3CEueNOmP/TChNq
2218 Cl23+BG1Qb/PJkpAO+GfpWSVhTcV53Mf/cKvFHcjGNrxzdSoq9fyW7a6gfcGEQY0
2219 LVkmwFWUfJ0wT8kaeLr0E0tozkIfo01KNWNzv6NcYP80QOBRDlApWu9ODmEVJHPD
2220 blx4jzTQ3JLa+4DvBNOjVUOp+mgRmjiW0rLdrxwOxIqIOwNjweMCp/hgxX/hTQID
2221 AQABozgwNjA0BgNVHR4BAf8EKjAooCQwIokgIACrzQAAAAAAAAAAAAAAAP////8A
2222 AAAAAAAAAAAAAAChADANBgkqhkiG9w0BAQsFAAOCAQEAWG+/zUMHQhP8uNCtgSHy
2223 im/vh7wminwAvWgMKxlkLBFns6nZeQqsOV1lABY7U0Zuoqa1Z5nb6L+iJa4ElREJ
2224 Oi/erLc9uLwBdDCAR0hUTKD7a6i4ooS39DTle87cUnj0MW1CUa6Hv5SsvpYW+1Xl
2225 eYJk/axQOOTcy4Es53dvnZsjXH0EA/QHnn7UV+JmlE3rtVxcYp6MLYPmRhTioROA
2226 /drghicRkiu9hxdPyxkYS16M5g3Zj30jdm+k/6C6PeNtN9YmOOganCOSyFYfGhqO
2227 ANYzpmuV+oIedAsPpIbfIzN8njYUs1zio+1IoI4o8ddM9sCbtPU8o+WoY6IsCKXV
2228 /g==
2229 -----END CERTIFICATE-----`
2230
2231 func TestCriticalNameConstraintWithUnknownType(t *testing.T) {
2232         block, _ := pem.Decode([]byte(criticalNameConstraintWithUnknownTypePEM))
2233         cert, err := ParseCertificate(block.Bytes)
2234         if err != nil {
2235                 t.Fatalf("unexpected parsing failure: %s", err)
2236         }
2237
2238         if l := len(cert.UnhandledCriticalExtensions); l != 1 {
2239                 t.Fatalf("expected one unhandled critical extension, but found %d", l)
2240         }
2241 }
2242
2243 const badIPMaskPEM = `
2244 -----BEGIN CERTIFICATE-----
2245 MIICzzCCAbegAwIBAgICEjQwDQYJKoZIhvcNAQELBQAwHTEbMBkGA1UEAxMSQmFk
2246 IElQIG1hc2sgaXNzdWVyMB4XDTEzMDIwMTAwMDAwMFoXDTIwMDUzMDEwNDgzOFow
2247 FjEUMBIGA1UEAxMLQmFkIElQIG1hc2swggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAw
2248 ggEKAoIBAQDCuISVQi3csKqYk5uz7IOhY8MXkiqBaTqagihtiM997G1mJhTojcR+
2249 8DCg3E8OQ3ZajByhxRkwlsR4Srl5sGSwWfF/XaAHGUhWIhjBkDO7toW+EMzI8pAj
2250 cLwIbRlIL0AFnUTe6Z0DcIS5406Y/9MKE2oKXbf4EbVBv88mSkA74Z+lZJWFNxXn
2251 cx/9wq8UdyMY2vHN1Kir1/JbtrqB9wYRBjQtWSbAVZR8nTBPyRp4uvQTS2jOQh+j
2252 TUo1Y3O/o1xg/zRA4FEOUCla704OYRUkc8NuXHiPNNDcktr7gO8E06NVQ6n6aBGa
2253 OJbSst2vHA7Eiog7A2PB4wKn+GDFf+FNAgMBAAGjIDAeMBwGA1UdHgEB/wQSMBCg
2254 DDAKhwgBAgME//8BAKEAMA0GCSqGSIb3DQEBCwUAA4IBAQBYb7/NQwdCE/y40K2B
2255 IfKKb++HvCaKfAC9aAwrGWQsEWezqdl5Cqw5XWUAFjtTRm6iprVnmdvov6IlrgSV
2256 EQk6L96stz24vAF0MIBHSFRMoPtrqLiihLf0NOV7ztxSePQxbUJRroe/lKy+lhb7
2257 VeV5gmT9rFA45NzLgSznd2+dmyNcfQQD9AeeftRX4maUTeu1XFxinowtg+ZGFOKh
2258 E4D92uCGJxGSK72HF0/LGRhLXozmDdmPfSN2b6T/oLo942031iY46BqcI5LIVh8a
2259 Go4A1jOma5X6gh50Cw+kht8jM3yeNhSzXOKj7Uigjijx10z2wJu09Tyj5ahjoiwI
2260 pdX+
2261 -----END CERTIFICATE-----`
2262
2263 func TestBadIPMask(t *testing.T) {
2264         block, _ := pem.Decode([]byte(badIPMaskPEM))
2265         _, err := ParseCertificate(block.Bytes)
2266         if err == nil {
2267                 t.Fatalf("unexpected success")
2268         }
2269
2270         const expected = "contained invalid mask"
2271         if !strings.Contains(err.Error(), expected) {
2272                 t.Fatalf("expected %q in error but got: %s", expected, err)
2273         }
2274 }
2275
2276 const additionalGeneralSubtreePEM = `
2277 -----BEGIN CERTIFICATE-----
2278 MIIG4TCCBMmgAwIBAgIRALss+4rLw2Ia7tFFhxE8g5cwDQYJKoZIhvcNAQELBQAw
2279 bjELMAkGA1UEBhMCTkwxIDAeBgNVBAoMF01pbmlzdGVyaWUgdmFuIERlZmVuc2ll
2280 MT0wOwYDVQQDDDRNaW5pc3RlcmllIHZhbiBEZWZlbnNpZSBDZXJ0aWZpY2F0aWUg
2281 QXV0b3JpdGVpdCAtIEcyMB4XDTEzMDMwNjEyMDM0OVoXDTEzMTEzMDEyMDM1MFow
2282 bDELMAkGA1UEBhMCVVMxFjAUBgNVBAoTDUNlcnRpUGF0aCBMTEMxIjAgBgNVBAsT
2283 GUNlcnRpZmljYXRpb24gQXV0aG9yaXRpZXMxITAfBgNVBAMTGENlcnRpUGF0aCBC
2284 cmlkZ2UgQ0EgLSBHMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANLW
2285 4kXiRqvwBhJfN9uz12FA+P2D34MPxOt7TGXljm2plJ2CLzvaH8/ymsMdSWdJBS1M
2286 8FmwvNL1w3A6ZuzksJjPikAu8kY3dcp3mrkk9eCPORDAwGtfsXwZysLiuEaDWpbD
2287 dHOaHnI6qWU0N6OI+hNX58EjDpIGC1WQdho1tHOTPc5Hf5/hOpM/29v/wr7kySjs
2288 Z+7nsvkm5rNhuJNzPsLsgzVaJ5/BVyOplZy24FKM8Y43MjR4osZm+a2e0zniqw6/
2289 rvcjcGYabYaznZfQG1GXoyf2Vea+CCgpgUhlVafgkwEs8izl8rIpvBzXiFAgFQuG
2290 Ituoy92PJbDs430fA/cCAwEAAaOCAnowggJ2MEUGCCsGAQUFBwEBBDkwNzA1Bggr
2291 BgEFBQcwAoYpaHR0cDovL2NlcnRzLmNhLm1pbmRlZi5ubC9taW5kZWYtY2EtMi5w
2292 N2MwHwYDVR0jBBgwFoAUzln9WSPz2M64Rl2HYf2/KD8StmQwDwYDVR0TAQH/BAUw
2293 AwEB/zCB6QYDVR0gBIHhMIHeMEgGCmCEEAGHawECBQEwOjA4BggrBgEFBQcCARYs
2294 aHR0cDovL2Nwcy5kcC5jYS5taW5kZWYubmwvbWluZGVmLWNhLWRwLWNwcy8wSAYK
2295 YIQQAYdrAQIFAjA6MDgGCCsGAQUFBwIBFixodHRwOi8vY3BzLmRwLmNhLm1pbmRl
2296 Zi5ubC9taW5kZWYtY2EtZHAtY3BzLzBIBgpghBABh2sBAgUDMDowOAYIKwYBBQUH
2297 AgEWLGh0dHA6Ly9jcHMuZHAuY2EubWluZGVmLm5sL21pbmRlZi1jYS1kcC1jcHMv
2298 MDkGA1UdHwQyMDAwLqAsoCqGKGh0dHA6Ly9jcmxzLmNhLm1pbmRlZi5ubC9taW5k
2299 ZWYtY2EtMi5jcmwwDgYDVR0PAQH/BAQDAgEGMEYGA1UdHgEB/wQ8MDqhODA2pDEw
2300 LzELMAkGA1UEBhMCTkwxIDAeBgNVBAoTF01pbmlzdGVyaWUgdmFuIERlZmVuc2ll
2301 gQFjMF0GA1UdIQRWMFQwGgYKYIQQAYdrAQIFAQYMKwYBBAGBu1MBAQECMBoGCmCE
2302 EAGHawECBQIGDCsGAQQBgbtTAQEBAjAaBgpghBABh2sBAgUDBgwrBgEEAYG7UwEB
2303 AQIwHQYDVR0OBBYEFNDCjBM3M3ZKkag84ei3/aKc0d0UMA0GCSqGSIb3DQEBCwUA
2304 A4ICAQAQXFn9jF90/DNFf15JhoGtta/0dNInb14PMu3PAjcdrXYCDPpQZOArTUng
2305 5YT1WuzfmjnXiTsziT3my0r9Mxvz/btKK/lnVOMW4c2q/8sIsIPnnW5ZaRGrsANB
2306 dNDZkzMYmeG2Pfgvd0AQSOrpE/TVgWfu/+MMRWwX9y6VbooBR7BLv7zMuVH0WqLn
2307 6OMFth7fqsThlfMSzkE/RDSaU6n3wXAWT1SIqBITtccRjSUQUFm/q3xrb2cwcZA6
2308 8vdS4hzNd+ttS905ay31Ks4/1Wrm1bH5RhEfRSH0VSXnc0b+z+RyBbmiwtVZqzxE
2309 u3UQg/rAmtLDclLFEzjp8YDTIRYSLwstDbEXO/0ArdGrQm79HQ8i/3ZbP2357myW
2310 i15qd6gMJIgGHS4b8Hc7R1K8LQ9Gm1aLKBEWVNGZlPK/cpXThpVmoEyslN2DHCrc
2311 fbMbjNZpXlTMa+/b9z7Fa4X8dY8u/ELzZuJXJv5Rmqtg29eopFFYDCl0Nkh1XAjo
2312 QejEoHHUvYV8TThHZr6Z6Ib8CECgTehU4QvepkgDXNoNrKRZBG0JhLjkwxh2whZq
2313 nvWBfALC2VuNOM6C0rDY+HmhMlVt0XeqnybD9MuQALMit7Z00Cw2CIjNsBI9xBqD
2314 xKK9CjUb7gzRUWSpB9jGHsvpEMHOzIFhufvH2Bz1XJw+Cl7khw==
2315 -----END CERTIFICATE-----`
2316
2317 func TestAdditionFieldsInGeneralSubtree(t *testing.T) {
2318         // Very rarely, certificates can include additional fields in the
2319         // GeneralSubtree structure. This tests that such certificates can be
2320         // parsed.
2321         block, _ := pem.Decode([]byte(additionalGeneralSubtreePEM))
2322         if _, err := ParseCertificate(block.Bytes); err != nil {
2323                 t.Fatalf("failed to parse certificate: %s", err)
2324         }
2325 }
2326
2327 func TestEmptySubject(t *testing.T) {
2328         template := Certificate{
2329                 SerialNumber: big.NewInt(1),
2330                 DNSNames:     []string{"example.com"},
2331         }
2332
2333         derBytes, err := CreateCertificate(rand.Reader, &template, &template, &testPrivateKey.PublicKey, testPrivateKey)
2334         if err != nil {
2335                 t.Fatalf("failed to create certificate: %s", err)
2336         }
2337
2338         cert, err := ParseCertificate(derBytes)
2339         if err != nil {
2340                 t.Fatalf("failed to parse certificate: %s", err)
2341         }
2342
2343         for _, ext := range cert.Extensions {
2344                 if ext.Id.Equal(oidExtensionSubjectAltName) {
2345                         if !ext.Critical {
2346                                 t.Fatal("SAN extension is not critical")
2347                         }
2348                         return
2349                 }
2350         }
2351
2352         t.Fatal("SAN extension is missing")
2353 }
2354
2355 // multipleURLsInCRLDPPEM contains two URLs in a single CRL DistributionPoint
2356 // structure. It is taken from https://crt.sh/?id=12721534.
2357 const multipleURLsInCRLDPPEM = `
2358 -----BEGIN CERTIFICATE-----
2359 MIIF4TCCBMmgAwIBAgIQc+6uFePfrahUGpXs8lhiTzANBgkqhkiG9w0BAQsFADCB
2360 8zELMAkGA1UEBhMCRVMxOzA5BgNVBAoTMkFnZW5jaWEgQ2F0YWxhbmEgZGUgQ2Vy
2361 dGlmaWNhY2lvIChOSUYgUS0wODAxMTc2LUkpMSgwJgYDVQQLEx9TZXJ2ZWlzIFB1
2362 YmxpY3MgZGUgQ2VydGlmaWNhY2lvMTUwMwYDVQQLEyxWZWdldSBodHRwczovL3d3
2363 dy5jYXRjZXJ0Lm5ldC92ZXJhcnJlbCAoYykwMzE1MDMGA1UECxMsSmVyYXJxdWlh
2364 IEVudGl0YXRzIGRlIENlcnRpZmljYWNpbyBDYXRhbGFuZXMxDzANBgNVBAMTBkVD
2365 LUFDQzAeFw0xNDA5MTgwODIxMDBaFw0zMDA5MTgwODIxMDBaMIGGMQswCQYDVQQG
2366 EwJFUzEzMDEGA1UECgwqQ09OU09SQ0kgQURNSU5JU1RSQUNJTyBPQkVSVEEgREUg
2367 Q0FUQUxVTllBMSowKAYDVQQLDCFTZXJ2ZWlzIFDDumJsaWNzIGRlIENlcnRpZmlj
2368 YWNpw7MxFjAUBgNVBAMMDUVDLUNpdXRhZGFuaWEwggEiMA0GCSqGSIb3DQEBAQUA
2369 A4IBDwAwggEKAoIBAQDFkHPRZPZlXTWZ5psJhbS/Gx+bxcTpGrlVQHHtIkgGz77y
2370 TA7UZUFb2EQMncfbOhR0OkvQQn1aMvhObFJSR6nI+caf2D+h/m/InMl1MyH3S0Ak
2371 YGZZsthnyC6KxqK2A/NApncrOreh70ULkQs45aOKsi1kR1W0zE+iFN+/P19P7AkL
2372 Rl3bXBCVd8w+DLhcwRrkf1FCDw6cEqaFm3cGgf5cbBDMaVYAweWTxwBZAq2RbQAW
2373 jE7mledcYghcZa4U6bUmCBPuLOnO8KMFAvH+aRzaf3ws5/ZoOVmryyLLJVZ54peZ
2374 OwnP9EL4OuWzmXCjBifXR2IAblxs5JYj57tls45nAgMBAAGjggHaMIIB1jASBgNV
2375 HRMBAf8ECDAGAQH/AgEAMA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUC2hZPofI
2376 oxUa4ECCIl+fHbLFNxUwHwYDVR0jBBgwFoAUoMOLRKo3pUW/l4Ba0fF4opvpXY0w
2377 gdYGA1UdIASBzjCByzCByAYEVR0gADCBvzAxBggrBgEFBQcCARYlaHR0cHM6Ly93
2378 d3cuYW9jLmNhdC9DQVRDZXJ0L1JlZ3VsYWNpbzCBiQYIKwYBBQUHAgIwfQx7QXF1
2379 ZXN0IGNlcnRpZmljYXQgw6lzIGVtw6hzIMO6bmljYSBpIGV4Y2x1c2l2YW1lbnQg
2380 YSBFbnRpdGF0cyBkZSBDZXJ0aWZpY2FjacOzLiBWZWdldSBodHRwczovL3d3dy5h
2381 b2MuY2F0L0NBVENlcnQvUmVndWxhY2lvMDMGCCsGAQUFBwEBBCcwJTAjBggrBgEF
2382 BQcwAYYXaHR0cDovL29jc3AuY2F0Y2VydC5jYXQwYgYDVR0fBFswWTBXoFWgU4Yn
2383 aHR0cDovL2Vwc2NkLmNhdGNlcnQubmV0L2NybC9lYy1hY2MuY3JshihodHRwOi8v
2384 ZXBzY2QyLmNhdGNlcnQubmV0L2NybC9lYy1hY2MuY3JsMA0GCSqGSIb3DQEBCwUA
2385 A4IBAQChqFTjlAH5PyIhLjLgEs68CyNNC1+vDuZXRhy22TI83JcvGmQrZosPvVIL
2386 PsUXx+C06Pfqmh48Q9S89X9K8w1SdJxP/rZeGEoRiKpwvQzM4ArD9QxyC8jirxex
2387 3Umg9Ai/sXQ+1lBf6xw4HfUUr1WIp7pNHj0ZWLo106urqktcdeAFWme+/klis5fu
2388 labCSVPuT/QpwakPrtqOhRms8vgpKiXa/eLtL9ZiA28X/Mker0zlAeTA7Z7uAnp6
2389 oPJTlZu1Gg1ZDJueTWWsLlO+P+Wzm3MRRIbcgdRzm4mdO7ubu26SzX/aQXDhuih+
2390 eVxXDTCfs7GUlxnjOp5j559X/N0A
2391 -----END CERTIFICATE-----
2392 `
2393
2394 func TestMultipleURLsInCRLDP(t *testing.T) {
2395         block, _ := pem.Decode([]byte(multipleURLsInCRLDPPEM))
2396         cert, err := ParseCertificate(block.Bytes)
2397         if err != nil {
2398                 t.Fatalf("failed to parse certificate: %s", err)
2399         }
2400
2401         want := []string{
2402                 "http://epscd.catcert.net/crl/ec-acc.crl",
2403                 "http://epscd2.catcert.net/crl/ec-acc.crl",
2404         }
2405         if got := cert.CRLDistributionPoints; !reflect.DeepEqual(got, want) {
2406                 t.Errorf("CRL distribution points = %#v, want #%v", got, want)
2407         }
2408 }
2409
2410 const hexPKCS1TestPKCS8Key = "30820278020100300d06092a864886f70d0101010500048202623082025e02010002818100cfb1b5bf9685ffa97b4f99df4ff122b70e59ac9b992f3bc2b3dde17d53c1a34928719b02e8fd17839499bfbd515bd6ef99c7a1c47a239718fe36bfd824c0d96060084b5f67f0273443007a24dfaf5634f7772c9346e10eb294c2306671a5a5e719ae24b4de467291bc571014b0e02dec04534d66a9bb171d644b66b091780e8d020301000102818100b595778383c4afdbab95d2bfed12b3f93bb0a73a7ad952f44d7185fd9ec6c34de8f03a48770f2009c8580bcd275e9632714e9a5e3f32f29dc55474b2329ff0ebc08b3ffcb35bc96e6516b483df80a4a59cceb71918cbabf91564e64a39d7e35dce21cb3031824fdbc845dba6458852ec16af5dddf51a8397a8797ae0337b1439024100ea0eb1b914158c70db39031dd8904d6f18f408c85fbbc592d7d20dee7986969efbda081fdf8bc40e1b1336d6b638110c836bfdc3f314560d2e49cd4fbde1e20b024100e32a4e793b574c9c4a94c8803db5152141e72d03de64e54ef2c8ed104988ca780cd11397bc359630d01b97ebd87067c5451ba777cf045ca23f5912f1031308c702406dfcdbbd5a57c9f85abc4edf9e9e29153507b07ce0a7ef6f52e60dcfebe1b8341babd8b789a837485da6c8d55b29bbb142ace3c24a1f5b54b454d01b51e2ad03024100bd6a2b60dee01e1b3bfcef6a2f09ed027c273cdbbaf6ba55a80f6dcc64e4509ee560f84b4f3e076bd03b11e42fe71a3fdd2dffe7e0902c8584f8cad877cdc945024100aa512fa4ada69881f1d8bb8ad6614f192b83200aef5edf4811313d5ef30a86cbd0a90f7b025c71ea06ec6b34db6306c86b1040670fd8654ad7291d066d06d031"
2411 const hexPKCS1TestECKey = "3081a40201010430bdb9839c08ee793d1157886a7a758a3c8b2a17a4df48f17ace57c72c56b4723cf21dcda21d4e1ad57ff034f19fcfd98ea00706052b81040022a16403620004feea808b5ee2429cfcce13c32160e1c960990bd050bb0fdf7222f3decd0a55008e32a6aa3c9062051c4cba92a7a3b178b24567412d43cdd2f882fa5addddd726fe3e208d2c26d733a773a597abb749714df7256ead5105fa6e7b3650de236b50"
2412
2413 var pkcs1MismatchKeyTests = []struct {
2414         hexKey        string
2415         errorContains string
2416 }{
2417         {hexKey: hexPKCS1TestPKCS8Key, errorContains: "use ParsePKCS8PrivateKey instead"},
2418         {hexKey: hexPKCS1TestECKey, errorContains: "use ParseECPrivateKey instead"},
2419 }
2420
2421 func TestPKCS1MismatchKeyFormat(t *testing.T) {
2422         for i, test := range pkcs1MismatchKeyTests {
2423                 derBytes, _ := hex.DecodeString(test.hexKey)
2424                 _, err := ParsePKCS1PrivateKey(derBytes)
2425                 if !strings.Contains(err.Error(), test.errorContains) {
2426                         t.Errorf("#%d: expected error containing %q, got %s", i, test.errorContains, err)
2427                 }
2428         }
2429 }
2430
2431 func TestCreateRevocationList(t *testing.T) {
2432         ec256Priv, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
2433         if err != nil {
2434                 t.Fatalf("Failed to generate ECDSA P256 key: %s", err)
2435         }
2436         _, ed25519Priv, err := ed25519.GenerateKey(rand.Reader)
2437         if err != nil {
2438                 t.Fatalf("Failed to generate Ed25519 key: %s", err)
2439         }
2440
2441         // Generation command:
2442         // openssl req -x509 -newkey rsa -keyout key.pem -out cert.pem -days 365 -nodes -subj '/C=US/ST=California/L=San Francisco/O=Internet Widgets, Inc./OU=WWW/CN=Root/emailAddress=admin@example.com' -sha256 -addext basicConstraints=CA:TRUE -addext "keyUsage = digitalSignature, keyEncipherment, dataEncipherment, cRLSign, keyCertSign" -utf8
2443         utf8CAStr := "MIIEITCCAwmgAwIBAgIUXHXy7NdtDv+ClaHvIvlwCYiI4a4wDQYJKoZIhvcNAQELBQAwgZoxCzAJBgNVBAYTAlVTMRMwEQYDVQQIDApDYWxpZm9ybmlhMRYwFAYDVQQHDA1TYW4gRnJhbmNpc2NvMR8wHQYDVQQKDBZJbnRlcm5ldCBXaWRnZXRzLCBJbmMuMQwwCgYDVQQLDANXV1cxDTALBgNVBAMMBFJvb3QxIDAeBgkqhkiG9w0BCQEWEWFkbWluQGV4YW1wbGUuY29tMB4XDTIyMDcwODE1MzgyMFoXDTIzMDcwODE1MzgyMFowgZoxCzAJBgNVBAYTAlVTMRMwEQYDVQQIDApDYWxpZm9ybmlhMRYwFAYDVQQHDA1TYW4gRnJhbmNpc2NvMR8wHQYDVQQKDBZJbnRlcm5ldCBXaWRnZXRzLCBJbmMuMQwwCgYDVQQLDANXV1cxDTALBgNVBAMMBFJvb3QxIDAeBgkqhkiG9w0BCQEWEWFkbWluQGV4YW1wbGUuY29tMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAmXvp0WNjsZzySWT7Ce5zewQNKq8ujeZGphJ44Vdrwut/b6TcC4iYENds5+7/3PYwBllp3K5TRpCcafSxdhJsvA7/zWlHHNRcJhJLNt9qsKWP6ukI2Iw6OmFMg6kJQ8f67RXkT8HR3v0UqE+lWrA0g+oRuj4erLtfOtSpnl4nsE/Rs2qxbELFWAf7F5qMqH4dUyveWKrNT8eI6YQN+wBg0MAjoKRvDJnBhuo+IvvXX8Aq1QWUcBGPK3or/Ehxy5f/gEmSUXyEU1Ht/vATt2op+eRaEEpBdGRvO+DrKjlcQV2XMN18A9LAX6hCzH43sGye87dj7RZ9yj+waOYNaM7kFQIDAQABo10wWzAdBgNVHQ4EFgQUtbSlrW4hGL2kNjviM6wcCRwvOEEwHwYDVR0jBBgwFoAUtbSlrW4hGL2kNjviM6wcCRwvOEEwDAYDVR0TBAUwAwEB/zALBgNVHQ8EBAMCAbYwDQYJKoZIhvcNAQELBQADggEBAAko82YNNI2n/45L3ya21vufP6nZihIOIxgcRPUMX+IDJZk16qsFdcLgH3KAP8uiVLn8sULuCj35HpViR4IcAk2d+DqfG11l8kY+e5P7nYsViRfy0AatF59/sYlWf+3RdmPXfL70x4mE9OqlMdDm0kR2obps8rng83VLDNvj3R5sBnQwdw6LKLGzaE+RiCTmkH0+P6vnbOJ33su9+9al1+HvJUg3UM1Xq5Bw7TE8DQTetMV3c2Q35RQaJB9pQ4blJOnW9hfnt8yQzU6TU1bU4mRctTm1o1f8btPqUpi+/blhi5MUJK0/myj1XD00pmyfp8QAFl1EfqmTMIBMLg633A0="
2444         utf8CABytes, _ := base64.StdEncoding.DecodeString(utf8CAStr)
2445         utf8CA, _ := ParseCertificate(utf8CABytes)
2446
2447         utf8KeyStr := "MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCZe+nRY2OxnPJJZPsJ7nN7BA0qry6N5kamEnjhV2vC639vpNwLiJgQ12zn7v/c9jAGWWncrlNGkJxp9LF2Emy8Dv/NaUcc1FwmEks232qwpY/q6QjYjDo6YUyDqQlDx/rtFeRPwdHe/RSoT6VasDSD6hG6Ph6su1861KmeXiewT9GzarFsQsVYB/sXmoyofh1TK95Yqs1Px4jphA37AGDQwCOgpG8MmcGG6j4i+9dfwCrVBZRwEY8reiv8SHHLl/+ASZJRfIRTUe3+8BO3ain55FoQSkF0ZG874OsqOVxBXZcw3XwD0sBfqELMfjewbJ7zt2PtFn3KP7Bo5g1ozuQVAgMBAAECggEAIscjKiD9PAe2Fs9c2tk/LYazfRKI1/pv072nylfGwToffCq8+ZgP7PEDamKLc4QNScME685MbFbkOlYJyBlQriQv7lmGlY/A+Zd3l410XWaGf9IiAP91Sjk13zd0M/micApf23qtlXt/LMwvSadXnvRw4+SjirxCTdBWRt5K2/ZAN550v7bHFk1EZc3UBF6sOoNsjQWh9Ek79UmQYJBPiZDBHO7O2fh2GSIbUutTma+Tb2i1QUZzg+AG3cseF3p1i3uhNrCh+p+01bJSzGTQsRod2xpD1tpWwR3kIftCOmD1XnhpaBQi7PXjEuNbfucaftnoYj2ShDdmgD5RkkbTAQKBgQC8Ghu5MQ/yIeqXg9IpcSxuWtUEAEfK33/cC/IvuntgbNEnWQm5Lif4D6a9zjkxiCS+9HhrUu5U2EV8NxOyaqmtub3Np1Z5mPuI9oiZ119bjUJd4X+jKOTaePWvOv/rL/pTHYqzXohVMrXy+DaTIq4lOcv3n72SuhuTcKU95rhKtQKBgQDQ4t+HsRZd5fJzoCgRQhlNK3EbXQDv2zXqMW3GfpF7GaDP18I530inRURSJa++rvi7/MCFg/TXVS3QC4HXtbzTYTqhE+VHzSr+/OcsqpLE8b0jKBDv/SBkz811PUJDs3LsX31DT3K0zUpMpNSd/5SYTyJKef9L6mxmwlC1S2Yv4QKBgQC57SiYDdnQIRwrtZ2nXvlm/xttAAX2jqJoU9qIuNA4yHaYaRcGVowlUvsiw9OelQ6VPTpGA0wWy0src5lhkrKzSFRHEe+U89U1VVJCljLoYKFIAJvUH5jOJh/am/vYca0COMIfeAJUDHLyfcwb9XyiyRVGZzvP62tUelSq8gIZvQKBgCAHeaDzzWsudCO4ngwvZ3PGwnwgoaElqrmzRJLYG3SVtGvKOJTpINnNLDGwZ6dEaw1gLyEJ38QY4oJxEULDMiXzVasXQuPkmMAqhUP7D7A1JPw8C4TQ+mOa3XUppHx/CpMl/S4SA5OnmsnvyE5Fv0IveCGVXUkFtAN5rihuXEfhAoGANUkuGU3A0Upk2mzv0JTGP4H95JFG93cqnyPNrYs30M6RkZNgTW27yyr+Nhs4/cMdrg1AYTB0+6ItQWSDmYLs7JEbBE/8L8fdD1irIcygjIHE9nJh96TgZCt61kVGLE8758lOdmoB2rZOpGwi16QIhdQb+IyozYqfX+lQUojL/W0="
2448         utf8KeyBytes, _ := base64.StdEncoding.DecodeString(utf8KeyStr)
2449         utf8KeyRaw, _ := ParsePKCS8PrivateKey(utf8KeyBytes)
2450         utf8Key := utf8KeyRaw.(crypto.Signer)
2451
2452         tests := []struct {
2453                 name          string
2454                 key           crypto.Signer
2455                 issuer        *Certificate
2456                 template      *RevocationList
2457                 expectedError string
2458         }{
2459                 {
2460                         name:          "nil template",
2461                         key:           ec256Priv,
2462                         issuer:        nil,
2463                         template:      nil,
2464                         expectedError: "x509: template can not be nil",
2465                 },
2466                 {
2467                         name:          "nil issuer",
2468                         key:           ec256Priv,
2469                         issuer:        nil,
2470                         template:      &RevocationList{},
2471                         expectedError: "x509: issuer can not be nil",
2472                 },
2473                 {
2474                         name: "issuer doesn't have crlSign key usage bit set",
2475                         key:  ec256Priv,
2476                         issuer: &Certificate{
2477                                 KeyUsage: KeyUsageCertSign,
2478                         },
2479                         template:      &RevocationList{},
2480                         expectedError: "x509: issuer must have the crlSign key usage bit set",
2481                 },
2482                 {
2483                         name: "issuer missing SubjectKeyId",
2484                         key:  ec256Priv,
2485                         issuer: &Certificate{
2486                                 KeyUsage: KeyUsageCRLSign,
2487                         },
2488                         template:      &RevocationList{},
2489                         expectedError: "x509: issuer certificate doesn't contain a subject key identifier",
2490                 },
2491                 {
2492                         name: "nextUpdate before thisUpdate",
2493                         key:  ec256Priv,
2494                         issuer: &Certificate{
2495                                 KeyUsage: KeyUsageCRLSign,
2496                                 Subject: pkix.Name{
2497                                         CommonName: "testing",
2498                                 },
2499                                 SubjectKeyId: []byte{1, 2, 3},
2500                         },
2501                         template: &RevocationList{
2502                                 ThisUpdate: time.Time{}.Add(time.Hour),
2503                                 NextUpdate: time.Time{},
2504                         },
2505                         expectedError: "x509: template.ThisUpdate is after template.NextUpdate",
2506                 },
2507                 {
2508                         name: "nil Number",
2509                         key:  ec256Priv,
2510                         issuer: &Certificate{
2511                                 KeyUsage: KeyUsageCRLSign,
2512                                 Subject: pkix.Name{
2513                                         CommonName: "testing",
2514                                 },
2515                                 SubjectKeyId: []byte{1, 2, 3},
2516                         },
2517                         template: &RevocationList{
2518                                 ThisUpdate: time.Time{}.Add(time.Hour * 24),
2519                                 NextUpdate: time.Time{}.Add(time.Hour * 48),
2520                         },
2521                         expectedError: "x509: template contains nil Number field",
2522                 },
2523                 {
2524                         name: "long Number",
2525                         key:  ec256Priv,
2526                         issuer: &Certificate{
2527                                 KeyUsage: KeyUsageCRLSign,
2528                                 Subject: pkix.Name{
2529                                         CommonName: "testing",
2530                                 },
2531                                 SubjectKeyId: []byte{1, 2, 3},
2532                         },
2533                         template: &RevocationList{
2534                                 ThisUpdate: time.Time{}.Add(time.Hour * 24),
2535                                 NextUpdate: time.Time{}.Add(time.Hour * 48),
2536                                 Number:     big.NewInt(0).SetBytes(append([]byte{1}, make([]byte, 20)...)),
2537                         },
2538                         expectedError: "x509: CRL number exceeds 20 octets",
2539                 },
2540                 {
2541                         name: "long Number (20 bytes, MSB set)",
2542                         key:  ec256Priv,
2543                         issuer: &Certificate{
2544                                 KeyUsage: KeyUsageCRLSign,
2545                                 Subject: pkix.Name{
2546                                         CommonName: "testing",
2547                                 },
2548                                 SubjectKeyId: []byte{1, 2, 3},
2549                         },
2550                         template: &RevocationList{
2551                                 ThisUpdate: time.Time{}.Add(time.Hour * 24),
2552                                 NextUpdate: time.Time{}.Add(time.Hour * 48),
2553                                 Number:     big.NewInt(0).SetBytes(append([]byte{255}, make([]byte, 19)...)),
2554                         },
2555                         expectedError: "x509: CRL number exceeds 20 octets",
2556                 },
2557                 {
2558                         name: "invalid signature algorithm",
2559                         key:  ec256Priv,
2560                         issuer: &Certificate{
2561                                 KeyUsage: KeyUsageCRLSign,
2562                                 Subject: pkix.Name{
2563                                         CommonName: "testing",
2564                                 },
2565                                 SubjectKeyId: []byte{1, 2, 3},
2566                         },
2567                         template: &RevocationList{
2568                                 SignatureAlgorithm: SHA256WithRSA,
2569                                 RevokedCertificates: []pkix.RevokedCertificate{
2570                                         {
2571                                                 SerialNumber:   big.NewInt(2),
2572                                                 RevocationTime: time.Time{}.Add(time.Hour),
2573                                         },
2574                                 },
2575                                 Number:     big.NewInt(5),
2576                                 ThisUpdate: time.Time{}.Add(time.Hour * 24),
2577                                 NextUpdate: time.Time{}.Add(time.Hour * 48),
2578                         },
2579                         expectedError: "x509: requested SignatureAlgorithm does not match private key type",
2580                 },
2581                 {
2582                         name: "valid",
2583                         key:  ec256Priv,
2584                         issuer: &Certificate{
2585                                 KeyUsage: KeyUsageCRLSign,
2586                                 Subject: pkix.Name{
2587                                         CommonName: "testing",
2588                                 },
2589                                 SubjectKeyId: []byte{1, 2, 3},
2590                         },
2591                         template: &RevocationList{
2592                                 RevokedCertificateEntries: []RevocationListEntry{
2593                                         {
2594                                                 SerialNumber:   big.NewInt(2),
2595                                                 RevocationTime: time.Time{}.Add(time.Hour),
2596                                         },
2597                                 },
2598                                 Number:     big.NewInt(5),
2599                                 ThisUpdate: time.Time{}.Add(time.Hour * 24),
2600                                 NextUpdate: time.Time{}.Add(time.Hour * 48),
2601                         },
2602                 },
2603                 {
2604                         name: "valid, reason code",
2605                         key:  ec256Priv,
2606                         issuer: &Certificate{
2607                                 KeyUsage: KeyUsageCRLSign,
2608                                 Subject: pkix.Name{
2609                                         CommonName: "testing",
2610                                 },
2611                                 SubjectKeyId: []byte{1, 2, 3},
2612                         },
2613                         template: &RevocationList{
2614                                 RevokedCertificateEntries: []RevocationListEntry{
2615                                         {
2616                                                 SerialNumber:   big.NewInt(2),
2617                                                 RevocationTime: time.Time{}.Add(time.Hour),
2618                                                 ReasonCode:     1,
2619                                         },
2620                                 },
2621                                 Number:     big.NewInt(5),
2622                                 ThisUpdate: time.Time{}.Add(time.Hour * 24),
2623                                 NextUpdate: time.Time{}.Add(time.Hour * 48),
2624                         },
2625                 },
2626                 {
2627                         name: "valid, extra entry extension",
2628                         key:  ec256Priv,
2629                         issuer: &Certificate{
2630                                 KeyUsage: KeyUsageCRLSign,
2631                                 Subject: pkix.Name{
2632                                         CommonName: "testing",
2633                                 },
2634                                 SubjectKeyId: []byte{1, 2, 3},
2635                         },
2636                         template: &RevocationList{
2637                                 RevokedCertificateEntries: []RevocationListEntry{
2638                                         {
2639                                                 SerialNumber:   big.NewInt(2),
2640                                                 RevocationTime: time.Time{}.Add(time.Hour),
2641                                                 ExtraExtensions: []pkix.Extension{
2642                                                         {
2643                                                                 Id:    []int{2, 5, 29, 99},
2644                                                                 Value: []byte{5, 0},
2645                                                         },
2646                                                 },
2647                                         },
2648                                 },
2649                                 Number:     big.NewInt(5),
2650                                 ThisUpdate: time.Time{}.Add(time.Hour * 24),
2651                                 NextUpdate: time.Time{}.Add(time.Hour * 48),
2652                         },
2653                 },
2654                 {
2655                         name: "valid, Ed25519 key",
2656                         key:  ed25519Priv,
2657                         issuer: &Certificate{
2658                                 KeyUsage: KeyUsageCRLSign,
2659                                 Subject: pkix.Name{
2660                                         CommonName: "testing",
2661                                 },
2662                                 SubjectKeyId: []byte{1, 2, 3},
2663                         },
2664                         template: &RevocationList{
2665                                 RevokedCertificateEntries: []RevocationListEntry{
2666                                         {
2667                                                 SerialNumber:   big.NewInt(2),
2668                                                 RevocationTime: time.Time{}.Add(time.Hour),
2669                                         },
2670                                 },
2671                                 Number:     big.NewInt(5),
2672                                 ThisUpdate: time.Time{}.Add(time.Hour * 24),
2673                                 NextUpdate: time.Time{}.Add(time.Hour * 48),
2674                         },
2675                 },
2676                 {
2677                         name: "valid, non-default signature algorithm",
2678                         key:  ec256Priv,
2679                         issuer: &Certificate{
2680                                 KeyUsage: KeyUsageCRLSign,
2681                                 Subject: pkix.Name{
2682                                         CommonName: "testing",
2683                                 },
2684                                 SubjectKeyId: []byte{1, 2, 3},
2685                         },
2686                         template: &RevocationList{
2687                                 SignatureAlgorithm: ECDSAWithSHA512,
2688                                 RevokedCertificateEntries: []RevocationListEntry{
2689                                         {
2690                                                 SerialNumber:   big.NewInt(2),
2691                                                 RevocationTime: time.Time{}.Add(time.Hour),
2692                                         },
2693                                 },
2694                                 Number:     big.NewInt(5),
2695                                 ThisUpdate: time.Time{}.Add(time.Hour * 24),
2696                                 NextUpdate: time.Time{}.Add(time.Hour * 48),
2697                         },
2698                 },
2699                 {
2700                         name: "valid, extra extension",
2701                         key:  ec256Priv,
2702                         issuer: &Certificate{
2703                                 KeyUsage: KeyUsageCRLSign,
2704                                 Subject: pkix.Name{
2705                                         CommonName: "testing",
2706                                 },
2707                                 SubjectKeyId: []byte{1, 2, 3},
2708                         },
2709                         template: &RevocationList{
2710                                 RevokedCertificateEntries: []RevocationListEntry{
2711                                         {
2712                                                 SerialNumber:   big.NewInt(2),
2713                                                 RevocationTime: time.Time{}.Add(time.Hour),
2714                                         },
2715                                 },
2716                                 Number:     big.NewInt(5),
2717                                 ThisUpdate: time.Time{}.Add(time.Hour * 24),
2718                                 NextUpdate: time.Time{}.Add(time.Hour * 48),
2719                                 ExtraExtensions: []pkix.Extension{
2720                                         {
2721                                                 Id:    []int{2, 5, 29, 99},
2722                                                 Value: []byte{5, 0},
2723                                         },
2724                                 },
2725                         },
2726                 },
2727                 {
2728                         name: "valid, deprecated entries with extension",
2729                         key:  ec256Priv,
2730                         issuer: &Certificate{
2731                                 KeyUsage: KeyUsageCRLSign,
2732                                 Subject: pkix.Name{
2733                                         CommonName: "testing",
2734                                 },
2735                                 SubjectKeyId: []byte{1, 2, 3},
2736                         },
2737                         template: &RevocationList{
2738                                 RevokedCertificates: []pkix.RevokedCertificate{
2739                                         {
2740                                                 SerialNumber:   big.NewInt(2),
2741                                                 RevocationTime: time.Time{}.Add(time.Hour),
2742                                                 Extensions: []pkix.Extension{
2743                                                         {
2744                                                                 Id:    []int{2, 5, 29, 99},
2745                                                                 Value: []byte{5, 0},
2746                                                         },
2747                                                 },
2748                                         },
2749                                 },
2750                                 Number:     big.NewInt(5),
2751                                 ThisUpdate: time.Time{}.Add(time.Hour * 24),
2752                                 NextUpdate: time.Time{}.Add(time.Hour * 48),
2753                         },
2754                 },
2755                 {
2756                         name: "valid, empty list",
2757                         key:  ec256Priv,
2758                         issuer: &Certificate{
2759                                 KeyUsage: KeyUsageCRLSign,
2760                                 Subject: pkix.Name{
2761                                         CommonName: "testing",
2762                                 },
2763                                 SubjectKeyId: []byte{1, 2, 3},
2764                         },
2765                         template: &RevocationList{
2766                                 Number:     big.NewInt(5),
2767                                 ThisUpdate: time.Time{}.Add(time.Hour * 24),
2768                                 NextUpdate: time.Time{}.Add(time.Hour * 48),
2769                         },
2770                 },
2771                 {
2772                         name:   "valid CA with utf8 Subject fields including Email, empty list",
2773                         key:    utf8Key,
2774                         issuer: utf8CA,
2775                         template: &RevocationList{
2776                                 Number:     big.NewInt(5),
2777                                 ThisUpdate: time.Time{}.Add(time.Hour * 24),
2778                                 NextUpdate: time.Time{}.Add(time.Hour * 48),
2779                         },
2780                 },
2781         }
2782
2783         for _, tc := range tests {
2784                 t.Run(tc.name, func(t *testing.T) {
2785                         crl, err := CreateRevocationList(rand.Reader, tc.template, tc.issuer, tc.key)
2786                         if err != nil && tc.expectedError == "" {
2787                                 t.Fatalf("CreateRevocationList failed unexpectedly: %s", err)
2788                         } else if err != nil && tc.expectedError != err.Error() {
2789                                 t.Fatalf("CreateRevocationList failed unexpectedly, wanted: %s, got: %s", tc.expectedError, err)
2790                         } else if err == nil && tc.expectedError != "" {
2791                                 t.Fatalf("CreateRevocationList didn't fail, expected: %s", tc.expectedError)
2792                         }
2793                         if tc.expectedError != "" {
2794                                 return
2795                         }
2796
2797                         parsedCRL, err := ParseRevocationList(crl)
2798                         if err != nil {
2799                                 t.Fatalf("Failed to parse generated CRL: %s", err)
2800                         }
2801
2802                         if tc.template.SignatureAlgorithm != UnknownSignatureAlgorithm &&
2803                                 parsedCRL.SignatureAlgorithm != tc.template.SignatureAlgorithm {
2804                                 t.Fatalf("SignatureAlgorithm mismatch: got %v; want %v.", parsedCRL.SignatureAlgorithm,
2805                                         tc.template.SignatureAlgorithm)
2806                         }
2807
2808                         if len(tc.template.RevokedCertificates) > 0 {
2809                                 if !reflect.DeepEqual(parsedCRL.RevokedCertificates, tc.template.RevokedCertificates) {
2810                                         t.Fatalf("RevokedCertificates mismatch: got %v; want %v.",
2811                                                 parsedCRL.RevokedCertificates, tc.template.RevokedCertificates)
2812                                 }
2813                         } else {
2814                                 if len(parsedCRL.RevokedCertificateEntries) != len(tc.template.RevokedCertificateEntries) {
2815                                         t.Fatalf("RevokedCertificateEntries length mismatch: got %d; want %d.",
2816                                                 len(parsedCRL.RevokedCertificateEntries),
2817                                                 len(tc.template.RevokedCertificateEntries))
2818                                 }
2819                                 for i, rce := range parsedCRL.RevokedCertificateEntries {
2820                                         expected := tc.template.RevokedCertificateEntries[i]
2821                                         if rce.SerialNumber.Cmp(expected.SerialNumber) != 0 {
2822                                                 t.Fatalf("RevocationListEntry serial mismatch: got %d; want %d.",
2823                                                         rce.SerialNumber, expected.SerialNumber)
2824                                         }
2825                                         if !rce.RevocationTime.Equal(expected.RevocationTime) {
2826                                                 t.Fatalf("RevocationListEntry revocation time mismatch: got %v; want %v.",
2827                                                         rce.RevocationTime, expected.RevocationTime)
2828                                         }
2829                                         if rce.ReasonCode != expected.ReasonCode {
2830                                                 t.Fatalf("RevocationListEntry reason code mismatch: got %d; want %d.",
2831                                                         rce.ReasonCode, expected.ReasonCode)
2832                                         }
2833                                 }
2834                         }
2835
2836                         if len(parsedCRL.Extensions) != 2+len(tc.template.ExtraExtensions) {
2837                                 t.Fatalf("Generated CRL has wrong number of extensions, wanted: %d, got: %d", 2+len(tc.template.ExtraExtensions), len(parsedCRL.Extensions))
2838                         }
2839                         expectedAKI, err := asn1.Marshal(authKeyId{Id: tc.issuer.SubjectKeyId})
2840                         if err != nil {
2841                                 t.Fatalf("asn1.Marshal failed: %s", err)
2842                         }
2843                         akiExt := pkix.Extension{
2844                                 Id:    oidExtensionAuthorityKeyId,
2845                                 Value: expectedAKI,
2846                         }
2847                         if !reflect.DeepEqual(parsedCRL.Extensions[0], akiExt) {
2848                                 t.Fatalf("Unexpected first extension: got %v, want %v",
2849                                         parsedCRL.Extensions[0], akiExt)
2850                         }
2851                         expectedNum, err := asn1.Marshal(tc.template.Number)
2852                         if err != nil {
2853                                 t.Fatalf("asn1.Marshal failed: %s", err)
2854                         }
2855                         crlExt := pkix.Extension{
2856                                 Id:    oidExtensionCRLNumber,
2857                                 Value: expectedNum,
2858                         }
2859                         if !reflect.DeepEqual(parsedCRL.Extensions[1], crlExt) {
2860                                 t.Fatalf("Unexpected second extension: got %v, want %v",
2861                                         parsedCRL.Extensions[1], crlExt)
2862                         }
2863
2864                         // With Go 1.19's updated RevocationList, we can now directly compare
2865                         // the RawSubject of the certificate to RawIssuer on the parsed CRL.
2866                         // However, this doesn't work with our hacked issuers above (that
2867                         // aren't parsed from a proper DER bundle but are instead manually
2868                         // constructed). Prefer RawSubject when it is set.
2869                         if len(tc.issuer.RawSubject) > 0 {
2870                                 issuerSubj, err := subjectBytes(tc.issuer)
2871                                 if err != nil {
2872                                         t.Fatalf("failed to get issuer subject: %s", err)
2873                                 }
2874                                 if !bytes.Equal(issuerSubj, parsedCRL.RawIssuer) {
2875                                         t.Fatalf("Unexpected issuer subject; wanted: %v, got: %v", hex.EncodeToString(issuerSubj), hex.EncodeToString(parsedCRL.RawIssuer))
2876                                 }
2877                         } else {
2878                                 // When we hack our custom Subject in the test cases above,
2879                                 // we don't set the additional fields (such as Names) in the
2880                                 // hacked issuer. Round-trip a parsing of pkix.Name so that
2881                                 // we add these missing fields for the comparison.
2882                                 issuerRDN := tc.issuer.Subject.ToRDNSequence()
2883                                 var caIssuer pkix.Name
2884                                 caIssuer.FillFromRDNSequence(&issuerRDN)
2885                                 if !reflect.DeepEqual(caIssuer, parsedCRL.Issuer) {
2886                                         t.Fatalf("Expected issuer.Subject, parsedCRL.Issuer to be the same; wanted: %#v, got: %#v", caIssuer, parsedCRL.Issuer)
2887                                 }
2888                         }
2889
2890                         if len(parsedCRL.Extensions[2:]) == 0 && len(tc.template.ExtraExtensions) == 0 {
2891                                 // If we don't have anything to check return early so we don't
2892                                 // hit a [] != nil false positive below.
2893                                 return
2894                         }
2895                         if !reflect.DeepEqual(parsedCRL.Extensions[2:], tc.template.ExtraExtensions) {
2896                                 t.Fatalf("Extensions mismatch: got %v; want %v.",
2897                                         parsedCRL.Extensions[2:], tc.template.ExtraExtensions)
2898                         }
2899
2900                         if tc.template.Number != nil && parsedCRL.Number == nil {
2901                                 t.Fatalf("Generated CRL missing Number: got nil, want %s",
2902                                         tc.template.Number.String())
2903                         }
2904                         if tc.template.Number != nil && tc.template.Number.Cmp(parsedCRL.Number) != 0 {
2905                                 t.Fatalf("Generated CRL has wrong Number: got %s, want %s",
2906                                         parsedCRL.Number.String(), tc.template.Number.String())
2907                         }
2908                         if !bytes.Equal(parsedCRL.AuthorityKeyId, expectedAKI) {
2909                                 t.Fatalf("Generated CRL has wrong Number: got %x, want %x",
2910                                         parsedCRL.AuthorityKeyId, expectedAKI)
2911                         }
2912                 })
2913         }
2914 }
2915
2916 func TestRSAPSAParameters(t *testing.T) {
2917         generateParams := func(hashFunc crypto.Hash) []byte {
2918                 var hashOID asn1.ObjectIdentifier
2919
2920                 switch hashFunc {
2921                 case crypto.SHA256:
2922                         hashOID = oidSHA256
2923                 case crypto.SHA384:
2924                         hashOID = oidSHA384
2925                 case crypto.SHA512:
2926                         hashOID = oidSHA512
2927                 }
2928
2929                 params := pssParameters{
2930                         Hash: pkix.AlgorithmIdentifier{
2931                                 Algorithm:  hashOID,
2932                                 Parameters: asn1.NullRawValue,
2933                         },
2934                         MGF: pkix.AlgorithmIdentifier{
2935                                 Algorithm: oidMGF1,
2936                         },
2937                         SaltLength:   hashFunc.Size(),
2938                         TrailerField: 1,
2939                 }
2940
2941                 mgf1Params := pkix.AlgorithmIdentifier{
2942                         Algorithm:  hashOID,
2943                         Parameters: asn1.NullRawValue,
2944                 }
2945
2946                 var err error
2947                 params.MGF.Parameters.FullBytes, err = asn1.Marshal(mgf1Params)
2948                 if err != nil {
2949                         t.Fatalf("failed to marshal MGF parameters: %s", err)
2950                 }
2951
2952                 serialized, err := asn1.Marshal(params)
2953                 if err != nil {
2954                         t.Fatalf("failed to marshal parameters: %s", err)
2955                 }
2956
2957                 return serialized
2958         }
2959
2960         for h, params := range hashToPSSParameters {
2961                 generated := generateParams(h)
2962                 if !bytes.Equal(params.FullBytes, generated) {
2963                         t.Errorf("hardcoded parameters for %s didn't match generated parameters: got (generated) %x, wanted (hardcoded) %x", h, generated, params.FullBytes)
2964                 }
2965         }
2966 }
2967
2968 func TestUnknownExtKey(t *testing.T) {
2969         const errorContains = "unknown extended key usage"
2970
2971         template := &Certificate{
2972                 SerialNumber: big.NewInt(10),
2973                 DNSNames:     []string{"foo"},
2974                 ExtKeyUsage:  []ExtKeyUsage{ExtKeyUsage(-1)},
2975         }
2976         signer, err := rsa.GenerateKey(rand.Reader, 1024)
2977         if err != nil {
2978                 t.Errorf("failed to generate key for TestUnknownExtKey")
2979         }
2980
2981         _, err = CreateCertificate(rand.Reader, template, template, signer.Public(), signer)
2982         if !strings.Contains(err.Error(), errorContains) {
2983                 t.Errorf("expected error containing %q, got %s", errorContains, err)
2984         }
2985 }
2986
2987 func TestIA5SANEnforcement(t *testing.T) {
2988         k, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
2989         if err != nil {
2990                 t.Fatalf("ecdsa.GenerateKey failed: %s", err)
2991         }
2992
2993         testURL, err := url.Parse("https://example.com/")
2994         if err != nil {
2995                 t.Fatalf("url.Parse failed: %s", err)
2996         }
2997         testURL.RawQuery = "∞"
2998
2999         marshalTests := []struct {
3000                 name          string
3001                 template      *Certificate
3002                 expectedError string
3003         }{
3004                 {
3005                         name: "marshal: unicode dNSName",
3006                         template: &Certificate{
3007                                 SerialNumber: big.NewInt(0),
3008                                 DNSNames:     []string{"∞"},
3009                         },
3010                         expectedError: "x509: \"∞\" cannot be encoded as an IA5String",
3011                 },
3012                 {
3013                         name: "marshal: unicode rfc822Name",
3014                         template: &Certificate{
3015                                 SerialNumber:   big.NewInt(0),
3016                                 EmailAddresses: []string{"∞"},
3017                         },
3018                         expectedError: "x509: \"∞\" cannot be encoded as an IA5String",
3019                 },
3020                 {
3021                         name: "marshal: unicode uniformResourceIdentifier",
3022                         template: &Certificate{
3023                                 SerialNumber: big.NewInt(0),
3024                                 URIs:         []*url.URL{testURL},
3025                         },
3026                         expectedError: "x509: \"https://example.com/?∞\" cannot be encoded as an IA5String",
3027                 },
3028         }
3029
3030         for _, tc := range marshalTests {
3031                 t.Run(tc.name, func(t *testing.T) {
3032                         _, err := CreateCertificate(rand.Reader, tc.template, tc.template, k.Public(), k)
3033                         if err == nil {
3034                                 t.Errorf("expected CreateCertificate to fail with template: %v", tc.template)
3035                         } else if err.Error() != tc.expectedError {
3036                                 t.Errorf("unexpected error: got %q, want %q", err.Error(), tc.expectedError)
3037                         }
3038                 })
3039         }
3040
3041         unmarshalTests := []struct {
3042                 name          string
3043                 cert          string
3044                 expectedError string
3045         }{
3046                 {
3047                         name:          "unmarshal: unicode dNSName",
3048                         cert:          "308201083081aea003020102020100300a06082a8648ce3d04030230003022180f30303031303130313030303030305a180f30303031303130313030303030305a30003059301306072a8648ce3d020106082a8648ce3d0301070342000424bcc48180d8d9db794028f2575ebe3cac79f04d7b0d0151c5292e588aac3668c495f108c626168462e0668c9705e08a211dd103a659d2684e0adf8c2bfd47baa315301330110603551d110101ff040730058203e2889e300a06082a8648ce3d04030203490030460221008ac7827ac326a6ee0fa70b2afe99af575ec60b975f820f3c25f60fff43fbccd0022100bffeed93556722d43d13e461d5b3e33efc61f6349300327d3a0196cb6da501c2",
3049                         expectedError: "x509: SAN dNSName is malformed",
3050                 },
3051                 {
3052                         name:          "unmarshal: unicode rfc822Name",
3053                         cert:          "308201083081aea003020102020100300a06082a8648ce3d04030230003022180f30303031303130313030303030305a180f30303031303130313030303030305a30003059301306072a8648ce3d020106082a8648ce3d0301070342000405cb4c4ba72aac980f7b11b0285191425e29e196ce7c5df1c83f56886566e517f196657cc1b73de89ab84ce503fd634e2f2af88fde24c63ca536dc3a5eed2665a315301330110603551d110101ff040730058103e2889e300a06082a8648ce3d0403020349003046022100ed1431cd4b9bb03d88d1511a0ec128a51204375764c716280dc36e2a60142c8902210088c96d25cfaf97eea851ff17d87bb6fe619d6546656e1739f35c3566051c3d0f",
3054                         expectedError: "x509: SAN rfc822Name is malformed",
3055                 },
3056                 {
3057                         name:          "unmarshal: unicode uniformResourceIdentifier",
3058                         cert:          "3082011b3081c3a003020102020100300a06082a8648ce3d04030230003022180f30303031303130313030303030305a180f30303031303130313030303030305a30003059301306072a8648ce3d020106082a8648ce3d03010703420004ce0a79b511701d9188e1ea76bcc5907f1db51de6cc1a037b803f256e8588145ca409d120288bfeb4e38f3088104674d374b35bb91fc80d768d1d519dbe2b0b5aa32a302830260603551d110101ff041c301a861868747470733a2f2f6578616d706c652e636f6d2f3fe2889e300a06082a8648ce3d0403020347003044022044f4697779fd1dae1e382d2452413c5c5ca67851e267d6bc64a8d164977c172c0220505015e657637aa1945d46e7650b6f59b968fc1508ca8b152c99f782446dfc81",
3059                         expectedError: "x509: SAN uniformResourceIdentifier is malformed",
3060                 },
3061         }
3062
3063         for _, tc := range unmarshalTests {
3064                 der, err := hex.DecodeString(tc.cert)
3065                 if err != nil {
3066                         t.Fatalf("failed to decode test cert: %s", err)
3067                 }
3068                 _, err = ParseCertificate(der)
3069                 if err == nil {
3070                         t.Error("expected CreateCertificate to fail")
3071                 } else if err.Error() != tc.expectedError {
3072                         t.Errorf("unexpected error: got %q, want %q", err.Error(), tc.expectedError)
3073                 }
3074         }
3075 }
3076
3077 func BenchmarkCreateCertificate(b *testing.B) {
3078         template := &Certificate{
3079                 SerialNumber: big.NewInt(10),
3080                 DNSNames:     []string{"example.com"},
3081         }
3082         tests := []struct {
3083                 name string
3084                 gen  func() crypto.Signer
3085         }{
3086                 {
3087                         name: "RSA 2048",
3088                         gen: func() crypto.Signer {
3089                                 k, err := rsa.GenerateKey(rand.Reader, 2048)
3090                                 if err != nil {
3091                                         b.Fatalf("failed to generate test key: %s", err)
3092                                 }
3093                                 return k
3094                         },
3095                 },
3096                 {
3097                         name: "ECDSA P256",
3098                         gen: func() crypto.Signer {
3099                                 k, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
3100                                 if err != nil {
3101                                         b.Fatalf("failed to generate test key: %s", err)
3102                                 }
3103                                 return k
3104                         },
3105                 },
3106         }
3107
3108         for _, tc := range tests {
3109                 k := tc.gen()
3110                 b.ResetTimer()
3111                 b.Run(tc.name, func(b *testing.B) {
3112                         for i := 0; i < b.N; i++ {
3113                                 _, err := CreateCertificate(rand.Reader, template, template, k.Public(), k)
3114                                 if err != nil {
3115                                         b.Fatalf("failed to create certificate: %s", err)
3116                                 }
3117                         }
3118                 })
3119         }
3120 }
3121
3122 type brokenSigner struct {
3123         pub crypto.PublicKey
3124 }
3125
3126 func (bs *brokenSigner) Public() crypto.PublicKey {
3127         return bs.pub
3128 }
3129
3130 func (bs *brokenSigner) Sign(_ io.Reader, _ []byte, _ crypto.SignerOpts) ([]byte, error) {
3131         return []byte{1, 2, 3}, nil
3132 }
3133
3134 func TestCreateCertificateBrokenSigner(t *testing.T) {
3135         template := &Certificate{
3136                 SerialNumber: big.NewInt(10),
3137                 DNSNames:     []string{"example.com"},
3138         }
3139         k, err := rsa.GenerateKey(rand.Reader, 1024)
3140         if err != nil {
3141                 t.Fatalf("failed to generate test key: %s", err)
3142         }
3143         expectedErr := "x509: signature over certificate returned by signer is invalid: crypto/rsa: verification error"
3144         _, err = CreateCertificate(rand.Reader, template, template, k.Public(), &brokenSigner{k.Public()})
3145         if err == nil {
3146                 t.Fatal("expected CreateCertificate to fail with a broken signer")
3147         } else if err.Error() != expectedErr {
3148                 t.Fatalf("CreateCertificate returned an unexpected error: got %q, want %q", err, expectedErr)
3149         }
3150 }
3151
3152 func TestCreateCertificateLegacy(t *testing.T) {
3153         sigAlg := MD5WithRSA
3154         template := &Certificate{
3155                 SerialNumber:       big.NewInt(10),
3156                 DNSNames:           []string{"example.com"},
3157                 SignatureAlgorithm: sigAlg,
3158         }
3159         _, err := CreateCertificate(rand.Reader, template, template, testPrivateKey.Public(), &brokenSigner{testPrivateKey.Public()})
3160         if err == nil {
3161                 t.Fatal("CreateCertificate didn't fail when SignatureAlgorithm = MD5WithRSA")
3162         }
3163 }
3164
3165 func (s *CertPool) mustCert(t *testing.T, n int) *Certificate {
3166         c, err := s.lazyCerts[n].getCert()
3167         if err != nil {
3168                 t.Fatalf("failed to load cert %d: %v", n, err)
3169         }
3170         return c
3171 }
3172
3173 func allCerts(t *testing.T, p *CertPool) []*Certificate {
3174         all := make([]*Certificate, p.len())
3175         for i := range all {
3176                 all[i] = p.mustCert(t, i)
3177         }
3178         return all
3179 }
3180
3181 // certPoolEqual reports whether a and b are equal, except for the
3182 // function pointers.
3183 func certPoolEqual(a, b *CertPool) bool {
3184         if (a != nil) != (b != nil) {
3185                 return false
3186         }
3187         if a == nil {
3188                 return true
3189         }
3190         if !reflect.DeepEqual(a.byName, b.byName) ||
3191                 len(a.lazyCerts) != len(b.lazyCerts) {
3192                 return false
3193         }
3194         for i := range a.lazyCerts {
3195                 la, lb := a.lazyCerts[i], b.lazyCerts[i]
3196                 if !bytes.Equal(la.rawSubject, lb.rawSubject) {
3197                         return false
3198                 }
3199                 ca, err := la.getCert()
3200                 if err != nil {
3201                         panic(err)
3202                 }
3203                 cb, err := la.getCert()
3204                 if err != nil {
3205                         panic(err)
3206                 }
3207                 if !ca.Equal(cb) {
3208                         return false
3209                 }
3210         }
3211
3212         return true
3213 }
3214
3215 func TestCertificateRequestRoundtripFields(t *testing.T) {
3216         urlA, err := url.Parse("https://example.com/_")
3217         if err != nil {
3218                 t.Fatal(err)
3219         }
3220         urlB, err := url.Parse("https://example.org/_")
3221         if err != nil {
3222                 t.Fatal(err)
3223         }
3224         in := &CertificateRequest{
3225                 DNSNames:       []string{"example.com", "example.org"},
3226                 EmailAddresses: []string{"a@example.com", "b@example.com"},
3227                 IPAddresses:    []net.IP{net.IPv4(192, 0, 2, 0), net.IPv6loopback},
3228                 URIs:           []*url.URL{urlA, urlB},
3229         }
3230         out := marshalAndParseCSR(t, in)
3231
3232         if !reflect.DeepEqual(in.DNSNames, out.DNSNames) {
3233                 t.Fatalf("Unexpected DNSNames: got %v, want %v", out.DNSNames, in.DNSNames)
3234         }
3235         if !reflect.DeepEqual(in.EmailAddresses, out.EmailAddresses) {
3236                 t.Fatalf("Unexpected EmailAddresses: got %v, want %v", out.EmailAddresses, in.EmailAddresses)
3237         }
3238         if len(in.IPAddresses) != len(out.IPAddresses) ||
3239                 !in.IPAddresses[0].Equal(out.IPAddresses[0]) ||
3240                 !in.IPAddresses[1].Equal(out.IPAddresses[1]) {
3241                 t.Fatalf("Unexpected IPAddresses: got %v, want %v", out.IPAddresses, in.IPAddresses)
3242         }
3243         if !reflect.DeepEqual(in.URIs, out.URIs) {
3244                 t.Fatalf("Unexpected URIs: got %v, want %v", out.URIs, in.URIs)
3245         }
3246 }
3247
3248 func BenchmarkParseCertificate(b *testing.B) {
3249         cases := []struct {
3250                 name string
3251                 pem  string
3252         }{
3253                 {
3254                         name: "ecdsa leaf",
3255                         pem: `-----BEGIN CERTIFICATE-----
3256 MIIINjCCBx6gAwIBAgIQHdQ6oBMoe/MJAAAAAEHzmTANBgkqhkiG9w0BAQsFADBG
3257 MQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExM
3258 QzETMBEGA1UEAxMKR1RTIENBIDFDMzAeFw0yMDEyMDgwOTExMzZaFw0yMTAzMDIw
3259 OTExMzVaMBcxFTATBgNVBAMMDCouZ29vZ2xlLmNvbTBZMBMGByqGSM49AgEGCCqG
3260 SM49AwEHA0IABEFYegyHh1AHRS1nar5+zYJgMACcsIQMtg0YMyK/59ml8ERIt/JF
3261 kXM3XIvQuCJhghUawZrrAcAs8djZF1U9M4mjggYYMIIGFDAOBgNVHQ8BAf8EBAMC
3262 B4AwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAdBgNVHQ4EFgQU
3263 6SWWF36XBsmXJ6iV0EHPXUFoMbwwHwYDVR0jBBgwFoAUinR/r4XN7pXNPZzQ4kYU
3264 83E1HScwagYIKwYBBQUHAQEEXjBcMCcGCCsGAQUFBzABhhtodHRwOi8vb2NzcC5w
3265 a2kuZ29vZy9ndHMxYzMwMQYIKwYBBQUHMAKGJWh0dHA6Ly9wa2kuZ29vZy9yZXBv
3266 L2NlcnRzL2d0czFjMy5kZXIwggTCBgNVHREEggS5MIIEtYIMKi5nb29nbGUuY29t
3267 gg0qLmFuZHJvaWQuY29tghYqLmFwcGVuZ2luZS5nb29nbGUuY29tggkqLmJkbi5k
3268 ZXaCEiouY2xvdWQuZ29vZ2xlLmNvbYIYKi5jcm93ZHNvdXJjZS5nb29nbGUuY29t
3269 ghgqLmRhdGFjb21wdXRlLmdvb2dsZS5jb22CBiouZy5jb4IOKi5nY3AuZ3Z0Mi5j
3270 b22CESouZ2NwY2RuLmd2dDEuY29tggoqLmdncGh0LmNugg4qLmdrZWNuYXBwcy5j
3271 boIWKi5nb29nbGUtYW5hbHl0aWNzLmNvbYILKi5nb29nbGUuY2GCCyouZ29vZ2xl
3272 LmNsgg4qLmdvb2dsZS5jby5pboIOKi5nb29nbGUuY28uanCCDiouZ29vZ2xlLmNv
3273 LnVrgg8qLmdvb2dsZS5jb20uYXKCDyouZ29vZ2xlLmNvbS5hdYIPKi5nb29nbGUu
3274 Y29tLmJygg8qLmdvb2dsZS5jb20uY2+CDyouZ29vZ2xlLmNvbS5teIIPKi5nb29n
3275 bGUuY29tLnRygg8qLmdvb2dsZS5jb20udm6CCyouZ29vZ2xlLmRlggsqLmdvb2ds
3276 ZS5lc4ILKi5nb29nbGUuZnKCCyouZ29vZ2xlLmh1ggsqLmdvb2dsZS5pdIILKi5n
3277 b29nbGUubmyCCyouZ29vZ2xlLnBsggsqLmdvb2dsZS5wdIISKi5nb29nbGVhZGFw
3278 aXMuY29tgg8qLmdvb2dsZWFwaXMuY26CESouZ29vZ2xlY25hcHBzLmNughQqLmdv
3279 b2dsZWNvbW1lcmNlLmNvbYIRKi5nb29nbGV2aWRlby5jb22CDCouZ3N0YXRpYy5j
3280 boINKi5nc3RhdGljLmNvbYISKi5nc3RhdGljY25hcHBzLmNuggoqLmd2dDEuY29t
3281 ggoqLmd2dDIuY29tghQqLm1ldHJpYy5nc3RhdGljLmNvbYIMKi51cmNoaW4uY29t
3282 ghAqLnVybC5nb29nbGUuY29tghMqLndlYXIuZ2tlY25hcHBzLmNughYqLnlvdXR1
3283 YmUtbm9jb29raWUuY29tgg0qLnlvdXR1YmUuY29tghYqLnlvdXR1YmVlZHVjYXRp
3284 b24uY29tghEqLnlvdXR1YmVraWRzLmNvbYIHKi55dC5iZYILKi55dGltZy5jb22C
3285 GmFuZHJvaWQuY2xpZW50cy5nb29nbGUuY29tggthbmRyb2lkLmNvbYIbZGV2ZWxv
3286 cGVyLmFuZHJvaWQuZ29vZ2xlLmNughxkZXZlbG9wZXJzLmFuZHJvaWQuZ29vZ2xl
3287 LmNuggRnLmNvgghnZ3BodC5jboIMZ2tlY25hcHBzLmNuggZnb28uZ2yCFGdvb2ds
3288 ZS1hbmFseXRpY3MuY29tggpnb29nbGUuY29tgg9nb29nbGVjbmFwcHMuY26CEmdv
3289 b2dsZWNvbW1lcmNlLmNvbYIYc291cmNlLmFuZHJvaWQuZ29vZ2xlLmNuggp1cmNo
3290 aW4uY29tggp3d3cuZ29vLmdsggh5b3V0dS5iZYILeW91dHViZS5jb22CFHlvdXR1
3291 YmVlZHVjYXRpb24uY29tgg95b3V0dWJla2lkcy5jb22CBXl0LmJlMCEGA1UdIAQa
3292 MBgwCAYGZ4EMAQIBMAwGCisGAQQB1nkCBQMwNQYDVR0fBC4wLDAqoCigJoYkaHR0
3293 cDovL2NybC5wa2kuZ29vZy9ndHNyMS9ndHMxYzMuY3JsMBMGCisGAQQB1nkCBAMB
3294 Af8EAgUAMA0GCSqGSIb3DQEBCwUAA4IBAQAlDQm5zY7JcPxcJ9ulfTGsWV/m6Pro
3295 gLYmAlBUPGKy313aetT4Zjz44ZseVtUOKsXVHh4avPA9O+ta1FgkASlbkgJ05ivb
3296 j/+MMqkrLemdMv9Svvx3CNaAq2jJ2E+8GdrA1RzMkiNthJCiRafaPnXnN6hOHGNr
3297 GtqYfMHsvrRHW8J2IPHW0/MUHmJ/NDu/vNchxke2OEfCPLtseo3hJt8l8HbH+yE8
3298 DFrt8YVRi1CLomEyuPJDF4og3O3ZsoXuxcPd9UPxULOCxycdolRw8Iv/Xgr082j3
3299 svXC3HUd3apM2Yy3xJAlk/mUkzVXfdJZ+Zy1huNsUoJ+gM8rmpyGhYyx
3300 -----END CERTIFICATE-----`,
3301                 },
3302                 {
3303                         name: "rsa leaf",
3304                         pem: `-----BEGIN CERTIFICATE-----
3305 MIIJXjCCCEagAwIBAgIRAPYaTUsjP4iRBQAAAACHSSgwDQYJKoZIhvcNAQELBQAw
3306 QjELMAkGA1UEBhMCVVMxHjAcBgNVBAoTFUdvb2dsZSBUcnVzdCBTZXJ2aWNlczET
3307 MBEGA1UEAxMKR1RTIENBIDFPMTAeFw0yMTAxMjYwODQ2MzRaFw0yMTA0MjAwODQ2
3308 MzNaMGYxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpDYWxpZm9ybmlhMRYwFAYDVQQH
3309 Ew1Nb3VudGFpbiBWaWV3MRMwEQYDVQQKEwpHb29nbGUgTExDMRUwEwYDVQQDDAwq
3310 Lmdvb2dsZS5jb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC76xx0
3311 UdZ36/41rZNPfQ/yQ05vsBLUO0d+3uMOhvDlpst+XvIsG6L+vLDgf3RiQRFlei0h
3312 KqqLOtWLDc/y0+OmaaC+8ft1zljBYdvQlAYoZrT79Cc5pAIDq7G1OZ7cC4ahDno/
3313 n46FHjT/UTUAMYa8cKWBaMPneMIsKvn8nMdZzHkfO2nUd6OEecn90XweMvNmx8De
3314 6h5AlIgG3m66hkD/UCSdxn7yJHBQVdHgkfTqzv3sz2YyBQGNi288F1bn541f6khE
3315 fYti1MvXRtkky7yLCQNUG6PtvuSU4cKaNvRklHigf5i1nVdGEuH61gAElZIklSia
3316 OVK46UyU4DGtbdWNAgMBAAGjggYpMIIGJTAOBgNVHQ8BAf8EBAMCBaAwEwYDVR0l
3317 BAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAdBgNVHQ4EFgQU8zCvllLd3jhB
3318 k//+Wdjo40Q+T3gwHwYDVR0jBBgwFoAUmNH4bhDrz5vsYJ8YkBug630J/SswaAYI
3319 KwYBBQUHAQEEXDBaMCsGCCsGAQUFBzABhh9odHRwOi8vb2NzcC5wa2kuZ29vZy9n
3320 dHMxbzFjb3JlMCsGCCsGAQUFBzAChh9odHRwOi8vcGtpLmdvb2cvZ3NyMi9HVFMx
3321 TzEuY3J0MIIE1wYDVR0RBIIEzjCCBMqCDCouZ29vZ2xlLmNvbYINKi5hbmRyb2lk
3322 LmNvbYIWKi5hcHBlbmdpbmUuZ29vZ2xlLmNvbYIJKi5iZG4uZGV2ghIqLmNsb3Vk
3323 Lmdvb2dsZS5jb22CGCouY3Jvd2Rzb3VyY2UuZ29vZ2xlLmNvbYIYKi5kYXRhY29t
3324 cHV0ZS5nb29nbGUuY29tghMqLmZsYXNoLmFuZHJvaWQuY29tggYqLmcuY2+CDiou
3325 Z2NwLmd2dDIuY29tghEqLmdjcGNkbi5ndnQxLmNvbYIKKi5nZ3BodC5jboIOKi5n
3326 a2VjbmFwcHMuY26CFiouZ29vZ2xlLWFuYWx5dGljcy5jb22CCyouZ29vZ2xlLmNh
3327 ggsqLmdvb2dsZS5jbIIOKi5nb29nbGUuY28uaW6CDiouZ29vZ2xlLmNvLmpwgg4q
3328 Lmdvb2dsZS5jby51a4IPKi5nb29nbGUuY29tLmFygg8qLmdvb2dsZS5jb20uYXWC
3329 DyouZ29vZ2xlLmNvbS5icoIPKi5nb29nbGUuY29tLmNvgg8qLmdvb2dsZS5jb20u
3330 bXiCDyouZ29vZ2xlLmNvbS50coIPKi5nb29nbGUuY29tLnZuggsqLmdvb2dsZS5k
3331 ZYILKi5nb29nbGUuZXOCCyouZ29vZ2xlLmZyggsqLmdvb2dsZS5odYILKi5nb29n
3332 bGUuaXSCCyouZ29vZ2xlLm5sggsqLmdvb2dsZS5wbIILKi5nb29nbGUucHSCEiou
3333 Z29vZ2xlYWRhcGlzLmNvbYIPKi5nb29nbGVhcGlzLmNughEqLmdvb2dsZWNuYXBw
3334 cy5jboIUKi5nb29nbGVjb21tZXJjZS5jb22CESouZ29vZ2xldmlkZW8uY29tggwq
3335 LmdzdGF0aWMuY26CDSouZ3N0YXRpYy5jb22CEiouZ3N0YXRpY2NuYXBwcy5jboIK
3336 Ki5ndnQxLmNvbYIKKi5ndnQyLmNvbYIUKi5tZXRyaWMuZ3N0YXRpYy5jb22CDCou
3337 dXJjaGluLmNvbYIQKi51cmwuZ29vZ2xlLmNvbYITKi53ZWFyLmdrZWNuYXBwcy5j
3338 boIWKi55b3V0dWJlLW5vY29va2llLmNvbYINKi55b3V0dWJlLmNvbYIWKi55b3V0
3339 dWJlZWR1Y2F0aW9uLmNvbYIRKi55b3V0dWJla2lkcy5jb22CByoueXQuYmWCCyou
3340 eXRpbWcuY29tghphbmRyb2lkLmNsaWVudHMuZ29vZ2xlLmNvbYILYW5kcm9pZC5j
3341 b22CG2RldmVsb3Blci5hbmRyb2lkLmdvb2dsZS5jboIcZGV2ZWxvcGVycy5hbmRy
3342 b2lkLmdvb2dsZS5jboIEZy5jb4IIZ2dwaHQuY26CDGdrZWNuYXBwcy5jboIGZ29v
3343 LmdsghRnb29nbGUtYW5hbHl0aWNzLmNvbYIKZ29vZ2xlLmNvbYIPZ29vZ2xlY25h
3344 cHBzLmNughJnb29nbGVjb21tZXJjZS5jb22CGHNvdXJjZS5hbmRyb2lkLmdvb2ds
3345 ZS5jboIKdXJjaGluLmNvbYIKd3d3Lmdvby5nbIIIeW91dHUuYmWCC3lvdXR1YmUu
3346 Y29tghR5b3V0dWJlZWR1Y2F0aW9uLmNvbYIPeW91dHViZWtpZHMuY29tggV5dC5i
3347 ZTAhBgNVHSAEGjAYMAgGBmeBDAECAjAMBgorBgEEAdZ5AgUDMDMGA1UdHwQsMCow
3348 KKAmoCSGImh0dHA6Ly9jcmwucGtpLmdvb2cvR1RTMU8xY29yZS5jcmwwEwYKKwYB
3349 BAHWeQIEAwEB/wQCBQAwDQYJKoZIhvcNAQELBQADggEBAHh9/ozYUGRd+W5akWlM
3350 4WvX808TK2oUISnagbxCCFZ2trpg2oi03CJf4o4o3Je5Qzzz10s22oQY6gPHAR0B
3351 QHzrpqAveQw9D5vd8xjgtQ/SAujPzPKNQee5511rS7/EKW9I83ccd5XhhoEyx8A1
3352 /65RTS+2hKpJKTMkr0yHBPJV7kUW+n/KIef5YaSOA9VYK7hyH0niDpvm9EmoqvWS
3353 U5xAFAe/Xrrq3sxTuDJPQA8alk6h/ql5Klkw6dL53csiPka/MevDqdifWkzuT/6n
3354 YK/ePeJzPD17FA9V+N1rcuF3Wk29AZvCOSasdIkIuE82vGr3dfNrsrn9E9lWIbCr
3355 Qc4=
3356 -----END CERTIFICATE-----`,
3357                 },
3358         }
3359         for _, c := range cases {
3360                 b.Run(c.name, func(b *testing.B) {
3361                         pemBlock, _ := pem.Decode([]byte(c.pem))
3362                         b.ReportAllocs()
3363                         b.ResetTimer()
3364                         for i := 0; i < b.N; i++ {
3365                                 _, err := ParseCertificate(pemBlock.Bytes)
3366                                 if err != nil {
3367                                         b.Fatal(err)
3368                                 }
3369                         }
3370                 })
3371         }
3372 }
3373
3374 func TestParseCertificateRawEquals(t *testing.T) {
3375         p, _ := pem.Decode([]byte(pemCertificate))
3376         cert, err := ParseCertificate(p.Bytes)
3377         if err != nil {
3378                 t.Fatalf("failed to parse certificate: %s", err)
3379         }
3380         if !bytes.Equal(p.Bytes, cert.Raw) {
3381                 t.Fatalf("unexpected Certificate.Raw\ngot: %x\nwant: %x\n", cert.Raw, p.Bytes)
3382         }
3383 }
3384
3385 // mismatchingSigAlgIDPEM contains a certificate where the Certificate
3386 // signatureAlgorithm and the TBSCertificate signature contain
3387 // mismatching OIDs
3388 const mismatchingSigAlgIDPEM = `-----BEGIN CERTIFICATE-----
3389 MIIBBzCBrqADAgECAgEAMAoGCCqGSM49BAMCMAAwIhgPMDAwMTAxMDEwMDAwMDBa
3390 GA8wMDAxMDEwMTAwMDAwMFowADBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOqV
3391 EDuVXxwZgIU3+dOwv1SsMu0xuV48hf7xmK8n7sAMYgllB+96DnPqBeboJj4snYnx
3392 0AcE0PDVQ1l4Z3YXsQWjFTATMBEGA1UdEQEB/wQHMAWCA2FzZDAKBggqhkjOPQQD
3393 AwNIADBFAiBi1jz/T2HT5nAfrD7zsgR+68qh7Erc6Q4qlxYBOgKG4QIhAOtjIn+Q
3394 tA+bq+55P3ntxTOVRq0nv1mwnkjwt9cQR9Fn
3395 -----END CERTIFICATE-----`
3396
3397 // mismatchingSigAlgParamPEM contains a certificate where the Certificate
3398 // signatureAlgorithm and the TBSCertificate signature contain
3399 // mismatching parameters
3400 const mismatchingSigAlgParamPEM = `-----BEGIN CERTIFICATE-----
3401 MIIBCTCBrqADAgECAgEAMAoGCCqGSM49BAMCMAAwIhgPMDAwMTAxMDEwMDAwMDBa
3402 GA8wMDAxMDEwMTAwMDAwMFowADBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOqV
3403 EDuVXxwZgIU3+dOwv1SsMu0xuV48hf7xmK8n7sAMYgllB+96DnPqBeboJj4snYnx
3404 0AcE0PDVQ1l4Z3YXsQWjFTATMBEGA1UdEQEB/wQHMAWCA2FzZDAMBggqhkjOPQQD
3405 AgUAA0gAMEUCIGLWPP9PYdPmcB+sPvOyBH7ryqHsStzpDiqXFgE6AobhAiEA62Mi
3406 f5C0D5ur7nk/ee3FM5VGrSe/WbCeSPC31xBH0Wc=
3407 -----END CERTIFICATE-----`
3408
3409 func TestSigAlgMismatch(t *testing.T) {
3410         for _, certPEM := range []string{mismatchingSigAlgIDPEM, mismatchingSigAlgParamPEM} {
3411                 b, _ := pem.Decode([]byte(certPEM))
3412                 if b == nil {
3413                         t.Fatalf("couldn't decode test certificate")
3414                 }
3415                 _, err := ParseCertificate(b.Bytes)
3416                 if err == nil {
3417                         t.Fatalf("expected ParseCertificate to fail")
3418                 }
3419                 expected := "x509: inner and outer signature algorithm identifiers don't match"
3420                 if err.Error() != expected {
3421                         t.Errorf("unexpected error from ParseCertificate: got %q, want %q", err.Error(), expected)
3422                 }
3423         }
3424 }
3425
3426 const optionalAuthKeyIDPEM = `-----BEGIN CERTIFICATE-----
3427 MIIFEjCCBHugAwIBAgICAQwwDQYJKoZIhvcNAQEFBQAwgbsxJDAiBgNVBAcTG1Zh
3428 bGlDZXJ0IFZhbGlkYXRpb24gTmV0d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIElu
3429 Yy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENsYXNzIDIgUG9saWN5IFZhbGlkYXRpb24g
3430 QXV0aG9yaXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAe
3431 BgkqhkiG9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMB4XDTA0MDYyOTE3MzkxNloX
3432 DTI0MDYyOTE3MzkxNlowaDELMAkGA1UEBhMCVVMxJTAjBgNVBAoTHFN0YXJmaWVs
3433 ZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAsTKVN0YXJmaWVsZCBDbGFzcyAy
3434 IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIIBIDANBgkqhkiG9w0BAQEFAAOCAQ0A
3435 MIIBCAKCAQEAtzLI/ulxpgSFrQwRZN/OTe/IAxiHP6Gr+zymn/DDodrU2G4rU5D7
3436 JKQ+hPCe6F/s5SdE9SimP3ve4CrwyK9TL57KBQGTHo9mHDmnTfpatnMEJWbrd3/n
3437 WcZKmSUUVOsmx/N/GdUwcI+vsEYq/63rKe3Xn6oEh6PU+YmlNF/bQ5GCNtlmPLG4
3438 uYL9nDo+EMg77wZlZnqbGRg9/3FRPDAuX749d3OyXQZswyNWmiuFJpIcpwKz5D8N
3439 rwh5grg2Peqc0zWzvGnK9cyd6P1kjReAM25eSl2ZyR6HtJ0awNVuEzUjXt+bXz3v
3440 1vd2wuo+u3gNHEJnawTY+Nbab4vyRKABqwIBA6OCAfMwggHvMB0GA1UdDgQWBBS/
3441 X7fRzt0fhvRbVazc1xDCDqmI5zCB0gYDVR0jBIHKMIHHoYHBpIG+MIG7MSQwIgYD
3442 VQQHExtWYWxpQ2VydCBWYWxpZGF0aW9uIE5ldHdvcmsxFzAVBgNVBAoTDlZhbGlD
3443 ZXJ0LCBJbmMuMTUwMwYDVQQLEyxWYWxpQ2VydCBDbGFzcyAyIFBvbGljeSBWYWxp
3444 ZGF0aW9uIEF1dGhvcml0eTEhMB8GA1UEAxMYaHR0cDovL3d3dy52YWxpY2VydC5j
3445 b20vMSAwHgYJKoZIhvcNAQkBFhFpbmZvQHZhbGljZXJ0LmNvbYIBATAPBgNVHRMB
3446 Af8EBTADAQH/MDkGCCsGAQUFBwEBBC0wKzApBggrBgEFBQcwAYYdaHR0cDovL29j
3447 c3Auc3RhcmZpZWxkdGVjaC5jb20wSgYDVR0fBEMwQTA/oD2gO4Y5aHR0cDovL2Nl
3448 cnRpZmljYXRlcy5zdGFyZmllbGR0ZWNoLmNvbS9yZXBvc2l0b3J5L3Jvb3QuY3Js
3449 MFEGA1UdIARKMEgwRgYEVR0gADA+MDwGCCsGAQUFBwIBFjBodHRwOi8vY2VydGlm
3450 aWNhdGVzLnN0YXJmaWVsZHRlY2guY29tL3JlcG9zaXRvcnkwDgYDVR0PAQH/BAQD
3451 AgEGMA0GCSqGSIb3DQEBBQUAA4GBAKVi8afCXSWlcD284ipxs33kDTcdVWptobCr
3452 mADkhWBKIMuh8D1195TaQ39oXCUIuNJ9MxB73HZn8bjhU3zhxoNbKXuNSm8uf0So
3453 GkVrMgfHeMpkksK0hAzc3S1fTbvdiuo43NlmouxBulVtWmQ9twPMHOKRUJ7jCUSV
3454 FxdzPcwl
3455 -----END CERTIFICATE-----`
3456
3457 func TestAuthKeyIdOptional(t *testing.T) {
3458         b, _ := pem.Decode([]byte(optionalAuthKeyIDPEM))
3459         if b == nil {
3460                 t.Fatalf("couldn't decode test certificate")
3461         }
3462         _, err := ParseCertificate(b.Bytes)
3463         if err != nil {
3464                 t.Fatalf("ParseCertificate to failed to parse certificate with optional authority key identifier fields: %s", err)
3465         }
3466 }
3467
3468 const largeOIDPEM = `
3469 Certificate:
3470     Data:
3471         Version: 3 (0x2)
3472         Serial Number:
3473             da:ba:53:19:1b:09:4b:82:b2:89:26:7d:c7:6f:a0:02
3474         Signature Algorithm: sha256WithRSAEncryption
3475         Issuer: O = Acme Co
3476         Validity
3477             Not Before: Dec 21 16:59:27 2021 GMT
3478             Not After : Dec 21 16:59:27 2022 GMT
3479         Subject: O = Acme Co
3480         Subject Public Key Info:
3481             Public Key Algorithm: rsaEncryption
3482                 RSA Public-Key: (2048 bit)
3483                 Modulus:
3484                     00:bf:17:16:d8:bc:29:9c:16:e5:76:b4:93:15:78:
3485                     ad:6e:45:c5:4a:63:46:a1:b2:76:71:65:51:9c:14:
3486                     c4:ea:74:13:e4:34:df:2f:2c:65:11:e8:56:52:69:
3487                     11:f9:0e:fc:77:bb:63:a8:7c:1a:c6:a1:7b:6e:6c:
3488                     e7:18:25:25:c9:e8:fb:06:7f:a2:a9:98:fe:2a:bc:
3489                     8a:b3:75:b6:b8:7d:b6:c9:6b:29:08:32:22:10:cb:
3490                     8d:d6:60:c8:83:ad:f5:58:91:d6:11:e8:55:56:fb:
3491                     8f:a3:a2:9f:48:cb:79:e4:65:4a:8c:a6:52:64:9f:
3492                     99:38:35:d4:d5:ac:6f:cf:a0:cb:42:8c:07:eb:21:
3493                     17:31:3a:eb:91:7b:62:43:a4:75:5f:ef:a7:2f:94:
3494                     f8:69:0b:d4:ec:09:e6:00:c0:8c:dd:07:63:0b:e4:
3495                     77:aa:60:18:3c:a0:e0:ae:0a:ea:0e:52:3b:b4:fa:
3496                     6a:30:1b:50:62:21:73:53:33:01:60:a1:6b:99:58:
3497                     00:f3:77:c6:0f:46:19:ca:c2:5d:cd:f5:e2:52:4d:
3498                     84:94:23:d3:32:2f:ae:5f:da:43:a1:19:95:d2:17:
3499                     dd:49:14:b4:d9:48:1c:08:13:93:8e:d5:09:43:21:
3500                     b6:ce:52:e8:87:bb:d2:60:0d:c6:4e:bf:c5:93:6a:
3501                     c6:bf
3502                 Exponent: 65537 (0x10001)
3503         X509v3 extensions:
3504             X509v3 Key Usage: critical
3505                 Digital Signature, Key Encipherment
3506             X509v3 Extended Key Usage:
3507                 TLS Web Server Authentication
3508             X509v3 Basic Constraints: critical
3509                 CA:FALSE
3510             X509v3 Subject Alternative Name:
3511                 DNS:longOID.example
3512             X509v3 Certificate Policies:
3513                 Policy: 1.3.6.1.4.1.311.21.8.1492336001
3514
3515     Signature Algorithm: sha256WithRSAEncryption
3516          72:77:8b:de:48:fb:6d:9a:94:b1:be:d4:90:7d:4c:e6:d3:79:
3517          fa:fb:fc:3e:d5:3d:e9:a0:ce:28:2b:2f:94:77:3f:87:f8:9c:
3518          9f:91:1c:f3:f6:58:91:15:6b:24:b9:ca:ae:9f:ee:ca:c8:31:
3519          db:1a:3d:bb:6b:83:6d:bc:81:8b:a1:79:d5:3e:bb:dd:93:fe:
3520          35:3e:b7:99:e0:d6:eb:58:0c:fd:42:73:dc:49:da:e2:b7:ae:
3521          15:ee:e6:cc:aa:ef:91:41:9a:18:46:8d:4a:39:65:a2:85:3c:
3522          7f:0c:41:f8:0b:9c:e8:1f:35:36:60:8d:8c:e0:8e:18:b1:06:
3523          57:d0:4e:c4:c3:cd:8f:6f:e7:76:02:52:da:03:43:61:2b:b3:
3524          bf:19:fd:73:0d:6a:0b:b4:b6:cb:a9:6f:70:4e:53:2a:54:07:
3525          b3:74:fd:85:49:57:5b:23:8d:8c:6b:53:2b:09:e8:41:a5:80:
3526          3f:69:1b:11:d1:6b:13:35:2e:f9:d6:50:15:d9:91:38:42:43:
3527          e9:17:af:67:d9:96:a4:d1:6a:4f:cc:b4:a7:8e:48:1f:00:72:
3528          69:de:4d:f1:73:a4:47:12:67:e9:f9:07:3e:79:75:90:42:b8:
3529          d4:b5:fd:d1:7e:35:04:f7:00:04:cf:f1:36:be:0f:27:81:1f:
3530          a6:ba:88:6c
3531 -----BEGIN CERTIFICATE-----
3532 MIIDHTCCAgWgAwIBAgIRANq6UxkbCUuCsokmfcdvoAIwDQYJKoZIhvcNAQELBQAw
3533 EjEQMA4GA1UEChMHQWNtZSBDbzAeFw0yMTEyMjExNjU5MjdaFw0yMjEyMjExNjU5
3534 MjdaMBIxEDAOBgNVBAoTB0FjbWUgQ28wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAw
3535 ggEKAoIBAQC/FxbYvCmcFuV2tJMVeK1uRcVKY0ahsnZxZVGcFMTqdBPkNN8vLGUR
3536 6FZSaRH5Dvx3u2OofBrGoXtubOcYJSXJ6PsGf6KpmP4qvIqzdba4fbbJaykIMiIQ
3537 y43WYMiDrfVYkdYR6FVW+4+jop9Iy3nkZUqMplJkn5k4NdTVrG/PoMtCjAfrIRcx
3538 OuuRe2JDpHVf76cvlPhpC9TsCeYAwIzdB2ML5HeqYBg8oOCuCuoOUju0+mowG1Bi
3539 IXNTMwFgoWuZWADzd8YPRhnKwl3N9eJSTYSUI9MyL65f2kOhGZXSF91JFLTZSBwI
3540 E5OO1QlDIbbOUuiHu9JgDcZOv8WTasa/AgMBAAGjbjBsMA4GA1UdDwEB/wQEAwIF
3541 oDATBgNVHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMBoGA1UdEQQTMBGC
3542 D2xvbmdPSUQuZXhhbXBsZTAbBgNVHSAEFDASMBAGDisGAQQBgjcVCIXHzPsBMA0G
3543 CSqGSIb3DQEBCwUAA4IBAQByd4veSPttmpSxvtSQfUzm03n6+/w+1T3poM4oKy+U
3544 dz+H+JyfkRzz9liRFWskucqun+7KyDHbGj27a4NtvIGLoXnVPrvdk/41PreZ4Nbr
3545 WAz9QnPcSdrit64V7ubMqu+RQZoYRo1KOWWihTx/DEH4C5zoHzU2YI2M4I4YsQZX
3546 0E7Ew82Pb+d2AlLaA0NhK7O/Gf1zDWoLtLbLqW9wTlMqVAezdP2FSVdbI42Ma1Mr
3547 CehBpYA/aRsR0WsTNS751lAV2ZE4QkPpF69n2Zak0WpPzLSnjkgfAHJp3k3xc6RH
3548 Emfp+Qc+eXWQQrjUtf3RfjUE9wAEz/E2vg8ngR+muohs
3549 -----END CERTIFICATE-----`
3550
3551 func TestLargeOID(t *testing.T) {
3552         // See Issue 49678.
3553         b, _ := pem.Decode([]byte(largeOIDPEM))
3554         if b == nil {
3555                 t.Fatalf("couldn't decode test certificate")
3556         }
3557         _, err := ParseCertificate(b.Bytes)
3558         if err != nil {
3559                 t.Fatalf("ParseCertificate to failed to parse certificate with large OID: %s", err)
3560         }
3561 }
3562
3563 const uniqueIDPEM = `-----BEGIN CERTIFICATE-----
3564 MIIFsDCCBJigAwIBAgIIrOyC1ydafZMwDQYJKoZIhvcNAQEFBQAwgY4xgYswgYgG
3565 A1UEAx6BgABNAGkAYwByAG8AcwBvAGYAdAAgAEYAbwByAGUAZgByAG8AbgB0ACAA
3566 VABNAEcAIABIAFQAVABQAFMAIABJAG4AcwBwAGUAYwB0AGkAbwBuACAAQwBlAHIA
3567 dABpAGYAaQBjAGEAdABpAG8AbgAgAEEAdQB0AGgAbwByAGkAdAB5MB4XDTE0MDEx
3568 ODAwNDEwMFoXDTE1MTExNTA5Mzc1NlowgZYxCzAJBgNVBAYTAklEMRAwDgYDVQQI
3569 EwdqYWthcnRhMRIwEAYDVQQHEwlJbmRvbmVzaWExHDAaBgNVBAoTE3N0aG9ub3Jl
3570 aG90ZWxyZXNvcnQxHDAaBgNVBAsTE3N0aG9ub3JlaG90ZWxyZXNvcnQxJTAjBgNV
3571 BAMTHG1haWwuc3Rob25vcmVob3RlbHJlc29ydC5jb20wggEiMA0GCSqGSIb3DQEB
3572 AQUAA4IBDwAwggEKAoIBAQCvuu0qpI+Ko2X84Twkf84cRD/rgp6vpgc5Ebejx/D4
3573 PEVON5edZkazrMGocK/oQqIlRxx/lefponN/chlGcllcVVPWTuFjs8k+Aat6T1qp
3574 4iXxZekAqX+U4XZMIGJD3PckPL6G2RQSlF7/LhGCsRNRdKpMWSTbou2Ma39g52Kf
3575 gsl3SK/GwLiWpxpcSkNQD1hugguEIsQYLxbeNwpcheXZtxbBGguPzQ7rH8c5vuKU
3576 BkMOzaiNKLzHbBdFSrua8KWwCJg76Vdq/q36O9GlW6YgG3i+A4pCJjXWerI1lWwX
3577 Ktk5V+SvUHGey1bkDuZKJ6myMk2pGrrPWCT7jP7WskChAgMBAAGBCQBCr1dgEleo
3578 cKOCAfswggH3MIHDBgNVHREEgbswgbiCHG1haWwuc3Rob25vcmVob3RlbHJlc29y
3579 dC5jb22CIGFzaGNoc3ZyLnN0aG9ub3JlaG90ZWxyZXNvcnQuY29tgiRBdXRvRGlz
3580 Y292ZXIuc3Rob25vcmVob3RlbHJlc29ydC5jb22CHEF1dG9EaXNjb3Zlci5ob3Rl
3581 bHJlc29ydC5jb22CCEFTSENIU1ZSghdzdGhvbm9yZWhvdGVscmVzb3J0LmNvbYIP
3582 aG90ZWxyZXNvcnQuY29tMCEGCSsGAQQBgjcUAgQUHhIAVwBlAGIAUwBlAHIAdgBl
3583 AHIwHQYDVR0OBBYEFMAC3UR4FwAdGekbhMgnd6lMejtbMAsGA1UdDwQEAwIFoDAT
3584 BgNVHSUEDDAKBggrBgEFBQcDATAJBgNVHRMEAjAAMIG/BgNVHQEEgbcwgbSAFGfF
3585 6xihk+gJJ5TfwvtWe1UFnHLQoYGRMIGOMYGLMIGIBgNVBAMegYAATQBpAGMAcgBv
3586 AHMAbwBmAHQAIABGAG8AcgBlAGYAcgBvAG4AdAAgAFQATQBHACAASABUAFQAUABT
3587 ACAASQBuAHMAcABlAGMAdABpAG8AbgAgAEMAZQByAHQAaQBmAGkAYwBhAHQAaQBv
3588 AG4AIABBAHUAdABoAG8AcgBpAHQAeYIIcKhXEmBXr0IwDQYJKoZIhvcNAQEFBQAD
3589 ggEBABlSxyCMr3+ANr+WmPSjyN5YCJBgnS0IFCwJAzIYP87bcTye/U8eQ2+E6PqG
3590 Q7Huj7nfHEw9qnGo+HNyPp1ad3KORzXDb54c6xEoi+DeuPzYHPbn4c3hlH49I0aQ
3591 eWW2w4RslSWpLvO6Y7Lboyz2/Thk/s2kd4RHxkkWpH2ltPqJuYYg3X6oM5+gIFHJ
3592 WGnh+ojZ5clKvS5yXh3Wkj78M6sb32KfcBk0Hx6NkCYPt60ODYmWtvqwtw6r73u5
3593 TnTYWRNvo2svX69TriL+CkHY9O1Hkwf2It5zHl3gNiKTJVaak8AuEz/CKWZneovt
3594 yYLwhUhg3PX5Co1VKYE+9TxloiE=
3595 -----END CERTIFICATE-----`
3596
3597 func TestParseUniqueID(t *testing.T) {
3598         b, _ := pem.Decode([]byte(uniqueIDPEM))
3599         if b == nil {
3600                 t.Fatalf("couldn't decode test certificate")
3601         }
3602         cert, err := ParseCertificate(b.Bytes)
3603         if err != nil {
3604                 t.Fatalf("ParseCertificate to failed to parse certificate with unique identifier id: %s", err)
3605         }
3606         if len(cert.Extensions) != 7 {
3607                 t.Fatalf("unexpected number of extensions (probably because the extension section was not parsed): got %d, want 7", len(cert.Extensions))
3608         }
3609 }
3610
3611 func TestDisableSHA1ForCertOnly(t *testing.T) {
3612         t.Setenv("GODEBUG", "")
3613
3614         tmpl := &Certificate{
3615                 SerialNumber:          big.NewInt(1),
3616                 NotBefore:             time.Now().Add(-time.Hour),
3617                 NotAfter:              time.Now().Add(time.Hour),
3618                 SignatureAlgorithm:    SHA1WithRSA,
3619                 BasicConstraintsValid: true,
3620                 IsCA:                  true,
3621                 KeyUsage:              KeyUsageCertSign | KeyUsageCRLSign,
3622         }
3623         certDER, err := CreateCertificate(rand.Reader, tmpl, tmpl, rsaPrivateKey.Public(), rsaPrivateKey)
3624         if err != nil {
3625                 t.Fatalf("failed to generate test cert: %s", err)
3626         }
3627         cert, err := ParseCertificate(certDER)
3628         if err != nil {
3629                 t.Fatalf("failed to parse test cert: %s", err)
3630         }
3631
3632         err = cert.CheckSignatureFrom(cert)
3633         if err == nil {
3634                 t.Error("expected CheckSignatureFrom to fail")
3635         } else if _, ok := err.(InsecureAlgorithmError); !ok {
3636                 t.Errorf("expected InsecureAlgorithmError error, got %T", err)
3637         }
3638
3639         crlDER, err := CreateRevocationList(rand.Reader, &RevocationList{
3640                 SignatureAlgorithm: SHA1WithRSA,
3641                 Number:             big.NewInt(1),
3642                 ThisUpdate:         time.Now().Add(-time.Hour),
3643                 NextUpdate:         time.Now().Add(time.Hour),
3644         }, cert, rsaPrivateKey)
3645         if err != nil {
3646                 t.Fatalf("failed to generate test CRL: %s", err)
3647         }
3648         crl, err := ParseRevocationList(crlDER)
3649         if err != nil {
3650                 t.Fatalf("failed to parse test CRL: %s", err)
3651         }
3652
3653         if err = crl.CheckSignatureFrom(cert); err != nil {
3654                 t.Errorf("unexpected error: %s", err)
3655         }
3656
3657         // This is an unrelated OCSP response, which will fail signature verification
3658         // but shouldn't return an InsecureAlgorithmError, since SHA1 should be allowed
3659         // for OCSP.
3660         ocspTBSHex := "30819fa2160414884451ff502a695e2d88f421bad90cf2cecbea7c180f32303133303631383037323434335a30743072304a300906052b0e03021a0500041448b60d38238df8456e4ee5843ea394111802979f0414884451ff502a695e2d88f421bad90cf2cecbea7c021100f78b13b946fc9635d8ab49de9d2148218000180f32303133303631383037323434335aa011180f32303133303632323037323434335a"
3661         ocspTBS, err := hex.DecodeString(ocspTBSHex)
3662         if err != nil {
3663                 t.Fatalf("failed to decode OCSP response TBS hex: %s", err)
3664         }
3665
3666         err = cert.CheckSignature(SHA1WithRSA, ocspTBS, nil)
3667         if err != rsa.ErrVerification {
3668                 t.Errorf("unexpected error: %s", err)
3669         }
3670 }
3671
3672 func TestParseRevocationList(t *testing.T) {
3673         derBytes := fromBase64(derCRLBase64)
3674         certList, err := ParseRevocationList(derBytes)
3675         if err != nil {
3676                 t.Errorf("error parsing: %s", err)
3677                 return
3678         }
3679         numCerts := len(certList.RevokedCertificateEntries)
3680         numCertsDeprecated := len(certList.RevokedCertificateEntries)
3681         expected := 88
3682         if numCerts != expected || numCertsDeprecated != expected {
3683                 t.Errorf("bad number of revoked certificates. got: %d want: %d", numCerts, expected)
3684         }
3685 }
3686
3687 func TestRevocationListCheckSignatureFrom(t *testing.T) {
3688         goodKey, err := ecdsa.GenerateKey(elliptic.P224(), rand.Reader)
3689         if err != nil {
3690                 t.Fatalf("failed to generate test key: %s", err)
3691         }
3692         badKey, err := ecdsa.GenerateKey(elliptic.P224(), rand.Reader)
3693         if err != nil {
3694                 t.Fatalf("failed to generate test key: %s", err)
3695         }
3696         tests := []struct {
3697                 name   string
3698                 issuer *Certificate
3699                 err    string
3700         }{
3701                 {
3702                         name: "valid",
3703                         issuer: &Certificate{
3704                                 Version:               3,
3705                                 BasicConstraintsValid: true,
3706                                 IsCA:                  true,
3707                                 PublicKeyAlgorithm:    ECDSA,
3708                                 PublicKey:             goodKey.Public(),
3709                         },
3710                 },
3711                 {
3712                         name: "valid, key usage set",
3713                         issuer: &Certificate{
3714                                 Version:               3,
3715                                 BasicConstraintsValid: true,
3716                                 IsCA:                  true,
3717                                 PublicKeyAlgorithm:    ECDSA,
3718                                 PublicKey:             goodKey.Public(),
3719                                 KeyUsage:              KeyUsageCRLSign,
3720                         },
3721                 },
3722                 {
3723                         name: "invalid issuer, wrong key usage",
3724                         issuer: &Certificate{
3725                                 Version:               3,
3726                                 BasicConstraintsValid: true,
3727                                 IsCA:                  true,
3728                                 PublicKeyAlgorithm:    ECDSA,
3729                                 PublicKey:             goodKey.Public(),
3730                                 KeyUsage:              KeyUsageCertSign,
3731                         },
3732                         err: "x509: invalid signature: parent certificate cannot sign this kind of certificate",
3733                 },
3734                 {
3735                         name: "invalid issuer, no basic constraints/ca",
3736                         issuer: &Certificate{
3737                                 Version:            3,
3738                                 PublicKeyAlgorithm: ECDSA,
3739                                 PublicKey:          goodKey.Public(),
3740                         },
3741                         err: "x509: invalid signature: parent certificate cannot sign this kind of certificate",
3742                 },
3743                 {
3744                         name: "invalid issuer, unsupported public key type",
3745                         issuer: &Certificate{
3746                                 Version:               3,
3747                                 BasicConstraintsValid: true,
3748                                 IsCA:                  true,
3749                                 PublicKeyAlgorithm:    UnknownPublicKeyAlgorithm,
3750                                 PublicKey:             goodKey.Public(),
3751                         },
3752                         err: "x509: cannot verify signature: algorithm unimplemented",
3753                 },
3754                 {
3755                         name: "wrong key",
3756                         issuer: &Certificate{
3757                                 Version:               3,
3758                                 BasicConstraintsValid: true,
3759                                 IsCA:                  true,
3760                                 PublicKeyAlgorithm:    ECDSA,
3761                                 PublicKey:             badKey.Public(),
3762                         },
3763                         err: "x509: ECDSA verification failure",
3764                 },
3765         }
3766
3767         crlIssuer := &Certificate{
3768                 BasicConstraintsValid: true,
3769                 IsCA:                  true,
3770                 PublicKeyAlgorithm:    ECDSA,
3771                 PublicKey:             goodKey.Public(),
3772                 KeyUsage:              KeyUsageCRLSign,
3773                 SubjectKeyId:          []byte{1, 2, 3},
3774         }
3775         for _, tc := range tests {
3776                 t.Run(tc.name, func(t *testing.T) {
3777                         crlDER, err := CreateRevocationList(rand.Reader, &RevocationList{Number: big.NewInt(1)}, crlIssuer, goodKey)
3778                         if err != nil {
3779                                 t.Fatalf("failed to generate CRL: %s", err)
3780                         }
3781                         crl, err := ParseRevocationList(crlDER)
3782                         if err != nil {
3783                                 t.Fatalf("failed to parse test CRL: %s", err)
3784                         }
3785                         err = crl.CheckSignatureFrom(tc.issuer)
3786                         if err != nil && err.Error() != tc.err {
3787                                 t.Errorf("unexpected error: got %s, want %s", err, tc.err)
3788                         } else if err == nil && tc.err != "" {
3789                                 t.Errorf("CheckSignatureFrom did not fail: want %s", tc.err)
3790                         }
3791                 })
3792         }
3793 }
3794
3795 func TestOmitEmptyExtensions(t *testing.T) {
3796         k, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
3797         if err != nil {
3798                 t.Fatal(err)
3799         }
3800         tmpl := &Certificate{
3801                 SerialNumber: big.NewInt(1),
3802                 Subject: pkix.Name{
3803                         CommonName: ":)",
3804                 },
3805                 NotAfter:  time.Now().Add(time.Hour),
3806                 NotBefore: time.Now().Add(-time.Hour),
3807         }
3808         der, err := CreateCertificate(rand.Reader, tmpl, tmpl, k.Public(), k)
3809         if err != nil {
3810                 t.Fatal(err)
3811         }
3812
3813         emptyExtSeq := []byte{0xA3, 0x02, 0x30, 0x00}
3814         if bytes.Contains(der, emptyExtSeq) {
3815                 t.Error("DER encoding contains the an empty extensions SEQUENCE")
3816         }
3817 }
3818
3819 var negativeSerialCert = `-----BEGIN CERTIFICATE-----
3820 MIIBBTCBraADAgECAgH/MAoGCCqGSM49BAMCMA0xCzAJBgNVBAMTAjopMB4XDTIy
3821 MDQxNDIzNTYwNFoXDTIyMDQxNTAxNTYwNFowDTELMAkGA1UEAxMCOikwWTATBgcq
3822 hkjOPQIBBggqhkjOPQMBBwNCAAQ9ezsIsj+q17K87z/PXE/rfGRN72P/Wyn5d6oo
3823 5M0ZbSatuntMvfKdX79CQxXAxN4oXk3Aov4jVSG12AcDI8ShMAoGCCqGSM49BAMC
3824 A0cAMEQCIBzfBU5eMPT6m5lsR6cXaJILpAaiD9YxOl4v6dT3rzEjAiBHmjnHmAss
3825 RqUAyJKFzqZxOlK2q4j2IYnuj5+LrLGbQA==
3826 -----END CERTIFICATE-----`
3827
3828 func TestParseNegativeSerial(t *testing.T) {
3829         pemBlock, _ := pem.Decode([]byte(negativeSerialCert))
3830         _, err := ParseCertificate(pemBlock.Bytes)
3831         if err != nil {
3832                 t.Fatalf("failed to parse certificate: %s", err)
3833         }
3834 }
3835
3836 func TestCreateNegativeSerial(t *testing.T) {
3837         k, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
3838         if err != nil {
3839                 t.Fatal(err)
3840         }
3841         tmpl := &Certificate{
3842                 SerialNumber: big.NewInt(-1),
3843                 Subject: pkix.Name{
3844                         CommonName: ":)",
3845                 },
3846                 NotAfter:  time.Now().Add(time.Hour),
3847                 NotBefore: time.Now().Add(-time.Hour),
3848         }
3849         expectedErr := "x509: serial number must be positive"
3850         _, err = CreateCertificate(rand.Reader, tmpl, tmpl, k.Public(), k)
3851         if err == nil || err.Error() != expectedErr {
3852                 t.Errorf("CreateCertificate returned unexpected error: want %q, got %q", expectedErr, err)
3853         }
3854 }
3855
3856 const dupExtCert = `-----BEGIN CERTIFICATE-----
3857 MIIBrjCCARegAwIBAgIBATANBgkqhkiG9w0BAQsFADAPMQ0wCwYDVQQDEwR0ZXN0
3858 MCIYDzAwMDEwMTAxMDAwMDAwWhgPMDAwMTAxMDEwMDAwMDBaMA8xDTALBgNVBAMT
3859 BHRlc3QwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMiFchnHms9l9NninAIz
3860 SkY9acwl9Bk2AtmJrNCenFpiA17AcOO5q8DJYwdXi6WPKlVgcyH+ysW8XMWkq+CP
3861 yhtF/+LMzl9odaUF2iUy3vgTC5gxGLWH5URVssx21Und2Pm2f4xyou5IVxbS9dxy
3862 jLvV9PEY9BIb0H+zFthjhihDAgMBAAGjFjAUMAgGAioDBAIFADAIBgIqAwQCBQAw
3863 DQYJKoZIhvcNAQELBQADgYEAlhQ4TQQKIQ8GUyzGiN/75TCtQtjhMGemxc0cNgre
3864 d9rmm4DjydH0t7/sMCB56lQrfhJNplguzsbjFW4l245KbNKHfLiqwEGUgZjBNKur
3865 ot6qX/skahLtt0CNOaFIge75HVKe/69OrWQGdp18dkay/KS4Glu8YMKIjOhfrUi1
3866 NZA=
3867 -----END CERTIFICATE-----`
3868
3869 func TestDuplicateExtensionsCert(t *testing.T) {
3870         b, _ := pem.Decode([]byte(dupExtCert))
3871         if b == nil {
3872                 t.Fatalf("couldn't decode test certificate")
3873         }
3874         _, err := ParseCertificate(b.Bytes)
3875         if err == nil {
3876                 t.Fatal("ParseCertificate should fail when parsing certificate with duplicate extensions")
3877         }
3878 }
3879
3880 const dupExtCSR = `-----BEGIN CERTIFICATE REQUEST-----
3881 MIIBczCB3QIBADAPMQ0wCwYDVQQDEwR0ZXN0MIGfMA0GCSqGSIb3DQEBAQUAA4GN
3882 ADCBiQKBgQC5PbxMGVJ8aLF9lq/EvGObXTRMB7ieiZL9N+DJZg1n/ECCnZLIvYrr
3883 ZmmDV7YZsClgxKGfjJB0RQFFyZElFM9EfHEs8NJdidDKCRdIhDXQWRyhXKevHvdm
3884 CQNKzUeoxvdHpU/uscSkw6BgUzPyLyTx9A6ye2ix94z8Y9hGOBO2DQIDAQABoCUw
3885 IwYJKoZIhvcNAQkOMRYwFDAIBgIqAwQCBQAwCAYCKgMEAgUAMA0GCSqGSIb3DQEB
3886 CwUAA4GBAHROEsE7URk1knXmBnQtIHwoq663vlMcX3Hes58pUy020rWP8QkocA+X
3887 VF18/phg3p5ILlS4fcbbP2bEeV0pePo2k00FDPsJEKCBAX2LKxbU7Vp2OuV2HM2+
3888 VLOVx0i+/Q7fikp3hbN1JwuMTU0v2KL/IKoUcZc02+5xiYrnOIt5
3889 -----END CERTIFICATE REQUEST-----`
3890
3891 func TestDuplicateExtensionsCSR(t *testing.T) {
3892         b, _ := pem.Decode([]byte(dupExtCSR))
3893         if b == nil {
3894                 t.Fatalf("couldn't decode test CSR")
3895         }
3896         _, err := ParseCertificateRequest(b.Bytes)
3897         if err == nil {
3898                 t.Fatal("ParseCertificateRequest should fail when parsing CSR with duplicate extensions")
3899         }
3900 }
3901
3902 const dupAttCSR = `-----BEGIN CERTIFICATE REQUEST-----
3903 MIIBbDCB1gIBADAPMQ0wCwYDVQQDEwR0ZXN0MIGfMA0GCSqGSIb3DQEBAQUAA4GN
3904 ADCBiQKBgQCj5Po3PKO/JNuxr+B+WNfMIzqqYztdlv+mTQhT0jOR5rTkUvxeeHH8
3905 YclryES2dOISjaUOTmOAr5GQIIdQl4Ql33Cp7ZR/VWcRn+qvTak0Yow+xVsDo0n4
3906 7IcvvP6CJ7FRoYBUakVczeXLxCjLwdyK16VGJM06eRzDLykPxpPwLQIDAQABoB4w
3907 DQYCKgMxBwwFdGVzdDEwDQYCKgMxBwwFdGVzdDIwDQYJKoZIhvcNAQELBQADgYEA
3908 UJ8hsHxtnIeqb2ufHnQFJO+wEJhx2Uxm/BTuzHOeffuQkwATez4skZ7SlX9exgb7
3909 6jRMRilqb4F7f8w+uDoqxRrA9zc8mwY16zPsyBhRet+ZGbj/ilgvGmtZ21qZZ/FU
3910 0pJFJIVLM3l49Onr5uIt5+hCWKwHlgE0nGpjKLR3cMg=
3911 -----END CERTIFICATE REQUEST-----`
3912
3913 func TestDuplicateAttributesCSR(t *testing.T) {
3914         b, _ := pem.Decode([]byte(dupAttCSR))
3915         if b == nil {
3916                 t.Fatalf("couldn't decode test CSR")
3917         }
3918         _, err := ParseCertificateRequest(b.Bytes)
3919         if err != nil {
3920                 t.Fatal("ParseCertificateRequest should succeed when parsing CSR with duplicate attributes")
3921         }
3922 }
3923
3924 func TestCertificateOIDPolicies(t *testing.T) {
3925         template := Certificate{
3926                 SerialNumber:      big.NewInt(1),
3927                 Subject:           pkix.Name{CommonName: "Cert"},
3928                 NotBefore:         time.Unix(1000, 0),
3929                 NotAfter:          time.Unix(100000, 0),
3930                 PolicyIdentifiers: []asn1.ObjectIdentifier{[]int{1, 2, 3}},
3931                 Policies: []OID{
3932                         mustNewOIDFromInts(t, []uint64{1, 2, 3}),
3933                         mustNewOIDFromInts(t, []uint64{1, 2, 3, 4, 5}),
3934                         mustNewOIDFromInts(t, []uint64{1, 2, 3, math.MaxInt32}),
3935                         mustNewOIDFromInts(t, []uint64{1, 2, 3, math.MaxUint32, math.MaxUint64}),
3936                 },
3937         }
3938
3939         var expectPolicyIdentifiers = []asn1.ObjectIdentifier{
3940                 []int{1, 2, 3},
3941                 []int{1, 2, 3, 4, 5},
3942                 []int{1, 2, 3, math.MaxInt32},
3943         }
3944
3945         var expectPolicies = []OID{
3946                 mustNewOIDFromInts(t, []uint64{1, 2, 3}),
3947                 mustNewOIDFromInts(t, []uint64{1, 2, 3, 4, 5}),
3948                 mustNewOIDFromInts(t, []uint64{1, 2, 3, math.MaxInt32}),
3949                 mustNewOIDFromInts(t, []uint64{1, 2, 3, math.MaxUint32, math.MaxUint64}),
3950         }
3951
3952         certDER, err := CreateCertificate(rand.Reader, &template, &template, rsaPrivateKey.Public(), rsaPrivateKey)
3953         if err != nil {
3954                 t.Fatalf("CreateCertificate() unexpected error: %v", err)
3955         }
3956
3957         cert, err := ParseCertificate(certDER)
3958         if err != nil {
3959                 t.Fatalf("ParseCertificate() unexpected error: %v", err)
3960         }
3961
3962         if !slices.EqualFunc(cert.PolicyIdentifiers, expectPolicyIdentifiers, slices.Equal) {
3963                 t.Errorf("cert.PolicyIdentifiers = %v, want: %v", cert.PolicyIdentifiers, expectPolicyIdentifiers)
3964         }
3965
3966         if !slices.EqualFunc(cert.Policies, expectPolicies, OID.Equal) {
3967                 t.Errorf("cert.Policies = %v, want: %v", cert.Policies, expectPolicies)
3968         }
3969 }
3970
3971 func TestInvalidPolicyOID(t *testing.T) {
3972         template := Certificate{
3973                 SerialNumber:      big.NewInt(1),
3974                 Subject:           pkix.Name{CommonName: "Cert"},
3975                 NotBefore:         time.Now(),
3976                 NotAfter:          time.Now().Add(time.Hour),
3977                 PolicyIdentifiers: []asn1.ObjectIdentifier{[]int{1, 2, 3}},
3978                 Policies:          []OID{OID{}},
3979         }
3980         _, err := CreateCertificate(rand.Reader, &template, &template, rsaPrivateKey.Public(), rsaPrivateKey)
3981         expected := "invalid policy object identifier"
3982         if err.Error() != expected {
3983                 t.Fatalf("CreateCertificate() unexpected error: %v, want: %v", err, expected)
3984         }
3985 }