Skip to main content

qualia_core_db/p2p/
wg_engine.rs

1//! Socket-free WireGuard engine. Caller supplies output buffers.
2
3#![cfg(not(target_arch = "wasm32"))]
4
5use boringtun::noise::{Tunn, TunnResult};
6use boringtun::x25519::PublicKey;
7
8use super::wireguard_userspace::{new_tunnel, WgKeypair};
9
10#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11pub enum EngineOut {
12    Network { len: usize },
13    InnerV6 { len: usize },
14    Done,
15}
16
17#[derive(Debug, Clone, Copy, PartialEq, Eq)]
18pub enum EngineError {
19    Invalid,
20    Ipv4Inner,
21}
22
23/// Point-to-point `Tunn` with no socket and no per-packet `Vec`.
24pub struct WgEngine {
25    tunn: Tunn,
26}
27
28impl WgEngine {
29    /// Creates a default `WgEngine`.
30    pub fn new(mine: &WgKeypair, peer: PublicKey, index: u32) -> Result<Self, String> {
31        Ok(Self {
32            tunn: new_tunnel(mine, peer, index)?,
33        })
34    }
35
36    /// `true` when `session` present.
37    pub fn has_session(&self) -> bool {
38        self.tunn.time_since_last_handshake().is_some()
39    }
40
41    /// `WgEngine::encapsulate`.
42    pub fn encapsulate(&mut self, inner: &[u8], out: &mut [u8]) -> Result<EngineOut, EngineError> {
43        match self.tunn.encapsulate(inner, out) {
44            TunnResult::WriteToNetwork(p) => Ok(EngineOut::Network { len: p.len() }),
45            TunnResult::Done => Ok(EngineOut::Done),
46            TunnResult::Err(_) => Err(EngineError::Invalid),
47            TunnResult::WriteToTunnelV4(_, _) | TunnResult::WriteToTunnelV6(_, _) => {
48                Err(EngineError::Invalid)
49            }
50        }
51    }
52
53    /// Decapsulates a WireGuard packet.
54    pub fn decapsulate(&mut self, pkt: &[u8], out: &mut [u8]) -> Result<EngineOut, EngineError> {
55        match self.tunn.decapsulate(None, pkt, out) {
56            TunnResult::WriteToNetwork(p) => Ok(EngineOut::Network { len: p.len() }),
57            TunnResult::WriteToTunnelV6(data, _) => Ok(EngineOut::InnerV6 { len: data.len() }),
58            TunnResult::WriteToTunnelV4(_, _) => Err(EngineError::Ipv4Inner),
59            TunnResult::Done => Ok(EngineOut::Done),
60            TunnResult::Err(_) => Err(EngineError::Invalid),
61        }
62    }
63}
64
65#[cfg(test)]
66mod tests {
67    use super::*;
68    use crate::p2p::wireguard_userspace::generate_keypair;
69
70    fn ipv6_hello() -> [u8; 48] {
71        let mut p = [0u8; 48];
72        p[0] = 0x60;
73        p[4..6].copy_from_slice(&8u16.to_be_bytes());
74        p[6] = 17;
75        p[7] = 64;
76        p[8] = 0xfd;
77        p[23] = 1;
78        p[24] = 0xfd;
79        p[39] = 2;
80        p[40..].copy_from_slice(b"engine!!");
81        p
82    }
83
84    #[test]
85    fn handshake_and_inner_v6_caller_buffers() {
86        let a_k = generate_keypair();
87        let b_k = generate_keypair();
88        let mut a = WgEngine::new(&a_k, b_k.public, 1).unwrap();
89        let mut b = WgEngine::new(&b_k, a_k.public, 2).unwrap();
90        let mut buf = [0u8; 2048];
91        let init = match a.encapsulate(&[], &mut buf).unwrap() {
92            EngineOut::Network { len } => {
93                let mut p = [0u8; 2048];
94                p[..len].copy_from_slice(&buf[..len]);
95                (p, len)
96            }
97            other => panic!("{other:?}"),
98        };
99        let mut inflight = init;
100        let mut to_b = true;
101        let mut done = false;
102        for _ in 0..12 {
103            let (pkt, n) = inflight;
104            let recv = if to_b { &mut b } else { &mut a };
105            match recv.decapsulate(&pkt[..n], &mut buf).unwrap() {
106                EngineOut::Network { len } => {
107                    let mut p = [0u8; 2048];
108                    p[..len].copy_from_slice(&buf[..len]);
109                    inflight = (p, len);
110                    to_b = !to_b;
111                }
112                EngineOut::Done | EngineOut::InnerV6 { .. } => {
113                    done = true;
114                    break;
115                }
116            }
117        }
118        assert!(done);
119        let inner = ipv6_hello();
120        let mut got = None;
121        for _ in 0..4 {
122            match a.encapsulate(&inner, &mut buf).unwrap() {
123                EngineOut::Network { len } => {
124                    let mut cipher = [0u8; 2048];
125                    cipher[..len].copy_from_slice(&buf[..len]);
126                    match b.decapsulate(&cipher[..len], &mut buf) {
127                        Ok(EngineOut::InnerV6 { len }) => {
128                            got = Some(buf[..len].to_vec());
129                            break;
130                        }
131                        Ok(EngineOut::Network { len }) => {
132                            let mut r = [0u8; 2048];
133                            r[..len].copy_from_slice(&buf[..len]);
134                            let _ = a.decapsulate(&r[..len], &mut buf);
135                        }
136                        _ => {}
137                    }
138                }
139                EngineOut::Done => {}
140                other => panic!("{other:?}"),
141            }
142        }
143        assert_eq!(got.as_deref(), Some(&inner[..]));
144    }
145}