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

View as plain text