lib

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

codec.rs (21095B)


      1 use super::super::{
      2     crypto::{DeliveryPayload, DeliveryScope, PRIVATE_PAYLOAD_MAX_BYTES, WorkspaceCrypto},
      3     installation::EvidenceRef,
      4 };
      5 use super::{MAX_BYTES, MAX_PROTECTED_BYTES};
      6 use radroots_domain::{EnvelopeEventId, TransactionId, UnixSeconds};
      7 use radroots_storage::command::{
      8     DeliveryAttempt, DeliveryIntent, OperationError, PublicationArtifact, PublicationWork,
      9 };
     10 use radroots_transport::{TargetSet, policy::SatisfactionPolicy};
     11 use serde::{Deserialize, Serialize};
     12 use sha2::{Digest, Sha256};
     13 use sqlx::{Row, SqliteConnection};
     14 use zeroize::Zeroizing;
     15 
     16 #[cfg(test)]
     17 #[path = "codec_tests.rs"]
     18 mod tests;
     19 
     20 #[derive(Serialize, Deserialize, Eq, PartialEq)]
     21 #[serde(deny_unknown_fields)]
     22 pub(super) struct PrivateWorkRef {
     23     installation: TransactionId,
     24     plan: [u8; 32],
     25     evidence: EvidenceRef,
     26     transaction: TransactionId,
     27     queued_at: UnixSeconds,
     28 }
     29 impl PrivateWorkRef {
     30     pub(super) fn new(work: PublicationWork) -> Self {
     31         Self {
     32             installation: work.installation_transaction_id(),
     33             plan: *work.plan_digest(),
     34             evidence: EvidenceRef::new(work.evidence(), work.recipient()),
     35             transaction: work.transaction_id(),
     36             queued_at: work.queued_at(),
     37         }
     38     }
     39 }
     40 
     41 #[derive(Serialize, Deserialize, Eq, PartialEq)]
     42 #[serde(deny_unknown_fields)]
     43 pub(super) struct PublicWorkRef {
     44     role: u8,
     45     #[serde(deserialize_with = "required_recipient")]
     46     recipient: Option<radroots_domain::PublicKey>,
     47     installation: TransactionId,
     48     plan: [u8; 32],
     49     evidence: super::super::listing_installation::PublicEvidenceRef,
     50     transaction: TransactionId,
     51     queued_at: UnixSeconds,
     52 }
     53 fn required_recipient<'de, D: serde::Deserializer<'de>>(
     54     d: D,
     55 ) -> Result<Option<radroots_domain::PublicKey>, D::Error> {
     56     Option::<radroots_domain::PublicKey>::deserialize(d)
     57 }
     58 #[derive(Serialize, Deserialize, Eq, PartialEq)]
     59 #[serde(untagged)]
     60 pub(super) enum WorkRef {
     61     Private(PrivateWorkRef),
     62     Public(PublicWorkRef),
     63 }
     64 impl WorkRef {
     65     pub(super) fn new(work: impl Into<PublicationArtifact>) -> Self {
     66         match work.into() {
     67             PublicationArtifact::Private(v) => Self::Private(PrivateWorkRef::new(v)),
     68             PublicationArtifact::Public(v) => Self::Public(PublicWorkRef {
     69                 role: 0,
     70                 recipient: None,
     71                 installation: v.installation_transaction_id(),
     72                 plan: *v.plan_digest(),
     73                 evidence: super::super::listing_installation::PublicEvidenceRef::new(v.evidence()),
     74                 transaction: v.transaction_id(),
     75                 queued_at: v.queued_at(),
     76             }),
     77         }
     78     }
     79 }
     80 fn version(work: PublicationArtifact) -> u8 {
     81     match work {
     82         PublicationArtifact::Private(_) => 1,
     83         PublicationArtifact::Public(_) => 2,
     84     }
     85 }
     86 fn intent(
     87     work: PublicationArtifact,
     88     request: &str,
     89     event: EnvelopeEventId,
     90     targets: &TargetSet,
     91     policy: &SatisfactionPolicy,
     92     deadline: core::num::NonZeroU64,
     93 ) -> Result<DeliveryIntent, OperationError> {
     94     match work {
     95         PublicationArtifact::Private(_) => {
     96             DeliveryIntent::new(request, event, targets, policy, deadline)
     97         }
     98         PublicationArtifact::Public(_) => {
     99             DeliveryIntent::public(request, event, targets, policy, deadline)
    100         }
    101     }
    102 }
    103 
    104 #[derive(Serialize, Deserialize, Eq, PartialEq)]
    105 #[serde(deny_unknown_fields)]
    106 struct Header {
    107     version: u8,
    108     work: WorkRef,
    109     request: String,
    110     event: EnvelopeEventId,
    111     intent: [u8; 32],
    112     #[serde(deserialize_with = "super::json::targets")]
    113     targets: TargetSet,
    114     #[serde(deserialize_with = "super::json::small_vec")]
    115     selection: Vec<radroots_transport::target::TargetFingerprint>,
    116     #[serde(deserialize_with = "super::json::policy")]
    117     policy: SatisfactionPolicy,
    118     deadline: u64,
    119     transaction: TransactionId,
    120     retained_at: UnixSeconds,
    121     #[serde(deserialize_with = "super::json::small_vec")]
    122     ordinals: Vec<u8>,
    123 }
    124 impl Header {
    125     fn new(value: &DeliveryAttempt) -> Self {
    126         Self {
    127             version: version(value.work()),
    128             work: WorkRef::new(value.work()),
    129             request: value.intent().request_id().as_str().into(),
    130             event: value.intent().event_id(),
    131             intent: *value.intent().digest(),
    132             targets: value.intent().targets().clone(),
    133             selection: value.intent().selection().to_vec(),
    134             policy: value.intent().policy().clone(),
    135             deadline: value.intent().deadline_unix_ms().get(),
    136             transaction: value.transaction_id(),
    137             retained_at: value.retained_at(),
    138             ordinals: value.target_ordinals().to_vec(),
    139         }
    140     }
    141     fn into_attempt(
    142         self,
    143         work: PublicationArtifact,
    144         raw: &str,
    145     ) -> Result<DeliveryAttempt, OperationError> {
    146         if self.version != version(work) || self.work != WorkRef::new(work) {
    147             return Err(OperationError::RecoveryRequired);
    148         }
    149         let intent = intent(
    150             work,
    151             &self.request,
    152             self.event,
    153             &self.targets,
    154             &self.policy,
    155             core::num::NonZeroU64::new(self.deadline).ok_or(OperationError::RecoveryRequired)?,
    156         )
    157         .map_err(|_| OperationError::RecoveryRequired)?;
    158         let selected = TargetSet::new(
    159             intent
    160                 .targets()
    161                 .targets()
    162                 .iter()
    163                 .filter(|target| self.selection.contains(target.fingerprint()))
    164                 .cloned()
    165                 .collect(),
    166         )
    167         .map_err(|_| OperationError::RecoveryRequired)?;
    168         if selected
    169             .targets()
    170             .iter()
    171             .map(|target| target.fingerprint())
    172             .ne(self.selection.iter())
    173         {
    174             return Err(OperationError::RecoveryRequired);
    175         }
    176         let intent = intent
    177             .with_selection(&selected)
    178             .map_err(|_| OperationError::RecoveryRequired)?;
    179         if intent.digest() != &self.intent {
    180             return Err(OperationError::RecoveryRequired);
    181         }
    182         DeliveryAttempt::from_store_report(
    183             work,
    184             intent,
    185             raw,
    186             self.transaction,
    187             self.retained_at,
    188             self.ordinals,
    189         )
    190         .map_err(|_| OperationError::RecoveryRequired)
    191     }
    192 }
    193 #[derive(Serialize, Deserialize)]
    194 #[serde(deny_unknown_fields)]
    195 struct Manifest {
    196     version: u8,
    197     work: WorkRef,
    198     request: String,
    199     event: EnvelopeEventId,
    200     transaction: TransactionId,
    201     parts: usize,
    202     bytes: usize,
    203     digest: [u8; 32],
    204 }
    205 
    206 pub(super) fn request_key(request: &str) -> [u8; 32] {
    207     let mut hash = Sha256::new();
    208     hash.update(b"radroots.delivery.request.key.v1\0");
    209     hash.update(request.as_bytes());
    210     hash.finalize().into()
    211 }
    212 pub(super) fn scope(work: PublicationArtifact, key: [u8; 32]) -> DeliveryScope {
    213     let e = work.evidence();
    214     DeliveryScope {
    215         workspace: e.workspace_id(),
    216         operation: e.operation_id(),
    217         target: work.target(),
    218         request: key,
    219     }
    220 }
    221 fn invalid<E>(_: E) -> OperationError {
    222     OperationError::RecoveryRequired
    223 }
    224 fn bytes(row: &sqlx::sqlite::SqliteRow, index: usize) -> Result<Vec<u8>, OperationError> {
    225     row.try_get::<Option<Vec<u8>>, _>(index)
    226         .map_err(invalid)?
    227         .ok_or(OperationError::RecoveryRequired)
    228 }
    229 
    230 pub(super) struct ProtectedAttempt {
    231     pub report: DeliveryAttempt,
    232     pub manifest: Vec<u8>,
    233     pub parts: Vec<Vec<u8>>,
    234     pub bytes: usize,
    235 }
    236 pub(super) struct Fact {
    237     pub scope: DeliveryScope,
    238     pub event: EnvelopeEventId,
    239     pub transaction: TransactionId,
    240     pub bytes: usize,
    241     pub manifest_digest: [u8; 32],
    242     pub parts: Vec<[u8; 32]>,
    243 }
    244 impl ProtectedAttempt {
    245     pub(super) fn fact(&self) -> Fact {
    246         Fact {
    247             scope: scope(
    248                 self.report.work(),
    249                 request_key(self.report.intent().request_id().as_str()),
    250             ),
    251             event: self.report.intent().event_id(),
    252             transaction: self.report.transaction_id(),
    253             bytes: self.bytes,
    254             manifest_digest: Sha256::digest(&self.manifest).into(),
    255             parts: self
    256                 .parts
    257                 .iter()
    258                 .map(|v| Sha256::digest(v).into())
    259                 .collect(),
    260         }
    261     }
    262 }
    263 
    264 pub(super) async fn protect(
    265     report: DeliveryAttempt,
    266     crypto: &WorkspaceCrypto,
    267 ) -> Result<ProtectedAttempt, OperationError> {
    268     // Every target descriptor is independently within the private-record bound;
    269     // the composite frame has the fixed 24-part owning-store bound.
    270     for target in report.intent().targets().targets() {
    271         if serde_json::to_vec(target)
    272             .map_err(|_| OperationError::InvalidCommand)?
    273             .len()
    274             > PRIVATE_PAYLOAD_MAX_BYTES
    275         {
    276             return Err(OperationError::InvalidCommand);
    277         }
    278     }
    279     let header = Zeroizing::new(
    280         serde_json::to_vec(&Header::new(&report)).map_err(|_| OperationError::InvalidCommand)?,
    281     );
    282     let size = 4usize
    283         .checked_add(header.len())
    284         .and_then(|n| n.checked_add(report.raw_json().len()))
    285         .filter(|n| *n <= MAX_BYTES)
    286         .ok_or(OperationError::InvalidCommand)?;
    287     let mut plain = Zeroizing::new(Vec::with_capacity(size));
    288     plain.extend_from_slice(&(header.len() as u32).to_be_bytes());
    289     plain.extend_from_slice(&header);
    290     plain.extend_from_slice(report.raw_json().as_bytes());
    291     let selected = scope(
    292         report.work(),
    293         request_key(report.intent().request_id().as_str()),
    294     );
    295     let mut parts = Vec::new();
    296     let mut total = 0usize;
    297     for (index, chunk) in plain.chunks(PRIVATE_PAYLOAD_MAX_BYTES).enumerate() {
    298         let protected = crypto
    299             .seal_delivery(selected, DeliveryPayload::Attempt, (index + 1) as u8, chunk)
    300             .await?;
    301         total = total
    302             .checked_add(protected.len())
    303             .filter(|n| *n <= MAX_PROTECTED_BYTES)
    304             .ok_or(OperationError::InvalidEvidence)?;
    305         parts.push(protected);
    306     }
    307     let manifest = Manifest {
    308         version: version(report.work()),
    309         work: WorkRef::new(report.work()),
    310         request: report.intent().request_id().as_str().into(),
    311         event: report.intent().event_id(),
    312         transaction: report.transaction_id(),
    313         parts: parts.len(),
    314         bytes: plain.len(),
    315         digest: Sha256::digest(&plain).into(),
    316     };
    317     let encoded =
    318         Zeroizing::new(serde_json::to_vec(&manifest).map_err(|_| OperationError::InvalidCommand)?);
    319     let manifest = crypto
    320         .seal_delivery(selected, DeliveryPayload::Attempt, 0, &encoded)
    321         .await?;
    322     if total
    323         .checked_add(manifest.len())
    324         .is_none_or(|n| n > MAX_PROTECTED_BYTES)
    325     {
    326         return Err(OperationError::InvalidEvidence);
    327     }
    328     Ok(ProtectedAttempt {
    329         report,
    330         manifest,
    331         parts,
    332         bytes: plain.len(),
    333     })
    334 }
    335 
    336 pub(super) async fn read(
    337     connection: &mut SqliteConnection,
    338     work: PublicationArtifact,
    339     key: [u8; 32],
    340     crypto: &WorkspaceCrypto,
    341 ) -> Result<Option<ProtectedAttempt>, OperationError> {
    342     let s = scope(work, key);
    343     let row=sqlx::query(super::sql(connection,"SELECT CASE WHEN length(event_id)=32 THEN event_id END,CASE WHEN length(transaction_id)=32 THEN transaction_id END,part_count,byte_count,CASE WHEN length(protected)>0 AND length(protected)<=262144 THEN protected END FROM chat_delivery_attempts WHERE workspace=? AND operation_id=? AND recipient=? AND request_key=?").await?)
    344         .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.target.key().as_slice()).bind(s.request.as_slice()).fetch_optional(&mut *connection).await.map_err(invalid)?;
    345     let Some(row) = row else { return Ok(None) };
    346     let event = bytes(&row, 0)?;
    347     let transaction = bytes(&row, 1)?;
    348     let manifest = bytes(&row, 4)?;
    349     let count: i64 = row.try_get(2).map_err(invalid)?;
    350     let size: i64 = row.try_get(3).map_err(invalid)?;
    351     if !(1..=24).contains(&count)
    352         || !(1..=MAX_BYTES as i64).contains(&size)
    353         || (size as usize).div_ceil(PRIVATE_PAYLOAD_MAX_BYTES) != count as usize
    354     {
    355         return Err(OperationError::RecoveryRequired);
    356     }
    357     let totals:(i64,i64)=sqlx::query_as(super::sql(connection,"SELECT count(*),coalesce(sum(n),0) FROM (SELECT length(protected) AS n FROM chat_delivery_parts WHERE workspace=? AND operation_id=? AND recipient=? AND request_key=? LIMIT 25)").await?)
    358         .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.target.key().as_slice()).bind(s.request.as_slice()).fetch_one(&mut *connection).await.map_err(invalid)?;
    359     if totals.0 != count
    360         || totals.1 <= 0
    361         || (totals.1 as usize)
    362             .checked_add(manifest.len())
    363             .is_none_or(|n| n > MAX_PROTECTED_BYTES)
    364     {
    365         return Err(OperationError::RecoveryRequired);
    366     }
    367     let decoded = crypto
    368         .open_delivery(s, DeliveryPayload::Attempt, 0, &manifest)
    369         .await?;
    370     let value: Manifest = decoded.expose_secret(|raw| {
    371         if !super::json::bounded(raw, 32) {
    372             return Err(OperationError::RecoveryRequired);
    373         }
    374         serde_json::from_slice(raw).map_err(invalid)
    375     })?;
    376     if value.version != version(work)
    377         || value.work != WorkRef::new(work)
    378         || request_key(&value.request) != key
    379         || value.event.as_bytes().as_slice() != event
    380         || value.transaction.as_bytes().as_slice() != transaction
    381         || value.parts != count as usize
    382         || value.bytes != size as usize
    383     {
    384         return Err(OperationError::RecoveryRequired);
    385     }
    386     let rows=sqlx::query(super::sql(connection,"SELECT part,CASE WHEN length(protected)>0 AND length(protected)<=262144 THEN protected END FROM chat_delivery_parts WHERE workspace=? AND operation_id=? AND recipient=? AND request_key=? ORDER BY part LIMIT 25").await?)
    387         .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.target.key().as_slice()).bind(s.request.as_slice()).fetch_all(&mut *connection).await.map_err(invalid)?;
    388     let mut parts = Vec::with_capacity(rows.len());
    389     let mut plain = Zeroizing::new(Vec::with_capacity(value.bytes));
    390     for (index, row) in rows.iter().enumerate() {
    391         if row.try_get::<i64, _>(0).map_err(invalid)? != index as i64 + 1 {
    392             return Err(OperationError::RecoveryRequired);
    393         }
    394         let protected = bytes(row, 1)?;
    395         let piece = crypto
    396             .open_delivery(s, DeliveryPayload::Attempt, (index + 1) as u8, &protected)
    397             .await?;
    398         piece.expose_secret(|raw| {
    399             if plain
    400                 .len()
    401                 .checked_add(raw.len())
    402                 .is_none_or(|n| n > value.bytes)
    403             {
    404                 return Err(OperationError::RecoveryRequired);
    405             }
    406             plain.extend_from_slice(raw);
    407             Ok(())
    408         })?;
    409         parts.push(protected);
    410     }
    411     if plain.len() != value.bytes
    412         || <[u8; 32]>::from(Sha256::digest(&plain)) != value.digest
    413         || plain.len() < 4
    414     {
    415         return Err(OperationError::RecoveryRequired);
    416     }
    417     let header_size = u32::from_be_bytes(plain[..4].try_into().map_err(invalid)?) as usize;
    418     let boundary = 4usize
    419         .checked_add(header_size)
    420         .filter(|n| *n < plain.len())
    421         .ok_or(OperationError::RecoveryRequired)?;
    422     if !super::json::bounded(&plain[4..boundary], 32) {
    423         return Err(OperationError::RecoveryRequired);
    424     }
    425     let header: Header = serde_json::from_slice(&plain[4..boundary]).map_err(invalid)?;
    426     let report = header.into_attempt(
    427         work,
    428         core::str::from_utf8(&plain[boundary..]).map_err(invalid)?,
    429     )?;
    430     if report.intent().request_id().as_str() != value.request
    431         || report.intent().event_id() != value.event
    432         || report.transaction_id() != value.transaction
    433     {
    434         return Err(OperationError::RecoveryRequired);
    435     }
    436     Ok(Some(ProtectedAttempt {
    437         report,
    438         manifest,
    439         parts,
    440         bytes: value.bytes,
    441     }))
    442 }
    443 
    444 pub(super) async fn insert(
    445     connection: &mut SqliteConnection,
    446     value: &ProtectedAttempt,
    447 ) -> Result<(), OperationError> {
    448     let s = scope(
    449         value.report.work(),
    450         request_key(value.report.intent().request_id().as_str()),
    451     );
    452     sqlx::query(super::sql(connection,"INSERT INTO chat_delivery_attempts(workspace,operation_id,recipient,request_key,event_id,transaction_id,part_count,byte_count,protected) VALUES(?,?,?,?,?,?,?,?,?)").await?)
    453         .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.target.key().as_slice()).bind(s.request.as_slice()).bind(value.report.intent().event_id().as_bytes().as_slice()).bind(value.report.transaction_id().as_bytes().as_slice()).bind(value.parts.len() as i64).bind(value.bytes as i64).bind(&value.manifest).execute(&mut *connection).await.map_err(|_|OperationError::StorageFailure)?;
    454     for (index, part) in value.parts.iter().enumerate() {
    455         sqlx::query(super::sql(connection,"INSERT INTO chat_delivery_parts(workspace,operation_id,recipient,request_key,part,protected) VALUES(?,?,?,?,?,?)").await?)
    456         .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.target.key().as_slice()).bind(s.request.as_slice()).bind(index as i64+1).bind(part).execute(&mut *connection).await.map_err(|_|OperationError::StorageFailure)?;
    457     }
    458     Ok(())
    459 }
    460 
    461 impl Fact {
    462     pub(super) async fn unchanged(
    463         &self,
    464         connection: &mut SqliteConnection,
    465     ) -> Result<(), OperationError> {
    466         let s = self.scope;
    467         let row=sqlx::query(super::sql(connection,"SELECT CASE WHEN length(event_id)=32 THEN event_id END,CASE WHEN length(transaction_id)=32 THEN transaction_id END,part_count,byte_count,CASE WHEN length(protected)>0 AND length(protected)<=262144 THEN protected END FROM chat_delivery_attempts WHERE workspace=? AND operation_id=? AND recipient=? AND request_key=?").await?)
    468             .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.target.key().as_slice()).bind(s.request.as_slice()).fetch_optional(&mut *connection).await.map_err(invalid)?.ok_or(OperationError::RecoveryRequired)?;
    469         if bytes(&row, 0)? != self.event.as_bytes()
    470             || bytes(&row, 1)? != self.transaction.as_bytes()
    471             || row.try_get::<i64, _>(2).map_err(invalid)? != self.parts.len() as i64
    472             || row.try_get::<i64, _>(3).map_err(invalid)? != self.bytes as i64
    473             || <[u8; 32]>::from(Sha256::digest(bytes(&row, 4)?)) != self.manifest_digest
    474         {
    475             return Err(OperationError::RecoveryRequired);
    476         }
    477         // Compare one bounded ciphertext at a time. No provider, decryption,
    478         // signing or network operation occurs while holding the write fence.
    479         for (index, expected) in self.parts.iter().enumerate() {
    480             let row=sqlx::query(super::sql(connection,"SELECT CASE WHEN length(protected)>0 AND length(protected)<=262144 THEN protected END FROM chat_delivery_parts WHERE workspace=? AND operation_id=? AND recipient=? AND request_key=? AND part=?").await?)
    481                 .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.target.key().as_slice()).bind(s.request.as_slice()).bind(index as i64+1).fetch_optional(&mut *connection).await.map_err(invalid)?.ok_or(OperationError::RecoveryRequired)?;
    482             if <[u8; 32]>::from(Sha256::digest(bytes(&row, 0)?)) != *expected {
    483                 return Err(OperationError::RecoveryRequired);
    484             }
    485         }
    486         let count:i64=sqlx::query_scalar(super::sql(connection,"SELECT count(*) FROM (SELECT 1 FROM chat_delivery_parts WHERE workspace=? AND operation_id=? AND recipient=? AND request_key=? LIMIT 25)").await?)
    487             .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.target.key().as_slice()).bind(s.request.as_slice()).fetch_one(connection).await.map_err(invalid)?;
    488         if count != self.parts.len() as i64 {
    489             return Err(OperationError::RecoveryRequired);
    490         }
    491         Ok(())
    492     }
    493 }
    494 
    495 pub(super) async fn absent(
    496     connection: &mut SqliteConnection,
    497     work: PublicationArtifact,
    498     key: [u8; 32],
    499 ) -> Result<(), OperationError> {
    500     let s = scope(work, key);
    501     let count:i64=sqlx::query_scalar(super::sql(connection,"SELECT EXISTS(SELECT 1 FROM chat_delivery_attempts WHERE workspace=?1 AND operation_id=?2 AND recipient=?3 AND request_key=?4)+EXISTS(SELECT 1 FROM chat_delivery_parts WHERE workspace=?1 AND operation_id=?2 AND recipient=?3 AND request_key=?4)").await?)
    502         .bind(s.workspace.as_bytes().as_slice()).bind(s.operation.as_bytes().as_slice()).bind(s.target.key().as_slice()).bind(s.request.as_slice()).fetch_one(connection).await.map_err(invalid)?;
    503     if count != 0 {
    504         return Err(OperationError::RecoveryRequired);
    505     }
    506     Ok(())
    507 }