github.com/jasoet/gopki@v1.15.0/encryption/certificate/certificate_test.go (about) 1 package certificate 2 3 import ( 4 "crypto/rand" 5 "crypto/x509" 6 "crypto/x509/pkix" 7 "math/big" 8 "testing" 9 "time" 10 11 "github.com/jasoet/gopki/cert" 12 "github.com/jasoet/gopki/encryption" 13 "github.com/jasoet/gopki/keypair/algo" 14 "github.com/stretchr/testify/assert" 15 ) 16 17 // Helper function to create test certificate 18 func createTestCertificate(t *testing.T, keyPair interface{}) *cert.Certificate { 19 template := x509.Certificate{ 20 SerialNumber: big.NewInt(1), 21 Subject: pkix.Name{ 22 CommonName: "Test Certificate", 23 Organization: []string{"Test Org"}, 24 }, 25 NotBefore: time.Now().Add(-time.Hour), 26 NotAfter: time.Now().Add(365 * 24 * time.Hour), 27 KeyUsage: x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature | x509.KeyUsageKeyAgreement, 28 ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth, x509.ExtKeyUsageClientAuth}, 29 BasicConstraintsValid: true, 30 } 31 32 var publicKey interface{} 33 var privateKey interface{} 34 35 switch kp := keyPair.(type) { 36 case *algo.RSAKeyPair: 37 publicKey = kp.PublicKey 38 privateKey = kp.PrivateKey 39 case *algo.ECDSAKeyPair: 40 publicKey = kp.PublicKey 41 privateKey = kp.PrivateKey 42 case *algo.Ed25519KeyPair: 43 publicKey = kp.PublicKey 44 privateKey = kp.PrivateKey 45 default: 46 t.Fatalf("Unsupported key pair type: %T", keyPair) 47 } 48 49 certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, publicKey, privateKey) 50 assert.NoError(t, err) 51 52 parsedCert, err := x509.ParseCertificate(certDER) 53 assert.NoError(t, err) 54 55 return &cert.Certificate{ 56 Certificate: parsedCert, 57 } 58 } 59 60 // Helper function to create expired certificate 61 func createExpiredCertificate(t *testing.T, keyPair interface{}) *cert.Certificate { 62 template := x509.Certificate{ 63 SerialNumber: big.NewInt(1), 64 Subject: pkix.Name{ 65 CommonName: "Expired Certificate", 66 }, 67 NotBefore: time.Now().Add(-48 * time.Hour), 68 NotAfter: time.Now().Add(-24 * time.Hour), // Expired 69 KeyUsage: x509.KeyUsageKeyEncipherment, 70 BasicConstraintsValid: true, 71 } 72 73 var publicKey interface{} 74 var privateKey interface{} 75 76 switch kp := keyPair.(type) { 77 case *algo.RSAKeyPair: 78 publicKey = kp.PublicKey 79 privateKey = kp.PrivateKey 80 default: 81 t.Fatalf("Unsupported key pair type: %T", keyPair) 82 } 83 84 certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, publicKey, privateKey) 85 assert.NoError(t, err) 86 87 parsedCert, err := x509.ParseCertificate(certDER) 88 assert.NoError(t, err) 89 90 return &cert.Certificate{ 91 Certificate: parsedCert, 92 } 93 } 94 95 // Helper function to create certificate without encryption key usage 96 func createNonEncryptionCertificate(t *testing.T, keyPair interface{}) *cert.Certificate { 97 template := x509.Certificate{ 98 SerialNumber: big.NewInt(1), 99 Subject: pkix.Name{ 100 CommonName: "Non-Encryption Certificate", 101 }, 102 NotBefore: time.Now().Add(-time.Hour), 103 NotAfter: time.Now().Add(365 * 24 * time.Hour), 104 KeyUsage: x509.KeyUsageDigitalSignature, // No KeyEncipherment or KeyAgreement 105 BasicConstraintsValid: true, 106 } 107 108 var publicKey interface{} 109 var privateKey interface{} 110 111 switch kp := keyPair.(type) { 112 case *algo.RSAKeyPair: 113 publicKey = kp.PublicKey 114 privateKey = kp.PrivateKey 115 default: 116 t.Fatalf("Unsupported key pair type: %T", keyPair) 117 } 118 119 certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, publicKey, privateKey) 120 assert.NoError(t, err) 121 122 parsedCert, err := x509.ParseCertificate(certDER) 123 assert.NoError(t, err) 124 125 return &cert.Certificate{ 126 Certificate: parsedCert, 127 } 128 } 129 130 func TestEncryptDocument(t *testing.T) { 131 testData := []byte("test document for encryption") 132 opts := encryption.DefaultEncryptOptions() 133 134 t.Run("RSA Certificate", func(t *testing.T) { 135 rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 136 assert.NoError(t, err) 137 138 testCert := createTestCertificate(t, rsaKeys) 139 140 encrypted, err := EncryptDocument(testData, testCert, opts) 141 assert.NoError(t, err) 142 assert.NotNil(t, encrypted) 143 assert.NotEmpty(t, encrypted.Data) 144 }) 145 146 t.Run("ECDSA Certificate", func(t *testing.T) { 147 ecdsaKeys, err := algo.GenerateECDSAKeyPair(algo.P256) 148 assert.NoError(t, err) 149 150 testCert := createTestCertificate(t, ecdsaKeys) 151 152 // ECDSA should now work for certificate encryption 153 encrypted, err := EncryptDocument(testData, testCert, opts) 154 assert.NoError(t, err) // ECDSA should work now 155 assert.NotNil(t, encrypted) 156 }) 157 158 t.Run("Ed25519 Certificate", func(t *testing.T) { 159 ed25519Keys, err := algo.GenerateEd25519KeyPair() 160 assert.NoError(t, err) 161 162 testCert := createTestCertificate(t, ed25519Keys) 163 164 // Ed25519 has partial implementation (may fail with certain key formats) 165 encrypted, err := EncryptDocument(testData, testCert, opts) 166 if err == nil { 167 // Success case 168 assert.NotNil(t, encrypted) 169 assert.Equal(t, encryption.AlgorithmX25519, encrypted.Algorithm) 170 } else { 171 // Expected failure case 172 assert.Error(t, err) 173 assert.Contains(t, err.Error(), "Ed25519 public-key-only encryption failed") 174 } 175 }) 176 177 t.Run("Nil Certificate", func(t *testing.T) { 178 encrypted, err := EncryptDocument(testData, nil, opts) 179 assert.Error(t, err) 180 assert.Nil(t, encrypted) 181 assert.Contains(t, err.Error(), "certificate is required") 182 }) 183 184 t.Run("With Certificate Metadata", func(t *testing.T) { 185 rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 186 assert.NoError(t, err) 187 188 testCert := createTestCertificate(t, rsaKeys) 189 190 opts := encryption.DefaultEncryptOptions() 191 opts.IncludeCertificate = true 192 193 encrypted, err := EncryptDocument(testData, testCert, opts) 194 assert.NoError(t, err) 195 assert.NotNil(t, encrypted) 196 assert.NotNil(t, encrypted.Metadata) 197 assert.Contains(t, encrypted.Metadata, "certificate_subject") 198 assert.Contains(t, encrypted.Metadata, "certificate_serial") 199 }) 200 } 201 202 func TestDecryptDocument(t *testing.T) { 203 testData := []byte("test document for decryption") 204 opts := encryption.DefaultEncryptOptions() 205 decryptOpts := encryption.DefaultDecryptOptions() 206 207 t.Run("RSA Round Trip", func(t *testing.T) { 208 rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 209 assert.NoError(t, err) 210 211 testCert := createTestCertificate(t, rsaKeys) 212 213 encrypted, err := EncryptDocument(testData, testCert, opts) 214 assert.NoError(t, err) 215 216 decrypted, err := DecryptDocument(encrypted, rsaKeys, decryptOpts) 217 assert.NoError(t, err) 218 assert.Equal(t, testData, decrypted) 219 }) 220 221 t.Run("ECDSA Round Trip", func(t *testing.T) { 222 ecdsaKeys, err := algo.GenerateECDSAKeyPair(algo.P256) 223 assert.NoError(t, err) 224 225 testCert := createTestCertificate(t, ecdsaKeys) 226 227 // ECDSA should now work for certificate encryption 228 encrypted, err := EncryptDocument(testData, testCert, opts) 229 assert.NoError(t, err) // ECDSA should work now 230 assert.NotNil(t, encrypted) 231 }) 232 233 t.Run("Ed25519 Round Trip", func(t *testing.T) { 234 ed25519Keys, err := algo.GenerateEd25519KeyPair() 235 assert.NoError(t, err) 236 237 testCert := createTestCertificate(t, ed25519Keys) 238 239 // Ed25519 has partial implementation (may fail with certain key formats) 240 encrypted, err := EncryptDocument(testData, testCert, opts) 241 if err == nil { 242 // Success case 243 assert.NotNil(t, encrypted) 244 assert.Equal(t, encryption.AlgorithmX25519, encrypted.Algorithm) 245 } else { 246 // Expected failure case 247 assert.Error(t, err) 248 assert.Contains(t, err.Error(), "Ed25519 public-key-only encryption failed") 249 } 250 }) 251 252 t.Run("Nil Encrypted Data", func(t *testing.T) { 253 rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 254 assert.NoError(t, err) 255 256 decrypted, err := DecryptDocument[*algo.RSAKeyPair](nil, rsaKeys, decryptOpts) 257 assert.Error(t, err) 258 assert.Nil(t, decrypted) 259 assert.Contains(t, err.Error(), "encrypted data is required") 260 }) 261 262 t.Run("Invalid Decrypt Options", func(t *testing.T) { 263 rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 264 assert.NoError(t, err) 265 266 testCert := createTestCertificate(t, rsaKeys) 267 encrypted, err := EncryptDocument(testData, testCert, opts) 268 assert.NoError(t, err) 269 270 invalidDecryptOpts := encryption.DecryptOptions{ 271 MaxAge: -time.Hour, // Invalid negative max age 272 } 273 274 decrypted, err := DecryptDocument(encrypted, rsaKeys, invalidDecryptOpts) 275 assert.Error(t, err) 276 assert.Nil(t, decrypted) 277 assert.Contains(t, err.Error(), "invalid encryption parameters") 278 }) 279 } 280 281 func TestEncryptForMultipleCertificates(t *testing.T) { 282 testData := []byte("test document for multiple recipients") 283 opts := encryption.DefaultEncryptOptions() 284 285 t.Run("Multiple RSA Certificates", func(t *testing.T) { 286 // Generate multiple key pairs 287 rsaKeys1, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 288 assert.NoError(t, err) 289 rsaKeys2, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 290 assert.NoError(t, err) 291 rsaKeys3, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 292 assert.NoError(t, err) 293 294 // Create certificates 295 cert1 := createTestCertificate(t, rsaKeys1) 296 cert2 := createTestCertificate(t, rsaKeys2) 297 cert3 := createTestCertificate(t, rsaKeys3) 298 299 certificates := []*cert.Certificate{cert1, cert2, cert3} 300 301 encrypted, err := EncryptForMultipleCertificates(testData, certificates, opts) 302 assert.NoError(t, err) 303 assert.NotNil(t, encrypted) 304 assert.NotEmpty(t, encrypted.Data) 305 assert.Len(t, encrypted.Recipients, 3) 306 }) 307 308 t.Run("Mixed Key Types", func(t *testing.T) { 309 rsaKeys1, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 310 assert.NoError(t, err) 311 rsaKeys2, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 312 assert.NoError(t, err) 313 314 cert1 := createTestCertificate(t, rsaKeys1) 315 cert2 := createTestCertificate(t, rsaKeys2) 316 317 // Only use RSA certificates since ECDSA and Ed25519 are not yet supported 318 certificates := []*cert.Certificate{cert1, cert2} 319 320 encrypted, err := EncryptForMultipleCertificates(testData, certificates, opts) 321 assert.NoError(t, err) 322 assert.NotNil(t, encrypted) 323 assert.Len(t, encrypted.Recipients, 2) 324 }) 325 326 t.Run("Empty Certificate List", func(t *testing.T) { 327 encrypted, err := EncryptForMultipleCertificates(testData, []*cert.Certificate{}, opts) 328 assert.Error(t, err) 329 assert.Nil(t, encrypted) 330 assert.Contains(t, err.Error(), "at least one certificate is required") 331 }) 332 333 t.Run("Nil Certificate in List", func(t *testing.T) { 334 rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 335 assert.NoError(t, err) 336 337 cert1 := createTestCertificate(t, rsaKeys) 338 certificates := []*cert.Certificate{cert1, nil} 339 340 encrypted, err := EncryptForMultipleCertificates(testData, certificates, opts) 341 assert.Error(t, err) 342 assert.Nil(t, encrypted) 343 assert.Contains(t, err.Error(), "certificate at index 1 is nil") 344 }) 345 346 t.Run("With Recipient Metadata", func(t *testing.T) { 347 rsaKeys1, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 348 assert.NoError(t, err) 349 rsaKeys2, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 350 assert.NoError(t, err) 351 352 cert1 := createTestCertificate(t, rsaKeys1) 353 cert2 := createTestCertificate(t, rsaKeys2) 354 355 certificates := []*cert.Certificate{cert1, cert2} 356 357 opts := encryption.DefaultEncryptOptions() 358 opts.IncludeCertificate = true 359 360 encrypted, err := EncryptForMultipleCertificates(testData, certificates, opts) 361 assert.NoError(t, err) 362 assert.NotNil(t, encrypted.Metadata) 363 assert.Contains(t, encrypted.Metadata, "recipient_subjects") 364 }) 365 } 366 367 func TestDecryptForCertificateHolder(t *testing.T) { 368 testData := []byte("test document for multiple recipients") 369 opts := encryption.DefaultEncryptOptions() 370 decryptOpts := encryption.DefaultDecryptOptions() 371 372 t.Run("Decrypt by Different Recipients", func(t *testing.T) { 373 // Generate multiple key pairs 374 rsaKeys1, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 375 assert.NoError(t, err) 376 rsaKeys2, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 377 assert.NoError(t, err) 378 rsaKeys3, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 379 assert.NoError(t, err) 380 381 // Create certificates 382 cert1 := createTestCertificate(t, rsaKeys1) 383 cert2 := createTestCertificate(t, rsaKeys2) 384 cert3 := createTestCertificate(t, rsaKeys3) 385 386 certificates := []*cert.Certificate{cert1, cert2, cert3} 387 388 encrypted, err := EncryptForMultipleCertificates(testData, certificates, opts) 389 assert.NoError(t, err) 390 391 // Each recipient should be able to decrypt 392 decrypted1, err := DecryptForCertificateHolder(encrypted, rsaKeys1, 0, decryptOpts) 393 assert.NoError(t, err) 394 assert.Equal(t, testData, decrypted1) 395 396 decrypted2, err := DecryptForCertificateHolder(encrypted, rsaKeys2, 1, decryptOpts) 397 assert.NoError(t, err) 398 assert.Equal(t, testData, decrypted2) 399 400 decrypted3, err := DecryptForCertificateHolder(encrypted, rsaKeys3, 2, decryptOpts) 401 assert.NoError(t, err) 402 assert.Equal(t, testData, decrypted3) 403 }) 404 405 t.Run("Invalid Recipient Index", func(t *testing.T) { 406 rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 407 assert.NoError(t, err) 408 409 cert := createTestCertificate(t, rsaKeys) 410 encrypted, err := EncryptDocument(testData, cert, opts) 411 assert.NoError(t, err) 412 413 // Try to decrypt with invalid index 414 decrypted, err := DecryptForCertificateHolder(encrypted, rsaKeys, 5, decryptOpts) 415 assert.Error(t, err) 416 assert.Nil(t, decrypted) 417 }) 418 419 t.Run("Nil Encrypted Data", func(t *testing.T) { 420 rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 421 assert.NoError(t, err) 422 423 decrypted, err := DecryptForCertificateHolder[*algo.RSAKeyPair](nil, rsaKeys, 0, decryptOpts) 424 assert.Error(t, err) 425 assert.Nil(t, decrypted) 426 assert.Contains(t, err.Error(), "encrypted data is required") 427 }) 428 } 429 430 func TestEncryptWithKeyUsageValidation(t *testing.T) { 431 testData := []byte("test document with validation") 432 opts := encryption.DefaultEncryptOptions() 433 434 t.Run("Valid Certificate", func(t *testing.T) { 435 rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 436 assert.NoError(t, err) 437 438 testCert := createTestCertificate(t, rsaKeys) 439 440 encrypted, err := EncryptWithKeyUsageValidation(testData, testCert, opts) 441 assert.NoError(t, err) 442 assert.NotNil(t, encrypted) 443 }) 444 445 t.Run("Expired Certificate", func(t *testing.T) { 446 rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 447 assert.NoError(t, err) 448 449 expiredCert := createExpiredCertificate(t, rsaKeys) 450 451 encrypted, err := EncryptWithKeyUsageValidation(testData, expiredCert, opts) 452 assert.Error(t, err) 453 assert.Nil(t, encrypted) 454 assert.Contains(t, err.Error(), "certificate has expired") 455 }) 456 457 t.Run("Certificate Without Encryption Key Usage", func(t *testing.T) { 458 rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 459 assert.NoError(t, err) 460 461 nonEncryptCert := createNonEncryptionCertificate(t, rsaKeys) 462 463 encrypted, err := EncryptWithKeyUsageValidation(testData, nonEncryptCert, opts) 464 assert.Error(t, err) 465 assert.Nil(t, encrypted) 466 assert.Contains(t, err.Error(), "key usage does not allow encryption") 467 }) 468 469 t.Run("Nil Certificate", func(t *testing.T) { 470 encrypted, err := EncryptWithKeyUsageValidation(testData, nil, opts) 471 assert.Error(t, err) 472 assert.Nil(t, encrypted) 473 assert.Contains(t, err.Error(), "certificate is required") 474 }) 475 476 t.Run("Not Yet Valid Certificate", func(t *testing.T) { 477 rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 478 assert.NoError(t, err) 479 480 template := x509.Certificate{ 481 SerialNumber: big.NewInt(1), 482 Subject: pkix.Name{CommonName: "Future Certificate"}, 483 NotBefore: time.Now().Add(24 * time.Hour), // Future 484 NotAfter: time.Now().Add(48 * time.Hour), 485 KeyUsage: x509.KeyUsageKeyEncipherment, 486 BasicConstraintsValid: true, 487 } 488 489 certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, 490 rsaKeys.PublicKey, rsaKeys.PrivateKey) 491 assert.NoError(t, err) 492 493 parsedCert, err := x509.ParseCertificate(certDER) 494 assert.NoError(t, err) 495 496 futureCert := &cert.Certificate{ 497 Certificate: parsedCert, 498 } 499 500 encrypted, err := EncryptWithKeyUsageValidation(testData, futureCert, opts) 501 assert.Error(t, err) 502 assert.Nil(t, encrypted) 503 assert.Contains(t, err.Error(), "certificate is not yet valid") 504 }) 505 } 506 507 func TestDecryptWithCertificateValidation(t *testing.T) { 508 testData := []byte("test document with validation") 509 opts := encryption.DefaultEncryptOptions() 510 decryptOpts := encryption.DefaultDecryptOptions() 511 512 t.Run("Valid Certificate and KeyPair", func(t *testing.T) { 513 rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 514 assert.NoError(t, err) 515 516 testCert := createTestCertificate(t, rsaKeys) 517 518 encrypted, err := EncryptDocument(testData, testCert, opts) 519 assert.NoError(t, err) 520 521 decrypted, err := DecryptWithCertificateValidation(encrypted, rsaKeys, testCert, decryptOpts) 522 assert.NoError(t, err) 523 assert.Equal(t, testData, decrypted) 524 }) 525 526 t.Run("Nil Certificate", func(t *testing.T) { 527 rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 528 assert.NoError(t, err) 529 530 testCert := createTestCertificate(t, rsaKeys) 531 encrypted, err := EncryptDocument(testData, testCert, opts) 532 assert.NoError(t, err) 533 534 decrypted, err := DecryptWithCertificateValidation(encrypted, rsaKeys, nil, decryptOpts) 535 assert.Error(t, err) 536 assert.Nil(t, decrypted) 537 assert.Contains(t, err.Error(), "certificate is required") 538 }) 539 } 540 541 func TestValidateCertificateForEncryption(t *testing.T) { 542 t.Run("Valid Certificate", func(t *testing.T) { 543 rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 544 assert.NoError(t, err) 545 546 testCert := createTestCertificate(t, rsaKeys) 547 err = validateCertificateForEncryption(testCert) 548 assert.NoError(t, err) 549 }) 550 551 t.Run("Certificate Without Key Usage", func(t *testing.T) { 552 rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 553 assert.NoError(t, err) 554 555 template := x509.Certificate{ 556 SerialNumber: big.NewInt(1), 557 Subject: pkix.Name{CommonName: "No Key Usage"}, 558 NotBefore: time.Now().Add(-time.Hour), 559 NotAfter: time.Now().Add(365 * 24 * time.Hour), 560 BasicConstraintsValid: true, 561 // KeyUsage not set (zero value) 562 } 563 564 certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, 565 rsaKeys.PublicKey, rsaKeys.PrivateKey) 566 assert.NoError(t, err) 567 568 parsedCert, err := x509.ParseCertificate(certDER) 569 assert.NoError(t, err) 570 571 cert := &cert.Certificate{ 572 Certificate: parsedCert, 573 } 574 575 // Should pass because KeyUsage is 0 (not set) 576 err = validateCertificateForEncryption(cert) 577 assert.NoError(t, err) 578 }) 579 580 t.Run("Certificate With Wrong Key Usage", func(t *testing.T) { 581 rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 582 assert.NoError(t, err) 583 584 nonEncryptCert := createNonEncryptionCertificate(t, rsaKeys) 585 err = validateCertificateForEncryption(nonEncryptCert) 586 assert.Error(t, err) 587 assert.Contains(t, err.Error(), "key usage does not allow encryption") 588 }) 589 590 t.Run("Nil Certificate", func(t *testing.T) { 591 err := validateCertificateForEncryption(nil) 592 assert.Error(t, err) 593 assert.Contains(t, err.Error(), "invalid certificate") 594 }) 595 596 t.Run("Certificate With Nil X509", func(t *testing.T) { 597 cert := &cert.Certificate{ 598 Certificate: nil, 599 } 600 err := validateCertificateForEncryption(cert) 601 assert.Error(t, err) 602 assert.Contains(t, err.Error(), "invalid certificate") 603 }) 604 } 605 606 func TestValidateCertificateForDecryption(t *testing.T) { 607 t.Run("Valid Certificate", func(t *testing.T) { 608 rsaKeys, err := algo.GenerateRSAKeyPair(algo.KeySize2048) 609 assert.NoError(t, err) 610 611 testCert := createTestCertificate(t, rsaKeys) 612 err = validateCertificateForDecryption(testCert) 613 assert.NoError(t, err) 614 }) 615 616 t.Run("Nil Certificate", func(t *testing.T) { 617 err := validateCertificateForDecryption(nil) 618 assert.Error(t, err) 619 assert.Contains(t, err.Error(), "invalid certificate") 620 }) 621 }