github.com/jasoet/gopki@v1.15.0/pkcs12/cert_integration.go (about) 1 // Package pkcs12 provides certificate integration utilities for PKCS#12 files. 2 // This file contains functions for working with certificates and PKCS#12 format, 3 // including loading certificates from P12 files and saving certificates to P12 format. 4 package pkcs12 5 6 import ( 7 "crypto/ecdsa" 8 "crypto/ed25519" 9 "crypto/rsa" 10 "crypto/x509" 11 "encoding/pem" 12 "fmt" 13 "os" 14 "path/filepath" 15 16 "github.com/jasoet/gopki/cert" 17 "github.com/jasoet/gopki/keypair" 18 ) 19 20 // FromP12Cert loads a certificate from PKCS#12 data and returns a GoPKI Certificate 21 func FromP12Cert(p12Data []byte, password string) (*cert.Certificate, []*x509.Certificate, error) { 22 if len(p12Data) == 0 { 23 return nil, nil, fmt.Errorf("P12 data is required") 24 } 25 if password == "" { 26 return nil, nil, fmt.Errorf("password is required") 27 } 28 29 // Parse P12 data 30 opts := DefaultLoadOptions(password) 31 container, err := ParseP12(p12Data, opts) 32 if err != nil { 33 return nil, nil, fmt.Errorf("failed to parse P12 data: %w", err) 34 } 35 36 if container.Certificate == nil { 37 return nil, nil, fmt.Errorf("no certificate found in P12 data") 38 } 39 40 // Wrap in GoPKI Certificate 41 goPKICert := &cert.Certificate{ 42 Certificate: container.Certificate, 43 } 44 45 return goPKICert, container.CACertificates, nil 46 } 47 48 // FromP12CertFile loads a certificate from a PKCS#12 file and returns a GoPKI Certificate 49 func FromP12CertFile(filename, password string) (*cert.Certificate, []*x509.Certificate, error) { 50 if filename == "" { 51 return nil, nil, fmt.Errorf("filename is required") 52 } 53 if password == "" { 54 return nil, nil, fmt.Errorf("password is required") 55 } 56 57 // Load P12 file 58 opts := DefaultLoadOptions(password) 59 container, err := LoadFromP12File(filename, opts) 60 if err != nil { 61 return nil, nil, fmt.Errorf("failed to load P12 file: %w", err) 62 } 63 64 if container.Certificate == nil { 65 return nil, nil, fmt.Errorf("no certificate found in P12 file") 66 } 67 68 // Wrap in GoPKI Certificate 69 goPKICert := &cert.Certificate{ 70 Certificate: container.Certificate, 71 } 72 73 return goPKICert, container.CACertificates, nil 74 } 75 76 // LoadCertificateChainFromP12 loads the complete certificate chain from a P12 file as GoPKI Certificates 77 func LoadCertificateChainFromP12(filename, password string) ([]*cert.Certificate, error) { 78 if filename == "" { 79 return nil, fmt.Errorf("filename is required") 80 } 81 if password == "" { 82 return nil, fmt.Errorf("password is required") 83 } 84 85 // Load P12 file 86 opts := DefaultLoadOptions(password) 87 container, err := LoadFromP12File(filename, opts) 88 if err != nil { 89 return nil, fmt.Errorf("failed to load P12 file: %w", err) 90 } 91 92 var certificates []*cert.Certificate 93 94 // Add the main certificate 95 if container.Certificate != nil { 96 certificates = append(certificates, &cert.Certificate{ 97 Certificate: container.Certificate, 98 }) 99 } 100 101 // Add CA certificates 102 for _, caCert := range container.CACertificates { 103 certificates = append(certificates, &cert.Certificate{ 104 Certificate: caCert, 105 }) 106 } 107 108 if len(certificates) == 0 { 109 return nil, fmt.Errorf("no certificates found in P12 file") 110 } 111 112 return certificates, nil 113 } 114 115 // SaveCertToP12 saves a certificate to PKCS#12 format (requires private key) 116 // Note: This function requires a private key to create a valid P12 file 117 func SaveCertToP12(certificate *cert.Certificate, privateKey keypair.GenericPrivateKey, filename, password string) error { 118 if certificate == nil || certificate.Certificate == nil { 119 return fmt.Errorf("certificate is not initialized") 120 } 121 if privateKey == nil { 122 return fmt.Errorf("private key is required for P12 format") 123 } 124 if filename == "" { 125 return fmt.Errorf("filename is required") 126 } 127 if password == "" { 128 return fmt.Errorf("password is required") 129 } 130 131 // Create P12 file using type-specific approach 132 opts := DefaultCreateOptions(password) 133 switch priv := privateKey.(type) { 134 case *rsa.PrivateKey: 135 return CreateP12File(filename, priv, certificate.Certificate, nil, opts) 136 case *ecdsa.PrivateKey: 137 return CreateP12File(filename, priv, certificate.Certificate, nil, opts) 138 case ed25519.PrivateKey: 139 return CreateP12File(filename, priv, certificate.Certificate, nil, opts) 140 default: 141 return fmt.Errorf("unsupported private key type: %T", privateKey) 142 } 143 } 144 145 // SaveCertToP12WithChain saves a certificate with a certificate chain to PKCS#12 format 146 func SaveCertToP12WithChain(certificate *cert.Certificate, privateKey keypair.GenericPrivateKey, caCerts []*cert.Certificate, filename, password string) error { 147 if certificate == nil || certificate.Certificate == nil { 148 return fmt.Errorf("certificate is not initialized") 149 } 150 if privateKey == nil { 151 return fmt.Errorf("private key is required for P12 format") 152 } 153 if filename == "" { 154 return fmt.Errorf("filename is required") 155 } 156 if password == "" { 157 return fmt.Errorf("password is required") 158 } 159 160 // Convert GoPKI certificates to x509 certificates 161 var x509CACerts []*x509.Certificate 162 for _, caCert := range caCerts { 163 if caCert.Certificate != nil { 164 x509CACerts = append(x509CACerts, caCert.Certificate) 165 } 166 } 167 168 // Create P12 file with chain using type-specific approach 169 opts := DefaultCreateOptions(password) 170 opts.IncludeChain = true 171 switch priv := privateKey.(type) { 172 case *rsa.PrivateKey: 173 return CreateP12File(filename, priv, certificate.Certificate, x509CACerts, opts) 174 case *ecdsa.PrivateKey: 175 return CreateP12File(filename, priv, certificate.Certificate, x509CACerts, opts) 176 case ed25519.PrivateKey: 177 return CreateP12File(filename, priv, certificate.Certificate, x509CACerts, opts) 178 default: 179 return fmt.Errorf("unsupported private key type: %T", privateKey) 180 } 181 } 182 183 // ExtractCertificatesFromP12 extracts all certificates from a P12 file and saves them as separate PEM files 184 func ExtractCertificatesFromP12(p12File, password, outputDir string) error { 185 if p12File == "" { 186 return fmt.Errorf("P12 file path is required") 187 } 188 if password == "" { 189 return fmt.Errorf("password is required") 190 } 191 if outputDir == "" { 192 return fmt.Errorf("output directory is required") 193 } 194 195 // Load P12 file 196 opts := DefaultLoadOptions(password) 197 container, err := LoadFromP12File(p12File, opts) 198 if err != nil { 199 return fmt.Errorf("failed to load P12 file: %w", err) 200 } 201 202 // Create output directory 203 if err := os.MkdirAll(outputDir, 0755); err != nil { 204 return fmt.Errorf("failed to create output directory: %w", err) 205 } 206 207 // Save main certificate 208 if container.Certificate != nil { 209 certFile := filepath.Join(outputDir, "certificate.pem") 210 if err := saveCertificateAsPEM(container.Certificate, certFile); err != nil { 211 return fmt.Errorf("failed to save main certificate: %w", err) 212 } 213 } 214 215 // Save CA certificates 216 for i, caCert := range container.CACertificates { 217 certFile := filepath.Join(outputDir, fmt.Sprintf("ca_cert_%d.pem", i)) 218 if err := saveCertificateAsPEM(caCert, certFile); err != nil { 219 return fmt.Errorf("failed to save CA certificate %d: %w", i, err) 220 } 221 } 222 223 return nil 224 } 225 226 // ValidateP12Certificate validates a certificate in a P12 file 227 func ValidateP12Certificate(filename, password string) (map[string]interface{}, error) { 228 if filename == "" { 229 return nil, fmt.Errorf("filename is required") 230 } 231 if password == "" { 232 return nil, fmt.Errorf("password is required") 233 } 234 235 // Load certificate from P12 236 certificate, caCerts, err := FromP12CertFile(filename, password) 237 if err != nil { 238 return nil, fmt.Errorf("failed to load certificate from P12: %w", err) 239 } 240 241 // Get certificate information 242 info := map[string]interface{}{ 243 "subject": certificate.Certificate.Subject.String(), 244 "issuer": certificate.Certificate.Issuer.String(), 245 "not_before": certificate.Certificate.NotBefore, 246 "not_after": certificate.Certificate.NotAfter, 247 "serial": certificate.Certificate.SerialNumber.String(), 248 "is_ca": certificate.Certificate.IsCA, 249 "chain_length": len(caCerts), 250 } 251 252 // Add chain information 253 if len(caCerts) > 0 { 254 var chainInfo []map[string]interface{} 255 for i, caCert := range caCerts { 256 caInfo := map[string]interface{}{ 257 "index": i, 258 "subject": caCert.Subject.String(), 259 "issuer": caCert.Issuer.String(), 260 "is_ca": caCert.IsCA, 261 } 262 chainInfo = append(chainInfo, caInfo) 263 } 264 info["certificate_chain"] = chainInfo 265 } 266 267 return info, nil 268 } 269 270 // ImportP12AndSavePEM imports a P12 file and saves the certificate as PEM 271 func ImportP12AndSavePEM(p12File, password, pemFile string) error { 272 if p12File == "" { 273 return fmt.Errorf("P12 file path is required") 274 } 275 if password == "" { 276 return fmt.Errorf("password is required") 277 } 278 if pemFile == "" { 279 return fmt.Errorf("PEM file path is required") 280 } 281 282 // Load certificate from P12 283 certificate, _, err := FromP12CertFile(p12File, password) 284 if err != nil { 285 return fmt.Errorf("failed to load certificate from P12: %w", err) 286 } 287 288 // Save as PEM 289 return certificate.SaveToFile(pemFile) 290 } 291 292 // CreateP12FromPEM creates a P12 file from separate PEM files 293 func CreateP12FromPEM(privateKeyFile, certFile, p12File, password string) error { 294 if privateKeyFile == "" { 295 return fmt.Errorf("private key file is required") 296 } 297 if certFile == "" { 298 return fmt.Errorf("certificate file is required") 299 } 300 if p12File == "" { 301 return fmt.Errorf("P12 file path is required") 302 } 303 if password == "" { 304 return fmt.Errorf("password is required") 305 } 306 307 // Load private key 308 privateKey, err := LoadPrivateKeyFromPEM(privateKeyFile) 309 if err != nil { 310 return fmt.Errorf("failed to load private key: %w", err) 311 } 312 313 // Load certificate from PEM file 314 certificate, err := LoadCertificateFromPEMFile(certFile) 315 if err != nil { 316 return fmt.Errorf("failed to load certificate: %w", err) 317 } 318 319 // Create P12 file 320 return SaveCertToP12(certificate, privateKey, p12File, password) 321 } 322 323 // Helper function to save certificate as PEM 324 func saveCertificateAsPEM(cert *x509.Certificate, filename string) error { 325 // Create directory if it doesn't exist 326 dir := filepath.Dir(filename) 327 if err := os.MkdirAll(dir, 0755); err != nil { 328 return fmt.Errorf("failed to create directory: %w", err) 329 } 330 331 // Encode certificate as PEM 332 certPEM := pem.EncodeToMemory(&pem.Block{ 333 Type: "CERTIFICATE", 334 Bytes: cert.Raw, 335 }) 336 337 // Write to file 338 if err := os.WriteFile(filename, certPEM, 0644); err != nil { 339 return fmt.Errorf("failed to write PEM file: %w", err) 340 } 341 342 return nil 343 } 344 345 // LoadCertificateFromPEMFile loads a certificate from PEM file and returns a GoPKI Certificate 346 func LoadCertificateFromPEMFile(filename string) (*cert.Certificate, error) { 347 // Read PEM file 348 pemData, err := os.ReadFile(filename) 349 if err != nil { 350 return nil, fmt.Errorf("failed to read PEM file: %w", err) 351 } 352 353 // Parse PEM block 354 block, _ := pem.Decode(pemData) 355 if block == nil { 356 return nil, fmt.Errorf("failed to parse PEM block") 357 } 358 359 // Parse certificate 360 parsedCert, err := x509.ParseCertificate(block.Bytes) 361 if err != nil { 362 return nil, fmt.Errorf("failed to parse certificate: %w", err) 363 } 364 365 return &cert.Certificate{ 366 Certificate: parsedCert, 367 PEMData: pemData, 368 DERData: parsedCert.Raw, 369 }, nil 370 } 371 372 // LoadPrivateKeyFromPEM loads a private key from PEM file with generic return type 373 func LoadPrivateKeyFromPEM(filename string) (keypair.GenericPrivateKey, error) { 374 // Read PEM file 375 pemData, err := os.ReadFile(filename) 376 if err != nil { 377 return nil, fmt.Errorf("failed to read PEM file: %w", err) 378 } 379 380 // Parse PEM block 381 block, _ := pem.Decode(pemData) 382 if block == nil { 383 return nil, fmt.Errorf("failed to parse PEM block") 384 } 385 386 // Parse private key based on type 387 switch block.Type { 388 case "PRIVATE KEY": 389 return x509.ParsePKCS8PrivateKey(block.Bytes) 390 case "RSA PRIVATE KEY": 391 return x509.ParsePKCS1PrivateKey(block.Bytes) 392 case "EC PRIVATE KEY": 393 return x509.ParseECPrivateKey(block.Bytes) 394 default: 395 return nil, fmt.Errorf("unsupported private key type: %s", block.Type) 396 } 397 } 398 399 // P12CertificateUtils provides utility functions for working with P12 certificates 400 type P12CertificateUtils struct{} 401 402 // ListCertificatesInP12 lists all certificates in a P12 file 403 func (p P12CertificateUtils) ListCertificatesInP12(filename, password string) ([]map[string]interface{}, error) { 404 certificates, err := LoadCertificateChainFromP12(filename, password) 405 if err != nil { 406 return nil, err 407 } 408 409 var certInfos []map[string]interface{} 410 for _, cert := range certificates { 411 info := map[string]interface{}{ 412 "subject": cert.Certificate.Subject.String(), 413 "issuer": cert.Certificate.Issuer.String(), 414 "not_before": cert.Certificate.NotBefore, 415 "not_after": cert.Certificate.NotAfter, 416 "serial": cert.Certificate.SerialNumber.String(), 417 "is_ca": cert.Certificate.IsCA, 418 } 419 certInfos = append(certInfos, info) 420 } 421 422 return certInfos, nil 423 } 424 425 // VerifyP12CertificateChain verifies the certificate chain in a P12 file 426 func (p P12CertificateUtils) VerifyP12CertificateChain(filename, password string) error { 427 // Load with chain validation enabled 428 opts := DefaultLoadOptions(password) 429 opts.ValidateChain = true 430 opts.CheckExpiration = false // Don't check expiration for chain validation 431 432 _, err := LoadFromP12File(filename, opts) 433 if err != nil { 434 return fmt.Errorf("certificate chain verification failed: %w", err) 435 } 436 437 return nil 438 } 439 440 // ConvertP12ChainToPEM converts all certificates in a P12 file to separate PEM files 441 func (p P12CertificateUtils) ConvertP12ChainToPEM(p12File, password, outputPrefix string) error { 442 certificates, err := LoadCertificateChainFromP12(p12File, password) 443 if err != nil { 444 return err 445 } 446 447 for i, cert := range certificates { 448 var filename string 449 if i == 0 { 450 filename = fmt.Sprintf("%s_cert.pem", outputPrefix) 451 } else { 452 filename = fmt.Sprintf("%s_ca_%d.pem", outputPrefix, i-1) 453 } 454 455 if err := cert.SaveToFile(filename); err != nil { 456 return fmt.Errorf("failed to save certificate %d: %w", i, err) 457 } 458 } 459 460 return nil 461 } 462 463 // GetP12CertificateFingerprints gets fingerprints of all certificates in a P12 file 464 func (p P12CertificateUtils) GetP12CertificateFingerprints(filename, password string) (map[string]string, error) { 465 certificates, err := LoadCertificateChainFromP12(filename, password) 466 if err != nil { 467 return nil, err 468 } 469 470 fingerprints := make(map[string]string) 471 for i, cert := range certificates { 472 var name string 473 if i == 0 { 474 name = "certificate" 475 } else { 476 name = fmt.Sprintf("ca_cert_%d", i-1) 477 } 478 479 // Create SHA-256 fingerprint 480 fingerprint := fmt.Sprintf("%x", cert.Certificate.Raw) 481 fingerprints[name] = fingerprint 482 } 483 484 return fingerprints, nil 485 }