850 lines
31 KiB
Python
Executable File
850 lines
31 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""
|
|
Monitor mode WiFi packet capture and analysis using scapy.
|
|
Replaces the bash script with a pure Python solution.
|
|
|
|
Usage:
|
|
# Live capture from interface:
|
|
sudo python3 wifi_monitor.py [interface] [channel] [duration_seconds] [--keep-pcap] [--full-packet]
|
|
sudo python3 wifi_monitor.py wlan0 36 10
|
|
sudo python3 wifi_monitor.py wlan0 36 10 --keep-pcap
|
|
sudo python3 wifi_monitor.py wlan0 36 10 --full-packet # Capture entire packets (default: header only)
|
|
|
|
# Read from pcap file:
|
|
python3 wifi_monitor.py <pcap_file>
|
|
python3 wifi_monitor.py /tmp/capture.pcap
|
|
"""
|
|
|
|
# Standard library imports
|
|
import asyncio
|
|
import os
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import time
|
|
from collections import Counter, defaultdict
|
|
|
|
# Third-party imports
|
|
from scapy.all import RadioTap, rdpcap, sniff, wrpcap
|
|
from scapy.layers.dot11 import (
|
|
Dot11, Dot11AssoReq, Dot11AssoResp, Dot11Auth, Dot11Beacon,
|
|
Dot11Deauth, Dot11Disas, Dot11ProbeReq, Dot11ProbeResp, Dot11QoS
|
|
)
|
|
|
|
|
|
class Config:
|
|
"""Configuration class for capture settings."""
|
|
def __init__(self):
|
|
self.wifi_interface = os.environ.get("WIFI_INTERFACE", "wlan0")
|
|
self.keep_pcap = False
|
|
self.full_packet = False
|
|
self.default_snaplen = 256 # Header + some payload
|
|
|
|
@property
|
|
def snaplen(self):
|
|
"""Get snaplen value based on full_packet setting."""
|
|
return 0 if self.full_packet else self.default_snaplen
|
|
|
|
|
|
class WiFiMonitor:
|
|
"""Handles WiFi interface monitor mode setup and teardown with async support."""
|
|
def __init__(self, interface, channel):
|
|
self.interface = interface
|
|
self.channel = channel
|
|
self._error_message = None
|
|
self._original_mode = None
|
|
self._is_started = False
|
|
|
|
@property
|
|
def error_message(self):
|
|
"""Get error message if setup failed."""
|
|
return self._error_message
|
|
|
|
@property
|
|
def is_successful(self):
|
|
"""Check if setup was successful."""
|
|
return self._error_message is None
|
|
|
|
@property
|
|
def is_started(self):
|
|
"""Check if monitor mode is currently active."""
|
|
return self._is_started
|
|
|
|
async def start(self):
|
|
"""Start monitor mode on the WiFi interface."""
|
|
self._error_message = None
|
|
result = True
|
|
print(f"=== Setting up monitor mode on {self.interface} ===")
|
|
|
|
if not await self._unmanage_networkmanager():
|
|
result = False
|
|
|
|
await self._unblock_wifi()
|
|
|
|
if not await self._set_monitor_mode():
|
|
result = False
|
|
|
|
if not await self._set_channel():
|
|
result = False
|
|
|
|
await self._verify_monitor_mode()
|
|
|
|
if result:
|
|
self._is_started = True
|
|
|
|
return result
|
|
|
|
async def stop(self):
|
|
"""Stop monitor mode and restore interface to managed mode."""
|
|
if not self._is_started:
|
|
return True
|
|
|
|
print(f"=== Restoring {self.interface} to managed mode ===")
|
|
result = True
|
|
|
|
try:
|
|
# Bring down interface
|
|
proc = await asyncio.create_subprocess_exec(
|
|
"ip", "link", "set", self.interface, "down",
|
|
stdout=asyncio.subprocess.DEVNULL,
|
|
stderr=asyncio.subprocess.DEVNULL
|
|
)
|
|
await proc.wait()
|
|
await asyncio.sleep(0.5)
|
|
|
|
# Set back to managed mode
|
|
proc = await asyncio.create_subprocess_exec(
|
|
"iw", "dev", self.interface, "set", "type", "managed",
|
|
stdout=asyncio.subprocess.DEVNULL,
|
|
stderr=asyncio.subprocess.PIPE
|
|
)
|
|
_, stderr = await proc.communicate()
|
|
if proc.returncode != 0:
|
|
error_msg = stderr.decode() if stderr else "Unknown error"
|
|
print(f"Warning: Failed to set managed mode: {error_msg}")
|
|
result = False
|
|
else:
|
|
print("Restored to managed mode")
|
|
|
|
# Re-enable NetworkManager management
|
|
await self._manage_networkmanager()
|
|
|
|
# Bring up interface
|
|
proc = await asyncio.create_subprocess_exec(
|
|
"ip", "link", "set", self.interface, "up",
|
|
stdout=asyncio.subprocess.DEVNULL,
|
|
stderr=asyncio.subprocess.DEVNULL
|
|
)
|
|
await proc.wait()
|
|
|
|
self._is_started = False
|
|
except OSError as e:
|
|
self._error_message = f"Error restoring managed mode: {e}"
|
|
print(self._error_message)
|
|
result = False
|
|
|
|
return result
|
|
|
|
async def _unmanage_networkmanager(self):
|
|
"""Try to unmanage interface from NetworkManager."""
|
|
try:
|
|
proc = await asyncio.create_subprocess_exec(
|
|
"which", "nmcli",
|
|
stdout=asyncio.subprocess.PIPE,
|
|
stderr=asyncio.subprocess.DEVNULL
|
|
)
|
|
await proc.wait()
|
|
if proc.returncode == 0:
|
|
print("Unmanaging interface from NetworkManager...")
|
|
proc = await asyncio.create_subprocess_exec(
|
|
"nmcli", "device", "set", self.interface, "managed", "no",
|
|
stdout=asyncio.subprocess.DEVNULL,
|
|
stderr=asyncio.subprocess.DEVNULL
|
|
)
|
|
await proc.wait()
|
|
except OSError:
|
|
pass
|
|
return True
|
|
|
|
async def _manage_networkmanager(self):
|
|
"""Re-enable NetworkManager management of the interface."""
|
|
try:
|
|
proc = await asyncio.create_subprocess_exec(
|
|
"which", "nmcli",
|
|
stdout=asyncio.subprocess.PIPE,
|
|
stderr=asyncio.subprocess.DEVNULL
|
|
)
|
|
await proc.wait()
|
|
if proc.returncode == 0:
|
|
proc = await asyncio.create_subprocess_exec(
|
|
"nmcli", "device", "set", self.interface, "managed", "yes",
|
|
stdout=asyncio.subprocess.DEVNULL,
|
|
stderr=asyncio.subprocess.DEVNULL
|
|
)
|
|
await proc.wait()
|
|
except OSError:
|
|
pass
|
|
|
|
async def _unblock_wifi(self):
|
|
"""Unblock WiFi if blocked by rfkill."""
|
|
try:
|
|
proc = await asyncio.create_subprocess_exec(
|
|
"rfkill", "unblock", "wifi",
|
|
stdout=asyncio.subprocess.DEVNULL,
|
|
stderr=asyncio.subprocess.DEVNULL
|
|
)
|
|
await proc.wait()
|
|
except OSError:
|
|
pass
|
|
|
|
async def _set_monitor_mode(self):
|
|
"""Set interface to monitor mode."""
|
|
try:
|
|
proc = await asyncio.create_subprocess_exec(
|
|
"iw", "dev", self.interface, "info",
|
|
stdout=asyncio.subprocess.PIPE,
|
|
stderr=asyncio.subprocess.PIPE
|
|
)
|
|
stdout, stderr = await proc.communicate()
|
|
await proc.wait()
|
|
|
|
if proc.returncode == 0 and b"type monitor" in stdout:
|
|
print(f"Already in monitor mode")
|
|
return True
|
|
|
|
print(f"Setting {self.interface} to monitor mode...")
|
|
|
|
proc = await asyncio.create_subprocess_exec(
|
|
"ip", "link", "set", self.interface, "down",
|
|
stdout=asyncio.subprocess.DEVNULL,
|
|
stderr=asyncio.subprocess.DEVNULL
|
|
)
|
|
await proc.wait()
|
|
await asyncio.sleep(0.5)
|
|
|
|
proc = await asyncio.create_subprocess_exec(
|
|
"iw", "dev", self.interface, "set", "type", "monitor",
|
|
stdout=asyncio.subprocess.DEVNULL,
|
|
stderr=asyncio.subprocess.PIPE
|
|
)
|
|
stderr = await proc.communicate()[1]
|
|
await proc.wait()
|
|
|
|
if proc.returncode != 0:
|
|
error_msg = stderr.decode() if stderr else "Unknown error"
|
|
self._error_message = f"Error setting monitor mode: {error_msg}"
|
|
print(self._error_message)
|
|
return False
|
|
|
|
await asyncio.sleep(0.5)
|
|
|
|
proc = await asyncio.create_subprocess_exec(
|
|
"ip", "link", "set", self.interface, "up",
|
|
stdout=asyncio.subprocess.DEVNULL,
|
|
stderr=asyncio.subprocess.PIPE
|
|
)
|
|
stderr = await proc.communicate()[1]
|
|
await proc.wait()
|
|
|
|
if proc.returncode != 0:
|
|
error_msg = stderr.decode() if stderr else "Unknown error"
|
|
self._error_message = f"Error bringing interface up: {error_msg}"
|
|
print(self._error_message)
|
|
return False
|
|
|
|
print("Monitor mode activated")
|
|
return True
|
|
except OSError as e:
|
|
self._error_message = f"Error setting monitor mode: {e}"
|
|
print(self._error_message)
|
|
return False
|
|
|
|
async def _set_channel(self):
|
|
"""Set channel for monitor mode interface."""
|
|
try:
|
|
proc = await asyncio.create_subprocess_exec(
|
|
"iw", "dev", self.interface, "set", "channel", str(self.channel),
|
|
stdout=asyncio.subprocess.DEVNULL,
|
|
stderr=asyncio.subprocess.PIPE
|
|
)
|
|
stderr = await proc.communicate()[1]
|
|
await proc.wait()
|
|
|
|
if proc.returncode == 0:
|
|
print(f"Channel set to {self.channel}")
|
|
return True
|
|
else:
|
|
print(f"Error setting channel: {stderr.decode() if stderr else 'Unknown error'}")
|
|
print("Continuing anyway - channel may not be set correctly")
|
|
return True # Non-fatal
|
|
except OSError as e:
|
|
print(f"Error setting channel: {e}")
|
|
print("Continuing anyway - channel may not be set correctly")
|
|
return True # Non-fatal
|
|
|
|
async def _verify_monitor_mode(self):
|
|
"""Verify monitor mode is active."""
|
|
print("\nVerifying monitor mode...")
|
|
try:
|
|
proc = await asyncio.create_subprocess_exec(
|
|
"iw", "dev", self.interface, "info",
|
|
stdout=asyncio.subprocess.PIPE,
|
|
stderr=asyncio.subprocess.DEVNULL
|
|
)
|
|
stdout, _ = await proc.communicate()
|
|
await proc.wait()
|
|
|
|
if proc.returncode == 0:
|
|
for line in stdout.decode().splitlines():
|
|
if "type" in line or "channel" in line:
|
|
print(f"\t{line.strip()}")
|
|
except (OSError, subprocess.SubprocessError):
|
|
pass
|
|
|
|
|
|
class PacketParser:
|
|
"""Handles parsing of 802.11 packet fields."""
|
|
@staticmethod
|
|
def frame_type_name(pkt):
|
|
"""Get human-readable frame type name."""
|
|
if not pkt.haslayer(Dot11):
|
|
return "Unknown"
|
|
|
|
dot11 = pkt[Dot11]
|
|
fc = dot11.FCfield
|
|
|
|
if dot11.type == 0: # Management
|
|
if dot11.subtype == 8:
|
|
return "Beacon"
|
|
elif dot11.subtype == 4:
|
|
return "Probe Request"
|
|
elif dot11.subtype == 5:
|
|
return "Probe Response"
|
|
elif dot11.subtype == 11:
|
|
return "Authentication"
|
|
elif dot11.subtype == 12:
|
|
return "Deauthentication"
|
|
elif dot11.subtype == 0:
|
|
return "Association Request"
|
|
elif dot11.subtype == 1:
|
|
return "Association Response"
|
|
elif dot11.subtype == 10:
|
|
return "Disassociation"
|
|
else:
|
|
return f"Management ({dot11.subtype})"
|
|
elif dot11.type == 1: # Control
|
|
return f"Control ({dot11.subtype})"
|
|
elif dot11.type == 2: # Data
|
|
if dot11.subtype == 8:
|
|
return "QoS Data"
|
|
elif dot11.subtype == 0:
|
|
return "Data"
|
|
else:
|
|
return f"Data ({dot11.subtype})"
|
|
else:
|
|
return f"Unknown ({dot11.type}/{dot11.subtype})"
|
|
|
|
@staticmethod
|
|
def ra_ta(pkt):
|
|
"""Extract RA and TA from 802.11 frame."""
|
|
if not pkt.haslayer(Dot11):
|
|
return None, None
|
|
|
|
dot11 = pkt[Dot11]
|
|
|
|
ra = dot11.addr1 if hasattr(dot11, 'addr1') else None
|
|
ta = dot11.addr2 if hasattr(dot11, 'addr2') else None
|
|
|
|
if ra:
|
|
ra = ra.lower() if isinstance(ra, str) else ':'.join(f'{b:02x}' for b in ra)
|
|
if ta:
|
|
ta = ta.lower() if isinstance(ta, str) else ':'.join(f'{b:02x}' for b in ta)
|
|
|
|
return ra, ta
|
|
|
|
@staticmethod
|
|
def phy_info(pkt):
|
|
"""Extract PHY rate and MCS from packet (if available in radiotap)."""
|
|
phy_rate = None
|
|
mcs = None
|
|
|
|
if pkt.haslayer(RadioTap):
|
|
radiotap = pkt[RadioTap]
|
|
if hasattr(radiotap, 'Rate'):
|
|
rate_val = radiotap.Rate
|
|
if rate_val:
|
|
phy_rate = rate_val * 0.5 # Convert to Mbps
|
|
if hasattr(radiotap, 'MCS'):
|
|
mcs_data = radiotap.MCS
|
|
if mcs_data and hasattr(mcs_data, 'index'):
|
|
mcs = mcs_data.index
|
|
|
|
return phy_rate, mcs
|
|
|
|
|
|
class CaptureAnalyzer:
|
|
"""Analyzes packet captures and generates statistics."""
|
|
def __init__(self, parser):
|
|
self.parser = parser
|
|
|
|
def analyze(self, packets, duration):
|
|
"""Analyze captured packets and generate statistics."""
|
|
print("\n=== Capture Statistics ===")
|
|
|
|
total_count = len(packets)
|
|
print(f"Total packets captured: {total_count}")
|
|
|
|
if total_count == 0:
|
|
self._print_no_packets_message()
|
|
return
|
|
|
|
plcp_count = sum(1 for pkt in packets if pkt.haslayer(RadioTap))
|
|
print(f"PLCP headers: {plcp_count}")
|
|
|
|
if total_count > 0:
|
|
rate = total_count / duration
|
|
print(f"Packet rate: {rate:.1f} packets/second")
|
|
print()
|
|
|
|
self._print_sample_packets(packets)
|
|
self._print_ra_ta_pairs(packets)
|
|
self._print_phy_histograms(packets)
|
|
self._print_frame_type_breakdown(packets)
|
|
self._print_data_frame_analysis(packets)
|
|
self._print_server_mac_analysis(packets)
|
|
self._print_summary(total_count, plcp_count)
|
|
|
|
def _print_no_packets_message(self):
|
|
"""Print message when no packets are captured."""
|
|
print("\n(No packets captured)")
|
|
print("\n=== Summary ===")
|
|
print("✗ No packets captured. Check:")
|
|
print(f" 1. Is there WiFi traffic on the channel?")
|
|
print(f" 2. Is the interface actually in monitor mode?")
|
|
print(f" 3. Try a different channel or longer duration")
|
|
|
|
def _print_sample_packets(self, packets):
|
|
"""Print sample packets."""
|
|
print("Sample packets (first 10):")
|
|
for i, pkt in enumerate(packets[:10]):
|
|
ra, ta = self.parser.ra_ta(pkt)
|
|
ra_str = ra if ra else "N/A"
|
|
ta_str = ta if ta else "N/A"
|
|
|
|
frame_type = self.parser.frame_type_name(pkt)
|
|
|
|
encrypted = "encrypted" if (pkt.haslayer(Dot11) and pkt[Dot11].FCfield & 0x40) else "unencrypted"
|
|
|
|
retry = " [retry]" if (pkt.haslayer(Dot11) and pkt[Dot11].FCfield & 0x08) else ""
|
|
|
|
duration_val = "N/A"
|
|
if pkt.haslayer(Dot11):
|
|
duration_val = pkt[Dot11].Duration if hasattr(pkt[Dot11], 'Duration') else "N/A"
|
|
|
|
plcp = "yes" if pkt.haslayer(RadioTap) else "no"
|
|
|
|
print(f" Frame {i+1}: RA={ra_str}, TA={ta_str}, type={frame_type}, {encrypted}, dur={duration_val}, PLCP={plcp}{retry}")
|
|
print()
|
|
|
|
def _print_ra_ta_pairs(self, packets):
|
|
"""Print unique RA/TA pairs."""
|
|
print("Unique RA/TA pairs (with counts):")
|
|
ra_ta_pairs = Counter()
|
|
for pkt in packets:
|
|
ra, ta = self.parser.ra_ta(pkt)
|
|
if ra or ta:
|
|
ra_str = ra if ra else "N/A"
|
|
ta_str = ta if ta else "N/A"
|
|
pair = f"{ra_str} -> {ta_str}"
|
|
ra_ta_pairs[pair] += 1
|
|
|
|
if ra_ta_pairs:
|
|
for pair, count in ra_ta_pairs.most_common():
|
|
print(f" {pair}: {count} frame(s)")
|
|
else:
|
|
print(" (no valid RA/TA pairs found)")
|
|
print()
|
|
|
|
def _print_phy_histograms(self, packets):
|
|
"""Print PHY rate and MCS histograms per RA/TA pair."""
|
|
print("PHY Rate and MCS Histograms per RA/TA pair:")
|
|
rate_histograms = defaultdict(Counter)
|
|
mcs_histograms = defaultdict(Counter)
|
|
|
|
for pkt in packets:
|
|
ra, ta = self.parser.ra_ta(pkt)
|
|
if not (ra or ta):
|
|
continue
|
|
|
|
if not pkt.haslayer(Dot11) or pkt[Dot11].type != 2:
|
|
continue
|
|
|
|
ra_str = ra if ra else "N/A"
|
|
ta_str = ta if ta else "N/A"
|
|
pair = f"{ra_str} -> {ta_str}"
|
|
|
|
phy_rate, mcs = self.parser.phy_info(pkt)
|
|
if phy_rate:
|
|
rate_histograms[pair][phy_rate] += 1
|
|
if mcs is not None:
|
|
mcs_histograms[pair][mcs] += 1
|
|
|
|
for pair in sorted(set(list(rate_histograms.keys()) + list(mcs_histograms.keys()))):
|
|
print(f"\n {pair}:")
|
|
|
|
print(" PHY Rate (Mbps):")
|
|
if pair in rate_histograms:
|
|
for rate in sorted(rate_histograms[pair].keys()):
|
|
print(f" {rate} Mbps: {rate_histograms[pair][rate]} frame(s)")
|
|
else:
|
|
print(" (no PHY rate data)")
|
|
|
|
print(" MCS Index:")
|
|
if pair in mcs_histograms:
|
|
for mcs_val in sorted(mcs_histograms[pair].keys()):
|
|
print(f" MCS {mcs_val}: {mcs_histograms[pair][mcs_val]} frame(s)")
|
|
else:
|
|
print(" (no MCS data)")
|
|
print()
|
|
|
|
def _print_frame_type_breakdown(self, packets):
|
|
"""Print frame type breakdown."""
|
|
print("Frame type breakdown:")
|
|
frame_types = Counter()
|
|
for pkt in packets:
|
|
if pkt.haslayer(Dot11):
|
|
dot11 = pkt[Dot11]
|
|
if dot11.type == 0:
|
|
frame_types["Management"] += 1
|
|
elif dot11.type == 1:
|
|
frame_types["Control"] += 1
|
|
elif dot11.type == 2:
|
|
frame_types["Data"] += 1
|
|
else:
|
|
frame_types["Unknown"] += 1
|
|
|
|
for frame_type, count in frame_types.most_common():
|
|
print(f" {frame_type}: {count} frame(s)")
|
|
print()
|
|
|
|
def _print_data_frame_analysis(self, packets):
|
|
"""Print data frame analysis."""
|
|
print("Data frame analysis (iperf typically uses QoS Data frames, subtype 8):")
|
|
qos_data_frames = [pkt for pkt in packets if pkt.haslayer(Dot11) and pkt[Dot11].type == 2 and pkt[Dot11].subtype == 8]
|
|
qos_count = len(qos_data_frames)
|
|
print(f" QoS Data frames (type 2, subtype 8): {qos_count}")
|
|
|
|
encrypted_count = sum(1 for pkt in qos_data_frames if pkt.haslayer(Dot11) and pkt[Dot11].FCfield & 0x40)
|
|
unencrypted_count = qos_count - encrypted_count
|
|
print(f" Encrypted: {encrypted_count}")
|
|
print(f" Unencrypted: {unencrypted_count}")
|
|
|
|
if qos_count > 0:
|
|
print(" Sample QoS Data frames (likely iperf traffic):")
|
|
for i, pkt in enumerate(qos_data_frames[:5]):
|
|
ra, ta = self.parser.ra_ta(pkt)
|
|
ra_str = ra if ra else "N/A"
|
|
ta_str = ta if ta else "N/A"
|
|
encrypted = "encrypted" if (pkt.haslayer(Dot11) and pkt[Dot11].FCfield & 0x40) else "unencrypted"
|
|
retry = " [retry]" if (pkt.haslayer(Dot11) and pkt[Dot11].FCfield & 0x08) else ""
|
|
duration_val = pkt[Dot11].Duration if pkt.haslayer(Dot11) and hasattr(pkt[Dot11], 'Duration') else "N/A"
|
|
print(f" Frame {i+1}: RA={ra_str}, TA={ta_str}, {encrypted}, dur={duration_val}{retry}")
|
|
print()
|
|
|
|
def _print_server_mac_analysis(self, packets):
|
|
"""Print analysis of frames involving server MAC."""
|
|
server_mac = "80:84:89:93:c4:b6"
|
|
print(f"Frames involving server MAC ({server_mac}):")
|
|
server_frames = []
|
|
for pkt in packets:
|
|
ra, ta = self.parser.ra_ta(pkt)
|
|
if (ra and ra.lower() == server_mac.lower()) or (ta and ta.lower() == server_mac.lower()):
|
|
server_frames.append(pkt)
|
|
|
|
server_count = len(server_frames)
|
|
print(f" Total frames with server MAC: {server_count}")
|
|
if server_count > 0:
|
|
server_frame_types = Counter()
|
|
for pkt in server_frames:
|
|
if pkt.haslayer(Dot11):
|
|
dot11 = pkt[Dot11]
|
|
if dot11.type == 0:
|
|
server_frame_types["Management"] += 1
|
|
elif dot11.type == 1:
|
|
server_frame_types["Control"] += 1
|
|
elif dot11.type == 2:
|
|
server_frame_types["Data"] += 1
|
|
|
|
print(" Frame type breakdown:")
|
|
for frame_type, count in server_frame_types.most_common():
|
|
print(f" {frame_type}: {count} frame(s)")
|
|
|
|
print(" Sample frames:")
|
|
for i, pkt in enumerate(server_frames[:5]):
|
|
ra, ta = self.parser.ra_ta(pkt)
|
|
ra_str = ra if ra else "N/A"
|
|
ta_str = ta if ta else "N/A"
|
|
frame_type = self.parser.frame_type_name(pkt)
|
|
encrypted = "encrypted" if (pkt.haslayer(Dot11) and pkt[Dot11].FCfield & 0x40) else "unencrypted"
|
|
retry = " [retry]" if (pkt.haslayer(Dot11) and pkt[Dot11].FCfield & 0x08) else ""
|
|
duration_val = pkt[Dot11].Duration if pkt.haslayer(Dot11) and hasattr(pkt[Dot11], 'Duration') else "N/A"
|
|
print(f" Frame {i+1}: RA={ra_str}, TA={ta_str}, type={frame_type}, {encrypted}, dur={duration_val}{retry}")
|
|
print()
|
|
|
|
def _print_summary(self, total_count, plcp_count):
|
|
"""Print summary statistics."""
|
|
print("=== Summary ===")
|
|
if total_count > 0:
|
|
print(f"✓ Monitor mode is working! Captured {total_count} packet(s)")
|
|
if plcp_count > 0:
|
|
print(f"✓ PLCP headers detected: {plcp_count} packet(s) with radiotap information")
|
|
else:
|
|
print("⚠ No PLCP headers detected (may be using DLT_IEEE802_11 instead of DLT_IEEE802_11_RADIO)")
|
|
|
|
|
|
class PacketCapture:
|
|
"""Handles packet capture operations."""
|
|
def __init__(self, config):
|
|
self.config = config
|
|
self.parser = PacketParser()
|
|
self.analyzer = CaptureAnalyzer(self.parser)
|
|
|
|
def capture_from_pcap(self, pcap_file):
|
|
"""Read and analyze packets from a PCAP file."""
|
|
print("=== Reading packets from PCAP file ===")
|
|
print(f"PCAP file: {pcap_file}")
|
|
print()
|
|
|
|
try:
|
|
packets = rdpcap(pcap_file)
|
|
print(f"Loaded {len(packets)} packets from {pcap_file}")
|
|
|
|
file_size = os.path.getsize(pcap_file)
|
|
print(f"File size: {file_size} bytes")
|
|
print()
|
|
|
|
self.analyzer.analyze(packets, 1.0)
|
|
return 0
|
|
except OSError as e:
|
|
print(f"Error reading PCAP file: {e}")
|
|
return 1
|
|
except Exception as e:
|
|
print(f"Error reading PCAP file: {e}")
|
|
import traceback
|
|
traceback.print_exc()
|
|
return 1
|
|
|
|
def capture_live(self, interface, channel, duration):
|
|
"""Capture packets from a live interface."""
|
|
return asyncio.run(self._capture_live_async(interface, channel, duration))
|
|
|
|
async def _capture_live_async(self, interface, channel, duration):
|
|
"""Async implementation of live capture."""
|
|
print("=== Testing Monitor Mode with scapy ===")
|
|
print(f"Interface: {interface}")
|
|
print(f"Channel: {channel}")
|
|
print(f"Duration: {duration} seconds")
|
|
print()
|
|
|
|
monitor = WiFiMonitor(interface, channel)
|
|
if not await monitor.start():
|
|
if monitor.error_message:
|
|
print(monitor.error_message)
|
|
return 1
|
|
|
|
try:
|
|
if not await self._test_capture_async(interface):
|
|
return 1
|
|
|
|
return await self._main_capture_async(interface, duration)
|
|
finally:
|
|
await monitor.stop()
|
|
|
|
async def _test_capture_async(self, interface):
|
|
"""Perform a test capture to verify monitor mode (async)."""
|
|
print("\nChecking Data Link Type (1 second test capture)...")
|
|
print("(This may take up to 2 seconds if no packets are present)")
|
|
|
|
test_packets = []
|
|
try:
|
|
# Run blocking sniff in executor
|
|
loop = asyncio.get_event_loop()
|
|
await loop.run_in_executor(
|
|
None,
|
|
lambda: sniff(iface=interface, prn=lambda pkt: test_packets.append(pkt), timeout=1, store=False, snaplen=self.config.snaplen)
|
|
)
|
|
except OSError as e:
|
|
print(f"Error during test capture (system error): {e}")
|
|
return False
|
|
except Exception as e:
|
|
print(f"Error during test capture: {e}")
|
|
return False
|
|
|
|
test_count = len(test_packets)
|
|
test_plcp = sum(1 for pkt in test_packets if pkt.haslayer(RadioTap))
|
|
|
|
if test_count > 0:
|
|
print("Sample packets:")
|
|
for i, pkt in enumerate(test_packets[:5]):
|
|
ra, ta = self.parser.ra_ta(pkt)
|
|
ra_str = ra if ra else "N/A"
|
|
ta_str = ta if ta else "N/A"
|
|
plcp = "yes" if pkt.haslayer(RadioTap) else "no"
|
|
print(f" Frame {i+1 if i > 0 else test_count}: RA={ra_str}, TA={ta_str}, PLCP={plcp}")
|
|
|
|
print(f"\nTest capture results:")
|
|
print(f" Packets captured: {test_count}")
|
|
print(f" PLCP headers: {test_plcp}")
|
|
if test_plcp == 0 and test_count > 0:
|
|
print(" Note: Packets captured but no radiotap headers (may be using DLT_IEEE802_11 instead of DLT_IEEE802_11_RADIO)")
|
|
|
|
return True
|
|
|
|
async def _main_capture_async(self, interface, duration):
|
|
"""Perform the main packet capture (async)."""
|
|
print(f"\n=== Starting scapy capture ({duration} seconds) ===")
|
|
print("Press Ctrl+C to stop early\n")
|
|
|
|
if self.config.full_packet:
|
|
print("Capturing full packets...")
|
|
else:
|
|
print(f"Capturing packets (snaplen={self.config.snaplen} bytes, header + some payload)...")
|
|
|
|
packets = []
|
|
pcap_path = None
|
|
|
|
if self.config.keep_pcap:
|
|
pcap_file = tempfile.NamedTemporaryFile(delete=False, suffix='.pcap', prefix='scapy_capture_')
|
|
pcap_path = pcap_file.name
|
|
pcap_file.close()
|
|
print(f"Capturing to file: {pcap_path}")
|
|
|
|
capture_error = None
|
|
try:
|
|
# Run blocking sniff in executor
|
|
loop = asyncio.get_event_loop()
|
|
if self.config.keep_pcap:
|
|
await loop.run_in_executor(
|
|
None,
|
|
lambda: sniff(iface=interface, prn=lambda pkt: packets.append(pkt), timeout=duration, store=True, snaplen=self.config.snaplen)
|
|
)
|
|
await loop.run_in_executor(None, lambda: wrpcap(pcap_path, packets))
|
|
print(f"Pcap file size: {os.path.getsize(pcap_path)} bytes")
|
|
print(f"Keeping pcap file: {pcap_path}")
|
|
print(f" (Use: python3 wifi_monitor.py {pcap_path} to analyze)")
|
|
else:
|
|
await loop.run_in_executor(
|
|
None,
|
|
lambda: sniff(iface=interface, prn=lambda pkt: packets.append(pkt), timeout=duration, store=True, snaplen=self.config.snaplen)
|
|
)
|
|
except KeyboardInterrupt:
|
|
print("\nCapture interrupted by user")
|
|
except OSError as e:
|
|
capture_error = e
|
|
print(f"\nError during capture (system error): {e}")
|
|
except Exception as e:
|
|
capture_error = e
|
|
print(f"\nError during capture: {e}")
|
|
import traceback
|
|
traceback.print_exc()
|
|
|
|
self.analyzer.analyze(packets, duration)
|
|
|
|
if capture_error:
|
|
return 1
|
|
return 0
|
|
|
|
|
|
class ArgumentParser:
|
|
"""Handles command line argument parsing."""
|
|
def __init__(self, config):
|
|
self.config = config
|
|
|
|
def parse(self):
|
|
"""Parse command line arguments."""
|
|
args = sys.argv[1:]
|
|
|
|
args = self._process_flags(args)
|
|
|
|
if len(args) == 0:
|
|
# Use defaults: wlan0, channel 36, 10 seconds
|
|
return self._parse_live_mode([])
|
|
|
|
if self._is_pcap_file(args):
|
|
return self._parse_pcap_mode(args)
|
|
|
|
return self._parse_live_mode(args)
|
|
|
|
def _print_usage(self):
|
|
"""Print usage information."""
|
|
print("Usage:")
|
|
print(" Live capture: sudo python3 wifi_monitor.py [interface] [channel] [duration] [--keep-pcap] [--full-packet]")
|
|
print(" Defaults: wlan0, channel 36, 10 seconds")
|
|
print(" Read pcap: python3 wifi_monitor.py <pcap_file>")
|
|
|
|
def _process_flags(self, args):
|
|
"""Process command line flags."""
|
|
if "--keep-pcap" in args or "-k" in args:
|
|
self.config.keep_pcap = True
|
|
args = [a for a in args if a not in ["--keep-pcap", "-k"]]
|
|
|
|
if "--full-packet" in args or "-f" in args:
|
|
self.config.full_packet = True
|
|
args = [a for a in args if a not in ["--full-packet", "-f"]]
|
|
|
|
return args
|
|
|
|
def _is_pcap_file(self, args):
|
|
"""Check if first argument is a PCAP file."""
|
|
return len(args) > 0 and (args[0].endswith('.pcap') or args[0].endswith('.cap'))
|
|
|
|
def _parse_pcap_mode(self, args):
|
|
"""Parse arguments for PCAP file mode."""
|
|
pcap_file = args[0]
|
|
if not os.path.isfile(pcap_file):
|
|
print(f"Error: PCAP file not found: {pcap_file}")
|
|
return None
|
|
return ('pcap', pcap_file, None, None)
|
|
|
|
def _parse_live_mode(self, args):
|
|
"""Parse arguments for live capture mode."""
|
|
if len(args) > 0:
|
|
if args[0].startswith("wl") and len(args[0]) <= 6:
|
|
self.config.wifi_interface = args[0]
|
|
channel = int(args[1]) if len(args) > 1 else 36
|
|
duration = int(args[2]) if len(args) > 2 else 10
|
|
else:
|
|
channel = int(args[0]) if len(args) > 0 else 36
|
|
duration = int(args[1]) if len(args) > 1 else 10
|
|
else:
|
|
channel = 36
|
|
duration = 10
|
|
|
|
return ('live', self.config.wifi_interface, channel, duration)
|
|
|
|
|
|
def main():
|
|
"""Main function with single exit point."""
|
|
exit_code = 0
|
|
|
|
config = Config()
|
|
arg_parser = ArgumentParser(config)
|
|
parsed_args = arg_parser.parse()
|
|
|
|
if parsed_args is None:
|
|
exit_code = 1
|
|
else:
|
|
mode, interface_or_pcap, channel, duration = parsed_args
|
|
capture = PacketCapture(config)
|
|
|
|
if mode == 'pcap':
|
|
exit_code = capture.capture_from_pcap(interface_or_pcap)
|
|
else:
|
|
exit_code = capture.capture_live(interface_or_pcap, channel, duration)
|
|
|
|
return exit_code
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|