lib

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

workspace.rs (16351B)


      1 use radroots_domain::{
      2     ActorRef, ActorRole, AuthorityRef, CheckpointDigest, CheckpointRef, Coverage, ExecutorId,
      3     Generation, GrantId, PublicKey, RouteDigest, Sequence, UnixSeconds, WorkspaceId,
      4 };
      5 use radroots_storage::workspace::{
      6     AttachmentInput, AttachmentProof, WorkspaceBinding, WorkspaceError,
      7 };
      8 #[cfg(feature = "protected_outbox")]
      9 #[path = "workspace/inventory_abort.rs"]
     10 mod inventory_abort;
     11 #[cfg(feature = "protected_outbox")]
     12 #[path = "workspace/inventory_envelope.rs"]
     13 mod inventory_envelope;
     14 #[cfg(feature = "protected_outbox")]
     15 #[path = "workspace/inventory_evidence.rs"]
     16 mod inventory_evidence;
     17 fn key() -> PublicKey {
     18     PublicKey::from_hex("79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798").unwrap()
     19 }
     20 fn input() -> AttachmentInput {
     21     AttachmentInput::new(
     22         WorkspaceId::from_bytes([1; 32]),
     23         AuthorityRef::new(ExecutorId::from_bytes([2; 32]), Generation::new(1).unwrap()),
     24         key(),
     25         "local://workspace/selector",
     26         key(),
     27         GrantId::from_bytes([3; 32]),
     28         CheckpointRef::new(
     29             CheckpointDigest::from_bytes([4; 32]),
     30             Sequence::new(0).unwrap(),
     31             Coverage::Partial,
     32             vec![],
     33         )
     34         .unwrap(),
     35         RouteDigest::from_bytes([5; 32]),
     36     )
     37     .unwrap()
     38 }
     39 
     40 #[cfg(feature = "protected_outbox")]
     41 #[test]
     42 fn declared_stock_grants_are_explicit_bounded_and_never_expand_empty_or_reordered_scopes() {
     43     use radroots_domain::PoolId;
     44     use radroots_storage::workspace::seller_stock::{
     45         StockAction::*, StockGrantScope, StockResources,
     46     };
     47     let first = PoolId::from_bytes([1; 32]);
     48     let second = PoolId::from_bytes([2; 32]);
     49     assert!(StockResources::pools(vec![]).is_err());
     50     assert!(StockResources::pools(vec![first, first]).is_err());
     51     assert!(StockResources::pools(vec![second, first]).is_err());
     52     assert!(StockResources::pools((0..65).map(|n| PoolId::from_bytes([n; 32])).collect()).is_err());
     53     assert!(StockGrantScope::new(StockResources::all_pools(), vec![]).is_err());
     54     for actions in [
     55         vec![AddStock],
     56         vec![ReadPools, AddStock],
     57         vec![ReadOperations, AddStock],
     58         vec![ReadOperations, ReadPools],
     59         vec![ReadPools, ReadPools],
     60     ] {
     61         assert!(StockGrantScope::new(StockResources::all_pools(), actions).is_err());
     62     }
     63     let scope = StockGrantScope::new(
     64         StockResources::pools(vec![first]).unwrap(),
     65         vec![ReadPools, ReadOperations, AddStock],
     66     )
     67     .unwrap();
     68     assert!(scope.allows(AddStock, first));
     69     assert!(!scope.allows(AddStock, second));
     70     assert!(!scope.allows(RemoveStock, first));
     71     assert!(!scope.allows(SpoilStock, first));
     72     assert_eq!(scope.actions(), vec![ReadPools, ReadOperations, AddStock]);
     73     assert_eq!(scope.resources().selected_pools(), Some(&[first][..]));
     74     let readonly =
     75         StockGrantScope::new(StockResources::pools(vec![first]).unwrap(), vec![ReadPools]).unwrap();
     76     assert!(readonly.allows(ReadPools, first));
     77     assert!(!readonly.allows(ReadOperations, first));
     78     assert!(!readonly.allows(AddStock, first));
     79     let full = StockGrantScope::full_inventory();
     80     assert_eq!(
     81         full.actions(),
     82         vec![
     83             ReadPools,
     84             ReadOperations,
     85             CreatePool,
     86             AddStock,
     87             RemoveStock,
     88             SpoilStock
     89         ]
     90     );
     91     assert!(full.allows(SpoilStock, second));
     92     assert_eq!(
     93         format!("{scope:?}"),
     94         "StockGrantScope(<untrusted descriptor>)"
     95     );
     96     assert_eq!(
     97         format!("{:?}", scope.resources()),
     98         "StockResources(<redacted>)"
     99     );
    100 }
    101 
    102 #[cfg(all(feature = "protected_outbox", feature = "serde"))]
    103 #[test]
    104 fn closed_stock_scope_codecs_reject_aliases_extras_and_implicit_wildcards() {
    105     use radroots_storage::workspace::seller_stock::StockGrantScope;
    106     use serde_json::json;
    107     let valid = json!({"actions":["read_pools","read_operations","add_stock"],"resources":{"type":"pools","ids":["01".repeat(32)]}});
    108     let scope: StockGrantScope = serde_json::from_value(valid.clone()).unwrap();
    109     assert_eq!(serde_json::to_value(scope).unwrap(), valid);
    110     for invalid in [
    111         json!({"actions":[],"resources":{"type":"all_pools"}}),
    112         json!({"actions":["add_stock"],"resources":{"type":"all_pools"}}),
    113         json!({"actions":["read_pools"],"resources":{"type":"pools","ids":[]}}),
    114         json!({"actions":["read_pools"],"resources":{"type":"all_pools","ids":null}}),
    115         json!({"actions":["read_pools"],"resources":{"type":"all_pools","ids":[]}}),
    116         json!({"actions":["read_pools"],"resources":{"type":"all_pools","ignored":true}}),
    117         json!({"actions":[{"read_pools":null}],"resources":{"type":"all_pools"}}),
    118         json!({"actions":["admin"],"resources":{"type":"all_pools"}}),
    119         json!({"actions":["read_pools"],"resources":{"type":"all_pools"},"admin":true}),
    120         json!([{"type":"all_pools"},["read_pools"]]),
    121         json!({"actions":vec!["read_pools";7],"resources":{"type":"all_pools"}}),
    122     ] {
    123         assert!(serde_json::from_value::<StockGrantScope>(invalid).is_err());
    124     }
    125     let mut excessive = valid;
    126     excessive["resources"]["ids"] = json!(
    127         (0..65)
    128             .map(|n| format!("{n:02x}").repeat(32))
    129             .collect::<Vec<_>>()
    130     );
    131     assert!(serde_json::from_value::<StockGrantScope>(excessive).is_err());
    132 }
    133 
    134 #[cfg(feature = "protected_outbox")]
    135 #[test]
    136 fn seller_namespace_selection_excludes_only_the_caller_grant_without_minting_permission() {
    137     use radroots_storage::workspace::seller_stock::{SellerAuthoritySelection, SellerStockConfig};
    138     let (original, proof, record) = SellerStockConfig::new(
    139         key(),
    140         key(),
    141         "namespace-owner",
    142         UnixSeconds::new(200).unwrap(),
    143     )
    144     .unwrap()
    145     .enroll(
    146         UnixSeconds::new(100).unwrap(),
    147         WorkspaceId::from_bytes([1; 32]),
    148         ExecutorId::from_bytes([2; 32]),
    149         GrantId::from_bytes([3; 32]),
    150         AttachmentProof::from_protected_input(&[7; 32]).unwrap(),
    151     )
    152     .unwrap();
    153     let selected = SellerAuthoritySelection::from_attachment(&original);
    154     let caller = selected.attachment(GrantId::from_bytes([9; 32])).unwrap();
    155     assert_ne!(caller.grant_id(), original.grant_id());
    156     assert_eq!(SellerAuthoritySelection::from_attachment(&caller), selected);
    157     assert!(selected.matches_attachment(&original));
    158     assert!(selected.matches_attachment(&caller));
    159     assert!(
    160         record
    161             .authenticate(&original, &proof, UnixSeconds::new(100).unwrap())
    162             .is_ok()
    163     );
    164     assert!(
    165         record
    166             .authenticate(&caller, &proof, UnixSeconds::new(100).unwrap())
    167             .is_err()
    168     );
    169     assert_eq!(selected.workspace_id(), original.workspace_id());
    170     assert_eq!(selected.authority(), original.authority());
    171     assert_eq!(selected.participant(), original.participant());
    172     assert_eq!(selected.endpoint(), original.endpoint());
    173     assert_eq!(selected.endpoint_identity(), original.endpoint_identity());
    174     assert_eq!(selected.checkpoint(), original.checkpoint());
    175     assert_eq!(selected.route_digest(), original.route_digest());
    176     assert_eq!(
    177         format!("{selected:?}"),
    178         "SellerAuthoritySelection(<untrusted descriptor>)"
    179     );
    180 }
    181 
    182 #[cfg(all(feature = "protected_outbox", feature = "serde"))]
    183 #[test]
    184 fn seller_namespace_selection_is_a_closed_object_and_retains_every_namespace_binding() {
    185     use radroots_storage::workspace::seller_stock::SellerAuthoritySelection;
    186     use serde_json::json;
    187     let original = input();
    188     let selection = SellerAuthoritySelection::from_attachment(&original);
    189     let value = serde_json::to_value(&selection).unwrap();
    190     assert!(value.get("grant_id").is_none());
    191     assert_eq!(
    192         serde_json::from_value::<SellerAuthoritySelection>(value.clone()).unwrap(),
    193         selection
    194     );
    195     for field in [
    196         "workspace_id",
    197         "authority",
    198         "participant",
    199         "endpoint",
    200         "endpoint_identity",
    201         "checkpoint",
    202         "route_digest",
    203     ] {
    204         let mut changed = value.clone();
    205         changed.as_object_mut().unwrap().remove(field);
    206         assert!(
    207             serde_json::from_value::<SellerAuthoritySelection>(changed).is_err(),
    208             "{field}"
    209         );
    210     }
    211     let other_key = "c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5";
    212     for (path, bad) in [
    213         ("/workspace_id", json!("0b".repeat(32))),
    214         ("/authority/executor_id", json!("0b".repeat(32))),
    215         ("/authority/generation", json!("2")),
    216         ("/participant", json!(other_key)),
    217         ("/endpoint", json!("local://another-namespace")),
    218         ("/endpoint_identity", json!(other_key)),
    219         ("/checkpoint/digest", json!("0b".repeat(32))),
    220         ("/route_digest", json!("0b".repeat(32))),
    221     ] {
    222         let mut changed = value.clone();
    223         *changed.pointer_mut(path).unwrap() = bad;
    224         let changed: SellerAuthoritySelection = serde_json::from_value(changed).unwrap();
    225         assert!(!changed.matches_attachment(&original), "{path}");
    226     }
    227     for bad in [json!(""), json!("x".repeat(2049)), json!("local://bad\n")] {
    228         let mut changed = value.clone();
    229         changed["endpoint"] = bad;
    230         assert!(serde_json::from_value::<SellerAuthoritySelection>(changed).is_err());
    231     }
    232     let mut changed = value.clone();
    233     changed["grant_id"] = json!(null);
    234     for bad in [
    235         json!(null),
    236         json!({"id":"radroots.seller_stock.native_inventory","version":"2"}),
    237         json!({"id":"radroots.seller_stock.native_inventory","version":1}),
    238         json!(["radroots.seller_stock.native_inventory", "1"]),
    239     ] {
    240         let mut invalid = value.clone();
    241         invalid["capability_contract"] = bad;
    242         assert!(serde_json::from_value::<SellerAuthoritySelection>(invalid).is_err());
    243     }
    244 
    245     assert!(serde_json::from_value::<SellerAuthoritySelection>(changed).is_err());
    246     assert!(
    247         serde_json::from_value::<SellerAuthoritySelection>(json!([
    248             value["workspace_id"],
    249             value["authority"]
    250         ]))
    251         .is_err()
    252     );
    253 }
    254 fn actor() -> ActorRef {
    255     ActorRef::new(key(), ActorRole::Buyer, None, Some(input().grant_id()))
    256 }
    257 
    258 #[test]
    259 fn proof_has_exact_width_explicit_exposure_and_redacted_diagnostics() {
    260     for bytes in [&[][..], &[7; 31][..], &[7; 33][..]] {
    261         assert_eq!(
    262             AttachmentProof::from_protected_input(bytes).unwrap_err(),
    263             WorkspaceError::InvalidInput
    264         );
    265     }
    266     let proof = AttachmentProof::from_protected_input(&[7; 32]).unwrap();
    267     proof.with_secret(|bytes| assert_eq!(bytes, &[7; 32]));
    268     assert_eq!(format!("{proof:?}"), "AttachmentProof(<redacted>)");
    269 }
    270 #[test]
    271 fn selections_are_bounded_untrusted_data_with_complete_getters() {
    272     let input = input();
    273     assert_eq!(input.workspace_id(), WorkspaceId::from_bytes([1; 32]));
    274     assert_eq!(
    275         input.authority().executor_id(),
    276         ExecutorId::from_bytes([2; 32])
    277     );
    278     assert_eq!(input.participant(), key());
    279     assert_eq!(input.endpoint_identity(), key());
    280     assert_eq!(input.endpoint(), "local://workspace/selector");
    281     assert_eq!(input.grant_id(), GrantId::from_bytes([3; 32]));
    282     assert_eq!(input.checkpoint().sequence().get(), 0);
    283     assert_eq!(input.route_digest(), RouteDigest::from_bytes([5; 32]));
    284     for endpoint in [String::new(), "x".repeat(2049), "local://bad\n".into()] {
    285         assert_eq!(
    286             AttachmentInput::new(
    287                 input.workspace_id(),
    288                 input.authority(),
    289                 input.participant(),
    290                 endpoint,
    291                 input.endpoint_identity(),
    292                 input.grant_id(),
    293                 input.checkpoint().clone(),
    294                 input.route_digest()
    295             )
    296             .unwrap_err(),
    297             WorkspaceError::InvalidInput
    298         );
    299     }
    300     assert_eq!(
    301         format!("{input:?}"),
    302         "AttachmentInput(<untrusted descriptor>)"
    303     );
    304 }
    305 #[test]
    306 fn host_observations_validate_internal_binding_without_authenticating_metadata() {
    307     let binding = |actor, principal: &str, revision, expiry, observed| {
    308         WorkspaceBinding::from_authenticated_host(
    309             input(),
    310             radroots_storage::workspace::WorkspaceScope::NewBuyerOutbox,
    311             actor,
    312             principal,
    313             Sequence::new(revision).unwrap(),
    314             UnixSeconds::new(expiry).unwrap(),
    315             UnixSeconds::new(observed).unwrap(),
    316         )
    317     };
    318     let observed = binding(actor(), "device", 1, 200, 100).unwrap();
    319     assert_eq!(observed.input(), &input());
    320     assert_eq!(
    321         observed.scope(),
    322         radroots_storage::workspace::WorkspaceScope::NewBuyerOutbox
    323     );
    324     assert_eq!(observed.actor(), actor());
    325     assert_eq!(observed.principal_id(), "device");
    326     assert_eq!(observed.grant_revision().get(), 1);
    327     assert_eq!(observed.expires_at().get(), 200);
    328     assert_eq!(observed.observed_at().get(), 100);
    329     assert_eq!(format!("{observed:?}"), "WorkspaceBinding(<redacted>)");
    330     for principal in [String::new(), "x".repeat(129), "device\n".into()] {
    331         assert_eq!(
    332             binding(actor(), principal.as_str(), 1, 200, 100).unwrap_err(),
    333             WorkspaceError::InvalidInput
    334         );
    335     }
    336     for (revision, expiry, observed) in [
    337         (0, 200, 100),
    338         (1, 0, 100),
    339         (1, 100, 0),
    340         (1, 100, 100),
    341         (1, 99, 100),
    342     ] {
    343         assert_eq!(
    344             binding(actor(), "device", revision, expiry, observed).unwrap_err(),
    345             WorkspaceError::InvalidInput
    346         );
    347     }
    348     let other_key =
    349         PublicKey::from_hex("c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5")
    350             .unwrap();
    351     for invalid in [
    352         ActorRef::new(key(), ActorRole::Seller, None, Some(input().grant_id())),
    353         ActorRef::new(
    354             key(),
    355             ActorRole::Coordinator,
    356             None,
    357             Some(input().grant_id()),
    358         ),
    359         ActorRef::new(
    360             key(),
    361             ActorRole::Buyer,
    362             Some(key()),
    363             Some(input().grant_id()),
    364         ),
    365         ActorRef::new(other_key, ActorRole::Buyer, None, Some(input().grant_id())),
    366         ActorRef::new(key(), ActorRole::Buyer, None, None),
    367         ActorRef::new(
    368             key(),
    369             ActorRole::Buyer,
    370             None,
    371             Some(GrantId::from_bytes([9; 32])),
    372         ),
    373     ] {
    374         assert_eq!(
    375             binding(invalid, "device", 1, 200, 100).unwrap_err(),
    376             WorkspaceError::InvalidInput
    377         );
    378     }
    379 }
    380 #[cfg(feature = "serde")]
    381 #[test]
    382 fn selection_json_rejects_missing_duplicate_unknown_and_invalid_data() {
    383     let input = input();
    384     let encoded = serde_json::to_string(&input).unwrap();
    385     assert_eq!(
    386         serde_json::from_str::<AttachmentInput>(&encoded).unwrap(),
    387         input
    388     );
    389     let value = serde_json::to_value(&input).unwrap();
    390     for field in value.as_object().unwrap().keys() {
    391         let mut missing = value.clone();
    392         missing.as_object_mut().unwrap().remove(field);
    393         assert!(serde_json::from_value::<AttachmentInput>(missing).is_err());
    394         let duplicate = format!("{{\"{field}\":{},{}", value[field], &encoded[1..]);
    395         assert!(serde_json::from_str::<AttachmentInput>(&duplicate).is_err());
    396     }
    397     let mut unknown = value.clone();
    398     unknown["unexpected"] = serde_json::json!(true);
    399     assert!(serde_json::from_value::<AttachmentInput>(unknown).is_err());
    400     for invalid in ["", "bad\n"] {
    401         let mut data = value.clone();
    402         data["endpoint"] = serde_json::json!(invalid);
    403         assert!(serde_json::from_value::<AttachmentInput>(data).is_err());
    404     }
    405 }
    406 #[test]
    407 fn workspace_failures_have_fixed_bounded_codes_and_no_sources() {
    408     use WorkspaceError::*;
    409     for error in [
    410         InvalidInput,
    411         Unavailable,
    412         NamespaceUnavailable,
    413         WriterActive,
    414         WrongNamespace,
    415         RecoveryRequired,
    416         Unauthorized,
    417         GrantExpired,
    418         GrantRevoked,
    419         StaleAuthority,
    420         StaleCheckpoint,
    421         Closed,
    422         StorageFailure,
    423         CommitUnknown,
    424     ] {
    425         assert_eq!(error.to_string(), error.code());
    426         assert!(error.code().len() <= 32);
    427         let source: &dyn core::error::Error = &error;
    428         assert!(source.source().is_none());
    429     }
    430 }