Skip to main content

qualia_core_db/net/qdnf/route/
realm.rs

1//! E08.5 — inter-realm policy authentication and default-route leak prevention.
2
3use crate::net::qdnf::errors::QdnfError;
4
5/// Authenticate an advertised realm against local membership.
6///
7/// Unsigned inter-realm adverts are [`QdnfError::Unauthorized`]. Intra-realm
8/// adverts do not require `signed_ok`. `advert_realm` is a bit index 0..63.
9pub fn authenticate_realm_policy(
10    advert_realm: u8,
11    local_realms: u64,
12    signed_ok: bool,
13) -> Result<(), QdnfError> {
14    if advert_realm >= 64 {
15        return Err(QdnfError::Range);
16    }
17    let bit = 1u64 << advert_realm;
18    if local_realms & bit != 0 {
19        return Ok(());
20    }
21    if !signed_ok {
22        return Err(QdnfError::Unauthorized);
23    }
24    Ok(())
25}
26
27/// Per-realm default-route install table. Foreign-realm defaults are refused.
28#[repr(C)]
29#[derive(Clone, Copy, Debug, PartialEq, Eq)]
30pub struct RealmRouteTable {
31    defaults: [bool; 64],
32}
33
34impl RealmRouteTable {
35    /// Creates a default `RealmRouteTable`.
36    pub const fn new() -> Self {
37        Self {
38            defaults: [false; 64],
39        }
40    }
41
42    /// True if any realm currently has an installed default.
43    pub fn has_default_route(&self) -> bool {
44        let mut i = 0usize;
45        while i < 64 {
46            if self.defaults[i] {
47                return true;
48            }
49            i += 1;
50        }
51        false
52    }
53
54    /// `true` when `default_in` present.
55    pub fn has_default_in(&self, realm: u8) -> bool {
56        if realm >= 64 {
57            return false;
58        }
59        self.defaults[realm as usize]
60    }
61
62    /// Install a default only when `advert_realm == into_realm`.
63    ///
64    /// A route originated in realm A is never a default in realm B; `has_default_route`
65    /// stays false after that attempt.
66    pub fn install_default(
67        &mut self,
68        advert_realm: u8,
69        into_realm: u8,
70        signed_ok: bool,
71    ) -> Result<(), QdnfError> {
72        if into_realm >= 64 {
73            return Err(QdnfError::Range);
74        }
75        let local = 1u64 << into_realm;
76        authenticate_realm_policy(advert_realm, local, signed_ok)?;
77        if advert_realm != into_realm {
78            return Err(QdnfError::Denied);
79        }
80        self.defaults[into_realm as usize] = true;
81        Ok(())
82    }
83}
84
85#[cfg(test)]
86mod tests {
87    use super::*;
88
89    #[test]
90    fn unsigned_inter_realm_advert_unauthorized() {
91        let local_b = 1u64 << 1;
92        assert_eq!(
93            authenticate_realm_policy(0, local_b, false),
94            Err(QdnfError::Unauthorized)
95        );
96        assert!(authenticate_realm_policy(0, local_b, true).is_ok());
97        assert!(authenticate_realm_policy(1, local_b, false).is_ok());
98    }
99
100    #[test]
101    fn signed_inter_realm_does_not_install_default_into_other_realm() {
102        let mut table = RealmRouteTable::new();
103        assert!(authenticate_realm_policy(0, 1u64 << 1, true).is_ok());
104        assert_eq!(table.install_default(0, 1, true), Err(QdnfError::Denied));
105        assert!(!table.has_default_route());
106        assert!(!table.has_default_in(1));
107        table.install_default(1, 1, false).unwrap();
108        assert!(table.has_default_route());
109        assert!(table.has_default_in(1));
110        assert!(!table.has_default_in(0));
111    }
112
113    #[test]
114    fn advert_realm_out_of_range() {
115        assert_eq!(
116            authenticate_realm_policy(64, u64::MAX, true),
117            Err(QdnfError::Range)
118        );
119    }
120}