qualia_core_db/p2p/
wg_engine.rs1#![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
23pub struct WgEngine {
25 tunn: Tunn,
26}
27
28impl WgEngine {
29 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 pub fn has_session(&self) -> bool {
38 self.tunn.time_since_last_handshake().is_some()
39 }
40
41 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 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}