wifiscan 0.4.0

Wireless network scanner TUI with monitor mode, handshake capture, deauth, and evil twin
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

use std::io::Write;
use std::path::PathBuf;
use std::sync::{Arc, Mutex, OnceLock};
use std::time::Instant;

use chrono::Local;

// ── Debug Logging ───────────────────────────────────────────────────────────

#[derive(Clone)]
pub struct DebugLog {
    inner: Option<Arc<Mutex<std::fs::File>>>,
}

impl DebugLog {
    pub fn new(enabled: bool, path: &str) -> Self {
        if enabled {
            match std::fs::File::create(path) {
                Ok(f) => {
                    eprintln!("[+] Debug logging to {}", path);
                    Self { inner: Some(Arc::new(Mutex::new(f))) }
                }
                Err(e) => {
                    eprintln!("[-] Failed to create debug log: {}", e);
                    Self { inner: None }
                }
            }
        } else {
            Self { inner: None }
        }
    }

    pub fn log(&self, msg: &str) {
        if let Some(ref f) = self.inner {
            if let Ok(mut file) = f.lock() {
                let ts = Local::now().format("%H:%M:%S%.3f");
                let _ = writeln!(file, "[{}] {}", ts, msg);
            }
        }
    }

    pub fn log_hex(&self, prefix: &str, data: &[u8], max_bytes: usize) {
        if self.inner.is_none() { return; }
        let len = data.len().min(max_bytes);
        let hex: String = data[..len].iter().map(|b| format!("{:02x}", b)).collect::<Vec<_>>().join(" ");
        let suffix = if data.len() > max_bytes { format!("... ({} bytes total)", data.len()) } else { String::new() };
        self.log(&format!("{}: {}{}", prefix, hex, suffix));
    }

    pub fn is_enabled(&self) -> bool {
        self.inner.is_some()
    }
}

// ── Pcap Dumper ─────────────────────────────────────────────────────────────

#[derive(Clone)]
pub struct PcapDumper {
    inner: Option<Arc<Mutex<std::fs::File>>>,
    start: Instant,
}

impl PcapDumper {
    pub fn new(path: Option<&PathBuf>) -> Self {
        match path {
            Some(p) => {
                match std::fs::File::create(p) {
                    Ok(mut f) => {
                        // pcap global header: LINKTYPE_IEEE802_11_RADIOTAP (127)
                        let hdr: [u8; 24] = [
                            0xd4, 0xc3, 0xb2, 0xa1, 0x02, 0x00, 0x04, 0x00,
                            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                            0xff, 0xff, 0x00, 0x00, 0x7f, 0x00, 0x00, 0x00,
                        ];
                        if f.write_all(&hdr).is_ok() {
                            eprintln!("[+] Dumping all packets to {}", p.display());
                            Self { inner: Some(Arc::new(Mutex::new(f))), start: Instant::now() }
                        } else {
                            Self { inner: None, start: Instant::now() }
                        }
                    }
                    Err(e) => {
                        eprintln!("[-] Failed to create pcap dump: {}", e);
                        Self { inner: None, start: Instant::now() }
                    }
                }
            }
            None => Self { inner: None, start: Instant::now() },
        }
    }

    pub fn write_packet(&self, raw: &[u8]) {
        if let Some(ref f) = self.inner {
            if let Ok(mut file) = f.lock() {
                let elapsed = self.start.elapsed();
                let ts_sec = elapsed.as_secs() as u32;
                let ts_usec = elapsed.subsec_micros();
                let len = raw.len() as u32;
                let mut hdr = [0u8; 16];
                hdr[0..4].copy_from_slice(&ts_sec.to_le_bytes());
                hdr[4..8].copy_from_slice(&ts_usec.to_le_bytes());
                hdr[8..12].copy_from_slice(&len.to_le_bytes());
                hdr[12..16].copy_from_slice(&len.to_le_bytes());
                let _ = file.write_all(&hdr);
                let _ = file.write_all(raw);
            }
        }
    }
}

// ── Global Singletons ───────────────────────────────────────────────────────

static DEBUG_LOG: OnceLock<DebugLog> = OnceLock::new();
static PCAP_DUMP: OnceLock<PcapDumper> = OnceLock::new();

pub fn init_debug(enabled: bool, path: &str) {
    let _ = DEBUG_LOG.set(DebugLog::new(enabled, path));
}

pub fn init_pcap_dump(path: Option<&PathBuf>) {
    let _ = PCAP_DUMP.set(PcapDumper::new(path));
}

pub fn dbg_log(msg: &str) {
    if let Some(log) = DEBUG_LOG.get() {
        log.log(msg);
    }
}

pub fn dbg_hex(prefix: &str, data: &[u8], max_bytes: usize) {
    if let Some(log) = DEBUG_LOG.get() {
        log.log_hex(prefix, data, max_bytes);
    }
}

pub fn dbg_enabled() -> bool {
    DEBUG_LOG.get().map(|l| l.is_enabled()).unwrap_or(false)
}

pub fn pcap_dump(raw: &[u8]) {
    if let Some(d) = PCAP_DUMP.get() {
        d.write_packet(raw);
    }
}