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 }