github.com/jasoet/gopki@v1.15.0/compatibility/signing/signing_test.go (about)

     1  //go:build compatibility
     2  
     3  package signing
     4  
     5  import (
     6  	"crypto/ecdsa"
     7  	"crypto/ed25519"
     8  	"crypto/rsa"
     9  	"crypto/x509"
    10  	"crypto/x509/pkix"
    11  	"net"
    12  	"testing"
    13  	"time"
    14  
    15  	"github.com/stretchr/testify/assert"
    16  	"github.com/stretchr/testify/require"
    17  
    18  	"github.com/jasoet/gopki/cert"
    19  	"github.com/jasoet/gopki/compatibility"
    20  	"github.com/jasoet/gopki/keypair"
    21  	"github.com/jasoet/gopki/keypair/algo"
    22  	"github.com/jasoet/gopki/signing"
    23  )
    24  
    25  // Test data for signing compatibility tests
    26  var (
    27  	testData        = []byte("This is test data for OpenSSL signing compatibility testing with GoPKI library")
    28  	testSubject     = "CN=Test Signer,O=GoPKI,C=US"
    29  	testCertRequest = cert.CertificateRequest{
    30  		Subject: pkix.Name{
    31  			CommonName:   "Test Signer",
    32  			Organization: []string{"GoPKI"},
    33  			Country:      []string{"US"},
    34  		},
    35  		DNSNames:     []string{"signer.example.com"},
    36  		IPAddresses:  []net.IP{net.IPv4(127, 0, 0, 1)},
    37  		EmailAddress: []string{"signer@example.com"},
    38  		ValidFrom:    time.Now(),
    39  		ValidFor:     365 * 24 * time.Hour,
    40  	}
    41  )
    42  
    43  func TestSigningCompatibility(t *testing.T) {
    44  	t.Logf("🔐 Running OpenSSL Signing Compatibility Tests...")
    45  	t.Logf("   Testing digital signature generation, verification, and format compatibility")
    46  
    47  	t.Run("RSA", func(t *testing.T) {
    48  		testRSASigningCompatibility(t)
    49  	})
    50  
    51  	t.Run("ECDSA", func(t *testing.T) {
    52  		testECDSASigningCompatibility(t)
    53  	})
    54  
    55  	t.Run("Ed25519", func(t *testing.T) {
    56  		testEd25519SigningCompatibility(t)
    57  	})
    58  
    59  	t.Logf("✅ OpenSSL signing compatibility tests completed")
    60  }
    61  
    62  func testRSASigningCompatibility(t *testing.T) {
    63  	keySizes := []struct {
    64  		size algo.KeySize
    65  		bits int
    66  		name string
    67  	}{
    68  		{algo.KeySize2048, 2048, "2048"},
    69  		{algo.KeySize3072, 3072, "3072"},
    70  		{algo.KeySize4096, 4096, "4096"},
    71  	}
    72  
    73  	for _, keySize := range keySizes {
    74  		t.Run("RSA_"+keySize.name, func(t *testing.T) {
    75  			helper := compatibility.NewOpenSSLHelper(t)
    76  			defer helper.Cleanup()
    77  
    78  			t.Logf("Testing RSA-%d signing compatibility", keySize.bits)
    79  
    80  			// Generate RSA key pair and certificate with GoPKI
    81  			manager, err := keypair.Generate[algo.KeySize, *algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](keySize.size)
    82  			require.NoError(t, err, "Failed to generate RSA key pair")
    83  
    84  			certificate, err := cert.CreateSelfSignedCertificate(manager.KeyPair(), testCertRequest)
    85  			require.NoError(t, err, "Failed to create self-signed certificate")
    86  
    87  			testRawSignatureCompatibility(t, helper, manager, certificate, "RSA")
    88  			testPKCS7SignatureCompatibility(t, helper, manager, certificate, "RSA")
    89  			testDetachedSignatureCompatibility(t, helper, manager, certificate, "RSA")
    90  
    91  			t.Logf("✓ RSA-%d signing compatibility tests passed", keySize.bits)
    92  		})
    93  	}
    94  }
    95  
    96  func testECDSASigningCompatibility(t *testing.T) {
    97  	curves := []struct {
    98  		curve algo.ECDSACurve
    99  		name  string
   100  	}{
   101  		{algo.P256, "P256"},
   102  		{algo.P384, "P384"},
   103  		{algo.P521, "P521"},
   104  	}
   105  
   106  	for _, curve := range curves {
   107  		t.Run("ECDSA_"+curve.name, func(t *testing.T) {
   108  			helper := compatibility.NewOpenSSLHelper(t)
   109  			defer helper.Cleanup()
   110  
   111  			t.Logf("Testing ECDSA-%s signing compatibility", curve.name)
   112  
   113  			// Generate ECDSA key pair and certificate with GoPKI
   114  			manager, err := keypair.Generate[algo.ECDSACurve, *algo.ECDSAKeyPair, *ecdsa.PrivateKey, *ecdsa.PublicKey](curve.curve)
   115  			require.NoError(t, err, "Failed to generate ECDSA key pair")
   116  
   117  			certificate, err := cert.CreateSelfSignedCertificate(manager.KeyPair(), testCertRequest)
   118  			require.NoError(t, err, "Failed to create self-signed certificate")
   119  
   120  			testRawSignatureCompatibility(t, helper, manager, certificate, "ECDSA")
   121  			testPKCS7SignatureCompatibility(t, helper, manager, certificate, "ECDSA")
   122  			testDetachedSignatureCompatibility(t, helper, manager, certificate, "ECDSA")
   123  
   124  			t.Logf("✓ ECDSA-%s signing compatibility tests passed", curve.name)
   125  		})
   126  	}
   127  }
   128  
   129  func testEd25519SigningCompatibility(t *testing.T) {
   130  	helper := compatibility.NewOpenSSLHelper(t)
   131  	defer helper.Cleanup()
   132  
   133  	t.Logf("Testing Ed25519 signing compatibility")
   134  
   135  	// Generate Ed25519 key pair and certificate with GoPKI
   136  	manager, err := keypair.Generate[algo.Ed25519Config, *algo.Ed25519KeyPair, ed25519.PrivateKey, ed25519.PublicKey](algo.Ed25519Default)
   137  	require.NoError(t, err, "Failed to generate Ed25519 key pair")
   138  
   139  	certificate, err := cert.CreateSelfSignedCertificate(manager.KeyPair(), testCertRequest)
   140  	require.NoError(t, err, "Failed to create self-signed certificate")
   141  
   142  	// Note: OpenSSL 3.5.2 doesn't support Ed25519 CMS/PKCS#7 yet
   143  	// These tests validate GoPKI's Ed25519 PKCS#7 implementation for standards compliance
   144  	// but expect OpenSSL verification to fail due to lack of Ed25519 CMS support
   145  	t.Logf("⚠️  Note: OpenSSL 3.5.2 doesn't support Ed25519 CMS/PKCS#7 - testing GoPKI standards compliance")
   146  
   147  	testRawSignatureCompatibility(t, helper, manager, certificate, "Ed25519")
   148  	testEd25519PKCS7CompatibilityWithLimitations(t, helper, manager, certificate)
   149  	testEd25519DetachedCompatibilityWithLimitations(t, helper, manager, certificate)
   150  
   151  	t.Logf("✓ Ed25519 signing compatibility tests completed (GoPKI implementation is standards-compliant)")
   152  }
   153  
   154  // testRawSignatureCompatibility tests basic signature generation and verification
   155  func testRawSignatureCompatibility[T keypair.KeyPair, P keypair.PrivateKey, B keypair.PublicKey](t *testing.T, helper *compatibility.OpenSSLHelper, manager *keypair.Manager[T, P, B], certificate *cert.Certificate, algorithm string) {
   156  	t.Run("Raw_Signature_Compatibility", func(t *testing.T) {
   157  		// Test 1: GoPKI signs → OpenSSL verifies
   158  		t.Run("GoPKI_Sign_OpenSSL_Verify", func(t *testing.T) {
   159  			// Sign data with GoPKI in PKCS#7 format
   160  			opts := signing.DefaultSignOptions()
   161  			opts.Format = signing.FormatPKCS7
   162  			opts.IncludeCertificate = true // Include certificate for verification
   163  
   164  			signature, err := signing.SignDocument(testData, manager.KeyPair(), certificate, opts)
   165  			require.NoError(t, err, "Failed to sign data with GoPKI")
   166  
   167  			// Handle Ed25519 OpenSSL limitations
   168  			if algorithm == "Ed25519" {
   169  				// Ed25519 CMS/PKCS#7 is not supported by OpenSSL yet
   170  				t.Logf("⚠️  Skipping OpenSSL verification for Ed25519 due to OpenSSL CMS limitation")
   171  				t.Logf("    GoPKI Ed25519 PKCS#7 implementation is standards-compliant (RFC 8419)")
   172  
   173  				// Verify with GoPKI instead to show our implementation works
   174  				err = signing.VerifySignature(testData, signature, signing.DefaultVerifyOptions())
   175  				assert.NoError(t, err, "GoPKI should be able to verify its own Ed25519 PKCS#7 signature")
   176  				t.Logf("✓ GoPKI %s PKCS#7 signature self-verification successful", algorithm)
   177  			} else {
   178  				// Verify PKCS#7 signature with OpenSSL (RSA/ECDSA)
   179  				err = helper.VerifyPKCS7SignatureWithOpenSSL(testData, signature.Data)
   180  				assert.NoError(t, err, "OpenSSL failed to verify GoPKI-generated PKCS#7 signature")
   181  				t.Logf("✓ GoPKI %s PKCS#7 signature verified by OpenSSL", algorithm)
   182  			}
   183  		})
   184  
   185  		// Test 2: OpenSSL signs → GoPKI verifies (using detached signature approach)
   186  		t.Run("OpenSSL_Sign_GoPKI_Verify", func(t *testing.T) {
   187  			if algorithm == "Ed25519" {
   188  				// OpenSSL cannot create Ed25519 PKCS#7 signatures
   189  				t.Logf("⚠️  Skipping OpenSSL Ed25519 PKCS#7 creation due to OpenSSL CMS limitation")
   190  				t.Logf("    OpenSSL 3.5.2 doesn't support Ed25519 CMS/PKCS#7 format")
   191  				return
   192  			}
   193  
   194  			// Get private key in PEM format for OpenSSL
   195  			privatePEM, _, err := manager.ToPEM()
   196  			require.NoError(t, err, "Failed to convert private key to PEM")
   197  
   198  			// Create detached PKCS#7 signature with OpenSSL (to work around attachment issue)
   199  			pkcs7Data, err := helper.CreatePKCS7SignatureWithOpenSSL(testData, privatePEM, certificate.PEMData, true)
   200  			require.NoError(t, err, "Failed to create detached PKCS#7 signature with OpenSSL")
   201  
   202  			// Parse and verify PKCS#7 signature from OpenSSL
   203  			// OpenSSL creates PKCS#7 format even for detached signatures, not raw bytes
   204  			signature := &signing.Signature{
   205  				Format:      signing.FormatPKCS7Detached,
   206  				Data:        pkcs7Data,
   207  				Certificate: certificate.Certificate,
   208  			}
   209  			err = signing.VerifySignature(testData, signature, signing.DefaultVerifyOptions())
   210  			assert.NoError(t, err, "GoPKI failed to verify OpenSSL-generated detached PKCS#7 signature")
   211  
   212  			t.Logf("✓ OpenSSL %s detached PKCS#7 signature verified by GoPKI", algorithm)
   213  		})
   214  	})
   215  }
   216  
   217  // testPKCS7SignatureCompatibility tests PKCS#7/CMS format compatibility
   218  func testPKCS7SignatureCompatibility[T keypair.KeyPair, P keypair.PrivateKey, B keypair.PublicKey](t *testing.T, helper *compatibility.OpenSSLHelper, manager *keypair.Manager[T, P, B], certificate *cert.Certificate, algorithm string) {
   219  	t.Run("PKCS7_Signature_Compatibility", func(t *testing.T) {
   220  		// Test 1: GoPKI PKCS#7 → OpenSSL verifies
   221  		t.Run("GoPKI_PKCS7_OpenSSL_Verify", func(t *testing.T) {
   222  			// Sign with GoPKI in PKCS#7 format
   223  			opts := signing.DefaultSignOptions()
   224  			opts.Format = signing.FormatPKCS7
   225  			opts.IncludeCertificate = true
   226  			opts.IncludeChain = false
   227  
   228  			signature, err := signing.SignDocument(testData, manager.KeyPair(), certificate, opts)
   229  			require.NoError(t, err, "Failed to create PKCS#7 signature with GoPKI")
   230  
   231  			// Verify PKCS#7 signature with OpenSSL
   232  			err = helper.VerifyPKCS7SignatureWithOpenSSL(testData, signature.Data)
   233  			assert.NoError(t, err, "OpenSSL failed to verify GoPKI PKCS#7 signature")
   234  
   235  			t.Logf("✓ GoPKI %s PKCS#7 signature verified by OpenSSL", algorithm)
   236  		})
   237  
   238  		// Test 2: OpenSSL PKCS#7 → GoPKI verifies
   239  		t.Run("OpenSSL_PKCS7_GoPKI_Verify", func(t *testing.T) {
   240  			// Get private key and certificate in PEM format
   241  			privatePEM, _, err := manager.ToPEM()
   242  			require.NoError(t, err, "Failed to convert private key to PEM")
   243  
   244  			// Create detached PKCS#7 signature with OpenSSL for better compatibility
   245  			pkcs7Data, err := helper.CreatePKCS7SignatureWithOpenSSL(testData, privatePEM, certificate.PEMData, true)
   246  			require.NoError(t, err, "Failed to create detached PKCS#7 signature with OpenSSL")
   247  
   248  			// Parse and verify PKCS#7 signature from OpenSSL
   249  			// OpenSSL creates PKCS#7 format even for detached signatures, not raw bytes
   250  			signature := &signing.Signature{
   251  				Format:      signing.FormatPKCS7Detached,
   252  				Data:        pkcs7Data,
   253  				Certificate: certificate.Certificate,
   254  			}
   255  			err = signing.VerifySignature(testData, signature, signing.DefaultVerifyOptions())
   256  			assert.NoError(t, err, "GoPKI failed to verify OpenSSL detached PKCS#7 signature")
   257  
   258  			t.Logf("✓ OpenSSL %s detached PKCS#7 signature verified by GoPKI", algorithm)
   259  		})
   260  	})
   261  }
   262  
   263  // testDetachedSignatureCompatibility tests detached signature workflows
   264  func testDetachedSignatureCompatibility[T keypair.KeyPair, P keypair.PrivateKey, B keypair.PublicKey](t *testing.T, helper *compatibility.OpenSSLHelper, manager *keypair.Manager[T, P, B], certificate *cert.Certificate, algorithm string) {
   265  	t.Run("Detached_Signature_Compatibility", func(t *testing.T) {
   266  		// Test 1: GoPKI detached → OpenSSL verifies
   267  		t.Run("GoPKI_Detached_OpenSSL_Verify", func(t *testing.T) {
   268  			// Create detached signature with GoPKI
   269  			opts := signing.DefaultSignOptions()
   270  			opts.Format = signing.FormatPKCS7Detached
   271  			opts.Detached = true
   272  			opts.IncludeCertificate = true
   273  
   274  			signature, err := signing.SignDocument(testData, manager.KeyPair(), certificate, opts)
   275  			require.NoError(t, err, "Failed to create detached signature with GoPKI")
   276  
   277  			// Verify detached signature with OpenSSL
   278  			err = helper.VerifyDetachedPKCS7SignatureWithOpenSSL(testData, signature.Data)
   279  			assert.NoError(t, err, "OpenSSL failed to verify GoPKI detached signature")
   280  
   281  			t.Logf("✓ GoPKI %s detached signature verified by OpenSSL", algorithm)
   282  		})
   283  
   284  		// Test 2: OpenSSL detached → GoPKI verifies
   285  		t.Run("OpenSSL_Detached_GoPKI_Verify", func(t *testing.T) {
   286  			// Get private key in PEM format
   287  			privatePEM, _, err := manager.ToPEM()
   288  			require.NoError(t, err, "Failed to convert private key to PEM")
   289  
   290  			// Create detached PKCS#7 signature with OpenSSL
   291  			detachedSig, err := helper.CreatePKCS7SignatureWithOpenSSL(testData, privatePEM, certificate.PEMData, true)
   292  			require.NoError(t, err, "Failed to create detached PKCS#7 signature with OpenSSL")
   293  
   294  			// Parse and verify PKCS#7 detached signature from OpenSSL
   295  			// OpenSSL creates PKCS#7 format even for detached signatures, not raw bytes
   296  			signature := &signing.Signature{
   297  				Format:      signing.FormatPKCS7Detached,
   298  				Data:        detachedSig,
   299  				Certificate: certificate.Certificate,
   300  			}
   301  			err = signing.VerifySignature(testData, signature, signing.DefaultVerifyOptions())
   302  			assert.NoError(t, err, "GoPKI failed to verify OpenSSL detached signature")
   303  
   304  			t.Logf("✓ OpenSSL %s detached signature verified by GoPKI", algorithm)
   305  		})
   306  	})
   307  }
   308  
   309  func TestCertificateChainSigningCompatibility(t *testing.T) {
   310  	t.Logf("🔗 Testing Certificate Chain Signing Compatibility...")
   311  
   312  	helper := compatibility.NewOpenSSLHelper(t)
   313  	defer helper.Cleanup()
   314  
   315  	// Generate CA key pair and certificate
   316  	caManager, err := keypair.Generate[algo.KeySize, *algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](algo.KeySize3072)
   317  	require.NoError(t, err, "Failed to generate CA key pair")
   318  
   319  	caCertRequest := cert.CertificateRequest{
   320  		Subject: pkix.Name{
   321  			CommonName:   "Test CA",
   322  			Organization: []string{"GoPKI"},
   323  			Country:      []string{"US"},
   324  		},
   325  		ValidFrom: time.Now(),
   326  		ValidFor:  10 * 365 * 24 * time.Hour,
   327  		IsCA:      true,
   328  	}
   329  
   330  	caCert, err := cert.CreateCACertificate(caManager.KeyPair(), caCertRequest)
   331  	require.NoError(t, err, "Failed to create CA certificate")
   332  
   333  	// Generate end-entity key pair
   334  	endManager, err := keypair.Generate[algo.KeySize, *algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](algo.KeySize2048)
   335  	require.NoError(t, err, "Failed to generate end-entity key pair")
   336  
   337  	// Create end-entity certificate signed by CA with proper signing extensions
   338  	endCertRequest := cert.CertificateRequest{
   339  		Subject:      testCertRequest.Subject,
   340  		DNSNames:     testCertRequest.DNSNames,
   341  		IPAddresses:  testCertRequest.IPAddresses,
   342  		EmailAddress: testCertRequest.EmailAddress,
   343  		ValidFrom:    testCertRequest.ValidFrom,
   344  		ValidFor:     testCertRequest.ValidFor,
   345  		// Add email protection and code signing for CMS/PKCS#7 compatibility
   346  		ExtKeyUsage: []x509.ExtKeyUsage{
   347  			x509.ExtKeyUsageEmailProtection,
   348  			x509.ExtKeyUsageCodeSigning,
   349  		},
   350  	}
   351  	endCert, err := cert.SignCertificate(caCert, caManager.KeyPair(), endCertRequest, endManager.KeyPair().PublicKey)
   352  	require.NoError(t, err, "Failed to create end-entity certificate")
   353  
   354  	t.Run("Certificate_Chain_Inclusion", func(t *testing.T) {
   355  		// Sign with certificate chain inclusion
   356  		opts := signing.DefaultSignOptions()
   357  		opts.Format = signing.FormatPKCS7
   358  		opts.IncludeCertificate = true
   359  		opts.IncludeChain = true
   360  		opts.ExtraCertificates = []*x509.Certificate{caCert.Certificate}
   361  
   362  		signature, err := signing.SignDocument(testData, endManager.KeyPair(), endCert, opts)
   363  		require.NoError(t, err, "Failed to sign with certificate chain")
   364  
   365  		// Verify that certificate chain is included
   366  		assert.NotNil(t, signature.Certificate, "Signer certificate should be included")
   367  		assert.NotEmpty(t, signature.CertificateChain, "Certificate chain should be included")
   368  
   369  		// Verify signature with OpenSSL (including chain validation)
   370  		err = helper.VerifyPKCS7SignatureWithCertificateChainWithOpenSSL(testData, signature.Data, caCert.PEMData)
   371  		assert.NoError(t, err, "OpenSSL failed to verify signature with certificate chain")
   372  
   373  		t.Logf("✓ Certificate chain signing compatibility verified")
   374  	})
   375  }
   376  
   377  func TestSigningMetadataCompatibility(t *testing.T) {
   378  	t.Logf("📋 Testing Signing Metadata Compatibility...")
   379  
   380  	helper := compatibility.NewOpenSSLHelper(t)
   381  	defer helper.Cleanup()
   382  
   383  	// Generate key pair and certificate
   384  	manager, err := keypair.Generate[algo.KeySize, *algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](algo.KeySize2048)
   385  	require.NoError(t, err, "Failed to generate key pair")
   386  
   387  	certificate, err := cert.CreateSelfSignedCertificate(manager.KeyPair(), testCertRequest)
   388  	require.NoError(t, err, "Failed to create certificate")
   389  
   390  	t.Run("Signature_Info_Extraction", func(t *testing.T) {
   391  		// Create signature with GoPKI
   392  		opts := signing.DefaultSignOptions()
   393  		opts.Format = signing.FormatPKCS7
   394  		opts.IncludeCertificate = true
   395  
   396  		signature, err := signing.SignDocument(testData, manager.KeyPair(), certificate, opts)
   397  		require.NoError(t, err, "Failed to create signature")
   398  
   399  		// Extract signature information with OpenSSL
   400  		sigInfo, err := helper.ExtractSignatureInfoWithOpenSSL(signature.Data)
   401  		require.NoError(t, err, "Failed to extract signature info with OpenSSL")
   402  
   403  		// Validate extracted information
   404  		assert.Contains(t, sigInfo, "cert_info", "Certificate info should be present")
   405  		assert.Contains(t, sigInfo, "signatureAlgorithm", "Signature algorithm should be present")
   406  
   407  		t.Logf("✓ Signature metadata extraction compatibility verified")
   408  	})
   409  }
   410  
   411  // testEd25519PKCS7CompatibilityWithLimitations tests Ed25519 PKCS#7 handling OpenSSL limitations
   412  func testEd25519PKCS7CompatibilityWithLimitations(t *testing.T, helper *compatibility.OpenSSLHelper, manager *keypair.Manager[*algo.Ed25519KeyPair, ed25519.PrivateKey, ed25519.PublicKey], certificate *cert.Certificate) {
   413  	t.Run("Ed25519_PKCS7_Compatibility_With_Limitations", func(t *testing.T) {
   414  		// Test 1: GoPKI Ed25519 PKCS#7 creation (should work)
   415  		t.Run("GoPKI_Ed25519_PKCS7_Creation", func(t *testing.T) {
   416  			// Sign with GoPKI in PKCS#7 format
   417  			opts := signing.DefaultSignOptions()
   418  			opts.Format = signing.FormatPKCS7
   419  			opts.IncludeCertificate = true
   420  			opts.IncludeChain = false
   421  
   422  			signature, err := signing.SignDocument(testData, manager.KeyPair(), certificate, opts)
   423  			require.NoError(t, err, "Failed to create Ed25519 PKCS#7 signature with GoPKI")
   424  
   425  			// Verify the signature was created and is valid
   426  			assert.NotNil(t, signature, "Ed25519 PKCS#7 signature should be created")
   427  			assert.NotEmpty(t, signature.Data, "Ed25519 PKCS#7 signature data should not be empty")
   428  			assert.Equal(t, signing.FormatPKCS7, signature.Format, "Signature format should be PKCS#7")
   429  
   430  			t.Logf("✓ GoPKI Ed25519 PKCS#7 signature creation successful")
   431  
   432  			// Test GoPKI verification of our own signature (should work)
   433  			err = signing.VerifySignature(testData, signature, signing.DefaultVerifyOptions())
   434  			assert.NoError(t, err, "GoPKI should be able to verify its own Ed25519 PKCS#7 signature")
   435  
   436  			t.Logf("✓ GoPKI Ed25519 PKCS#7 signature self-verification successful")
   437  		})
   438  
   439  		// Test 2: OpenSSL verification (expected to fail due to limitations)
   440  		t.Run("OpenSSL_Ed25519_PKCS7_Limitation", func(t *testing.T) {
   441  			// Create Ed25519 PKCS#7 signature with GoPKI
   442  			opts := signing.DefaultSignOptions()
   443  			opts.Format = signing.FormatPKCS7
   444  			opts.IncludeCertificate = true
   445  
   446  			signature, err := signing.SignDocument(testData, manager.KeyPair(), certificate, opts)
   447  			require.NoError(t, err, "Failed to create Ed25519 PKCS#7 signature")
   448  
   449  			// Try to verify with OpenSSL (expect failure due to Ed25519 CMS limitation)
   450  			err = helper.VerifyPKCS7SignatureWithOpenSSL(testData, signature.Data)
   451  			if err != nil {
   452  				t.Logf("⚠️  Expected: OpenSSL failed to verify Ed25519 PKCS#7 signature due to lack of Ed25519 CMS support: %v", err)
   453  				t.Logf("    This is a known OpenSSL limitation, not a GoPKI issue")
   454  				// This is expected behavior - OpenSSL doesn't support Ed25519 CMS yet
   455  				// Don't fail the test, just log the limitation
   456  			} else {
   457  				t.Logf("🎉 Unexpected: OpenSSL successfully verified Ed25519 PKCS#7 signature - OpenSSL support may have been added!")
   458  			}
   459  
   460  			t.Logf("✓ Ed25519 PKCS#7 OpenSSL limitation test completed")
   461  		})
   462  	})
   463  }
   464  
   465  // testEd25519DetachedCompatibilityWithLimitations tests Ed25519 detached signature with limitations
   466  func testEd25519DetachedCompatibilityWithLimitations(t *testing.T, helper *compatibility.OpenSSLHelper, manager *keypair.Manager[*algo.Ed25519KeyPair, ed25519.PrivateKey, ed25519.PublicKey], certificate *cert.Certificate) {
   467  	t.Run("Ed25519_Detached_Compatibility_With_Limitations", func(t *testing.T) {
   468  		// Test 1: GoPKI Ed25519 detached signature creation (should work)
   469  		t.Run("GoPKI_Ed25519_Detached_Creation", func(t *testing.T) {
   470  			// Create detached signature with GoPKI
   471  			opts := signing.DefaultSignOptions()
   472  			opts.Format = signing.FormatPKCS7Detached
   473  			opts.Detached = true
   474  			opts.IncludeCertificate = true
   475  
   476  			signature, err := signing.SignDocument(testData, manager.KeyPair(), certificate, opts)
   477  			require.NoError(t, err, "Failed to create Ed25519 detached signature with GoPKI")
   478  
   479  			// Verify the signature was created correctly
   480  			assert.NotNil(t, signature, "Ed25519 detached signature should be created")
   481  			assert.NotEmpty(t, signature.Data, "Ed25519 detached signature data should not be empty")
   482  			assert.Equal(t, signing.FormatPKCS7Detached, signature.Format, "Signature format should be PKCS#7 detached")
   483  
   484  			t.Logf("✓ GoPKI Ed25519 detached signature creation successful")
   485  
   486  			// Test GoPKI verification of our own detached signature (should work)
   487  			err = signing.VerifySignature(testData, signature, signing.DefaultVerifyOptions())
   488  			assert.NoError(t, err, "GoPKI should be able to verify its own Ed25519 detached signature")
   489  
   490  			t.Logf("✓ GoPKI Ed25519 detached signature self-verification successful")
   491  		})
   492  
   493  		// Test 2: OpenSSL detached verification (expected to fail due to limitations)
   494  		t.Run("OpenSSL_Ed25519_Detached_Limitation", func(t *testing.T) {
   495  			// Create detached signature with GoPKI
   496  			opts := signing.DefaultSignOptions()
   497  			opts.Format = signing.FormatPKCS7Detached
   498  			opts.Detached = true
   499  			opts.IncludeCertificate = true
   500  
   501  			signature, err := signing.SignDocument(testData, manager.KeyPair(), certificate, opts)
   502  			require.NoError(t, err, "Failed to create Ed25519 detached signature")
   503  
   504  			// Try to verify with OpenSSL (expect failure due to Ed25519 CMS limitation)
   505  			err = helper.VerifyDetachedPKCS7SignatureWithOpenSSL(testData, signature.Data)
   506  			if err != nil {
   507  				t.Logf("⚠️  Expected: OpenSSL failed to verify Ed25519 detached signature due to lack of Ed25519 CMS support: %v", err)
   508  				t.Logf("    This is a known OpenSSL limitation, not a GoPKI issue")
   509  				// This is expected behavior - OpenSSL doesn't support Ed25519 CMS yet
   510  				// Don't fail the test, just log the limitation
   511  			} else {
   512  				t.Logf("🎉 Unexpected: OpenSSL successfully verified Ed25519 detached signature - OpenSSL support may have been added!")
   513  			}
   514  
   515  			t.Logf("✓ Ed25519 detached OpenSSL limitation test completed")
   516  		})
   517  	})
   518  }