Add ML-DSA to COSE encoding

Author: fdennis

webauthn-server-core/src/test/scala/com/yubico/webauthn/TestAuthenticator.scala

@@ -85,6 +85,7 @@ import java.security.interfaces.RSAPublicKey
 import java.security.spec.ECGenParameterSpec
 import java.security.spec.ECPoint
 import java.security.spec.ECPublicKeySpec
+import java.security.spec.NamedParameterSpec
 import java.security.spec.PKCS8EncodedKeySpec
 import java.security.spec.X509EncodedKeySpec
 import java.time.Instant
@@ -416,6 +417,8 @@ object TestAuthenticator {
       case pub: BCEdDSAPublicKey => WebAuthnTestCodecs.eddsaPublicKeyToCose(pub)
       case pub: RSAPublicKey =>
         WebAuthnTestCodecs.rsaPublicKeyToCose(pub, keyAlgorithm)
+      case pub if pub.getAlgorithm == "ML-DSA" =>
+        WebAuthnTestCodecs.mlDsaPublicKeyToCose(pub, keyAlgorithm)
     }
 
     val authDataBytes: ByteArray = makeAuthDataBytes(
@@ -1098,8 +1101,15 @@ object TestAuthenticator {
   ): ByteArray = {
     val jAlg = WebAuthnCodecs.getJavaAlgorithmName(alg)
 
-    // Need to use BouncyCastle provider here because JDK15 standard providers do not support secp256k1
-    val sig = Signature.getInstance(jAlg, new BouncyCastleProvider())
+    val sig = alg match {
+      case COSEAlgorithmIdentifier.ML_DSA_44 |
+          COSEAlgorithmIdentifier.ML_DSA_65 |
+          COSEAlgorithmIdentifier.ML_DSA_87 =>
+        Signature.getInstance(jAlg)
+      case _ =>
+        // Need to use BouncyCastle provider here because JDK15 standard providers do not support secp256k1
+        Signature.getInstance(jAlg, new BouncyCastleProvider())
+    }
 
     sig.initSign(key)
     sig.update(data.getBytes)
@@ -1117,6 +1127,10 @@ object TestAuthenticator {
       case COSEAlgorithmIdentifier.RS256 | COSEAlgorithmIdentifier.RS384 |
           COSEAlgorithmIdentifier.RS512 | COSEAlgorithmIdentifier.RS1 =>
         generateRsaKeypair()
+      case COSEAlgorithmIdentifier.ML_DSA_44 |
+          COSEAlgorithmIdentifier.ML_DSA_65 |
+          COSEAlgorithmIdentifier.ML_DSA_87 =>
+        generateMlDsaKeypair(algorithm)
     }
 
   def generateEcKeypair(curve: String = "secp256r1"): KeyPair = {
@@ -1138,6 +1152,15 @@ object TestAuthenticator {
     keyPairGenerator.generateKeyPair()
   }
 
+  def generateMlDsaKeypair(
+      algorithm: COSEAlgorithmIdentifier
+  ): KeyPair = {
+    val alg = WebAuthnCodecs.getJavaAlgorithmName(algorithm)
+    val keyPairGenerator = KeyPairGenerator.getInstance("ML-DSA")
+    keyPairGenerator.initialize(new NamedParameterSpec(alg))
+    keyPairGenerator.generateKeyPair()
+  }
+
   def importEcKeypair(
       privateBytes: ByteArray,
       publicBytes: ByteArray,
@@ -1312,9 +1335,15 @@ object TestAuthenticator {
       val signerBuilder = new JcaContentSignerBuilder(
         WebAuthnCodecs.getJavaAlgorithmName(signingAlg)
       )
-        .setProvider(
-          new BouncyCastleProvider()
-        ) // Needed because JDK15 standard providers do not support secp256k1
+      signingAlg match {
+        case COSEAlgorithmIdentifier.ML_DSA_44 |
+            COSEAlgorithmIdentifier.ML_DSA_65 |
+            COSEAlgorithmIdentifier.ML_DSA_87 =>
+        case _ =>
+          signerBuilder.setProvider(
+            new BouncyCastleProvider()
+          ) // Needed because JDK15 standard providers do not support secp256k1
+      }
 
       builder.build(signerBuilder.build(signingKey)).getEncoded
     })

webauthn-server-core/src/test/scala/com/yubico/webauthn/WebAuthnTestCodecs.scala

@@ -64,6 +64,21 @@ object WebAuthnTestCodecs {
         val keyFactory: KeyFactory = KeyFactory.getInstance("RSA")
         val spec = new PKCS8EncodedKeySpec(encodedKey.getBytes)
         keyFactory.generatePrivate(spec)
+
+      case COSEAlgorithmIdentifier.ML_DSA_44 =>
+        val keyFactory: KeyFactory = KeyFactory.getInstance("ML-DSA-44")
+        val spec = new PKCS8EncodedKeySpec(encodedKey.getBytes)
+        keyFactory.generatePrivate(spec)
+
+      case COSEAlgorithmIdentifier.ML_DSA_65 =>
+        val keyFactory: KeyFactory = KeyFactory.getInstance("ML-DSA-65")
+        val spec = new PKCS8EncodedKeySpec(encodedKey.getBytes)
+        keyFactory.generatePrivate(spec)
+
+      case COSEAlgorithmIdentifier.ML_DSA_87 =>
+        val keyFactory: KeyFactory = KeyFactory.getInstance("ML-DSA-87")
+        val spec = new PKCS8EncodedKeySpec(encodedKey.getBytes)
+        keyFactory.generatePrivate(spec)
     }
 
   def importEcdsaPrivateKey(encodedKey: ByteArray): PrivateKey = {
@@ -94,6 +109,33 @@ object WebAuthnTestCodecs {
     new ByteArray(CBORObject.FromObject(coseKey).EncodeToBytes)
   }
 
+  def mlDsaPublicKeyToCose(
+      key: PublicKey,
+      alg: COSEAlgorithmIdentifier,
+  ): ByteArray = {
+    val encoded = key.getEncoded
+    val algId: Array[Byte] =
+      Try(encoded.slice(4, 17)).getOrElse(
+        throw new IllegalArgumentException("Unknown ML-DSA ASN.1 OID prefix")
+      )
+
+    val keyBytesLength =
+      if (algId.sameElements(WebAuthnCodecs.ML_DSA_44_ALG_ID.getBytes))
+        1312
+      else if (algId.sameElements(WebAuthnCodecs.ML_DSA_65_ALG_ID.getBytes))
+        1952
+      else if (algId.sameElements(WebAuthnCodecs.ML_DSA_87_ALG_ID.getBytes))
+        2592
+      else
+        throw new IllegalArgumentException("Unknown ML-DSA ASN.1 OID prefix")
+
+    val coseKey: java.util.Map[Long, Any] = new java.util.HashMap[Long, Any]
+    coseKey.put(1L, 7L) // Key type: AKP
+    coseKey.put(3L, alg.getId)
+    coseKey.put(-1L, encoded.takeRight(keyBytesLength))
+    new ByteArray(CBORObject.FromObject(coseKey).EncodeToBytes)
+  }
+
   def rsaPublicKeyToCose(
       key: RSAPublicKey,
       alg: COSEAlgorithmIdentifier,