qualia_core_db/bundle/stream/policy/remote/
current.rs1use 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 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 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 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 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 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}