Files

233 lines
6.0 KiB
Go

package csr
import (
"crypto"
"crypto/elliptic"
"crypto/x509"
"strings"
"github.com/cockroachdb/errors"
"github.com/effective-security/xpki/cryptoprov"
)
const (
// CurveP256 specifies curve P-256 for ECDSA
CurveP256 = 256
// CurveP384 specifies curve P-384 for ECDSA
CurveP384 = 384
// CurveP521 specifies curve P-521 for ECDSA
CurveP521 = 521
// Post-Quantum ML-DSA (FIPS 204 / Dilithium) algorithm identifiers
AlgoMLDSA = "ML-DSA"
AlgoDilithium = "DILITHIUM"
// ML-DSA parameter sizes (FIPS 204)
MLDSA44 = 44
MLDSA65 = 65
MLDSA87 = 87
)
// KeyPurpose declares the purpose for keys
type KeyPurpose int
const (
// Undefined purpose of key
Undefined KeyPurpose = 0
// SigningKey specifies the purpose of key to be used in signing/verification operations
SigningKey KeyPurpose = 1
// EncryptionKey specifies the purpose of key to be used in encryption/decryption operations
EncryptionKey KeyPurpose = 2
)
// KeyRequestGen contains the algorithm and key size for a new private key.
type KeyRequestGen interface {
Algo() string
Label() string
Size() int
Generate() (crypto.PrivateKey, error)
SigAlgo() x509.SignatureAlgorithm
Purpose() int
}
// KeyRequest contains the algorithm and key size for a new private key.
type KeyRequest struct {
L string `json:"label" yaml:"label"`
A string `json:"algo" yaml:"algo"`
S int `json:"size" yaml:"size"`
P KeyPurpose `json:"purpose" yaml:"purpose"`
prov cryptoprov.Provider `json:"-" yaml:"-"`
}
// Label returns the requested key label.
func (kr *KeyRequest) Label() string {
return kr.L
}
// Algo returns the requested key algorithm represented as a string.
func (kr *KeyRequest) Algo() string {
return kr.A
}
// Size returns the requested key size.
func (kr *KeyRequest) Size() int {
return kr.S
}
// Purpose returns the purpose of the key .
func (kr *KeyRequest) Purpose() int {
return int(kr.P)
}
// SigAlgo returns an appropriate X.509 signature algorithm given the
// key request's type and size.
func (kr *KeyRequest) SigAlgo() x509.SignatureAlgorithm {
return SigAlgo(kr.Algo(), kr.Size())
}
// Generate generates a key as specified in the request. Currently,
// only ECDSA and RSA are supported.
func (kr *KeyRequest) Generate() (crypto.PrivateKey, error) {
switch algo := kr.Algo(); strings.ToUpper(algo) {
case "RSA":
err := validateRSAKeyPairInfoHandler(kr.Size())
if err != nil {
return nil, errors.WithMessage(err, "validate RSA key")
}
pk, err := kr.prov.GenerateRSAKey(kr.Label(), kr.Size(), kr.Purpose())
if err != nil {
return nil, errors.WithMessage(err, "generate RSA key")
}
return pk, nil
case "ECDSA":
err := validateECDSAKeyPairCurveInfoHandler(kr.Size())
if err != nil {
return nil, errors.WithMessage(err, "validate ECDSA key")
}
var curve elliptic.Curve
switch kr.Size() {
case CurveP256:
curve = elliptic.P256()
case CurveP384:
curve = elliptic.P384()
case CurveP521:
curve = elliptic.P521()
default:
return nil, errors.New("invalid curve")
}
pk, err := kr.prov.GenerateECDSAKey(kr.Label(), curve)
if err != nil {
return nil, errors.WithMessage(err, "generate ECDSA key")
}
return pk, nil
case AlgoMLDSA, AlgoDilithium:
err := validateMLDSAKeyPairInfoHandler(kr.Size())
if err != nil {
return nil, errors.WithMessage(err, "validate ML-DSA key")
}
return nil, errors.New("ML-DSA provider key generation requires PQC hardware token or hybrid mode")
default:
return nil, errors.Errorf("invalid algorithm: %s", algo)
}
}
// NewKeyRequest returns KeyRequest from given parameters
func (c *Provider) NewKeyRequest(label, algo string, keySize int, purpose KeyPurpose) *KeyRequest {
return &KeyRequest{
L: label,
A: algo,
S: keySize,
P: purpose,
prov: c.provider,
}
}
// NewKeyRequest returns KeyRequest from given parameters
func NewKeyRequest(prov cryptoprov.Provider, label, algo string, keySize int, purpose KeyPurpose) *KeyRequest {
return &KeyRequest{
L: label,
A: algo,
S: keySize,
P: purpose,
prov: prov,
}
}
// validateRSAKeyPairInfoHandler validates size of the RSA key
func validateRSAKeyPairInfoHandler(size int) error {
if size < 2048 {
return errors.Errorf("RSA key is too weak: %d", size)
}
if size > 4096 {
return errors.Errorf("RSA key size too large: %d", size)
}
return nil
}
// validateECDSAKeyPairCurveInfoHandler validates size of the ECDSA key
func validateECDSAKeyPairCurveInfoHandler(size int) error {
switch size {
case CurveP256, CurveP384, CurveP521:
return nil
}
return errors.Errorf("invalid curve size: %d", size)
}
// validateMLDSAKeyPairInfoHandler validates size of the ML-DSA (Dilithium) parameter set
func validateMLDSAKeyPairInfoHandler(size int) error {
switch size {
case MLDSA44, MLDSA65, MLDSA87:
return nil
}
return errors.Errorf("invalid ML-DSA parameter size (expected 44, 65, or 87): %d", size)
}
// IsPostQuantumAlgo returns true if the algorithm is a supported post-quantum standard
func IsPostQuantumAlgo(algo string) bool {
switch strings.ToUpper(algo) {
case AlgoMLDSA, AlgoDilithium:
return true
default:
return false
}
}
// SigAlgo returns the signature algorithm for a key of algo ("RSA" or
// "ECDSA", case-insensitive) and size, as DefaultSigAlgo chooses it from a
// key: RSA 2048 and 3072 bits SHA-256 (XPKI-114), 4096 bits and above
// SHA-512; ECDSA by curve size. Other algorithms give
// x509.UnknownSignatureAlgorithm.
func SigAlgo(algo string, size int) x509.SignatureAlgorithm {
switch strings.ToUpper(algo) {
case "RSA":
switch {
case size >= 4096:
return x509.SHA512WithRSA
case size >= 2048:
return x509.SHA256WithRSA
default:
// SHA-1 signatures are rejected by x509.CreateCertificate;
// SHA-256 is the floor for any key size.
return x509.SHA256WithRSA
}
case "ECDSA":
switch size {
case CurveP521:
return x509.ECDSAWithSHA512
case CurveP384:
return x509.ECDSAWithSHA384
case CurveP256:
return x509.ECDSAWithSHA256
default:
return x509.ECDSAWithSHA256
}
default:
return x509.UnknownSignatureAlgorithm
}
}