lib

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

grants.rs (21278B)


      1 //! Protected grant-set updates on the existing stock connection owner.
      2 use super::*;
      3 use radroots_domain::{CheckpointDigest, PoolId};
      4 use radroots_storage::command::OperationError;
      5 use sha2::{Digest, Sha256};
      6 use sqlx::Row;
      7 
      8 pub(super) enum StockRecord {
      9     Legacy(GrantRecord),
     10     Scoped(StockGrantRecord),
     11 }
     12 impl StockRecord {
     13     pub(super) fn authenticate(
     14         &self,
     15         input: &AttachmentInput,
     16         proof: &AttachmentProof,
     17         now: radroots_domain::UnixSeconds,
     18     ) -> Result<WorkspaceBinding, WorkspaceError> {
     19         match self {
     20             Self::Legacy(v) => v.authenticate(input, proof, now),
     21             Self::Scoped(v) => v.authenticate(input, proof, now),
     22         }
     23     }
     24     pub(super) fn authenticate_retained_capture(
     25         &self,
     26         input: &AttachmentInput,
     27         proof: &AttachmentProof,
     28     ) -> Result<(), WorkspaceError> {
     29         match self {
     30             Self::Legacy(v) => v.authenticate_retained_capture(input, proof),
     31             Self::Scoped(v) => v.authenticate_retained_capture(input, proof),
     32         }
     33     }
     34     pub(super) fn revoke(&mut self) -> Result<(), WorkspaceError> {
     35         match self {
     36             Self::Legacy(v) => v.revoke(),
     37             Self::Scoped(v) => v.revoke(),
     38         }
     39     }
     40     pub(super) fn encode(&self) -> Result<zeroize::Zeroizing<Vec<u8>>, WorkspaceError> {
     41         match self {
     42             Self::Legacy(v) => v.encode(),
     43             Self::Scoped(v) => v.encode(),
     44         }
     45     }
     46     pub(super) fn allows_action(&self, action: StockAction) -> bool {
     47         match self {
     48             Self::Legacy(_) => true,
     49             Self::Scoped(v) => v.permissions().allows_action(action),
     50         }
     51     }
     52     pub(super) fn require(&self, action: StockAction, pool: PoolId) -> Result<(), OperationError> {
     53         if match self {
     54             Self::Legacy(_) => true,
     55             Self::Scoped(v) => v.permissions().allows(action, pool),
     56         } {
     57             Ok(())
     58         } else {
     59             Err(OperationError::Unauthorized)
     60         }
     61     }
     62     pub(super) fn administrator(&self) -> bool {
     63         matches!(self, Self::Scoped(v) if v.administrator())
     64     }
     65 }
     66 
     67 fn state_hash() -> Sha256 {
     68     let mut h = Sha256::new();
     69     h.update(b"radroots.seller_stock.grant_set.v1\0");
     70     h
     71 }
     72 fn hash_row(hash: &mut Sha256, id: &[u8], protected: &[u8]) {
     73     hash.update(id);
     74     hash.update((protected.len() as u64).to_be_bytes());
     75     hash.update(protected);
     76 }
     77 pub(super) fn single_state(
     78     id: GrantId,
     79     protected: &[u8],
     80 ) -> Result<StockAuthorizationRef, WorkspaceError> {
     81     let mut hash = state_hash();
     82     hash_row(&mut hash, id.as_bytes(), protected);
     83     StockAuthorizationRef::from_host_metadata(
     84         Sequence::new(1).map_err(|_| WorkspaceError::Capacity)?,
     85         CheckpointDigest::from_bytes(hash.finalize().into()),
     86     )
     87 }
     88 async fn snapshot(
     89     connection: &mut SqliteConnection,
     90 ) -> Result<Vec<(GrantId, Vec<u8>)>, WorkspaceError> {
     91     // The count is checked before materializing bounded rows. Revoked grants
     92     // remain retained; exhaustion requires an explicit successor contract.
     93     let count: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_grants")
     94         .fetch_one(&mut *connection)
     95         .await
     96         .map_err(|_| WorkspaceError::RecoveryRequired)?;
     97     if !(1..=64).contains(&count) {
     98         return Err(WorkspaceError::Capacity);
     99     }
    100     let rows=sqlx::query("SELECT grant_id, CASE WHEN length(protected) BETWEEN 1 AND 262144 THEN protected END FROM stock_grants ORDER BY grant_id LIMIT 65").fetch_all(connection).await.map_err(|_|WorkspaceError::RecoveryRequired)?;
    101     if rows.len() != count as usize {
    102         return Err(WorkspaceError::RecoveryRequired);
    103     }
    104     rows.into_iter()
    105         .map(|row| {
    106             let id: Vec<u8> = row
    107                 .try_get(0)
    108                 .map_err(|_| WorkspaceError::RecoveryRequired)?;
    109             let protected: Vec<u8> = row
    110                 .try_get::<Option<Vec<u8>>, _>(1)
    111                 .map_err(|_| WorkspaceError::RecoveryRequired)?
    112                 .ok_or(WorkspaceError::RecoveryRequired)?;
    113             Ok((
    114                 GrantId::from_bytes(
    115                     id.try_into()
    116                         .map_err(|_| WorkspaceError::RecoveryRequired)?,
    117                 ),
    118                 protected,
    119             ))
    120         })
    121         .collect()
    122 }
    123 fn state(
    124     generation: Sequence,
    125     rows: &[(GrantId, Vec<u8>)],
    126 ) -> Result<StockAuthorizationRef, WorkspaceError> {
    127     let mut hash = state_hash();
    128     for (id, protected) in rows {
    129         hash_row(&mut hash, id.as_bytes(), protected);
    130     }
    131     StockAuthorizationRef::from_host_metadata(
    132         generation,
    133         CheckpointDigest::from_bytes(hash.finalize().into()),
    134     )
    135 }
    136 pub(super) async fn check_state(
    137     connection: &mut SqliteConnection,
    138     expected: StockAuthorizationRef,
    139 ) -> Result<(), WorkspaceError> {
    140     let count: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_grant_changes")
    141         .fetch_one(&mut *connection)
    142         .await
    143         .map_err(|_| WorkspaceError::RecoveryRequired)?;
    144     let maximum: i64 =
    145         sqlx::query_scalar("SELECT coalesce(max(revision),1) FROM stock_grant_changes")
    146             .fetch_one(&mut *connection)
    147             .await
    148             .map_err(|_| WorkspaceError::RecoveryRequired)?;
    149     if count != expected.generation().get() as i64 - 1
    150         || maximum != expected.generation().get() as i64
    151     {
    152         return Err(WorkspaceError::RecoveryRequired);
    153     }
    154     if state(expected.generation(), &snapshot(connection).await?)? != expected {
    155         return Err(WorkspaceError::RecoveryRequired);
    156     }
    157     Ok(())
    158 }
    159 
    160 /// Prepared before IO; the original credential and transaction ID survive a
    161 /// lost observer. This value creates no grant until an administrator commits it.
    162 pub struct StockGrantEnrollment {
    163     input: AttachmentInput,
    164     proof: AttachmentProof,
    165     record: StockGrantRecord,
    166     transaction: TransactionId,
    167 }
    168 impl StockGrantEnrollment {
    169     pub fn prepare(
    170         namespace: &SellerAuthoritySelection,
    171         principal: String,
    172         expires_at: radroots_domain::UnixSeconds,
    173         permissions: StockGrantScope,
    174     ) -> Result<Self, WorkspaceError> {
    175         let input = namespace.attachment(GrantId::from_bytes(super::super::random()?))?;
    176         let secret = zeroize::Zeroizing::new(super::super::random()?);
    177         let proof = AttachmentProof::from_protected_input(secret.as_ref())?;
    178         let record =
    179             StockGrantRecord::new(input.clone(), principal, expires_at, permissions, &proof)?;
    180         Ok(Self {
    181             input,
    182             proof,
    183             record,
    184             transaction: TransactionId::from_bytes(super::super::random()?),
    185         })
    186     }
    187     pub fn input(&self) -> &AttachmentInput {
    188         &self.input
    189     }
    190     pub fn proof(&self) -> &AttachmentProof {
    191         &self.proof
    192     }
    193     pub const fn transaction_id(&self) -> TransactionId {
    194         self.transaction
    195     }
    196 }
    197 impl std::fmt::Debug for StockGrantEnrollment {
    198     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    199         f.write_str("StockGrantEnrollment(<redacted>)")
    200     }
    201 }
    202 
    203 /// An actual confirmed grant-set mutation, suitable for independent retention.
    204 #[derive(Clone, Debug, Eq, PartialEq)]
    205 pub struct StockGrantReceipt {
    206     pub(super) transaction: TransactionId,
    207     pub(super) grant: GrantId,
    208     pub(super) authorization: StockAuthorizationRef,
    209 }
    210 impl StockGrantReceipt {
    211     pub const fn transaction_id(&self) -> TransactionId {
    212         self.transaction
    213     }
    214     pub const fn grant_id(&self) -> GrantId {
    215         self.grant
    216     }
    217     pub const fn authorization(&self) -> StockAuthorizationRef {
    218         self.authorization
    219     }
    220 }
    221 #[derive(Clone, Debug, Eq, PartialEq)]
    222 pub enum StockGrantOutcome {
    223     Committed(StockGrantReceipt),
    224     Unknown(TransactionId),
    225 }
    226 
    227 pub(in crate::workspace) struct Change {
    228     pub caller: WorkspaceBinding,
    229     pub minimum: radroots_storage::inventory::InventoryCheckpointRef,
    230     pub transaction: TransactionId,
    231     pub target: GrantId,
    232     pub addition: Option<zeroize::Zeroizing<Vec<u8>>>,
    233 }
    234 #[derive(Serialize, Deserialize)]
    235 #[serde(deny_unknown_fields)]
    236 struct ChangeWire {
    237     version: u8,
    238     transaction: TransactionId,
    239     target: GrantId,
    240     caller: GrantId,
    241     digest: CheckpointDigest,
    242     prior_authorization: StockAuthorizationRef,
    243     authorization: StockAuthorizationRef,
    244 }
    245 fn change_digest(change: &Change) -> Result<CheckpointDigest, WorkspaceError> {
    246     let mut hash = Sha256::new();
    247     hash.update(b"radroots.seller_stock.grant_change.v1\0");
    248     let namespace = SellerAuthoritySelection::from_attachment(change.caller.input());
    249     let clear = zeroize::Zeroizing::new(
    250         serde_json::to_vec(&namespace).map_err(|_| WorkspaceError::InvalidInput)?,
    251     );
    252     hash.update(clear.as_slice());
    253     hash.update(change.caller.input().grant_id().as_bytes());
    254     hash.update(change.transaction.as_bytes());
    255     hash.update(change.target.as_bytes());
    256     hash.update([u8::from(change.addition.is_some())]);
    257     if let Some(clear) = &change.addition {
    258         hash.update(clear.as_slice());
    259     }
    260     Ok(CheckpointDigest::from_bytes(hash.finalize().into()))
    261 }
    262 
    263 impl NativeWorkspace {
    264     pub async fn enroll_stock_grant(
    265         &self,
    266         caller: WorkspaceBinding,
    267         minimum: radroots_storage::inventory::InventoryCheckpointRef,
    268         proof: &AttachmentProof,
    269         enrollment: &StockGrantEnrollment,
    270     ) -> Result<StockGrantOutcome, WorkspaceError> {
    271         let addition = enrollment.record.encode()?;
    272         let proof = proof.with_secret(|bytes| AttachmentProof::from_protected_input(bytes))?;
    273         self.worker
    274             .change_stock_grant(
    275                 Change {
    276                     caller,
    277                     minimum,
    278                     transaction: enrollment.transaction,
    279                     target: enrollment.input.grant_id(),
    280                     addition: Some(addition),
    281                 },
    282                 proof,
    283             )
    284             .await
    285     }
    286     /// The caller prepares and retains this transaction ID before submission.
    287     pub async fn revoke_stock_grant(
    288         &self,
    289         caller: WorkspaceBinding,
    290         minimum: radroots_storage::inventory::InventoryCheckpointRef,
    291         proof: &AttachmentProof,
    292         transaction: TransactionId,
    293         target: GrantId,
    294     ) -> Result<StockGrantOutcome, WorkspaceError> {
    295         let proof = proof.with_secret(|bytes| AttachmentProof::from_protected_input(bytes))?;
    296         self.worker
    297             .change_stock_grant(
    298                 Change {
    299                     caller,
    300                     minimum,
    301                     transaction,
    302                     target,
    303                     addition: None,
    304                 },
    305                 proof,
    306             )
    307             .await
    308     }
    309 }
    310 
    311 pub(in crate::workspace) async fn change(
    312     turn: &mut inventory::Turn<'_>,
    313     change: Change,
    314     proof: AttachmentProof,
    315 ) -> Result<StockGrantOutcome, WorkspaceError> {
    316     if *turn.uncertain {
    317         return Err(WorkspaceError::RecoveryRequired);
    318     }
    319     turn.namespace.validate()?;
    320     if !SellerAuthoritySelection::from_attachment(turn.selected)
    321         .matches_attachment(change.caller.input())
    322     {
    323         return Err(WorkspaceError::WrongNamespace);
    324     }
    325     let (mut authority, record, old_root, old_grant) =
    326         super::read(turn.connection, change.caller.input(), turn.crypto).await?;
    327     if !(4..=20).contains(&authority.catalog) {
    328         return Err(WorkspaceError::Unauthorized);
    329     }
    330     let catalog = authority.catalog;
    331     let current = record.authenticate(change.caller.input(), &proof, turn.clock.now()?)?;
    332     if current.observed_at() < change.caller.observed_at() {
    333         return Err(WorkspaceError::Unavailable);
    334     }
    335     radroots_storage::command::protected::same_binding(&change.caller, &current)
    336         .map_err(|_| WorkspaceError::Unauthorized)?;
    337     if !record.administrator() {
    338         return Err(WorkspaceError::Unauthorized);
    339     }
    340     let authorization = authority
    341         .authorization
    342         .ok_or(WorkspaceError::RecoveryRequired)?;
    343     // Existing protected ancestry is checked outside the SQL lock and its exact
    344     // row witness is rechecked inside it, alongside the grant-set fingerprint.
    345     let ancestry = inventory::grant_minimum(
    346         turn.connection,
    347         turn.selected,
    348         turn.crypto,
    349         &current,
    350         &authority,
    351         change.minimum,
    352     )
    353     .await?;
    354     let digest = change_digest(&change)?;
    355     let existing:Option<Vec<u8>>=sqlx::query_scalar("SELECT protected FROM stock_grant_changes WHERE transaction_id=? AND length(protected) BETWEEN 1 AND 262144").bind(change.transaction.as_bytes().as_slice()).fetch_optional(&mut *turn.connection).await.map_err(|_|WorkspaceError::RecoveryRequired)?;
    356     if let Some(protected) = existing {
    357         let clear = turn
    358             .crypto
    359             .open_stock_record(
    360                 turn.selected,
    361                 "grant_change",
    362                 change.transaction.as_bytes(),
    363                 &protected,
    364             )
    365             .await?;
    366         let retained: ChangeWire = clear.expose_secret(|bytes| super::closed_record(bytes))?;
    367         if retained.version != 1
    368             || retained.transaction != change.transaction
    369             || retained.target != change.target
    370             || retained.caller != current.input().grant_id()
    371             || retained.digest != digest
    372             || (change.minimum.authorization() != Some(authorization)
    373                 && change.minimum.authorization() != Some(retained.prior_authorization))
    374             || retained.authorization.generation().get() > authorization.generation().get()
    375         {
    376             return Err(WorkspaceError::InvalidInput);
    377         }
    378         let mut tx = turn
    379             .connection
    380             .begin_with("BEGIN IMMEDIATE")
    381             .await
    382             .map_err(|_| WorkspaceError::StorageFailure)?;
    383         let checked: Result<(), WorkspaceError> = async {
    384             super::unchanged(&mut tx, current.input(), catalog, &old_root, &old_grant).await?;
    385             check_state(&mut tx, authorization).await?;
    386             ancestry
    387                 .confirm(&mut tx)
    388                 .await
    389                 .map_err(|_| WorkspaceError::RecoveryRequired)?;
    390             let checked = record.authenticate(current.input(), &proof, turn.clock.now()?)?;
    391             if checked.observed_at() < current.observed_at() {
    392                 return Err(WorkspaceError::Unavailable);
    393             }
    394             let matched: i64 = sqlx::query_scalar(
    395                 "SELECT count(*) FROM stock_grant_changes WHERE transaction_id=? AND protected=?",
    396             )
    397             .bind(change.transaction.as_bytes().as_slice())
    398             .bind(&protected)
    399             .fetch_one(&mut *tx)
    400             .await
    401             .map_err(|_| WorkspaceError::StorageFailure)?;
    402             if matched != 1 {
    403                 return Err(WorkspaceError::RecoveryRequired);
    404             }
    405             Ok(())
    406         }
    407         .await;
    408         if tx.rollback().await.is_err() {
    409             *turn.uncertain = true;
    410             return Ok(StockGrantOutcome::Unknown(change.transaction));
    411         }
    412         checked?;
    413         return Ok(StockGrantOutcome::Committed(StockGrantReceipt {
    414             transaction: retained.transaction,
    415             grant: retained.target,
    416             authorization: retained.authorization,
    417         }));
    418     }
    419     if change.minimum.authorization() != Some(authorization) {
    420         return Err(WorkspaceError::StaleCheckpoint);
    421     }
    422     let mut rows = snapshot(turn.connection).await?;
    423     let position = rows.binary_search_by_key(&change.target, |v| v.0);
    424     let protected = if let Some(clear) = &change.addition {
    425         if position.is_ok() {
    426             return Err(WorkspaceError::InvalidInput);
    427         }
    428         if rows.len() >= 64 {
    429             return Err(WorkspaceError::Capacity);
    430         }
    431         let new = StockGrantRecord::decode(clear)?;
    432         if new.input().grant_id() != change.target || new.expires_at() <= turn.clock.now()? {
    433             return Err(WorkspaceError::InvalidInput);
    434         }
    435         if new.administrator()
    436             || !new.belongs_to(&SellerAuthoritySelection::from_attachment(turn.selected))?
    437         {
    438             return Err(WorkspaceError::Unauthorized);
    439         }
    440         turn.crypto
    441             .seal_stock_record(turn.selected, "grant", change.target.as_bytes(), clear)
    442             .await?
    443     } else {
    444         let index = position.map_err(|_| WorkspaceError::WrongNamespace)?;
    445         let input =
    446             SellerAuthoritySelection::from_attachment(turn.selected).attachment(change.target)?;
    447         let clear = turn
    448             .crypto
    449             .open_stock_record(&input, "grant", change.target.as_bytes(), &rows[index].1)
    450             .await?;
    451         let mut target = clear.expose_secret(StockGrantRecord::decode)?;
    452         target.revoke()?;
    453         turn.crypto
    454             .seal_stock_record(&input, "grant", change.target.as_bytes(), &target.encode()?)
    455             .await?
    456     };
    457     match position {
    458         Ok(index) => rows[index].1 = protected.clone(),
    459         Err(index) => rows.insert(index, (change.target, protected.clone())),
    460     }
    461     authority.revocation = Sequence::new(
    462         authority
    463             .revocation
    464             .get()
    465             .checked_add(1)
    466             .ok_or(WorkspaceError::Capacity)?,
    467     )
    468     .map_err(|_| WorkspaceError::Capacity)?;
    469     let next = state(authority.revocation, &rows)?;
    470     authority.authorization = Some(next);
    471     let root = turn
    472         .crypto
    473         .seal_stock_root(turn.selected, catalog, &authority.encode()?)
    474         .await?;
    475     let retained = ChangeWire {
    476         version: 1,
    477         transaction: change.transaction,
    478         target: change.target,
    479         caller: current.input().grant_id(),
    480         digest,
    481         prior_authorization: authorization,
    482         authorization: next,
    483     };
    484     let clear = zeroize::Zeroizing::new(
    485         serde_json::to_vec(&retained).map_err(|_| WorkspaceError::StorageFailure)?,
    486     );
    487     let receipt = turn
    488         .crypto
    489         .seal_stock_record(
    490             turn.selected,
    491             "grant_change",
    492             change.transaction.as_bytes(),
    493             &clear,
    494         )
    495         .await?;
    496     let mut tx = turn
    497         .connection
    498         .begin_with("BEGIN IMMEDIATE")
    499         .await
    500         .map_err(|_| WorkspaceError::StorageFailure)?;
    501     let changed: Result<(), WorkspaceError> = async {
    502         turn.namespace.validate()?;
    503         super::unchanged(&mut tx, current.input(), catalog, &old_root, &old_grant).await?;
    504         check_state(&mut tx, authorization).await?;
    505         ancestry
    506             .confirm(&mut tx)
    507             .await
    508             .map_err(|_| WorkspaceError::RecoveryRequired)?;
    509         let now = turn.clock.now()?;
    510         record.authenticate(current.input(), &proof, now)?;
    511         if now < current.observed_at() {
    512             return Err(WorkspaceError::Unavailable);
    513         }
    514         if let Some(clear) = &change.addition
    515             && StockGrantRecord::decode(clear)?.expires_at() <= now
    516         {
    517             return Err(WorkspaceError::GrantExpired);
    518         }
    519         if position.is_ok() {
    520             let result = sqlx::query("UPDATE stock_grants SET protected=? WHERE grant_id=?")
    521                 .bind(&protected)
    522                 .bind(change.target.as_bytes().as_slice())
    523                 .execute(&mut *tx)
    524                 .await
    525                 .map_err(|_| WorkspaceError::StorageFailure)?;
    526             if result.rows_affected() != 1 {
    527                 return Err(WorkspaceError::RecoveryRequired);
    528             }
    529         } else {
    530             sqlx::query("INSERT INTO stock_grants(grant_id,protected) VALUES(?,?)")
    531                 .bind(change.target.as_bytes().as_slice())
    532                 .bind(&protected)
    533                 .execute(&mut *tx)
    534                 .await
    535                 .map_err(|_| WorkspaceError::StorageFailure)?;
    536         }
    537         sqlx::query(
    538             "INSERT INTO stock_grant_changes(transaction_id,revision,protected) VALUES(?,?,?)",
    539         )
    540         .bind(change.transaction.as_bytes().as_slice())
    541         .bind(next.generation().get() as i64)
    542         .bind(receipt)
    543         .execute(&mut *tx)
    544         .await
    545         .map_err(|_| WorkspaceError::StorageFailure)?;
    546         let result =
    547             sqlx::query("UPDATE stock_authority SET protected=? WHERE singleton=1 AND protected=?")
    548                 .bind(root)
    549                 .bind(&old_root)
    550                 .execute(&mut *tx)
    551                 .await
    552                 .map_err(|_| WorkspaceError::StorageFailure)?;
    553         if result.rows_affected() != 1 {
    554             return Err(WorkspaceError::RecoveryRequired);
    555         }
    556         turn.namespace.validate()?;
    557         Ok(())
    558     }
    559     .await;
    560     if let Err(error) = changed {
    561         if tx.rollback().await.is_err() {
    562             *turn.uncertain = true;
    563             return Ok(StockGrantOutcome::Unknown(change.transaction));
    564         }
    565         return Err(error);
    566     }
    567     if tx.commit().await.is_err() {
    568         *turn.uncertain = true;
    569         return Ok(StockGrantOutcome::Unknown(change.transaction));
    570     }
    571     Ok(StockGrantOutcome::Committed(StockGrantReceipt {
    572         transaction: change.transaction,
    573         grant: change.target,
    574         authorization: next,
    575     }))
    576 }