@@ -1150,3 +1150,236 @@ func TestTlogEntriesCountAtCap(t *testing.T) {
11501150 require .NotContains (t , err .Error (), "too many tlog entries" )
11511151 }
11521152}
1153+
1154+ func TestNewBundleWithAllowCertificateChain (t * testing.T ) {
1155+ t .Parallel ()
1156+
1157+ v03BundleWithCertChain := & protobundle.Bundle {
1158+ MediaType : "application/vnd.dev.sigstore.bundle.v0.3+json" ,
1159+ VerificationMaterial : & protobundle.VerificationMaterial {
1160+ Content : & protobundle.VerificationMaterial_X509CertificateChain {
1161+ X509CertificateChain : & protocommon.X509CertificateChain {},
1162+ },
1163+ },
1164+ Content : & protobundle.Bundle_MessageSignature {},
1165+ }
1166+
1167+ for _ , tc := range []struct {
1168+ name string
1169+ opts []Option
1170+ wantErr bool
1171+ }{
1172+ {"v0.3 with cert chain without option" , nil , true },
1173+ {"v0.3 with cert chain with AllowCertificateChain" , []Option {AllowCertificateChain ()}, false },
1174+ } {
1175+ t .Run (tc .name , func (t * testing.T ) {
1176+ t .Parallel ()
1177+ bundle , err := NewBundle (v03BundleWithCertChain , tc .opts ... )
1178+ if tc .wantErr {
1179+ require .Error (t , err )
1180+ require .Contains (t , err .Error (), "verification material cannot be X.509 certificate chain" )
1181+ } else {
1182+ require .NoError (t , err )
1183+ require .NotNil (t , bundle )
1184+ }
1185+ })
1186+ }
1187+ }
1188+
1189+ func TestVerificationContentIntermediates (t * testing.T ) {
1190+ t .Parallel ()
1191+ rootKey , err := rsa .GenerateKey (rand .Reader , 2048 )
1192+ require .NoError (t , err )
1193+ intermediateKey , err := rsa .GenerateKey (rand .Reader , 2048 )
1194+ require .NoError (t , err )
1195+ subordinateIntermediateKey , err := rsa .GenerateKey (rand .Reader , 2048 )
1196+ require .NoError (t , err )
1197+ leafKey , err := rsa .GenerateKey (rand .Reader , 2048 )
1198+ require .NoError (t , err )
1199+
1200+ rootCert := & x509.Certificate {
1201+ SerialNumber : big .NewInt (1 ),
1202+ BasicConstraintsValid : true ,
1203+ IsCA : true ,
1204+ }
1205+ intermediateCert := & x509.Certificate {
1206+ SerialNumber : big .NewInt (2 ),
1207+ BasicConstraintsValid : true ,
1208+ IsCA : true ,
1209+ }
1210+ subordinateIntermediateCert := & x509.Certificate {
1211+ SerialNumber : big .NewInt (3 ),
1212+ BasicConstraintsValid : true ,
1213+ IsCA : true ,
1214+ }
1215+ leafCert := & x509.Certificate {SerialNumber : big .NewInt (4 )}
1216+
1217+ rootDer , err := x509 .CreateCertificate (rand .Reader , rootCert , rootCert , & rootKey .PublicKey , rootKey )
1218+ require .NoError (t , err )
1219+ intermediateDer , err := x509 .CreateCertificate (rand .Reader , intermediateCert , rootCert , & intermediateKey .PublicKey , rootKey )
1220+ require .NoError (t , err )
1221+ subordinateIntermediateDer , err := x509 .CreateCertificate (rand .Reader , subordinateIntermediateCert , intermediateCert , & subordinateIntermediateKey .PublicKey , intermediateKey )
1222+ require .NoError (t , err )
1223+ leafDer , err := x509 .CreateCertificate (rand .Reader , leafCert , subordinateIntermediateCert , & leafKey .PublicKey , subordinateIntermediateKey )
1224+ require .NoError (t , err )
1225+
1226+ tests := []struct {
1227+ name string
1228+ bundle Bundle
1229+ allowCertificateChain bool
1230+ wantSerials []* big.Int
1231+ wantErr bool
1232+ wantErrContains string
1233+ }{
1234+ {
1235+ name : "single certificate verification material" ,
1236+ bundle : Bundle {Bundle : & protobundle.Bundle {
1237+ VerificationMaterial : & protobundle.VerificationMaterial {
1238+ Content : & protobundle.VerificationMaterial_Certificate {
1239+ Certificate : & protocommon.X509Certificate {RawBytes : leafDer },
1240+ },
1241+ },
1242+ }},
1243+ allowCertificateChain : true ,
1244+ wantSerials : nil ,
1245+ },
1246+ {
1247+ name : "certificate chain with leaf only" ,
1248+ bundle : Bundle {Bundle : & protobundle.Bundle {
1249+ VerificationMaterial : & protobundle.VerificationMaterial {
1250+ Content : & protobundle.VerificationMaterial_X509CertificateChain {
1251+ X509CertificateChain : & protocommon.X509CertificateChain {
1252+ Certificates : []* protocommon.X509Certificate {
1253+ {RawBytes : leafDer },
1254+ },
1255+ },
1256+ },
1257+ },
1258+ }},
1259+ allowCertificateChain : true ,
1260+ wantSerials : nil ,
1261+ },
1262+ {
1263+ name : "certificate chain with leaf and intermediate" ,
1264+ bundle : Bundle {Bundle : & protobundle.Bundle {
1265+ VerificationMaterial : & protobundle.VerificationMaterial {
1266+ Content : & protobundle.VerificationMaterial_X509CertificateChain {
1267+ X509CertificateChain : & protocommon.X509CertificateChain {
1268+ Certificates : []* protocommon.X509Certificate {
1269+ {RawBytes : leafDer },
1270+ {RawBytes : subordinateIntermediateDer },
1271+ },
1272+ },
1273+ },
1274+ },
1275+ }},
1276+ allowCertificateChain : true ,
1277+ wantSerials : []* big.Int {subordinateIntermediateCert .SerialNumber },
1278+ },
1279+ {
1280+ name : "certificate chain with leaf and multiple intermediates" ,
1281+ bundle : Bundle {Bundle : & protobundle.Bundle {
1282+ VerificationMaterial : & protobundle.VerificationMaterial {
1283+ Content : & protobundle.VerificationMaterial_X509CertificateChain {
1284+ X509CertificateChain : & protocommon.X509CertificateChain {
1285+ Certificates : []* protocommon.X509Certificate {
1286+ {RawBytes : leafDer },
1287+ {RawBytes : subordinateIntermediateDer },
1288+ {RawBytes : intermediateDer },
1289+ },
1290+ },
1291+ },
1292+ },
1293+ }},
1294+ allowCertificateChain : true ,
1295+ wantSerials : []* big.Int {subordinateIntermediateCert .SerialNumber , intermediateCert .SerialNumber },
1296+ },
1297+ {
1298+ name : "certificate chain with intermediate but certificate chain option disabled" ,
1299+ bundle : Bundle {Bundle : & protobundle.Bundle {
1300+ VerificationMaterial : & protobundle.VerificationMaterial {
1301+ Content : & protobundle.VerificationMaterial_X509CertificateChain {
1302+ X509CertificateChain : & protocommon.X509CertificateChain {
1303+ Certificates : []* protocommon.X509Certificate {
1304+ {RawBytes : leafDer },
1305+ {RawBytes : subordinateIntermediateDer },
1306+ },
1307+ },
1308+ },
1309+ },
1310+ }},
1311+ allowCertificateChain : false ,
1312+ wantSerials : nil ,
1313+ },
1314+ {
1315+ name : "certificate chain with leaf, intermediate, and self-signed root is rejected" ,
1316+ bundle : Bundle {Bundle : & protobundle.Bundle {
1317+ MediaType : "application/vnd.dev.sigstore.bundle.v0.3+json" ,
1318+ VerificationMaterial : & protobundle.VerificationMaterial {
1319+ Content : & protobundle.VerificationMaterial_X509CertificateChain {
1320+ X509CertificateChain : & protocommon.X509CertificateChain {
1321+ Certificates : []* protocommon.X509Certificate {
1322+ {RawBytes : leafDer },
1323+ {RawBytes : subordinateIntermediateDer },
1324+ {RawBytes : rootDer },
1325+ },
1326+ },
1327+ },
1328+ },
1329+ }},
1330+ allowCertificateChain : true ,
1331+ wantErr : true ,
1332+ wantErrContains : "self-signed certificate found in certificate chain" ,
1333+ },
1334+ }
1335+
1336+ for _ , tt := range tests {
1337+ t .Run (tt .name , func (t * testing.T ) {
1338+ t .Parallel ()
1339+ tt .bundle .allowCertificateChain = tt .allowCertificateChain
1340+ vc , err := tt .bundle .VerificationContent ()
1341+ if tt .wantErr {
1342+ require .Error (t , err )
1343+ if tt .wantErrContains != "" {
1344+ require .ErrorContains (t , err , tt .wantErrContains )
1345+ }
1346+ return
1347+ }
1348+ require .NoError (t , err )
1349+ got := vc .Intermediates ()
1350+ require .Len (t , got , len (tt .wantSerials ))
1351+ for i , cert := range got {
1352+ require .True (t , cert .IsCA )
1353+ require .Equal (t , tt .wantSerials [i ], cert .SerialNumber )
1354+ }
1355+ })
1356+ }
1357+ }
1358+
1359+ func TestVerificationContentIntermediatesParseError (t * testing.T ) {
1360+ t .Parallel ()
1361+ leafKey , err := rsa .GenerateKey (rand .Reader , 2048 )
1362+ require .NoError (t , err )
1363+ leafTmpl := & x509.Certificate {SerialNumber : big .NewInt (1 )}
1364+ leafDer , err := x509 .CreateCertificate (rand .Reader , leafTmpl , leafTmpl , & leafKey .PublicKey , leafKey )
1365+ require .NoError (t , err )
1366+
1367+ bundle := Bundle {
1368+ Bundle : & protobundle.Bundle {
1369+ VerificationMaterial : & protobundle.VerificationMaterial {
1370+ Content : & protobundle.VerificationMaterial_X509CertificateChain {
1371+ X509CertificateChain : & protocommon.X509CertificateChain {
1372+ Certificates : []* protocommon.X509Certificate {
1373+ {RawBytes : leafDer },
1374+ {RawBytes : []byte ("not a certificate" )},
1375+ },
1376+ },
1377+ },
1378+ },
1379+ },
1380+ allowCertificateChain : true ,
1381+ }
1382+ _ , err = bundle .VerificationContent ()
1383+ require .Error (t , err )
1384+ require .ErrorIs (t , err , ErrValidation )
1385+ }
0 commit comments