lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

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 }