Skip to main content

qualia_core_db/net/peer/fabric/
outcome.rs

1//! ConnectAccept / ConnectReject from kernel + local evidence.
2
3use super::carrier::prohibited;
4use super::evidence::PathEvidence;
5use super::kernel::{FabricError, FabricState, Kernel};
6use super::wire::{decode_accept, encode_accept, encode_reject, RejectReason};
7
8/// Maps a `FabricError` to a `RejectReason`.
9pub fn reject_reason(err: FabricError) -> RejectReason {
10    match err {
11        FabricError::StaleDescriptor => RejectReason::Stale,
12        FabricError::Expired => RejectReason::Expired,
13        FabricError::GrantRevoked => RejectReason::Revoked,
14        FabricError::Capacity => RejectReason::Capacity,
15        _ => RejectReason::Policy,
16    }
17}
18
19/// Accept only a locally validated, permitted path while the kernel is PathLive or SessionLive.
20pub fn encode_outcome(
21    kernel: &Kernel,
22    evidence: PathEvidence,
23    out: &mut [u8],
24) -> Result<usize, FabricError> {
25    let intent = kernel.intent().ok_or(FabricError::Illegal)?;
26    if !kernel.grant_live {
27        return encode_reject(RejectReason::Revoked, out).map_err(FabricError::from);
28    }
29    if prohibited(intent.protection.disclosure, evidence.class) || !evidence.validated() {
30        return encode_reject(RejectReason::Policy, out).map_err(FabricError::from);
31    }
32    match kernel.state {
33        FabricState::PathLive | FabricState::SessionLive => {
34            encode_accept(evidence.class, kernel.generation, out).map_err(FabricError::from)
35        }
36        _ => encode_reject(RejectReason::Policy, out).map_err(FabricError::from),
37    }
38}
39
40/// Decodes `outcome_accept`; fails closed on malformed input.
41pub fn decode_outcome_accept(
42    bytes: &[u8],
43) -> Result<(super::carrier::PathClass, u32), FabricError> {
44    decode_accept(bytes).map_err(FabricError::from)
45}
46
47#[cfg(test)]
48mod tests {
49    use super::*;
50    use crate::net::peer::fabric::carrier::PathClass;
51    use crate::net::peer::fabric::evidence::TransportWitness;
52    use crate::net::peer::fabric::intent::{ConnectionIntent, ProtectionPolicy, Purpose};
53    use crate::net::peer::fabric::kernel::{Kernel, KernelEvent};
54    use crate::net::peer::runtime::ResourceBudget;
55
56    #[test]
57    fn remote_or_direct_under_relay_only_rejects() {
58        let mut k = Kernel::new();
59        k.admit(
60            ConnectionIntent::new(
61                [1u8; 32],
62                Purpose::ordinary(),
63                ProtectionPolicy::RELAY_ONLY,
64                ResourceBudget {
65                    bytes: 64,
66                    work: 1,
67                    io: 1,
68                },
69                0,
70                1000,
71            ),
72            0,
73        )
74        .unwrap();
75        k.step(
76            KernelEvent::Descriptor {
77                stale: false,
78                expired: false,
79                direct_locator: false,
80            },
81            1,
82        );
83        k.step(KernelEvent::LeaseLive, 1);
84        k.step(
85            KernelEvent::PathValidated {
86                class: PathClass::Relayed,
87            },
88            1,
89        );
90        let local = PathEvidence::from_witness(TransportWitness::from_local(
91            PathClass::Relayed,
92            1,
93            64,
94            5,
95            1,
96        ));
97        let mut buf = [0u8; 64];
98        let n = encode_outcome(&k, local, &mut buf).unwrap();
99        assert_eq!(
100            decode_outcome_accept(&buf[..n]).unwrap().0,
101            PathClass::Relayed
102        );
103        let remote = PathEvidence::remote_assertion(PathClass::Relayed, 1, 1);
104        let n = encode_outcome(&k, remote, &mut buf).unwrap();
105        assert!(decode_outcome_accept(&buf[..n]).is_err());
106        let direct = PathEvidence::from_witness(TransportWitness::from_local(
107            PathClass::DirectV6,
108            1,
109            64,
110            1,
111            1,
112        ));
113        let n = encode_outcome(&k, direct, &mut buf).unwrap();
114        assert!(decode_outcome_accept(&buf[..n]).is_err());
115    }
116}