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  }