github.com/jasoet/gopki@v1.15.0/pkcs12/helpers_test.go (about) 1 package pkcs12 2 3 import ( 4 "crypto/ecdsa" 5 "crypto/ed25519" 6 "crypto/rand" 7 "crypto/rsa" 8 "crypto/x509" 9 "crypto/x509/pkix" 10 "math/big" 11 "testing" 12 "time" 13 14 "github.com/jasoet/gopki/keypair" 15 "github.com/jasoet/gopki/keypair/algo" 16 ) 17 18 // TestValidateKeyPairMatch tests the validateKeyPairMatch function with various key types and scenarios 19 func TestValidateKeyPairMatch(t *testing.T) { 20 // Generate RSA key pair 21 rsaManager, err := keypair.Generate[algo.KeySize, *algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](algo.KeySize2048) 22 if err != nil { 23 t.Fatalf("Failed to generate RSA key pair: %v", err) 24 } 25 rsaKeyPair := rsaManager.KeyPair() 26 27 // Generate ECDSA key pair 28 ecdsaManager, err := keypair.Generate[algo.ECDSACurve, *algo.ECDSAKeyPair, *ecdsa.PrivateKey, *ecdsa.PublicKey](algo.P256) 29 if err != nil { 30 t.Fatalf("Failed to generate ECDSA key pair: %v", err) 31 } 32 ecdsaKeyPair := ecdsaManager.KeyPair() 33 34 // Generate Ed25519 key pair 35 ed25519Manager, err := keypair.Generate[algo.Ed25519Config, *algo.Ed25519KeyPair, ed25519.PrivateKey, ed25519.PublicKey]("") 36 if err != nil { 37 t.Fatalf("Failed to generate Ed25519 key pair: %v", err) 38 } 39 ed25519KeyPair := ed25519Manager.KeyPair() 40 41 // Generate a different RSA key pair for mismatch testing 42 differentRSAManager, err := keypair.Generate[algo.KeySize, *algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](algo.KeySize2048) 43 if err != nil { 44 t.Fatalf("Failed to generate different RSA key pair: %v", err) 45 } 46 differentRSAKeyPair := differentRSAManager.KeyPair() 47 48 t.Run("ValidRSAKeyPairMatch", func(t *testing.T) { 49 err := validateKeyPairMatch(rsaKeyPair.PrivateKey, rsaKeyPair.PublicKey) 50 if err != nil { 51 t.Errorf("Expected RSA key pair to match, got error: %v", err) 52 } 53 }) 54 55 t.Run("ValidECDSAKeyPairMatch", func(t *testing.T) { 56 err := validateKeyPairMatch(ecdsaKeyPair.PrivateKey, ecdsaKeyPair.PublicKey) 57 if err != nil { 58 t.Errorf("Expected ECDSA key pair to match, got error: %v", err) 59 } 60 }) 61 62 t.Run("ValidEd25519KeyPairMatch", func(t *testing.T) { 63 err := validateKeyPairMatch(ed25519KeyPair.PrivateKey, ed25519KeyPair.PublicKey) 64 if err != nil { 65 t.Errorf("Expected Ed25519 key pair to match, got error: %v", err) 66 } 67 }) 68 69 t.Run("RSAKeyPairMismatch", func(t *testing.T) { 70 err := validateKeyPairMatch(rsaKeyPair.PrivateKey, differentRSAKeyPair.PublicKey) 71 if err == nil { 72 t.Error("Expected RSA key pair mismatch to produce an error") 73 } 74 }) 75 76 t.Run("RSAPrivateKeyWithECDSAPublicKey", func(t *testing.T) { 77 err := validateKeyPairMatch(rsaKeyPair.PrivateKey, ecdsaKeyPair.PublicKey) 78 if err == nil { 79 t.Error("Expected RSA private key with ECDSA public key to produce an error") 80 } 81 if err != nil && err.Error() != "private key is RSA but public key is not" { 82 t.Errorf("Expected specific error message, got: %v", err) 83 } 84 }) 85 86 t.Run("ECDSAPrivateKeyWithRSAPublicKey", func(t *testing.T) { 87 err := validateKeyPairMatch(ecdsaKeyPair.PrivateKey, rsaKeyPair.PublicKey) 88 if err == nil { 89 t.Error("Expected ECDSA private key with RSA public key to produce an error") 90 } 91 if err != nil && err.Error() != "private key is ECDSA but public key is not" { 92 t.Errorf("Expected specific error message, got: %v", err) 93 } 94 }) 95 96 t.Run("Ed25519PrivateKeyWithRSAPublicKey", func(t *testing.T) { 97 err := validateKeyPairMatch(ed25519KeyPair.PrivateKey, rsaKeyPair.PublicKey) 98 if err == nil { 99 t.Error("Expected Ed25519 private key with RSA public key to produce an error") 100 } 101 if err != nil && err.Error() != "private key is Ed25519 but public key is not" { 102 t.Errorf("Expected specific error message, got: %v", err) 103 } 104 }) 105 106 t.Run("UnsupportedPrivateKeyType", func(t *testing.T) { 107 // Create an unsupported private key type (using a string as a mock) 108 unsupportedKey := "not a real key" 109 err := validateKeyPairMatch(unsupportedKey, rsaKeyPair.PublicKey) 110 if err == nil { 111 t.Error("Expected unsupported private key type to produce an error") 112 } 113 if err != nil && !contains(err.Error(), "unsupported private key type") { 114 t.Errorf("Expected unsupported key type error, got: %v", err) 115 } 116 }) 117 118 t.Run("ECDSAKeyPairMismatch", func(t *testing.T) { 119 // Generate another ECDSA key pair for mismatch testing 120 differentECDSAManager, err := keypair.Generate[algo.ECDSACurve, *algo.ECDSAKeyPair, *ecdsa.PrivateKey, *ecdsa.PublicKey](algo.P256) 121 if err != nil { 122 t.Fatalf("Failed to generate different ECDSA key pair: %v", err) 123 } 124 differentECDSAKeyPair := differentECDSAManager.KeyPair() 125 126 err = validateKeyPairMatch(ecdsaKeyPair.PrivateKey, differentECDSAKeyPair.PublicKey) 127 if err == nil { 128 t.Error("Expected ECDSA key pair mismatch to produce an error") 129 } 130 if err != nil && err.Error() != "ECDSA private key does not match public key" { 131 t.Errorf("Expected specific ECDSA mismatch error, got: %v", err) 132 } 133 }) 134 135 t.Run("Ed25519KeyPairMismatch", func(t *testing.T) { 136 // Generate another Ed25519 key pair for mismatch testing 137 differentEd25519Manager, err := keypair.Generate[algo.Ed25519Config, *algo.Ed25519KeyPair, ed25519.PrivateKey, ed25519.PublicKey]("") 138 if err != nil { 139 t.Fatalf("Failed to generate different Ed25519 key pair: %v", err) 140 } 141 differentEd25519KeyPair := differentEd25519Manager.KeyPair() 142 143 err = validateKeyPairMatch(ed25519KeyPair.PrivateKey, differentEd25519KeyPair.PublicKey) 144 if err == nil { 145 t.Error("Expected Ed25519 key pair mismatch to produce an error") 146 } 147 if err != nil && err.Error() != "Ed25519 private key does not match public key" { 148 t.Errorf("Expected specific Ed25519 mismatch error, got: %v", err) 149 } 150 }) 151 } 152 153 // TestGetExtKeyUsageStrings tests the getExtKeyUsageStrings function comprehensively 154 func TestGetExtKeyUsageStrings(t *testing.T) { 155 testCases := []struct { 156 name string 157 usages []x509.ExtKeyUsage 158 expected []string 159 }{ 160 { 161 name: "EmptyUsages", 162 usages: []x509.ExtKeyUsage{}, 163 expected: []string{}, 164 }, 165 { 166 name: "ServerAuth", 167 usages: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth}, 168 expected: []string{"Server Authentication"}, 169 }, 170 { 171 name: "ClientAuth", 172 usages: []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth}, 173 expected: []string{"Client Authentication"}, 174 }, 175 { 176 name: "CodeSigning", 177 usages: []x509.ExtKeyUsage{x509.ExtKeyUsageCodeSigning}, 178 expected: []string{"Code Signing"}, 179 }, 180 { 181 name: "EmailProtection", 182 usages: []x509.ExtKeyUsage{x509.ExtKeyUsageEmailProtection}, 183 expected: []string{"Email Protection"}, 184 }, 185 { 186 name: "TimeStamping", 187 usages: []x509.ExtKeyUsage{x509.ExtKeyUsageTimeStamping}, 188 expected: []string{"Time Stamping"}, 189 }, 190 { 191 name: "OCSPSigning", 192 usages: []x509.ExtKeyUsage{x509.ExtKeyUsageOCSPSigning}, 193 expected: []string{"OCSP Signing"}, 194 }, 195 { 196 name: "MultipleUsages", 197 usages: []x509.ExtKeyUsage{ 198 x509.ExtKeyUsageServerAuth, 199 x509.ExtKeyUsageClientAuth, 200 x509.ExtKeyUsageCodeSigning, 201 }, 202 expected: []string{ 203 "Server Authentication", 204 "Client Authentication", 205 "Code Signing", 206 }, 207 }, 208 { 209 name: "AllStandardUsages", 210 usages: []x509.ExtKeyUsage{ 211 x509.ExtKeyUsageServerAuth, 212 x509.ExtKeyUsageClientAuth, 213 x509.ExtKeyUsageCodeSigning, 214 x509.ExtKeyUsageEmailProtection, 215 x509.ExtKeyUsageTimeStamping, 216 x509.ExtKeyUsageOCSPSigning, 217 }, 218 expected: []string{ 219 "Server Authentication", 220 "Client Authentication", 221 "Code Signing", 222 "Email Protection", 223 "Time Stamping", 224 "OCSP Signing", 225 }, 226 }, 227 { 228 name: "UnknownUsage", 229 usages: []x509.ExtKeyUsage{x509.ExtKeyUsage(999)}, // Unknown usage value 230 expected: []string{"Unknown (999)"}, 231 }, 232 { 233 name: "MixedKnownAndUnknownUsages", 234 usages: []x509.ExtKeyUsage{ 235 x509.ExtKeyUsageServerAuth, 236 x509.ExtKeyUsage(888), // Unknown 237 x509.ExtKeyUsageClientAuth, 238 x509.ExtKeyUsage(777), // Unknown 239 }, 240 expected: []string{ 241 "Server Authentication", 242 "Unknown (888)", 243 "Client Authentication", 244 "Unknown (777)", 245 }, 246 }, 247 } 248 249 for _, tc := range testCases { 250 t.Run(tc.name, func(t *testing.T) { 251 result := getExtKeyUsageStrings(tc.usages) 252 253 if len(result) != len(tc.expected) { 254 t.Errorf("Expected %d usage strings, got %d", len(tc.expected), len(result)) 255 return 256 } 257 258 for i, expected := range tc.expected { 259 if i >= len(result) || result[i] != expected { 260 t.Errorf("Expected usage string at index %d to be '%s', got '%s'", i, expected, result[i]) 261 } 262 } 263 }) 264 } 265 } 266 267 // TestGetCertificateInfoExtKeyUsage tests GetCertificateInfo with focus on extended key usage 268 func TestGetCertificateInfoExtKeyUsage(t *testing.T) { 269 // Create a certificate with various extended key usages 270 rsaManager, err := keypair.Generate[algo.KeySize, *algo.RSAKeyPair, *rsa.PrivateKey, *rsa.PublicKey](algo.KeySize2048) 271 if err != nil { 272 t.Fatalf("Failed to generate RSA key pair: %v", err) 273 } 274 rsaKeyPair := rsaManager.KeyPair() 275 276 template := &x509.Certificate{ 277 Subject: pkix.Name{ 278 CommonName: "Test Cert with ExtKeyUsage", 279 Organization: []string{"Test Org"}, 280 }, 281 NotBefore: time.Now(), 282 NotAfter: time.Now().Add(365 * 24 * time.Hour), 283 KeyUsage: x509.KeyUsageDigitalSignature | x509.KeyUsageKeyEncipherment, 284 ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth, x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageCodeSigning}, 285 SerialNumber: big.NewInt(12345), 286 } 287 288 certDER, err := x509.CreateCertificate(rand.Reader, template, template, rsaKeyPair.PublicKey, rsaKeyPair.PrivateKey) 289 if err != nil { 290 t.Fatalf("Failed to create certificate: %v", err) 291 } 292 293 cert, err := x509.ParseCertificate(certDER) 294 if err != nil { 295 t.Fatalf("Failed to parse certificate: %v", err) 296 } 297 298 // Test GetCertificateInfo 299 info := GetCertificateInfo(cert) 300 if info == nil { 301 t.Error("Expected certificate info to be non-nil") 302 return 303 } 304 305 // Check extended key usage strings 306 extKeyUsage, ok := info["ext_key_usage"].([]string) 307 if !ok { 308 t.Error("Expected ext_key_usage to be []string") 309 return 310 } 311 312 expectedExtKeyUsages := []string{ 313 "Server Authentication", 314 "Client Authentication", 315 "Code Signing", 316 } 317 318 if len(extKeyUsage) != len(expectedExtKeyUsages) { 319 t.Errorf("Expected %d extended key usages, got %d", len(expectedExtKeyUsages), len(extKeyUsage)) 320 } 321 322 for i, expected := range expectedExtKeyUsages { 323 if i < len(extKeyUsage) && extKeyUsage[i] != expected { 324 t.Errorf("Expected extended key usage %d to be '%s', got '%s'", i, expected, extKeyUsage[i]) 325 } 326 } 327 328 t.Run("NilCertificate", func(t *testing.T) { 329 info := GetCertificateInfo(nil) 330 if info != nil { 331 t.Error("Expected nil certificate to return nil info") 332 } 333 }) 334 } 335 336 // Helper function to check if a string contains a substring 337 func contains(s, substr string) bool { 338 return len(s) >= len(substr) && (s == substr || 339 (len(s) > len(substr) && 340 (s[:len(substr)] == substr || 341 s[len(s)-len(substr):] == substr || 342 findInString(s, substr)))) 343 } 344 345 func findInString(s, substr string) bool { 346 for i := 0; i <= len(s)-len(substr); i++ { 347 if s[i:i+len(substr)] == substr { 348 return true 349 } 350 } 351 return false 352 }