codec_tests.rs (19842B)
1 //! Authenticated malformed records must fail closed without repairing storage. 2 #[cfg(test)] 3 mod cases { 4 use super::super::*; 5 use crate::workspace::tests::issuance_records::{DeliveryData, delivery_data}; 6 use nostr::JsonUtil; 7 use serde_json::{Value, json}; 8 use sqlx::Connection; 9 10 fn copy(report: &DeliveryAttempt) -> DeliveryAttempt { 11 DeliveryAttempt::from_store_report( 12 report.work(), 13 report.intent().clone(), 14 report.raw_json(), 15 report.transaction_id(), 16 report.retained_at(), 17 report.target_ordinals().to_vec(), 18 ) 19 .unwrap() 20 } 21 async fn restore(data: &mut DeliveryData, original: &ProtectedAttempt) { 22 sqlx::query("DELETE FROM artifact_delivery_parts") 23 .execute(&mut data.database) 24 .await 25 .unwrap(); 26 sqlx::query("DELETE FROM artifact_delivery_attempts") 27 .execute(&mut data.database) 28 .await 29 .unwrap(); 30 insert(&mut data.database, original).await.unwrap(); 31 } 32 async fn refused(data: &mut DeliveryData) { 33 let key = request_key(data.report.intent().request_id().as_str()); 34 let error = read(&mut data.database, data.report.work(), key, &data.crypto) 35 .await 36 .err() 37 .expect("malformed retained record must be refused"); 38 assert_eq!(error.code(), "recovery_required"); 39 } 40 async fn manifest(data: &mut DeliveryData, original: &ProtectedAttempt, value: &Value) { 41 let selected = scope( 42 data.report.work(), 43 request_key(data.report.intent().request_id().as_str()), 44 ); 45 let protected = data 46 .crypto 47 .seal_delivery( 48 selected, 49 DeliveryPayload::Attempt, 50 0, 51 &serde_json::to_vec(value).unwrap(), 52 ) 53 .await 54 .unwrap(); 55 sqlx::query("UPDATE artifact_delivery_attempts SET protected=?") 56 .bind(protected) 57 .execute(&mut data.database) 58 .await 59 .unwrap(); 60 assert!(!original.parts.is_empty()); 61 } 62 async fn frame(data: &mut DeliveryData, raw: &[u8]) { 63 let selected = scope( 64 data.report.work(), 65 request_key(data.report.intent().request_id().as_str()), 66 ); 67 let pieces = raw.len().div_ceil(PRIVATE_PAYLOAD_MAX_BYTES); 68 let value = json!({"version":version(data.report.work()),"work":WorkRef::new(data.report.work()),"request":data.report.intent().request_id().as_str(),"event":data.report.intent().event_id(),"transaction":data.report.transaction_id(),"parts":pieces,"bytes":raw.len(),"digest":<[u8;32]>::from(Sha256::digest(raw))}); 69 let protected = data 70 .crypto 71 .seal_delivery( 72 selected, 73 DeliveryPayload::Attempt, 74 0, 75 &serde_json::to_vec(&value).unwrap(), 76 ) 77 .await 78 .unwrap(); 79 sqlx::query("DELETE FROM artifact_delivery_parts") 80 .execute(&mut data.database) 81 .await 82 .unwrap(); 83 for (index, piece) in raw.chunks(PRIVATE_PAYLOAD_MAX_BYTES).enumerate() { 84 let protected = data 85 .crypto 86 .seal_delivery(selected, DeliveryPayload::Attempt, (index + 1) as u8, piece) 87 .await 88 .unwrap(); 89 sqlx::query("INSERT INTO artifact_delivery_parts(workspace,operation_id,artifact_key,request_key,part,protected) VALUES(?,?,?,?,?,?)").bind(selected.workspace.as_bytes().as_slice()).bind(selected.operation.as_bytes().as_slice()).bind(selected.target.key().as_slice()).bind(selected.request.as_slice()).bind(index as i64+1).bind(protected).execute(&mut data.database).await.unwrap(); 90 } 91 sqlx::query("UPDATE artifact_delivery_attempts SET part_count=?,byte_count=?,protected=?") 92 .bind(pieces as i64) 93 .bind(raw.len() as i64) 94 .bind(protected) 95 .execute(&mut data.database) 96 .await 97 .unwrap(); 98 } 99 fn encoded(header: &Value, tail: &[u8]) -> Vec<u8> { 100 let header = serde_json::to_vec(header).unwrap(); 101 let mut result = (header.len() as u32).to_be_bytes().to_vec(); 102 result.extend_from_slice(&header); 103 result.extend_from_slice(tail); 104 result 105 } 106 107 #[tokio::test] 108 async fn protected_delivery_headers_lengths_parts_and_fences_refuse_each_inconsistency() { 109 let mut data = delivery_data().await; 110 let key = request_key(data.report.intent().request_id().as_str()); 111 assert!( 112 read(&mut data.database, data.report.work(), key, &data.crypto) 113 .await 114 .unwrap() 115 .is_none() 116 ); 117 absent(&mut data.database, data.report.work(), key) 118 .await 119 .unwrap(); 120 let original = protect(copy(&data.report), &data.crypto).await.unwrap(); 121 assert!(original.parts.len() > 1); 122 insert(&mut data.database, &original).await.unwrap(); 123 assert!( 124 absent(&mut data.database, data.report.work(), key) 125 .await 126 .is_err() 127 ); 128 let fact = original.fact(); 129 fact.unchanged(&mut data.database).await.unwrap(); 130 let selected = scope(data.report.work(), key); 131 let decoded = data 132 .crypto 133 .open_delivery(selected, DeliveryPayload::Attempt, 0, &original.manifest) 134 .await 135 .unwrap(); 136 let base: Value = decoded.expose_secret(|raw| serde_json::from_slice(raw).unwrap()); 137 let mut rebound = base["work"].clone(); 138 rebound["transaction"] = json!("99".repeat(32)); 139 for (field, value) in [ 140 ("version", json!(2)), 141 ("work", rebound), 142 ("request", json!("02".repeat(32))), 143 ("event", json!("99".repeat(32))), 144 ("transaction", json!("99".repeat(32))), 145 ("parts", json!(original.parts.len() + 1)), 146 ("bytes", json!(original.bytes - 1)), 147 ("digest", json!(vec![0u8; 32])), 148 ] { 149 restore(&mut data, &original).await; 150 let mut changed = base.clone(); 151 changed[field] = value; 152 manifest(&mut data, &original, &changed).await; 153 refused(&mut data).await; 154 assert!(fact.unchanged(&mut data.database).await.is_err()); 155 } 156 let nested: Value = 157 serde_json::from_str(&format!("{}0{}", "[".repeat(17), "]".repeat(17))).unwrap(); 158 restore(&mut data, &original).await; 159 manifest(&mut data, &original, &nested).await; 160 refused(&mut data).await; 161 for statement in [ 162 "UPDATE artifact_delivery_attempts SET event_id=zeroblob(31)", 163 "UPDATE artifact_delivery_attempts SET transaction_id=zeroblob(31)", 164 "UPDATE artifact_delivery_attempts SET event_id=zeroblob(32)", 165 "UPDATE artifact_delivery_attempts SET transaction_id=zeroblob(32)", 166 "UPDATE artifact_delivery_attempts SET part_count=0", 167 "UPDATE artifact_delivery_attempts SET part_count=25", 168 "UPDATE artifact_delivery_attempts SET byte_count=0", 169 "UPDATE artifact_delivery_attempts SET byte_count=393217", 170 "UPDATE artifact_delivery_attempts SET byte_count=1", 171 "UPDATE artifact_delivery_attempts SET protected=zeroblob(262145)", 172 "DELETE FROM artifact_delivery_parts WHERE part=1", 173 "UPDATE artifact_delivery_parts SET part=0 WHERE part=1", 174 "UPDATE artifact_delivery_parts SET protected=zeroblob(262145) WHERE part=1", 175 "UPDATE artifact_delivery_parts SET protected=zeroblob(1) WHERE part=1", 176 "UPDATE artifact_delivery_parts SET protected=zeroblob(0)", 177 ] { 178 restore(&mut data, &original).await; 179 sqlx::query(statement) 180 .execute(&mut data.database) 181 .await 182 .unwrap(); 183 refused(&mut data).await; 184 assert!( 185 fact.unchanged(&mut data.database).await.is_err(), 186 "{statement}" 187 ); 188 } 189 restore(&mut data, &original).await; 190 let part = original.parts.len() + 1; 191 sqlx::query("INSERT INTO artifact_delivery_parts SELECT workspace,operation_id,artifact_key,request_key,?,protected FROM artifact_delivery_parts WHERE part=1").bind(part as i64).execute(&mut data.database).await.unwrap(); 192 assert!(fact.unchanged(&mut data.database).await.is_err()); 193 refused(&mut data).await; 194 restore(&mut data, &original).await; 195 for increase in [false, true] { 196 let index = if increase { original.parts.len() } else { 1 }; 197 let decoded = data 198 .crypto 199 .open_delivery( 200 selected, 201 DeliveryPayload::Attempt, 202 index as u8, 203 &original.parts[index - 1], 204 ) 205 .await 206 .unwrap(); 207 let mut plain = decoded.expose_secret(<[u8]>::to_vec); 208 if increase { 209 plain.push(0); 210 } else { 211 plain.pop(); 212 } 213 let changed = data 214 .crypto 215 .seal_delivery(selected, DeliveryPayload::Attempt, index as u8, &plain) 216 .await 217 .unwrap(); 218 sqlx::query("UPDATE artifact_delivery_parts SET protected=? WHERE part=?") 219 .bind(changed) 220 .bind(index as i64) 221 .execute(&mut data.database) 222 .await 223 .unwrap(); 224 refused(&mut data).await; 225 restore(&mut data, &original).await; 226 } 227 sqlx::query("DELETE FROM artifact_delivery_parts") 228 .execute(&mut data.database) 229 .await 230 .unwrap(); 231 for index in 1..=24i64 { 232 sqlx::query("INSERT INTO artifact_delivery_parts(workspace,operation_id,artifact_key,request_key,part,protected) VALUES(?,?,?,?,?,zeroblob(262144))").bind(selected.workspace.as_bytes().as_slice()).bind(selected.operation.as_bytes().as_slice()).bind(selected.target.key().as_slice()).bind(selected.request.as_slice()).bind(index).execute(&mut data.database).await.unwrap(); 233 } 234 sqlx::query("UPDATE artifact_delivery_attempts SET part_count=24,byte_count=393216") 235 .execute(&mut data.database) 236 .await 237 .unwrap(); 238 refused(&mut data).await; 239 restore(&mut data, &original).await; 240 let retained = read(&mut data.database, data.report.work(), key, &data.crypto) 241 .await 242 .unwrap() 243 .unwrap(); 244 assert_eq!(retained.report.raw_json(), data.report.raw_json()); 245 fact.unchanged(&mut data.database).await.unwrap(); 246 } 247 248 #[tokio::test] 249 async fn authenticated_delivery_frames_reject_rebound_fields_and_invalid_nested_encodings() { 250 let mut data = delivery_data().await; 251 let original = protect(copy(&data.report), &data.crypto).await.unwrap(); 252 insert(&mut data.database, &original).await.unwrap(); 253 let base = serde_json::to_value(Header::new(&data.report)).unwrap(); 254 let mut rebound = base["work"].clone(); 255 rebound["transaction"] = json!("99".repeat(32)); 256 let header = Header::new(&data.report); 257 assert!( 258 header 259 .into_attempt(data.report.work(), data.report.raw_json()) 260 .is_ok() 261 ); 262 let foreign = radroots_transport::Target::nostr_relay("wss://foreign.example/").unwrap(); 263 for (field, value) in [ 264 ("version", json!(2)), 265 ("work", rebound), 266 ("selection", json!([])), 267 ("selection", json!([foreign.fingerprint().as_str()])), 268 ( 269 "selection", 270 json!([ 271 data.report.intent().selection()[0].as_str(), 272 data.report.intent().selection()[0].as_str() 273 ]), 274 ), 275 ("intent", json!(vec![0u8; 32])), 276 ("ordinals", json!([0])), 277 ("unknown", json!(true)), 278 ] { 279 let mut changed = base.clone(); 280 changed[field] = value; 281 let raw = encoded(&changed, data.report.raw_json().as_bytes()); 282 frame(&mut data, &raw).await; 283 refused(&mut data).await; 284 } 285 let nested: Value = 286 serde_json::from_str(&format!("{}0{}", "[".repeat(17), "]".repeat(17))).unwrap(); 287 for raw in [ 288 vec![0], 289 u32::MAX.to_be_bytes().to_vec(), 290 encoded(&nested, b"tail"), 291 encoded(&base, &[0xff]), 292 ] { 293 frame(&mut data, &raw).await; 294 refused(&mut data).await; 295 } 296 for field in ["request", "transaction"] { 297 let mut changed = base.clone(); 298 if field == "request" { 299 let next = DeliveryIntent::new( 300 &"02".repeat(32), 301 data.report.intent().event_id(), 302 data.report.intent().targets(), 303 data.report.intent().policy(), 304 data.report.intent().deadline_unix_ms(), 305 ) 306 .unwrap(); 307 changed["request"] = json!(next.request_id().as_str()); 308 changed["intent"] = json!(next.digest()); 309 } else { 310 changed["transaction"] = json!("99".repeat(32)); 311 } 312 let raw = encoded(&changed, data.report.raw_json().as_bytes()); 313 frame(&mut data, &raw).await; 314 refused(&mut data).await; 315 } 316 let original_event = nostr::Event::from_json(data.report.raw_json()).unwrap(); 317 let mut scalar = [0; 32]; 318 scalar[31] = 3; 319 let keys = nostr::Keys::new(nostr::SecretKey::from_slice(&scalar).unwrap()); 320 let other = nostr::UnsignedEvent { 321 id: None, 322 pubkey: keys.public_key(), 323 created_at: original_event.created_at, 324 kind: original_event.kind, 325 tags: original_event.tags.clone(), 326 content: format!("{} ", original_event.content), 327 } 328 .sign_with_keys(&keys) 329 .unwrap(); 330 let intent = DeliveryIntent::new( 331 data.report.intent().request_id().as_str(), 332 EnvelopeEventId::from_bytes(*other.id.as_bytes()), 333 data.report.intent().targets(), 334 data.report.intent().policy(), 335 data.report.intent().deadline_unix_ms(), 336 ) 337 .unwrap(); 338 let mut changed = base.clone(); 339 changed["event"] = json!(intent.event_id()); 340 changed["intent"] = json!(intent.digest()); 341 frame(&mut data, &encoded(&changed, other.as_json().as_bytes())).await; 342 refused(&mut data).await; 343 restore(&mut data, &original).await; 344 assert_eq!( 345 read( 346 &mut data.database, 347 data.report.work(), 348 request_key(data.report.intent().request_id().as_str()), 349 &data.crypto 350 ) 351 .await 352 .unwrap() 353 .unwrap() 354 .report 355 .raw_json(), 356 data.report.raw_json() 357 ); 358 } 359 #[tokio::test] 360 async fn public_delivery_metadata_requires_role_and_explicit_absent_recipient_in_each_frame() { 361 use crate::workspace::tests::issuance_records::public_delivery_data; 362 use radroots_storage::command::SigningTarget; 363 let mut data = public_delivery_data().await; 364 let original = protect(copy(&data.report), &data.crypto).await.unwrap(); 365 insert(&mut data.database, &original).await.unwrap(); 366 let key = request_key(data.report.intent().request_id().as_str()); 367 let selected = scope(data.report.work(), key); 368 let plain = data 369 .crypto 370 .open_delivery(selected, DeliveryPayload::Attempt, 0, &original.manifest) 371 .await 372 .unwrap(); 373 let base: Value = plain.expose_secret(|v| serde_json::from_slice(v).unwrap()); 374 let header = serde_json::to_value(Header::new(&data.report)).unwrap(); 375 assert_eq!(base["version"], json!(2)); 376 assert_eq!(base["work"]["role"], json!(0)); 377 assert!(base["work"].as_object().unwrap().contains_key("recipient")); 378 assert!(base["work"]["recipient"].is_null()); 379 let mut mutants = Vec::new(); 380 for (field, value) in [ 381 ("role", json!(1)), 382 ("role", Value::Null), 383 ( 384 "recipient", 385 json!("79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"), 386 ), 387 ("unknown", json!(true)), 388 ] { 389 let mut value_work = base["work"].clone(); 390 value_work[field] = value; 391 mutants.push(value_work); 392 } 393 for field in ["role", "recipient"] { 394 let mut value_work = base["work"].clone(); 395 value_work.as_object_mut().unwrap().remove(field); 396 mutants.push(value_work); 397 } 398 // Include a real private work reference rather than a fabricated peer. 399 let private = delivery_data().await; 400 mutants.push(serde_json::to_value(WorkRef::new(private.report.work())).unwrap()); 401 for work in mutants { 402 restore(&mut data, &original).await; 403 let mut changed = base.clone(); 404 changed["work"] = work.clone(); 405 manifest(&mut data, &original, &changed).await; 406 refused(&mut data).await; 407 restore(&mut data, &original).await; 408 let mut changed = header.clone(); 409 changed["work"] = work; 410 let raw = data.report.raw_json().to_owned(); 411 frame(&mut data, &encoded(&changed, raw.as_bytes())).await; 412 refused(&mut data).await; 413 } 414 for is_header in [false, true] { 415 restore(&mut data, &original).await; 416 let mut changed = if is_header { 417 header.clone() 418 } else { 419 base.clone() 420 }; 421 changed["version"] = json!(1); 422 if is_header { 423 let raw = data.report.raw_json().to_owned(); 424 frame(&mut data, &encoded(&changed, raw.as_bytes())).await; 425 } else { 426 manifest(&mut data, &original, &changed).await; 427 } 428 refused(&mut data).await; 429 } 430 // Public/private and attempt/observation contexts cannot open each other's bytes. 431 let mut foreign = selected; 432 foreign.target = 433 SigningTarget::BusinessSeal(private.report.work().private().unwrap().recipient()); 434 assert!( 435 data.crypto 436 .open_delivery(foreign, DeliveryPayload::Attempt, 0, &original.manifest) 437 .await 438 .is_err() 439 ); 440 assert!( 441 data.crypto 442 .open_delivery( 443 selected, 444 DeliveryPayload::Observation, 445 0, 446 &original.manifest 447 ) 448 .await 449 .is_err() 450 ); 451 restore(&mut data, &original).await; 452 let actual = read(&mut data.database, data.report.work(), key, &data.crypto) 453 .await 454 .unwrap() 455 .unwrap(); 456 assert_eq!(actual.report.raw_json(), data.report.raw_json()); 457 assert_eq!(actual.report.work(), data.report.work()); 458 private.database.close().await.unwrap(); 459 } 460 }