lib

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

context.rs (14265B)


      1 use radroots_domain::*;
      2 use radroots_identity::PublicKey;
      3 #[cfg(feature = "serde")]
      4 use serde_json::{Value, json};
      5 use std::str::FromStr;
      6 
      7 const KEY: &str = "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798";
      8 fn actor() -> ActorRef {
      9     ActorRef::new(
     10         PublicKey::from_str(KEY).unwrap(),
     11         ActorRole::Buyer,
     12         None,
     13         Some(GrantId::from_bytes([4; 32])),
     14     )
     15 }
     16 fn checkpoint() -> CheckpointRef {
     17     CheckpointRef::new(
     18         CheckpointDigest::from_bytes([8; 32]),
     19         Sequence::new(0).unwrap(),
     20         Coverage::Partial,
     21         vec![SourceId::from_bytes([9; 32])],
     22     )
     23     .unwrap()
     24 }
     25 fn context() -> CommandContextData {
     26     CommandContextData::new(
     27         OperationId::from_bytes([1; 32]),
     28         actor(),
     29         WorkspaceId::from_bytes([2; 32]),
     30         AuthorityRef::new(
     31             ExecutorId::from_bytes([3; 32]),
     32             Generation::new(9_007_199_254_740_993).unwrap(),
     33         ),
     34         RouteDigest::from_bytes([5; 32]),
     35         None,
     36         None,
     37         UnixSeconds::new(1_900_000_000).unwrap(),
     38         None,
     39     )
     40     .unwrap()
     41 }
     42 
     43 #[cfg(feature = "serde")]
     44 #[test]
     45 fn profile_keys_require_canonical_spelling_in_direct_actor_and_context_decoding() {
     46     let uppercase = KEY.to_ascii_uppercase();
     47     assert!(PublicKey::from_hex(&uppercase).is_ok());
     48     let mut descriptor = serde_json::to_value(actor()).unwrap();
     49     descriptor["organization"] = json!(KEY);
     50     assert!(serde_json::from_value::<ActorRef>(descriptor.clone()).is_ok());
     51     for field in ["participant", "organization"] {
     52         let mut altered = descriptor.clone();
     53         altered[field] = json!(uppercase);
     54         assert!(
     55             serde_json::from_value::<ActorRef>(altered.clone()).is_err(),
     56             "{field}"
     57         );
     58         let mut command = serde_json::to_value(context()).unwrap();
     59         command["actor"] = altered;
     60         assert!(
     61             serde_json::from_value::<CommandContextData>(command).is_err(),
     62             "context {field}"
     63         );
     64     }
     65 }
     66 
     67 #[cfg(feature = "serde")]
     68 #[test]
     69 fn context_descriptors_require_objects_when_decoded_directly() {
     70     fn check<T>(value: T, fields: &[&str])
     71     where
     72         T: serde::Serialize + serde::de::DeserializeOwned + PartialEq + std::fmt::Debug,
     73     {
     74         let object = serde_json::to_value(&value).unwrap();
     75         assert_eq!(serde_json::from_value::<T>(object.clone()).unwrap(), value);
     76         let array = Value::Array(fields.iter().map(|field| object[field].clone()).collect());
     77         assert!(serde_json::from_value::<T>(array).is_err());
     78     }
     79     check(
     80         actor(),
     81         &["participant", "role", "organization", "grant_id"],
     82     );
     83     check(context().authority(), &["executor_id", "generation"]);
     84     check(checkpoint(), &["digest", "sequence", "coverage", "missing"]);
     85     check(
     86         Approval::new(
     87             ApprovalIntentDigest::from_bytes([6; 32]),
     88             "inbox.inquire",
     89             UnixSeconds::new(190).unwrap(),
     90         )
     91         .unwrap(),
     92         &["intent_digest", "scope", "expires_at"],
     93     );
     94     check(
     95         ExpectedOrder::new(
     96             OrderId::from_bytes([7; 32]),
     97             None,
     98             Sequence::new(4).unwrap(),
     99             None,
    100             checkpoint(),
    101         ),
    102         &[
    103             "order_id",
    104             "agreement",
    105             "seller_sequence",
    106             "buyer_head",
    107             "checkpoint",
    108         ],
    109     );
    110     check(
    111         context(),
    112         &[
    113             "operation_id",
    114             "actor",
    115             "workspace_id",
    116             "authority",
    117             "route_digest",
    118             "approval",
    119             "expected",
    120             "not_after",
    121             "correlation_id",
    122         ],
    123     );
    124 }
    125 
    126 #[test]
    127 fn exact_integers_never_round_or_accept_numeric_json_coercions() {
    128     for value in [0, 1, 9_007_199_254_740_993, i64::MAX as u64] {
    129         let sequence = Sequence::new(value).unwrap();
    130         assert_eq!(sequence.get(), value);
    131         assert_eq!(sequence.to_string().parse::<Sequence>(), Ok(sequence));
    132         #[cfg(feature = "serde")]
    133         {
    134             assert_eq!(
    135                 serde_json::to_value(sequence).unwrap(),
    136                 json!(value.to_string())
    137             );
    138             assert_eq!(
    139                 serde_json::from_value::<Sequence>(json!(value.to_string())).unwrap(),
    140                 sequence
    141             );
    142             assert!(serde_json::from_value::<Sequence>(json!(value)).is_err());
    143         }
    144         if value > 0 {
    145             let generation = Generation::new(value).unwrap();
    146             assert_eq!(generation.get(), value);
    147             assert_eq!(generation.to_string().parse::<Generation>(), Ok(generation));
    148             #[cfg(feature = "serde")]
    149             assert_eq!(
    150                 serde_json::from_value::<Generation>(json!(value.to_string())).unwrap(),
    151                 generation
    152             );
    153         }
    154     }
    155     for text in [
    156         "",
    157         "00",
    158         "01",
    159         "-1",
    160         "+1",
    161         "1.0",
    162         "1e2",
    163         " 1",
    164         "1 ",
    165         "1",
    166         "18446744073709551616",
    167         "9223372036854775808",
    168     ] {
    169         assert!(text.parse::<Sequence>().is_err(), "{text:?}");
    170         assert!(text.parse::<Generation>().is_err());
    171         #[cfg(feature = "serde")]
    172         assert!(serde_json::from_value::<Sequence>(json!(text)).is_err());
    173     }
    174     assert!(Generation::new(0).is_err());
    175     assert!("0".parse::<Generation>().is_err());
    176     assert!(Sequence::new(u64::MAX).is_err());
    177     assert!(Generation::new(u64::MAX).is_err());
    178     for value in [0, 1, 253_402_300_799] {
    179         let timestamp = UnixSeconds::new(value).unwrap();
    180         assert_eq!(timestamp.get(), value);
    181         assert_eq!(timestamp.to_string().parse::<UnixSeconds>(), Ok(timestamp));
    182         #[cfg(feature = "serde")]
    183         {
    184             assert_eq!(
    185                 serde_json::from_value::<UnixSeconds>(json!(value.to_string())).unwrap(),
    186                 timestamp
    187             );
    188             assert_eq!(
    189                 serde_json::to_value(timestamp).unwrap(),
    190                 json!(value.to_string())
    191             );
    192         }
    193     }
    194     assert!(UnixSeconds::new(253_402_300_800).is_err());
    195     assert!("253402300800".parse::<UnixSeconds>().is_err());
    196     #[cfg(feature = "serde")]
    197     assert!(serde_json::from_value::<UnixSeconds>(json!(1)).is_err());
    198 }
    199 
    200 #[test]
    201 fn captured_descriptors_preserve_every_field_and_explicit_null() {
    202     let data = context();
    203     #[cfg(feature = "serde")]
    204     let wire = {
    205         let wire = serde_json::to_value(&data).unwrap();
    206         assert_eq!(wire["operation_id"], json!("01".repeat(32)));
    207         assert_eq!(wire["authority"]["generation"], json!("9007199254740993"));
    208         for name in ["approval", "expected", "correlation_id"] {
    209             assert!(wire[name].is_null());
    210         }
    211         assert_eq!(
    212             serde_json::from_value::<CommandContextData>(wire.clone()).unwrap(),
    213             data
    214         );
    215         wire
    216     };
    217     assert_eq!(data.operation_id(), OperationId::from_bytes([1; 32]));
    218     assert_eq!(data.actor(), actor());
    219     assert_eq!(data.workspace_id(), WorkspaceId::from_bytes([2; 32]));
    220     assert_eq!(
    221         data.authority().executor_id(),
    222         ExecutorId::from_bytes([3; 32])
    223     );
    224     assert_eq!(data.authority().generation().get(), 9_007_199_254_740_993);
    225     assert_eq!(data.route_digest(), RouteDigest::from_bytes([5; 32]));
    226     assert_eq!(data.not_after().get(), 1_900_000_000);
    227     assert!(
    228         data.approval().is_none() && data.expected().is_none() && data.correlation_id().is_none()
    229     );
    230     assert_eq!(
    231         data.actor().participant(),
    232         PublicKey::from_str(KEY).unwrap()
    233     );
    234     assert_eq!(data.actor().role(), ActorRole::Buyer);
    235     assert_eq!(data.actor().organization(), None);
    236     assert_eq!(data.actor().grant_id(), Some(GrantId::from_bytes([4; 32])));
    237     #[cfg(feature = "serde")]
    238     {
    239         for field in ["approval", "expected", "correlation_id"] {
    240             let mut missing = wire.clone();
    241             missing.as_object_mut().unwrap().remove(field);
    242             assert!(
    243                 serde_json::from_value::<CommandContextData>(missing).is_err(),
    244                 "required {field}"
    245             );
    246         }
    247         for field in ["organization", "grant_id"] {
    248             let mut missing = wire.clone();
    249             missing["actor"].as_object_mut().unwrap().remove(field);
    250             assert!(
    251                 serde_json::from_value::<CommandContextData>(missing).is_err(),
    252                 "required actor {field}"
    253             );
    254         }
    255         let raw = serde_json::to_string(&data).unwrap();
    256         let duplicate = format!("{{\"operation_id\":\"{}\",{}", "ff".repeat(32), &raw[1..]);
    257         assert!(serde_json::from_str::<CommandContextData>(&duplicate).is_err());
    258         let mut unknown = wire.clone();
    259         unknown["authenticated"] = json!(true);
    260         assert!(serde_json::from_value::<CommandContextData>(unknown).is_err());
    261         let mut unknown = wire;
    262         unknown["actor"]["role"] = json!("operator");
    263         assert!(serde_json::from_value::<CommandContextData>(unknown).is_err());
    264     }
    265     assert!(!format!("{data:?}").contains(KEY));
    266 }
    267 
    268 #[test]
    269 fn complete_preconditions_and_approval_data_remain_untrusted_bounded_values() {
    270     let approval = Approval::new(
    271         ApprovalIntentDigest::from_bytes([6; 32]),
    272         "orders.accept",
    273         UnixSeconds::new(1_900_000_000).unwrap(),
    274     )
    275     .unwrap();
    276     assert_eq!(
    277         approval.intent_digest(),
    278         ApprovalIntentDigest::from_bytes([6; 32])
    279     );
    280     assert_eq!(approval.scope(), "orders.accept");
    281     assert_eq!(approval.expires_at().get(), 1_900_000_000);
    282     let expected = ExpectedOrder::new(
    283         OrderId::from_bytes([7; 32]),
    284         Some(RecordId::from_bytes([10; 32])),
    285         Sequence::new(4).unwrap(),
    286         Some(RecordId::from_bytes([11; 32])),
    287         checkpoint(),
    288     );
    289     assert_eq!(expected.order_id(), OrderId::from_bytes([7; 32]));
    290     assert_eq!(expected.agreement(), Some(RecordId::from_bytes([10; 32])));
    291     assert_eq!(expected.seller_sequence().get(), 4);
    292     assert_eq!(expected.buyer_head(), Some(RecordId::from_bytes([11; 32])));
    293     assert_eq!(
    294         expected.checkpoint().digest(),
    295         CheckpointDigest::from_bytes([8; 32])
    296     );
    297     assert_eq!(expected.checkpoint().sequence().get(), 0);
    298     assert_eq!(expected.checkpoint().coverage(), Coverage::Partial);
    299     assert_eq!(
    300         expected.checkpoint().missing(),
    301         &[SourceId::from_bytes([9; 32])]
    302     );
    303     #[cfg(feature = "serde")]
    304     {
    305         let mut wire = serde_json::to_value(context()).unwrap();
    306         wire["approval"] = serde_json::to_value(&approval).unwrap();
    307         wire["expected"] = serde_json::to_value(&expected).unwrap();
    308         wire["correlation_id"] = json!("synthetic diagnostic");
    309         let data: CommandContextData = serde_json::from_value(wire.clone()).unwrap();
    310         assert_eq!(data.approval(), Some(&approval));
    311         assert_eq!(data.expected(), Some(&expected));
    312         assert_eq!(
    313             data.correlation_id().unwrap().as_str(),
    314             "synthetic diagnostic"
    315         );
    316         assert_eq!(serde_json::to_value(&data).unwrap(), wire);
    317         for field in ["agreement", "buyer_head"] {
    318             let mut missing = wire.clone();
    319             missing["expected"].as_object_mut().unwrap().remove(field);
    320             assert!(serde_json::from_value::<CommandContextData>(missing).is_err());
    321         }
    322         for nested in ["authority", "approval", "expected"] {
    323             let mut changed = wire.clone();
    324             changed[nested]["extra"] = Value::Bool(true);
    325             assert!(serde_json::from_value::<CommandContextData>(changed).is_err());
    326         }
    327         assert!(!format!("{data:?}").contains("synthetic diagnostic"));
    328     }
    329     assert!(!format!("{approval:?}").contains("orders.accept"));
    330 }
    331 
    332 #[test]
    333 fn bounds_and_coverage_claims_fail_without_echoing_sensitive_text() {
    334     assert!(CorrelationId::new("é".repeat(64)).is_ok());
    335     assert!(CorrelationId::new("é".repeat(65)).is_err());
    336     assert!(CorrelationId::new("diagnostic\nsecret").is_err());
    337     #[cfg(feature = "serde")]
    338     {
    339         assert_eq!(
    340             serde_json::from_str::<CorrelationId>("\"hello\"")
    341                 .unwrap()
    342                 .as_str(),
    343             "hello"
    344         );
    345         assert!(serde_json::from_value::<CorrelationId>(json!("x".repeat(129))).is_err());
    346     }
    347     assert!(
    348         !format!("{:?}", CorrelationId::new("private diagnostic").unwrap())
    349             .contains("private diagnostic")
    350     );
    351     for scope in [String::new(), "x".repeat(161), "private\ncontext".into()] {
    352         let error = Approval::new(
    353             ApprovalIntentDigest::from_bytes([1; 32]),
    354             scope.clone(),
    355             UnixSeconds::new(1).unwrap(),
    356         )
    357         .unwrap_err();
    358         assert_eq!(error, ContextError::InvalidText);
    359         assert!(!error.to_string().contains(&scope) || scope.is_empty());
    360     }
    361     assert!(
    362         Approval::new(
    363             ApprovalIntentDigest::from_bytes([1; 32]),
    364             "valid",
    365             UnixSeconds::new(0).unwrap()
    366         )
    367         .is_err()
    368     );
    369     let digest = CheckpointDigest::from_bytes([2; 32]);
    370     let sequence = Sequence::new(0).unwrap();
    371     assert!(
    372         CheckpointRef::new(
    373             digest,
    374             sequence,
    375             Coverage::Partial,
    376             vec![SourceId::from_bytes([1; 32]); 128]
    377         )
    378         .is_ok()
    379     );
    380     assert_eq!(
    381         CheckpointRef::new(
    382             digest,
    383             sequence,
    384             Coverage::Partial,
    385             vec![SourceId::from_bytes([1; 32]); 129]
    386         )
    387         .unwrap_err(),
    388         ContextError::TooManyReferences
    389     );
    390     assert_eq!(
    391         CheckpointRef::new(
    392             digest,
    393             sequence,
    394             Coverage::ScopeSatisfied,
    395             vec![SourceId::from_bytes([1; 32])]
    396         )
    397         .unwrap_err(),
    398         ContextError::InconsistentCoverage
    399     );
    400     assert!(CheckpointRef::new(digest, sequence, Coverage::ScopeSatisfied, vec![]).is_ok());
    401     #[cfg(feature = "serde")]
    402     {
    403         let mut invalid = serde_json::to_value(context()).unwrap();
    404         invalid["not_after"] = json!("0");
    405         assert!(serde_json::from_value::<CommandContextData>(invalid).is_err());
    406     }
    407 }