github.com/jasoet/gopki@v1.15.0/keypair/algo/ed25519_test.go (about) 1 package algo 2 3 import ( 4 "crypto/ed25519" 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 TestEd25519Config(t *testing.T) { 16 // Test that Ed25519Config is just a string type 17 config := Ed25519Config("default") 18 assert.Equal(t, "default", string(config)) 19 } 20 21 func TestGenerateEd25519KeyPair_Success(t *testing.T) { 22 keyPair, err := GenerateEd25519KeyPair() 23 24 assert.NoError(t, err) 25 assert.NotNil(t, keyPair) 26 assert.NotNil(t, keyPair.PrivateKey) 27 assert.NotNil(t, keyPair.PublicKey) 28 29 // Verify Ed25519 key lengths 30 assert.Equal(t, ed25519.PrivateKeySize, len(keyPair.PrivateKey)) 31 assert.Equal(t, ed25519.PublicKeySize, len(keyPair.PublicKey)) 32 33 // Verify public key is derived from private key 34 expectedPublicKey := keyPair.PrivateKey.Public().(ed25519.PublicKey) 35 assert.Equal(t, expectedPublicKey, keyPair.PublicKey) 36 } 37 38 func TestGenerateEd25519KeyPair_MultipleGenerations(t *testing.T) { 39 // Generate multiple key pairs to ensure randomness 40 keyPairs := make([]*Ed25519KeyPair, 5) 41 42 for i := 0; i < 5; i++ { 43 keyPair, err := GenerateEd25519KeyPair() 44 assert.NoError(t, err) 45 assert.NotNil(t, keyPair) 46 keyPairs[i] = keyPair 47 } 48 49 // Verify all keys are different 50 for i := 0; i < len(keyPairs); i++ { 51 for j := i + 1; j < len(keyPairs); j++ { 52 assert.NotEqual(t, keyPairs[i].PrivateKey, keyPairs[j].PrivateKey, "Private keys should be different") 53 assert.NotEqual(t, keyPairs[i].PublicKey, keyPairs[j].PublicKey, "Public keys should be different") 54 } 55 } 56 } 57 58 func TestEd25519KeyPair_PrivateKeyToPEM(t *testing.T) { 59 keyPair, err := GenerateEd25519KeyPair() 60 assert.NoError(t, err) 61 assert.NotNil(t, keyPair) 62 63 pemData, err := keyPair.PrivateKeyToPEM() 64 assert.NoError(t, err) 65 assert.NotEmpty(t, pemData) 66 67 // Verify PEM format 68 block, _ := pem.Decode(pemData) 69 assert.NotNil(t, block) 70 assert.Equal(t, "PRIVATE KEY", block.Type) 71 72 // Verify we can parse the PEM back to a private key 73 parsedKey, err := x509.ParsePKCS8PrivateKey(block.Bytes) 74 assert.NoError(t, err) 75 76 ed25519Key, ok := parsedKey.(ed25519.PrivateKey) 77 assert.True(t, ok) 78 assert.Equal(t, len(keyPair.PrivateKey), len(ed25519Key)) 79 assert.Equal(t, keyPair.PrivateKey, ed25519Key) 80 } 81 82 func TestEd25519KeyPair_PublicKeyToPEM(t *testing.T) { 83 keyPair, err := GenerateEd25519KeyPair() 84 assert.NoError(t, err) 85 assert.NotNil(t, keyPair) 86 87 pemData, err := keyPair.PublicKeyToPEM() 88 assert.NoError(t, err) 89 assert.NotEmpty(t, pemData) 90 91 // Verify PEM format 92 block, _ := pem.Decode(pemData) 93 assert.NotNil(t, block) 94 assert.Equal(t, "PUBLIC KEY", block.Type) 95 96 // Verify we can parse the PEM back to a public key 97 parsedKey, err := x509.ParsePKIXPublicKey(block.Bytes) 98 assert.NoError(t, err) 99 100 ed25519Key, ok := parsedKey.(ed25519.PublicKey) 101 assert.True(t, ok) 102 assert.Equal(t, len(keyPair.PublicKey), len(ed25519Key)) 103 assert.Equal(t, keyPair.PublicKey, ed25519Key) 104 } 105 106 func TestEd25519KeyPairFromPEM_Success(t *testing.T) { 107 // Generate original key pair 108 originalKeyPair, err := GenerateEd25519KeyPair() 109 assert.NoError(t, err) 110 assert.NotNil(t, originalKeyPair) 111 112 // Convert to PEM 113 pemData, err := originalKeyPair.PrivateKeyToPEM() 114 assert.NoError(t, err) 115 116 // Reconstruct from PEM 117 reconstructedKeyPair, err := Ed25519KeyPairFromPEM(pemData) 118 assert.NoError(t, err) 119 assert.NotNil(t, reconstructedKeyPair) 120 121 // Verify the keys match exactly 122 assert.Equal(t, originalKeyPair.PrivateKey, reconstructedKeyPair.PrivateKey) 123 assert.Equal(t, originalKeyPair.PublicKey, reconstructedKeyPair.PublicKey) 124 125 // Verify public key is derived from private key 126 expectedPublicKey := reconstructedKeyPair.PrivateKey.Public().(ed25519.PublicKey) 127 assert.Equal(t, expectedPublicKey, reconstructedKeyPair.PublicKey) 128 } 129 130 func TestEd25519KeyPairFromPEM_InvalidPEM(t *testing.T) { 131 tests := []struct { 132 name string 133 pemData []byte 134 errMsg string 135 }{ 136 { 137 name: "NotPEM", 138 pemData: []byte("not a pem file"), 139 errMsg: "failed to decode PEM block", 140 }, 141 { 142 name: "InvalidPEMContent", 143 pemData: []byte(`-----BEGIN PRIVATE KEY----- 144 invalid base64 content 145 -----END PRIVATE KEY-----`), 146 errMsg: "failed to parse private key", 147 }, 148 { 149 name: "NotEd25519Key_RSA", 150 pemData: func() []byte { 151 // Create an RSA key PEM that's not Ed25519 152 rsaKeyPair, _ := GenerateRSAKeyPair(KeySize2048) 153 rsaPEM, _ := rsaKeyPair.PrivateKeyToPEM() 154 return rsaPEM 155 }(), 156 errMsg: "private key is not an Ed25519 key", 157 }, 158 { 159 name: "NotEd25519Key_ECDSA", 160 pemData: func() []byte { 161 // Create an ECDSA key PEM that's not Ed25519 162 ecdsaKeyPair, _ := GenerateECDSAKeyPair(P256) 163 ecdsaPEM, _ := ecdsaKeyPair.PrivateKeyToPEM() 164 return ecdsaPEM 165 }(), 166 errMsg: "private key is not an Ed25519 key", 167 }, 168 } 169 170 for _, tt := range tests { 171 t.Run(tt.name, func(t *testing.T) { 172 keyPair, err := Ed25519KeyPairFromPEM(tt.pemData) 173 174 assert.Error(t, err) 175 assert.Nil(t, keyPair) 176 assert.Contains(t, err.Error(), tt.errMsg) 177 }) 178 } 179 } 180 181 func TestEd25519KeyPair_PEMRoundTrip(t *testing.T) { 182 // Generate original key pair 183 original, err := GenerateEd25519KeyPair() 184 assert.NoError(t, err) 185 assert.NotNil(t, original) 186 187 // Convert to PEM and back 188 privatePEM, err := original.PrivateKeyToPEM() 189 assert.NoError(t, err) 190 191 publicPEM, err := original.PublicKeyToPEM() 192 assert.NoError(t, err) 193 194 // Reconstruct from private key PEM 195 reconstructed, err := Ed25519KeyPairFromPEM(privatePEM) 196 assert.NoError(t, err) 197 assert.NotNil(t, reconstructed) 198 199 // Verify private keys match exactly 200 assert.Equal(t, original.PrivateKey, reconstructed.PrivateKey) 201 202 // Verify public keys match exactly 203 assert.Equal(t, original.PublicKey, reconstructed.PublicKey) 204 205 // Verify reconstructed public key PEM matches original 206 reconstructedPublicPEM, err := reconstructed.PublicKeyToPEM() 207 assert.NoError(t, err) 208 assert.Equal(t, string(publicPEM), string(reconstructedPublicPEM)) 209 } 210 211 func TestEd25519KeyPair_PEMFormat(t *testing.T) { 212 keyPair, err := GenerateEd25519KeyPair() 213 assert.NoError(t, err) 214 assert.NotNil(t, keyPair) 215 216 // Test private key PEM format 217 privatePEM, err := keyPair.PrivateKeyToPEM() 218 assert.NoError(t, err) 219 220 privateStr := string(privatePEM) 221 assert.True(t, strings.HasPrefix(privateStr, "-----BEGIN PRIVATE KEY-----")) 222 assert.True(t, strings.HasSuffix(strings.TrimSpace(privateStr), "-----END PRIVATE KEY-----")) 223 224 // Test public key PEM format 225 publicPEM, err := keyPair.PublicKeyToPEM() 226 assert.NoError(t, err) 227 228 publicStr := string(publicPEM) 229 assert.True(t, strings.HasPrefix(publicStr, "-----BEGIN PUBLIC KEY-----")) 230 assert.True(t, strings.HasSuffix(strings.TrimSpace(publicStr), "-----END PUBLIC KEY-----")) 231 } 232 233 func TestEd25519KeyPair_KeySizes(t *testing.T) { 234 keyPair, err := GenerateEd25519KeyPair() 235 assert.NoError(t, err) 236 assert.NotNil(t, keyPair) 237 238 // Verify Ed25519 standard key sizes 239 assert.Equal(t, ed25519.PrivateKeySize, len(keyPair.PrivateKey), "Ed25519 private key should be 64 bytes") 240 assert.Equal(t, ed25519.PublicKeySize, len(keyPair.PublicKey), "Ed25519 public key should be 32 bytes") 241 242 // Verify constants match expected values 243 assert.Equal(t, 64, ed25519.PrivateKeySize) 244 assert.Equal(t, 32, ed25519.PublicKeySize) 245 } 246 247 func TestEd25519KeyPair_PublicKeyDerivation(t *testing.T) { 248 keyPair, err := GenerateEd25519KeyPair() 249 assert.NoError(t, err) 250 assert.NotNil(t, keyPair) 251 252 // Verify public key can be derived from private key 253 derivedPublicKey := keyPair.PrivateKey.Public().(ed25519.PublicKey) 254 assert.Equal(t, keyPair.PublicKey, derivedPublicKey) 255 256 // Verify it's the same reference in our structure 257 assert.Equal(t, keyPair.PublicKey, derivedPublicKey) 258 } 259 260 func TestEd25519KeyPair_CryptographicProperties(t *testing.T) { 261 keyPair, err := GenerateEd25519KeyPair() 262 assert.NoError(t, err) 263 assert.NotNil(t, keyPair) 264 265 // Test basic signing/verification to ensure keys are cryptographically valid 266 message := []byte("test message for Ed25519 signature verification") 267 268 signature := ed25519.Sign(keyPair.PrivateKey, message) 269 assert.NotNil(t, signature) 270 assert.Equal(t, ed25519.SignatureSize, len(signature), "Ed25519 signature should be 64 bytes") 271 272 // Verify signature with correct public key 273 valid := ed25519.Verify(keyPair.PublicKey, message, signature) 274 assert.True(t, valid, "Signature should be valid with correct public key") 275 276 // Generate another key pair to test with wrong public key 277 wrongKeyPair, err := GenerateEd25519KeyPair() 278 assert.NoError(t, err) 279 280 // Verify signature fails with wrong public key 281 invalidVerification := ed25519.Verify(wrongKeyPair.PublicKey, message, signature) 282 assert.False(t, invalidVerification, "Signature should be invalid with wrong public key") 283 } 284 285 func TestEd25519KeyPair_MultiplePEMRoundTrips(t *testing.T) { 286 // Test multiple round trips to ensure consistency 287 for i := 0; i < 3; i++ { 288 t.Run(fmt.Sprintf("RoundTrip_%d", i+1), func(t *testing.T) { 289 // Generate original key pair 290 original, err := GenerateEd25519KeyPair() 291 assert.NoError(t, err) 292 293 // First round trip 294 pemData1, err := original.PrivateKeyToPEM() 295 assert.NoError(t, err) 296 297 reconstructed1, err := Ed25519KeyPairFromPEM(pemData1) 298 assert.NoError(t, err) 299 300 // Second round trip 301 pemData2, err := reconstructed1.PrivateKeyToPEM() 302 assert.NoError(t, err) 303 304 reconstructed2, err := Ed25519KeyPairFromPEM(pemData2) 305 assert.NoError(t, err) 306 307 // All should be identical 308 assert.Equal(t, original.PrivateKey, reconstructed1.PrivateKey) 309 assert.Equal(t, original.PrivateKey, reconstructed2.PrivateKey) 310 assert.Equal(t, original.PublicKey, reconstructed1.PublicKey) 311 assert.Equal(t, original.PublicKey, reconstructed2.PublicKey) 312 assert.Equal(t, string(pemData1), string(pemData2)) 313 }) 314 } 315 } 316 317 func BenchmarkGenerateEd25519KeyPair(b *testing.B) { 318 for i := 0; i < b.N; i++ { 319 _, err := GenerateEd25519KeyPair() 320 if err != nil { 321 b.Fatalf("Key generation failed: %v", err) 322 } 323 } 324 } 325 326 func BenchmarkEd25519KeyPair_PEMOperations(b *testing.B) { 327 keyPair, err := GenerateEd25519KeyPair() 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("Ed25519KeyPairFromPEM", func(b *testing.B) { 352 for i := 0; i < b.N; i++ { 353 _, err := Ed25519KeyPairFromPEM(pemData) 354 if err != nil { 355 b.Fatalf("PEM reconstruction failed: %v", err) 356 } 357 } 358 }) 359 } 360 361 func BenchmarkEd25519_SignVerify(b *testing.B) { 362 keyPair, err := GenerateEd25519KeyPair() 363 if err != nil { 364 b.Fatalf("Key generation failed: %v", err) 365 } 366 367 message := []byte("benchmark message for Ed25519 signature performance testing") 368 369 b.Run("Sign", func(b *testing.B) { 370 for i := 0; i < b.N; i++ { 371 signature := ed25519.Sign(keyPair.PrivateKey, message) 372 if len(signature) != ed25519.SignatureSize { 373 b.Fatalf("Invalid signature size: %d", len(signature)) 374 } 375 } 376 }) 377 378 signature := ed25519.Sign(keyPair.PrivateKey, message) 379 b.Run("Verify", func(b *testing.B) { 380 for i := 0; i < b.N; i++ { 381 valid := ed25519.Verify(keyPair.PublicKey, message, signature) 382 if !valid { 383 b.Fatalf("Signature verification failed") 384 } 385 } 386 }) 387 } 388 389 // DER Format Tests 390 391 func TestEd25519KeyPair_PrivateKeyToDER(t *testing.T) { 392 keyPair, err := GenerateEd25519KeyPair() 393 assert.NoError(t, err) 394 395 derData, err := keyPair.PrivateKeyToDER() 396 assert.NoError(t, err) 397 assert.NotEmpty(t, derData) 398 399 // Verify we can parse the DER back to a private key 400 parsedKey, err := x509.ParsePKCS8PrivateKey(derData) 401 assert.NoError(t, err) 402 403 ed25519Key, ok := parsedKey.(ed25519.PrivateKey) 404 assert.True(t, ok, "Parsed key should be Ed25519") 405 assert.Equal(t, keyPair.PrivateKey, ed25519Key) 406 407 // Verify DER is more compact than PEM 408 pemData, err := keyPair.PrivateKeyToPEM() 409 assert.NoError(t, err) 410 assert.True(t, len(derData) < len(pemData), "DER should be more compact than PEM") 411 412 // Verify Ed25519 DER is very compact (should be around 48 bytes) 413 assert.True(t, len(derData) < 60, "Ed25519 DER should be very compact") 414 } 415 416 func TestEd25519KeyPair_PublicKeyToDER(t *testing.T) { 417 keyPair, err := GenerateEd25519KeyPair() 418 assert.NoError(t, err) 419 420 derData, err := keyPair.PublicKeyToDER() 421 assert.NoError(t, err) 422 assert.NotEmpty(t, derData) 423 424 // Verify we can parse the DER back to a public key 425 parsedKey, err := x509.ParsePKIXPublicKey(derData) 426 assert.NoError(t, err) 427 428 ed25519Key, ok := parsedKey.(ed25519.PublicKey) 429 assert.True(t, ok, "Parsed key should be Ed25519") 430 assert.Equal(t, keyPair.PublicKey, ed25519Key) 431 432 // Verify DER is more compact than PEM 433 pemData, err := keyPair.PublicKeyToPEM() 434 assert.NoError(t, err) 435 assert.True(t, len(derData) < len(pemData), "DER should be more compact than PEM") 436 437 // Verify Ed25519 public key DER is very compact (should be around 44 bytes) 438 assert.True(t, len(derData) < 50, "Ed25519 public key DER should be very compact") 439 } 440 441 func TestEd25519KeyPairFromDER_Success(t *testing.T) { 442 // Generate original key pair 443 originalKeyPair, err := GenerateEd25519KeyPair() 444 assert.NoError(t, err) 445 446 // Convert to DER 447 derData, err := originalKeyPair.PrivateKeyToDER() 448 assert.NoError(t, err) 449 450 // Reconstruct from DER 451 reconstructedKeyPair, err := Ed25519KeyPairFromDER(derData) 452 assert.NoError(t, err) 453 assert.NotNil(t, reconstructedKeyPair) 454 455 // Verify the keys match exactly 456 assert.Equal(t, originalKeyPair.PrivateKey, reconstructedKeyPair.PrivateKey) 457 assert.Equal(t, originalKeyPair.PublicKey, reconstructedKeyPair.PublicKey) 458 459 // Verify public key is derived from private key 460 expectedPublicKey := reconstructedKeyPair.PrivateKey.Public().(ed25519.PublicKey) 461 assert.Equal(t, expectedPublicKey, reconstructedKeyPair.PublicKey) 462 463 // Verify key sizes are correct 464 assert.Equal(t, ed25519.PrivateKeySize, len(reconstructedKeyPair.PrivateKey)) 465 assert.Equal(t, ed25519.PublicKeySize, len(reconstructedKeyPair.PublicKey)) 466 } 467 468 func TestEd25519KeyPairFromDER_InvalidDER(t *testing.T) { 469 tests := []struct { 470 name string 471 derData []byte 472 errMsg string 473 }{ 474 { 475 name: "InvalidDERData", 476 derData: []byte("invalid der data"), 477 errMsg: "failed to parse DER private key", 478 }, 479 { 480 name: "EmptyData", 481 derData: []byte{}, 482 errMsg: "failed to parse DER private key", 483 }, 484 } 485 486 for _, tt := range tests { 487 t.Run(tt.name, func(t *testing.T) { 488 keyPair, err := Ed25519KeyPairFromDER(tt.derData) 489 490 assert.Error(t, err) 491 assert.Nil(t, keyPair) 492 assert.Contains(t, err.Error(), tt.errMsg) 493 }) 494 } 495 } 496 497 func TestEd25519KeyPair_DERRoundTrip(t *testing.T) { 498 // Generate original key pair 499 original, err := GenerateEd25519KeyPair() 500 assert.NoError(t, err) 501 502 // Convert to DER and back 503 privateDER, err := original.PrivateKeyToDER() 504 assert.NoError(t, err) 505 506 publicDER, err := original.PublicKeyToDER() 507 assert.NoError(t, err) 508 509 // Reconstruct from private key DER 510 reconstructed, err := Ed25519KeyPairFromDER(privateDER) 511 assert.NoError(t, err) 512 513 // Verify private keys match exactly 514 assert.Equal(t, original.PrivateKey, reconstructed.PrivateKey) 515 516 // Verify public keys match exactly 517 assert.Equal(t, original.PublicKey, reconstructed.PublicKey) 518 519 // Verify reconstructed public key DER matches original 520 reconstructedPublicDER, err := reconstructed.PublicKeyToDER() 521 assert.NoError(t, err) 522 assert.Equal(t, publicDER, reconstructedPublicDER) 523 } 524 525 // SSH Format Tests 526 527 func TestEd25519KeyPair_PublicKeyToSSH(t *testing.T) { 528 keyPair, err := GenerateEd25519KeyPair() 529 assert.NoError(t, err) 530 531 // Test with comment 532 sshData, err := keyPair.PublicKeyToSSH("user@example.com") 533 assert.NoError(t, err) 534 assert.NotEmpty(t, sshData) 535 536 // Verify SSH format starts with Ed25519 prefix 537 assert.True(t, strings.HasPrefix(string(sshData), "ssh-ed25519 "), "SSH key should start with 'ssh-ed25519 '") 538 assert.Contains(t, string(sshData), "user@example.com", "SSH key should contain comment") 539 assert.Equal(t, 3, len(strings.Fields(string(sshData))), "SSH key should have 3 parts") 540 541 // Test without comment 542 sshDataNoComment, err := keyPair.PublicKeyToSSH("") 543 assert.NoError(t, err) 544 assert.Equal(t, 2, len(strings.Fields(string(sshDataNoComment))), "SSH key without comment should have 2 parts") 545 assert.True(t, strings.HasPrefix(string(sshDataNoComment), "ssh-ed25519 ")) 546 547 // Verify the SSH public key is properly formatted and compact 548 parts := strings.Fields(string(sshData)) 549 assert.Equal(t, "ssh-ed25519", parts[0]) 550 assert.True(t, len(parts[1]) > 40, "Base64 encoded key should be substantial") 551 } 552 553 func TestEd25519KeyPair_PrivateKeyToSSH(t *testing.T) { 554 keyPair, err := GenerateEd25519KeyPair() 555 assert.NoError(t, err) 556 557 // Test unencrypted SSH private key 558 sshData, err := keyPair.PrivateKeyToSSH("test-key", "") 559 assert.NoError(t, err) 560 assert.NotEmpty(t, sshData) 561 assert.Contains(t, sshData, "-----BEGIN OPENSSH PRIVATE KEY-----") 562 assert.Contains(t, sshData, "-----END OPENSSH PRIVATE KEY-----") 563 564 // Test encrypted SSH private key 565 passphrase := "test-passphrase-123" 566 sshEncrypted, err := keyPair.PrivateKeyToSSH("encrypted-key", passphrase) 567 assert.NoError(t, err) 568 assert.NotEmpty(t, sshEncrypted) 569 assert.Contains(t, sshEncrypted, "-----BEGIN OPENSSH PRIVATE KEY-----") 570 assert.True(t, len(sshEncrypted) > len(sshData), "Encrypted key should be larger") 571 572 // Ed25519 SSH keys should be relatively compact 573 assert.True(t, len(sshData) < 500, "Unencrypted Ed25519 SSH key should be compact") 574 } 575 576 func TestEd25519KeyPairFromSSH_Success(t *testing.T) { 577 // Generate original key pair 578 originalKeyPair, err := GenerateEd25519KeyPair() 579 assert.NoError(t, err) 580 581 // Test unencrypted SSH round-trip 582 sshData, err := originalKeyPair.PrivateKeyToSSH("test-key", "") 583 assert.NoError(t, err) 584 585 reconstructed, err := Ed25519KeyPairFromSSH(sshData, "") 586 assert.NoError(t, err) 587 assert.NotNil(t, reconstructed) 588 assert.Equal(t, originalKeyPair.PrivateKey, reconstructed.PrivateKey) 589 assert.Equal(t, originalKeyPair.PublicKey, reconstructed.PublicKey) 590 591 // Test encrypted SSH round-trip 592 passphrase := "test-passphrase-123" 593 sshEncrypted, err := originalKeyPair.PrivateKeyToSSH("encrypted-key", passphrase) 594 assert.NoError(t, err) 595 596 reconstructedEncrypted, err := Ed25519KeyPairFromSSH(sshEncrypted, passphrase) 597 assert.NoError(t, err) 598 assert.NotNil(t, reconstructedEncrypted) 599 assert.Equal(t, originalKeyPair.PrivateKey, reconstructedEncrypted.PrivateKey) 600 assert.Equal(t, originalKeyPair.PublicKey, reconstructedEncrypted.PublicKey) 601 602 // Verify cryptographic properties of reconstructed keys 603 message := []byte("test message for Ed25519 signature verification") 604 signature := ed25519.Sign(reconstructed.PrivateKey, message) 605 valid := ed25519.Verify(reconstructed.PublicKey, message, signature) 606 assert.True(t, valid, "Reconstructed key should be cryptographically valid") 607 } 608 609 func TestEd25519KeyPairFromSSH_InvalidSSH(t *testing.T) { 610 tests := []struct { 611 name string 612 sshData string 613 passphrase string 614 errMsg string 615 }{ 616 { 617 name: "InvalidSSHData", 618 sshData: "invalid ssh data", 619 passphrase: "", 620 errMsg: "failed to parse SSH private key", 621 }, 622 { 623 name: "WrongPassphrase", 624 sshData: func() string { 625 keyPair, _ := GenerateEd25519KeyPair() 626 sshData, _ := keyPair.PrivateKeyToSSH("test", "correct-passphrase") 627 return string(sshData) 628 }(), 629 passphrase: "wrong-passphrase", 630 errMsg: "failed to parse SSH private key", 631 }, 632 } 633 634 for _, tt := range tests { 635 t.Run(tt.name, func(t *testing.T) { 636 keyPair, err := Ed25519KeyPairFromSSH(format.SSH(tt.sshData), tt.passphrase) 637 638 assert.Error(t, err) 639 assert.Nil(t, keyPair) 640 assert.Contains(t, err.Error(), tt.errMsg) 641 }) 642 } 643 } 644 645 func TestEd25519KeyPair_SSHRoundTrip(t *testing.T) { 646 keyPair, err := GenerateEd25519KeyPair() 647 assert.NoError(t, err) 648 649 // Test unencrypted round-trip 650 sshPrivate, err := keyPair.PrivateKeyToSSH("test-key", "") 651 assert.NoError(t, err) 652 653 sshPublic, err := keyPair.PublicKeyToSSH("test@example.com") 654 assert.NoError(t, err) 655 656 // Reconstruct from SSH private key 657 reconstructed, err := Ed25519KeyPairFromSSH(sshPrivate, "") 658 assert.NoError(t, err) 659 660 // Verify keys match exactly 661 assert.Equal(t, keyPair.PrivateKey, reconstructed.PrivateKey) 662 assert.Equal(t, keyPair.PublicKey, reconstructed.PublicKey) 663 664 // Verify public key can be reconstructed correctly 665 reconstructedPublic, err := reconstructed.PublicKeyToSSH("test@example.com") 666 assert.NoError(t, err) 667 assert.Equal(t, sshPublic, reconstructedPublic) 668 669 // Test encrypted round-trip 670 passphrase := "secure-passphrase-456" 671 sshEncrypted, err := keyPair.PrivateKeyToSSH("encrypted-test", passphrase) 672 assert.NoError(t, err) 673 674 reconstructedEncrypted, err := Ed25519KeyPairFromSSH(sshEncrypted, passphrase) 675 assert.NoError(t, err) 676 assert.Equal(t, keyPair.PrivateKey, reconstructedEncrypted.PrivateKey) 677 assert.Equal(t, keyPair.PublicKey, reconstructedEncrypted.PublicKey) 678 } 679 680 // Cross-Format Tests 681 682 func TestEd25519KeyPair_CrossFormatCompatibility(t *testing.T) { 683 // Generate original key pair 684 original, err := GenerateEd25519KeyPair() 685 assert.NoError(t, err) 686 687 // Test PEM -> DER -> SSH -> PEM conversion chain 688 t.Run("PEM->DER->SSH->PEM", func(t *testing.T) { 689 // PEM to DER 690 pemData, err := original.PrivateKeyToPEM() 691 assert.NoError(t, err) 692 693 keyFromPEM, err := Ed25519KeyPairFromPEM(pemData) 694 assert.NoError(t, err) 695 696 derData, err := keyFromPEM.PrivateKeyToDER() 697 assert.NoError(t, err) 698 699 // DER to SSH 700 keyFromDER, err := Ed25519KeyPairFromDER(derData) 701 assert.NoError(t, err) 702 703 sshData, err := keyFromDER.PrivateKeyToSSH("test", "") 704 assert.NoError(t, err) 705 706 // SSH back to PEM 707 keyFromSSH, err := Ed25519KeyPairFromSSH(sshData, "") 708 assert.NoError(t, err) 709 710 finalPEM, err := keyFromSSH.PrivateKeyToPEM() 711 assert.NoError(t, err) 712 713 // Verify final result matches original 714 finalKey, err := Ed25519KeyPairFromPEM(finalPEM) 715 assert.NoError(t, err) 716 assert.Equal(t, original.PrivateKey, finalKey.PrivateKey) 717 assert.Equal(t, original.PublicKey, finalKey.PublicKey) 718 }) 719 720 // Test DER -> SSH -> DER conversion chain 721 t.Run("DER->SSH->DER", func(t *testing.T) { 722 // Start with DER 723 originalDER, err := original.PrivateKeyToDER() 724 assert.NoError(t, err) 725 726 keyFromDER, err := Ed25519KeyPairFromDER(originalDER) 727 assert.NoError(t, err) 728 729 // DER to SSH 730 sshData, err := keyFromDER.PrivateKeyToSSH("cross-format", "") 731 assert.NoError(t, err) 732 733 // SSH back to DER 734 keyFromSSH, err := Ed25519KeyPairFromSSH(sshData, "") 735 assert.NoError(t, err) 736 737 finalDER, err := keyFromSSH.PrivateKeyToDER() 738 assert.NoError(t, err) 739 740 // Verify DER data matches 741 assert.Equal(t, originalDER, finalDER) 742 }) 743 } 744 745 func TestEd25519KeyPair_FormatCompactness(t *testing.T) { 746 keyPair, err := GenerateEd25519KeyPair() 747 assert.NoError(t, err) 748 749 // Get all formats 750 pemData, err := keyPair.PrivateKeyToPEM() 751 assert.NoError(t, err) 752 753 derData, err := keyPair.PrivateKeyToDER() 754 assert.NoError(t, err) 755 756 sshData, err := keyPair.PrivateKeyToSSH("test", "") 757 assert.NoError(t, err) 758 759 // Verify size ordering: DER < SSH < PEM (generally) 760 assert.True(t, len(derData) < len(pemData), "DER should be more compact than PEM") 761 762 // Ed25519 is very efficient, so all formats should be relatively compact 763 assert.True(t, len(derData) < 60, "Ed25519 DER should be very compact") 764 assert.True(t, len(pemData) < 150, "Ed25519 PEM should be compact") 765 assert.True(t, len(sshData) < 500, "Ed25519 SSH should be reasonably compact") 766 767 t.Logf("Format sizes - DER: %d bytes, PEM: %d bytes, SSH: %d bytes", 768 len(derData), len(pemData), len(sshData)) 769 } 770 771 // Enhanced Benchmarks 772 773 func BenchmarkEd25519KeyPair_AllFormats(b *testing.B) { 774 keyPair, err := GenerateEd25519KeyPair() 775 if err != nil { 776 b.Fatalf("Key generation failed: %v", err) 777 } 778 779 // DER operations 780 b.Run("PrivateKeyToDER", func(b *testing.B) { 781 for i := 0; i < b.N; i++ { 782 _, err := keyPair.PrivateKeyToDER() 783 if err != nil { 784 b.Fatalf("DER conversion failed: %v", err) 785 } 786 } 787 }) 788 789 derData, _ := keyPair.PrivateKeyToDER() 790 b.Run("Ed25519KeyPairFromDER", func(b *testing.B) { 791 for i := 0; i < b.N; i++ { 792 _, err := Ed25519KeyPairFromDER(derData) 793 if err != nil { 794 b.Fatalf("DER reconstruction failed: %v", err) 795 } 796 } 797 }) 798 799 // SSH operations 800 b.Run("PrivateKeyToSSH", func(b *testing.B) { 801 for i := 0; i < b.N; i++ { 802 _, err := keyPair.PrivateKeyToSSH("bench", "") 803 if err != nil { 804 b.Fatalf("SSH conversion failed: %v", err) 805 } 806 } 807 }) 808 809 sshData, _ := keyPair.PrivateKeyToSSH("bench", "") 810 b.Run("Ed25519KeyPairFromSSH", func(b *testing.B) { 811 for i := 0; i < b.N; i++ { 812 _, err := Ed25519KeyPairFromSSH(sshData, "") 813 if err != nil { 814 b.Fatalf("SSH reconstruction failed: %v", err) 815 } 816 } 817 }) 818 819 b.Run("PublicKeyToSSH", func(b *testing.B) { 820 for i := 0; i < b.N; i++ { 821 _, err := keyPair.PublicKeyToSSH("bench@example.com") 822 if err != nil { 823 b.Fatalf("SSH public conversion failed: %v", err) 824 } 825 } 826 }) 827 } 828 829 func BenchmarkEd25519_CrossFormatConversion(b *testing.B) { 830 keyPair, err := GenerateEd25519KeyPair() 831 if err != nil { 832 b.Fatalf("Key generation failed: %v", err) 833 } 834 835 b.Run("PEM->DER->SSH->PEM", func(b *testing.B) { 836 for i := 0; i < b.N; i++ { 837 // PEM to DER 838 pemData, _ := keyPair.PrivateKeyToPEM() 839 keyFromPEM, _ := Ed25519KeyPairFromPEM(pemData) 840 derData, _ := keyFromPEM.PrivateKeyToDER() 841 842 // DER to SSH 843 keyFromDER, _ := Ed25519KeyPairFromDER(derData) 844 sshData, _ := keyFromDER.PrivateKeyToSSH("bench", "") 845 846 // SSH back to PEM 847 keyFromSSH, _ := Ed25519KeyPairFromSSH(sshData, "") 848 _, _ = keyFromSSH.PrivateKeyToPEM() 849 } 850 }) 851 }