Add custom lints covering our CP/CPS profiles

cmd/cert-checker/main_test.go

@@ -33,6 +33,7 @@ import (
 	"github.com/letsencrypt/boulder/goodkey"
 	"github.com/letsencrypt/boulder/goodkey/sagoodkey"
 	"github.com/letsencrypt/boulder/identifier"
+	"github.com/letsencrypt/boulder/issuance"
 	"github.com/letsencrypt/boulder/linter"
 	blog "github.com/letsencrypt/boulder/log"
 	"github.com/letsencrypt/boulder/metrics"
@@ -559,13 +560,9 @@ func TestIgnoredLint(t *testing.T) {
 
 	err = loglist.InitLintList("../../test/ct-test-srv/log_list.json", false)
 	test.AssertNotError(t, err, "failed to load ct log list")
-	testKey, _ := rsa.GenerateKey(rand.Reader, 2048)
-	checker := newChecker(saDbMap, clock.NewFake(), pa, kp, time.Hour, testValidityDurations, nil, nil, linter.Config{}, blog.NewMock())
-	serial := big.NewInt(1337)
-
-	x509OID, err := x509.OIDFromInts([]uint64{1, 2, 3})
-	test.AssertNotError(t, err, "failed to create x509.OID")
 
+	// Create a self-signed issuer certificate to use
+	serial := big.NewInt(1337)
 	template := &x509.Certificate{
 		Subject: pkix.Name{
 			CommonName: "CPU's Cool CA",
@@ -575,27 +572,37 @@ func TestIgnoredLint(t *testing.T) {
 		NotAfter:              time.Now().Add(testValidityDuration - time.Second),
 		KeyUsage:              x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign,
 		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth, x509.ExtKeyUsageClientAuth},
-		Policies:              []x509.OID{x509OID},
 		BasicConstraintsValid: true,
 		IsCA:                  true,
 		IssuingCertificateURL: []string{"http://aia.example.org"},
 		SubjectKeyId:          []byte("foobar"),
 	}
 
-	// Create a self-signed issuer certificate to use
+	testKey, _ := rsa.GenerateKey(rand.Reader, 2048)
 	issuerDer, err := x509.CreateCertificate(rand.Reader, template, template, testKey.Public(), testKey)
 	test.AssertNotError(t, err, "failed to create self-signed issuer cert")
 	issuerCert, err := x509.ParseCertificate(issuerDer)
 	test.AssertNotError(t, err, "failed to parse self-signed issuer cert")
+	issuer, err := issuance.NewCertificate(issuerCert)
+	test.AssertNotError(t, err, "failed to make self-signed issuer cert")
+
+	checker := newChecker(
+		saDbMap, clock.NewFake(), pa, kp, time.Hour, testValidityDurations,
+		map[string]*issuance.Certificate{issuerCert.Subject.CommonName: issuer},
+		nil, linter.Config{}, blog.NewMock(),
+	)
 
 	// Reconfigure the template for an EE cert with a Subj. CN
-	serial = big.NewInt(1338)
+	serial, _ = big.NewInt(0).SetString("12345678901234567890123456789012", 10)
 	template.SerialNumber = serial
 	template.Subject.CommonName = "zombo.com"
 	template.DNSNames = []string{"zombo.com"}
 	template.KeyUsage = x509.KeyUsageDigitalSignature | x509.KeyUsageKeyEncipherment
-	template.ExtKeyUsage = []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth, x509.ExtKeyUsageClientAuth}
+	template.ExtKeyUsage = []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth}
 	template.CRLDistributionPoints = []string{"http://crl.example.org"}
+	template.SubjectKeyId, _ = core.GenerateSKID(testKey.Public())
+	dvOID, _ := x509.OIDFromASN1OID(asn1.ObjectIdentifier{2, 23, 140, 1, 2, 1})
+	template.Policies = []x509.OID{dvOID}
 	template.IsCA = false
 
 	subjectCertDer, err := x509.CreateCertificate(rand.Reader, template, issuerCert, testKey.Public(), testKey)
@@ -618,6 +625,7 @@ func TestIgnoredLint(t *testing.T) {
 		"zlint warn: w_ext_subject_key_identifier_not_recommended_subscriber",
 		"zlint info: w_ct_sct_policy_count_unsatisfied Certificate had 0 embedded SCTs. Browser policy may require 2 for this certificate.",
 		"zlint error: e_scts_from_same_operator Certificate had too few embedded SCTs; browser policy requires 2.",
+		"zlint error: e_subscriber_server_certificate_matches_cps_profile signedCertificateTimestampList extension is not present",
 	}
 	slices.Sort(expectedProblems)
 
@@ -634,6 +642,7 @@ func TestIgnoredLint(t *testing.T) {
 		"w_ext_subject_key_identifier_not_recommended_subscriber",
 		"w_ct_sct_policy_count_unsatisfied",
 		"e_scts_from_same_operator",
+		"e_subscriber_server_certificate_matches_cps_profile",
 	})
 	test.AssertNotError(t, err, "creating test lint registry")
 	checker.lints = lints

issuance/cert_test.go

@@ -273,7 +273,7 @@ func TestRequestValid(t *testing.T) {
 				SubjectKeyId:    goodSKID,
 				NotBefore:       fc.Now(),
 				NotAfter:        fc.Now().Add(time.Hour),
-				Serial:          []byte{1, 2, 3, 4, 5, 6, 7, 8, 9},
+				Serial:          []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18},
 				IncludeCTPoison: true,
 			},
 		},
@@ -290,7 +290,7 @@ func TestRequestValid(t *testing.T) {
 				SubjectKeyId: goodSKID,
 				NotBefore:    fc.Now(),
 				NotAfter:     fc.Now().Add(time.Hour),
-				Serial:       []byte{1, 2, 3, 4, 5, 6, 7, 8, 9},
+				Serial:       []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18},
 				sctList:      []ct.SignedCertificateTimestamp{},
 			},
 		},
@@ -367,7 +367,7 @@ func TestIssue(t *testing.T) {
 			lintCertBytes, issuanceToken, err := signer.Prepare(defaultProfile(), &IssuanceRequest{
 				PublicKey:       MarshalablePublicKey{pk.Public()},
 				SubjectKeyId:    skid,
-				Serial:          []byte{1, 2, 3, 4, 5, 6, 7, 8, 9},
+				Serial:          []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18},
 				DNSNames:        []string{"example.com"},
 				IPAddresses:     []net.IP{net.ParseIP("128.101.101.101"), net.ParseIP("3fff:aaa:a:c0ff:ee:a:bad:deed")},
 				NotBefore:       fc.Now(),
@@ -392,7 +392,7 @@ func TestIssue(t *testing.T) {
 			// addresses back to 4 bytes. Adding .To4() both allows this test to
 			// succeed, and covers this requirement.
 			test.AssertDeepEquals(t, cert.IPAddresses, []net.IP{net.ParseIP("128.101.101.101").To4(), net.ParseIP("3fff:aaa:a:c0ff:ee:a:bad:deed")})
-			test.AssertByteEquals(t, cert.SerialNumber.Bytes(), []byte{1, 2, 3, 4, 5, 6, 7, 8, 9})
+			test.AssertByteEquals(t, cert.SerialNumber.Bytes(), []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18})
 			test.AssertDeepEquals(t, cert.PublicKey, pk.Public())
 			test.AssertEquals(t, len(cert.Extensions), 10) // Constraints, KU, EKU, SKID, AKID, AIA, CRLDP, SAN, Policies, Poison
 			test.AssertEquals(t, cert.KeyUsage, tc.ku)
@@ -454,7 +454,7 @@ func TestIssueDNSNamesOnly(t *testing.T) {
 	_, issuanceToken, err := signer.Prepare(defaultProfile(), &IssuanceRequest{
 		PublicKey:       MarshalablePublicKey{pk.Public()},
 		SubjectKeyId:    skid,
-		Serial:          []byte{1, 2, 3, 4, 5, 6, 7, 8, 9},
+		Serial:          []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18},
 		DNSNames:        []string{"example.com"},
 		NotBefore:       fc.Now(),
 		NotAfter:        fc.Now().Add(time.Hour - time.Second),
@@ -497,7 +497,7 @@ func TestIssueIPAddressesOnly(t *testing.T) {
 	_, issuanceToken, err := signer.Prepare(defaultProfile(), &IssuanceRequest{
 		PublicKey:       MarshalablePublicKey{pk.Public()},
 		SubjectKeyId:    skid,
-		Serial:          []byte{1, 2, 3, 4, 5, 6, 7, 8, 9},
+		Serial:          []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18},
 		IPAddresses:     []net.IP{net.ParseIP("128.101.101.101"), net.ParseIP("3fff:aaa:a:c0ff:ee:a:bad:deed")},
 		NotBefore:       fc.Now(),
 		NotAfter:        fc.Now().Add(time.Hour - time.Second),
@@ -544,7 +544,7 @@ func TestIssueWithCRLDP(t *testing.T) {
 	_, issuanceToken, err := signer.Prepare(profile, &IssuanceRequest{
 		PublicKey:       MarshalablePublicKey{pk.Public()},
 		SubjectKeyId:    skid,
-		Serial:          []byte{1, 2, 3, 4, 5, 6, 7, 8, 9},
+		Serial:          []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18},
 		DNSNames:        []string{"example.com"},
 		NotBefore:       fc.Now(),
 		NotAfter:        fc.Now().Add(time.Hour - time.Second),
@@ -562,7 +562,7 @@ func TestIssueWithCRLDP(t *testing.T) {
 		t.Fatalf("x509.ParseCertificate: %s", err)
 	}
 	// Because CRL shard is calculated deterministically from serial, we know which shard will be chosen.
-	expectedCRLDP := []string{"http://crls.example.net/919.crl"}
+	expectedCRLDP := []string{"http://crls.example.net/838.crl"}
 	if !reflect.DeepEqual(cert.CRLDistributionPoints, expectedCRLDP) {
 		t.Errorf("CRLDP=%+v, want %+v", cert.CRLDistributionPoints, expectedCRLDP)
 	}
@@ -585,7 +585,7 @@ func TestIssueCommonName(t *testing.T) {
 	ir := &IssuanceRequest{
 		PublicKey:       MarshalablePublicKey{pk.Public()},
 		SubjectKeyId:    skid,
-		Serial:          []byte{1, 2, 3, 4, 5, 6, 7, 8, 9},
+		Serial:          []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18},
 		DNSNames:        []string{"example.com", "www.example.com"},
 		NotBefore:       fc.Now(),
 		NotAfter:        fc.Now().Add(time.Hour - time.Second),
@@ -636,6 +636,10 @@ func TestPrepareMTC(t *testing.T) {
 		// Ignore the warning about *not* including the SubjectKeyIdentifier extension:
 		// zlint has both lints (one enforcing RFC5280, the other the BRs).
 		"w_ext_subject_key_identifier_missing_sub_cert",
+		// MTCs are not (yet) subject to our CPS profiles, and will likely be
+		// subject to a *different* profile when we get around to issuing them
+		// from prod. Ignore our CPS-specific lint for now.
+		"e_subscriber_server_certificate_matches_cps_profile",
 	}
 	prof, err := NewProfile(pc)
 	if err != nil {
@@ -657,7 +661,7 @@ func TestPrepareMTC(t *testing.T) {
 		sctList:         nil,
 
 		PublicKey: MarshalablePublicKey{pk.Public()},
-		Serial:    []byte{1, 2, 3, 4, 5, 6, 7, 8, 9},
+		Serial:    []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18},
 		DNSNames:  []string{"example.com"},
 		NotBefore: fc.Now(),
 		NotAfter:  fc.Now().Add(time.Hour - time.Second),
@@ -670,7 +674,7 @@ func TestPrepareMTC(t *testing.T) {
 		IncludeCTPoison: true,
 
 		PublicKey: MarshalablePublicKey{pk.Public()},
-		Serial:    []byte{1, 2, 3, 4, 5, 6, 7, 8, 9},
+		Serial:    []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18},
 		DNSNames:  []string{"example.com"},
 		NotBefore: fc.Now(),
 		NotAfter:  fc.Now().Add(time.Hour - time.Second),
@@ -683,7 +687,7 @@ func TestPrepareMTC(t *testing.T) {
 		sctList: []ct.SignedCertificateTimestamp{{SCTVersion: 1}},
 
 		PublicKey: MarshalablePublicKey{pk.Public()},
-		Serial:    []byte{1, 2, 3, 4, 5, 6, 7, 8, 9},
+		Serial:    []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18},
 		DNSNames:  []string{"example.com"},
 		NotBefore: fc.Now(),
 		NotAfter:  fc.Now().Add(time.Hour - time.Second),
@@ -722,7 +726,7 @@ func TestIssueOmissions(t *testing.T) {
 	_, issuanceToken, err := signer.Prepare(prof, &IssuanceRequest{
 		PublicKey:       MarshalablePublicKey{pk.Public()},
 		SubjectKeyId:    skid,
-		Serial:          []byte{1, 2, 3, 4, 5, 6, 7, 8, 9},
+		Serial:          []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18},
 		DNSNames:        []string{"example.com"},
 		CommonName:      "example.com",
 		IncludeCTPoison: true,
@@ -753,7 +757,7 @@ func TestIssueCTPoison(t *testing.T) {
 	_, issuanceToken, err := signer.Prepare(defaultProfile(), &IssuanceRequest{
 		PublicKey:       MarshalablePublicKey{pk.Public()},
 		SubjectKeyId:    skid,
-		Serial:          []byte{1, 2, 3, 4, 5, 6, 7, 8, 9},
+		Serial:          []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18},
 		DNSNames:        []string{"example.com"},
 		IncludeCTPoison: true,
 		NotBefore:       fc.Now(),
@@ -766,7 +770,7 @@ func TestIssueCTPoison(t *testing.T) {
 	test.AssertNotError(t, err, "failed to parse certificate")
 	err = cert.CheckSignatureFrom(issuerCert.Certificate)
 	test.AssertNotError(t, err, "signature validation failed")
-	test.AssertByteEquals(t, cert.SerialNumber.Bytes(), []byte{1, 2, 3, 4, 5, 6, 7, 8, 9})
+	test.AssertByteEquals(t, cert.SerialNumber.Bytes(), []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18})
 	test.AssertDeepEquals(t, cert.PublicKey, pk.Public())
 	test.AssertEquals(t, len(cert.Extensions), 10) // Constraints, KU, EKU, SKID, AKID, AIA, CRLDP, SAN, Policies, Poison
 	test.AssertDeepEquals(t, cert.Extensions[9], ctPoisonExt)
@@ -803,7 +807,7 @@ func TestIssueSCTList(t *testing.T) {
 	_, issuanceToken, err := signer.Prepare(enforceSCTsProfile, &IssuanceRequest{
 		PublicKey:       MarshalablePublicKey{pk.Public()},
 		SubjectKeyId:    skid,
-		Serial:          []byte{1, 2, 3, 4, 5, 6, 7, 8, 9},
+		Serial:          []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18},
 		DNSNames:        []string{"example.com"},
 		NotBefore:       fc.Now(),
 		NotAfter:        fc.Now().Add(time.Hour - time.Second),
@@ -840,7 +844,7 @@ func TestIssueSCTList(t *testing.T) {
 
 	err = finalCert.CheckSignatureFrom(issuerCert.Certificate)
 	test.AssertNotError(t, err, "signature validation failed")
-	test.AssertByteEquals(t, finalCert.SerialNumber.Bytes(), []byte{1, 2, 3, 4, 5, 6, 7, 8, 9})
+	test.AssertByteEquals(t, finalCert.SerialNumber.Bytes(), []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18})
 	test.AssertDeepEquals(t, finalCert.PublicKey, pk.Public())
 	test.AssertEquals(t, len(finalCert.Extensions), 10) // Constraints, KU, EKU, SKID, AKID, AIA, CRLDP, SAN, Policies, Poison
 	test.AssertDeepEquals(t, finalCert.Extensions[9], pkix.Extension{
@@ -873,7 +877,7 @@ func TestIssueBadLint(t *testing.T) {
 	_, _, err = signer.Prepare(noSkipLintsProfile, &IssuanceRequest{
 		PublicKey:       MarshalablePublicKey{pk.Public()},
 		SubjectKeyId:    skid,
-		Serial:          []byte{1, 2, 3, 4, 5, 6, 7, 8, 9},
+		Serial:          []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18},
 		DNSNames:        []string{"example-com"},
 		NotBefore:       fc.Now(),
 		NotAfter:        fc.Now().Add(time.Hour - time.Second),
@@ -904,7 +908,7 @@ func TestIssuanceToken(t *testing.T) {
 	_, issuanceToken, err := signer.Prepare(defaultProfile(), &IssuanceRequest{
 		PublicKey:       MarshalablePublicKey{pk.Public()},
 		SubjectKeyId:    skid,
-		Serial:          []byte{1, 2, 3, 4, 5, 6, 7, 8, 9},
+		Serial:          []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18},
 		DNSNames:        []string{"example.com"},
 		NotBefore:       fc.Now(),
 		NotAfter:        fc.Now().Add(time.Hour - time.Second),
@@ -921,7 +925,7 @@ func TestIssuanceToken(t *testing.T) {
 	_, issuanceToken, err = signer.Prepare(defaultProfile(), &IssuanceRequest{
 		PublicKey:       MarshalablePublicKey{pk.Public()},
 		SubjectKeyId:    skid,
-		Serial:          []byte{1, 2, 3, 4, 5, 6, 7, 8, 9},
+		Serial:          []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18},
 		DNSNames:        []string{"example.com"},
 		NotBefore:       fc.Now(),
 		NotAfter:        fc.Now().Add(time.Hour - time.Second),
@@ -953,7 +957,7 @@ func TestInvalidProfile(t *testing.T) {
 	_, _, err = signer.Prepare(defaultProfile(), &IssuanceRequest{
 		PublicKey:       MarshalablePublicKey{pk.Public()},
 		SubjectKeyId:    skid,
-		Serial:          []byte{1, 2, 3, 4, 5, 6, 7, 8, 9},
+		Serial:          []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18},
 		DNSNames:        []string{"example.com"},
 		NotBefore:       fc.Now(),
 		NotAfter:        fc.Now().Add(time.Hour - time.Second),
@@ -965,7 +969,7 @@ func TestInvalidProfile(t *testing.T) {
 	_, _, err = signer.Prepare(defaultProfile(), &IssuanceRequest{
 		PublicKey:    MarshalablePublicKey{pk.Public()},
 		SubjectKeyId: skid,
-		Serial:       []byte{1, 2, 3, 4, 5, 6, 7, 8, 9},
+		Serial:       []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18},
 		DNSNames:     []string{"example.com"},
 		NotBefore:    fc.Now(),
 		NotAfter:     fc.Now().Add(time.Hour - time.Second),
@@ -1004,7 +1008,7 @@ func TestMismatchedProfiles(t *testing.T) {
 	_, issuanceToken, err := issuer1.Prepare(cnProfile, &IssuanceRequest{
 		PublicKey:       MarshalablePublicKey{pk.Public()},
 		SubjectKeyId:    skid,
-		Serial:          []byte{1, 2, 3, 4, 5, 6, 7, 8, 9},
+		Serial:          []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18},
 		CommonName:      "example.com",
 		DNSNames:        []string{"example.com"},
 		NotBefore:       fc.Now(),

issuance/issuer_test.go

@@ -24,6 +24,7 @@ import (
 
 func defaultProfileConfig() ProfileConfig {
 	return ProfileConfig{
+		OmitClientAuth:      true,
 		MaxValidityPeriod:   config.Duration{Duration: time.Hour},
 		MaxValidityBackdate: config.Duration{Duration: time.Hour},
 		IgnoredLints: []string{

linter/linter.go

@@ -5,6 +5,7 @@ import (
 	"crypto"
 	"crypto/rand"
 	"crypto/x509"
+	"errors"
 	"fmt"
 	"strings"
 
@@ -121,7 +122,31 @@ func (l *Linter) Check(tbs *x509.Certificate, subjectPubKey crypto.PublicKey, re
 		return nil, err
 	}
 	if selfSigned {
+		// If the cert being linted is going to be self-signed, replace the lint
+		// cert's public key and subjectKeyId extension with ones built from the
+		// fake lint signing key, so that everything lines up as it should.
 		lintPubKey = l.signer.Public()
+		if len(tbs.SubjectKeyId) != 0 {
+			// This is a dumb hack. Because we're replacing the SKID with a fake one
+			// derived from the lint key, none of the lints will actually inspect the
+			// real SKID. So to make up for it, do the most critical check here and
+			// now.
+			realSKID, err := core.GenerateSKID(subjectPubKey)
+			if err != nil {
+				return nil, err
+			}
+			if !bytes.Equal(tbs.SubjectKeyId, realSKID) {
+				return nil, errors.New("self-signed certificate's subjectKeyIdentifier was not computed from its subjectPublicKey per RFC 7093 Section 2(1)")
+			}
+
+			lintSKID, err := core.GenerateSKID(lintPubKey)
+			if err != nil {
+				return nil, err
+			}
+			tbsCopy := *tbs
+			tbsCopy.SubjectKeyId = lintSKID
+			tbs = &tbsCopy
+		}
 	}
 
 	lintCertBytes, cert, err := makeLintCert(tbs, lintPubKey, l.issuer, l.signer)

linter/linter_test.go

@@ -14,7 +14,9 @@ import (
 	"math/big"
 	"strings"
 	"testing"
+	"time"
 
+	"github.com/letsencrypt/boulder/core"
 	"github.com/letsencrypt/boulder/test"
 )
 
@@ -111,3 +113,36 @@ func TestMakeIssuer(t *testing.T) {
 		t.Errorf("linting certificate issuer: got %x, want %x", lintCert.RawIssuer, realIssuer.RawSubject)
 	}
 }
+
+func TestCheckSelfSignedSKID(t *testing.T) {
+	key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+	test.AssertNotError(t, err, "generating test key")
+
+	tbs := &x509.Certificate{
+		SerialNumber:          big.NewInt(1),
+		Subject:               pkix.Name{CommonName: "Self-Signed Test"},
+		NotBefore:             time.Date(2026, time.January, 1, 0, 0, 0, 0, time.UTC),
+		NotAfter:              time.Date(2026, time.February, 1, 0, 0, 0, 0, time.UTC),
+		BasicConstraintsValid: true,
+		IsCA:                  true,
+		SubjectKeyId:          []byte{1, 2, 3, 4},
+	}
+
+	// A self-signed tbs certificate whose subjectKeyIdentifier was not
+	// computed from its public key must be rejected outright: the SKID
+	// substitution performed by Check would otherwise hide it from the lints.
+	_, err = Check(tbs, key.Public(), tbs, key, Config{}, nil)
+	test.AssertError(t, err, "linting should have failed")
+	test.AssertContains(t, err.Error(), "RFC 7093")
+
+	// With the correct subjectKeyIdentifier, linting may fail for other
+	// reasons (this minimal certificate is far from profile-compliant), but
+	// not because of the subjectKeyIdentifier check.
+	skid, err := core.GenerateSKID(key.Public())
+	test.AssertNotError(t, err, "computing SKID")
+	tbs.SubjectKeyId = skid
+	_, err = Check(tbs, key.Public(), tbs, key, Config{}, nil)
+	if err != nil && strings.Contains(err.Error(), "RFC 7093") {
+		t.Errorf("linting failed on the subjectKeyIdentifier check despite a correct SKID: %s", err)
+	}
+}