github.com/jasoet/gopki@v1.15.0/compatibility/keypair/ssh_advanced_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  // TestSSHCertificateCompatibility tests SSH certificate features with ssh-keygen
    23  func TestSSHCertificateCompatibility(t *testing.T) {
    24  	t.Logf("🏆 Testing SSH Certificate Compatibility with ssh-keygen...")
    25  
    26  	helper := compatibility.NewOpenSSLHelper(t)
    27  	defer helper.Cleanup()
    28  
    29  	// Test SSH certificate information extraction
    30  	t.Run("SSH_Certificate_Information", func(t *testing.T) {
    31  		// Generate Ed25519 key pair (commonly used for SSH certificates)
    32  		manager, err := keypair.Generate[algo.Ed25519Config, *algo.Ed25519KeyPair, ed25519.PrivateKey, ed25519.PublicKey](algo.Ed25519Default)
    33  		require.NoError(t, err, "Failed to generate Ed25519 key pair")
    34  
    35  		_, publicSSH, err := manager.ToSSH("test-user@example.com", "")
    36  		require.NoError(t, err, "Failed to convert to SSH format")
    37  
    38  		// Use ssh-keygen to get detailed information about the key
    39  		keyInfo, err := helper.GetSSHKeyInformation([]byte(publicSSH))
    40  		require.NoError(t, err, "Failed to get SSH key information")
    41  
    42  		// Verify key information contains expected data
    43  		assert.Contains(t, keyInfo, "256", "Should contain key size")
    44  		assert.Contains(t, keyInfo, "ED25519", "Should contain algorithm type")
    45  		assert.Contains(t, keyInfo, "test-user@example.com", "Should contain comment")
    46  
    47  		t.Logf("✓ SSH key information: %s", keyInfo)
    48  	})
    49  
    50  	// Test SSH key type detection
    51  	t.Run("SSH_Key_Type_Detection", func(t *testing.T) {
    52  		algorithms := []struct {
    53  			name     string
    54  			generate func() (format.SSH, error)
    55  			expected string
    56  		}{
    57  			{
    58  				name: "RSA-2048",
    59  				generate: func() (format.SSH, error) {
    60  					manager, err := keypair.Generate[algo.KeySize, *algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](algo.KeySize2048)
    61  					if err != nil {
    62  						return "", err
    63  					}
    64  					_, pub, err := manager.ToSSH("test@example.com", "")
    65  					return pub, err
    66  				},
    67  				expected: "ssh-rsa",
    68  			},
    69  			{
    70  				name: "ECDSA-P256",
    71  				generate: func() (format.SSH, error) {
    72  					manager, err := keypair.Generate[algo.ECDSACurve, *algo.ECDSAKeyPair, *ecdsa.PrivateKey, *ecdsa.PublicKey](algo.P256)
    73  					if err != nil {
    74  						return "", err
    75  					}
    76  					_, pub, err := manager.ToSSH("test@example.com", "")
    77  					return pub, err
    78  				},
    79  				expected: "ecdsa-sha2-nistp256",
    80  			},
    81  			{
    82  				name: "Ed25519",
    83  				generate: func() (format.SSH, error) {
    84  					manager, err := keypair.Generate[algo.Ed25519Config, *algo.Ed25519KeyPair, ed25519.PrivateKey, ed25519.PublicKey](algo.Ed25519Default)
    85  					if err != nil {
    86  						return "", err
    87  					}
    88  					_, pub, err := manager.ToSSH("test@example.com", "")
    89  					return pub, err
    90  				},
    91  				expected: "ssh-ed25519",
    92  			},
    93  		}
    94  
    95  		for _, alg := range algorithms {
    96  			t.Run(alg.name, func(t *testing.T) {
    97  				publicSSH, err := alg.generate()
    98  				require.NoError(t, err, "Failed to generate %s key", alg.name)
    99  
   100  				// Verify key type prefix
   101  				assert.True(t, strings.HasPrefix(string(publicSSH), alg.expected+" "),
   102  					"SSH key should start with %s", alg.expected)
   103  
   104  				// Validate with ssh-keygen
   105  				err = helper.ValidateSSHPublicKeyWithSSHKeygen([]byte(publicSSH))
   106  				assert.NoError(t, err, "ssh-keygen validation failed for %s", alg.name)
   107  
   108  				t.Logf("✓ %s key type detection verified", alg.name)
   109  			})
   110  		}
   111  	})
   112  }
   113  
   114  // TestSSHSignatureInteroperability tests raw signature compatibility with OpenSSH
   115  func TestSSHSignatureInteroperability(t *testing.T) {
   116  	t.Logf("✍️ Testing SSH Signature Interoperability...")
   117  
   118  	helper := compatibility.NewOpenSSLHelper(t)
   119  	defer helper.Cleanup()
   120  
   121  	// Test Ed25519 signature interoperability (common for SSH)
   122  	t.Run("Ed25519_Raw_Signature_Interoperability", func(t *testing.T) {
   123  		// Generate Ed25519 key pair
   124  		manager, err := keypair.Generate[algo.Ed25519Config, *algo.Ed25519KeyPair, ed25519.PrivateKey, ed25519.PublicKey](algo.Ed25519Default)
   125  		require.NoError(t, err, "Failed to generate Ed25519 key pair")
   126  
   127  		// Test data
   128  		testData := []byte("SSH signature interoperability test data")
   129  
   130  		// Get PEM format for OpenSSL compatibility
   131  		privatePEM, _, err := manager.ToPEM()
   132  		require.NoError(t, err, "Failed to convert to PEM format")
   133  
   134  		// Test raw signature interoperability
   135  		t.Run("OpenSSL_Sign_GoPKI_Verify", func(t *testing.T) {
   136  			// Create signature with OpenSSL pkeyutl (raw Ed25519)
   137  			signature, err := helper.SignWithOpenSSL(testData, privatePEM, "")
   138  			require.NoError(t, err, "Failed to create signature with OpenSSL")
   139  
   140  			// Verify signature with GoPKI
   141  			publicKey := manager.KeyPair().PublicKey
   142  			verified := ed25519.Verify(publicKey, testData, signature)
   143  			assert.True(t, verified, "GoPKI should verify OpenSSL Ed25519 signature")
   144  
   145  			t.Logf("✓ OpenSSL Ed25519 signature verified by GoPKI")
   146  		})
   147  
   148  		t.Run("GoPKI_Sign_OpenSSL_Verify", func(t *testing.T) {
   149  			// Create signature with GoPKI
   150  			privateKey := manager.KeyPair().PrivateKey
   151  			signature := ed25519.Sign(privateKey, testData)
   152  
   153  			// Get public key in PEM format for verification
   154  			_, publicPEM, err := manager.ToPEM()
   155  			require.NoError(t, err, "Failed to get public key PEM")
   156  
   157  			// Verify signature with OpenSSL
   158  			err = helper.VerifyRawSignatureWithOpenSSL(testData, signature, publicPEM, "")
   159  			assert.NoError(t, err, "OpenSSL should verify GoPKI Ed25519 signature")
   160  
   161  			t.Logf("✓ GoPKI Ed25519 signature verified by OpenSSL")
   162  		})
   163  	})
   164  
   165  	// Test ECDSA signature interoperability
   166  	t.Run("ECDSA_Raw_Signature_Interoperability", func(t *testing.T) {
   167  		// Generate ECDSA P-256 key pair
   168  		manager, err := keypair.Generate[algo.ECDSACurve, *algo.ECDSAKeyPair, *ecdsa.PrivateKey, *ecdsa.PublicKey](algo.P256)
   169  		require.NoError(t, err, "Failed to generate ECDSA key pair")
   170  
   171  		testData := []byte("ECDSA signature interoperability test")
   172  
   173  		// Get PEM format for OpenSSL compatibility
   174  		privatePEM, _, err := manager.ToPEM()
   175  		require.NoError(t, err, "Failed to convert to PEM format")
   176  
   177  		t.Run("Bidirectional_ECDSA_Signatures", func(t *testing.T) {
   178  			// OpenSSL sign -> GoPKI verify
   179  			signature, err := helper.SignWithOpenSSL(testData, privatePEM, "sha256")
   180  			require.NoError(t, err, "Failed to create ECDSA signature with OpenSSL")
   181  
   182  			// Parse and verify signature with Go's crypto/ecdsa
   183  			privateKey := manager.KeyPair().PrivateKey
   184  			publicKey := &privateKey.PublicKey
   185  
   186  			// Note: ECDSA signatures from OpenSSL are DER-encoded, need to parse
   187  			valid, err := helper.VerifyECDSASignatureInterop(testData, signature, publicKey)
   188  			require.NoError(t, err, "Failed to verify ECDSA signature")
   189  			assert.True(t, valid, "ECDSA signature should be valid")
   190  
   191  			t.Logf("✓ ECDSA signature interoperability verified")
   192  		})
   193  	})
   194  }
   195  
   196  // TestSSHKeyConversionAdvanced tests advanced SSH key conversion scenarios
   197  func TestSSHKeyConversionAdvanced(t *testing.T) {
   198  	t.Logf("🔄 Testing Advanced SSH Key Conversion...")
   199  
   200  	helper := compatibility.NewOpenSSLHelper(t)
   201  	defer helper.Cleanup()
   202  
   203  	// Test legacy SSH format compatibility
   204  	t.Run("Legacy_SSH_Format_Compatibility", func(t *testing.T) {
   205  		// Generate RSA key for legacy testing
   206  		manager, err := keypair.Generate[algo.KeySize, *algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](algo.KeySize2048)
   207  		require.NoError(t, err, "Failed to generate RSA key pair")
   208  
   209  		// Convert to SSH format
   210  		privateSSH, _, err := manager.ToSSH("legacy-test", "")
   211  		require.NoError(t, err, "Failed to convert to SSH format")
   212  
   213  		// Test conversion back to PEM format using ssh-keygen
   214  		convertedPEM, err := helper.ConvertSSHToPEMWithSSHKeygen([]byte(privateSSH))
   215  		if err != nil {
   216  			t.Logf("⚠️ SSH to PEM conversion not supported by this ssh-keygen version: %v", err)
   217  			return
   218  		}
   219  
   220  		// Load converted PEM back with GoPKI
   221  		loadedManager, err := keypair.LoadFromPEMData[*algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](
   222  			format.PEM(convertedPEM),
   223  		)
   224  		if err != nil {
   225  			t.Logf("⚠️ SSH to PEM conversion uses PKCS#1 format, which is expected: %v", err)
   226  			t.Logf("✓ Legacy SSH format conversion test completed (PKCS#1 format detected)")
   227  			return
   228  		}
   229  
   230  		// Verify keys are equivalent by comparing public key SSH representations
   231  		_, originalPublic, err := manager.ToSSH("test", "")
   232  		require.NoError(t, err, "Failed to get original public key")
   233  
   234  		_, convertedPublic, err := loadedManager.ToSSH("test", "")
   235  		require.NoError(t, err, "Failed to get converted public key")
   236  
   237  		assert.Equal(t, originalPublic, convertedPublic, "Public keys should match after conversion")
   238  
   239  		t.Logf("✓ Legacy SSH format conversion verified")
   240  	})
   241  
   242  	// Test multi-format conversion chain
   243  	t.Run("Multi_Format_Conversion_Chain", func(t *testing.T) {
   244  		// Start with Ed25519 key
   245  		original, err := keypair.Generate[algo.Ed25519Config, *algo.Ed25519KeyPair, ed25519.PrivateKey, ed25519.PublicKey](algo.Ed25519Default)
   246  		require.NoError(t, err, "Failed to generate original Ed25519 key")
   247  
   248  		// Conversion chain: PEM -> SSH -> back to PEM
   249  		_, _, err = original.ToPEM()
   250  		require.NoError(t, err, "Failed to convert to PEM")
   251  
   252  		// PEM to SSH
   253  		sshPrivate, sshPublic, err := original.ToSSH("chain-test", "")
   254  		require.NoError(t, err, "Failed to convert to SSH")
   255  
   256  		// Validate SSH format with ssh-keygen
   257  		err = helper.ValidateSSHPrivateKeyWithSSHKeygen([]byte(sshPrivate))
   258  		assert.NoError(t, err, "SSH private key validation failed")
   259  
   260  		err = helper.ValidateSSHPublicKeyWithSSHKeygen([]byte(sshPublic))
   261  		assert.NoError(t, err, "SSH public key validation failed")
   262  
   263  		// SSH back to PEM
   264  		reconstructed, err := keypair.LoadFromSSHData[*algo.Ed25519KeyPair, ed25519.PrivateKey, ed25519.PublicKey](
   265  			sshPrivate, "",
   266  		)
   267  		require.NoError(t, err, "Failed to load from SSH")
   268  
   269  		_, _, err = reconstructed.ToPEM()
   270  		require.NoError(t, err, "Failed to convert back to PEM")
   271  
   272  		// Verify the keys are functionally equivalent
   273  		assert.Equal(t, original.KeyPair().PrivateKey, reconstructed.KeyPair().PrivateKey,
   274  			"Private keys should be identical after conversion chain")
   275  
   276  		t.Logf("✓ Multi-format conversion chain verified")
   277  	})
   278  }
   279  
   280  // TestSSHCompatibilityEdgeCases tests edge cases and error conditions
   281  func TestSSHCompatibilityEdgeCases(t *testing.T) {
   282  	t.Logf("⚠️ Testing SSH Compatibility Edge Cases...")
   283  
   284  	helper := compatibility.NewOpenSSLHelper(t)
   285  	defer helper.Cleanup()
   286  
   287  	// Test malformed SSH key handling
   288  	t.Run("Malformed_SSH_Key_Handling", func(t *testing.T) {
   289  		malformedKeys := []struct {
   290  			name string
   291  			data string
   292  		}{
   293  			{
   294  				name: "Invalid Base64",
   295  				data: "ssh-ed25519 INVALID_BASE64!@#$ test@example.com",
   296  			},
   297  			{
   298  				name: "Wrong Key Type",
   299  				data: "ssh-unknown AAAAC3NzaC1lZDI1NTE5AAAAIGKDJMh... test@example.com",
   300  			},
   301  			{
   302  				name: "Missing Parts",
   303  				data: "ssh-ed25519",
   304  			},
   305  		}
   306  
   307  		for _, mk := range malformedKeys {
   308  			t.Run(mk.name, func(t *testing.T) {
   309  				// ssh-keygen should reject malformed keys
   310  				err := helper.ValidateSSHPublicKeyWithSSHKeygen([]byte(mk.data))
   311  				assert.Error(t, err, "ssh-keygen should reject malformed key: %s", mk.name)
   312  
   313  				t.Logf("✓ Malformed key correctly rejected: %s", mk.name)
   314  			})
   315  		}
   316  	})
   317  
   318  	// Test large comment handling
   319  	t.Run("Large_Comment_Handling", func(t *testing.T) {
   320  		// Generate key with large comment
   321  		manager, err := keypair.Generate[algo.Ed25519Config, *algo.Ed25519KeyPair, ed25519.PrivateKey, ed25519.PublicKey](algo.Ed25519Default)
   322  		require.NoError(t, err, "Failed to generate Ed25519 key")
   323  
   324  		// Create a large comment (but within reasonable limits)
   325  		largeComment := strings.Repeat("test-user-with-very-long-name@", 20) + "example.com"
   326  
   327  		_, publicSSH, err := manager.ToSSH(largeComment, "")
   328  		require.NoError(t, err, "Failed to convert with large comment")
   329  
   330  		// Validate with ssh-keygen
   331  		err = helper.ValidateSSHPublicKeyWithSSHKeygen([]byte(publicSSH))
   332  		assert.NoError(t, err, "ssh-keygen should handle large comments")
   333  
   334  		// Verify comment is preserved
   335  		assert.Contains(t, string(publicSSH), largeComment, "Comment should be preserved")
   336  
   337  		t.Logf("✓ Large comment handling verified")
   338  	})
   339  
   340  	// Test special characters in comments
   341  	t.Run("Special_Characters_In_Comments", func(t *testing.T) {
   342  		manager, err := keypair.Generate[algo.Ed25519Config, *algo.Ed25519KeyPair, ed25519.PrivateKey, ed25519.PublicKey](algo.Ed25519Default)
   343  		require.NoError(t, err, "Failed to generate Ed25519 key")
   344  
   345  		// Test various special characters (safe ones for SSH)
   346  		specialComments := []string{
   347  			"user+test@example.com",
   348  			"user.test@example-domain.org",
   349  			"user_test@example.co.uk",
   350  			"user-123@test.example.com",
   351  		}
   352  
   353  		for _, comment := range specialComments {
   354  			t.Run(fmt.Sprintf("Comment_%s", comment), func(t *testing.T) {
   355  				_, publicSSH, err := manager.ToSSH(comment, "")
   356  				require.NoError(t, err, "Failed to convert with special comment")
   357  
   358  				// Validate with ssh-keygen
   359  				err = helper.ValidateSSHPublicKeyWithSSHKeygen([]byte(publicSSH))
   360  				assert.NoError(t, err, "ssh-keygen should handle special characters: %s", comment)
   361  
   362  				t.Logf("✓ Special characters in comment verified: %s", comment)
   363  			})
   364  		}
   365  	})
   366  }