pack2 0.1.3

windows ipv4 packet sniffing
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

use etherparse::{SlicedPacket, TcpOptionElement, TcpOptionReadError};
use pack2::recv_all_socket;
use std::mem::MaybeUninit;

// IMPORTANT:
// This example needs to be run as administrator and to receive incoming packets
// you need to allow the firewall rule which pops up upon starting the example.
fn main() -> Result<(), Box<dyn std::error::Error>> {
    let socket = recv_all_socket()?;

    let mut buf = vec![0u8; 65535];
    loop {
        // This is safe as described in the documentation of socket2::Socket::recv_from
        let buf_maybe = unsafe { &mut *(&mut buf[..] as *mut [u8] as *mut [MaybeUninit<u8>]) };
        let (read, _) = socket.recv_from(buf_maybe)?;

        let packet = match SlicedPacket::from_ip(&buf[..read]) {
            Ok(p) => p,
            _ => {
                println!("received but unable to parse");
                continue;
            }
        };
        print_packet(&packet);
    }
}

fn print_packet(packet: &SlicedPacket) {
    use etherparse::{InternetSlice::*, LinkSlice::*, TransportSlice::*, VlanSlice::*};

    match &packet.link {
        Some(Ethernet2(value)) => println!(
            "  Ethernet2 {:?} => {:?}",
            value.source(),
            value.destination()
        ),
        None => {}
    }

    match &packet.vlan {
        Some(SingleVlan(value)) => println!("  SingleVlan {:?}", value.vlan_identifier()),
        Some(DoubleVlan(value)) => println!(
            "  DoubleVlan {:?}, {:?}",
            value.outer().vlan_identifier(),
            value.inner().vlan_identifier()
        ),
        None => {}
    }

    match &packet.ip {
        Some(Ipv4(value, extensions)) => {
            println!(
                "  Ipv4 {:?} => {:?}",
                value.source_addr(),
                value.destination_addr()
            );
            if false == extensions.is_empty() {
                println!("    {:?}", extensions);
            }
        }
        Some(Ipv6(value, extensions)) => {
            println!(
                "  Ipv6 {:?} => {:?}",
                value.source_addr(),
                value.destination_addr()
            );
            if false == extensions.is_empty() {
                println!("    {:?}", extensions);
            }
        }
        None => {}
    }

    match &packet.transport {
        Some(Udp(value)) => println!(
            "  UDP {:?} -> {:?}",
            value.source_port(),
            value.destination_port()
        ),
        Some(Tcp(value)) => {
            println!(
                "  TCP {:?} -> {:?}",
                value.source_port(),
                value.destination_port()
            );
            let options: Vec<Result<TcpOptionElement, TcpOptionReadError>> =
                value.options_iterator().collect();
            println!("    {:?}", options);
        }
        Some(Unknown(ip_protocol)) => {
            println!("  Unknwon Protocol (ip protocol number {:?}", ip_protocol)
        }
        None => {}
    }
}