mirrors/krata
1
0
Fork 0
mirror of https://github.com/edera-dev/krata.git synced 2025-09-17 10:21:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

network: successfully implement NAT support for UDP. timeouts are not yet implemented.

Browse Source
This commit is contained in:
Alex Zenla
2024-02-10 12:00:15 +00:00
parent 360506bbdd
commit d2f86afb7c
3 changed files with 109 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
network/src/backend.rs
View File

@ -109,11 +109,11 @@ impl NetworkBackend {
.map_err(|_| anyhow!("failed to parse cidr: {}", self.network))?; .map_err(|_| anyhow!("failed to parse cidr: {}", self.network))?;
let addresses: Vec<IpCidr> = vec![address]; let addresses: Vec<IpCidr> = vec![address];
let kdev = AsyncRawSocket::bind(&self.interface)?; let kdev = AsyncRawSocket::bind(&self.interface)?;
let (sender, receiver) = channel::<Vec<u8>>(4); let (tx_sender, tx_receiver) = channel::<Vec<u8>>(4);
let mut udev = ChannelDevice::new(1500, sender); let mut udev = ChannelDevice::new(1500, tx_sender.clone());
let mac = MacAddr6::random(); let mac = MacAddr6::random();
let mac = smoltcp::wire::EthernetAddress(mac.to_array()); let mac = smoltcp::wire::EthernetAddress(mac.to_array());
let nat = NatRouter::new(proxy, mac); let nat = NatRouter::new(proxy, mac, tx_sender.clone());
let mac = HardwareAddress::Ethernet(mac); let mac = HardwareAddress::Ethernet(mac);
let config = Config::new(mac); let config = Config::new(mac);
let mut iface = Interface::new(config, &mut udev, Instant::now()); let mut iface = Interface::new(config, &mut udev, Instant::now());
@ -124,7 +124,7 @@ impl NetworkBackend {
}); });
let sockets = SocketSet::new(vec![]); let sockets = SocketSet::new(vec![]);
Ok(NetworkStack { Ok(NetworkStack {
tx: receiver, tx: tx_receiver,
kdev, kdev,
udev, udev,
interface: iface, interface: iface,

97
network/src/nat.rs
View File

@ -3,6 +3,7 @@
use anyhow::Result; use anyhow::Result;
use async_trait::async_trait; use async_trait::async_trait;
use etherparse::Ethernet2Slice;
use etherparse::IpNumber; use etherparse::IpNumber;
use etherparse::IpPayloadSlice; use etherparse::IpPayloadSlice;
use etherparse::Ipv4Slice; use etherparse::Ipv4Slice;
@ -17,32 +18,31 @@ use smoltcp::wire::IpEndpoint;
use std::collections::hash_map::Entry; use std::collections::hash_map::Entry;
use std::collections::HashMap; use std::collections::HashMap;
use std::fmt::Display; use std::fmt::Display;
use tokio::sync::mpsc::Sender;
#[derive(Debug, Copy, Clone, Eq, PartialEq, PartialOrd, Ord, Hash)] #[derive(Debug, Copy, Clone, Eq, PartialEq, PartialOrd, Ord, Hash)]
pub enum NatKey { pub enum NatKeyProtocol {
Tcp { Tcp,
client: IpEndpoint, Udp,
external: IpEndpoint, Ping,
}, }
Udp { #[derive(Debug, Copy, Clone, Eq, PartialEq, PartialOrd, Ord, Hash)]
client: IpEndpoint, pub struct NatKey {
external: IpEndpoint, pub protocol: NatKeyProtocol,
}, pub client_mac: EthernetAddress,
pub local_mac: EthernetAddress,
Ping { pub client_ip: IpEndpoint,
client: IpAddress, pub external_ip: IpEndpoint,
external: IpAddress,
},
} }
impl Display for NatKey { impl Display for NatKey {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self { write!(
NatKey::Tcp { client, external } => write!(f, "TCP {client} -> {external}"), f,
NatKey::Udp { client, external } => write!(f, "UDP {client} -> {external}"), "{} -> {} {:?} {} -> {}",
NatKey::Ping { client, external } => write!(f, "Ping {client} -> {external}"), self.client_mac, self.local_mac, self.protocol, self.client_ip, self.external_ip
} )
} }
} }
@ -51,6 +51,11 @@ pub trait NatHandler: Send {
async fn receive(&self, packet: &[u8]) -> Result<()>; async fn receive(&self, packet: &[u8]) -> Result<()>;
} }
#[async_trait]
pub trait NatHandlerFactory: Send {
async fn nat(&self, key: NatKey, sender: Sender<Vec<u8>>) -> Option<Box<dyn NatHandler>>;
}
pub struct NatTable { pub struct NatTable {
inner: HashMap<NatKey, Box<dyn NatHandler>>, inner: HashMap<NatKey, Box<dyn NatHandler>>,
} }
@ -63,23 +68,24 @@ impl NatTable {
} }
} }
#[async_trait]
pub trait NatHandlerFactory: Send {
async fn nat(&self, key: NatKey) -> Option<Box<dyn NatHandler>>;
}
pub struct NatRouter { pub struct NatRouter {
_mac: EthernetAddress, _local_mac: EthernetAddress,
factory: Box<dyn NatHandlerFactory>, factory: Box<dyn NatHandlerFactory>,
table: NatTable, table: NatTable,
tx_sender: Sender<Vec<u8>>,
} }
impl NatRouter { impl NatRouter {
pub fn new(factory: Box<dyn NatHandlerFactory>, mac: EthernetAddress) -> Self { pub fn new(
factory: Box<dyn NatHandlerFactory>,
mac: EthernetAddress,
tx_sender: Sender<Vec<u8>>,
) -> Self {
Self { Self {
_mac: mac, _local_mac: mac,
factory, factory,
table: NatTable::new(), table: NatTable::new(),
tx_sender,
} }
} }
@ -101,8 +107,9 @@ impl NatRouter {
match net { match net {
NetSlice::Ipv4(ipv4) => { NetSlice::Ipv4(ipv4) => {
self.process_ipv4(data, ipv4).await?; self.process_ipv4(data, ether, ipv4).await?;
} }
_ => { _ => {
return Ok(()); return Ok(());
} }
@ -111,18 +118,22 @@ impl NatRouter {
Ok(()) Ok(())
} }
pub async fn process_ipv4<'a>(&mut self, data: &[u8], ipv4: &Ipv4Slice<'a>) -> Result<()> { pub async fn process_ipv4<'a>(
&mut self,
data: &[u8],
ether: &Ethernet2Slice<'a>,
ipv4: &Ipv4Slice<'a>,
) -> Result<()> {
let source_addr = IpAddress::Ipv4(ipv4.header().source_addr().into()); let source_addr = IpAddress::Ipv4(ipv4.header().source_addr().into());
let dest_addr = IpAddress::Ipv4(ipv4.header().destination_addr().into()); let dest_addr = IpAddress::Ipv4(ipv4.header().destination_addr().into());
match ipv4.header().protocol() { match ipv4.header().protocol() {
IpNumber::TCP => { IpNumber::TCP => {
self.process_tcp(data, source_addr, dest_addr, ipv4.payload()) self.process_tcp(data, ether, source_addr, dest_addr, ipv4.payload())
.await?; .await?;
} }
IpNumber::UDP => { IpNumber::UDP => {
self.process_udp(data, source_addr, dest_addr, ipv4.payload()) self.process_udp(data, ether, source_addr, dest_addr, ipv4.payload())
.await?; .await?;
} }
@ -135,6 +146,7 @@ impl NatRouter {
pub async fn process_tcp<'a>( pub async fn process_tcp<'a>(
&mut self, &mut self,
data: &'a [u8], data: &'a [u8],
ether: &Ethernet2Slice<'a>,
source_addr: IpAddress, source_addr: IpAddress,
dest_addr: IpAddress, dest_addr: IpAddress,
payload: &IpPayloadSlice<'a>, payload: &IpPayloadSlice<'a>,
@ -142,9 +154,12 @@ impl NatRouter {
let header = TcpHeaderSlice::from_slice(payload.payload)?; let header = TcpHeaderSlice::from_slice(payload.payload)?;
let source = IpEndpoint::new(source_addr, header.source_port()); let source = IpEndpoint::new(source_addr, header.source_port());
let dest = IpEndpoint::new(dest_addr, header.destination_port()); let dest = IpEndpoint::new(dest_addr, header.destination_port());
let key = NatKey::Tcp { let key = NatKey {
client: source, protocol: NatKeyProtocol::Tcp,
external: dest, client_mac: EthernetAddress(ether.destination()),
local_mac: EthernetAddress(ether.source()),
client_ip: source,
external_ip: dest,
}; };
self.process_nat(data, key).await?; self.process_nat(data, key).await?;
Ok(()) Ok(())
@ -153,6 +168,7 @@ impl NatRouter {
pub async fn process_udp<'a>( pub async fn process_udp<'a>(
&mut self, &mut self,
data: &'a [u8], data: &'a [u8],
ether: &Ethernet2Slice<'a>,
source_addr: IpAddress, source_addr: IpAddress,
dest_addr: IpAddress, dest_addr: IpAddress,
payload: &IpPayloadSlice<'a>, payload: &IpPayloadSlice<'a>,
@ -160,9 +176,12 @@ impl NatRouter {
let header = UdpHeaderSlice::from_slice(payload.payload)?; let header = UdpHeaderSlice::from_slice(payload.payload)?;
let source = IpEndpoint::new(source_addr, header.source_port()); let source = IpEndpoint::new(source_addr, header.source_port());
let dest = IpEndpoint::new(dest_addr, header.destination_port()); let dest = IpEndpoint::new(dest_addr, header.destination_port());
let key = NatKey::Udp { let key = NatKey {
client: source, protocol: NatKeyProtocol::Udp,
external: dest, client_mac: EthernetAddress(ether.destination()),
local_mac: EthernetAddress(ether.source()),
client_ip: source,
external_ip: dest,
}; };
self.process_nat(data, key).await?; self.process_nat(data, key).await?;
Ok(()) Ok(())
@ -172,7 +191,7 @@ impl NatRouter {
let handler: Option<&mut Box<dyn NatHandler>> = match self.table.inner.entry(key) { let handler: Option<&mut Box<dyn NatHandler>> = match self.table.inner.entry(key) {
Entry::Occupied(entry) => Some(entry.into_mut()), Entry::Occupied(entry) => Some(entry.into_mut()),
Entry::Vacant(entry) => { Entry::Vacant(entry) => {
if let Some(handler) = self.factory.nat(key).await { if let Some(handler) = self.factory.nat(key, self.tx_sender.clone()).await {
Some(entry.insert(handler)) Some(entry.insert(handler))
} else { } else {
None None

69
network/src/proxynat.rs
View File

@ -2,11 +2,11 @@ use std::net::{IpAddr, Ipv4Addr, SocketAddr};
use anyhow::{anyhow, Result}; use anyhow::{anyhow, Result};
use async_trait::async_trait; use async_trait::async_trait;
use etherparse::{SlicedPacket, UdpSlice}; use etherparse::{PacketBuilder, SlicedPacket, UdpSlice};
use log::{debug, warn}; use log::{debug, warn};
use smoltcp::{ use smoltcp::{
phy::{Checksum, ChecksumCapabilities}, phy::{Checksum, ChecksumCapabilities},
wire::{IpAddress, IpEndpoint}, wire::IpAddress,
}; };
use tokio::{ use tokio::{
io::{AsyncReadExt, AsyncWriteExt}, io::{AsyncReadExt, AsyncWriteExt},
@ -16,13 +16,13 @@ use tokio::{
use tokio::{sync::mpsc::Receiver, sync::mpsc::Sender}; use tokio::{sync::mpsc::Receiver, sync::mpsc::Sender};
use udp_stream::UdpStream; use udp_stream::UdpStream;
use crate::nat::{NatHandler, NatHandlerFactory, NatKey}; use crate::nat::{NatHandler, NatHandlerFactory, NatKey, NatKeyProtocol};
pub struct ProxyNatHandlerFactory {} pub struct ProxyNatHandlerFactory {}
struct ProxyUdpHandler { struct ProxyUdpHandler {
external: IpEndpoint, key: NatKey,
sender: Sender<Vec<u8>>, rx_sender: Sender<Vec<u8>>,
} }
impl ProxyNatHandlerFactory { impl ProxyNatHandlerFactory {
@ -33,18 +33,15 @@ impl ProxyNatHandlerFactory {
#[async_trait] #[async_trait]
impl NatHandlerFactory for ProxyNatHandlerFactory { impl NatHandlerFactory for ProxyNatHandlerFactory {
async fn nat(&self, key: NatKey) -> Option<Box<dyn NatHandler>> { async fn nat(&self, key: NatKey, sender: Sender<Vec<u8>>) -> Option<Box<dyn NatHandler>> {
debug!("creating proxy nat entry for key: {}", key); debug!("creating proxy nat entry for key: {}", key);
match key { match key.protocol {
NatKey::Udp { NatKeyProtocol::Udp => {
client: _, let (rx_sender, rx_receiver) = channel::<Vec<u8>>(4);
external, let mut handler = ProxyUdpHandler { key, rx_sender };
} => {
let (sender, receiver) = channel::<Vec<u8>>(4);
let mut handler = ProxyUdpHandler { external, sender };
if let Err(error) = handler.spawn(receiver).await { if let Err(error) = handler.spawn(rx_receiver, sender.clone()).await {
warn!("unable to spawn udp proxy handler: {}", error); warn!("unable to spawn udp proxy handler: {}", error);
None None
} else { } else {
@ -60,7 +57,7 @@ impl NatHandlerFactory for ProxyNatHandlerFactory {
#[async_trait] #[async_trait]
impl NatHandler for ProxyUdpHandler { impl NatHandler for ProxyUdpHandler {
async fn receive(&self, data: &[u8]) -> Result<()> { async fn receive(&self, data: &[u8]) -> Result<()> {
self.sender.try_send(data.to_vec())?; self.rx_sender.try_send(data.to_vec())?;
Ok(()) Ok(())
} }
} }
@ -72,25 +69,36 @@ enum ProxySelect {
} }
impl ProxyUdpHandler { impl ProxyUdpHandler {
async fn spawn(&mut self, receiver: Receiver<Vec<u8>>) -> Result<()> { async fn spawn(
let external_addr = match self.external.addr { &mut self,
rx_receiver: Receiver<Vec<u8>>,
tx_sender: Sender<Vec<u8>>,
) -> Result<()> {
let external_addr = match self.key.external_ip.addr {
IpAddress::Ipv4(addr) => SocketAddr::new( IpAddress::Ipv4(addr) => SocketAddr::new(
IpAddr::V4(Ipv4Addr::new(addr.0[0], addr.0[1], addr.0[2], addr.0[3])), IpAddr::V4(Ipv4Addr::new(addr.0[0], addr.0[1], addr.0[2], addr.0[3])),
self.external.port, self.key.external_ip.port,
), ),
IpAddress::Ipv6(_) => return Err(anyhow!("IPv6 unsupported")), IpAddress::Ipv6(_) => return Err(anyhow!("IPv6 unsupported")),
}; };
let socket = UdpStream::connect(external_addr).await?; let socket = UdpStream::connect(external_addr).await?;
let key = self.key;
tokio::spawn(async move { tokio::spawn(async move {
if let Err(error) = ProxyUdpHandler::process(socket, receiver).await { if let Err(error) = ProxyUdpHandler::process(key, socket, rx_receiver, tx_sender).await
{
warn!("processing of udp proxy failed: {}", error); warn!("processing of udp proxy failed: {}", error);
} }
}); });
Ok(()) Ok(())
} }
async fn process(mut socket: UdpStream, mut receiver: Receiver<Vec<u8>>) -> Result<()> { async fn process(
key: NatKey,
mut socket: UdpStream,
mut rx_receiver: Receiver<Vec<u8>>,
tx_sender: Sender<Vec<u8>>,
) -> Result<()> {
let mut checksum = ChecksumCapabilities::ignored(); let mut checksum = ChecksumCapabilities::ignored();
checksum.udp = Checksum::Tx; checksum.udp = Checksum::Tx;
checksum.ipv4 = Checksum::Tx; checksum.ipv4 = Checksum::Tx;
@ -100,7 +108,7 @@ impl ProxyUdpHandler {
loop { loop {
let selection = select! { let selection = select! {
x = receiver.recv() => if let Some(data) = x { x = rx_receiver.recv() => if let Some(data) = x {
ProxySelect::Internal(data) ProxySelect::Internal(data)
} else { } else {
ProxySelect::Closed ProxySelect::Closed
@ -111,7 +119,24 @@ impl ProxyUdpHandler {
match selection { match selection {
ProxySelect::External(size) => { ProxySelect::External(size) => {
let data = &external_buffer[0..size]; let data = &external_buffer[0..size];
debug!("UDP from external: {:?}", data); let packet = PacketBuilder::ethernet2(key.local_mac.0, key.client_mac.0);
let packet = match (key.external_ip.addr, key.client_ip.addr) {
(IpAddress::Ipv4(external_addr), IpAddress::Ipv4(client_addr)) => {
packet.ipv4(external_addr.0, client_addr.0, 20)
}
(IpAddress::Ipv6(external_addr), IpAddress::Ipv6(client_addr)) => {
packet.ipv6(external_addr.0, client_addr.0, 20)
}
_ => {
return Err(anyhow!("IP endpoint mismatch"));
}
};
let packet = packet.udp(key.external_ip.port, key.client_ip.port);
let mut buffer: Vec<u8> = Vec::new();
packet.write(&mut buffer, data)?;
if let Err(error) = tx_sender.try_send(buffer) {
debug!("failed to transmit udp packet: {}", error);
}
} }
ProxySelect::Internal(data) => { ProxySelect::Internal(data) => {
debug!("udp socket to handle data: {:?}", data); debug!("udp socket to handle data: {:?}", data);