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