github.com/jasoet/gopki@v1.15.0/keypair/algo/rsa_test.go (about) 1 package algo 2 3 import ( 4 "crypto/rsa" 5 "crypto/x509" 6 "encoding/pem" 7 "fmt" 8 "github.com/jasoet/gopki/keypair/format" 9 "strings" 10 "testing" 11 12 "github.com/stretchr/testify/assert" 13 ) 14 15 func TestKeySizeConstants(t *testing.T) { 16 tests := []struct { 17 name string 18 keySize KeySize 19 expected int 20 }{ 21 {"KeySize2048", KeySize2048, 2048}, 22 {"KeySize3072", KeySize3072, 3072}, 23 {"KeySize4096", KeySize4096, 4096}, 24 } 25 26 for _, tt := range tests { 27 t.Run(tt.name, func(t *testing.T) { 28 assert.Equal(t, tt.expected, tt.keySize.Bits()) 29 }) 30 } 31 } 32 33 func TestGenerateRSAKeyPair_ValidKeySizes(t *testing.T) { 34 tests := []struct { 35 name string 36 keySize KeySize 37 }{ 38 {"KeySize2048", KeySize2048}, 39 {"KeySize3072", KeySize3072}, 40 {"KeySize4096", KeySize4096}, 41 } 42 43 for _, tt := range tests { 44 t.Run(tt.name, func(t *testing.T) { 45 keyPair, err := GenerateRSAKeyPair(tt.keySize) 46 47 assert.NoError(t, err) 48 assert.NotNil(t, keyPair) 49 if keyPair == nil { 50 t.Fatal("keyPair is nil") 51 } 52 assert.NotNil(t, keyPair.PrivateKey) 53 assert.NotNil(t, keyPair.PublicKey) 54 55 // Verify key size matches request 56 assert.Equal(t, tt.keySize.Bits(), keyPair.PrivateKey.Size()*8) 57 58 // Verify public key is derived from private key 59 assert.Equal(t, &keyPair.PrivateKey.PublicKey, keyPair.PublicKey) 60 61 // Verify key can be used for basic cryptographic operations 62 assert.NoError(t, keyPair.PrivateKey.Validate()) 63 }) 64 } 65 } 66 67 func TestGenerateRSAKeyPair_InvalidKeySizes(t *testing.T) { 68 // Note: With the new struct-based KeySize, it's impossible to create invalid key sizes 69 // at compile time. This test demonstrates that only predefined constants work. 70 // We test with a zero-value KeySize to ensure proper validation. 71 tests := []struct { 72 name string 73 keySize KeySize 74 }{ 75 {"ZeroValue", KeySize{}}, // Only way to get an invalid KeySize 76 } 77 78 for _, tt := range tests { 79 t.Run(tt.name, func(t *testing.T) { 80 keyPair, err := GenerateRSAKeyPair(tt.keySize) 81 82 assert.Error(t, err) 83 assert.Nil(t, keyPair) 84 assert.Contains(t, err.Error(), "RSA key size must be at least 2048 bits") 85 }) 86 } 87 } 88 89 func TestRSAKeyPair_PrivateKeyToPEM(t *testing.T) { 90 keyPair, err := GenerateRSAKeyPair(KeySize2048) 91 assert.NoError(t, err) 92 93 pemData, err := keyPair.PrivateKeyToPEM() 94 assert.NoError(t, err) 95 assert.NotEmpty(t, pemData) 96 97 // Verify PEM format 98 block, _ := pem.Decode(pemData) 99 assert.NotNil(t, block) 100 assert.Equal(t, "PRIVATE KEY", block.Type) 101 102 // Verify we can parse the PEM back to a private key 103 parsedKey, err := x509.ParsePKCS8PrivateKey(block.Bytes) 104 assert.NoError(t, err) 105 106 rsaKey, ok := parsedKey.(*rsa.PrivateKey) 107 assert.True(t, ok) 108 assert.Equal(t, keyPair.PrivateKey.Size(), rsaKey.Size()) 109 } 110 111 func TestRSAKeyPair_PublicKeyToPEM(t *testing.T) { 112 keyPair, err := GenerateRSAKeyPair(KeySize2048) 113 assert.NoError(t, err) 114 115 pemData, err := keyPair.PublicKeyToPEM() 116 assert.NoError(t, err) 117 assert.NotEmpty(t, pemData) 118 119 // Verify PEM format 120 block, _ := pem.Decode(pemData) 121 assert.NotNil(t, block) 122 assert.Equal(t, "PUBLIC KEY", block.Type) 123 124 // Verify we can parse the PEM back to a public key 125 parsedKey, err := x509.ParsePKIXPublicKey(block.Bytes) 126 assert.NoError(t, err) 127 128 rsaKey, ok := parsedKey.(*rsa.PublicKey) 129 assert.True(t, ok) 130 assert.Equal(t, keyPair.PublicKey.Size(), rsaKey.Size()) 131 } 132 133 func TestRSAKeyPairFromPEM_Success(t *testing.T) { 134 // Generate original key pair 135 originalKeyPair, err := GenerateRSAKeyPair(KeySize2048) 136 assert.NoError(t, err) 137 138 // Convert to PEM 139 pemData, err := originalKeyPair.PrivateKeyToPEM() 140 assert.NoError(t, err) 141 142 // Reconstruct from PEM 143 reconstructedKeyPair, err := RSAKeyPairFromPEM(pemData) 144 assert.NoError(t, err) 145 assert.NotNil(t, reconstructedKeyPair) 146 147 // Verify the keys match 148 assert.Equal(t, originalKeyPair.PrivateKey.Size(), reconstructedKeyPair.PrivateKey.Size()) 149 assert.Equal(t, originalKeyPair.PublicKey.Size(), reconstructedKeyPair.PublicKey.Size()) 150 assert.Equal(t, &reconstructedKeyPair.PrivateKey.PublicKey, reconstructedKeyPair.PublicKey) 151 } 152 153 func TestRSAKeyPairFromPEM_InvalidPEM(t *testing.T) { 154 tests := []struct { 155 name string 156 pemData []byte 157 errMsg string 158 }{ 159 { 160 name: "NotPEM", 161 pemData: []byte("not a pem file"), 162 errMsg: "failed to decode PEM block", 163 }, 164 { 165 name: "InvalidPEMContent", 166 pemData: []byte(`-----BEGIN PRIVATE KEY----- 167 invalid base64 content 168 -----END PRIVATE KEY-----`), 169 errMsg: "failed to parse private key", 170 }, 171 { 172 name: "NotRSAKey", 173 pemData: func() []byte { 174 // Create a valid PKCS8 key that's not RSA (this is a mock - in real test would use ECDSA) 175 return []byte(`-----BEGIN PRIVATE KEY----- 176 MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQg 177 -----END PRIVATE KEY-----`) 178 }(), 179 errMsg: "failed to parse private key", 180 }, 181 } 182 183 for _, tt := range tests { 184 t.Run(tt.name, func(t *testing.T) { 185 keyPair, err := RSAKeyPairFromPEM(tt.pemData) 186 187 assert.Error(t, err) 188 assert.Nil(t, keyPair) 189 assert.Contains(t, err.Error(), tt.errMsg) 190 }) 191 } 192 } 193 194 func TestRSAKeyPair_PEMRoundTrip(t *testing.T) { 195 // Test with different key sizes 196 tests := []struct { 197 name string 198 keySize KeySize 199 }{ 200 {"2048", KeySize2048}, 201 {"3072", KeySize3072}, 202 {"4096", KeySize4096}, 203 } 204 205 for _, tt := range tests { 206 t.Run(tt.name, func(t *testing.T) { 207 // Generate original key pair 208 original, err := GenerateRSAKeyPair(tt.keySize) 209 assert.NoError(t, err) 210 211 // Convert to PEM and back 212 privatePEM, err := original.PrivateKeyToPEM() 213 assert.NoError(t, err) 214 215 publicPEM, err := original.PublicKeyToPEM() 216 assert.NoError(t, err) 217 218 // Reconstruct from private key PEM 219 reconstructed, err := RSAKeyPairFromPEM(privatePEM) 220 assert.NoError(t, err) 221 222 // Verify private keys match 223 assert.Equal(t, original.PrivateKey.Size(), reconstructed.PrivateKey.Size()) 224 225 // Verify public keys match 226 assert.Equal(t, original.PublicKey.Size(), reconstructed.PublicKey.Size()) 227 228 // Verify reconstructed public key PEM matches original 229 reconstructedPublicPEM, err := reconstructed.PublicKeyToPEM() 230 assert.NoError(t, err) 231 assert.Equal(t, string(publicPEM), string(reconstructedPublicPEM)) 232 }) 233 } 234 } 235 236 func TestRSAKeyPair_PEMFormat(t *testing.T) { 237 keyPair, err := GenerateRSAKeyPair(KeySize2048) 238 assert.NoError(t, err) 239 240 // Test private key PEM format 241 privatePEM, err := keyPair.PrivateKeyToPEM() 242 assert.NoError(t, err) 243 244 privateStr := string(privatePEM) 245 assert.True(t, strings.HasPrefix(privateStr, "-----BEGIN PRIVATE KEY-----")) 246 assert.True(t, strings.HasSuffix(strings.TrimSpace(privateStr), "-----END PRIVATE KEY-----")) 247 248 // Test public key PEM format 249 publicPEM, err := keyPair.PublicKeyToPEM() 250 assert.NoError(t, err) 251 252 publicStr := string(publicPEM) 253 assert.True(t, strings.HasPrefix(publicStr, "-----BEGIN PUBLIC KEY-----")) 254 assert.True(t, strings.HasSuffix(strings.TrimSpace(publicStr), "-----END PUBLIC KEY-----")) 255 } 256 257 func TestRSAKeyPair_KeyValidation(t *testing.T) { 258 keyPair, err := GenerateRSAKeyPair(KeySize2048) 259 assert.NoError(t, err) 260 261 // Verify the private key is mathematically valid 262 err = keyPair.PrivateKey.Validate() 263 assert.NoError(t, err) 264 265 // Verify N (modulus) is the same for both keys 266 assert.Equal(t, keyPair.PrivateKey.N, keyPair.PublicKey.N) 267 268 // Verify E (public exponent) is the same for both keys 269 assert.Equal(t, keyPair.PrivateKey.E, keyPair.PublicKey.E) 270 } 271 272 func BenchmarkGenerateRSAKeyPair(b *testing.B) { 273 tests := []struct { 274 name string 275 keySize KeySize 276 }{ 277 {"2048", KeySize2048}, 278 {"3072", KeySize3072}, 279 {"4096", KeySize4096}, 280 } 281 282 for _, tt := range tests { 283 b.Run(tt.name, func(b *testing.B) { 284 for i := 0; i < b.N; i++ { 285 _, err := GenerateRSAKeyPair(tt.keySize) 286 if err != nil { 287 b.Fatalf("Key generation failed: %v", err) 288 } 289 } 290 }) 291 } 292 } 293 294 func BenchmarkRSAKeyPair_PEMOperations(b *testing.B) { 295 keyPair, err := GenerateRSAKeyPair(KeySize2048) 296 if err != nil { 297 b.Fatalf("Key generation failed: %v", err) 298 } 299 300 b.Run("PrivateKeyToPEM", func(b *testing.B) { 301 for i := 0; i < b.N; i++ { 302 _, err := keyPair.PrivateKeyToPEM() 303 if err != nil { 304 b.Fatalf("PEM conversion failed: %v", err) 305 } 306 } 307 }) 308 309 b.Run("PublicKeyToPEM", func(b *testing.B) { 310 for i := 0; i < b.N; i++ { 311 _, err := keyPair.PublicKeyToPEM() 312 if err != nil { 313 b.Fatalf("PEM conversion failed: %v", err) 314 } 315 } 316 }) 317 318 pemData, _ := keyPair.PrivateKeyToPEM() 319 b.Run("RSAKeyPairFromPEM", func(b *testing.B) { 320 for i := 0; i < b.N; i++ { 321 _, err := RSAKeyPairFromPEM(pemData) 322 if err != nil { 323 b.Fatalf("PEM reconstruction failed: %v", err) 324 } 325 } 326 }) 327 } 328 329 // DER Format Tests 330 331 func TestRSAKeyPair_PrivateKeyToDER(t *testing.T) { 332 keySizes := []KeySize{KeySize2048, KeySize3072, KeySize4096} 333 334 for _, keySize := range keySizes { 335 t.Run(fmt.Sprintf("%d-bit", keySize.Bits()), func(t *testing.T) { 336 keyPair, err := GenerateRSAKeyPair(keySize) 337 assert.NoError(t, err) 338 339 derData, err := keyPair.PrivateKeyToDER() 340 assert.NoError(t, err) 341 assert.NotEmpty(t, derData) 342 343 // Verify we can parse the DER back to a private key 344 parsedKey, err := x509.ParsePKCS8PrivateKey(derData) 345 assert.NoError(t, err) 346 347 rsaKey, ok := parsedKey.(*rsa.PrivateKey) 348 assert.True(t, ok, "Parsed key should be RSA") 349 assert.Equal(t, keyPair.PrivateKey.Size(), rsaKey.Size()) 350 351 // Verify DER is more compact than PEM 352 pemData, err := keyPair.PrivateKeyToPEM() 353 assert.NoError(t, err) 354 assert.True(t, len(derData) < len(pemData), "DER should be more compact than PEM") 355 }) 356 } 357 } 358 359 func TestRSAKeyPair_PublicKeyToDER(t *testing.T) { 360 keyPair, err := GenerateRSAKeyPair(KeySize2048) 361 assert.NoError(t, err) 362 363 derData, err := keyPair.PublicKeyToDER() 364 assert.NoError(t, err) 365 assert.NotEmpty(t, derData) 366 367 // Verify we can parse the DER back to a public key 368 parsedKey, err := x509.ParsePKIXPublicKey(derData) 369 assert.NoError(t, err) 370 371 rsaKey, ok := parsedKey.(*rsa.PublicKey) 372 assert.True(t, ok, "Parsed key should be RSA") 373 assert.Equal(t, keyPair.PublicKey.Size(), rsaKey.Size()) 374 375 // Verify DER is more compact than PEM 376 pemData, err := keyPair.PublicKeyToPEM() 377 assert.NoError(t, err) 378 assert.True(t, len(derData) < len(pemData), "DER should be more compact than PEM") 379 } 380 381 func TestRSAKeyPairFromDER_Success(t *testing.T) { 382 keySizes := []KeySize{KeySize2048, KeySize3072, KeySize4096} 383 384 for _, keySize := range keySizes { 385 t.Run(fmt.Sprintf("%d-bit", keySize.Bits()), func(t *testing.T) { 386 // Generate original key pair 387 originalKeyPair, err := GenerateRSAKeyPair(keySize) 388 assert.NoError(t, err) 389 390 // Convert to DER 391 derData, err := originalKeyPair.PrivateKeyToDER() 392 assert.NoError(t, err) 393 394 // Reconstruct from DER 395 reconstructedKeyPair, err := RSAKeyPairFromDER(derData) 396 assert.NoError(t, err) 397 assert.NotNil(t, reconstructedKeyPair) 398 399 // Verify the keys match 400 assert.Equal(t, originalKeyPair.PrivateKey.Size(), reconstructedKeyPair.PrivateKey.Size()) 401 assert.Equal(t, originalKeyPair.PublicKey.Size(), reconstructedKeyPair.PublicKey.Size()) 402 assert.Equal(t, &reconstructedKeyPair.PrivateKey.PublicKey, reconstructedKeyPair.PublicKey) 403 404 // Verify key validation 405 assert.NoError(t, reconstructedKeyPair.PrivateKey.Validate()) 406 }) 407 } 408 } 409 410 func TestRSAKeyPairFromDER_InvalidDER(t *testing.T) { 411 tests := []struct { 412 name string 413 derData []byte 414 errMsg string 415 }{ 416 { 417 name: "InvalidDERData", 418 derData: []byte("invalid der data"), 419 errMsg: "failed to parse DER private key", 420 }, 421 { 422 name: "EmptyData", 423 derData: []byte{}, 424 errMsg: "failed to parse DER private key", 425 }, 426 } 427 428 for _, tt := range tests { 429 t.Run(tt.name, func(t *testing.T) { 430 keyPair, err := RSAKeyPairFromDER(tt.derData) 431 432 assert.Error(t, err) 433 assert.Nil(t, keyPair) 434 assert.Contains(t, err.Error(), tt.errMsg) 435 }) 436 } 437 } 438 439 func TestRSAKeyPair_DERRoundTrip(t *testing.T) { 440 keySizes := []KeySize{KeySize2048, KeySize3072, KeySize4096} 441 442 for _, keySize := range keySizes { 443 t.Run(fmt.Sprintf("%d-bit", keySize.Bits()), func(t *testing.T) { 444 // Generate original key pair 445 original, err := GenerateRSAKeyPair(keySize) 446 assert.NoError(t, err) 447 448 // Convert to DER and back 449 privateDER, err := original.PrivateKeyToDER() 450 assert.NoError(t, err) 451 452 publicDER, err := original.PublicKeyToDER() 453 assert.NoError(t, err) 454 455 // Reconstruct from private key DER 456 reconstructed, err := RSAKeyPairFromDER(privateDER) 457 assert.NoError(t, err) 458 459 // Verify private keys match 460 assert.Equal(t, original.PrivateKey.Size(), reconstructed.PrivateKey.Size()) 461 462 // Verify public keys match 463 assert.Equal(t, original.PublicKey.Size(), reconstructed.PublicKey.Size()) 464 465 // Verify reconstructed public key DER matches original 466 reconstructedPublicDER, err := reconstructed.PublicKeyToDER() 467 assert.NoError(t, err) 468 assert.Equal(t, publicDER, reconstructedPublicDER) 469 }) 470 } 471 } 472 473 // SSH Format Tests 474 475 func TestRSAKeyPair_PublicKeyToSSH(t *testing.T) { 476 keySizes := []KeySize{KeySize2048, KeySize3072, KeySize4096} 477 478 for _, keySize := range keySizes { 479 t.Run(fmt.Sprintf("%d-bit", keySize.Bits()), func(t *testing.T) { 480 keyPair, err := GenerateRSAKeyPair(keySize) 481 assert.NoError(t, err) 482 483 // Test with comment 484 sshData, err := keyPair.PublicKeyToSSH("user@example.com") 485 assert.NoError(t, err) 486 assert.NotEmpty(t, sshData) 487 488 // Verify SSH format 489 assert.True(t, strings.HasPrefix(string(sshData), "ssh-rsa "), "SSH key should start with 'ssh-rsa '") 490 assert.Contains(t, string(sshData), "user@example.com", "SSH key should contain comment") 491 assert.Equal(t, 3, len(strings.Fields(string(sshData))), "SSH key should have 3 parts") 492 493 // Test without comment 494 sshDataNoComment, err := keyPair.PublicKeyToSSH("") 495 assert.NoError(t, err) 496 assert.Equal(t, 2, len(strings.Fields(string(sshDataNoComment))), "SSH key without comment should have 2 parts") 497 assert.True(t, strings.HasPrefix(string(sshDataNoComment), "ssh-rsa ")) 498 }) 499 } 500 } 501 502 func TestRSAKeyPair_PrivateKeyToSSH(t *testing.T) { 503 keyPair, err := GenerateRSAKeyPair(KeySize2048) 504 assert.NoError(t, err) 505 506 // Test unencrypted SSH private key 507 sshData, err := keyPair.PrivateKeyToSSH("test-key", "") 508 assert.NoError(t, err) 509 assert.NotEmpty(t, sshData) 510 assert.Contains(t, sshData, "-----BEGIN OPENSSH PRIVATE KEY-----") 511 assert.Contains(t, sshData, "-----END OPENSSH PRIVATE KEY-----") 512 513 // Test encrypted SSH private key 514 passphrase := "test-passphrase-123" 515 sshEncrypted, err := keyPair.PrivateKeyToSSH("encrypted-key", passphrase) 516 assert.NoError(t, err) 517 assert.NotEmpty(t, sshEncrypted) 518 assert.Contains(t, sshEncrypted, "-----BEGIN OPENSSH PRIVATE KEY-----") 519 assert.True(t, len(sshEncrypted) > len(sshData), "Encrypted key should be larger") 520 } 521 522 func TestRSAKeyPairFromSSH_Success(t *testing.T) { 523 keySizes := []KeySize{KeySize2048, KeySize3072} 524 525 for _, keySize := range keySizes { 526 t.Run(fmt.Sprintf("%d-bit", keySize.Bits()), func(t *testing.T) { 527 // Generate original key pair 528 originalKeyPair, err := GenerateRSAKeyPair(keySize) 529 assert.NoError(t, err) 530 531 // Test unencrypted SSH round-trip 532 sshData, err := originalKeyPair.PrivateKeyToSSH("test-key", "") 533 assert.NoError(t, err) 534 535 reconstructed, err := RSAKeyPairFromSSH(sshData, "") 536 assert.NoError(t, err) 537 assert.NotNil(t, reconstructed) 538 assert.Equal(t, originalKeyPair.PrivateKey.Size(), reconstructed.PrivateKey.Size()) 539 540 // Test encrypted SSH round-trip 541 passphrase := "test-passphrase-123" 542 sshEncrypted, err := originalKeyPair.PrivateKeyToSSH("encrypted-key", passphrase) 543 assert.NoError(t, err) 544 545 reconstructedEncrypted, err := RSAKeyPairFromSSH(sshEncrypted, passphrase) 546 assert.NoError(t, err) 547 assert.NotNil(t, reconstructedEncrypted) 548 assert.Equal(t, originalKeyPair.PrivateKey.Size(), reconstructedEncrypted.PrivateKey.Size()) 549 }) 550 } 551 } 552 553 func TestRSAKeyPairFromSSH_InvalidSSH(t *testing.T) { 554 tests := []struct { 555 name string 556 sshData string 557 passphrase string 558 errMsg string 559 }{ 560 { 561 name: "InvalidSSHData", 562 sshData: "invalid ssh data", 563 passphrase: "", 564 errMsg: "failed to parse SSH private key", 565 }, 566 { 567 name: "WrongPassphrase", 568 sshData: func() string { 569 keyPair, _ := GenerateRSAKeyPair(KeySize2048) 570 sshData, _ := keyPair.PrivateKeyToSSH("test", "correct-passphrase") 571 return string(sshData) 572 }(), 573 passphrase: "wrong-passphrase", 574 errMsg: "failed to parse SSH private key", 575 }, 576 } 577 578 for _, tt := range tests { 579 t.Run(tt.name, func(t *testing.T) { 580 keyPair, err := RSAKeyPairFromSSH(format.SSH(tt.sshData), tt.passphrase) 581 582 assert.Error(t, err) 583 assert.Nil(t, keyPair) 584 assert.Contains(t, err.Error(), tt.errMsg) 585 }) 586 } 587 } 588 589 func TestRSAKeyPair_SSHRoundTrip(t *testing.T) { 590 keyPair, err := GenerateRSAKeyPair(KeySize2048) 591 assert.NoError(t, err) 592 593 // Test unencrypted round-trip 594 sshPrivate, err := keyPair.PrivateKeyToSSH("test-key", "") 595 assert.NoError(t, err) 596 597 sshPublic, err := keyPair.PublicKeyToSSH("test@example.com") 598 assert.NoError(t, err) 599 600 // Reconstruct from SSH private key 601 reconstructed, err := RSAKeyPairFromSSH(sshPrivate, "") 602 assert.NoError(t, err) 603 604 // Verify keys match 605 assert.Equal(t, keyPair.PrivateKey.Size(), reconstructed.PrivateKey.Size()) 606 607 // Verify public key can be reconstructed correctly 608 reconstructedPublic, err := reconstructed.PublicKeyToSSH("test@example.com") 609 assert.NoError(t, err) 610 assert.Equal(t, sshPublic, reconstructedPublic) 611 } 612 613 // Cross-Format Tests 614 615 func TestRSAKeyPair_CrossFormatCompatibility(t *testing.T) { 616 // Generate original key pair 617 original, err := GenerateRSAKeyPair(KeySize2048) 618 assert.NoError(t, err) 619 620 // Test PEM -> DER -> SSH -> PEM conversion chain 621 t.Run("PEM->DER->SSH->PEM", func(t *testing.T) { 622 // PEM to DER 623 pemData, err := original.PrivateKeyToPEM() 624 assert.NoError(t, err) 625 626 keyFromPEM, err := RSAKeyPairFromPEM(pemData) 627 assert.NoError(t, err) 628 629 derData, err := keyFromPEM.PrivateKeyToDER() 630 assert.NoError(t, err) 631 632 // DER to SSH 633 keyFromDER, err := RSAKeyPairFromDER(derData) 634 assert.NoError(t, err) 635 636 sshData, err := keyFromDER.PrivateKeyToSSH("test", "") 637 assert.NoError(t, err) 638 639 // SSH back to PEM 640 keyFromSSH, err := RSAKeyPairFromSSH(sshData, "") 641 assert.NoError(t, err) 642 643 finalPEM, err := keyFromSSH.PrivateKeyToPEM() 644 assert.NoError(t, err) 645 646 // Verify final result matches original 647 finalKey, err := RSAKeyPairFromPEM(finalPEM) 648 assert.NoError(t, err) 649 assert.Equal(t, original.PrivateKey.Size(), finalKey.PrivateKey.Size()) 650 }) 651 } 652 653 // Enhanced Benchmarks 654 655 func BenchmarkRSAKeyPair_AllFormats(b *testing.B) { 656 keyPair, err := GenerateRSAKeyPair(KeySize2048) 657 if err != nil { 658 b.Fatalf("Key generation failed: %v", err) 659 } 660 661 // DER operations 662 b.Run("PrivateKeyToDER", func(b *testing.B) { 663 for i := 0; i < b.N; i++ { 664 _, err := keyPair.PrivateKeyToDER() 665 if err != nil { 666 b.Fatalf("DER conversion failed: %v", err) 667 } 668 } 669 }) 670 671 derData, _ := keyPair.PrivateKeyToDER() 672 b.Run("RSAKeyPairFromDER", func(b *testing.B) { 673 for i := 0; i < b.N; i++ { 674 _, err := RSAKeyPairFromDER(derData) 675 if err != nil { 676 b.Fatalf("DER reconstruction failed: %v", err) 677 } 678 } 679 }) 680 681 // SSH operations 682 b.Run("PrivateKeyToSSH", func(b *testing.B) { 683 for i := 0; i < b.N; i++ { 684 _, err := keyPair.PrivateKeyToSSH("bench", "") 685 if err != nil { 686 b.Fatalf("SSH conversion failed: %v", err) 687 } 688 } 689 }) 690 691 sshData, _ := keyPair.PrivateKeyToSSH("bench", "") 692 b.Run("RSAKeyPairFromSSH", func(b *testing.B) { 693 for i := 0; i < b.N; i++ { 694 _, err := RSAKeyPairFromSSH(sshData, "") 695 if err != nil { 696 b.Fatalf("SSH reconstruction failed: %v", err) 697 } 698 } 699 }) 700 701 b.Run("PublicKeyToSSH", func(b *testing.B) { 702 for i := 0; i < b.N; i++ { 703 _, err := keyPair.PublicKeyToSSH("bench@example.com") 704 if err != nil { 705 b.Fatalf("SSH public conversion failed: %v", err) 706 } 707 } 708 }) 709 }