lib

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

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 }