github.com/jasoet/gopki@v1.15.0/compatibility/cert/cert_test.go (about) 1 //go:build compatibility 2 3 package cert 4 5 import ( 6 "crypto/ecdsa" 7 "crypto/ed25519" 8 "crypto/rsa" 9 "crypto/x509/pkix" 10 "net" 11 "testing" 12 "time" 13 14 "github.com/jasoet/gopki/cert" 15 "github.com/jasoet/gopki/compatibility" 16 "github.com/jasoet/gopki/keypair" 17 "github.com/jasoet/gopki/keypair/algo" 18 "github.com/stretchr/testify/assert" 19 "github.com/stretchr/testify/require" 20 ) 21 22 // Test data for certificate compatibility tests 23 var ( 24 testSubject = "CN=Test Certificate,O=GoPKI,C=US" 25 testSAN = "DNS:localhost,DNS:example.com,IP:127.0.0.1" 26 caSubject = "CN=Test CA,O=GoPKI,C=US" 27 ) 28 29 func TestSelfSignedCertificateCompatibility(t *testing.T) { 30 t.Logf("🔐 Running Self-Signed Certificate OpenSSL Compatibility Tests...") 31 t.Logf(" Testing self-signed certificate generation and validation") 32 33 t.Run("RSA_2048", func(t *testing.T) { 34 t.Logf("Testing RSA-2048 self-signed certificate compatibility") 35 testSelfSignedCertificateRSA(t, "RSA-2048", algo.KeySize2048) 36 }) 37 38 t.Run("RSA_4096", func(t *testing.T) { 39 t.Logf("Testing RSA-4096 self-signed certificate compatibility") 40 testSelfSignedCertificateRSA(t, "RSA-4096", algo.KeySize4096) 41 }) 42 43 t.Run("ECDSA_P256", func(t *testing.T) { 44 t.Logf("Testing ECDSA-P256 self-signed certificate compatibility") 45 testSelfSignedCertificateECDSA(t, "ECDSA-P256", algo.P256) 46 }) 47 48 t.Run("ECDSA_P384", func(t *testing.T) { 49 t.Logf("Testing ECDSA-P384 self-signed certificate compatibility") 50 testSelfSignedCertificateECDSA(t, "ECDSA-P384", algo.P384) 51 }) 52 53 t.Run("Ed25519", func(t *testing.T) { 54 t.Logf("Testing Ed25519 self-signed certificate compatibility") 55 testSelfSignedCertificateEd25519(t, "Ed25519") 56 }) 57 } 58 59 func testSelfSignedCertificateRSA(t *testing.T, algName string, keySize algo.KeySize) { 60 helper := compatibility.NewOpenSSLHelper(t) 61 defer helper.Cleanup() 62 63 t.Run("GoPKI_Generate_OpenSSL_Validate", func(t *testing.T) { 64 // Generate RSA key pair with GoPKI 65 manager, err := keypair.Generate[algo.KeySize, *algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](keySize) 66 require.NoError(t, err, "Failed to generate RSA key pair with GoPKI") 67 68 // Create self-signed certificate with GoPKI 69 certRequest := cert.CertificateRequest{ 70 Subject: pkix.Name{ 71 CommonName: "Test Certificate", 72 Organization: []string{"GoPKI"}, 73 Country: []string{"US"}, 74 }, 75 DNSNames: []string{"localhost", "example.com"}, 76 IPAddresses: []net.IP{net.IPv4(127, 0, 0, 1)}, 77 EmailAddress: []string{"test@example.com"}, 78 ValidFrom: time.Now(), 79 ValidFor: 365 * 24 * time.Hour, 80 } 81 82 certificate, err := cert.CreateSelfSignedCertificate(manager.KeyPair(), certRequest) 83 require.NoError(t, err, "Failed to create self-signed certificate with GoPKI") 84 85 // Validate certificate with OpenSSL 86 err = helper.ValidateCertificateWithOpenSSL(certificate.PEMData) 87 assert.NoError(t, err, "OpenSSL validation failed for GoPKI-generated certificate") 88 89 t.Logf("✓ GoPKI %s self-signed certificate validated by OpenSSL", algName) 90 }) 91 92 t.Run("OpenSSL_Generate_GoPKI_Validate", func(t *testing.T) { 93 // Generate key pair with GoPKI for OpenSSL to use 94 manager, err := keypair.Generate[algo.KeySize, *algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](keySize) 95 require.NoError(t, err, "Failed to generate key pair") 96 97 privatePEM, _, err := manager.ToPEM() 98 require.NoError(t, err, "Failed to convert private key to PEM") 99 100 // Generate self-signed certificate with OpenSSL 101 certPEM, err := helper.GenerateSelfSignedCertWithOpenSSL(privatePEM, testSubject, testSAN) 102 require.NoError(t, err, "Failed to generate self-signed certificate with OpenSSL") 103 104 // Validate certificate with GoPKI 105 parsedCert, err := cert.ParseCertificateFromPEM(certPEM) 106 require.NoError(t, err, "Failed to parse OpenSSL-generated certificate with GoPKI") 107 108 // Verify certificate structure 109 assert.NotNil(t, parsedCert.Certificate, "Certificate should be parsed") 110 assert.Contains(t, parsedCert.Certificate.Subject.CommonName, "Test Certificate") 111 112 t.Logf("✓ OpenSSL %s self-signed certificate parsed and validated by GoPKI", algName) 113 }) 114 115 t.Run("Format_Conversion", func(t *testing.T) { 116 // Generate certificate with GoPKI 117 manager, err := keypair.Generate[algo.KeySize, *algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](keySize) 118 require.NoError(t, err, "Failed to generate key pair") 119 120 certRequest := cert.CertificateRequest{ 121 Subject: pkix.Name{ 122 CommonName: "Format Test Certificate", 123 Organization: []string{"GoPKI"}, 124 Country: []string{"US"}, 125 }, 126 ValidFor: 365 * 24 * time.Hour, 127 } 128 129 certificate, err := cert.CreateSelfSignedCertificate(manager.KeyPair(), certRequest) 130 require.NoError(t, err, "Failed to create certificate") 131 132 // Test PEM to DER conversion 133 derData, err := helper.ConvertCertPEMToDERWithOpenSSL(certificate.PEMData) 134 require.NoError(t, err, "Failed to convert PEM to DER with OpenSSL") 135 136 // Test DER to PEM conversion 137 pemData, err := helper.ConvertCertDERToPEMWithOpenSSL(derData) 138 require.NoError(t, err, "Failed to convert DER to PEM with OpenSSL") 139 140 // Validate converted certificate 141 err = helper.ValidateCertificateWithOpenSSL(pemData) 142 assert.NoError(t, err, "Failed to validate converted certificate") 143 144 t.Logf("✓ %s certificate format conversion compatibility verified", algName) 145 }) 146 } 147 148 func testSelfSignedCertificateECDSA(t *testing.T, algName string, curve algo.ECDSACurve) { 149 helper := compatibility.NewOpenSSLHelper(t) 150 defer helper.Cleanup() 151 152 t.Run("GoPKI_Generate_OpenSSL_Validate", func(t *testing.T) { 153 // Generate ECDSA key pair with GoPKI 154 manager, err := keypair.Generate[algo.ECDSACurve, *algo.ECDSAKeyPair, *ecdsa.PrivateKey, *ecdsa.PublicKey](curve) 155 require.NoError(t, err, "Failed to generate ECDSA key pair with GoPKI") 156 157 // Create self-signed certificate with GoPKI 158 certRequest := cert.CertificateRequest{ 159 Subject: pkix.Name{ 160 CommonName: "Test Certificate", 161 Organization: []string{"GoPKI"}, 162 Country: []string{"US"}, 163 }, 164 DNSNames: []string{"localhost", "example.com"}, 165 IPAddresses: []net.IP{net.IPv4(127, 0, 0, 1)}, 166 EmailAddress: []string{"test@example.com"}, 167 ValidFrom: time.Now(), 168 ValidFor: 365 * 24 * time.Hour, 169 } 170 171 certificate, err := cert.CreateSelfSignedCertificate(manager.KeyPair(), certRequest) 172 require.NoError(t, err, "Failed to create self-signed certificate with GoPKI") 173 174 // Validate certificate with OpenSSL 175 err = helper.ValidateCertificateWithOpenSSL(certificate.PEMData) 176 assert.NoError(t, err, "OpenSSL validation failed for GoPKI-generated certificate") 177 178 t.Logf("✓ GoPKI %s self-signed certificate validated by OpenSSL", algName) 179 }) 180 181 t.Run("OpenSSL_Generate_GoPKI_Validate", func(t *testing.T) { 182 // Generate key pair with GoPKI for OpenSSL to use 183 manager, err := keypair.Generate[algo.ECDSACurve, *algo.ECDSAKeyPair, *ecdsa.PrivateKey, *ecdsa.PublicKey](curve) 184 require.NoError(t, err, "Failed to generate key pair") 185 186 privatePEM, _, err := manager.ToPEM() 187 require.NoError(t, err, "Failed to convert private key to PEM") 188 189 // Generate self-signed certificate with OpenSSL 190 certPEM, err := helper.GenerateSelfSignedCertWithOpenSSL(privatePEM, testSubject, testSAN) 191 require.NoError(t, err, "Failed to generate self-signed certificate with OpenSSL") 192 193 // Validate certificate with GoPKI 194 parsedCert, err := cert.ParseCertificateFromPEM(certPEM) 195 require.NoError(t, err, "Failed to parse OpenSSL-generated certificate with GoPKI") 196 197 // Verify certificate structure 198 assert.NotNil(t, parsedCert.Certificate, "Certificate should be parsed") 199 assert.Contains(t, parsedCert.Certificate.Subject.CommonName, "Test Certificate") 200 201 t.Logf("✓ OpenSSL %s self-signed certificate parsed and validated by GoPKI", algName) 202 }) 203 } 204 205 func testSelfSignedCertificateEd25519(t *testing.T, algName string) { 206 helper := compatibility.NewOpenSSLHelper(t) 207 defer helper.Cleanup() 208 209 t.Run("GoPKI_Generate_OpenSSL_Validate", func(t *testing.T) { 210 // Generate Ed25519 key pair with GoPKI 211 manager, err := keypair.Generate[algo.Ed25519Config, *algo.Ed25519KeyPair, ed25519.PrivateKey, ed25519.PublicKey](algo.Ed25519Default) 212 require.NoError(t, err, "Failed to generate Ed25519 key pair with GoPKI") 213 214 // Create self-signed certificate with GoPKI 215 certRequest := cert.CertificateRequest{ 216 Subject: pkix.Name{ 217 CommonName: "Test Certificate", 218 Organization: []string{"GoPKI"}, 219 Country: []string{"US"}, 220 }, 221 DNSNames: []string{"localhost", "example.com"}, 222 IPAddresses: []net.IP{net.IPv4(127, 0, 0, 1)}, 223 EmailAddress: []string{"test@example.com"}, 224 ValidFrom: time.Now(), 225 ValidFor: 365 * 24 * time.Hour, 226 } 227 228 certificate, err := cert.CreateSelfSignedCertificate(manager.KeyPair(), certRequest) 229 require.NoError(t, err, "Failed to create self-signed certificate with GoPKI") 230 231 // Validate certificate with OpenSSL 232 err = helper.ValidateCertificateWithOpenSSL(certificate.PEMData) 233 assert.NoError(t, err, "OpenSSL validation failed for GoPKI-generated certificate") 234 235 t.Logf("✓ GoPKI %s self-signed certificate validated by OpenSSL", algName) 236 }) 237 238 t.Run("OpenSSL_Generate_GoPKI_Validate", func(t *testing.T) { 239 // Generate key pair with GoPKI for OpenSSL to use 240 manager, err := keypair.Generate[algo.Ed25519Config, *algo.Ed25519KeyPair, ed25519.PrivateKey, ed25519.PublicKey](algo.Ed25519Default) 241 require.NoError(t, err, "Failed to generate key pair") 242 243 privatePEM, _, err := manager.ToPEM() 244 require.NoError(t, err, "Failed to convert private key to PEM") 245 246 // Generate self-signed certificate with OpenSSL 247 certPEM, err := helper.GenerateSelfSignedCertWithOpenSSL(privatePEM, testSubject, testSAN) 248 require.NoError(t, err, "Failed to generate self-signed certificate with OpenSSL") 249 250 // Validate certificate with GoPKI 251 parsedCert, err := cert.ParseCertificateFromPEM(certPEM) 252 require.NoError(t, err, "Failed to parse OpenSSL-generated certificate with GoPKI") 253 254 // Verify certificate structure 255 assert.NotNil(t, parsedCert.Certificate, "Certificate should be parsed") 256 assert.Contains(t, parsedCert.Certificate.Subject.CommonName, "Test Certificate") 257 258 t.Logf("✓ OpenSSL %s self-signed certificate parsed and validated by GoPKI", algName) 259 }) 260 } 261 262 func TestCACertificateCompatibility(t *testing.T) { 263 t.Logf("🏛️ Running CA Certificate OpenSSL Compatibility Tests...") 264 t.Logf(" Testing CA certificate generation and validation") 265 266 t.Run("RSA_4096_CA", func(t *testing.T) { 267 testCACertificateRSA(t, "RSA-4096", algo.KeySize4096) 268 }) 269 270 t.Run("ECDSA_P384_CA", func(t *testing.T) { 271 testCACertificateECDSA(t, "ECDSA-P384", algo.P384) 272 }) 273 } 274 275 func testCACertificateRSA(t *testing.T, algName string, keySize algo.KeySize) { 276 helper := compatibility.NewOpenSSLHelper(t) 277 defer helper.Cleanup() 278 279 t.Run("GoPKI_Generate_OpenSSL_Validate", func(t *testing.T) { 280 // Generate CA key pair with GoPKI 281 manager, err := keypair.Generate[algo.KeySize, *algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](keySize) 282 require.NoError(t, err, "Failed to generate CA key pair") 283 284 // Create CA certificate with GoPKI 285 caRequest := cert.CertificateRequest{ 286 Subject: pkix.Name{ 287 CommonName: "Test CA", 288 Organization: []string{"GoPKI"}, 289 Country: []string{"US"}, 290 }, 291 292 ValidFor: 10 * 365 * 24 * time.Hour, // 10 years 293 IsCA: true, 294 MaxPathLen: 2, 295 } 296 297 caCert, err := cert.CreateCACertificate(manager.KeyPair(), caRequest) 298 require.NoError(t, err, "Failed to create CA certificate with GoPKI") 299 300 // Validate CA certificate with OpenSSL 301 err = helper.ValidateCertificateWithOpenSSL(caCert.PEMData) 302 assert.NoError(t, err, "OpenSSL validation failed for GoPKI-generated CA certificate") 303 304 // Verify CA extensions are present 305 assert.True(t, caCert.Certificate.IsCA, "Certificate should be marked as CA") 306 assert.Equal(t, 2, caCert.Certificate.MaxPathLen, "MaxPathLen should be 2") 307 308 t.Logf("✓ GoPKI %s CA certificate validated by OpenSSL", algName) 309 }) 310 311 t.Run("OpenSSL_Generate_GoPKI_Validate", func(t *testing.T) { 312 // Generate CA key pair with GoPKI for OpenSSL to use 313 manager, err := keypair.Generate[algo.KeySize, *algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](keySize) 314 require.NoError(t, err, "Failed to generate CA key pair") 315 316 privatePEM, _, err := manager.ToPEM() 317 require.NoError(t, err, "Failed to convert CA private key to PEM") 318 319 // Generate CA certificate with OpenSSL 320 caCertPEM, err := helper.GenerateCACertWithOpenSSL(privatePEM, caSubject) 321 require.NoError(t, err, "Failed to generate CA certificate with OpenSSL") 322 323 // Validate CA certificate with GoPKI 324 parsedCACert, err := cert.ParseCertificateFromPEM(caCertPEM) 325 require.NoError(t, err, "Failed to parse OpenSSL-generated CA certificate with GoPKI") 326 327 // Verify CA properties 328 assert.True(t, parsedCACert.Certificate.IsCA, "Certificate should be marked as CA") 329 assert.Contains(t, parsedCACert.Certificate.Subject.CommonName, "Test CA") 330 331 t.Logf("✓ OpenSSL %s CA certificate parsed and validated by GoPKI", algName) 332 }) 333 } 334 335 func testCACertificateECDSA(t *testing.T, algName string, curve algo.ECDSACurve) { 336 helper := compatibility.NewOpenSSLHelper(t) 337 defer helper.Cleanup() 338 339 t.Run("GoPKI_Generate_OpenSSL_Validate", func(t *testing.T) { 340 // Generate CA key pair with GoPKI 341 manager, err := keypair.Generate[algo.ECDSACurve, *algo.ECDSAKeyPair, *ecdsa.PrivateKey, *ecdsa.PublicKey](curve) 342 require.NoError(t, err, "Failed to generate CA key pair") 343 344 // Create CA certificate with GoPKI 345 caRequest := cert.CertificateRequest{ 346 Subject: pkix.Name{ 347 CommonName: "Test CA", 348 Organization: []string{"GoPKI"}, 349 Country: []string{"US"}, 350 }, 351 ValidFor: 10 * 365 * 24 * time.Hour, // 10 years 352 IsCA: true, 353 MaxPathLen: 2, 354 } 355 356 caCert, err := cert.CreateCACertificate(manager.KeyPair(), caRequest) 357 require.NoError(t, err, "Failed to create CA certificate with GoPKI") 358 359 // Validate CA certificate with OpenSSL 360 err = helper.ValidateCertificateWithOpenSSL(caCert.PEMData) 361 assert.NoError(t, err, "OpenSSL validation failed for GoPKI-generated CA certificate") 362 363 // Verify CA extensions are present 364 assert.True(t, caCert.Certificate.IsCA, "Certificate should be marked as CA") 365 assert.Equal(t, 2, caCert.Certificate.MaxPathLen, "MaxPathLen should be 2") 366 367 t.Logf("✓ GoPKI %s CA certificate validated by OpenSSL", algName) 368 }) 369 } 370 371 func TestCertificateSigningCompatibility(t *testing.T) { 372 t.Logf("✍️ Running Certificate Signing OpenSSL Compatibility Tests...") 373 t.Logf(" Testing certificate signing and chain validation") 374 375 t.Run("RSA_Certificate_Signing", func(t *testing.T) { 376 testCertificateSigningRSA(t, "RSA", algo.KeySize2048) 377 }) 378 379 t.Run("ECDSA_Certificate_Signing", func(t *testing.T) { 380 testCertificateSigningECDSA(t, "ECDSA", algo.P256) 381 }) 382 } 383 384 func testCertificateSigningRSA(t *testing.T, algName string, keySize algo.KeySize) { 385 helper := compatibility.NewOpenSSLHelper(t) 386 defer helper.Cleanup() 387 388 t.Run("GoPKI_CA_Signs_OpenSSL_Validates", func(t *testing.T) { 389 // Create CA with GoPKI 390 caManager, err := keypair.Generate[algo.KeySize, *algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](keySize) 391 require.NoError(t, err, "Failed to generate CA key pair") 392 393 caRequest := cert.CertificateRequest{ 394 Subject: pkix.Name{ 395 CommonName: "Test CA", 396 Organization: []string{"GoPKI"}, 397 Country: []string{"US"}, 398 }, 399 ValidFor: 10 * 365 * 24 * time.Hour, 400 IsCA: true, 401 MaxPathLen: 1, 402 } 403 404 caCert, err := cert.CreateCACertificate(caManager.KeyPair(), caRequest) 405 require.NoError(t, err, "Failed to create CA certificate") 406 407 // Create end-entity certificate signed by CA 408 entityManager, err := keypair.Generate[algo.KeySize, *algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](keySize) 409 require.NoError(t, err, "Failed to generate entity key pair") 410 411 entityRequest := cert.CertificateRequest{ 412 Subject: pkix.Name{ 413 CommonName: "Test Server", 414 Organization: []string{"GoPKI"}, 415 Country: []string{"US"}, 416 }, 417 DNSNames: []string{"server.example.com"}, 418 IPAddresses: []net.IP{net.IPv4(192, 168, 1, 100)}, 419 ValidFor: 365 * 24 * time.Hour, 420 } 421 422 entityCert, err := cert.SignCertificate(caCert, caManager.KeyPair(), entityRequest, entityManager.PublicKey()) 423 require.NoError(t, err, "Failed to sign certificate with GoPKI CA") 424 425 // Verify certificate chain with OpenSSL 426 err = helper.VerifyCertificateChainWithOpenSSL(entityCert.PEMData, caCert.PEMData) 427 assert.NoError(t, err, "OpenSSL chain verification failed for GoPKI-signed certificate") 428 429 t.Logf("✓ GoPKI %s CA-signed certificate verified by OpenSSL", algName) 430 }) 431 } 432 433 func testCertificateSigningECDSA(t *testing.T, algName string, curve algo.ECDSACurve) { 434 helper := compatibility.NewOpenSSLHelper(t) 435 defer helper.Cleanup() 436 437 t.Run("GoPKI_CA_Signs_OpenSSL_Validates", func(t *testing.T) { 438 // Create CA with GoPKI 439 caManager, err := keypair.Generate[algo.ECDSACurve, *algo.ECDSAKeyPair, *ecdsa.PrivateKey, *ecdsa.PublicKey](curve) 440 require.NoError(t, err, "Failed to generate CA key pair") 441 442 caRequest := cert.CertificateRequest{ 443 Subject: pkix.Name{ 444 CommonName: "Test CA", 445 Organization: []string{"GoPKI"}, 446 Country: []string{"US"}, 447 }, 448 ValidFor: 10 * 365 * 24 * time.Hour, 449 IsCA: true, 450 MaxPathLen: 1, 451 } 452 453 caCert, err := cert.CreateCACertificate(caManager.KeyPair(), caRequest) 454 require.NoError(t, err, "Failed to create CA certificate") 455 456 // Create end-entity certificate signed by CA 457 entityManager, err := keypair.Generate[algo.ECDSACurve, *algo.ECDSAKeyPair, *ecdsa.PrivateKey, *ecdsa.PublicKey](curve) 458 require.NoError(t, err, "Failed to generate entity key pair") 459 460 entityRequest := cert.CertificateRequest{ 461 Subject: pkix.Name{ 462 CommonName: "Test Server", 463 Organization: []string{"GoPKI"}, 464 Country: []string{"US"}, 465 }, 466 DNSNames: []string{"server.example.com"}, 467 IPAddresses: []net.IP{net.IPv4(192, 168, 1, 100)}, 468 ValidFor: 365 * 24 * time.Hour, 469 } 470 471 entityCert, err := cert.SignCertificate(caCert, caManager.KeyPair(), entityRequest, entityManager.PublicKey()) 472 require.NoError(t, err, "Failed to sign certificate with GoPKI CA") 473 474 // Verify certificate chain with OpenSSL 475 err = helper.VerifyCertificateChainWithOpenSSL(entityCert.PEMData, caCert.PEMData) 476 assert.NoError(t, err, "OpenSSL chain verification failed for GoPKI-signed certificate") 477 478 t.Logf("✓ GoPKI %s CA-signed certificate verified by OpenSSL", algName) 479 }) 480 } 481 482 func TestSubjectAlternativeNames(t *testing.T) { 483 t.Logf("🌐 Running Subject Alternative Names (SAN) Compatibility Tests...") 484 t.Logf(" Testing SAN extension compatibility") 485 486 helper := compatibility.NewOpenSSLHelper(t) 487 defer helper.Cleanup() 488 489 t.Run("Multi_SAN_Certificate", func(t *testing.T) { 490 // Generate key pair 491 manager, err := keypair.Generate[algo.ECDSACurve, *algo.ECDSAKeyPair, *ecdsa.PrivateKey, *ecdsa.PublicKey](algo.P256) 492 require.NoError(t, err, "Failed to generate key pair") 493 494 // Create certificate with multiple SAN types 495 certRequest := cert.CertificateRequest{ 496 Subject: pkix.Name{ 497 CommonName: "Multi-SAN Certificate", 498 Organization: []string{"GoPKI Test"}, 499 Country: []string{"US"}, 500 }, 501 DNSNames: []string{ 502 "example.com", 503 "www.example.com", 504 "api.example.com", 505 "*.staging.example.com", 506 }, 507 IPAddresses: []net.IP{ 508 net.IPv4(192, 168, 1, 1), 509 net.IPv4(10, 0, 0, 1), 510 net.ParseIP("2001:db8::1"), 511 }, 512 EmailAddress: []string{ 513 "admin@example.com", 514 "support@example.com", 515 }, 516 ValidFor: 365 * 24 * time.Hour, 517 } 518 519 certificate, err := cert.CreateSelfSignedCertificate(manager.KeyPair(), certRequest) 520 require.NoError(t, err, "Failed to create multi-SAN certificate") 521 522 // Validate certificate with OpenSSL 523 err = helper.ValidateCertificateWithOpenSSL(certificate.PEMData) 524 assert.NoError(t, err, "OpenSSL validation failed for multi-SAN certificate") 525 526 // Verify SAN extensions are properly parsed 527 assert.Len(t, certificate.Certificate.DNSNames, 4, "Should have 4 DNS names") 528 assert.Len(t, certificate.Certificate.IPAddresses, 3, "Should have 3 IP addresses") 529 assert.Len(t, certificate.Certificate.EmailAddresses, 2, "Should have 2 email addresses") 530 531 t.Logf("✓ Multi-SAN certificate validated by OpenSSL") 532 }) 533 } 534 535 func TestCertificateFormatCompatibility(t *testing.T) { 536 t.Logf("💾 Running Certificate Format Compatibility Tests...") 537 t.Logf(" Testing PEM/DER format interoperability") 538 539 helper := compatibility.NewOpenSSLHelper(t) 540 defer helper.Cleanup() 541 542 t.Run("Bidirectional_Format_Conversion", func(t *testing.T) { 543 // Generate certificate with GoPKI 544 manager, err := keypair.Generate[algo.KeySize, *algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](algo.KeySize2048) 545 require.NoError(t, err, "Failed to generate key pair") 546 547 certRequest := cert.CertificateRequest{ 548 Subject: pkix.Name{ 549 CommonName: "Format Test Certificate", 550 Organization: []string{"GoPKI"}, 551 Country: []string{"US"}, 552 }, 553 ValidFor: 365 * 24 * time.Hour, 554 } 555 556 certificate, err := cert.CreateSelfSignedCertificate(manager.KeyPair(), certRequest) 557 require.NoError(t, err, "Failed to create certificate") 558 559 // Test GoPKI format conversion 560 derFromGoPKI := certificate.ToDER() 561 pemFromGoPKI := certificate.ToPEM() 562 563 // Test OpenSSL format conversion 564 derFromOpenSSL, err := helper.ConvertCertPEMToDERWithOpenSSL(pemFromGoPKI) 565 require.NoError(t, err, "Failed to convert PEM to DER with OpenSSL") 566 567 pemFromOpenSSL, err := helper.ConvertCertDERToPEMWithOpenSSL(derFromOpenSSL) 568 require.NoError(t, err, "Failed to convert DER to PEM with OpenSSL") 569 570 // Cross-validate formats 571 assert.Equal(t, derFromGoPKI, derFromOpenSSL, "DER data should match between GoPKI and OpenSSL") 572 573 // Parse converted certificate back with GoPKI 574 parsedCert, err := cert.ParseCertificateFromPEM(pemFromOpenSSL) 575 require.NoError(t, err, "Failed to parse OpenSSL-converted certificate") 576 577 assert.Equal(t, certificate.Certificate.Subject.CommonName, parsedCert.Certificate.Subject.CommonName) 578 579 t.Logf("✓ Bidirectional format conversion compatibility verified") 580 }) 581 } 582 583 func TestCompatibilityEdgeCases(t *testing.T) { 584 t.Logf("⚠️ Running Certificate Compatibility Edge Cases...") 585 t.Logf(" Testing error conditions and edge cases") 586 587 helper := compatibility.NewOpenSSLHelper(t) 588 defer helper.Cleanup() 589 590 t.Run("Invalid_Certificate_Data", func(t *testing.T) { 591 invalidPEM := []byte(`-----BEGIN CERTIFICATE----- 592 INVALID_BASE64_DATA_HERE 593 -----END CERTIFICATE-----`) 594 595 err := helper.ValidateCertificateWithOpenSSL(invalidPEM) 596 assert.Error(t, err, "OpenSSL should reject invalid certificate data") 597 598 _, err = cert.ParseCertificateFromPEM(invalidPEM) 599 assert.Error(t, err, "GoPKI should reject invalid certificate data") 600 601 t.Logf("✓ Invalid certificate data handling verified") 602 }) 603 604 t.Run("Expired_Certificate_Handling", func(t *testing.T) { 605 // Generate certificate with past validity period 606 manager, err := keypair.Generate[algo.KeySize, *algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](algo.KeySize2048) 607 require.NoError(t, err, "Failed to generate key pair") 608 609 certRequest := cert.CertificateRequest{ 610 Subject: pkix.Name{ 611 CommonName: "Expired Certificate", 612 }, 613 ValidFrom: time.Now().Add(-2 * 365 * 24 * time.Hour), // Started 2 years ago 614 ValidFor: 365 * 24 * time.Hour, // Valid for 1 year (expired 1 year ago) 615 } 616 617 expiredCert, err := cert.CreateSelfSignedCertificate(manager.KeyPair(), certRequest) 618 require.NoError(t, err, "Failed to create expired certificate") 619 620 // Certificate should parse but validation should indicate expiry 621 parsedCert, err := cert.ParseCertificateFromPEM(expiredCert.PEMData) 622 require.NoError(t, err, "Expired certificate should still parse") 623 624 assert.True(t, time.Now().After(parsedCert.Certificate.NotAfter), "Certificate should be expired") 625 626 t.Logf("✓ Expired certificate handling verified") 627 }) 628 }