nickstadb/barmieOutil d'énumération et d'attaque Java RMI.
BaRMIe est un outil pour énumérer et attaquer les services Java RMI (Remote Method Invocation).
Les services RMI exposent souvent des fonctionnalités dangereuses sans contrôles de sécurité adéquats, mais ils passent généralement inaperçus lors des audits de sécurité en raison du manque d'outils de test efficaces. En 2008, Adam Boulton a présenté à l'AppSec USA (YouTube) et a publié des outils d'attaque RMI qui ont rapidement disparu, mais même avec ces outils, une attaque sans connaissance préalable repose sur une attaque par force brute significative (~64 bits / 9 quintillions de possibilités) réalisée sur le réseau.
L'objectif de BaRMIe est de permettre aux professionnels de la sécurité d'identifier, d'attaquer et de sécuriser les services RMI non sécurisés. En utilisant des interfaces RMI partielles issues de logiciels existants, BaRMIe peut interagir directement avec ces services sans avoir à forcer 64 bits sur le réseau au préalable.
Téléchargez la dernière version compilée et prête à l'emploi ici : https://github.com/NickstaDB/BaRMIe/releases/latest
BaRMIe a été écrit pour aider les professionnels de la sécurité à identifier les services RMI non sécurisés sur des systèmes pour lesquels l'utilisateur a préalablement obtenu l'autorisation d'attaquer. L'accès non autorisé à des systèmes informatiques est illégal et BaRMIe doit être utilisé conformément à toutes les lois en vigueur. Le non-respect de cette règle peut entraîner des poursuites judiciaires. Les développeurs de BaRMIe déclinent toute responsabilité et ne sont pas responsables des mauvais usages ou des dommages causés par ce programme.
L'utilisation de BaRMIe est simple. Exécutez BaRMIe sans paramètre pour afficher les informations d'utilisation.
$ java -jar BaRMIe.jar
▄▄▄▄ ▄▄▄ ██▀███ ███▄ ▄███▓ ██▓▓█████
▓█████▄ ▒████▄ ▓██ ▒ ██▒▓██▒▀█▀ ██▒▓██▒▓█ ▀
▒██▒ ▄██▒██ ▀█▄ ▓██ ░▄█ ▒▓██ ▓██░▒██▒▒███
▒██░█▀ ░██▄▄▄▄██ ▒██▀▀█▄ ▒██ ▒██ ░██░▒▓█ ▄
░▓█ ▀█▓ ▓█ ▓██▒░██▓ ▒██▒▒██▒ ░██▒░██░░▒████▒
░▒▓███▀▒ ▒▒ ▓▒█░░ ▒▓ ░▒▓░░ ▒░ ░ ░░▓ ░░ ▒░ ░
▒░▒ ░ ▒ ▒▒ ░ ░▒ ░ ▒░░ ░ ░ ▒ ░ ░ ░ ░
░ ░ ░ ▒ ░░ ░ ░ ░ ▒ ░ ░
░ ░ ░ ░ ░ ░ ░ ░
░ v1.0
Outil d'énumération Java RMI.
Écrit par Nicky Bloor (@NickstaDB)
Warning: BaRMIe a été écrit pour aider les professionnels de la sécurité à identifier les
utilisations non sécurisées des services RMI sur des systèmes pour lesquels l'utilisateur a
préalablement obtenu l'autorisation d'attaquer. BaRMIe doit être utilisé conformément à toutes
les lois en vigueur. Le non-respect de cette règle peut entraîner des poursuites judiciaires.
Les développeurs déclinent toute responsabilité et ne sont pas responsables des mauvais usages
ou des dommages causés par ce programme.
Utilisation :
BaRMIe -enum [options] [hôte] [port]
Énumérer les services RMI sur le(s) point(s) d'accès donné(s).
Note : si -enum n'est pas spécifié, ce mode est utilisé par défaut.
BaRMIe -attack [options] [hôte] [port]
Énumérer et attaquer la/les cible(s) donnée(s).
Options :
--threads Le nombre de threads à utiliser pour l'énumération (par défaut 10).
--timeout Le délai d'attente pour les opérations socket bloquantes (par défaut 5000 ms).
--targets Un fichier contenant les cibles à analyser.
Le fichier doit contenir un seul hôte ou une paire hôte et port séparés par un espace par ligne.
Alternativement, tous les formats de sortie nmap sont supportés ; BaRMIe analysera
la sortie nmap pour les services sur le port 1099, 'rmiregistry' ou 'Java RMI'
afin de déterminer les cibles.
Note : [hôte] [port] n'est pas supporté lorsque --targets est utilisé.
Fiabilité :
Un système de +/- est utilisé pour indiquer la fiabilité de l'attaque comme suit :
[+ ] : Indique une attaque spécifique à l'application
[- ] : Indique une attaque JRE
[ + ] : Attaque des méthodes non sécurisées (comme 'writeFile' sans authentification)
[ - ] : Attaque par désérialisation Java (c'est-à-dire des paramètres de type Object)
[ +]: Ne nécessite pas de dépendances non par défaut
[ -]: Des dépendances non par défaut sont nécessaires
Le mode Énumération (-enum) extrait les détails des objets exposés via un service de registre RMI et liste les attaques connues qui affectent le point d'accès.
Le mode Attaque (-attack) énumère d'abord les cibles données, puis fournit un système de menus pour lancer des attaques connues contre les services RMI.
Une seule cible peut être spécifiée en ligne de commande. Alternativement, BaRMIe peut extraire des cibles à partir d'un simple fichier texte ou de la sortie nmap.
Génial ! C'est l'occasion d'aider à améliorer BaRMIe ! BaRMIe repose sur une certaine connaissance des classes exposées via RMI, donc les contributions aideront grandement à améliorer BaRMIe et la sécurité des services RMI.
Si vous avez accès aux fichiers JAR ou au code source de l'application cible, produire une attaque est aussi simple que de compiler du code avec les fichiers JAR pertinents. Récupérez l'objet distant concerné à l'aide des classes LocateRegistry et Registry, puis appelez les méthodes souhaitées. Sinon, cherchez des méthodes distantes qui acceptent des objets arbitraires ou d'autres paramètres non primitifs, car ceux-ci peuvent être utilisés pour livrer des charges utiles de désérialisation. Une documentation plus complète sur l'attaque des services RMI et la création d'attaques pour BaRMIe sera publiée prochainement.
Sinon, prenez contact et fournissez autant de détails que possible, notamment la sortie de BaRMIe -enum et, idéalement, les fichiers JAR pertinents.
BaRMIe est capable de réaliser trois types d'attaques contre les services RMI. Une brève description de chacune suit. D'autres détails techniques seront publiés prochainement sur https://nickbloor.co.uk/. De plus, j'ai présenté les résultats de mes recherches à 44CON 2017 et les diapositives peuvent être trouvées ici : BaRMIe - Poking Java's Back Door.
La première et la plus simple méthode pour attaquer des services RMI non sécurisés consiste simplement à appeler des méthodes distantes non sécurisées. Il arrive souvent que des fonctionnalités dangereuses soient exposées via RMI et puissent être déclenchées simplement en récupérant la référence de l'objet distant et en appelant la méthode dangereuse. Le code suivant en est un exemple :
//Obtenir une référence au service de registre RMI distant
Registry reg = LocateRegistry.getRegistry(hôteCible, portCible);
//Obtenir une référence à l'objet RMI cible
Foo bar = (Foo)reg.lookup(nomObjet);
//Appeler la méthode distante executeCommand()
bar.executeCommand(cmd);
Certains services RMI n'exposent pas de fonctionnalités dangereuses, ou bien ils implémentent des contrôles de sécurité tels que l'authentification et la gestion de session. Si le service RMI expose une méthode qui accepte un Object arbitraire comme paramètre, alors cette méthode peut être utilisée comme point d'entrée pour des attaques par désérialisation. On peut voir ci-dessous quelques exemples de telles méthodes :
public void setOption(String name, Object value);
public void addAll(List values);
En raison de l'utilisation de la sérialisation et d'une gestion non sécurisée des paramètres de méthode côté serveur, il est possible d'utiliser n'importe quelle méthode avec des types de paramètres non primitifs comme point d'entrée pour des attaques par désérialisation. BaRMIe y parvient en utilisant des proxys TCP pour modifier les paramètres de méthode au niveau réseau, déclenchant ainsi des invocations de méthode illégales. On peut voir ci-dessous quelques exemples de méthodes vulnérables :
public void setName(String name);
public Long add(Integer i1, Integer i2);
public void sum(int[] values);
Les paramètres de chacune de ces méthodes peuvent être remplacés par une charge utile de désérialisation lorsque l'invocation de méthode passe par un proxy. Cette attaque est possible car Java ne tente pas de vérifier que les paramètres de méthode distante reçus sur le réseau sont compatibles avec les types de paramètres réels avant de les désérialiser.