Skip to main content

qualia_core_db/bundle/stream/policy/remote/
current.rs

1//! Pre-effect recheck and explicit revoke/retire. No wrap/send/plaintext consumer.
2use super::grant::RemoteDisclosureGrant;
3use super::{ControllerRecognition, DisclosureAction, PolicyError as E};
4use crate::crypto::network::authority::{AuthorityReceipt, PinAuthority};
5use crate::net::qdnf::authority::{AuthorityOwner, CurrentAuthorityGuard};
6use crate::net::qdnf::errors::QdnfError;
7use std::sync::{Mutex, TryLockError};
8
9impl RemoteDisclosureGrant<'_> {
10    /// Recheck immediately before wrap/send/plaintext (those callers are R3/B2).
11    pub fn recheck(
12        &self,
13        guard: &CurrentAuthorityGuard<'_>,
14        owner: &Mutex<AuthorityOwner>,
15        pins: &PinAuthority,
16        recognition: &ControllerRecognition,
17        receipt: &AuthorityReceipt,
18        now: u64,
19        expected_action: DisclosureAction,
20    ) -> Result<(), E> {
21        if self.closed || self.revoked {
22            return Err(E::Authority(QdnfError::Revoked));
23        }
24        if !core::ptr::eq(self.owner, owner) {
25            return Err(E::Authority(QdnfError::Unauthorized));
26        }
27        guard
28            .check_affinity(owner)
29            .and_then(|_| guard.check_handle(owner, self.handle, self.binding, now, self.ceiling))
30            .map_err(E::Authority)?;
31        let descriptor = receipt.descriptor_digest();
32        if descriptor != &self.descriptor_a && descriptor != &self.descriptor_ticket {
33            return Err(E::Reference);
34        }
35        pins.recheck(receipt, descriptor, now).map_err(E::Crypto)?;
36        pins.recheck(&self.receipt_a, &self.descriptor_a, now)
37            .map_err(E::Crypto)?;
38        pins.recheck(&self.receipt_ticket, &self.descriptor_ticket, now)
39            .map_err(E::Crypto)?;
40        if now >= self.decision.expires() {
41            return Err(E::Crypto(
42                crate::crypto::network::errors::CryptoError::Expired,
43            ));
44        }
45        if self.decision.action() != expected_action {
46            return Err(E::Reference);
47        }
48        let live = recognition.recognize(
49            self.recognized.principal(),
50            self.recognized.source(),
51            self.recognized.source_length(),
52            self.recognized.policy(),
53            self.recognized.publisher(),
54            self.recognized.purpose(),
55            self.recognized.operation(),
56            expected_action,
57            now,
58        )?;
59        if live.pin() != self.recognized.pin()
60            || live.controller_generation() != self.recognized.controller_generation()
61        {
62            return Err(E::Authority(QdnfError::StaleGeneration));
63        }
64        Ok(())
65    }
66
67    /// Revoke under the caller's current guard. Retire is a separate step because
68    /// `CurrentAuthorityGuard` does not expose `AuthorityOwner::retire_revoked`.
69    pub fn revoke_current(
70        &mut self,
71        guard: &mut CurrentAuthorityGuard<'_>,
72        owner: &Mutex<AuthorityOwner>,
73    ) -> Result<(), E> {
74        if !core::ptr::eq(self.owner, owner) {
75            return Err(E::Authority(QdnfError::Unauthorized));
76        }
77        guard
78            .revoke_handle(owner, self.handle)
79            .map_err(E::Authority)?;
80        self.revoked = true;
81        Ok(())
82    }
83
84    /// Reclaim the revoked slot. Caller must not hold `CurrentAuthorityGuard`.
85    pub fn retire_current(&mut self, owner: &Mutex<AuthorityOwner>) -> Result<(), E> {
86        if !core::ptr::eq(self.owner, owner) {
87            return Err(E::Authority(QdnfError::Unauthorized));
88        }
89        if !self.revoked {
90            return Err(E::Authority(QdnfError::Denied));
91        }
92        if self.closed {
93            return Ok(());
94        }
95        let mut inner = owner.try_lock().map_err(|e| match e {
96            TryLockError::WouldBlock => E::Authority(QdnfError::WouldBlock),
97            TryLockError::Poisoned(_) => E::Authority(QdnfError::Unauthorized),
98        })?;
99        inner.retire_revoked(self.handle).map_err(E::Authority)?;
100        self.closed = true;
101        Ok(())
102    }
103
104    /// Revoke then retire when the mutex is free. Used by tests and Drop.
105    pub fn close_now(&mut self, owner: &Mutex<AuthorityOwner>) -> Result<(), E> {
106        {
107            let mut guard = CurrentAuthorityGuard::try_lock(owner).map_err(E::Authority)?;
108            self.revoke_current(&mut guard, owner)?;
109        }
110        self.retire_current(owner)
111    }
112}
113
114impl Drop for RemoteDisclosureGrant<'_> {
115    fn drop(&mut self) {
116        if self.closed {
117            return;
118        }
119        // Without the lock, leave the slot occupied. Do not mutate unlocked.
120        match CurrentAuthorityGuard::try_lock(self.owner) {
121            Ok(mut guard) => {
122                let _ = self.revoke_current(&mut guard, self.owner);
123                drop(guard);
124                let _ = self.retire_current(self.owner);
125            }
126            Err(_) => {}
127        }
128    }
129}