slapy 0.0.4

A much faster scapy
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

// linux implementation
use crate::packets::MAC;
// #[cfg(unix)]
// use pcap::Device;

#[cfg(unix)]
pub fn get_devices() -> Vec<String> {
    // let ignore_list = ["any", "dbus", "nfqueue", "lo"].to_vec();
    // let devices = Device::list().unwrap();
    let mut ret_list = Vec::new();
    // for device in devices {
    //     if ignore_list
    //         .iter()
    //         .find(|&&x| device.name.starts_with(x))
    //         .is_none()
    //     {
    //         ret_list.push(device.name.to_string());
    //     }
    // }

    ret_list
}

#[cfg(unix)]
pub fn set_monitor_mode(dev_name: &str) {
    // tracing::debug!("    - setting iface down");
    std::process::Command::new("ip")
        .args(["link", "set", dev_name, "down"])
        .output()
        .unwrap();

    // tracing::debug!("    - setting iface to monitormode");
    std::process::Command::new("iwconfig")
        .args([dev_name, "mode", "monitor"])
        .output()
        .unwrap();

    // tracing::debug!("    - setting iface up");
    std::process::Command::new("ip")
        .args(["link", "set", dev_name, "up"])
        .output()
        .unwrap();

    // tracing::debug!("    - iface should be in monitormode now");
}

#[cfg(unix)]
pub fn set_wifi_channel(dev_name: &str, channel: u8) {
    std::process::Command::new("iwconfig")
        .args([dev_name, "channel", channel.to_string().as_str()])
        .output()
        .unwrap();
    // tracing::debug!("Set {} to channel {}", dev_name, channel);
}

#[cfg(unix)]
pub fn get_interface_mode(dev_name: &str) -> String {
    let iw_out = String::from_utf8(
        std::process::Command::new("iwconfig")
            .arg(dev_name)
            .output()
            .unwrap()
            .stdout,
    )
    .unwrap();

    let mut mode = "".to_string();

    for part in iw_out.split(" ") {
        if part.trim().len() > 0 && part.contains("Mode:") {
            mode = part.trim().replace("Mode:", "").to_string();
        }
    }

    mode
}

#[cfg(unix)]
pub fn get_wifi_channel(dev_name: &str) -> u8 {
    let out = std::process::Command::new("iwlist")
        .args([dev_name, "channel"])
        .output()
        .unwrap();

    let s = String::from_utf8(out.stdout).unwrap();
    let mut ch = "0".to_string();
    for line in s.split("\n") {
        if line.trim().contains("Current Frequency") {
            ch = line
                .trim()
                .replace("Current Frequency:", "")
                .split(" ")
                .into_iter()
                .last()
                .unwrap()
                .replace(")", "")
        }
    }

    ch.parse().unwrap()
}

#[cfg(unix)]
/// Get the mac address based on the given device name.
/// Executes `ip a s <dev_name> | grep ether` in the background and does some parsing.
pub fn get_mac_address(dev_name: &str) -> MAC {
    let echo_child = std::process::Command::new("ip")
        .args(["-j", "a", "s", dev_name])
        .output()
        .expect("Failed to run ip command");

    let ip_out = String::from_utf8(echo_child.stdout).unwrap();
    if ip_out.contains("does not exist.") || ip_out.trim().len() == 0 {
        // tracing::warn!("Device {dev_name} is no network device found by `ip` command.");
        return MAC::new([0; 6]);
    }

    let mut mac = "";

    // let parsed = serde_json::from_str::<serde_json::Value>(&ip_out).unwrap();
    // if parsed.is_array() && parsed[0].is_object() {
    //     let obj = &parsed[0];
    //     mac = obj.get("address").unwrap().as_str().unwrap();
    // }

    MAC::try_from(mac).expect("Could not interpret string as valid MAC address")
}

// Windows implementation (TODO)
#[cfg(windows)]
pub fn set_monitor_mode(_device: &str) {
    tracing::error!("Using unsupported feature in windows!");
}

#[cfg(windows)]
pub fn set_wifi_channel(_device: &str, _channel: u8) {
    tracing::error!("Using unsupported feature in windows!");
}

#[cfg(windows)]
pub fn get_devices() -> Vec<String> {
    println!("[Get Wifi Devices] Unsupported Feature on Windows!");
    Vec::new()
}

#[cfg(windows)]
pub fn get_mac_address(_dev_name: &str) -> MAC {
    tracing::error!("Using unsupported feature in windows!");
    MAC::BROADCAST
}

#[cfg(windows)]
pub fn get_interface_mode(_dev_name: &str) -> String {
    tracing::error!("Using unsupported feature in windows!");
    "".to_string()
}

#[cfg(windows)]
pub fn get_wifi_channel(_dev_name: &str) -> u8 {
    tracing::error!("Using unsupported feature in windows!");
    0
}