Skip to main content

qualia_core_db/crypto/network/
mldsa.rs

1//! ML-DSA-65 adapter with length-delimited network context.
2//!
3//! Historical fiduciary_crypto context hashing concatenates domain and purpose
4//! without lengths. This adapter uses an unambiguous length-delimited context
5//! so old signatures cannot silently acquire the new interpretation.
6
7use fips204::ml_dsa_65;
8use fips204::traits::{SerDes, Signer, Verifier};
9use sha2::{Digest, Sha384};
10
11use super::errors::CryptoError;
12use super::types::{ML_DSA_65_PK_LEN, ML_DSA_65_SIG_LEN, ML_DSA_65_SK_LEN};
13
14const NETWORK_CTX_LABEL: &[u8] = b"QDNF-MLDSA-CTX-V1";
15
16/// ML-DSA-65 keypair generation.
17pub fn generate_keypair() -> Result<([u8; ML_DSA_65_SK_LEN], [u8; ML_DSA_65_PK_LEN]), CryptoError> {
18    let (pk, sk) = ml_dsa_65::try_keygen().map_err(|_| CryptoError::CryptoFailure)?;
19    Ok((sk.into_bytes(), pk.into_bytes()))
20}
21
22/// Compress a length-delimited context into a FIPS-204 ctx (<= 255 bytes).
23fn network_ctx(context: &[u8]) -> [u8; 48] {
24    let mut hasher = Sha384::new();
25    hasher.update(&(NETWORK_CTX_LABEL.len() as u16).to_be_bytes());
26    hasher.update(NETWORK_CTX_LABEL);
27    hasher.update(&(context.len() as u32).to_be_bytes());
28    hasher.update(context);
29    let out = hasher.finalize();
30    let mut ctx = [0u8; 48];
31    ctx.copy_from_slice(&out);
32    ctx
33}
34
35/// ML-DSA-65 sign over message+context.
36pub fn sign(
37    secret: &[u8; ML_DSA_65_SK_LEN],
38    message: &[u8],
39    context: &[u8],
40    sig_out: &mut [u8; ML_DSA_65_SIG_LEN],
41) -> Result<(), CryptoError> {
42    let sk =
43        ml_dsa_65::PrivateKey::try_from_bytes(*secret).map_err(|_| CryptoError::CryptoFailure)?;
44    let ctx = network_ctx(context);
45    let sig = sk
46        .try_sign(message, &ctx)
47        .map_err(|_| CryptoError::CryptoFailure)?;
48    sig_out.copy_from_slice(&sig);
49    Ok(())
50}
51
52/// ML-DSA-65 verify; fails closed on bad signature.
53pub fn verify(
54    public: &[u8; ML_DSA_65_PK_LEN],
55    message: &[u8],
56    context: &[u8],
57    signature: &[u8; ML_DSA_65_SIG_LEN],
58) -> Result<(), CryptoError> {
59    let pk =
60        ml_dsa_65::PublicKey::try_from_bytes(*public).map_err(|_| CryptoError::CryptoFailure)?;
61    let ctx = network_ctx(context);
62    if pk.verify(message, signature, &ctx) {
63        Ok(())
64    } else {
65        Err(CryptoError::Unauthorized)
66    }
67}
68
69#[cfg(test)]
70mod tests {
71    use super::*;
72
73    #[test]
74    fn network_context_is_length_delimited() {
75        let (sk, pk) = generate_keypair().unwrap();
76        let mut sig = [0u8; ML_DSA_65_SIG_LEN];
77        sign(&sk, b"record", b"qlink", &mut sig).unwrap();
78        assert!(verify(&pk, b"record", b"qlink", &sig).is_ok());
79        assert_eq!(
80            verify(&pk, b"record", b"qsession", &sig),
81            Err(CryptoError::Unauthorized)
82        );
83    }
84}