phoebus_os/installer-rs/crates/phoebus-installer/src/approval.rs

814 lines
29 KiB
Rust

//! Broker-controlled approval ledger for privileged plan execution.
//!
//! Plans are staged in per-user storage, which the reviewing user fully
//! controls: they can replace a plan, recompute its seal, and delete the
//! consumption marker. The privileged broker therefore keeps its own record of
//! which approvals it has already consumed.
//!
//! The ledger lives in a root-owned directory (`/var/lib/phoebus/approvals`,
//! 0700, records 0600) that the unprivileged user cannot write.
//!
//! ## Stable approval identity
//!
//! A record is keyed by [`approval_key`], derived from the random plan ID, the
//! *canonical* approval digest (recomputed from the executable actions and the
//! reviewed material effects), the initiating uid and the canonical target
//! root. Presentation-only fields (summary, rationale, recommendations) are
//! deliberately absent: editing them cannot mint a fresh ledger entry for an
//! already-consumed approval. A newly reviewed identical operation gets a new
//! random plan ID and is therefore allowed, while every replay of the original
//! approval is refused.
//!
//! ## Monotonic, crash-safe terminal transitions
//!
//! A claim records the owning process identity (`pid`, process start time and
//! boot id). The terminal status is published exactly once by atomically
//! linking a fully written record into `<key>.terminal`; the link fails if a
//! terminal already exists, so a terminal status can never be overwritten or
//! changed to another terminal status. Reconciliation only marks a record
//! interrupted when its owner is provably gone (the pid no longer exists, the
//! pid was reused by a different process, or the machine rebooted), so a live
//! executor is never mistaken for a crashed one.
//!
//! The ledger is *not* a signature scheme and does not claim to be: the
//! independently preserved digest supplied by the approval UI is what binds the
//! human decision. The ledger anchors consumption so user-editable files cannot
//! be used to replay or replace an approved plan.
use std::io::Write;
use std::path::{Path, PathBuf};
use std::time::{SystemTime, UNIX_EPOCH};
use phoebus_executor::error::{ExecError, Result};
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
/// Terminal states a consumed approval can reach. There is deliberately no
/// "retry" transition: a plan whose approval was claimed is never automatically
/// re-executed.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ApprovalStatus {
/// Claimed and executing.
InProgress,
/// Completed and verified.
Consumed,
/// The action or verification failed; completed steps are retained.
Failed,
/// The process died after claiming but before finishing.
Interrupted,
/// Claimed after the plan's TTL; recorded for truthful reporting.
Expired,
}
impl ApprovalStatus {
pub fn as_str(self) -> &'static str {
match self {
ApprovalStatus::InProgress => "in_progress",
ApprovalStatus::Consumed => "consumed",
ApprovalStatus::Failed => "failed",
ApprovalStatus::Interrupted => "interrupted",
ApprovalStatus::Expired => "expired",
}
}
pub fn is_terminal(self) -> bool {
!matches!(self, ApprovalStatus::InProgress)
}
}
/// Identity of the process that claimed an approval, used to distinguish a live
/// executor from a crashed one during reconciliation.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ProcessIdentity {
pub pid: u32,
/// The process start time (`/proc/<pid>/stat` field 22), in clock ticks.
pub start_ticks: u64,
/// The kernel boot id, so a pid reused after a reboot is never mistaken for
/// the same process.
pub boot_id: String,
}
impl ProcessIdentity {
/// Identity of the current process.
pub fn current() -> Self {
let pid = std::process::id();
let start_ticks = std::fs::read_to_string(format!("/proc/{pid}/stat"))
.ok()
.and_then(|s| parse_start_ticks(&s))
.unwrap_or(0);
Self {
pid,
start_ticks,
boot_id: boot_id(),
}
}
/// Whether the owning process is still running. A missing `/proc` entry, a
/// different start time (pid reuse) or a different boot id all mean the
/// executor is gone.
pub fn is_alive(&self) -> bool {
let current_boot = boot_id();
if !self.boot_id.is_empty() && !current_boot.is_empty() && self.boot_id != current_boot {
return false;
}
match std::fs::read_to_string(format!("/proc/{}/stat", self.pid)) {
Ok(text) => match parse_start_ticks(&text) {
// A start time of 0 means it could not be recorded; fall back to
// "present" rather than mislabel a live process.
Some(ticks) => self.start_ticks == 0 || ticks == self.start_ticks,
None => true,
},
Err(_) => false,
}
}
}
fn parse_start_ticks(stat: &str) -> Option<u64> {
// The command name is parenthesised and may contain spaces or parentheses;
// parse the fields after the last ')'.
let close = stat.rfind(')')?;
let rest = stat.get(close + 1..)?.trim_start();
let fields: Vec<&str> = rest.split_whitespace().collect();
// fields[0] is field 3 (state); starttime is field 22 -> index 19.
fields.get(19).and_then(|s| s.parse::<u64>().ok())
}
fn boot_id() -> String {
std::fs::read_to_string("/proc/sys/kernel/random/boot_id")
.map(|s| s.trim().to_string())
.unwrap_or_default()
}
/// The stable identity of an approval, independent of presentation fields.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ApprovalIdentity {
/// The ledger key: a hex fingerprint over the fields below.
pub key: String,
pub plan_id: String,
/// The canonical approval digest, independently recomputed at the
/// privileged boundary.
pub digest: String,
pub initiator_uid: u32,
pub target_root: String,
pub expires_unix: u64,
pub action_count: usize,
}
impl ApprovalIdentity {
pub fn new(
plan_id: impl Into<String>,
digest: impl Into<String>,
initiator_uid: u32,
target_root: impl Into<String>,
expires_unix: u64,
action_count: usize,
) -> Self {
let plan_id = plan_id.into();
let digest = digest.into();
let target_root = target_root.into();
let key = approval_key(&plan_id, &digest, initiator_uid, &target_root);
Self {
key,
plan_id,
digest,
initiator_uid,
target_root,
expires_unix,
action_count,
}
}
}
/// Derive the stable ledger key. Deliberately excludes summary, rationale,
/// recommendations, timestamps and the plan's self-consistency seal, all of
/// which the reviewing user can edit and recompute.
pub fn approval_key(plan_id: &str, digest: &str, initiator_uid: u32, target_root: &str) -> String {
let mut hasher = Sha256::new();
hasher.update(b"phoebus-approval-key-v1\0");
hasher.update(plan_id.as_bytes());
hasher.update(b"\0");
hasher.update(digest.as_bytes());
hasher.update(b"\0");
hasher.update(initiator_uid.to_le_bytes());
hasher.update(b"\0");
hasher.update(target_root.as_bytes());
format!("{:x}", hasher.finalize())
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ApprovalRecord {
/// The stable [`approval_key`].
pub approval_key: String,
pub plan_id: String,
/// The canonical approval digest.
pub digest: String,
pub initiator_uid: u32,
pub target_root: String,
pub expires_unix: u64,
pub created_unix: u64,
#[serde(default)]
pub finished_unix: u64,
pub status: String,
#[serde(default)]
pub result: String,
/// How many actions the approved plan contained, for truthful reporting.
#[serde(default)]
pub action_count: usize,
/// The claiming process, when known (older records may lack it).
#[serde(default, skip_serializing_if = "Option::is_none")]
pub owner: Option<ProcessIdentity>,
}
/// The outcome of a terminal transition.
#[derive(Debug, Clone)]
pub enum Finished {
/// This call recorded the terminal status.
Recorded,
/// A terminal status already existed and was left unchanged.
AlreadyTerminal(Box<ApprovalRecord>),
}
/// A guard proving this process claimed the approval. Dropping it does not
/// release the claim: the durable record is the anti-replay anchor.
#[derive(Debug)]
pub struct ApprovalClaim {
key: String,
}
impl ApprovalClaim {
pub fn key(&self) -> &str {
&self.key
}
}
#[derive(Debug, Clone)]
pub struct ApprovalLedger {
dir: PathBuf,
}
impl ApprovalLedger {
/// The broker's ledger. `PHOEBUS_APPROVALS_DIR` overrides the location for
/// tests and for an installed system that relocates its state. `pkexec`
/// strips unknown environment variables, so this is not user-controllable
/// on the privileged path.
pub fn for_broker() -> Self {
if let Ok(dir) = std::env::var("PHOEBUS_APPROVALS_DIR") {
return Self {
dir: PathBuf::from(dir),
};
}
Self {
dir: PathBuf::from("/var/lib/phoebus/approvals"),
}
}
/// An explicit directory, for tests.
pub fn with_dir(dir: impl Into<PathBuf>) -> Self {
Self { dir: dir.into() }
}
pub fn dir(&self) -> &Path {
&self.dir
}
fn ensure_dir(&self) -> Result<()> {
std::fs::create_dir_all(&self.dir).map_err(|e| ExecError::io(self.dir.clone(), e))?;
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
let _ = std::fs::set_permissions(&self.dir, std::fs::Permissions::from_mode(0o700));
}
Ok(())
}
fn valid_key(key: &str) -> bool {
!key.is_empty() && key.len() <= 128 && key.bytes().all(|b| b.is_ascii_hexdigit())
}
fn main_path(&self, key: &str) -> Result<PathBuf> {
if !Self::valid_key(key) {
return Err(ExecError::operation(
"approval",
"ledger path",
"approval key is not a hex digest",
));
}
Ok(self.dir.join(format!("{key}.json")))
}
fn terminal_path(&self, key: &str) -> Result<PathBuf> {
if !Self::valid_key(key) {
return Err(ExecError::operation(
"approval",
"ledger path",
"approval key is not a hex digest",
));
}
Ok(self.dir.join(format!("{key}.terminal")))
}
/// Atomically claim an approval for execution. Fails if the key has already
/// been claimed or terminated, which is what makes replay impossible after
/// the user deletes their own plan and claim files.
pub fn claim(&self, identity: &ApprovalIdentity) -> Result<ApprovalClaim> {
self.claim_with_owner(identity, ProcessIdentity::current())
}
/// Claim with an explicit owner identity (used by tests to simulate a live
/// or an abandoned executor).
pub fn claim_with_owner(
&self,
identity: &ApprovalIdentity,
owner: ProcessIdentity,
) -> Result<ApprovalClaim> {
self.ensure_dir()?;
let path = self.main_path(&identity.key)?;
// A terminal marker is authoritative: even if the main record was
// removed (which the user cannot do to root-owned files), the approval
// stays consumed.
if self.terminal_path(&identity.key)?.exists() {
let prior = self.get(&identity.key).unwrap_or(None);
return Err(self.already_used(prior.as_ref()));
}
let record = ApprovalRecord {
approval_key: identity.key.clone(),
plan_id: identity.plan_id.clone(),
digest: identity.digest.clone(),
initiator_uid: identity.initiator_uid,
target_root: identity.target_root.clone(),
expires_unix: identity.expires_unix,
created_unix: now_unix(),
finished_unix: 0,
status: ApprovalStatus::InProgress.as_str().to_string(),
result: "in progress".into(),
action_count: identity.action_count,
owner: Some(owner),
};
let text = serde_json::to_string_pretty(&record)
.map_err(|e| ExecError::operation("approval", "serialize", e.to_string()))?;
let mut opts = std::fs::OpenOptions::new();
opts.write(true).create_new(true);
#[cfg(unix)]
{
use std::os::unix::fs::OpenOptionsExt;
opts.mode(0o600);
}
match opts.open(&path) {
Ok(mut file) => {
file.write_all(text.as_bytes())
.and_then(|_| file.flush())
.and_then(|_| file.sync_all())
.map_err(|e| ExecError::io(path.clone(), e))?;
Ok(ApprovalClaim {
key: identity.key.clone(),
})
}
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => {
let prior = self.get(&identity.key).unwrap_or(None);
Err(self.already_used(prior.as_ref()))
}
Err(e) => Err(ExecError::io(path, e)),
}
}
fn already_used(&self, prior: Option<&ApprovalRecord>) -> ExecError {
let detail = prior
.map(|r| format!("{} ({})", r.status, r.result))
.unwrap_or_else(|| "already claimed".to_string());
ExecError::operation(
"approval",
"claim",
format!(
"this approval was already used: {detail}; re-run the workflow to review a \
fresh plan instead of repeating a mutation"
),
)
}
/// Record the terminal status of a claimed approval. The transition is
/// atomic and monotonic: the first terminal status wins and can never be
/// overwritten or changed to another terminal status.
pub fn finish(&self, key: &str, status: ApprovalStatus, result: &str) -> Result<Finished> {
if !status.is_terminal() {
return Err(ExecError::operation(
"approval",
"finish",
"finish requires a terminal status",
));
}
self.ensure_dir()?;
let main = self.main_path(key)?;
let terminal = self.terminal_path(key)?;
// Read the current state. If it is already terminal, leave it untouched.
let mut record = match self.get(key)? {
Some(record) => record,
None => {
return Err(ExecError::operation(
"approval",
"finish",
"no approval record to finish",
))
}
};
if record.status != ApprovalStatus::InProgress.as_str() {
return Ok(Finished::AlreadyTerminal(Box::new(record)));
}
record.status = status.as_str().to_string();
record.result = result.to_string();
record.finished_unix = now_unix();
let text = serde_json::to_string_pretty(&record)
.map_err(|e| ExecError::operation("approval", "serialize", e.to_string()))?;
// Write a fully formed record to a unique temp file, then publish it
// with an atomic hard link that fails if a terminal already exists.
let tmp = self
.dir
.join(format!(".{key}.{}.terminal.tmp", std::process::id()));
{
let mut opts = std::fs::OpenOptions::new();
opts.write(true).create_new(true);
#[cfg(unix)]
{
use std::os::unix::fs::OpenOptionsExt;
opts.mode(0o600);
}
let mut fh = match opts.open(&tmp) {
Ok(fh) => fh,
Err(e) => return Err(ExecError::io(tmp.clone(), e)),
};
fh.write_all(text.as_bytes())
.and_then(|_| fh.flush())
.and_then(|_| fh.sync_all())
.map_err(|e| ExecError::io(tmp.clone(), e))?;
}
match std::fs::hard_link(&tmp, &terminal) {
Ok(()) => {
let _ = std::fs::remove_file(&tmp);
// Mirror the terminal state into the main record (best effort;
// the terminal marker is authoritative).
let _ = write_atomic(&main, text.as_bytes());
Ok(Finished::Recorded)
}
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => {
let _ = std::fs::remove_file(&tmp);
match self.get(key)? {
Some(existing) => Ok(Finished::AlreadyTerminal(Box::new(existing))),
None => Err(ExecError::io(terminal, e)),
}
}
Err(e) => {
let _ = std::fs::remove_file(&tmp);
Err(ExecError::io(terminal, e))
}
}
}
/// Read a record. The terminal marker is authoritative when present. An
/// invalid key simply has no record.
pub fn get(&self, key: &str) -> Result<Option<ApprovalRecord>> {
if !Self::valid_key(key) {
return Ok(None);
}
if let Some(record) = self.read_terminal(key)? {
return Ok(Some(record));
}
if let Some(record) = self.read_main(key)? {
return Ok(Some(record));
}
Ok(None)
}
fn read_terminal(&self, key: &str) -> Result<Option<ApprovalRecord>> {
let path = self.terminal_path(key)?;
self.read_record(&path)
}
fn read_main(&self, key: &str) -> Result<Option<ApprovalRecord>> {
let path = self.main_path(key)?;
self.read_record(&path)
}
fn read_record(&self, path: &Path) -> Result<Option<ApprovalRecord>> {
if !path.is_file() {
return Ok(None);
}
let text =
std::fs::read_to_string(path).map_err(|e| ExecError::io(path.to_path_buf(), e))?;
let record = serde_json::from_str(&text)
.map_err(|e| ExecError::operation("approval", "deserialize", e.to_string()))?;
Ok(Some(record))
}
/// Reconcile approvals whose owner is provably gone. A live executor is
/// never touched: a record is only marked interrupted when its owning
/// process no longer exists (or the machine rebooted). The transition uses
/// the same atomic terminal publication as [`finish`], so it cannot
/// overwrite a real terminal result.
pub fn reconcile_interrupted(&self) -> Result<usize> {
if !self.dir.is_dir() {
return Ok(0);
}
let entries =
std::fs::read_dir(&self.dir).map_err(|e| ExecError::io(self.dir.clone(), e))?;
let mut reconciled = 0;
for entry in entries.flatten() {
let path = entry.path();
if path.extension().and_then(|e| e.to_str()) != Some("json") {
continue;
}
let Some(key) = path.file_stem().and_then(|s| s.to_str()) else {
continue;
};
if !Self::valid_key(key) {
continue;
}
// Already terminal.
if self.terminal_path(key)?.exists() {
continue;
}
let Ok(Some(record)) = self.read_main(key) else {
continue;
};
if record.status != ApprovalStatus::InProgress.as_str() {
continue;
}
// Only reconcile when the owner is provably gone.
if record
.owner
.as_ref()
.map(|owner| owner.is_alive())
.unwrap_or(false)
{
continue;
}
if let Ok(Finished::Recorded) = self.finish(
key,
ApprovalStatus::Interrupted,
"the executing process ended before completing",
) {
reconciled += 1;
}
}
Ok(reconciled)
}
}
/// Atomically replace `path` with `bytes` (temp file + rename). Best effort.
fn write_atomic(path: &Path, bytes: &[u8]) -> std::io::Result<()> {
let dir = path.parent().unwrap_or_else(|| Path::new("."));
let tmp = dir.join(format!(".{}.{}.tmp", std::process::id(), now_unix()));
{
let mut opts = std::fs::OpenOptions::new();
opts.write(true).create_new(true);
#[cfg(unix)]
{
use std::os::unix::fs::OpenOptionsExt;
opts.mode(0o600);
}
let mut fh = opts.open(&tmp)?;
fh.write_all(bytes)?;
fh.flush()?;
fh.sync_all()?;
}
match std::fs::rename(&tmp, path) {
Ok(()) => Ok(()),
Err(e) => {
let _ = std::fs::remove_file(&tmp);
Err(e)
}
}
}
fn now_unix() -> u64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0)
}
/// Resolve the authenticated caller of a privileged broker invocation.
///
/// `pkexec` sets `PKEXEC_UID` to the uid of the process that requested
/// elevation; that is the authoritative initiator. The `--plan-uid` argument is
/// treated as untrusted input and only consulted when the broker already runs
/// as root for an internal (non-Polkit) invocation.
pub fn broker_initiator_uid(
explicit_plan_uid: Option<u32>,
effective_ground_uid: u32,
) -> Result<u32> {
if let Ok(value) = std::env::var("PKEXEC_UID") {
if let Ok(uid) = value.trim().parse::<u32>() {
return Ok(uid);
}
return Err(ExecError::operation(
"approval",
"caller identity",
"PKEXEC_UID was not a valid uid; refusing to execute",
));
}
if effective_ground_uid == 0 {
if let Some(uid) = explicit_plan_uid {
return Ok(uid);
}
return Err(ExecError::operation(
"approval",
"caller identity",
"--execute-plan requires the initiating uid (--plan-uid) when no authenticated \
PKEXEC_UID context is present",
));
}
Err(ExecError::operation(
"approval",
"caller identity",
"cannot establish the authenticated caller; refusing privileged execution",
))
}
#[cfg(test)]
mod tests {
use super::*;
use tempfile::tempdir;
fn identity() -> ApprovalIdentity {
ApprovalIdentity::new("plan-a", "digest-a", 1000, "/", 9999999999, 1)
}
fn dead_owner() -> ProcessIdentity {
ProcessIdentity {
pid: u32::MAX,
start_ticks: 1,
boot_id: boot_id(),
}
}
#[test]
fn a_claim_can_only_be_taken_once() {
let dir = tempdir().unwrap();
let ledger = ApprovalLedger::with_dir(dir.path());
let id = identity();
let _claim = ledger.claim(&id).unwrap();
let err = ledger.claim(&id).unwrap_err();
assert!(err.to_string().contains("already used"), "{err}");
}
#[test]
fn concurrent_claims_allow_at_most_one_execution() {
let dir = tempdir().unwrap();
let ledger = ApprovalLedger::with_dir(dir.path());
let id = identity();
let handles: Vec<_> = (0..8)
.map(|_| {
let ledger = ledger.clone();
let id = id.clone();
std::thread::spawn(move || ledger.claim(&id).is_ok())
})
.collect();
let successes = handles
.into_iter()
.map(|h| h.join().expect("claim thread panicked"))
.filter(|won| *won)
.count();
assert_eq!(successes, 1, "exactly one claim may win");
}
#[test]
fn finish_records_a_terminal_status_and_retains_the_record() {
let dir = tempdir().unwrap();
let ledger = ApprovalLedger::with_dir(dir.path());
let id = identity();
let claim = ledger.claim(&id).unwrap();
let finished = ledger
.finish(claim.key(), ApprovalStatus::Consumed, "ok")
.unwrap();
assert!(matches!(finished, Finished::Recorded));
let record = ledger.get(&id.key).unwrap().unwrap();
assert_eq!(record.status, "consumed");
}
#[test]
fn terminal_status_is_monotonic_and_cannot_be_overwritten() {
let dir = tempdir().unwrap();
let ledger = ApprovalLedger::with_dir(dir.path());
let id = identity();
let claim = ledger.claim(&id).unwrap();
ledger
.finish(claim.key(), ApprovalStatus::Consumed, "ok")
.unwrap();
// A second, conflicting terminal transition must be refused and must
// not change the recorded status.
let second = ledger
.finish(claim.key(), ApprovalStatus::Failed, "boom")
.unwrap();
assert!(matches!(second, Finished::AlreadyTerminal(ref r) if r.status == "consumed"));
assert_eq!(ledger.get(&id.key).unwrap().unwrap().status, "consumed");
}
#[test]
fn a_live_operation_is_not_reconciled() {
let dir = tempdir().unwrap();
let ledger = ApprovalLedger::with_dir(dir.path());
let id = identity();
// The current process owns this claim and is running.
let _claim = ledger.claim(&id).unwrap();
assert_eq!(ledger.reconcile_interrupted().unwrap(), 0);
assert_eq!(ledger.get(&id.key).unwrap().unwrap().status, "in_progress");
}
#[test]
fn a_genuinely_abandoned_operation_is_recovered() {
let dir = tempdir().unwrap();
let ledger = ApprovalLedger::with_dir(dir.path());
let id = identity();
let _claim = ledger.claim_with_owner(&id, dead_owner()).unwrap();
assert_eq!(ledger.reconcile_interrupted().unwrap(), 1);
assert_eq!(ledger.get(&id.key).unwrap().unwrap().status, "interrupted");
// And it cannot be retried.
assert!(ledger.claim(&id).is_err());
}
#[test]
fn reconciliation_racing_completion_yields_exactly_one_stable_terminal() {
let dir = tempdir().unwrap();
let ledger = ApprovalLedger::with_dir(dir.path());
let id = identity();
let _claim = ledger.claim_with_owner(&id, dead_owner()).unwrap();
let reconciler = {
let ledger = ledger.clone();
std::thread::spawn(move || ledger.reconcile_interrupted().is_ok())
};
let finisher = {
let ledger = ledger.clone();
let key = id.key.clone();
std::thread::spawn(move || ledger.finish(&key, ApprovalStatus::Consumed, "ok").is_ok())
};
reconciler.join().unwrap();
finisher.join().unwrap();
let first = ledger.get(&id.key).unwrap().unwrap();
assert!(ApprovalStatus::Consumed.is_terminal());
// Whatever won, the status is terminal and stable under a later finish.
let later = ledger
.finish(&id.key, ApprovalStatus::Failed, "late")
.unwrap();
assert!(matches!(later, Finished::AlreadyTerminal(_)));
let second = ledger.get(&id.key).unwrap().unwrap();
assert_eq!(
first.status, second.status,
"terminal status must not change"
);
assert!(second.status == "consumed" || second.status == "interrupted");
}
#[test]
fn a_replay_is_refused_even_after_the_user_plan_files_are_gone() {
let dir = tempdir().unwrap();
let ledger = ApprovalLedger::with_dir(dir.path());
let id = identity();
let claim = ledger.claim(&id).unwrap();
ledger
.finish(claim.key(), ApprovalStatus::Consumed, "ok")
.unwrap();
assert!(ledger.claim(&id).is_err());
}
#[test]
fn the_key_ignores_presentation_fields_but_changes_with_identity() {
// Same id/digest/uid/root -> same key regardless of anything else.
assert_eq!(
approval_key("plan-a", "d", 1000, "/"),
approval_key("plan-a", "d", 1000, "/")
);
// A new plan id is a new approval.
assert_ne!(
approval_key("plan-a", "d", 1000, "/"),
approval_key("plan-b", "d", 1000, "/")
);
// A different digest, user or root is a different approval.
assert_ne!(
approval_key("plan-a", "d", 1000, "/"),
approval_key("plan-a", "e", 1000, "/")
);
assert_ne!(
approval_key("plan-a", "d", 1000, "/"),
approval_key("plan-a", "d", 1001, "/")
);
assert_ne!(
approval_key("plan-a", "d", 1000, "/"),
approval_key("plan-a", "d", 1000, "/alt")
);
}
#[test]
fn rejects_non_hex_keys() {
let dir = tempdir().unwrap();
let ledger = ApprovalLedger::with_dir(dir.path());
assert!(ledger.get("../escape").unwrap().is_none());
assert!(ledger
.finish("not-a-hash", ApprovalStatus::Consumed, "x")
.is_err());
}
}