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, ¤t) 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 ¤t, 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 }