github.com/jasoet/gopki@v1.15.0/compatibility/keypair/ssh_test.go (about)

     1  //go:build compatibility
     2  
     3  package keypair
     4  
     5  import (
     6  	"crypto/ecdsa"
     7  	"crypto/ed25519"
     8  	"crypto/rsa"
     9  	"fmt"
    10  	"strings"
    11  	"testing"
    12  
    13  	"github.com/stretchr/testify/assert"
    14  	"github.com/stretchr/testify/require"
    15  
    16  	"github.com/jasoet/gopki/compatibility"
    17  	"github.com/jasoet/gopki/keypair"
    18  	"github.com/jasoet/gopki/keypair/algo"
    19  	"github.com/jasoet/gopki/keypair/format"
    20  )
    21  
    22  // TestSSHKeypairCompatibility tests SSH key pair compatibility between GoPKI and OpenSSH
    23  func TestSSHKeypairCompatibility(t *testing.T) {
    24  	t.Logf("🔐 Running SSH OpenSSH Compatibility Tests...")
    25  	t.Logf("   Testing SSH key generation, validation, and format conversion")
    26  
    27  	t.Run("RSA", func(t *testing.T) {
    28  		testSSHRSACompatibility(t)
    29  	})
    30  
    31  	t.Run("ECDSA", func(t *testing.T) {
    32  		testSSHECDSACompatibility(t)
    33  	})
    34  
    35  	t.Run("Ed25519", func(t *testing.T) {
    36  		testSSHEd25519Compatibility(t)
    37  	})
    38  }
    39  
    40  func testSSHRSACompatibility(t *testing.T) {
    41  	keySizes := []struct {
    42  		size algo.KeySize
    43  		bits int
    44  		name string
    45  	}{
    46  		{algo.KeySize2048, 2048, "2048"},
    47  		{algo.KeySize3072, 3072, "3072"},
    48  		{algo.KeySize4096, 4096, "4096"},
    49  	}
    50  
    51  	for _, keySize := range keySizes {
    52  		t.Run(fmt.Sprintf("RSA_%s", keySize.name), func(t *testing.T) {
    53  			helper := compatibility.NewOpenSSLHelper(t)
    54  			defer helper.Cleanup()
    55  
    56  			t.Logf("Testing RSA-%d SSH compatibility", keySize.bits)
    57  
    58  			// Test 1: GoPKI generates SSH keys → ssh-keygen validates
    59  			t.Run("GoPKI_Generate_SSH_Validate", func(t *testing.T) {
    60  				// Generate RSA key pair with GoPKI
    61  				manager, err := keypair.Generate[algo.KeySize, *algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](keySize.size)
    62  				require.NoError(t, err, "Failed to generate RSA key pair with GoPKI")
    63  
    64  				// Convert to SSH format
    65  				privateSSH, publicSSH, err := manager.ToSSH("test@gopki.com", "")
    66  				require.NoError(t, err, "Failed to convert keys to SSH format")
    67  
    68  				// Validate private key with ssh-keygen
    69  				err = helper.ValidateSSHPrivateKeyWithSSHKeygen([]byte(privateSSH))
    70  				assert.NoError(t, err, "ssh-keygen validation failed for GoPKI-generated RSA private key")
    71  
    72  				// Validate public key with ssh-keygen
    73  				err = helper.ValidateSSHPublicKeyWithSSHKeygen([]byte(publicSSH))
    74  				assert.NoError(t, err, "ssh-keygen validation failed for GoPKI-generated RSA public key")
    75  
    76  				// Validate authorized_keys format
    77  				err = helper.ValidateAuthorizedKeysFormat([]byte(publicSSH))
    78  				assert.NoError(t, err, "authorized_keys format validation failed")
    79  
    80  				t.Logf("✓ GoPKI RSA-%d SSH keys validated by ssh-keygen", keySize.bits)
    81  			})
    82  
    83  			// Test 2: ssh-keygen generates → GoPKI validates
    84  			t.Run("SSHKeygen_Generate_GoPKI_Validate", func(t *testing.T) {
    85  				// Generate RSA key pair with ssh-keygen
    86  				privateSSH, publicSSH, err := helper.GenerateSSHKeyWithSSHKeygen("rsa", keySize.bits)
    87  				require.NoError(t, err, "Failed to generate RSA key pair with ssh-keygen")
    88  
    89  				// Load with GoPKI
    90  				manager, err := keypair.LoadFromSSHData[*algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](
    91  					format.SSH(privateSSH), "",
    92  				)
    93  				require.NoError(t, err, "Failed to load ssh-keygen generated RSA key with GoPKI")
    94  
    95  				// Verify key properties
    96  				rsaKeyPair := manager.KeyPair()
    97  				assert.NotNil(t, rsaKeyPair.PrivateKey, "Private key should not be nil")
    98  				assert.NotNil(t, rsaKeyPair.PublicKey, "Public key should not be nil")
    99  				assert.Equal(t, keySize.bits/8, rsaKeyPair.PrivateKey.Size(), "Key size mismatch")
   100  
   101  				// Parse public key with GoPKI
   102  				parsedPublicKey, err := keypair.PublicKeyFromSSH[*rsa.PublicKey](format.SSH(publicSSH))
   103  				require.NoError(t, err, "Failed to parse SSH public key with GoPKI")
   104  				assert.NotNil(t, parsedPublicKey, "Parsed public key should not be nil")
   105  
   106  				t.Logf("✓ ssh-keygen RSA-%d keys loaded and validated by GoPKI", keySize.bits)
   107  			})
   108  
   109  			// Test 3: Passphrase protection
   110  			t.Run("Passphrase_Protection", func(t *testing.T) {
   111  				passphrase := "test-passphrase-123"
   112  
   113  				// Generate with GoPKI and passphrase
   114  				manager, err := keypair.Generate[algo.KeySize, *algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](keySize.size)
   115  				require.NoError(t, err, "Failed to generate RSA key pair")
   116  
   117  				privateSSH, _, err := manager.ToSSH("test@gopki.com", passphrase)
   118  				require.NoError(t, err, "Failed to convert to SSH with passphrase")
   119  
   120  				// Try to load without passphrase (should fail)
   121  				_, err = keypair.LoadFromSSHData[*algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](
   122  					privateSSH, "",
   123  				)
   124  				assert.Error(t, err, "Should fail to load encrypted key without passphrase")
   125  
   126  				// Load with correct passphrase
   127  				loadedManager, err := keypair.LoadFromSSHData[*algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](
   128  					privateSSH, passphrase,
   129  				)
   130  				require.NoError(t, err, "Failed to load encrypted key with correct passphrase")
   131  				assert.NotNil(t, loadedManager.KeyPair().PrivateKey, "Private key should be loaded")
   132  
   133  				// Generate with ssh-keygen and passphrase
   134  				sshPrivate, _, err := helper.GenerateSSHKeyWithPassphrase("rsa", keySize.bits, passphrase)
   135  				require.NoError(t, err, "Failed to generate passphrase-protected key with ssh-keygen")
   136  
   137  				// Load ssh-keygen encrypted key with GoPKI
   138  				sshManager, err := keypair.LoadFromSSHData[*algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](
   139  					format.SSH(sshPrivate), passphrase,
   140  				)
   141  				require.NoError(t, err, "Failed to load ssh-keygen encrypted key with GoPKI")
   142  				assert.NotNil(t, sshManager.KeyPair().PrivateKey, "ssh-keygen encrypted key should be loaded")
   143  
   144  				// Just verify that the encrypted key was loaded successfully
   145  				// The public key comparison was already done above
   146  
   147  				t.Logf("✓ RSA-%d passphrase protection validated bidirectionally", keySize.bits)
   148  			})
   149  		})
   150  	}
   151  }
   152  
   153  func testSSHECDSACompatibility(t *testing.T) {
   154  	curves := []struct {
   155  		curve algo.ECDSACurve
   156  		bits  int
   157  		name  string
   158  	}{
   159  		{algo.P256, 256, "P-256"},
   160  		{algo.P384, 384, "P-384"},
   161  		{algo.P521, 521, "P-521"},
   162  	}
   163  
   164  	for _, curve := range curves {
   165  		t.Run(curve.name, func(t *testing.T) {
   166  			helper := compatibility.NewOpenSSLHelper(t)
   167  			defer helper.Cleanup()
   168  
   169  			t.Logf("Testing ECDSA %s SSH compatibility", curve.name)
   170  
   171  			// Test 1: GoPKI generates SSH keys → ssh-keygen validates
   172  			t.Run("GoPKI_Generate_SSH_Validate", func(t *testing.T) {
   173  				// Generate ECDSA key pair with GoPKI
   174  				manager, err := keypair.Generate[algo.ECDSACurve, *algo.ECDSAKeyPair, *ecdsa.PrivateKey, *ecdsa.PublicKey](curve.curve)
   175  				require.NoError(t, err, "Failed to generate ECDSA key pair with GoPKI")
   176  
   177  				// Convert to SSH format
   178  				privateSSH, publicSSH, err := manager.ToSSH("test@gopki.com", "")
   179  				require.NoError(t, err, "Failed to convert keys to SSH format")
   180  
   181  				// Validate private key with ssh-keygen
   182  				err = helper.ValidateSSHPrivateKeyWithSSHKeygen([]byte(privateSSH))
   183  				assert.NoError(t, err, "ssh-keygen validation failed for GoPKI-generated ECDSA private key")
   184  
   185  				// Validate public key with ssh-keygen
   186  				err = helper.ValidateSSHPublicKeyWithSSHKeygen([]byte(publicSSH))
   187  				assert.NoError(t, err, "ssh-keygen validation failed for GoPKI-generated ECDSA public key")
   188  
   189  				// Validate authorized_keys format
   190  				err = helper.ValidateAuthorizedKeysFormat([]byte(publicSSH))
   191  				assert.NoError(t, err, "authorized_keys format validation failed")
   192  
   193  				t.Logf("✓ GoPKI ECDSA %s SSH keys validated by ssh-keygen", curve.name)
   194  			})
   195  
   196  			// Test 2: ssh-keygen generates → GoPKI validates
   197  			t.Run("SSHKeygen_Generate_GoPKI_Validate", func(t *testing.T) {
   198  				// Generate ECDSA key pair with ssh-keygen
   199  				privateSSH, publicSSH, err := helper.GenerateSSHKeyWithSSHKeygen("ecdsa", curve.bits)
   200  				require.NoError(t, err, "Failed to generate ECDSA key pair with ssh-keygen")
   201  
   202  				// Load with GoPKI
   203  				manager, err := keypair.LoadFromSSHData[*algo.ECDSAKeyPair, *ecdsa.PrivateKey, *ecdsa.PublicKey](
   204  					format.SSH(privateSSH), "",
   205  				)
   206  				require.NoError(t, err, "Failed to load ssh-keygen generated ECDSA key with GoPKI")
   207  
   208  				// Verify key properties
   209  				ecdsaKeyPair := manager.KeyPair()
   210  				assert.NotNil(t, ecdsaKeyPair.PrivateKey, "Private key should not be nil")
   211  				assert.NotNil(t, ecdsaKeyPair.PublicKey, "Public key should not be nil")
   212  
   213  				// Parse public key with GoPKI
   214  				parsedPublicKey, err := keypair.PublicKeyFromSSH[*ecdsa.PublicKey](format.SSH(publicSSH))
   215  				require.NoError(t, err, "Failed to parse SSH public key with GoPKI")
   216  				assert.NotNil(t, parsedPublicKey, "Parsed public key should not be nil")
   217  
   218  				t.Logf("✓ ssh-keygen ECDSA %s keys loaded and validated by GoPKI", curve.name)
   219  			})
   220  
   221  			// Test 3: Passphrase protection
   222  			t.Run("Passphrase_Protection", func(t *testing.T) {
   223  				passphrase := "ecdsa-test-pass"
   224  
   225  				// Generate with GoPKI and passphrase
   226  				manager, err := keypair.Generate[algo.ECDSACurve, *algo.ECDSAKeyPair, *ecdsa.PrivateKey, *ecdsa.PublicKey](curve.curve)
   227  				require.NoError(t, err, "Failed to generate ECDSA key pair")
   228  
   229  				privateSSH, _, err := manager.ToSSH("test@gopki.com", passphrase)
   230  				require.NoError(t, err, "Failed to convert to SSH with passphrase")
   231  
   232  				// Try to load without passphrase (should fail)
   233  				_, err = keypair.LoadFromSSHData[*algo.ECDSAKeyPair, *ecdsa.PrivateKey, *ecdsa.PublicKey](
   234  					privateSSH, "",
   235  				)
   236  				assert.Error(t, err, "Should fail to load encrypted key without passphrase")
   237  
   238  				// Load with correct passphrase
   239  				loadedManager, err := keypair.LoadFromSSHData[*algo.ECDSAKeyPair, *ecdsa.PrivateKey, *ecdsa.PublicKey](
   240  					privateSSH, passphrase,
   241  				)
   242  				require.NoError(t, err, "Failed to load encrypted key with correct passphrase")
   243  				assert.NotNil(t, loadedManager.KeyPair().PrivateKey, "Private key should be loaded")
   244  
   245  				t.Logf("✓ ECDSA %s passphrase protection validated", curve.name)
   246  			})
   247  		})
   248  	}
   249  }
   250  
   251  func testSSHEd25519Compatibility(t *testing.T) {
   252  	helper := compatibility.NewOpenSSLHelper(t)
   253  	defer helper.Cleanup()
   254  
   255  	t.Logf("Testing Ed25519 SSH compatibility")
   256  
   257  	// Test 1: GoPKI generates SSH keys → ssh-keygen validates
   258  	t.Run("GoPKI_Generate_SSH_Validate", func(t *testing.T) {
   259  		// Generate Ed25519 key pair with GoPKI
   260  		manager, err := keypair.Generate[algo.Ed25519Config, *algo.Ed25519KeyPair, ed25519.PrivateKey, ed25519.PublicKey](algo.Ed25519Default)
   261  		require.NoError(t, err, "Failed to generate Ed25519 key pair with GoPKI")
   262  
   263  		// Convert to SSH format
   264  		privateSSH, publicSSH, err := manager.ToSSH("test@gopki.com", "")
   265  		require.NoError(t, err, "Failed to convert keys to SSH format")
   266  
   267  		// Validate private key with ssh-keygen
   268  		err = helper.ValidateSSHPrivateKeyWithSSHKeygen([]byte(privateSSH))
   269  		assert.NoError(t, err, "ssh-keygen validation failed for GoPKI-generated Ed25519 private key")
   270  
   271  		// Validate public key with ssh-keygen
   272  		err = helper.ValidateSSHPublicKeyWithSSHKeygen([]byte(publicSSH))
   273  		assert.NoError(t, err, "ssh-keygen validation failed for GoPKI-generated Ed25519 public key")
   274  
   275  		// Validate authorized_keys format
   276  		err = helper.ValidateAuthorizedKeysFormat([]byte(publicSSH))
   277  		assert.NoError(t, err, "authorized_keys format validation failed")
   278  
   279  		t.Logf("✓ GoPKI Ed25519 SSH keys validated by ssh-keygen")
   280  	})
   281  
   282  	// Test 2: ssh-keygen generates → GoPKI validates
   283  	t.Run("SSHKeygen_Generate_GoPKI_Validate", func(t *testing.T) {
   284  		// Generate Ed25519 key pair with ssh-keygen
   285  		privateSSH, publicSSH, err := helper.GenerateSSHKeyWithSSHKeygen("ed25519", 0)
   286  		require.NoError(t, err, "Failed to generate Ed25519 key pair with ssh-keygen")
   287  
   288  		// Load with GoPKI
   289  		manager, err := keypair.LoadFromSSHData[*algo.Ed25519KeyPair, ed25519.PrivateKey, ed25519.PublicKey](
   290  			format.SSH(privateSSH), "",
   291  		)
   292  		require.NoError(t, err, "Failed to load ssh-keygen generated Ed25519 key with GoPKI")
   293  
   294  		// Verify key properties
   295  		ed25519KeyPair := manager.KeyPair()
   296  		assert.NotNil(t, ed25519KeyPair.PrivateKey, "Private key should not be nil")
   297  		assert.NotNil(t, ed25519KeyPair.PublicKey, "Public key should not be nil")
   298  
   299  		// Parse public key with GoPKI
   300  		parsedPublicKey, err := keypair.PublicKeyFromSSH[ed25519.PublicKey](format.SSH(publicSSH))
   301  		require.NoError(t, err, "Failed to parse SSH public key with GoPKI")
   302  		assert.NotNil(t, parsedPublicKey, "Parsed public key should not be nil")
   303  
   304  		t.Logf("✓ ssh-keygen Ed25519 keys loaded and validated by GoPKI")
   305  	})
   306  
   307  	// Test 3: Passphrase protection
   308  	t.Run("Passphrase_Protection", func(t *testing.T) {
   309  		passphrase := "ed25519-pass"
   310  
   311  		// Generate with GoPKI and passphrase
   312  		manager, err := keypair.Generate[algo.Ed25519Config, *algo.Ed25519KeyPair, ed25519.PrivateKey, ed25519.PublicKey](algo.Ed25519Default)
   313  		require.NoError(t, err, "Failed to generate Ed25519 key pair")
   314  
   315  		privateSSH, _, err := manager.ToSSH("test@gopki.com", passphrase)
   316  		require.NoError(t, err, "Failed to convert to SSH with passphrase")
   317  
   318  		// Try to load without passphrase (should fail)
   319  		_, err = keypair.LoadFromSSHData[*algo.Ed25519KeyPair, ed25519.PrivateKey, ed25519.PublicKey](
   320  			privateSSH, "",
   321  		)
   322  		assert.Error(t, err, "Should fail to load encrypted key without passphrase")
   323  
   324  		// Load with correct passphrase
   325  		loadedManager, err := keypair.LoadFromSSHData[*algo.Ed25519KeyPair, ed25519.PrivateKey, ed25519.PublicKey](
   326  			privateSSH, passphrase,
   327  		)
   328  		require.NoError(t, err, "Failed to load encrypted key with correct passphrase")
   329  		assert.NotNil(t, loadedManager.KeyPair().PrivateKey, "Private key should be loaded")
   330  
   331  		t.Logf("✓ Ed25519 passphrase protection validated")
   332  	})
   333  }
   334  
   335  // TestSSHFingerprintCompatibility tests SSH fingerprint generation compatibility
   336  func TestSSHFingerprintCompatibility(t *testing.T) {
   337  	t.Logf("🔍 Testing SSH Fingerprint Compatibility...")
   338  
   339  	helper := compatibility.NewOpenSSLHelper(t)
   340  	defer helper.Cleanup()
   341  
   342  	// Test RSA fingerprints
   343  	t.Run("RSA_Fingerprints", func(t *testing.T) {
   344  		// Generate RSA key with GoPKI
   345  		manager, err := keypair.Generate[algo.KeySize, *algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](algo.KeySize2048)
   346  		require.NoError(t, err, "Failed to generate RSA key pair")
   347  
   348  		_, publicSSH, err := manager.ToSSH("test@gopki.com", "")
   349  		require.NoError(t, err, "Failed to convert to SSH format")
   350  
   351  		// Get SHA256 fingerprint from ssh-keygen
   352  		sha256Fingerprint, err := helper.GetSSHKeyFingerprint([]byte(publicSSH), "sha256")
   353  		require.NoError(t, err, "Failed to get SHA256 fingerprint")
   354  		assert.True(t, strings.HasPrefix(sha256Fingerprint, "SHA256:"), "SHA256 fingerprint should have correct prefix")
   355  
   356  		// Get MD5 fingerprint from ssh-keygen
   357  		md5Fingerprint, err := helper.GetSSHKeyFingerprint([]byte(publicSSH), "md5")
   358  		require.NoError(t, err, "Failed to get MD5 fingerprint")
   359  		assert.True(t, strings.HasPrefix(md5Fingerprint, "MD5:"), "MD5 fingerprint should have correct prefix")
   360  
   361  		t.Logf("✓ RSA fingerprints: SHA256=%s, MD5=%s", sha256Fingerprint, md5Fingerprint)
   362  	})
   363  
   364  	// Test ECDSA fingerprints
   365  	t.Run("ECDSA_Fingerprints", func(t *testing.T) {
   366  		// Generate ECDSA key with GoPKI
   367  		manager, err := keypair.Generate[algo.ECDSACurve, *algo.ECDSAKeyPair, *ecdsa.PrivateKey, *ecdsa.PublicKey](algo.P256)
   368  		require.NoError(t, err, "Failed to generate ECDSA key pair")
   369  
   370  		_, publicSSH, err := manager.ToSSH("test@gopki.com", "")
   371  		require.NoError(t, err, "Failed to convert to SSH format")
   372  
   373  		// Get fingerprints
   374  		sha256Fingerprint, err := helper.GetSSHKeyFingerprint([]byte(publicSSH), "sha256")
   375  		require.NoError(t, err, "Failed to get SHA256 fingerprint")
   376  		assert.True(t, strings.HasPrefix(sha256Fingerprint, "SHA256:"), "SHA256 fingerprint should have correct prefix")
   377  
   378  		t.Logf("✓ ECDSA P-256 fingerprint: %s", sha256Fingerprint)
   379  	})
   380  
   381  	// Test Ed25519 fingerprints
   382  	t.Run("Ed25519_Fingerprints", func(t *testing.T) {
   383  		// Generate Ed25519 key with GoPKI
   384  		manager, err := keypair.Generate[algo.Ed25519Config, *algo.Ed25519KeyPair, ed25519.PrivateKey, ed25519.PublicKey](algo.Ed25519Default)
   385  		require.NoError(t, err, "Failed to generate Ed25519 key pair")
   386  
   387  		_, publicSSH, err := manager.ToSSH("test@gopki.com", "")
   388  		require.NoError(t, err, "Failed to convert to SSH format")
   389  
   390  		// Get fingerprints
   391  		sha256Fingerprint, err := helper.GetSSHKeyFingerprint([]byte(publicSSH), "sha256")
   392  		require.NoError(t, err, "Failed to get SHA256 fingerprint")
   393  		assert.True(t, strings.HasPrefix(sha256Fingerprint, "SHA256:"), "SHA256 fingerprint should have correct prefix")
   394  
   395  		t.Logf("✓ Ed25519 fingerprint: %s", sha256Fingerprint)
   396  	})
   397  }
   398  
   399  // TestSSHPublicKeyExtraction tests extracting public keys from private keys
   400  func TestSSHPublicKeyExtraction(t *testing.T) {
   401  	t.Logf("🔑 Testing SSH Public Key Extraction...")
   402  
   403  	helper := compatibility.NewOpenSSLHelper(t)
   404  	defer helper.Cleanup()
   405  
   406  	t.Run("RSA_Public_Key_Extraction", func(t *testing.T) {
   407  		// Generate RSA key with GoPKI
   408  		manager, err := keypair.Generate[algo.KeySize, *algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](algo.KeySize2048)
   409  		require.NoError(t, err, "Failed to generate RSA key pair")
   410  
   411  		privateSSH, expectedPublicSSH, err := manager.ToSSH("test@gopki.com", "")
   412  		require.NoError(t, err, "Failed to convert to SSH format")
   413  
   414  		// Extract public key using ssh-keygen from private key
   415  		extractedPublic, err := helper.ExtractPublicKeyWithSSHKeygen([]byte(privateSSH))
   416  		require.NoError(t, err, "Failed to extract public key with ssh-keygen")
   417  
   418  		// The extracted key should be parseable by GoPKI
   419  		extractedKey, err := keypair.PublicKeyFromSSH[*rsa.PublicKey](format.SSH(extractedPublic))
   420  		require.NoError(t, err, "Failed to parse extracted public key")
   421  		assert.NotNil(t, extractedKey, "Extracted key should not be nil")
   422  
   423  		// Compare fingerprints to verify they're the same key
   424  		expectedFingerprint, err := helper.GetSSHKeyFingerprint([]byte(expectedPublicSSH), "sha256")
   425  		require.NoError(t, err, "Failed to get expected fingerprint")
   426  
   427  		extractedFingerprint, err := helper.GetSSHKeyFingerprint(extractedPublic, "sha256")
   428  		require.NoError(t, err, "Failed to get extracted fingerprint")
   429  
   430  		assert.Equal(t, expectedFingerprint, extractedFingerprint, "Fingerprints should match")
   431  
   432  		t.Logf("✓ RSA public key extraction verified")
   433  	})
   434  
   435  	t.Run("ECDSA_Public_Key_Extraction", func(t *testing.T) {
   436  		// Generate ECDSA key with GoPKI
   437  		manager, err := keypair.Generate[algo.ECDSACurve, *algo.ECDSAKeyPair, *ecdsa.PrivateKey, *ecdsa.PublicKey](algo.P256)
   438  		require.NoError(t, err, "Failed to generate ECDSA key pair")
   439  
   440  		privateSSH, expectedPublicSSH, err := manager.ToSSH("test@gopki.com", "")
   441  		require.NoError(t, err, "Failed to convert to SSH format")
   442  
   443  		// Extract public key using ssh-keygen
   444  		extractedPublic, err := helper.ExtractPublicKeyWithSSHKeygen([]byte(privateSSH))
   445  		require.NoError(t, err, "Failed to extract public key with ssh-keygen")
   446  
   447  		// Parse and verify
   448  		extractedKey, err := keypair.PublicKeyFromSSH[*ecdsa.PublicKey](format.SSH(extractedPublic))
   449  		require.NoError(t, err, "Failed to parse extracted public key")
   450  		assert.NotNil(t, extractedKey, "Extracted key should not be nil")
   451  
   452  		// Compare fingerprints
   453  		expectedFingerprint, err := helper.GetSSHKeyFingerprint([]byte(expectedPublicSSH), "sha256")
   454  		require.NoError(t, err, "Failed to get expected fingerprint")
   455  
   456  		extractedFingerprint, err := helper.GetSSHKeyFingerprint(extractedPublic, "sha256")
   457  		require.NoError(t, err, "Failed to get extracted fingerprint")
   458  
   459  		assert.Equal(t, expectedFingerprint, extractedFingerprint, "Fingerprints should match")
   460  
   461  		t.Logf("✓ ECDSA public key extraction verified")
   462  	})
   463  
   464  	t.Run("Ed25519_Public_Key_Extraction", func(t *testing.T) {
   465  		// Generate Ed25519 key with GoPKI
   466  		manager, err := keypair.Generate[algo.Ed25519Config, *algo.Ed25519KeyPair, ed25519.PrivateKey, ed25519.PublicKey](algo.Ed25519Default)
   467  		require.NoError(t, err, "Failed to generate Ed25519 key pair")
   468  
   469  		privateSSH, expectedPublicSSH, err := manager.ToSSH("test@gopki.com", "")
   470  		require.NoError(t, err, "Failed to convert to SSH format")
   471  
   472  		// Extract public key using ssh-keygen
   473  		extractedPublic, err := helper.ExtractPublicKeyWithSSHKeygen([]byte(privateSSH))
   474  		require.NoError(t, err, "Failed to extract public key with ssh-keygen")
   475  
   476  		// Parse and verify
   477  		extractedKey, err := keypair.PublicKeyFromSSH[ed25519.PublicKey](format.SSH(extractedPublic))
   478  		require.NoError(t, err, "Failed to parse extracted public key")
   479  		assert.NotNil(t, extractedKey, "Extracted key should not be nil")
   480  
   481  		// Compare fingerprints
   482  		expectedFingerprint, err := helper.GetSSHKeyFingerprint([]byte(expectedPublicSSH), "sha256")
   483  		require.NoError(t, err, "Failed to get expected fingerprint")
   484  
   485  		extractedFingerprint, err := helper.GetSSHKeyFingerprint(extractedPublic, "sha256")
   486  		require.NoError(t, err, "Failed to get extracted fingerprint")
   487  
   488  		assert.Equal(t, expectedFingerprint, extractedFingerprint, "Fingerprints should match")
   489  
   490  		t.Logf("✓ Ed25519 public key extraction verified")
   491  	})
   492  }
   493  
   494  // TestSSHAuthorizedKeysFormat tests authorized_keys format compatibility
   495  func TestSSHAuthorizedKeysFormat(t *testing.T) {
   496  	t.Logf("📝 Testing SSH authorized_keys Format Compatibility...")
   497  
   498  	helper := compatibility.NewOpenSSLHelper(t)
   499  	defer helper.Cleanup()
   500  
   501  	t.Run("All_Algorithms_AuthorizedKeys", func(t *testing.T) {
   502  		// Test RSA
   503  		rsaManager, err := keypair.Generate[algo.KeySize, *algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](algo.KeySize2048)
   504  		require.NoError(t, err, "Failed to generate RSA key")
   505  
   506  		_, rsaPublicSSH, err := rsaManager.ToSSH("rsa-user@host.com", "")
   507  		require.NoError(t, err, "Failed to convert RSA to SSH")
   508  
   509  		err = helper.ValidateAuthorizedKeysFormat([]byte(rsaPublicSSH))
   510  		assert.NoError(t, err, "RSA authorized_keys validation failed")
   511  		assert.True(t, strings.HasPrefix(string(rsaPublicSSH), "ssh-rsa "), "RSA key should start with ssh-rsa")
   512  		assert.True(t, strings.Contains(string(rsaPublicSSH), "rsa-user@host.com"), "Should contain comment")
   513  
   514  		// Test ECDSA
   515  		ecdsaManager, err := keypair.Generate[algo.ECDSACurve, *algo.ECDSAKeyPair, *ecdsa.PrivateKey, *ecdsa.PublicKey](algo.P256)
   516  		require.NoError(t, err, "Failed to generate ECDSA key")
   517  
   518  		_, ecdsaPublicSSH, err := ecdsaManager.ToSSH("ecdsa-user@host.com", "")
   519  		require.NoError(t, err, "Failed to convert ECDSA to SSH")
   520  
   521  		err = helper.ValidateAuthorizedKeysFormat([]byte(ecdsaPublicSSH))
   522  		assert.NoError(t, err, "ECDSA authorized_keys validation failed")
   523  		assert.True(t, strings.HasPrefix(string(ecdsaPublicSSH), "ecdsa-sha2-nistp256 "), "ECDSA P-256 key should have correct prefix")
   524  
   525  		// Test Ed25519
   526  		ed25519Manager, err := keypair.Generate[algo.Ed25519Config, *algo.Ed25519KeyPair, ed25519.PrivateKey, ed25519.PublicKey](algo.Ed25519Default)
   527  		require.NoError(t, err, "Failed to generate Ed25519 key")
   528  
   529  		_, ed25519PublicSSH, err := ed25519Manager.ToSSH("ed25519-user@host.com", "")
   530  		require.NoError(t, err, "Failed to convert Ed25519 to SSH")
   531  
   532  		err = helper.ValidateAuthorizedKeysFormat([]byte(ed25519PublicSSH))
   533  		assert.NoError(t, err, "Ed25519 authorized_keys validation failed")
   534  		assert.True(t, strings.HasPrefix(string(ed25519PublicSSH), "ssh-ed25519 "), "Ed25519 key should start with ssh-ed25519")
   535  
   536  		t.Logf("✓ All algorithms validated for authorized_keys format")
   537  	})
   538  }