Outils IPMI issus des travaux de la DARPA
<p>
J'ai écrit un logiciel pour explorer IPMI ; voici quelques résultats. Je pensais suivre le cycle habituel : détection, récupération de données et audit. Chacun de ces aspects s'est révélé être un problème assez intéressant en soi, du moins pour moi.
</p>
**BTW/FYI ** - J'ai publié un nouvel outil pour explorer IPMI - https://github.com/zenfish/zipmi -
ainsi qu'un ensemble de recettes/images/etc. Qemu pour exécuter des BMC en tant que systèmes virtuels sous
Qemu à l'adresse https://github.com/zenfish/zbmc.
<h4>Site web IPMI</h4>
Les articles et autres documents de http://fish2.com/ipmi
<p> <a href="https://github.com/zenfish/ipmi/blob/master/html">html</a> </p>
<h4>Cassage de mots de passe</h4>
Voici un <a href="https://github.com/zenfish/ipmi/blob/master/rak-the-ripper.pl">petit programme Perl</a>
qui tente de deviner un compte sur un BMC distant, d'en extraire le hash,
puis d'essayer de casser son mot de passe (haché en HMAC). J'ai rédigé un
<a href="http://fish2.com/ipmi/remote-pw-cracking.html">petit</a>
texte à ce sujet pour les curieux. Abondamment commenté, il pourra peut-être être utile.
<h4> Obtenir les chiffrements</h4>
La spécification IPMI indique que l'on peut obtenir le chiffrement d'un système distant sans aucune
authentification, mais je ne connais aucun outil qui le fasse réellement
(ils exigent tous une authentification, bien sûr vous pourriez saisir les octets hexadécimaux
bruts si vous le souhaitiez !) J'ai donc écrit ce petit outil pour le faire ; il suit
essentiellement la sortie d'ipmitool ; ce faisant, je pense avoir trouvé un
bug dans cet utilitaire (sur la dernière ligne, *parfois* les systèmes émettent des
déchets qui semblent être mal interprétés), mais qui sait, je n'ai pas
assez de systèmes pour tester. Bref... <a href="https://github.com/zenfish/ipmi/blob/master/ipmi-get-ciphers.py">ipmi-get-ciphers.py</a>.
Si ce n'est rien d'autre, utile pour repérer les systèmes Cipher0 (note - cela
signale simplement les chiffrements qui sont pris en charge - cela ne signifie pas qu'ils
sont réellement activés), mais il y a des choses intéressantes dans la nature.
<h4> Obtenir les détails d'authentification </h4>
Deux programmes ici, l'un est un simple sondeur distant en Python
(je commence à détester Perl, je vous le dis) et un second
qui utilise les utilitaires de <a href="http://www.gnu.org/software/freeipmi/">FreeIPMI</a>
pour récupérer les données de configuration authentifiées.
</p> <p>
Un petit programme Python (plus de 50 % de commentaires en ligne, 2,5k compressé en gzip) qui envoie un seul paquet
à un BMC et analyse la réponse. Que peut-on faire avec un seul paquet, pourrait-on
se demander ? Plus de 10 tests de sécurité différents pour IPMI, pour commencer. Eh bien, pour commencer
et pour finir, ce n'est qu'un paquet :) Nécessite Python, un BMC et un chemin ouvert vers
le port UDP 623 pour fonctionner. L'utilisation est simplement « ipmi-get-auth.py target ».
<p style="padding-left:60px;">
<span style="padding: 5px; border: 1px solid #AAA;"> <a href="https://github.com/zenfish/ipmi/blob/master/ipmi-get-auth.py">ipmi-get-auth.py</a> /
<a href="http://trouble.org/?p=712">Une très brève description</a> </span><br />
</p> <p>
En poussant à l'extrême... eh bien, voici une sorte de méga version de
ce qui précède qui le fait pour tous les canaux, tous les privilèges, tous... enfin,
vous voyez l'idée. Pour les monomaniaques (lisez les commentaires ou l'article
que j'ai écrit à ce sujet pour comprendre pourquoi il fait ce qu'il fait !)
<p style="padding-left:60px;">
<span style="padding: 5px; border: 1px solid #AAA;"> <a href="https://github.com/zenfish/ipmi/blob/master/mega_chan.py">mega_chan.py</a> /
<a href="http://trouble.org/?p=1046">Mega mega mega ... chan chan chan...</a> </span><br />
</p> <p>
<h4> Obtenir l'ID de périphérique (GUID) </h4>
Et voici un simple programme pour envoyer un paquet Get Device ID (voir
p250 de la spécification IPMI v 2) à un système. Cela devrait, en théorie,
fonctionner sans authentification. Dans une petite enquête, environ 90 %
des systèmes ont répondu à cela (mais pas tous avec des informations valides !)
Vous pouvez, parfois, obtenir le fournisseur et d'autres informations, comme
les numéros de modèle et autres, mais le plus intéressant est en fait d'obtenir
un ID unique, traditionnellement une chose difficile à obtenir via le réseau.
<p style="padding-left:60px;">
<span style="padding: 5px; border: 1px solid #AAA;"> <a href="https://github.com/zenfish/ipmi/blob/master/mega_chan.py">get-ipmi-guid.py</a> /
<a href="http://trouble.org/wp-admin/post.php?post=1052">Get Device ID</a> </span><br />
</p> <p>
<h4> Extraire les mots de passe d'un fichier de mots de passe binaire SuperMicro</h4>
Supermicro a eu quelques problèmes de divulgation de fichiers de mots de passe depuis
son BMC - par exemple, voir ceci et d'autres articles :
<blockquote>
<a target="_blank" href="https://community.rapid7.com/community/metasploit/blog/2013/07/02/a-penetration-testers-guide-to-ipmi">a-penetration-testers-guide-to-ipmi</a>
</blockquote>
Pour utiliser ce script, il suffit de saisir :
<blockquote>
<a href="https://github.com/zenfish/ipmi/blob/master/dump_SM.py">dump_SM.py</a> password_file
</blockquote>
Fonctionne chez moi, aucune garantie implicite, explicite, etc.
<h4>Détection</h4>
Eh bien, si vous pouvez communiquer avec le port UDP 623, il est assez simple
de déterminer si un système distant exécute IPMI. Toutefois, à moins de vous trouver à l'intérieur
d'un centre de données, la plupart des gens bloquent l'UDP. Et même s'ils
ne le font pas... le scan UDP est à peu près aussi lent qu'on peut l'imaginer. J'utilise donc
actuellement deux méthodes de base, en m'appuyant sur le vénérable Nmap et
ipmiping (issu des outils GNU FreeIPMI). La chose la plus simple à faire est :
</p> <p>
<ul>
<li>Utiliser ipmiping pour demander à un système distant s'il parle IPMI ou non. Une réponse
positive est l'indication la plus forte qu'un système parle IPMI
(mais rien n'est certain !) Plus techniquement, il envoie deux appels IPMI
Get Channel Authentication Capabilities via un datagramme de requête Get Channel
Authentication Capabilities sur le port UDP 623 (deux
requêtes puisqu'il utilise UDP, et les connexions ne sont pas garanties.)
</p> <p>
Comme Nmap est bien plus efficace pour scanner des réseaux à grande échelle
qu'ipmiping, cette méthode n'est utilisée que si Nmap indique qu'un hôte
a le port UDP 623 ouvert.
</p> <p>
Pour le meilleur ou pour le pire, ce port est souvent bloqué, si bien que la plupart du
temps d'autres méthodes sont plus susceptibles de déterminer indirectement si
IPMI est en cours d'exécution ou non.
<li>La seconde méthode est un peu floue, et repose sur un peu
d'induction (autrement dit de la devinette). Nmap scanne les ports connus pour être
associés à IPMI et aux ajouts des constructeurs ; l'UDP 623 est évident (le
port IPMI par défaut), mais il existe une variété de ports (à la fois UDP et
TCP) qui, pris isolément, pourraient ne pas vous donner immédiatement une réponse,
mais qui, pris dans leur ensemble, peuvent fortement indiquer sa présence.
TFTP, SNMP, SSH/SMASH, VNC, et bien d'autres figurent parmi ceux-ci.
</p> <p>
Les ports sont pondérés selon leur capacité indicative et selon que
Nmap les trouve ouverts, filtrés, ou dans d'autres états.
</p> <p>
Nmap peut également afficher les bannières des services auxquels il se connecte. J'utilise
des expressions régulières pour traquer les cibles - par exemple les chaînes
"iLO" et "DRAC" sont de bons indicateurs qu'un système pourrait exécuter
le service Integrated Lights Out de HP, ou iLO.
</p> <p>
<strong>Note :</strong> Actuellement, je n'utilise PAS la méthode du ping
broadcast (un moyen très rapide de parcourir le sous-réseau dans lequel vous
vous trouvez) ; je n'ai tout simplement aucune donnée sur son efficacité ;
bien que très rapide lorsqu'elle fonctionne, je n'ai pas estimé qu'elle
permettait le contrôle et la fiabilité de scans arbitraires.
Deux de mes trois systèmes (Dell et HP) ont répondu à un
ping RMCP. Aucun n'a répondu à un ping broadcast par idiscover
(ipmiutil discover.) Tous, en revanche, ont répondu à mon outil d'audit
Python ci-dessous.
</p> <p>
Malheureusement (bien sûr !) le spectre des communications et des
réseaux entre en jeu - nmap donne un tas de raisons différentes
pour expliquer qu'un port soit ouvert ou non (open, closed, filtered, etc.)
Encore une autre table contient un ensemble de poids qui accorde plus de points à
un port ouvert qu'à un résultat "open|filtered" (comme dirait Nmap).
Interpréter nmap et pondérer est un peu frustrant,
mais c'est la vie.
</p> <p>
Prenez tous les poids, additionnez tous les points et vous obtenez un niveau de
certitude IPMI. J'ai constaté lors de tests ad hoc que 15 points ou
plus constituent de forts indicateurs que le système exécute IPMI.
</p> <p>
Actuellement, j'ai différents seuils (non, peut-être, probablement,
oui.) Dans les tests - sans avoir eu connaissance d'un accès à d'autres serveurs
que le mien - cela semble fonctionner raisonnablement bien. C'est-à-dire
que les choses que je considère suspectes et mon modèle de pensée
de base ci-dessus font effectivement remonter certains serveurs en tête et
laissent les hôtes aléatoires tranquilles. Il y a cependant de vrais problèmes avec
les faux positifs - beaucoup de pare-feu semblent laisser croire à nmap qu'il
y a quelque chose sur n'importe quel port (j'ai pensé à ajouter un ou deux ports
rares (si vous écoutez quelque chose comme le port 1 et 31313,
par exemple, vous n'êtes probablement pas *vraiment* à l'écoute !)
</p> <p>
Mais ce n'est pas censé être le dernier mot sur le sujet. Il devrait
être assez simple d'obtenir des données décentes sur les bannières IPMI, mon
pari est que ce serait de loin la meilleure façon de scanner rapidement de grandes
quantités de systèmes.
</ul>
</p> <p>
Voici quatre morceaux de Perl pour implémenter ce qui précède ; un scanne,
un interprète, et les deux autres servent à la pondération. C'est un
outil de recherche ou une preuve de concept, pas un scanner de production, mais
il produit une sortie raisonnable.
</p> <p>
<strong>REQUIS : Nmap version 6.</strong>
</p>
<table border=1>
<tr> <td style="padding-left:30px;"> <span> <a href="https://github.com/zenfish/ipmi/blob/master/ipmi-scan/ipmi_scan.pl">ipmi_scan.pl</a> - scanner IPMI basique, utilise Nmap et, si disponible, ipmitool </span> </td> </tr>
<tr> <td style="padding-left:30px;"> <span> <a href="https://github.com/zenfish/ipmi/blob/master/ipmi-scan/ipmi_scan.out">page de manuel d'ipmi_scan</a> - page de manuel pour ce qui précède</span> </td> </tr>
<tr> <td style="padding-left:30px;"> <span> <a href="https://github.com/zenfish/ipmi/blob/master/ipmi-scan/post_ipmi_scan.pl">post_ipmi_scan.pl</a> - analyse la sortie de ce qui précède, produit des résultats pondérés </span></td> </tr>
<tr> <td style="padding-left:30px;"> <span><a href="https://github.com/zenfish/ipmi/blob/master/ipmi-scan/j_vendor.pl">j_vendor.pl</a> - Quelques données de base sur les fournisseurs... lesquels utilisent quels ports ?</span> </td> </tr>
<tr> <td style="padding-left:30px;"> <span><a href="https://github.com/zenfish/ipmi/blob/master/ipmi-scan/j_weights.pl">j_weights.pl</a> - Quelques pondérations de base par fournisseur pour ce qui précède</span> </span></td> </tr>
</table>
</p> <p>
L'utilisation est assez simple, bien qu'un peu particulière. Doit être exécuté en tant que root. Mode verbeux (-v) pour beaucoup de sortie.
<blockquote>
<pre>
# exécution standard :
./ipmi_scan.pl -A -v -O yes 192.168.0.0/24
# rapide
./ipmi_scan.pl -tcp -v 192.168.0.0/24
# tout compris
./ipmi_scan.pl -A -v -O high 192.168.0.0/24
</pre>
</blockquote>
Le scan créera une paire de fichiers de résultats correspondant aux
noms cibles (les barres obliques sont converties en tirets bas.) Il suffit d'exécuter le
post-processeur sur ceux-ci ; un tri numérique inverse les met
dans un ordre plus intéressant. Tout ce qui dépasse 10, je l'appellerais suspect,
tandis qu'au-delà de 20, il est quasiment certain qu'IPMI est en cours d'exécution.
Dans ce cas, j'ai
utilisé l'option concise (-t) pour réduire la sortie au strict minimum.
<blockquote>
<pre>
./post_ipmi_scan.pl -t 192.168.0.0_24|sort -rn
96.3 192.168.0.69
16.25 192.168.0.46
10.8 192.168.0.23
7.33 192.168.0.202
5.4 192.168.0.189
5.4 192.168.0.179
1.7 192.168.0.9
1.23 192.168.0.1
1.1 192.168.0.8
0.9 192.168.0.251
0.63 192.168.0.55
0.43 silent/192.168.0.250
0.2 pi.fish2.com/192.168.0.14
0.2 fierce.fish2.com/192.168.0.6
0.2 192.168.0.88
0.01 192.168.0.16
</pre>
</blockquote>
</p> <p>
Dans les résultats ci-dessus, les 3 premiers systèmes exécutent réellement IPMI,
mais seul le HP a indiqué à Nmap que le port UDP 623 était ouvert - mon Dell et
mon Supermicro ont renvoyé la réponse plus ambiguë « open|filtered »,
qui est très souvent une fausse alerte, pff. Peut-être vaut-il mieux
tout simplement prendre son mal en patience et faire le ping IPMI en parallèle du scanner
(ou écrire un NSE pour le faire correctement dans Nmap.)
</p> <p>
<h4>Audit</h4>
Voici quelques petits programmes Python qui - à l'aide des outils FreeIPMI - (a) récupèrent la
configuration IPMI/BMC de base d'un serveur et (b) effectuent une petite vérification de sécurité sur les résultats.
Parce que je... eh bien, en fait, aucune bonne raison. L'un est en python3 et
l'autre en python2. Je suppose que je teste votre préparation. Les programmes sont
abondamment commentés, en particulier ipmifreely.py, alors consultez-le pour
plus de détails sur ce qui se passe. Nécessite simplejson et ConfigParser,
peut-être d'autres choses.
</p> <p>
<span style="color: #ff0000;">VOUS DEVEZ</span> avoir <a title="FreeIPMI"
href="https://github.com/zenfish/ipmi/blob/master/www.gnu.org/software/freeipmi" target="_blank">FreeIPMI</a>
installé, ce qui, à l'heure où j'écris ces lignes, élimine toute chance pour Mac et Windows
de récupérer un fichier JSON sympa depuis un serveur. Et vous devriez vraiment,
vraiment avoir une version récente. Ne dites pas que je ne vous ai pas prévenu.
Mais la vie continue.
</p> <p>
L'acquisition des données se fait via un programme python (I-check.py) qui
nécessite des identifiants valides pour obtenir les données. Il convertit les résultats en
JSON, qui peut ensuite être vérifié par l'outil d'audit (ipmifreely.py.)
Il y a une politique d'exemple dans « IPMI-policy.ini », où j'ai mis quelques valeurs
pour les tests.
</p> <p>
<table border=1>
<tr> <td style="padding-left:30px;"> <span> <a href="https://github.com/zenfish/ipmi/blob/master/iaudit/I-check.py">I-check.py</a> - récupère les données de configuration IPMI</span> </td> </tr>
<tr> <td style="padding-left:30px;"> <span> <a href="https://github.com/zenfish/ipmi/blob/master/iaudit/ipmifreely.py">ipmifreely.py</a> - analyse la sortie de ce qui précède, produit quelques résultats</span> </td> </tr>
<tr> <td style="padding-left:30px;"> <span> <a href="https://github.com/zenfish/ipmi/blob/master/iaudit/IPMI-policy.ini">IPMI-policy.ini</a> - fichier de politique IPMI</span></td> </tr>
</table>
</p> <p>
Exemple d'utilisation :
<blockquote>
<pre>
# this grabs the configuration stuff; here I'm using it on an HP iLO 3 server
# the output is redirected to a file
$ ./ipmifreely.py -v -u admin -p admin 192.168.0.46 > hp.json
# This takes the JSON file and looks for issues
$ ./I-check.py drac.json
./I-check.py hp.json
Host: 192.168.0.46
[bmc-config] Serial_Channel Non_Volatile_Enable_Pef_Alerting = No
[bmc-config] Serial_Channel Volatile_Enable_Pef_Alerting = No
[bmc-config] Serial_Channel Volatile_Enable_Per_Message_Auth = No
[bmc-config] Serial_Channel Non_Volatile_Enable_Per_Message_Auth = No
[bmc-config] Lan_Conf_Security_Keys K_G = 0x0000000000000000000000000000000000000000
[bmc-config] SOL_Conf Force_SOL_Payload_Authentication = No
[bmc-config] SOL_Conf Force_SOL_Payload_Encryption = No
[bmc-config] Lan_Conf_Auth Callback_Enable_Auth_Type_None = Yes
[bmc-config] Lan_Conf_Auth Operator_Enable_Auth_Type_None = Yes
[bmc-config] Lan_Conf_Auth OEM_Enable_Auth_Type_None = Yes
[bmc-config] Lan_Conf_Auth Admin_Enable_Auth_Type_None = Yes
[bmc-config] Lan_Conf_Auth User_Enable_Auth_Type_None = Yes
[bmc-config] Rmcpplus_Conf_Privilege Maximum_Privilege_Cipher_Suite_Id_1 = OEM_Proprietary
[bmc-config] Rmcpplus_Conf_Privilege Maximum_Privilege_Cipher_Suite_Id_0 = OEM_Proprietary
[bmc-config] Rmcpplus_Conf_Privilege Maximum_Privilege_Cipher_Suite_Id_2 = OEM_Proprietary
[pef-config] Community_String Community_String = public
[pef-config] PEF_Conf Enable_PEF_Event_Messages = No
</pre>
</blockquote>
Vous pouvez consulter quelques <a href="https://github.com/zenfish/ipmi/blob/master/ipmi/bp.pdf">Bonnes pratiques de sécurité IPMI</a> pour en savoir plus
sur ce qu'il faut vérifier, ce que je considère comme de bonnes choses à faire, en matière de sécurité.