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 }