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  }