#tun #devices #stack #userspace #asynchronous #tokio #stream

ipstack

Asynchronous lightweight userspace implementation of TCP/IP stack for Tun device

11 releases

0.0.10 May 12, 2024
0.0.9 Apr 16, 2024
0.0.7 Mar 30, 2024
0.0.3 Jan 21, 2024
0.0.0 Oct 22, 2023

#872 in Network programming

Download history 159/week @ 2024-03-03 181/week @ 2024-03-10 275/week @ 2024-03-17 229/week @ 2024-03-24 219/week @ 2024-03-31 316/week @ 2024-04-07 264/week @ 2024-04-14 39/week @ 2024-04-21 150/week @ 2024-04-28 193/week @ 2024-05-05 260/week @ 2024-05-12 125/week @ 2024-05-19 63/week @ 2024-05-26 64/week @ 2024-06-02 167/week @ 2024-06-09 145/week @ 2024-06-16

445 downloads per month
Used in 2 crates

Apache-2.0

70KB
1.5K SLoC

IpStack

An asynchronous lightweight userspace implementation of TCP/IP stack for Tun device. Unstable, under development.

Crates.io ipstack Documentation Download License

Usage

use etherparse::{IcmpEchoHeader, Icmpv4Header};
use ipstack::stream::IpStackStream;
use std::net::{IpAddr, Ipv4Addr, SocketAddr};
use tokio::net::TcpStream;
use udp_stream::UdpStream;

#[tokio::main]
async fn main() {
    const MTU: u16 = 1500;
    let ipv4 = Ipv4Addr::new(10, 0, 0, 1);
    let netmask = Ipv4Addr::new(255, 255, 255, 0);
    let mut config = tun2::Configuration::default();
    config.address(ipv4).netmask(netmask).mtu(MTU).up();

    #[cfg(target_os = "linux")]
    config.platform_config(|config| {
        config.ensure_root_privileges(true);
    });

    #[cfg(target_os = "windows")]
    config.platform_config(|config| {
        config.device_guid(Some(12324323423423434234_u128));
    });

    let mut ipstack_config = ipstack::IpStackConfig::default();
    ipstack_config.mtu(MTU);
    let mut ip_stack =
        ipstack::IpStack::new(ipstack_config, tun2::create_as_async(&config).unwrap());

    while let Ok(stream) = ip_stack.accept().await {
        match stream {
            IpStackStream::Tcp(mut tcp) => {
                let mut rhs = TcpStream::connect("1.1.1.1:80").await.unwrap();
                tokio::spawn(async move {
                    let _ = tokio::io::copy_bidirectional(&mut tcp, &mut rhs).await;
                });
            }
            IpStackStream::Udp(mut udp) => {
                let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(1, 1, 1, 1)), 53);
                let mut rhs = UdpStream::connect(addr).await.unwrap();
                tokio::spawn(async move {
                    let _ = tokio::io::copy_bidirectional(&mut udp, &mut rhs).await;
                });
            }
            IpStackStream::UnknownTransport(u) => {
                if u.src_addr().is_ipv4() && u.ip_protocol() == etherparse::IpNumber(1) {
                    let (icmp_header, req_payload) = Icmpv4Header::from_slice(u.payload()).unwrap();
                    if let etherparse::Icmpv4Type::EchoRequest(req) = icmp_header.icmp_type {
                        println!("ICMPv4 echo");
                        let echo = IcmpEchoHeader {
                            id: req.id,
                            seq: req.seq,
                        };
                        let mut resp = Icmpv4Header::new(etherparse::Icmpv4Type::EchoReply(echo));
                        resp.update_checksum(req_payload);
                        let mut payload = resp.to_bytes().to_vec();
                        payload.extend_from_slice(req_payload);
                        u.send(payload).unwrap();
                    } else {
                        println!("ICMPv4");
                    }
                    continue;
                }
                println!("unknown transport - Ip Protocol {}", u.ip_protocol().0);
                continue;
            }
            IpStackStream::UnknownNetwork(pkt) => {
                println!("unknown transport - {} bytes", pkt.len());
                continue;
            }
        }
    }
}

We also suggest that you take a look at the complete examples.

Dependencies

~8MB
~142K SLoC