codec.rs (7465B)
1 //! Closed private v2 frame, manifest and independent request-index metadata. 2 use core::num::NonZeroU64; 3 use radroots_domain::{EnvelopeEventId, TransactionId, UnixSeconds}; 4 use radroots_storage::command::{ 5 DeliveryAttempt, DeliveryIntent, OperationError, PublicationArtifact, 6 }; 7 use radroots_transport::{TargetSet, policy::SatisfactionPolicy, target::TargetFingerprint}; 8 use serde::{Deserialize, Serialize}; 9 use sha2::{Digest, Sha256}; 10 use zeroize::Zeroizing; 11 12 pub(super) const MAX_BYTES: usize = 393216; 13 pub(super) const PART_BYTES: usize = 16384; 14 pub(super) const PARTS: u8 = 24; 15 const _: () = assert!(MAX_BYTES == PART_BYTES * PARTS as usize); 16 fn bad<E>(_: E) -> OperationError { 17 OperationError::RecoveryRequired 18 } 19 pub(super) fn valid_request(raw: &str) -> bool { 20 raw.len() == 64 21 && raw 22 .bytes() 23 .all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b)) 24 } 25 #[derive(Serialize, Deserialize)] 26 #[serde(deny_unknown_fields)] 27 struct Header<'a> { 28 version: u8, 29 work: [u8; 32], 30 #[serde(borrow)] 31 request: &'a str, 32 event: EnvelopeEventId, 33 intent: [u8; 32], 34 #[serde(deserialize_with = "super::json::targets")] 35 targets: TargetSet, 36 #[serde(deserialize_with = "super::json::small_vec")] 37 selection: Vec<TargetFingerprint>, 38 #[serde(deserialize_with = "super::json::policy")] 39 policy: SatisfactionPolicy, 40 deadline: u64, 41 transaction: TransactionId, 42 retained_at: UnixSeconds, 43 #[serde(deserialize_with = "super::json::small_vec")] 44 ordinals: Vec<u8>, 45 } 46 pub(super) fn encode( 47 value: &DeliveryAttempt, 48 work: [u8; 32], 49 ) -> Result<Zeroizing<Vec<u8>>, OperationError> { 50 for target in value.intent().targets().targets() { 51 if serde_json::to_vec(target).map_err(bad)?.len() > PART_BYTES { 52 return Err(OperationError::InvalidCommand); 53 } 54 } 55 let header = Header { 56 version: if matches!(value.work(), PublicationArtifact::Public(_)) { 57 3 58 } else { 59 2 60 }, 61 work, 62 request: value.intent().request_id().as_str(), 63 event: value.intent().event_id(), 64 intent: *value.intent().digest(), 65 targets: value.intent().targets().clone(), 66 selection: value.intent().selection().to_vec(), 67 policy: value.intent().policy().clone(), 68 deadline: value.intent().deadline_unix_ms().get(), 69 transaction: value.transaction_id(), 70 retained_at: value.retained_at(), 71 ordinals: value.target_ordinals().to_vec(), 72 }; 73 let header = Zeroizing::new(serde_json::to_vec(&header).map_err(bad)?); 74 let length = 4usize 75 .checked_add(header.len()) 76 .and_then(|n| n.checked_add(value.raw_json().len())) 77 .filter(|n| *n <= MAX_BYTES) 78 .ok_or(OperationError::InvalidCommand)?; 79 let mut raw = Zeroizing::new(Vec::with_capacity(length)); 80 raw.extend_from_slice(&(header.len() as u32).to_be_bytes()); 81 raw.extend_from_slice(&header); 82 raw.extend_from_slice(value.raw_json().as_bytes()); 83 Ok(raw) 84 } 85 pub(super) fn decode( 86 raw: &[u8], 87 work: PublicationArtifact, 88 commitment: [u8; 32], 89 ) -> Result<DeliveryAttempt, OperationError> { 90 if raw.len() < 5 || raw.len() > MAX_BYTES { 91 return Err(OperationError::RecoveryRequired); 92 } 93 let boundary = 4usize 94 .checked_add(u32::from_be_bytes(raw[..4].try_into().map_err(bad)?) as usize) 95 .filter(|n| *n < raw.len()) 96 .ok_or(OperationError::RecoveryRequired)?; 97 if !super::json::bounded(&raw[4..boundary], 32) { 98 return Err(OperationError::RecoveryRequired); 99 } 100 let header: Header<'_> = serde_json::from_slice(&raw[4..boundary]).map_err(bad)?; 101 if header.version 102 != if matches!(work, PublicationArtifact::Public(_)) { 103 3 104 } else { 105 2 106 } 107 || header.work != commitment 108 { 109 return Err(OperationError::RecoveryRequired); 110 } 111 let constructor = match work { 112 PublicationArtifact::Private(_) => DeliveryIntent::new, 113 PublicationArtifact::Public(_) => DeliveryIntent::public, 114 }; 115 let intent = constructor( 116 header.request, 117 header.event, 118 &header.targets, 119 &header.policy, 120 NonZeroU64::new(header.deadline).ok_or(OperationError::RecoveryRequired)?, 121 ) 122 .map_err(bad)?; 123 let selected = TargetSet::new( 124 intent 125 .targets() 126 .targets() 127 .iter() 128 .filter(|target| header.selection.contains(target.fingerprint())) 129 .cloned() 130 .collect(), 131 ) 132 .map_err(bad)?; 133 if selected 134 .targets() 135 .iter() 136 .map(|target| target.fingerprint()) 137 .ne(header.selection.iter()) 138 { 139 return Err(OperationError::RecoveryRequired); 140 } 141 let intent = intent.with_selection(&selected).map_err(bad)?; 142 if intent.digest() != &header.intent { 143 return Err(OperationError::RecoveryRequired); 144 } 145 DeliveryAttempt::from_store_report( 146 work, 147 intent, 148 core::str::from_utf8(&raw[boundary..]).map_err(bad)?, 149 header.transaction, 150 header.retained_at, 151 header.ordinals, 152 ) 153 .map_err(bad) 154 } 155 pub(super) struct Manifest { 156 pub request: String, 157 pub event: EnvelopeEventId, 158 pub transaction: TransactionId, 159 pub bytes: usize, 160 pub digest: [u8; 32], 161 } 162 impl Manifest { 163 pub(super) fn encode( 164 value: &DeliveryAttempt, 165 commitment: [u8; 32], 166 frame: &[u8], 167 ) -> Zeroizing<Vec<u8>> { 168 let mut raw = Zeroizing::new(Vec::with_capacity(200)); 169 raw.extend_from_slice(b"RDD2"); 170 raw.extend_from_slice(&commitment); 171 raw.extend_from_slice(value.intent().request_id().as_str().as_bytes()); 172 raw.extend_from_slice(value.intent().event_id().as_bytes()); 173 raw.extend_from_slice(value.transaction_id().as_bytes()); 174 raw.extend_from_slice(&(frame.len() as u32).to_be_bytes()); 175 raw.extend_from_slice(&Sha256::digest(frame)); 176 raw 177 } 178 pub(super) fn decode(raw: &[u8], commitment: [u8; 32]) -> Result<Self, OperationError> { 179 if raw.len() != 200 || &raw[..4] != b"RDD2" || raw[4..36] != commitment { 180 return Err(OperationError::RecoveryRequired); 181 } 182 let request = core::str::from_utf8(&raw[36..100]).map_err(bad)?; 183 let bytes = u32::from_be_bytes(raw[164..168].try_into().map_err(bad)?) as usize; 184 if !valid_request(request) || !(5..=MAX_BYTES).contains(&bytes) { 185 return Err(OperationError::RecoveryRequired); 186 } 187 Ok(Self { 188 request: request.into(), 189 event: EnvelopeEventId::from_bytes(raw[100..132].try_into().map_err(bad)?), 190 transaction: TransactionId::from_bytes(raw[132..164].try_into().map_err(bad)?), 191 bytes, 192 digest: raw[168..200].try_into().map_err(bad)?, 193 }) 194 } 195 pub(super) fn matches(&self, value: &DeliveryAttempt) -> bool { 196 self.request == value.intent().request_id().as_str() 197 && self.event == value.intent().event_id() 198 && self.transaction == value.transaction_id() 199 } 200 } 201 pub(super) fn index(manifest: &[u8], request: &str) -> Zeroizing<Vec<u8>> { 202 let mut raw = Zeroizing::new(Vec::with_capacity(100)); 203 raw.extend_from_slice(b"RDI2"); 204 raw.extend_from_slice(&Sha256::digest(manifest)); 205 raw.extend_from_slice(request.as_bytes()); 206 raw 207 }