github.com/jasoet/gopki@v1.15.0/internal/crypto/ed25519_pkcs7_test.go (about) 1 package crypto 2 3 import ( 4 "crypto/ed25519" 5 "crypto/rand" 6 "crypto/x509" 7 "crypto/x509/pkix" 8 "math/big" 9 "testing" 10 "time" 11 ) 12 13 func TestCreateEd25519PKCS7Signature(t *testing.T) { 14 // Generate test key pair 15 publicKey, privateKey, err := ed25519.GenerateKey(rand.Reader) 16 if err != nil { 17 t.Fatalf("Failed to generate Ed25519 key pair: %v", err) 18 } 19 20 // Create test certificate 21 template := &x509.Certificate{ 22 SerialNumber: big.NewInt(1), 23 Subject: pkix.Name{ 24 CommonName: "Ed25519 Test Certificate", 25 }, 26 NotBefore: time.Now(), 27 NotAfter: time.Now().Add(365 * 24 * time.Hour), 28 KeyUsage: x509.KeyUsageDigitalSignature, 29 ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageCodeSigning}, 30 BasicConstraintsValid: true, 31 } 32 33 certDER, err := x509.CreateCertificate(rand.Reader, template, template, publicKey, privateKey) 34 if err != nil { 35 t.Fatalf("Failed to create certificate: %v", err) 36 } 37 38 cert, err := x509.ParseCertificate(certDER) 39 if err != nil { 40 t.Fatalf("Failed to parse certificate: %v", err) 41 } 42 43 testData := []byte("Hello, Ed25519 PKCS#7 World!") 44 45 t.Run("Attached Signature", func(t *testing.T) { 46 pkcs7Data, err := CreateEd25519PKCS7Signature(testData, privateKey, cert, false) 47 if err != nil { 48 t.Fatalf("Failed to create attached PKCS#7 signature: %v", err) 49 } 50 51 if len(pkcs7Data) == 0 { 52 t.Fatal("PKCS#7 signature data is empty") 53 } 54 55 t.Logf("Attached PKCS#7 signature created: %d bytes", len(pkcs7Data)) 56 57 // Verify the signature 58 info, err := VerifyEd25519PKCS7Signature(testData, pkcs7Data) 59 if err != nil { 60 t.Fatalf("Failed to verify attached signature: %v", err) 61 } 62 63 if !info.Verified { 64 t.Fatal("Signature verification failed") 65 } 66 67 if info.Certificate.SerialNumber.Cmp(cert.SerialNumber) != 0 { 68 t.Error("Certificate serial number mismatch") 69 } 70 71 t.Logf("Attached PKCS#7 signature verified successfully") 72 }) 73 74 t.Run("Detached Signature", func(t *testing.T) { 75 pkcs7Data, err := CreateEd25519PKCS7Signature(testData, privateKey, cert, true) 76 if err != nil { 77 t.Fatalf("Failed to create detached PKCS#7 signature: %v", err) 78 } 79 80 if len(pkcs7Data) == 0 { 81 t.Fatal("PKCS#7 signature data is empty") 82 } 83 84 t.Logf("Detached PKCS#7 signature created: %d bytes", len(pkcs7Data)) 85 86 // Verify the signature 87 info, err := VerifyEd25519PKCS7Signature(testData, pkcs7Data) 88 if err != nil { 89 t.Fatalf("Failed to verify detached signature: %v", err) 90 } 91 92 if !info.Verified { 93 t.Fatal("Signature verification failed") 94 } 95 96 t.Logf("Detached PKCS#7 signature verified successfully") 97 }) 98 99 t.Run("Large Data", func(t *testing.T) { 100 // Test with larger data 101 largeData := make([]byte, 10240) // 10KB 102 for i := range largeData { 103 largeData[i] = byte(i % 256) 104 } 105 106 pkcs7Data, err := CreateEd25519PKCS7Signature(largeData, privateKey, cert, true) 107 if err != nil { 108 t.Fatalf("Failed to create PKCS#7 signature for large data: %v", err) 109 } 110 111 info, err := VerifyEd25519PKCS7Signature(largeData, pkcs7Data) 112 if err != nil { 113 t.Fatalf("Failed to verify large data signature: %v", err) 114 } 115 116 if !info.Verified { 117 t.Fatal("Large data signature verification failed") 118 } 119 120 t.Logf("Large data PKCS#7 signature verified successfully") 121 }) 122 } 123 124 func TestVerifyEd25519PKCS7Signature(t *testing.T) { 125 // Generate test key pair 126 publicKey, privateKey, err := ed25519.GenerateKey(rand.Reader) 127 if err != nil { 128 t.Fatalf("Failed to generate Ed25519 key pair: %v", err) 129 } 130 131 // Create test certificate 132 template := &x509.Certificate{ 133 SerialNumber: big.NewInt(2), 134 Subject: pkix.Name{ 135 CommonName: "Ed25519 Verify Test", 136 }, 137 NotBefore: time.Now(), 138 NotAfter: time.Now().Add(365 * 24 * time.Hour), 139 KeyUsage: x509.KeyUsageDigitalSignature, 140 BasicConstraintsValid: true, 141 } 142 143 certDER, err := x509.CreateCertificate(rand.Reader, template, template, publicKey, privateKey) 144 if err != nil { 145 t.Fatalf("Failed to create certificate: %v", err) 146 } 147 148 cert, err := x509.ParseCertificate(certDER) 149 if err != nil { 150 t.Fatalf("Failed to parse certificate: %v", err) 151 } 152 153 testData := []byte("Verification test data") 154 155 t.Run("Valid Signature", func(t *testing.T) { 156 // Create signature 157 pkcs7Data, err := CreateEd25519PKCS7Signature(testData, privateKey, cert, true) 158 if err != nil { 159 t.Fatalf("Failed to create signature: %v", err) 160 } 161 162 // Verify signature 163 info, err := VerifyEd25519PKCS7Signature(testData, pkcs7Data) 164 if err != nil { 165 t.Fatalf("Verification failed: %v", err) 166 } 167 168 if !info.Verified { 169 t.Fatal("Signature should be valid") 170 } 171 172 if info.Certificate == nil { 173 t.Fatal("Certificate should be present") 174 } 175 176 if len(info.Signature) != ed25519.SignatureSize { 177 t.Errorf("Expected signature size %d, got %d", ed25519.SignatureSize, len(info.Signature)) 178 } 179 180 t.Logf("Valid signature verified successfully") 181 }) 182 183 t.Run("Tampered Data", func(t *testing.T) { 184 // Create signature 185 pkcs7Data, err := CreateEd25519PKCS7Signature(testData, privateKey, cert, true) 186 if err != nil { 187 t.Fatalf("Failed to create signature: %v", err) 188 } 189 190 // Tamper with the data 191 tamperedData := append([]byte(nil), testData...) 192 tamperedData[0] ^= 0x01 193 194 // Verify should fail 195 _, err = VerifyEd25519PKCS7Signature(tamperedData, pkcs7Data) 196 if err == nil { 197 t.Fatal("Should have failed with tampered data") 198 } 199 200 t.Logf("Correctly detected tampered data: %v", err) 201 }) 202 } 203 204 func TestIsEd25519PKCS7(t *testing.T) { 205 // Generate test key pair 206 publicKey, privateKey, err := ed25519.GenerateKey(rand.Reader) 207 if err != nil { 208 t.Fatalf("Failed to generate Ed25519 key pair: %v", err) 209 } 210 211 // Create test certificate 212 template := &x509.Certificate{ 213 SerialNumber: big.NewInt(3), 214 Subject: pkix.Name{ 215 CommonName: "Ed25519 Detection Test", 216 }, 217 NotBefore: time.Now(), 218 NotAfter: time.Now().Add(365 * 24 * time.Hour), 219 KeyUsage: x509.KeyUsageDigitalSignature, 220 BasicConstraintsValid: true, 221 } 222 223 certDER, err := x509.CreateCertificate(rand.Reader, template, template, publicKey, privateKey) 224 if err != nil { 225 t.Fatalf("Failed to create certificate: %v", err) 226 } 227 228 cert, err := x509.ParseCertificate(certDER) 229 if err != nil { 230 t.Fatalf("Failed to parse certificate: %v", err) 231 } 232 233 testData := []byte("Detection test data") 234 235 t.Run("Ed25519 PKCS#7", func(t *testing.T) { 236 pkcs7Data, err := CreateEd25519PKCS7Signature(testData, privateKey, cert, true) 237 if err != nil { 238 t.Fatalf("Failed to create signature: %v", err) 239 } 240 241 isEd25519, err := IsEd25519PKCS7(pkcs7Data) 242 if err != nil { 243 t.Fatalf("Detection failed: %v", err) 244 } 245 246 if !isEd25519 { 247 t.Fatal("Should detect Ed25519 PKCS#7 format") 248 } 249 250 t.Logf("Ed25519 PKCS#7 detected correctly") 251 }) 252 253 t.Run("Non-PKCS#7 Data", func(t *testing.T) { 254 nonPKCS7Data := []byte("This is not PKCS#7 data") 255 256 isEd25519, err := IsEd25519PKCS7(nonPKCS7Data) 257 if err == nil { 258 t.Fatal("Should fail for non-PKCS#7 data") 259 } 260 261 if isEd25519 { 262 t.Fatal("Should not detect Ed25519 in non-PKCS#7 data") 263 } 264 265 t.Logf("Correctly rejected non-PKCS#7 data") 266 }) 267 } 268 269 func TestValidateEd25519PKCS7Structure(t *testing.T) { 270 // Generate test key pair 271 publicKey, privateKey, err := ed25519.GenerateKey(rand.Reader) 272 if err != nil { 273 t.Fatalf("Failed to generate Ed25519 key pair: %v", err) 274 } 275 276 // Create test certificate 277 template := &x509.Certificate{ 278 SerialNumber: big.NewInt(4), 279 Subject: pkix.Name{ 280 CommonName: "Ed25519 Validation Test", 281 }, 282 NotBefore: time.Now(), 283 NotAfter: time.Now().Add(365 * 24 * time.Hour), 284 KeyUsage: x509.KeyUsageDigitalSignature, 285 BasicConstraintsValid: true, 286 } 287 288 certDER, err := x509.CreateCertificate(rand.Reader, template, template, publicKey, privateKey) 289 if err != nil { 290 t.Fatalf("Failed to create certificate: %v", err) 291 } 292 293 cert, err := x509.ParseCertificate(certDER) 294 if err != nil { 295 t.Fatalf("Failed to parse certificate: %v", err) 296 } 297 298 testData := []byte("Structure validation test") 299 300 t.Run("Valid Structure", func(t *testing.T) { 301 pkcs7Data, err := CreateEd25519PKCS7Signature(testData, privateKey, cert, true) 302 if err != nil { 303 t.Fatalf("Failed to create signature: %v", err) 304 } 305 306 err = ValidateEd25519PKCS7Structure(pkcs7Data) 307 if err != nil { 308 t.Fatalf("Structure validation failed: %v", err) 309 } 310 311 t.Logf("Structure validation passed") 312 }) 313 314 t.Run("Invalid Data", func(t *testing.T) { 315 invalidData := []byte("Invalid PKCS#7 structure") 316 317 err := ValidateEd25519PKCS7Structure(invalidData) 318 if err == nil { 319 t.Fatal("Should fail for invalid structure") 320 } 321 322 t.Logf("Correctly rejected invalid structure: %v", err) 323 }) 324 } 325 326 func TestEd25519PKCS7ErrorHandling(t *testing.T) { 327 t.Run("Invalid Private Key Size", func(t *testing.T) { 328 invalidKey := make([]byte, 10) // Wrong size 329 cert := &x509.Certificate{SerialNumber: big.NewInt(1)} 330 data := []byte("test") 331 332 _, err := CreateEd25519PKCS7Signature(data, invalidKey, cert, true) 333 if err == nil { 334 t.Fatal("Should fail for invalid private key size") 335 } 336 337 t.Logf("Correctly rejected invalid key size: %v", err) 338 }) 339 340 t.Run("Nil Certificate", func(t *testing.T) { 341 _, privateKey, err := ed25519.GenerateKey(rand.Reader) 342 if err != nil { 343 t.Fatalf("Failed to generate key pair: %v", err) 344 } 345 346 data := []byte("test") 347 348 _, err = CreateEd25519PKCS7Signature(data, privateKey, nil, true) 349 if err == nil { 350 t.Fatal("Should fail for nil certificate") 351 } 352 353 t.Logf("Correctly rejected nil certificate: %v", err) 354 }) 355 356 t.Run("Invalid PKCS#7 Data", func(t *testing.T) { 357 invalidData := []byte("Invalid PKCS#7 data") 358 testData := []byte("test") 359 360 _, err := VerifyEd25519PKCS7Signature(testData, invalidData) 361 if err == nil { 362 t.Fatal("Should fail for invalid PKCS#7 data") 363 } 364 365 t.Logf("Correctly rejected invalid PKCS#7 data: %v", err) 366 }) 367 } 368 369 // Benchmark the Ed25519 PKCS#7 operations 370 func BenchmarkEd25519PKCS7Creation(b *testing.B) { 371 // Setup 372 publicKey, privateKey, err := ed25519.GenerateKey(rand.Reader) 373 if err != nil { 374 b.Fatalf("Failed to generate key pair: %v", err) 375 } 376 377 template := &x509.Certificate{ 378 SerialNumber: big.NewInt(1), 379 Subject: pkix.Name{ 380 CommonName: "Benchmark Test", 381 }, 382 NotBefore: time.Now(), 383 NotAfter: time.Now().Add(365 * 24 * time.Hour), 384 KeyUsage: x509.KeyUsageDigitalSignature, 385 BasicConstraintsValid: true, 386 } 387 388 certDER, err := x509.CreateCertificate(rand.Reader, template, template, publicKey, privateKey) 389 if err != nil { 390 b.Fatalf("Failed to create certificate: %v", err) 391 } 392 393 cert, err := x509.ParseCertificate(certDER) 394 if err != nil { 395 b.Fatalf("Failed to parse certificate: %v", err) 396 } 397 398 testData := []byte("Benchmark test data") 399 400 b.ResetTimer() 401 for i := 0; i < b.N; i++ { 402 _, err := CreateEd25519PKCS7Signature(testData, privateKey, cert, true) 403 if err != nil { 404 b.Fatalf("Signature creation failed: %v", err) 405 } 406 } 407 } 408 409 func BenchmarkEd25519PKCS7Verification(b *testing.B) { 410 // Setup 411 publicKey, privateKey, err := ed25519.GenerateKey(rand.Reader) 412 if err != nil { 413 b.Fatalf("Failed to generate key pair: %v", err) 414 } 415 416 template := &x509.Certificate{ 417 SerialNumber: big.NewInt(1), 418 Subject: pkix.Name{ 419 CommonName: "Benchmark Test", 420 }, 421 NotBefore: time.Now(), 422 NotAfter: time.Now().Add(365 * 24 * time.Hour), 423 KeyUsage: x509.KeyUsageDigitalSignature, 424 BasicConstraintsValid: true, 425 } 426 427 certDER, err := x509.CreateCertificate(rand.Reader, template, template, publicKey, privateKey) 428 if err != nil { 429 b.Fatalf("Failed to create certificate: %v", err) 430 } 431 432 cert, err := x509.ParseCertificate(certDER) 433 if err != nil { 434 b.Fatalf("Failed to parse certificate: %v", err) 435 } 436 437 testData := []byte("Benchmark test data") 438 pkcs7Data, err := CreateEd25519PKCS7Signature(testData, privateKey, cert, true) 439 if err != nil { 440 b.Fatalf("Failed to create signature: %v", err) 441 } 442 443 b.ResetTimer() 444 for i := 0; i < b.N; i++ { 445 _, err := VerifyEd25519PKCS7Signature(testData, pkcs7Data) 446 if err != nil { 447 b.Fatalf("Signature verification failed: %v", err) 448 } 449 } 450 }