github.com/jasoet/gopki@v1.15.0/keypair/algo/rsa_test.go (about)

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