WifiForge Cheat Sheet¶
# Guida di Riferimento WifiForge
# 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
```## Panoramica
WifiForge è uno strumento completo di formazione e test sulla sicurezza wireless sviluppato da Black Hills Information Security (BHIS) per fornire un'esperienza pratica con i vettori di attacco Wi-Fi e le tecniche difensive. Progettato specificamente per scopi educativi e formazione sui test di penetrazione, WifiForge crea ambienti controllati in cui i professionisti della sicurezza possono imparare e praticare in modo sicuro tecniche di valutazione della sicurezza wireless senza impattare le reti di produzione. Lo strumento comprende una vasta gamma di scenari di attacco wireless, dalla ricognizione di base a tecniche di sfruttamento avanzate.
L'obiettivo principale di WifiForge è colmare il divario tra la conoscenza teorica e l'applicazione pratica nella sicurezza wireless. Fornendo scenari di attacco realistici e configurazioni wireless vulnerabili, lo strumento consente ai professionisti della sicurezza di sviluppare competenze pratiche nell'identificazione, nello sfruttamento e nella difesa contro le vulnerabilità di sicurezza wireless. WifiForge include moduli per vari protocolli wireless, metodi di crittografia e vettori di attacco comunemente incontrati negli impegni di test di penetrazione reali.
WifiForge si distingue nel panorama della formazione sulla sicurezza wireless offrendo percorsi di apprendimento strutturati che progrediscono da concetti di base a tecniche avanzate. Lo strumento include documentazione completa, tutorial passo-passo ed esercitazioni pratiche che aiutano gli utenti a comprendere non solo come eseguire attacchi, ma anche come rilevarli e prevenirli. Questo doppio focus sulle tecniche offensive e difensive rende WifiForge una risorsa preziosa per costruire una competenza completa nella sicurezza wireless.
Would you like me to continue with the remaining translations?```bash
# 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: ```bash
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
**Problemi di Esecuzione del Modulo:**bash
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 ```### Debug
Abilitare il debug e la registrazione dettagliati: ```bash
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) ```## Considerazioni sulla Sicurezza
Sicurezza dell'Ambiente di Training¶
Isolamento: - Utilizzare reti dedicate per il training - Implementare una corretta segmentazione di rete - Evitare interferenze con sistemi di produzione - Monitorare l'accesso di rete non autorizzato - Valutazioni di sicurezza regolari dell'infrastruttura di training
Protezione dei Dati: - Archiviazione sicura dei materiali di training - Crittografare dati di training sensibili - Implementare controlli di accesso - Procedure di backup regolari - Smaltimento sicuro degli artefatti di training
Considerazioni Legali ed Etiche¶
Solo Training Autorizzato: - Utilizzare solo in ambienti controllati - Ottenere l'autorizzazione appropriata per le attività di training - Seguire le politiche di sicurezza organizzative - Rispettare i diritti di proprietà intellettuale - Mantenere la riservatezza dei materiali di training
Uso Responsabile: - Solo a scopi educativi - Nessun test di rete non autorizzato - Seguire pratiche di divulgazione responsabile - Rispettare la privacy e la riservatezza - Conformarsi alle leggi e ai regolamenti applicabili
Riferimenti¶
Black Hills Information SecurityRepository GitHub WifiForgehttps://csrc.nist.gov/publications/detail/sp/800-153/final[Migliori Pratiche di Training sulla Sicurezza Wireless](