OrchestrAD/backend/internal/pki/export.go

package pki

import (
	"crypto/rsa"
	"crypto/x509"
	"encoding/pem"
	"fmt"
	"os"
	"path/filepath"

	pkcs12 "software.sslmate.com/src/go-pkcs12"
)

// Export writes the full chain to dir in PEM, DER, and PKCS#12 form. Every call
// overwrites the files, so it is safe to call on each renewal to keep the
// exports current. Private-key files are written 0600.
//
// Files written:
//
//	root.crt / root.key                 root CA (PEM)
//	intermediate.crt / intermediate.key intermediate CA (PEM)
//	server.crt / server.key             leaf (PEM)
//	fullchain.pem                       leaf + intermediate + root (PEM)
//	*.cer                               DER encodings of each certificate
//	server.pfx                          leaf key + leaf cert + CA chain (PKCS#12)
func (c *Chain) Export(dir, pfxPassword string) error {
	if err := os.MkdirAll(dir, 0o700); err != nil {
		return fmt.Errorf("creating tls dir: %w", err)
	}

	writes := []struct {
		name string
		data []byte
		mode os.FileMode
	}{
		{"root.crt", certPEM(c.Root.DER), 0o644},
		{"root.key", keyPEM(c.Root.Key), 0o600},
		{"intermediate.crt", certPEM(c.Intermediate.DER), 0o644},
		{"intermediate.key", keyPEM(c.Intermediate.Key), 0o600},
		{"server.crt", certPEM(c.Leaf.DER), 0o644},
		{"server.key", keyPEM(c.Leaf.Key), 0o600},
		{"fullchain.pem", c.FullChainPEM(), 0o644},
		// DER encodings.
		{"root.cer", c.Root.DER, 0o644},
		{"intermediate.cer", c.Intermediate.DER, 0o644},
		{"server.cer", c.Leaf.DER, 0o644},
	}
	for _, w := range writes {
		if err := os.WriteFile(filepath.Join(dir, w.name), w.data, w.mode); err != nil {
			return fmt.Errorf("writing %s: %w", w.name, err)
		}
	}

	// PKCS#12 bundle: leaf key + leaf cert + CA chain (intermediate, root).
	pfx, err := pkcs12.Modern.Encode(
		c.Leaf.Key,
		c.Leaf.Certificate,
		[]*x509.Certificate{c.Intermediate.Certificate, c.Root.Certificate},
		pfxPassword,
	)
	if err != nil {
		return fmt.Errorf("encoding pfx: %w", err)
	}
	if err := os.WriteFile(filepath.Join(dir, "server.pfx"), pfx, 0o600); err != nil {
		return fmt.Errorf("writing server.pfx: %w", err)
	}
	// Write the PFX password beside the bundle. The two live in the same
	// owner-only directory, so this grants no access that the .pfx itself
	// doesn't already give — and without it an operator importing the bundle
	// by hand has to go digging through settings for a password they never
	// chose.
	if err := os.WriteFile(filepath.Join(dir, "server.pfx.password"), []byte(pfxPassword+"\n"), 0o600); err != nil {
		return fmt.Errorf("writing server.pfx.password: %w", err)
	}
	return nil
}

// LoadCA reads the root and intermediate CA (cert + key) previously written by
// Export from dir, so renewals can re-issue leaves under the same chain.
// Returns (nil, nil, nil) when the CA files are not present yet.
func LoadCA(dir string) (root, intermediate *CertKey, err error) {
	rootCrt := filepath.Join(dir, "root.crt")
	if _, statErr := os.Stat(rootCrt); os.IsNotExist(statErr) {
		return nil, nil, nil
	}
	root, err = loadCertKey(filepath.Join(dir, "root.crt"), filepath.Join(dir, "root.key"))
	if err != nil {
		return nil, nil, fmt.Errorf("loading root CA: %w", err)
	}
	intermediate, err = loadCertKey(filepath.Join(dir, "intermediate.crt"), filepath.Join(dir, "intermediate.key"))
	if err != nil {
		return nil, nil, fmt.Errorf("loading intermediate CA: %w", err)
	}
	return root, intermediate, nil
}

func loadCertKey(certPath, keyPath string) (*CertKey, error) {
	certBytes, err := os.ReadFile(certPath)
	if err != nil {
		return nil, err
	}
	keyBytes, err := os.ReadFile(keyPath)
	if err != nil {
		return nil, err
	}
	cert, err := ParseCertPEM(certBytes)
	if err != nil {
		return nil, err
	}
	key, err := ParseKeyPEM(keyBytes)
	if err != nil {
		return nil, err
	}
	return &CertKey{Certificate: cert, DER: cert.Raw, Key: key}, nil
}

// ParseCertPEM parses the first CERTIFICATE block from PEM bytes.
func ParseCertPEM(b []byte) (*x509.Certificate, error) {
	block, _ := pem.Decode(b)
	if block == nil || block.Type != "CERTIFICATE" {
		return nil, fmt.Errorf("no CERTIFICATE PEM block found")
	}
	return x509.ParseCertificate(block.Bytes)
}

// ParseKeyPEM parses an RSA private key from a PKCS#8 or PKCS#1 PEM block.
func ParseKeyPEM(b []byte) (*rsa.PrivateKey, error) {
	block, _ := pem.Decode(b)
	if block == nil {
		return nil, fmt.Errorf("no PRIVATE KEY PEM block found")
	}
	if k, err := x509.ParsePKCS8PrivateKey(block.Bytes); err == nil {
		if rk, ok := k.(*rsa.PrivateKey); ok {
			return rk, nil
		}
		return nil, fmt.Errorf("private key is not RSA")
	}
	return x509.ParsePKCS1PrivateKey(block.Bytes)
}