aboutsummaryrefslogtreecommitdiffstats
path: root/src/wireguard/types
diff options
context:
space:
mode:
Diffstat (limited to 'src/wireguard/types')
-rw-r--r--src/wireguard/types/bind.rs23
-rw-r--r--src/wireguard/types/dummy.rs323
-rw-r--r--src/wireguard/types/endpoint.rs7
-rw-r--r--src/wireguard/types/keys.rs36
-rw-r--r--src/wireguard/types/mod.rs10
-rw-r--r--src/wireguard/types/tun.rs56
6 files changed, 455 insertions, 0 deletions
diff --git a/src/wireguard/types/bind.rs b/src/wireguard/types/bind.rs
new file mode 100644
index 0000000..3d3f187
--- /dev/null
+++ b/src/wireguard/types/bind.rs
@@ -0,0 +1,23 @@
+use super::Endpoint;
+use std::error::Error;
+
+pub trait Reader<E: Endpoint>: Send + Sync {
+ type Error: Error;
+
+ fn read(&self, buf: &mut [u8]) -> Result<(usize, E), Self::Error>;
+}
+
+pub trait Writer<E: Endpoint>: Send + Sync + Clone + 'static {
+ type Error: Error;
+
+ fn write(&self, buf: &[u8], dst: &E) -> Result<(), Self::Error>;
+}
+
+pub trait Bind: Send + Sync + 'static {
+ type Error: Error;
+ type Endpoint: Endpoint;
+
+ /* Until Rust gets type equality constraints these have to be generic */
+ type Writer: Writer<Self::Endpoint>;
+ type Reader: Reader<Self::Endpoint>;
+}
diff --git a/src/wireguard/types/dummy.rs b/src/wireguard/types/dummy.rs
new file mode 100644
index 0000000..2403c9b
--- /dev/null
+++ b/src/wireguard/types/dummy.rs
@@ -0,0 +1,323 @@
+use std::error::Error;
+use std::fmt;
+use std::marker;
+use std::net::SocketAddr;
+use std::sync::mpsc::{sync_channel, Receiver, SyncSender};
+use std::sync::Arc;
+use std::sync::Mutex;
+use std::time::Instant;
+use std::sync::atomic::{Ordering, AtomicUsize};
+
+use super::*;
+
+/* This submodule provides pure/dummy implementations of the IO interfaces
+ * for use in unit tests thoughout the project.
+ */
+
+/* Error implementation */
+
+#[derive(Debug)]
+pub enum BindError {
+ Disconnected,
+}
+
+impl Error for BindError {
+ fn description(&self) -> &str {
+ "Generic Bind Error"
+ }
+
+ fn source(&self) -> Option<&(dyn Error + 'static)> {
+ None
+ }
+}
+
+impl fmt::Display for BindError {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match self {
+ BindError::Disconnected => write!(f, "PairBind disconnected"),
+ }
+ }
+}
+
+/* TUN implementation */
+
+#[derive(Debug)]
+pub enum TunError {
+ Disconnected
+}
+
+impl Error for TunError {
+ fn description(&self) -> &str {
+ "Generic Tun Error"
+ }
+
+ fn source(&self) -> Option<&(dyn Error + 'static)> {
+ None
+ }
+}
+
+impl fmt::Display for TunError {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "Not Possible")
+ }
+}
+
+/* Endpoint implementation */
+
+#[derive(Clone, Copy)]
+pub struct UnitEndpoint {}
+
+impl Endpoint for UnitEndpoint {
+ fn from_address(_: SocketAddr) -> UnitEndpoint {
+ UnitEndpoint {}
+ }
+
+ fn into_address(&self) -> SocketAddr {
+ "127.0.0.1:8080".parse().unwrap()
+ }
+
+ fn clear_src(&self) {}
+}
+
+impl UnitEndpoint {
+ pub fn new() -> UnitEndpoint {
+ UnitEndpoint {}
+ }
+}
+
+/* */
+
+pub struct TunTest {}
+
+pub struct TunFakeIO {
+ store: bool,
+ tx: SyncSender<Vec<u8>>,
+ rx: Receiver<Vec<u8>>
+}
+
+pub struct TunReader {
+ rx: Receiver<Vec<u8>>
+}
+
+pub struct TunWriter {
+ store: bool,
+ tx: Mutex<SyncSender<Vec<u8>>>
+}
+
+#[derive(Clone)]
+pub struct TunMTU {
+ mtu: Arc<AtomicUsize>
+}
+
+impl tun::Reader for TunReader {
+ type Error = TunError;
+
+ fn read(&self, buf: &mut [u8], offset: usize) -> Result<usize, Self::Error> {
+ match self.rx.recv() {
+ Ok(m) => {
+ buf[offset..].copy_from_slice(&m[..]);
+ Ok(m.len())
+ }
+ Err(_) => Err(TunError::Disconnected)
+ }
+ }
+}
+
+impl tun::Writer for TunWriter {
+ type Error = TunError;
+
+ fn write(&self, src: &[u8]) -> Result<(), Self::Error> {
+ if self.store {
+ let m = src.to_owned();
+ match self.tx.lock().unwrap().send(m) {
+ Ok(_) => Ok(()),
+ Err(_) => Err(TunError::Disconnected)
+ }
+ } else {
+ Ok(())
+ }
+ }
+}
+
+impl tun::MTU for TunMTU {
+ fn mtu(&self) -> usize {
+ self.mtu.load(Ordering::Acquire)
+ }
+}
+
+impl tun::Tun for TunTest {
+ type Writer = TunWriter;
+ type Reader = TunReader;
+ type MTU = TunMTU;
+ type Error = TunError;
+}
+
+impl TunFakeIO {
+ pub fn write(&self, msg : Vec<u8>) {
+ if self.store {
+ self.tx.send(msg).unwrap();
+ }
+ }
+
+ pub fn read(&self) -> Vec<u8> {
+ self.rx.recv().unwrap()
+ }
+}
+
+impl TunTest {
+ pub fn create(mtu : usize, store: bool) -> (TunFakeIO, TunReader, TunWriter, TunMTU) {
+
+ let (tx1, rx1) = if store { sync_channel(32) } else { sync_channel(1) };
+ let (tx2, rx2) = if store { sync_channel(32) } else { sync_channel(1) };
+
+ let fake = TunFakeIO{tx: tx1, rx: rx2, store};
+ let reader = TunReader{rx : rx1};
+ let writer = TunWriter{tx : Mutex::new(tx2), store};
+ let mtu = TunMTU{mtu : Arc::new(AtomicUsize::new(mtu))};
+
+ (fake, reader, writer, mtu)
+ }
+}
+
+/* Void Bind */
+
+#[derive(Clone, Copy)]
+pub struct VoidBind {}
+
+impl bind::Reader<UnitEndpoint> for VoidBind {
+ type Error = BindError;
+
+ fn read(&self, _buf: &mut [u8]) -> Result<(usize, UnitEndpoint), Self::Error> {
+ Ok((0, UnitEndpoint {}))
+ }
+}
+
+impl bind::Writer<UnitEndpoint> for VoidBind {
+ type Error = BindError;
+
+ fn write(&self, _buf: &[u8], _dst: &UnitEndpoint) -> Result<(), Self::Error> {
+ Ok(())
+ }
+}
+
+impl bind::Bind for VoidBind {
+ type Error = BindError;
+ type Endpoint = UnitEndpoint;
+
+ type Reader = VoidBind;
+ type Writer = VoidBind;
+}
+
+impl VoidBind {
+ pub fn new() -> VoidBind {
+ VoidBind {}
+ }
+}
+
+/* Pair Bind */
+
+#[derive(Clone)]
+pub struct PairReader<E> {
+ recv: Arc<Mutex<Receiver<Vec<u8>>>>,
+ _marker: marker::PhantomData<E>,
+}
+
+impl bind::Reader<UnitEndpoint> for PairReader<UnitEndpoint> {
+ type Error = BindError;
+ fn read(&self, buf: &mut [u8]) -> Result<(usize, UnitEndpoint), Self::Error> {
+ let vec = self
+ .recv
+ .lock()
+ .unwrap()
+ .recv()
+ .map_err(|_| BindError::Disconnected)?;
+ let len = vec.len();
+ buf[..len].copy_from_slice(&vec[..]);
+ Ok((vec.len(), UnitEndpoint {}))
+ }
+}
+
+impl bind::Writer<UnitEndpoint> for PairWriter<UnitEndpoint> {
+ type Error = BindError;
+ fn write(&self, buf: &[u8], _dst: &UnitEndpoint) -> Result<(), Self::Error> {
+ let owned = buf.to_owned();
+ match self.send.lock().unwrap().send(owned) {
+ Err(_) => Err(BindError::Disconnected),
+ Ok(_) => Ok(()),
+ }
+ }
+}
+
+#[derive(Clone)]
+pub struct PairWriter<E> {
+ send: Arc<Mutex<SyncSender<Vec<u8>>>>,
+ _marker: marker::PhantomData<E>,
+}
+
+#[derive(Clone)]
+pub struct PairBind {}
+
+impl PairBind {
+ pub fn pair<E>() -> (
+ (PairReader<E>, PairWriter<E>),
+ (PairReader<E>, PairWriter<E>),
+ ) {
+ let (tx1, rx1) = sync_channel(128);
+ let (tx2, rx2) = sync_channel(128);
+ (
+ (
+ PairReader {
+ recv: Arc::new(Mutex::new(rx1)),
+ _marker: marker::PhantomData,
+ },
+ PairWriter {
+ send: Arc::new(Mutex::new(tx2)),
+ _marker: marker::PhantomData,
+ },
+ ),
+ (
+ PairReader {
+ recv: Arc::new(Mutex::new(rx2)),
+ _marker: marker::PhantomData,
+ },
+ PairWriter {
+ send: Arc::new(Mutex::new(tx1)),
+ _marker: marker::PhantomData,
+ },
+ ),
+ )
+ }
+}
+
+impl bind::Bind for PairBind {
+ type Error = BindError;
+ type Endpoint = UnitEndpoint;
+ type Reader = PairReader<Self::Endpoint>;
+ type Writer = PairWriter<Self::Endpoint>;
+}
+
+pub fn keypair(initiator: bool) -> KeyPair {
+ let k1 = Key {
+ key: [0x53u8; 32],
+ id: 0x646e6573,
+ };
+ let k2 = Key {
+ key: [0x52u8; 32],
+ id: 0x76636572,
+ };
+ if initiator {
+ KeyPair {
+ birth: Instant::now(),
+ initiator: true,
+ send: k1,
+ recv: k2,
+ }
+ } else {
+ KeyPair {
+ birth: Instant::now(),
+ initiator: false,
+ send: k2,
+ recv: k1,
+ }
+ }
+}
diff --git a/src/wireguard/types/endpoint.rs b/src/wireguard/types/endpoint.rs
new file mode 100644
index 0000000..f4f93da
--- /dev/null
+++ b/src/wireguard/types/endpoint.rs
@@ -0,0 +1,7 @@
+use std::net::SocketAddr;
+
+pub trait Endpoint: Send + 'static {
+ fn from_address(addr: SocketAddr) -> Self;
+ fn into_address(&self) -> SocketAddr;
+ fn clear_src(&self);
+}
diff --git a/src/wireguard/types/keys.rs b/src/wireguard/types/keys.rs
new file mode 100644
index 0000000..282c4ae
--- /dev/null
+++ b/src/wireguard/types/keys.rs
@@ -0,0 +1,36 @@
+use clear_on_drop::clear::Clear;
+use std::time::Instant;
+
+#[derive(Debug, Clone)]
+pub struct Key {
+ pub key: [u8; 32],
+ pub id: u32,
+}
+
+// zero key on drop
+impl Drop for Key {
+ fn drop(&mut self) {
+ self.key.clear()
+ }
+}
+
+#[cfg(test)]
+impl PartialEq for Key {
+ fn eq(&self, other: &Self) -> bool {
+ self.id == other.id && self.key[..] == other.key[..]
+ }
+}
+
+#[derive(Debug, Clone)]
+pub struct KeyPair {
+ pub birth: Instant, // when was the key-pair created
+ pub initiator: bool, // has the key-pair been confirmed?
+ pub send: Key, // key for outbound messages
+ pub recv: Key, // key for inbound messages
+}
+
+impl KeyPair {
+ pub fn local_id(&self) -> u32 {
+ self.recv.id
+ }
+}
diff --git a/src/wireguard/types/mod.rs b/src/wireguard/types/mod.rs
new file mode 100644
index 0000000..e0725f3
--- /dev/null
+++ b/src/wireguard/types/mod.rs
@@ -0,0 +1,10 @@
+mod endpoint;
+mod keys;
+pub mod tun;
+pub mod bind;
+
+#[cfg(test)]
+pub mod dummy;
+
+pub use endpoint::Endpoint;
+pub use keys::{Key, KeyPair}; \ No newline at end of file
diff --git a/src/wireguard/types/tun.rs b/src/wireguard/types/tun.rs
new file mode 100644
index 0000000..2ba16ff
--- /dev/null
+++ b/src/wireguard/types/tun.rs
@@ -0,0 +1,56 @@
+use std::error::Error;
+
+pub trait Writer: Send + Sync + 'static {
+ type Error: Error;
+
+ /// Receive a cryptkey routed IP packet
+ ///
+ /// # Arguments
+ ///
+ /// - src: Buffer containing the IP packet to be written
+ ///
+ /// # Returns
+ ///
+ /// Unit type or an error
+ fn write(&self, src: &[u8]) -> Result<(), Self::Error>;
+}
+
+pub trait Reader: Send + 'static {
+ type Error: Error;
+
+ /// Reads an IP packet into dst[offset:] from the tunnel device
+ ///
+ /// The reason for providing space for a prefix
+ /// is to efficiently accommodate platforms on which the packet is prefaced by a header.
+ /// This space is later used to construct the transport message inplace.
+ ///
+ /// # Arguments
+ ///
+ /// - buf: Destination buffer (enough space for MTU bytes + header)
+ /// - offset: Offset for the beginning of the IP packet
+ ///
+ /// # Returns
+ ///
+ /// The size of the IP packet (ignoring the header) or an std::error::Error instance:
+ fn read(&self, buf: &mut [u8], offset: usize) -> Result<usize, Self::Error>;
+}
+
+pub trait MTU: Send + Sync + Clone + 'static {
+ /// Returns the MTU of the device
+ ///
+ /// This function needs to be efficient (called for every read).
+ /// The goto implementation strategy is to .load an atomic variable,
+ /// then use e.g. netlink to update the variable in a separate thread.
+ ///
+ /// # Returns
+ ///
+ /// The MTU of the interface in bytes
+ fn mtu(&self) -> usize;
+}
+
+pub trait Tun: Send + Sync + 'static {
+ type Writer: Writer;
+ type Reader: Reader;
+ type MTU: MTU;
+ type Error: Error;
+}
Copyright © 1996 – 2023 Jason A. Donenfeld. All Rights Reverse Engineered.