wifi_scan 0.7.3

A crate to list WiFi hotspots in your area. Fork of booyaa/wifiscanner with many improvements to make it future-proof.
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

use crate::{misc::get_channel, Error, Result, Wifi, WifiSecurity, WlanScanner};

use libwifi::{frame::components::RsnAkmSuite, parsers::parse_rsn_information};
use win32_wlan::query_system_interfaces;

pub struct ScanWindows;

impl WlanScanner for ScanWindows {
    /// Returns a list of WiFi hotspots in your area - Windows uses the `win32-wlan` crate.
    fn scan(&mut self) -> Result<Vec<Wifi>> {
        let interfaces = futures::executor::block_on(query_system_interfaces())
            .map_err(|e| Error::InterfaceError(e.to_string()))?;

        if let Some(interface) = interfaces.first() {
            let networks = interface
                .blocking_scan()
                .map_err(|e| Error::ScanFailed(e.to_string()))?;

            let wifi_list = networks
                .iter()
                .filter_map(|network| {
                    network.ssid().map(|ssid| Wifi {
                        mac: network.bss_id().to_string(),
                        ssid: ssid.to_string(),
                        channel: get_channel(network.ch_center_frequency() / 1000),
                        signal_level: network.rssi(),
                        security: get_security(network.information_frame()),
                    })
                })
                .collect();

            Ok(wifi_list)
        } else {
            Err(Error::InterfaceError(
                "No WiFi interfaces found".to_string(),
            ))
        }
    }
}

fn get_security(ie_data: &[u8]) -> Vec<WifiSecurity> {
    let mut has_rsn = false;
    let mut has_wpa = false;
    let mut securities: Vec<WifiSecurity> = Vec::new();

    let mut i = 0;
    while i + 1 < ie_data.len() {
        let element_id = ie_data[i];
        let length = ie_data[i + 1] as usize;

        if i + 2 + length > ie_data.len() {
            break;
        }

        let element_data = &ie_data[i + 2..i + 2 + length];

        match element_id {
            48 => {
                has_rsn = true;
                if let Ok(rsn) = parse_rsn_information(element_data) {
                    let sec = format_security(&rsn.akm_suites);
                    if !sec.is_empty() {
                        securities.extend(sec.iter().cloned());
                    }
                }
            }
            221 => {
                if length >= 4 {
                    let oui = &element_data[0..3];
                    if oui == [0x00, 0x50, 0xF2] && element_data.get(3) == Some(&0x01) {
                        has_wpa = true;
                        securities.push(WifiSecurity::WpaPersonalPsk);
                    }
                }
            }
            _ => {}
        }

        i += 2 + length;
    }

    if securities.is_empty() {
        if has_rsn || has_wpa {
            vec![WifiSecurity::WpaPersonalPsk, WifiSecurity::Wpa2PersonalPsk]
        } else {
            vec![WifiSecurity::Open]
        }
    } else {
        securities
    }
}

fn format_security(akm_suites: &[RsnAkmSuite]) -> Vec<WifiSecurity> {
    let mut securities: Vec<WifiSecurity> = Vec::new();

    for akm_suite in akm_suites {
        let security = match akm_suite {
            RsnAkmSuite::PSK => WifiSecurity::Wpa2PersonalPsk,
            RsnAkmSuite::SAE => WifiSecurity::Wpa3PersonalSae,
            RsnAkmSuite::EAP => WifiSecurity::Wpa2EnterpriseEap,
            RsnAkmSuite::EAP256 => WifiSecurity::Wpa3EnterpriseEap256,
            RsnAkmSuite::EAPFT => WifiSecurity::Wpa2EnterpriseEapFt,
            RsnAkmSuite::PSK256 => WifiSecurity::Wpa2PersonalPsk256,
            RsnAkmSuite::PSKFT => WifiSecurity::Wpa2PersonalPskFt,
            RsnAkmSuite::SUITEBEAP256 => WifiSecurity::Wpa3EnterpriseSuiteBEap256,
            _ => WifiSecurity::Unknown,
        };

        if security != WifiSecurity::Unknown {
            securities.push(security);
        }
    }

    if securities.is_empty() {
        vec![WifiSecurity::Wpa2PersonalPsk]
    } else {
        securities
    }
}