WifiForge aide-mémoire
Overview
WifiForge is a comprehensive Sécurité Sans Fil 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 tests de pénétration training, WifiForge creates controlled environments where security professionals can safely learn and practice Sécurité Sans Fil 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 Sécurité Sans Fil. By providing realistic attack scenarios and vulnerable wireless configurations, the tool enables security professionals to develop practical skills in identifying, exploiting, and defending against Sécurité Sans Fil vulnerabilities. WifiForge includes modules for various wireless protocoles, chiffrement methods, and attack vectors commonly encountered in real-world tests de pénétration engagements.
WifiForge stands out in the Sécurité Sans Fil 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 Sécurité Sans Fil 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 hôteapd 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 hôteapd 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=hôte wififorge
# Mount workspace
docker run -it --privileged --net=hôte -v $(pwd):/workspace wififorge
Virtual Machine Setup
# Download WifiForge VM (if available)
wget https://exemple.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 utilisation
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 paramètres
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 vulnérabilité overview
python3 wififorge.py --module wep --exercise "vulnérabilité-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"
# attaque par dictionnaire
python3 wififorge.py --module wpa --exercise "dictionary-attack"
# force brute 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 Sécurité Sans Fil 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 authentification identifiants",
"Demonstrate mouvement latéral"
]
\\\\}
EOF
# Load custom scenario
python3 wififorge.py --load-scenario custom_scenario.json
# Execute scenario
python3 wififorge.py --execute-scenario
Automated Assessment
Automated Sécurité Sans Fil assessment:
# Full automated assessment
python3 wififorge.py --auto-assess --cible "all"
# cibleed assessment
python3 wififorge.py --auto-assess --cible "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 Sécurité Sans Fil 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"
# réponse aux incidents
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 ! commande -v aircrack-ng &> /dev/null; then
echo "Installing aircrack-ng..."
sudo apt install -y aircrack-ng
fi
if ! commande -v hôteapd &> /dev/null; then
echo "Installing hôteapd..."
sudo apt install -y hôteapd
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 --mot de passe "mot de passe123"
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 subprocessus
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 = subprocessus.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 subprocessus.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 = ["vulnérabilité-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 Sécurité Sans Fil assessment"""
print("Starting comprehensive Sécurité Sans Fil 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.clés())
\\\\},
"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 Sécurité Sans Fil 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")
# utilisation
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 clé 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 clé 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
# utilisation exemple
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 exemples
tests de pénétration Framework Integration
#!/usr/bin/env python3
# WifiForge integration with tests de pénétration frameworks
import subprocessus
import json
class WifiForgeIntegration:
def __init__(self):
self.results = \\\\{\\\\}
def integrate_with_metasploit(self, cible_info):
"""Integrate WifiForge results with Metasploit"""
# Extract wireless identifiants from WifiForge
identifiants = self.extract_identifiants()
for cred in identifiants:
# Create Metasploit resource script
msf_script = f"""
use auxiliary/scanner/ssh/ssh_login
set RhôteS \\\\{cible_info['ip_range']\\\\}
set nom d'utilisateur \\\\{cred['nom d'utilisateur']\\\\}
set mot de passe \\\\{cred['mot de passe']\\\\}
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_hôtes):
"""Integrate with Nmap for network discovery"""
for hôte in discovered_hôtes:
cmd = [
"nmap", "-sS", "-sV", "-O",
"-p", "22,23,80,443,8080",
hôte['ip']
]
try:
result = subprocessus.run(cmd, capture_output=True, text=True)
# Parse Nmap results
if "open" in result.stdout:
print(f"Open ports found on \\\\{hôte['ip']\\\\}")
# Store results for further analysis
except Exception as e:
print(f"Error scanning \\\\{hôte['ip']\\\\}: \\\\{e\\\\}")
def extract_identifiants(self):
"""Extract identifiants from WifiForge results"""
# Implementation depends on WifiForge output format
identifiants = []
# exemple 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"):
identifiants.append(\\\\{
"ssid": network["ssid"],
"mot de passe": network["mot de passe"],
"security": network["security"],
"nom d'utilisateur": network.get("nom d'utilisateur", "")
\\\\})
except FileNotFoundError:
print("No WifiForge results found")
return identifiants
# utilisation
integration = WifiForgeIntegration()
cible_info = \\\\{"ip_range": "192.168.1.0/24"\\\\}
integration.integrate_with_metasploit(cible_info)
dépannage
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 processuses
sudo airmon-ng check kill
Training Environment Issues:
# Check WifiForge dependencies
python3 -c "import requirements; print('Dependencies OK')"
# Verify hôteapd configuration
sudo hôteapd -dd /etc/hôteapd/hôteapd.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 Contrôle d'Accèss - Regular backup procedures - Secure disposal of training artifacts
Legal and Ethical Considerations
Authorized Training Only: - Use only in controlled environments - Obtain proper autorisation 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