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  }