package hsm import ( "context" "crypto" "crypto/ecdsa" "crypto/rand" "crypto/rsa" "crypto/x509" "encoding/asn1" "encoding/pem" "errors" "fmt" "log" "math/big" "os" "syscall" "time" "github.com/ThalesIgnite/crypto11" "git.cacert.org/cacert-gosigner/pkg/config" ) var ( // 1.3.6.1.4.1.18506.2.3.1 Class3 Policy Version 1 oidCAcertClass3PolicyV1 = []int{1, 3, 6, 1, 4, 1, 18506, 2, 3, 1} errKeyGenerationRefused = errors.New("not in setup mode, refusing key generation") errCertificateGenerationRefused = errors.New("not in setup mode, refusing certificate generation") ) func GetRootCACertificate(ctx context.Context, label string) (*x509.Certificate, error) { var ( certificate *x509.Certificate keyPair crypto.Signer ) sc := GetSignerConfig(ctx) caCert, err := sc.GetCADefinition(label) if err != nil { return nil, err } if !caCert.IsRoot() { return nil, fmt.Errorf("CA definition %s is not a root CA definition", label) } certFile := sc.CertificateFileName(label) certificate, err = loadCertificate(certFile) if err != nil { return nil, err } if certificate != nil && !IsSetupMode(ctx) { caCert.Certificate = certificate return certificate, nil } keyPair, err = getKeyPair(ctx, label, caCert.KeyInfo) if err != nil { return nil, err } if certificate != nil && certificateMatches(certificate, keyPair) { caCert.Certificate, caCert.KeyPair = certificate, keyPair return certificate, nil } if !IsSetupMode(ctx) { return nil, errCertificateGenerationRefused } notBefore, notAfter := sc.CalculateValidity(caCert, time.Now()) subject := sc.CalculateSubject(caCert) certificate, err = generateRootCACertificate( certFile, keyPair, &x509.Certificate{ Subject: subject, NotBefore: notBefore, NotAfter: notAfter, MaxPathLen: 0, MaxPathLenZero: false, BasicConstraintsValid: true, KeyUsage: x509.KeyUsageCRLSign | x509.KeyUsageCertSign, IsCA: true, }, ) if err != nil { return nil, err } p11Context, err := GetP11Context(ctx, caCert) if err != nil { return nil, err } err = addCertificate(p11Context, label, certificate) if err != nil { return nil, err } caCert.Certificate, caCert.KeyPair = certificate, keyPair return certificate, nil } func GetIntermediaryCACertificate(ctx context.Context, certLabel string) (*x509.Certificate, error) { var ( certificate *x509.Certificate keyPair crypto.Signer ) sc := GetSignerConfig(ctx) caCert, err := sc.GetCADefinition(certLabel) if err != nil { return nil, err } if caCert.IsRoot() { return nil, fmt.Errorf( "CA definition %s is a root CA definition, intermediary expected", certLabel, ) } keyPair, err = getKeyPair(ctx, certLabel, caCert.KeyInfo) if err != nil { return nil, err } certFile := sc.CertificateFileName(certLabel) certificate, err = loadCertificate(certFile) if err != nil { return nil, err } if certificate != nil && certificateMatches(certificate, keyPair) { caCert.Certificate, caCert.KeyPair = certificate, keyPair return certificate, nil } if !IsSetupMode(ctx) { return nil, errCertificateGenerationRefused } notBefore, notAfter := sc.CalculateValidity(caCert, time.Now()) subject := sc.CalculateSubject(caCert) certificate, err = generateIntermediaryCACertificate( sc, certLabel, keyPair.Public(), &x509.Certificate{ Subject: subject, NotBefore: notBefore, NotAfter: notAfter, MaxPathLen: caCert.MaxPathLen, MaxPathLenZero: true, BasicConstraintsValid: true, IsCA: true, KeyUsage: x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign | x509.KeyUsageCRLSign, ExtKeyUsage: caCert.ExtKeyUsage, IssuingCertificateURL: []string{sc.BuildIssuerURL(caCert)}, OCSPServer: []string{sc.BuildOCSPURL(caCert)}, CRLDistributionPoints: []string{sc.BuildCRLUrl(caCert)}, PolicyIdentifiers: []asn1.ObjectIdentifier{ // use policy identifiers from http://wiki.cacert.org/OidAllocation oidCAcertClass3PolicyV1, }, }, ) if err != nil { return nil, err } p11Context, err := GetP11Context(ctx, caCert) if err != nil { return nil, err } err = addCertificate(p11Context, certLabel, certificate) if err != nil { return nil, err } caCert.Certificate, caCert.KeyPair = certificate, keyPair return certificate, nil } func generateIntermediaryCACertificate(config *config.SignerConfig, certLabel string, publicKey crypto.PublicKey, template *x509.Certificate) (*x509.Certificate, error) { parent, err := config.GetParentCA(certLabel) if err != nil { return nil, err } serial, err := randomSerialNumber() if err != nil { return nil, err } template.SerialNumber = serial template.SignatureAlgorithm, err = determineSignatureAlgorithm(parent.KeyPair) if err != nil { return nil, err } certBytes, err := x509.CreateCertificate( rand.Reader, template, parent.Certificate, publicKey, parent.KeyPair, ) if err != nil { return nil, fmt.Errorf("could not create intermediary CA certificate: %w", err) } certBlock := &pem.Block{ Type: "CERTIFICATE", Bytes: certBytes, } certFile := config.CertificateFileName(certLabel) err = os.WriteFile(certFile, pem.EncodeToMemory(certBlock), 0o600) if err != nil { return nil, fmt.Errorf("could not write certificate to %s: %w", certFile, err) } certificate, err := x509.ParseCertificate(certBytes) if err != nil { return nil, fmt.Errorf("could not parse generated certificate: %w", err) } return certificate, nil } func addCertificate(p11Context *crypto11.Context, label string, certificate *x509.Certificate) error { objectId, err := randomObjectId() if err != nil { return err } err = p11Context.ImportCertificateWithLabel(objectId, []byte(label), certificate) if err != nil { return fmt.Errorf("could not import certificate into token: %w", err) } return nil } func getKeyPair(ctx context.Context, label string, keyInfo *config.PrivateKeyInfo) (crypto.Signer, error) { sc := GetSignerConfig(ctx) cert, err := sc.GetCADefinition(label) if err != nil { return nil, err } if cert.KeyPair != nil { return cert.KeyPair, nil } p11Context, err := GetP11Context(ctx, cert) if err != nil { return nil, err } keyPair, err := p11Context.FindKeyPair(nil, []byte(label)) if err != nil { return nil, fmt.Errorf("could not find requested key pair: %w", err) } if keyPair != nil { return keyPair, nil } if !IsSetupMode(ctx) { return nil, errKeyGenerationRefused } switch keyInfo.Algorithm { case x509.RSA: keyPair, err = generateRSAKeyPair(p11Context, label, keyInfo) if err != nil { return nil, fmt.Errorf("could not generate RSA key pair: %w", err) } case x509.ECDSA: keyPair, err = generateECDSAKeyPair(p11Context, label, keyInfo) if err != nil { return nil, fmt.Errorf("could not generate ECDSA key pair: %w", err) } default: return nil, fmt.Errorf("could not generate private key with label %s with unsupported key algorithm %s", label, keyInfo.Algorithm) } return keyPair, nil } func generateECDSAKeyPair(p11Context *crypto11.Context, label string, keyInfo *config.PrivateKeyInfo) (crypto11.Signer, error) { newObjectId, err := randomObjectId() if err != nil { return nil, err } return p11Context.GenerateECDSAKeyPairWithLabel(newObjectId, []byte(label), keyInfo.EccCurve) } func generateRSAKeyPair(p11Context *crypto11.Context, label string, keyInfo *config.PrivateKeyInfo) (crypto11.Signer, error) { newObjectId, err := randomObjectId() if err != nil { return nil, err } return p11Context.GenerateRSAKeyPairWithLabel(newObjectId, []byte(label), keyInfo.RSABits) } func randomObjectId() ([]byte, error) { result := make([]byte, 20) _, err := rand.Read(result) if err != nil { return nil, fmt.Errorf("could not create new random object id: %w", err) } return result, nil } func generateRootCACertificate(certFile string, keyPair crypto.Signer, template *x509.Certificate) (*x509.Certificate, error) { serial, err := randomSerialNumber() if err != nil { return nil, err } template.SerialNumber = serial template.SignatureAlgorithm, err = determineSignatureAlgorithm(keyPair) if err != nil { return nil, err } certBytes, err := x509.CreateCertificate( rand.Reader, template, template, keyPair.Public(), keyPair, ) if err != nil { return nil, fmt.Errorf("could not create root certificate: %w", err) } certBlock := &pem.Block{ Type: "CERTIFICATE", Bytes: certBytes, } err = os.WriteFile(certFile, pem.EncodeToMemory(certBlock), 0o600) if err != nil { return nil, fmt.Errorf("could not write certificate to %s: %w", certFile, err) } certificate, err := x509.ParseCertificate(certBytes) if err != nil { return nil, fmt.Errorf("could not parse generated certificate: %w", err) } return certificate, nil } func determineSignatureAlgorithm(keyPair crypto.Signer) (x509.SignatureAlgorithm, error) { switch keyPair.Public().(type) { case *ecdsa.PublicKey: return x509.ECDSAWithSHA256, nil case *rsa.PublicKey: return x509.SHA256WithRSA, nil default: return x509.UnknownSignatureAlgorithm, fmt.Errorf("could not determine signature algorithm for key of type %T", keyPair) } } func certificateMatches(certificate *x509.Certificate, key crypto.Signer) bool { switch v := certificate.PublicKey.(type) { case *ecdsa.PublicKey: if pub, ok := key.Public().(*ecdsa.PublicKey); ok { if v.Equal(pub) { return true } } case *rsa.PublicKey: if pub, ok := key.Public().(*rsa.PublicKey); ok { if v.Equal(pub) { return true } } default: log.Printf("unsupported public key %v", v) } log.Printf( "public key from certificate does not match private key: %s != %s", certificate.PublicKey, key.Public(), ) return false } func loadCertificate(certFile string) (*x509.Certificate, error) { certFileInfo, err := os.Stat(certFile) if err != nil { if errors.Is(err, syscall.ENOENT) { return nil, nil } return nil, fmt.Errorf("could not get info for %s: %w", certFile, err) } if !certFileInfo.Mode().IsRegular() { return nil, fmt.Errorf("certificate file %s is not a regular file", certFile) } certData, err := os.ReadFile(certFile) if err != nil { return nil, fmt.Errorf("could not read %s: %w", certFile, err) } pemData, _ := pem.Decode(certData) if pemData == nil { return nil, fmt.Errorf("no PEM data in %s", certFile) } if pemData.Type != "CERTIFICATE" { return nil, fmt.Errorf("no certificate found in %s", certFile) } certificate, err := x509.ParseCertificate(pemData.Bytes) if err != nil { return nil, fmt.Errorf("could not parse certificate from %s: %w", certFile, err) } return certificate, nil } func randomSerialNumber() (*big.Int, error) { serialNumberLimit := new(big.Int).Lsh(big.NewInt(1), 128) serialNumber, err := rand.Int(rand.Reader, serialNumberLimit) if err != nil { return nil, fmt.Errorf("could not generate serial number: %w", err) } return serialNumber, nil }