WifiForge hoja de trucos
Overview
WifiForge is a comprehensive Seguridad Inalámbrica 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 pruebas de penetración training, WifiForge creates controlled environments where security professionals can safely learn and practice Seguridad Inalámbrica assessment techniques without Impactoing production networks. The tool encompasses a wide range of wireless attack scenarios, from basic reconocimiento to advanced exploitation techniques.
The primary objective of WifiForge is to bridge the gap between theoretical knowledge and practical application in Seguridad Inalámbrica. By providing realistic attack scenarios and vulnerable wireless configuracións, the tool enables security professionals to develop practical skills in identifying, exploiting, and defending against Seguridad Inalámbrica vulnerabilities. WifiForge includes modules for various wireless protocolos, cifrado methods, and attack vectors commonly encountered in real-world pruebas de penetración engagements.
WifiForge stands out in the Seguridad Inalámbrica training landscape by offering structured learning paths that progress from basic concepts to advanced techniques. The tool includes comprehensive documentación, 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 Seguridad Inalámbrica expertise.
instalación
Git instalación
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 instalación
python3 wififorge.py --help
Docker instalación
# 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://ejemplo.com/wififorge-vm.ova
# Impuerto into VirtualBox
VBoxManage impuerto wififorge-vm.ova
# Configure VM network settings
VBoxManage modifyvm "WifiForge" --nic1 bridged --bridgeadapter1 wlan0
# Start VM
VBoxManage startvm "WifiForge"
Basic uso
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 reconocimiento 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 parámetros
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
reconocimiento Module
Wireless reconocimiento 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 vulnerabilidad overview
python3 wififorge.py --module wep --exercise "vulnerabilidad-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"
# ataque de diccionario
python3 wififorge.py --module wpa --exercise "dictionary-attack"
# fuerza bruta 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 puertoal creation
python3 wififorge.py --module evil-twin --exercise "captive-puertoal"
# 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 configuración file
cat > custom_scenario.json << 'EOF'
\\\\{
"name": "Enterprise Assessment",
"Descripción": "Corporate Seguridad Inalámbrica 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 autenticación credenciales",
"Demonstrate movimiento lateral"
]
\\\\}
EOF
# Load custom scenario
python3 wififorge.py --load-scenario custom_scenario.json
# Execute scenario
python3 wififorge.py --execute-scenario
Automated Assessment
Automated Seguridad Inalámbrica assessment:
# Full automated assessment
python3 wififorge.py --auto-assess --objetivo "all"
# objetivoed assessment
python3 wififorge.py --auto-assess --objetivo "WPA2" --wordlist rockyou.txt
# Time-limited assessment
python3 wififorge.py --auto-assess --timeout 3600
# Stealth assessment
python3 wififorge.py --auto-assess --stealth --delay 30
# Repuerto generation
python3 wififorge.py --auto-assess --repuerto-format html
Defensive Training
Defensive Seguridad Inalámbrica 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"
# respuesta a incidentes
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 ! comando -v aircrack-ng &> /dev/null; then
echo "Installing aircrack-ng..."
sudo apt install -y aircrack-ng
fi
if ! comando -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 --contraseña "contraseña123"
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
impuerto subproceso
impuerto json
impuerto time
from datetime impuerto 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 configuración"""
try:
with open(config_file, 'r') as f:
return json.load(f)
except FileNotFoundError:
# Default configuración
return \\\\{
"modules": ["recon", "wep", "wpa", "evil-twin"],
"timeout": 3600,
"stealth": True,
"repuerto_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 = subproceso.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 subproceso.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_reconocimiento(self):
"""Run reconocimiento 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 = ["vulnerabilidad-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-puertoal", "credential-harvest"]
return self.run_module("evil-twin", exercises)
def run_full_assessment(self):
"""Run complete Seguridad Inalámbrica assessment"""
print("Starting comprehensive Seguridad Inalámbrica assessment")
# Run all modules
if "recon" in self.config["modules"]:
self.results["reconocimiento"] = self.run_reconocimiento()
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 repuerto
self.generate_repuerto()
print("Assessment completed")
def generate_repuerto(self):
"""Generate assessment repuerto"""
repuerto = \\\\{
"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.claves())
\\\\},
"results": self.results,
"summary": self.generate_summary()
\\\\}
# Save JSON repuerto
with open("wififorge_assessment_repuerto.json", "w") as f:
json.dump(repuerto, f, indent=2)
# Generate HTML repuerto if requested
if self.config.get("repuerto_format") == "html":
self.generate_html_repuerto(repuerto)
print("Repuerto generated: wififorge_assessment_repuerto.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_repuerto(self, repuerto_data):
"""Generate HTML assessment repuerto"""
html_template = """
<!DOCTYPE html>
<html>
<head>
<title>WifiForge Assessment Repuerto</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 Seguridad Inalámbrica Assessment Repuerto</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 repuerto_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=repuerto_data["assessment_info"]["end_time"],
duration=repuerto_data["assessment_info"]["duration"],
total_modules=repuerto_data["summary"]["total_modules"],
successful_exercises=repuerto_data["summary"]["successful_exercises"],
failed_exercises=repuerto_data["summary"]["failed_exercises"],
module_results=module_html
)
with open("wififorge_assessment_repuerto.html", "w") as f:
f.write(html_content)
print("HTML repuerto generated: wififorge_assessment_repuerto.html")
# uso
if __name__ == "__main__":
assessment = WifiForgeAssessment()
assessment.run_full_assessment()
Training Progress Tracker
#!/usr/bin/env python3
# WifiForge training progress tracker
impuerto json
impuerto sqlite3
from datetime impuerto 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_sesións (
id INTEGER PRIMARY clave 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 clave AUTOINCREMENT,
user_id TEXT,
achievement TEXT,
earned_date TEXT,
Descripción TEXT
)
""")
conn.commit()
conn.close()
def start_sesión(self, user_id, module, exercise):
"""Start new training sesión"""
conn = sqlite3.connect(self.db_file)
cursor = conn.cursor()
cursor.execute("""
INSERT INTO training_sesións
(user_id, module, exercise, start_time, status)
VALUES (?, ?, ?, ?, 'in_progress')
""", (user_id, module, exercise, datetime.now().isoformat()))
sesión_id = cursor.lastrowid
conn.commit()
conn.close()
return sesión_id
def complete_sesión(self, sesión_id, status, score=None, notes=None):
"""Complete training sesión"""
conn = sqlite3.connect(self.db_file)
cursor = conn.cursor()
cursor.execute("""
UPDATE training_sesións
SET end_time = ?, status = ?, score = ?, notes = ?
WHERE id = ?
""", (datetime.now().isoformat(), status, score, notes, sesión_id))
conn.commit()
conn.close()
# Check for achievements
self.check_achievements(sesión_id)
def check_achievements(self, sesión_id):
"""Check and award achievements"""
conn = sqlite3.connect(self.db_file)
cursor = conn.cursor()
# Get sesión details
cursor.execute("""
SELECT user_id, module, exercise, status, score
FROM training_sesións WHERE id = ?
""", (sesión_id,))
sesión = cursor.fetchone()
if not sesión:
conn.close()
return
user_id, module, exercise, status, score = sesión
# Check for various achievements
achievements = []
# First completion achievement
cursor.execute("""
SELECT COUNT(*) FROM training_sesións
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_sesións
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, Descripción 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, Descripción)
VALUES (?, ?, ?, ?)
""", (user_id, achievement_id, datetime.now().isoformat(), Descripción))
print(f"Achievement unlocked: \\\\{Descripción\\\\}")
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 sesión statistics
cursor.execute("""
SELECT
COUNT(*) as total_sesións,
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_sesións WHERE user_id = ?
""", (user_id,))
stats = cursor.fetchone()
# Get achievements
cursor.execute("""
SELECT achievement, Descripción, earned_date
FROM achievements WHERE user_id = ?
ORDER BY earned_date DESC
""", (user_id,))
achievements = cursor.fetchall()
# Get recent sesións
cursor.execute("""
SELECT module, exercise, start_time, status, score
FROM training_sesións WHERE user_id = ?
ORDER BY start_time DESC LIMIT 10
""", (user_id,))
recent_sesións = cursor.fetchall()
conn.close()
return \\\\{
"statistics": \\\\{
"total_sesións": stats[0],
"completed": stats[1],
"failed": stats[2],
"average_score": stats[3]
\\\\},
"achievements": achievements,
"recent_sesións": recent_sesións
\\\\}
def generate_progress_repuerto(self, user_id):
"""Generate detailed progress repuerto"""
progress = self.get_user_progress(user_id)
repuerto = f"""
WifiForge Training Progress Repuerto
User: \\\\{user_id\\\\}
Generated: \\\\{datetime.now().strftime('%Y-%m-%d %H:%M:%S')\\\\}
STATISTICS:
- Total sesións: \\\\{progress['statistics']['total_sesións']\\\\}
- Completed: \\\\{progress['statistics']['completed']\\\\}
- Failed: \\\\{progress['statistics']['failed']\\\\}
- Average Score: \\\\{progress['statistics']['average_score']:.1f\\\\}%
ACHIEVEMENTS:
"""
for achievement, Descripción, date in progress['achievements']:
repuerto += f"- \\\\{Descripción\\\\} (Earned: \\\\{date\\\\})\n"
repuerto += "\nRECENT sesiónS:\n"
for module, exercise, start_time, status, score in progress['recent_sesións']:
score_str = f" (Score: \\\\{score\\\\}%)" if score else ""
repuerto += f"- \\\\{module\\\\}/\\\\{exercise\\\\}: \\\\{status\\\\}\\\\{score_str\\\\} (\\\\{start_time\\\\})\n"
return repuerto
# uso ejemplo
if __name__ == "__main__":
tracker = WifiForgeTracker()
# Start training sesión
sesión_id = tracker.start_sesión("user123", "recon", "basic-scan")
# Complete sesión
tracker.complete_sesión(sesión_id, "completed", 85, "Good understanding of basic scanning")
# Get progress repuerto
repuerto = tracker.generate_progress_repuerto("user123")
print(repuerto)
Integration ejemplos
pruebas de penetración Framework Integration
#!/usr/bin/env python3
# WifiForge integration with pruebas de penetración frameworks
impuerto subproceso
impuerto json
class WifiForgeIntegration:
def __init__(self):
self.results = \\\\{\\\\}
def integrate_with_metasploit(self, objetivo_info):
"""Integrate WifiForge results with Metasploit"""
# Extract wireless credenciales from WifiForge
credenciales = self.extract_credenciales()
for cred in credenciales:
# Create Metasploit resource script
msf_script = f"""
use auxiliary/scanner/ssh/ssh_login
set RhostS \\\\{objetivo_info['ip_range']\\\\}
set nombre de usuario \\\\{cred['nombre de usuario']\\\\}
set contraseña \\\\{cred['contraseña']\\\\}
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 = subproceso.run(cmd, capture_output=True, text=True)
# Parse Nmap results
if "open" in result.stdout:
print(f"Open puertos found on \\\\{host['ip']\\\\}")
# Store results for further analysis
except Exception as e:
print(f"Error scanning \\\\{host['ip']\\\\}: \\\\{e\\\\}")
def extract_credenciales(self):
"""Extract credenciales from WifiForge results"""
# Implementation depends on WifiForge output format
credenciales = []
# ejemplo 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"):
credenciales.append(\\\\{
"ssid": network["ssid"],
"contraseña": network["contraseña"],
"security": network["security"],
"nombre de usuario": network.get("nombre de usuario", "")
\\\\})
except FileNotFoundError:
print("No WifiForge results found")
return credenciales
# uso
integration = WifiForgeIntegration()
objetivo_info = \\\\{"ip_range": "192.168.1.0/24"\\\\}
integration.integrate_with_metasploit(objetivo_info)
solución de problemas
Common Issues
Interface configuración:
# 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 procesoes
sudo airmon-ng check kill
Training Environment Issues:
# Check WifiForge dependencies
python3 -c "impuerto requirements; print('Dependencies OK')"
# Verify hostapd configuración
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 Control de Accesos - Regular backup procedures - Secure disposal of training artifacts
Legal and Ethical Considerations
Authorized Training Only: - Use only in controlled environments - Obtain proper autorización 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