From 8107973342a31e8d654d31c1bb06786fc033d86c Mon Sep 17 00:00:00 2001 From: Mathias Hall-Andersen Date: Wed, 23 Oct 2019 14:00:21 +0200 Subject: Work on pure WireGuard test --- src/wireguard/tests.rs | 71 ++++++++++++++++++++++++++++++++++++-- src/wireguard/wireguard.rs | 86 +++++++++++++++++++++++++--------------------- 2 files changed, 116 insertions(+), 41 deletions(-) (limited to 'src/wireguard') diff --git a/src/wireguard/tests.rs b/src/wireguard/tests.rs index 4ecd43b..0dc9296 100644 --- a/src/wireguard/tests.rs +++ b/src/wireguard/tests.rs @@ -1,13 +1,53 @@ use super::wireguard::Wireguard; use super::{bind, dummy, tun}; +use std::net::IpAddr; use std::thread; use std::time::Duration; +use rand::rngs::OsRng; +use x25519_dalek::{PublicKey, StaticSecret}; + +use pnet::packet::ipv4::MutableIpv4Packet; +use pnet::packet::ipv6::MutableIpv6Packet; + +fn make_packet(size: usize, src: IpAddr, dst: IpAddr) -> Vec { + // create "IP packet" + let mut msg = Vec::with_capacity(size); + msg.resize(size, 0); + match dst { + IpAddr::V4(dst) => { + let mut packet = MutableIpv4Packet::new(&mut msg[..]).unwrap(); + packet.set_destination(dst); + packet.set_source(if let IpAddr::V4(src) = src { + src + } else { + panic!("src.version != dst.version") + }); + packet.set_version(4); + } + IpAddr::V6(dst) => { + let mut packet = MutableIpv6Packet::new(&mut msg[..]).unwrap(); + packet.set_destination(dst); + packet.set_source(if let IpAddr::V6(src) = src { + src + } else { + panic!("src.version != dst.version") + }); + packet.set_version(6); + } + } + msg +} + fn init() { let _ = env_logger::builder().is_test(true).try_init(); } +fn wait() { + thread::sleep(Duration::from_millis(500)); +} + /* Create and configure two matching pure instances of WireGuard * */ @@ -37,9 +77,36 @@ fn test_pure_wireguard() { // generate (public, pivate) key pairs + let mut rng = OsRng::new().unwrap(); + let sk1 = StaticSecret::new(&mut rng); + let sk2 = StaticSecret::new(&mut rng); + let pk1 = PublicKey::from(&sk1); + let pk2 = PublicKey::from(&sk2); + + wg1.new_peer(pk2); + wg2.new_peer(pk1); + + wg1.set_key(Some(sk1)); + wg2.set_key(Some(sk2)); + // configure cryptkey router - // create IP packets + let peer2 = wg1.lookup_peer(&pk2).unwrap(); + let peer1 = wg2.lookup_peer(&pk1).unwrap(); - thread::sleep(Duration::from_millis(500)); + peer1.router.add_subnet("192.168.2.0".parse().unwrap(), 24); + peer2.router.add_subnet("192.168.1.0".parse().unwrap(), 24); + + // set endpoints + + peer1.router.set_endpoint(dummy::UnitEndpoint::new()); + peer2.router.set_endpoint(dummy::UnitEndpoint::new()); + + // create IP packets (causing a new handshake) + + let packet_p1_to_p2 = make_packet( + 1000, + "192.168.2.20".parse().unwrap(), // src + "192.168.1.10".parse().unwrap(), // dst + ); } diff --git a/src/wireguard/wireguard.rs b/src/wireguard/wireguard.rs index 96a134c..25544d9 100644 --- a/src/wireguard/wireguard.rs +++ b/src/wireguard/wireguard.rs @@ -36,15 +36,6 @@ pub struct Peer { pub state: Arc>, } -impl Clone for Peer { - fn clone(&self) -> Peer { - Peer { - router: self.router.clone(), - state: self.state.clone(), - } - } -} - pub struct PeerInner { pub keepalive: AtomicUsize, // keepalive interval pub rx_bytes: AtomicU64, @@ -58,6 +49,44 @@ pub struct PeerInner { pub timers: RwLock, // } +pub struct WireguardInner { + // provides access to the MTU value of the tun device + // (otherwise owned solely by the router and a dedicated read IO thread) + mtu: T::MTU, + send: RwLock>, + + // identify and configuration map + peers: RwLock>>, + + // cryptkey router + router: router::Device, T::Writer, B::Writer>, + + // handshake related state + handshake: RwLock, + under_load: AtomicBool, + pending: AtomicUsize, // num of pending handshake packets in queue + queue: Mutex>>, +} + +pub enum HandshakeJob { + Message(Vec, E), + New(PublicKey), +} + +#[derive(Clone)] +pub struct WireguardHandle { + inner: Arc>, +} + +impl Clone for Peer { + fn clone(&self) -> Peer { + Peer { + router: self.router.clone(), + state: self.state.clone(), + } + } +} + impl PeerInner { #[inline(always)] pub fn timers(&self) -> RwLockReadGuard { @@ -94,35 +123,6 @@ struct Handshake { active: bool, } -pub enum HandshakeJob { - Message(Vec, E), - New(PublicKey), -} - -pub struct WireguardInner { - // provides access to the MTU value of the tun device - // (otherwise owned solely by the router and a dedicated read IO thread) - mtu: T::MTU, - send: RwLock>, - - // identify and configuration map - peers: RwLock>>, - - // cryptkey router - router: router::Device, T::Writer, B::Writer>, - - // handshake related state - handshake: RwLock, - under_load: AtomicBool, - pending: AtomicUsize, // num of pending handshake packets in queue - queue: Mutex>>, -} - -#[derive(Clone)] -pub struct WireguardHandle { - inner: Arc>, -} - impl Deref for WireguardHandle { type Target = Arc>; fn deref(&self) -> &Self::Target { @@ -162,10 +162,18 @@ impl Wireguard { self.state.peers.write().clear(); } - pub fn remove_peer(&self, pk: PublicKey) { + pub fn remove_peer(&self, pk: &PublicKey) { self.state.peers.write().remove(pk.as_bytes()); } + pub fn lookup_peer(&self, pk: &PublicKey) -> Option> { + self.state + .peers + .read() + .get(pk.as_bytes()) + .map(|p| p.clone()) + } + pub fn list_peers(&self) -> Vec> { let peers = self.state.peers.read(); let mut list = Vec::with_capacity(peers.len()); -- cgit v1.2.3-59-g8ed1b