Skip to content
Closed
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 2 additions & 0 deletions acme/api/internal/secure/signer.go
Original file line number Diff line number Diff line change
Expand Up @@ -160,6 +160,8 @@ func signatureAlgorithm(privKey crypto.Signer) jose.SignatureAlgorithm {
} else if k.Curve == elliptic.P384() {
alg = jose.ES384
}
default:
alg = mldsaSignatureAlgorithm(k)
}

return alg
Expand Down
28 changes: 28 additions & 0 deletions acme/api/internal/secure/signer_mldsa.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,28 @@
//go:build go1.27

package secure

import (
"crypto"
"crypto/mldsa"

"github.com/go-jose/go-jose/v4"
)

func mldsaSignatureAlgorithm(pubKey crypto.PublicKey) jose.SignatureAlgorithm {
k, ok := pubKey.(*mldsa.PublicKey)
if !ok {
return ""
}

switch k.Parameters() {
case mldsa.MLDSA44():
return jose.MLDSA44
case mldsa.MLDSA65():
return jose.MLDSA65
case mldsa.MLDSA87():
return jose.MLDSA87
}

return ""
}
22 changes: 22 additions & 0 deletions acme/api/internal/secure/signer_mldsa_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,22 @@
//go:build go1.27

package secure

import (
"crypto/mldsa"
"testing"

"github.com/stretchr/testify/require"
)

func TestSigner_SignContent_mldsa(t *testing.T) {
privKey, err := mldsa.GenerateKey(mldsa.MLDSA44())
require.NoError(t, err)

signer := NewSigner(privKey, "https://foo.example/kid")

content, err := signer.SignContent(&MockNonceSource{}, "https://foo.example", []byte("{}"))
require.NoError(t, err)

check(t, content)
}
14 changes: 14 additions & 0 deletions acme/api/internal/secure/signer_no_mldsa.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,14 @@
//go:build !go1.27

package secure

import (
"crypto"

"github.com/go-jose/go-jose/v4"
)

// ML-DSA requires Go 1.27 or later.
func mldsaSignatureAlgorithm(_ crypto.PublicKey) jose.SignatureAlgorithm {
return ""
}
19 changes: 16 additions & 3 deletions certcrypto/crypto.go
Original file line number Diff line number Diff line change
Expand Up @@ -99,6 +99,10 @@ func ParsePEMPrivateKey(key []byte) (crypto.Signer, error) {
case ed25519.PrivateKey:
return key, nil
default:
if signer, ok := key.(crypto.Signer); ok && isMLDSAPrivateKey(key) {
return signer, nil
}

return nil, fmt.Errorf("found unknown private key type in PKCS#8 wrapping: %T", key)
}
}
Expand Down Expand Up @@ -126,7 +130,7 @@ func GeneratePrivateKey(keyType KeyType) (crypto.Signer, error) {
return rsa.GenerateKey(rand.Reader, 8192)
}

return nil, fmt.Errorf("invalid KeyType: %s", keyType)
return generateMLDSAKey(keyType)
}

type CSROptions struct {
Expand Down Expand Up @@ -176,17 +180,26 @@ func PEMBlock(data any) *pem.Block {

switch key := data.(type) {
case *ecdsa.PrivateKey, *rsa.PrivateKey:
keyBytes, _ := x509.MarshalPKCS8PrivateKey(key)
pemBlock = &pem.Block{Type: "PRIVATE KEY", Bytes: keyBytes}
pemBlock = pkcs8PEMBlock(key)
case *x509.CertificateRequest:
pemBlock = &pem.Block{Type: "CERTIFICATE REQUEST", Bytes: key.Raw}
case DERCertificateBytes:
pemBlock = &pem.Block{Type: "CERTIFICATE", Bytes: []byte(data.(DERCertificateBytes))}
default:
if isMLDSAPrivateKey(key) {
pemBlock = pkcs8PEMBlock(key)
}
}

return pemBlock
}

func pkcs8PEMBlock(key any) *pem.Block {
keyBytes, _ := x509.MarshalPKCS8PrivateKey(key)

return &pem.Block{Type: "PRIVATE KEY", Bytes: keyBytes}
}

func pemDecode(data []byte) (*pem.Block, error) {
pemBlock, _ := pem.Decode(data)
if pemBlock == nil {
Expand Down
11 changes: 8 additions & 3 deletions certcrypto/keytypes.go
Original file line number Diff line number Diff line change
Expand Up @@ -46,14 +46,19 @@ func ToKeyType(keyType string) (KeyType, error) {
return EC384, nil
}

kt := KeyType(strings.ToUpper(keyType))
if slices.Contains(mldsaKeyTypes(), kt) {
return kt, nil
}

return "", fmt.Errorf("unsupported key type: %s", keyType)
}

func AllKeyTypes() []KeyType {
return []KeyType{
return append([]KeyType{
EC256, EC384,
RSA2048, RSA3072, RSA4096, RSA8192,
}
}, mldsaKeyTypes()...)
}

// IsSupported checks if the key type is supported.
Expand Down Expand Up @@ -92,7 +97,7 @@ func GetKeyType(key any) (KeyType, error) {
return getECDSAKeyType(k.Curve)

default:
return "", fmt.Errorf("unsupported key type: %T", k)
return getMLDSAKeyType(k)
}
}

Expand Down
68 changes: 68 additions & 0 deletions certcrypto/mldsa.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,68 @@
//go:build go1.27

package certcrypto

import (
"crypto"
"crypto/mldsa"
"fmt"
)

const (
MLDSA44 = KeyType("MLDSA44")
MLDSA65 = KeyType("MLDSA65")
MLDSA87 = KeyType("MLDSA87")
)

// mldsaKeyTypes returns the ML-DSA key types supported by this build.
func mldsaKeyTypes() []KeyType {
return []KeyType{MLDSA44, MLDSA65, MLDSA87}
}

// generateMLDSAKey generates an ML-DSA private key. It returns an error if
// keyType is not an ML-DSA key type.
func generateMLDSAKey(keyType KeyType) (crypto.Signer, error) {
switch keyType {
case MLDSA44:
return mldsa.GenerateKey(mldsa.MLDSA44())
case MLDSA65:
return mldsa.GenerateKey(mldsa.MLDSA65())
case MLDSA87:
return mldsa.GenerateKey(mldsa.MLDSA87())
}

return nil, fmt.Errorf("invalid KeyType: %s", keyType)
}

// isMLDSAPrivateKey reports whether key is an ML-DSA private key.
func isMLDSAPrivateKey(key any) bool {
_, ok := key.(*mldsa.PrivateKey)

return ok
}

// getMLDSAKeyType gets the key type of an ML-DSA key.
// It returns an error if key is not an ML-DSA key.
func getMLDSAKeyType(key any) (KeyType, error) {
var params mldsa.Parameters

switch k := key.(type) {
case *mldsa.PublicKey:
params = k.Parameters()
case *mldsa.PrivateKey:
params = k.PublicKey().Parameters()
default:
return "", fmt.Errorf("unsupported key type: %T", key)
}

switch params {
case mldsa.MLDSA44():
return MLDSA44, nil
case mldsa.MLDSA65():
return MLDSA65, nil
case mldsa.MLDSA87():
return MLDSA87, nil
default:
return "", fmt.Errorf("unsupported ML-DSA parameters: %s", params)
}
}
108 changes: 108 additions & 0 deletions certcrypto/mldsa_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,108 @@
//go:build go1.27

package certcrypto

import (
"crypto/mldsa"
"crypto/x509"
"encoding/pem"
"strings"
"testing"

"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)

func TestGeneratePrivateKey_mldsa(t *testing.T) {
testCases := []struct {
keyType KeyType
expected mldsa.Parameters
}{
{keyType: MLDSA44, expected: mldsa.MLDSA44()},
{keyType: MLDSA65, expected: mldsa.MLDSA65()},
{keyType: MLDSA87, expected: mldsa.MLDSA87()},
}

for _, test := range testCases {
t.Run(test.keyType.String(), func(t *testing.T) {
t.Parallel()

key, err := GeneratePrivateKey(test.keyType)
require.NoError(t, err)

require.IsType(t, &mldsa.PrivateKey{}, key)
assert.Equal(t, test.expected, key.(*mldsa.PrivateKey).PublicKey().Parameters())

keyType, err := GetPrivateKeyType(key)
require.NoError(t, err)

assert.Equal(t, test.keyType, keyType)

keyType, err = GetKeyType(key)
require.NoError(t, err)

assert.Equal(t, test.keyType, keyType)
})
}
}

func TestPEMEncode_mldsa(t *testing.T) {
for _, keyType := range []KeyType{MLDSA44, MLDSA65, MLDSA87} {
t.Run(keyType.String(), func(t *testing.T) {
t.Parallel()

privateKey, err := GeneratePrivateKey(keyType)
require.NoError(t, err)

data := PEMEncode(privateKey)
require.NotNil(t, data)

p, rest := pem.Decode(data)

assert.Equal(t, "PRIVATE KEY", p.Type)
assert.Empty(t, rest)
assert.Empty(t, p.Headers)

decoded, err := ParsePEMPrivateKey(data)
require.NoError(t, err)

require.IsType(t, &mldsa.PrivateKey{}, decoded)
assert.True(t, decoded.(*mldsa.PrivateKey).Equal(privateKey))
})
}
}

func TestCreateCSR_mldsa(t *testing.T) {
privateKey, err := GeneratePrivateKey(MLDSA44)
require.NoError(t, err)

der, err := CreateCSR(privateKey, CSROptions{SAN: []string{testDomain1}})
require.NoError(t, err)

csr, err := x509.ParseCertificateRequest(der)
require.NoError(t, err)

require.NoError(t, csr.CheckSignature())

assert.Equal(t, []string{testDomain1}, csr.DNSNames)

keyType, err := GetCSRKeyType(csr)
require.NoError(t, err)

assert.Equal(t, MLDSA44, keyType)
}

func TestToKeyType_mldsa(t *testing.T) {
for _, expected := range []KeyType{MLDSA44, MLDSA65, MLDSA87} {
t.Run(expected.String(), func(t *testing.T) {
t.Parallel()

keyType, err := ToKeyType(strings.ToLower(expected.String()))
require.NoError(t, err)

assert.Equal(t, expected, keyType)
assert.True(t, IsSupported(keyType))
assert.Contains(t, AllKeyTypes(), keyType)
})
}
}
24 changes: 24 additions & 0 deletions certcrypto/no_mldsa.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,24 @@
//go:build !go1.27

package certcrypto

import (
"crypto"
"fmt"
)

func mldsaKeyTypes() []KeyType {
return nil
}

func generateMLDSAKey(keyType KeyType) (crypto.Signer, error) {
return nil, fmt.Errorf("invalid KeyType: %s", keyType)
}

func isMLDSAPrivateKey(_ any) bool {
return false
}

func getMLDSAKeyType(key any) (KeyType, error) {
return "", fmt.Errorf("unsupported key type: %T", key)
}
Loading
Loading