qualia_core_db/crypto/network/cose/
envelope.rs1use 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
10pub 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 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
53pub 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 Ok(3498 + 2 * (head + payload_len))
96}
97
98pub 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
168pub 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}