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 }