WifiForge Cheat Sheet

Overview

WifiForge is a comprehensive wireless security training and testing tool developed by Black Hills Information Security (BHIS) to provide hands-on experience with Wi-Fi attack vectors and defensive techniques. Designed specifically for educational purposes and penetration testing training, WifiForge creates controlled environments where security professionals can safely learn and practice wireless security assessment techniques without impacting production networks. The tool encompasses a wide range of wireless attack scenarios, from basic reconnaissance to advanced exploitation techniques.

The primary objective of WifiForge is to bridge the gap between theoretical knowledge and practical application in wireless security. By providing realistic attack scenarios and vulnerable wireless configurations, the tool enables security professionals to develop practical skills in identifying, exploiting, and defending against wireless security vulnerabilities. WifiForge includes modules for various wireless protocols, encryption methods, and attack vectors commonly encountered in real-world penetration testing engagements.

WifiForge stands out in the wireless security training landscape by offering structured learning paths that progress from basic concepts to advanced techniques. The tool includes comprehensive documentation, step-by-step tutorials, and practical exercises that help users understand not only how to execute attacks but also how to detect and prevent them. This dual focus on offensive and defensive techniques makes WifiForge an invaluable resource for building comprehensive wireless security expertise.

Installation

Git Installation

Installing WifiForge from the official repository:

# Clone WifiForge repository
git clone https://github.com/blackhillsinfosec/wififorge.git
cd wififorge

# Install dependencies
sudo apt update
sudo apt install python3 python3-pip aircrack-ng hostapd dnsmasq

# Install Python requirements
pip3 install -r requirements.txt

# Make scripts executable
chmod +x *.py
chmod +x scripts/*.sh

# Verify installation
python3 wififorge.py --help

Docker Installation

# Build WifiForge Docker container
cat > Dockerfile << 'EOF'
FROM kalilinux/kali-rolling
RUN apt-get update && apt-get install -y \
    python3 python3-pip git \
    aircrack-ng hostapd dnsmasq \
    wireless-tools net-tools
WORKDIR /opt/wififorge
COPY . .
RUN pip3 install -r requirements.txt
CMD ["/bin/bash"]
EOF

# Build container
docker build -t wififorge .

# Run with network privileges
docker run -it --privileged --net=host wififorge

# Mount workspace
docker run -it --privileged --net=host -v $(pwd):/workspace wififorge

Virtual Machine Setup

# Download WifiForge VM (if available)
wget https://example.com/wififorge-vm.ova

# Import into VirtualBox
VBoxManage import wififorge-vm.ova

# Configure VM network settings
VBoxManage modifyvm "WifiForge" --nic1 bridged --bridgeadapter1 wlan0

# Start VM
VBoxManage startvm "WifiForge"

Basic Usage

Environment Setup

Setting up WifiForge training environment:

# Initialize WifiForge environment
python3 wififorge.py --init

# Check wireless interfaces
python3 wififorge.py --list-interfaces

# Set up training interface
python3 wififorge.py --setup-interface wlan1

# Create training network
python3 wififorge.py --create-network "TrainingNet" --security WPA2

# Start training environment
python3 wififorge.py --start-environment

Training Modules

Accessing WifiForge training modules:

# List available modules
python3 wififorge.py --list-modules

# Start basic reconnaissance module
python3 wififorge.py --module recon --level basic

# Start WEP cracking module
python3 wififorge.py --module wep-crack --level intermediate

# Start WPA/WPA2 module
python3 wififorge.py --module wpa-crack --level advanced

# Start evil twin module
python3 wififorge.py --module evil-twin --level expert

Scenario Management

Managing training scenarios:

# Create custom scenario
python3 wififorge.py --create-scenario "Corporate Assessment"

# Load predefined scenario
python3 wififorge.py --load-scenario "Hotel WiFi"

# Configure scenario parameters
python3 wififorge.py --scenario-config --clients 5 --aps 3

# Start scenario
python3 wififorge.py --start-scenario "Corporate Assessment"

# Monitor scenario progress
python3 wififorge.py --monitor-scenario

Training Modules

Reconnaissance Module

Wireless reconnaissance training:

# Basic scanning techniques
python3 wififorge.py --module recon --exercise "basic-scan"

# Advanced scanning with airodump-ng
python3 wififorge.py --module recon --exercise "advanced-scan"

# Client identification
python3 wififorge.py --module recon --exercise "client-enum"

# Hidden SSID discovery
python3 wififorge.py --module recon --exercise "hidden-ssid"

# Wireless mapping
python3 wififorge.py --module recon --exercise "wireless-mapping"

WEP Cracking Module

WEP security assessment training:

# WEP vulnerability overview
python3 wififorge.py --module wep --exercise "vulnerability-analysis"

# ARP replay attack
python3 wififorge.py --module wep --exercise "arp-replay"

# Fragmentation attack
python3 wififorge.py --module wep --exercise "fragmentation"

# Chopchop attack
python3 wififorge.py --module wep --exercise "chopchop"

# Statistical analysis
python3 wififorge.py --module wep --exercise "statistical-crack"

WPA/WPA2 Cracking Module

WPA/WPA2 security assessment training:

# Handshake capture
python3 wififorge.py --module wpa --exercise "handshake-capture"

# Dictionary attack
python3 wififorge.py --module wpa --exercise "dictionary-attack"

# Brute force attack
python3 wififorge.py --module wpa --exercise "brute-force"

# Rainbow table attack
python3 wififorge.py --module wpa --exercise "rainbow-tables"

# GPU acceleration
python3 wififorge.py --module wpa --exercise "gpu-cracking"

Evil Twin Module

Rogue access point training:

# Basic evil twin setup
python3 wififorge.py --module evil-twin --exercise "basic-setup"

# Captive portal creation
python3 wififorge.py --module evil-twin --exercise "captive-portal"

# SSL stripping
python3 wififorge.py --module evil-twin --exercise "ssl-strip"

# Credential harvesting
python3 wififorge.py --module evil-twin --exercise "credential-harvest"

# Advanced evasion
python3 wififorge.py --module evil-twin --exercise "evasion-techniques"

Advanced Features

Custom Attack Scenarios

Creating custom attack scenarios:

# Scenario configuration file
cat > custom_scenario.json << 'EOF'
{
  "name": "Enterprise Assessment",
  "description": "Corporate wireless security assessment",
  "networks": [
    {
      "ssid": "CorpWiFi",
      "security": "WPA2-Enterprise",
      "channel": 6,
      "clients": 10
    },
    {
      "ssid": "Guest",
      "security": "Open",
      "channel": 11,
      "clients": 5
    }
  ],
  "objectives": [
    "Identify all wireless networks",
    "Capture authentication credentials",
    "Demonstrate lateral movement"
  ]
}
EOF

# Load custom scenario
python3 wififorge.py --load-scenario custom_scenario.json

# Execute scenario
python3 wififorge.py --execute-scenario

Automated Assessment

Automated wireless security assessment:

# Full automated assessment
python3 wififorge.py --auto-assess --target "all"

# Targeted assessment
python3 wififorge.py --auto-assess --target "WPA2" --wordlist rockyou.txt

# Time-limited assessment
python3 wififorge.py --auto-assess --timeout 3600

# Stealth assessment
python3 wififorge.py --auto-assess --stealth --delay 30

# Report generation
python3 wififorge.py --auto-assess --report-format html

Defensive Training

Defensive wireless security training:

# Intrusion detection
python3 wififorge.py --module defense --exercise "ids-setup"

# Rogue AP detection
python3 wififorge.py --module defense --exercise "rogue-detection"

# Monitoring and alerting
python3 wififorge.py --module defense --exercise "monitoring"

# Incident response
python3 wififorge.py --module defense --exercise "incident-response"

# Hardening techniques
python3 wififorge.py --module defense --exercise "hardening"

Automation Scripts

Training Environment Automation

#!/bin/bash
# WifiForge training environment automation

WIFIFORGE_DIR="/opt/wififorge"
TRAINING_INTERFACE="wlan1"
SCENARIO="corporate-assessment"

echo "Setting up WifiForge training environment"

# Navigate to WifiForge directory
cd $WIFIFORGE_DIR

# Check prerequisites
echo "Checking prerequisites..."
if ! command -v aircrack-ng &> /dev/null; then
    echo "Installing aircrack-ng..."
    sudo apt install -y aircrack-ng
fi

if ! command -v hostapd &> /dev/null; then
    echo "Installing hostapd..."
    sudo apt install -y hostapd
fi

# Setup training interface
echo "Setting up training interface: $TRAINING_INTERFACE"
python3 wififorge.py --setup-interface $TRAINING_INTERFACE

# Create training networks
echo "Creating training networks..."
python3 wififorge.py --create-network "VulnWEP" --security WEP --channel 1
python3 wififorge.py --create-network "VulnWPA" --security WPA2 --channel 6 --password "password123"
python3 wififorge.py --create-network "OpenGuest" --security Open --channel 11

# Start training scenario
echo "Starting training scenario: $SCENARIO"
python3 wififorge.py --load-scenario $SCENARIO
python3 wififorge.py --start-scenario $SCENARIO

# Monitor training progress
echo "Monitoring training progress..."
python3 wififorge.py --monitor-scenario &
MONITOR_PID=$!

# Wait for user input to stop
echo "Training environment is running. Press Enter to stop..."
read

# Stop training environment
echo "Stopping training environment..."
kill $MONITOR_PID
python3 wififorge.py --stop-scenario $SCENARIO
python3 wififorge.py --cleanup

echo "Training environment stopped"

Assessment Automation

#!/usr/bin/env python3
# WifiForge automated assessment script

import subprocess
import json
import time
from datetime import datetime

class WifiForgeAssessment:
    def __init__(self, config_file="assessment_config.json"):
        self.config = self.load_config(config_file)
        self.results = {}
        self.start_time = datetime.now()
    
    def load_config(self, config_file):
        """Load assessment configuration"""
        try:
            with open(config_file, 'r') as f:
                return json.load(f)
        except FileNotFoundError:
            # Default configuration
            return {
                "modules": ["recon", "wep", "wpa", "evil-twin"],
                "timeout": 3600,
                "stealth": True,
                "report_format": "html"
            }
    
    def run_module(self, module_name, exercises=None):
        """Run specific WifiForge module"""
        if exercises is None:
            exercises = ["all"]
        
        module_results = {}
        
        for exercise in exercises:
            print(f"Running {module_name} module - {exercise}")
            
            cmd = [
                "python3", "wififorge.py",
                "--module", module_name,
                "--exercise", exercise,
                "--json-output"
            ]
            
            try:
                result = subprocess.run(cmd, capture_output=True, text=True, timeout=600)
                
                if result.returncode == 0:
                    exercise_data = json.loads(result.stdout)
                    module_results[exercise] = {
                        "status": "success",
                        "data": exercise_data,
                        "timestamp": datetime.now().isoformat()
                    }
                else:
                    module_results[exercise] = {
                        "status": "failed",
                        "error": result.stderr,
                        "timestamp": datetime.now().isoformat()
                    }
                    
            except subprocess.TimeoutExpired:
                module_results[exercise] = {
                    "status": "timeout",
                    "timestamp": datetime.now().isoformat()
                }
            except Exception as e:
                module_results[exercise] = {
                    "status": "error",
                    "error": str(e),
                    "timestamp": datetime.now().isoformat()
                }
        
        return module_results
    
    def run_reconnaissance(self):
        """Run reconnaissance module"""
        exercises = ["basic-scan", "advanced-scan", "client-enum", "hidden-ssid"]
        return self.run_module("recon", exercises)
    
    def run_wep_assessment(self):
        """Run WEP assessment module"""
        exercises = ["vulnerability-analysis", "arp-replay", "statistical-crack"]
        return self.run_module("wep", exercises)
    
    def run_wpa_assessment(self):
        """Run WPA/WPA2 assessment module"""
        exercises = ["handshake-capture", "dictionary-attack", "brute-force"]
        return self.run_module("wpa", exercises)
    
    def run_evil_twin_assessment(self):
        """Run evil twin assessment module"""
        exercises = ["basic-setup", "captive-portal", "credential-harvest"]
        return self.run_module("evil-twin", exercises)
    
    def run_full_assessment(self):
        """Run complete wireless security assessment"""
        print("Starting comprehensive wireless security assessment")
        
        # Run all modules
        if "recon" in self.config["modules"]:
            self.results["reconnaissance"] = self.run_reconnaissance()
        
        if "wep" in self.config["modules"]:
            self.results["wep_assessment"] = self.run_wep_assessment()
        
        if "wpa" in self.config["modules"]:
            self.results["wpa_assessment"] = self.run_wpa_assessment()
        
        if "evil-twin" in self.config["modules"]:
            self.results["evil_twin"] = self.run_evil_twin_assessment()
        
        # Generate report
        self.generate_report()
        
        print("Assessment completed")
    
    def generate_report(self):
        """Generate assessment report"""
        report = {
            "assessment_info": {
                "start_time": self.start_time.isoformat(),
                "end_time": datetime.now().isoformat(),
                "duration": str(datetime.now() - self.start_time),
                "modules_tested": list(self.results.keys())
            },
            "results": self.results,
            "summary": self.generate_summary()
        }
        
        # Save JSON report
        with open("wififorge_assessment_report.json", "w") as f:
            json.dump(report, f, indent=2)
        
        # Generate HTML report if requested
        if self.config.get("report_format") == "html":
            self.generate_html_report(report)
        
        print("Report generated: wififorge_assessment_report.json")
    
    def generate_summary(self):
        """Generate assessment summary"""
        summary = {
            "total_modules": len(self.results),
            "successful_exercises": 0,
            "failed_exercises": 0,
            "vulnerabilities_found": []
        }
        
        for module, exercises in self.results.items():
            for exercise, result in exercises.items():
                if result["status"] == "success":
                    summary["successful_exercises"] += 1
                    # Check for vulnerabilities
                    if "vulnerabilities" in result.get("data", {}):
                        summary["vulnerabilities_found"].extend(result["data"]["vulnerabilities"])
                else:
                    summary["failed_exercises"] += 1
        
        return summary
    
    def generate_html_report(self, report_data):
        """Generate HTML assessment report"""
        html_template = """
        <!DOCTYPE html>
        <html>
        <head>
            <title>WifiForge Assessment Report</title>
            <style>
                body { font-family: Arial, sans-serif; margin: 20px; }
                .header { background-color: #f0f0f0; padding: 20px; }
                .module { margin: 20px 0; border: 1px solid #ccc; padding: 15px; }
                .success { color: green; }
                .failed { color: red; }
                .timeout { color: orange; }
            </style>
        </head>
        <body>
            <div class="header">
                <h1>WifiForge Wireless Security Assessment Report</h1>
                <p>Generated: {timestamp}</p>
                <p>Duration: {duration}</p>
            </div>
            
            <div class="summary">
                <h2>Executive Summary</h2>
                <p>Total Modules Tested: {total_modules}</p>
                <p>Successful Exercises: {successful_exercises}</p>
                <p>Failed Exercises: {failed_exercises}</p>
            </div>
            
            <div class="results">
                <h2>Detailed Results</h2>
                {module_results}
            </div>
        </body>
        </html>
        """
        
        # Format module results
        module_html = ""
        for module, exercises in report_data["results"].items():
            module_html += f"<div class='module'><h3>{module.title()}</h3>"
            for exercise, result in exercises.items():
                status_class = result["status"]
                module_html += f"<p class='{status_class}'>{exercise}: {result['status']}</p>"
            module_html += "</div>"
        
        # Fill template
        html_content = html_template.format(
            timestamp=report_data["assessment_info"]["end_time"],
            duration=report_data["assessment_info"]["duration"],
            total_modules=report_data["summary"]["total_modules"],
            successful_exercises=report_data["summary"]["successful_exercises"],
            failed_exercises=report_data["summary"]["failed_exercises"],
            module_results=module_html
        )
        
        with open("wififorge_assessment_report.html", "w") as f:
            f.write(html_content)
        
        print("HTML report generated: wififorge_assessment_report.html")

# Usage
if __name__ == "__main__":
    assessment = WifiForgeAssessment()
    assessment.run_full_assessment()

Training Progress Tracker

#!/usr/bin/env python3
# WifiForge training progress tracker

import json
import sqlite3
from datetime import datetime

class WifiForgeTracker:
    def __init__(self, db_file="wififorge_progress.db"):
        self.db_file = db_file
        self.init_database()
    
    def init_database(self):
        """Initialize progress tracking database"""
        conn = sqlite3.connect(self.db_file)
        cursor = conn.cursor()
        
        cursor.execute("""
            CREATE TABLE IF NOT EXISTS training_sessions (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                user_id TEXT,
                module TEXT,
                exercise TEXT,
                start_time TEXT,
                end_time TEXT,
                status TEXT,
                score INTEGER,
                notes TEXT
            )
        """)
        
        cursor.execute("""
            CREATE TABLE IF NOT EXISTS achievements (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                user_id TEXT,
                achievement TEXT,
                earned_date TEXT,
                description TEXT
            )
        """)
        
        conn.commit()
        conn.close()
    
    def start_session(self, user_id, module, exercise):
        """Start new training session"""
        conn = sqlite3.connect(self.db_file)
        cursor = conn.cursor()
        
        cursor.execute("""
            INSERT INTO training_sessions 
            (user_id, module, exercise, start_time, status)
            VALUES (?, ?, ?, ?, 'in_progress')
        """, (user_id, module, exercise, datetime.now().isoformat()))
        
        session_id = cursor.lastrowid
        conn.commit()
        conn.close()
        
        return session_id
    
    def complete_session(self, session_id, status, score=None, notes=None):
        """Complete training session"""
        conn = sqlite3.connect(self.db_file)
        cursor = conn.cursor()
        
        cursor.execute("""
            UPDATE training_sessions 
            SET end_time = ?, status = ?, score = ?, notes = ?
            WHERE id = ?
        """, (datetime.now().isoformat(), status, score, notes, session_id))
        
        conn.commit()
        conn.close()
        
        # Check for achievements
        self.check_achievements(session_id)
    
    def check_achievements(self, session_id):
        """Check and award achievements"""
        conn = sqlite3.connect(self.db_file)
        cursor = conn.cursor()
        
        # Get session details
        cursor.execute("""
            SELECT user_id, module, exercise, status, score
            FROM training_sessions WHERE id = ?
        """, (session_id,))
        
        session = cursor.fetchone()
        if not session:
            conn.close()
            return
        
        user_id, module, exercise, status, score = session
        
        # Check for various achievements
        achievements = []
        
        # First completion achievement
        cursor.execute("""
            SELECT COUNT(*) FROM training_sessions 
            WHERE user_id = ? AND status = 'completed'
        """, (user_id,))
        
        completed_count = cursor.fetchone()[0]
        if completed_count == 1:
            achievements.append(("first_completion", "First Exercise Completed"))
        
        # Module mastery achievement
        cursor.execute("""
            SELECT COUNT(DISTINCT exercise) FROM training_sessions 
            WHERE user_id = ? AND module = ? AND status = 'completed'
        """, (user_id, module))
        
        module_exercises = cursor.fetchone()[0]
        if module_exercises >= 5:  # Assuming 5+ exercises per module
            achievements.append((f"{module}_master", f"{module.title()} Module Master"))
        
        # High score achievement
        if score and score >= 90:
            achievements.append(("high_achiever", "High Achiever (90+ Score)"))
        
        # Award achievements
        for achievement_id, description in achievements:
            # Check if already awarded
            cursor.execute("""
                SELECT COUNT(*) FROM achievements 
                WHERE user_id = ? AND achievement = ?
            """, (user_id, achievement_id))
            
            if cursor.fetchone()[0] == 0:
                cursor.execute("""
                    INSERT INTO achievements 
                    (user_id, achievement, earned_date, description)
                    VALUES (?, ?, ?, ?)
                """, (user_id, achievement_id, datetime.now().isoformat(), description))
                
                print(f"Achievement unlocked: {description}")
        
        conn.commit()
        conn.close()
    
    def get_user_progress(self, user_id):
        """Get user training progress"""
        conn = sqlite3.connect(self.db_file)
        cursor = conn.cursor()
        
        # Get session statistics
        cursor.execute("""
            SELECT 
                COUNT(*) as total_sessions,
                COUNT(CASE WHEN status = 'completed' THEN 1 END) as completed,
                COUNT(CASE WHEN status = 'failed' THEN 1 END) as failed,
                AVG(CASE WHEN score IS NOT NULL THEN score END) as avg_score
            FROM training_sessions WHERE user_id = ?
        """, (user_id,))
        
        stats = cursor.fetchone()
        
        # Get achievements
        cursor.execute("""
            SELECT achievement, description, earned_date 
            FROM achievements WHERE user_id = ?
            ORDER BY earned_date DESC
        """, (user_id,))
        
        achievements = cursor.fetchall()
        
        # Get recent sessions
        cursor.execute("""
            SELECT module, exercise, start_time, status, score
            FROM training_sessions WHERE user_id = ?
            ORDER BY start_time DESC LIMIT 10
        """, (user_id,))
        
        recent_sessions = cursor.fetchall()
        
        conn.close()
        
        return {
            "statistics": {
                "total_sessions": stats[0],
                "completed": stats[1],
                "failed": stats[2],
                "average_score": stats[3]
            },
            "achievements": achievements,
            "recent_sessions": recent_sessions
        }
    
    def generate_progress_report(self, user_id):
        """Generate detailed progress report"""
        progress = self.get_user_progress(user_id)
        
        report = f"""
WifiForge Training Progress Report
User: {user_id}
Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}

STATISTICS:
- Total Sessions: {progress['statistics']['total_sessions']}
- Completed: {progress['statistics']['completed']}
- Failed: {progress['statistics']['failed']}
- Average Score: {progress['statistics']['average_score']:.1f}%

ACHIEVEMENTS:
"""
        
        for achievement, description, date in progress['achievements']:
            report += f"- {description} (Earned: {date})\n"
        
        report += "\nRECENT SESSIONS:\n"
        for module, exercise, start_time, status, score in progress['recent_sessions']:
            score_str = f" (Score: {score}%)" if score else ""
            report += f"- {module}/{exercise}: {status}{score_str} ({start_time})\n"
        
        return report

# Usage example
if __name__ == "__main__":
    tracker = WifiForgeTracker()
    
    # Start training session
    session_id = tracker.start_session("user123", "recon", "basic-scan")
    
    # Complete session
    tracker.complete_session(session_id, "completed", 85, "Good understanding of basic scanning")
    
    # Get progress report
    report = tracker.generate_progress_report("user123")
    print(report)

Integration Examples

Penetration Testing Framework Integration

#!/usr/bin/env python3
# WifiForge integration with penetration testing frameworks

import subprocess
import json

class WifiForgeIntegration:
    def __init__(self):
        self.results = {}
    
    def integrate_with_metasploit(self, target_info):
        """Integrate WifiForge results with Metasploit"""
        
        # Extract wireless credentials from WifiForge
        credentials = self.extract_credentials()
        
        for cred in credentials:
            # Create Metasploit resource script
            msf_script = f"""
use auxiliary/scanner/ssh/ssh_login
set RHOSTS {target_info['ip_range']}
set USERNAME {cred['username']}
set PASSWORD {cred['password']}
run
"""
            
            with open(f"msf_script_{cred['ssid']}.rc", "w") as f:
                f.write(msf_script)
            
            print(f"Created Metasploit script for {cred['ssid']}")
    
    def integrate_with_nmap(self, discovered_hosts):
        """Integrate with Nmap for network discovery"""
        
        for host in discovered_hosts:
            cmd = [
                "nmap", "-sS", "-sV", "-O",
                "-p", "22,23,80,443,8080",
                host['ip']
            ]
            
            try:
                result = subprocess.run(cmd, capture_output=True, text=True)
                
                # Parse Nmap results
                if "open" in result.stdout:
                    print(f"Open ports found on {host['ip']}")
                    # Store results for further analysis
                    
            except Exception as e:
                print(f"Error scanning {host['ip']}: {e}")
    
    def extract_credentials(self):
        """Extract credentials from WifiForge results"""
        # Implementation depends on WifiForge output format
        credentials = []
        
        # Example credential extraction
        try:
            with open("wififorge_results.json", "r") as f:
                data = json.load(f)
                
                for network in data.get("networks", []):
                    if network.get("cracked"):
                        credentials.append({
                            "ssid": network["ssid"],
                            "password": network["password"],
                            "security": network["security"],
                            "username": network.get("username", "")
                        })
        
        except FileNotFoundError:
            print("No WifiForge results found")
        
        return credentials

# Usage
integration = WifiForgeIntegration()
target_info = {"ip_range": "192.168.1.0/24"}
integration.integrate_with_metasploit(target_info)

Troubleshooting

Common Issues

Interface Configuration:

# Check wireless interfaces
iwconfig

# Verify monitor mode capability
iw list | grep monitor

# Reset wireless interface
sudo ifconfig wlan1 down
sudo iwconfig wlan1 mode managed
sudo ifconfig wlan1 up

# Check for conflicting processes
sudo airmon-ng check kill

Training Environment Issues:

# Check WifiForge dependencies
python3 -c "import requirements; print('Dependencies OK')"

# Verify hostapd configuration
sudo hostapd -dd /etc/hostapd/hostapd.conf

# Check dnsmasq status
sudo systemctl status dnsmasq

# Monitor system logs
tail -f /var/log/syslog | grep -i wifi

Module Execution Problems:

# Run module in debug mode
python3 wififorge.py --module recon --debug

# Check module dependencies
python3 wififorge.py --check-deps --module wep

# Verify training data
python3 wififorge.py --verify-data

# Reset training environment
python3 wififorge.py --reset-environment

Debugging

Enable detailed debugging and logging:

# Enable verbose output
python3 wififorge.py --verbose --module recon

# Debug mode with logging
python3 wififorge.py --debug --log-file wififorge.log

# Monitor network traffic
tcpdump -i wlan1 -w training_traffic.pcap

# Check system resources
top -p $(pgrep python3)

Security Considerations

Training Environment Security

Isolation:

• Use dedicated training networks
• Implement proper network segmentation
• Avoid interference with production systems
• Monitor for unintended network access
• Regular security assessments of training infrastructure

Data Protection:

• Secure storage of training materials
• Encrypt sensitive training data
• Implement access controls
• Regular backup procedures
• Secure disposal of training artifacts

Legal and Ethical Considerations

Authorized Training Only:

• Use only in controlled environments
• Obtain proper authorization for training activities
• Follow organizational security policies
• Respect intellectual property rights
• Maintain confidentiality of training materials

Responsible Use:

• Educational purposes only
• No unauthorized network testing
• Follow responsible disclosure practices
• Respect privacy and confidentiality
• Comply with applicable laws and regulations

References

1. Black Hills Information Security
2. WifiForge GitHub Repository
3. Wireless Security Training Best Practices
4. IEEE 802.11 Security Standards
5. NIST Wireless Security Guidelines