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  }