Skip to main content

qualia_core_db/crypto/network/cose/
envelope.rs

1//! Strict paired Sign1 envelope and RFC 9052 signing structure.
2use super::cbor::{Reader, Writer};
3use super::{
4    decode_binding, Binding, PairSignatures, ED25519, EXTERNAL_AAD, MAX_BINDING_BYTES,
5    MAX_ENVELOPE_BYTES, MAX_PROTECTED_BYTES, MAX_SIG_STRUCTURE_BYTES, ML_DSA_65,
6};
7use crate::crypto::network::errors::CryptoError;
8use crate::crypto::network::types::{ED25519_SIG_LEN, ML_DSA_65_SIG_LEN};
9
10/// Parsed syntax only, never a signature or authority grant.
11pub struct ParsedPair<'a> {
12    pub(super) binding: Binding<'a>,
13    pub(super) payload: &'a [u8],
14    pub(super) ml_dsa_signature: &'a [u8; ML_DSA_65_SIG_LEN],
15    pub(super) ed_signature: &'a [u8; ED25519_SIG_LEN],
16}
17impl<'a> ParsedPair<'a> {
18    pub fn binding(&self) -> &Binding<'a> {
19        &self.binding
20    }
21    pub fn payload(&self) -> &'a [u8] {
22        self.payload
23    }
24}
25
26fn protected(alg: i64, kid: &[u8; 48], out: &mut [u8]) -> Result<usize, CryptoError> {
27    if alg != ML_DSA_65 && alg != ED25519 {
28        return Err(CryptoError::Unsupported);
29    }
30    let mut w = Writer::new(out);
31    w.head(5, 2)?;
32    w.head(0, 1)?;
33    w.integer(alg)?;
34    w.head(0, 4)?;
35    w.bytes(kid)?;
36    Ok(w.len())
37}
38fn parse_protected(input: &[u8], alg: i64) -> Result<&[u8; 48], CryptoError> {
39    let mut r = Reader::new(input);
40    // Exact ordered map: rejects duplicates, crit and all unreviewed extensions.
41    r.expect(5, 2)?;
42    r.expect(0, 1)?;
43    r.negative(alg)?;
44    r.expect(0, 4)?;
45    let kid = r
46        .bytes(48)?
47        .try_into()
48        .map_err(|_| CryptoError::Malformed)?;
49    r.finish()?;
50    Ok(kid)
51}
52
53/// RFC 9052 Signature1 bytes, with fixed profile AAD and canonical protection.
54/// This function only encodes; its result conveys no signature verification.
55pub fn sig_structure_into(
56    alg: i64,
57    kid: &[u8; 48],
58    payload: &[u8],
59    out: &mut [u8],
60) -> Result<usize, CryptoError> {
61    let binding = decode_binding(payload)?;
62    let expected = match alg {
63        ML_DSA_65 => &binding.key_ids.ml_dsa_65,
64        ED25519 => &binding.key_ids.ed25519,
65        _ => return Err(CryptoError::Unsupported),
66    };
67    if kid != expected {
68        return Err(CryptoError::Unauthorized);
69    }
70    let mut header = [0; MAX_PROTECTED_BYTES];
71    let n = protected(alg, kid, &mut header)?;
72    let cap = out.len().min(MAX_SIG_STRUCTURE_BYTES);
73    let mut w = Writer::new(&mut out[..cap]);
74    w.head(4, 4)?;
75    w.text("Signature1")?;
76    w.bytes(&header[..n])?;
77    w.bytes(EXTERNAL_AAD)?;
78    w.bytes(payload)?;
79    Ok(w.len())
80}
81
82pub(super) fn encoded_len(payload_len: usize) -> Result<usize, CryptoError> {
83    if payload_len > MAX_BINDING_BYTES {
84        return Err(CryptoError::Capacity);
85    }
86    let head = if payload_len < 24 {
87        1
88    } else if payload_len < 256 {
89        2
90    } else {
91        3
92    };
93    // Two tag/array/protected/map/signature envelopes + outer array.
94    // Protected lengths are 55 (-49) and 54 (-19); signature heads are 3/2.
95    Ok(3498 + 2 * (head + payload_len))
96}
97
98/// Serialize canonical binding bytes and supplied signatures; does not verify.
99/// No prefix is valid after an error. Detached/extension encodings are excluded.
100pub fn encode_pair(
101    payload: &[u8],
102    signatures: &PairSignatures,
103    out: &mut [u8],
104) -> Result<usize, CryptoError> {
105    let binding = decode_binding(payload)?;
106    let need = encoded_len(payload.len())?;
107    if out.len() < need {
108        return Err(CryptoError::Capacity);
109    }
110    let mut w = Writer::new(&mut out[..need]);
111    w.head(4, 2)?;
112    write_sign1(
113        &mut w,
114        ML_DSA_65,
115        &binding.key_ids.ml_dsa_65,
116        payload,
117        &signatures.ml_dsa_65,
118    )?;
119    write_sign1(
120        &mut w,
121        ED25519,
122        &binding.key_ids.ed25519,
123        payload,
124        &signatures.ed25519,
125    )?;
126    debug_assert_eq!(w.len(), need);
127    Ok(w.len())
128}
129fn write_sign1(
130    w: &mut Writer<'_>,
131    alg: i64,
132    kid: &[u8; 48],
133    payload: &[u8],
134    signature: &[u8],
135) -> Result<(), CryptoError> {
136    let mut header = [0; MAX_PROTECTED_BYTES];
137    let n = protected(alg, kid, &mut header)?;
138    w.head(6, 18)?;
139    w.head(4, 4)?;
140    w.bytes(&header[..n])?;
141    w.head(5, 0)?;
142    w.bytes(payload)?;
143    w.bytes(signature)
144}
145
146struct Member<'a> {
147    kid: &'a [u8; 48],
148    payload: &'a [u8],
149    signature: &'a [u8],
150}
151fn read_sign1<'a>(r: &mut Reader<'a>, alg: i64, sig_len: usize) -> Result<Member<'a>, CryptoError> {
152    r.expect(6, 18)?;
153    r.expect(4, 4)?;
154    let kid = parse_protected(r.bytes(MAX_PROTECTED_BYTES)?, alg)?;
155    r.expect(5, 0)?;
156    let payload = r.bytes(MAX_BINDING_BYTES)?;
157    let signature = r.bytes(sig_len)?;
158    if signature.len() != sig_len {
159        return Err(CryptoError::Malformed);
160    }
161    Ok(Member {
162        kid,
163        payload,
164        signature,
165    })
166}
167
168/// Parse syntax and common payload/key role consistency, without crypto checks.
169pub fn decode_pair(input: &[u8]) -> Result<ParsedPair<'_>, CryptoError> {
170    if input.len() > MAX_ENVELOPE_BYTES {
171        return Err(CryptoError::Capacity);
172    }
173    let mut r = Reader::new(input);
174    r.expect(4, 2)?;
175    let ml = read_sign1(&mut r, ML_DSA_65, ML_DSA_65_SIG_LEN)?;
176    let ed = read_sign1(&mut r, ED25519, ED25519_SIG_LEN)?;
177    r.finish()?;
178    if ml.payload != ed.payload {
179        return Err(CryptoError::Unauthorized);
180    }
181    let binding = decode_binding(ml.payload)?;
182    if ml.kid != &binding.key_ids.ml_dsa_65 || ed.kid != &binding.key_ids.ed25519 {
183        return Err(CryptoError::Unauthorized);
184    }
185    Ok(ParsedPair {
186        binding,
187        payload: ml.payload,
188        ml_dsa_signature: ml
189            .signature
190            .try_into()
191            .map_err(|_| CryptoError::Malformed)?,
192        ed_signature: ed
193            .signature
194            .try_into()
195            .map_err(|_| CryptoError::Malformed)?,
196    })
197}