Ferramentas IPMI do trabalho da DARPA
<p>
Escrevi um software para explorar IPMI; aqui estão alguns dos resultados. Pensei em
fazer o ciclo habitual de detetar, obter dados e auditar. Cada um destes acabou
por ser um problema bastante interessante por si só, pelo menos para mim.
</p>
**BTW/FYI ** - Lancei uma nova ferramenta para explorar IPMI - https://github.com/zenfish/zipmi -
bem como um conjunto de receitas/imagens/etc. de Qemu para executar BMCs como sistemas virtuais sob
Qemu em https://github.com/zenfish/zbmc.
<h4>Site web do IPMI</h4>
Os artigos e coisas de http://fish2.com/ipmi
<p> <a href="https://github.com/zenfish/ipmi/blob/master/html">html</a> </p>
<h4>Quebra de palavras-passe</h4>
Aqui está um <a href="https://github.com/zenfish/ipmi/blob/master/rak-the-ripper.pl"> pequeno programa Perl</a>
que tenta adivinhar uma conta num BMC remoto, extrair o seu hash,
e depois tentar quebrar a sua palavra-passe (com hash HMAC). Escrevi um
<a href="http://fish2.com/ipmi/remote-pw-cracking.html">pequeno</a>
texto sobre isto para os curiosos. Intensamente comentado, pode ser útil.
<h4> Obter cifras</h4>
A especificação IPMI diz que se pode obter a cifra de um sistema remoto sem qualquer
autenticação, mas não conheço nenhuma ferramenta que o faça
(todas exigem autenticação, embora, claro, se possa introduzir os bytes hex
em bruto se se quiser!) Por isso escrevi esta pequena ferramenta para o fazer; segue
sobretudo a saída do ipmitool; ao fazê-lo, acredito que encontrei um
bug nesse utilitário (na linha final *por vezes* os sistemas emitem algum
lixo que parece ser mal interpretado), mas quem sabe, não tenho
sistemas suficientes para testar. De qualquer forma... <a href="https://github.com/zenfish/ipmi/blob/master/ipmi-get-ciphers.py">ipmi-get-ciphers.py</a>.
Se não servir para mais nada, é útil para detetar sistemas Cipher0 (nota - isto
apenas indica cifras que são suportadas - não significa que
estejam realmente ativadas), mas há coisas interessantes por aí.
<h4> Obter detalhes de autenticação </h4>
Dois programas aqui, um é um simples
sondador remoto em Python (estou a começar a odiar Perl, diga-se) e um segundo
que usa utilitários do <a href="http://www.gnu.org/software/freeipmi/">FreeIPMI</a>
para obter dados de configuração com credenciais.
</p> <p>
Um pequeno programa Python (mais de 50% de comentários inline, 2,5k comprimido com gzip) que envia um único pacote
a um BMC e analisa a resposta. O que se pode fazer com apenas um único pacote, pode-se
perguntar? Mais de 10 testes de segurança diferentes para IPMI, para começar. Bem, para começar
e para terminar, é apenas um pacote :) Requer Python, um BMC e um caminho aberto para
a porta UDP 623 para funcionar. A utilização é simplesmente "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">Uma descrição muito pequena</a> </span><br />
</p> <p>
Levando isto a extremos... bem, aqui está uma espécie de mega versão
do acima que o faz para todos os canais, todos os privilégios, todos... bem,
percebem a ideia. Para os monomaníacos (leiam os comentários ou o post
que escrevi sobre isto para ver porque faz o que faz!)
<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> Obter Device ID (GUID) </h4>
E aqui está um programa simples para enviar um pacote Get Device ID (ver
p250 da especificação IPMI v 2) a um sistema. Isto deveria, em teoria,
funcionar sem autenticação. Num pequeno levantamento que fiz, cerca de 90%
dos sistemas responderam a isto (embora nem todos com informação válida!)
Pode-se, por vezes, obter o fabricante e outra informação, como
números de modelo e afins, mas mais interessante ainda é obter
um ID único, tradicionalmente uma coisa difícil de obter pela rede.
<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> Extrair palavras-passe de um ficheiro de palavras-passe binário da SuperMicro</h4>
A Supermicro teve alguns problemas com a divulgação de ficheiros de palavras-passe do
seu BMC - por exemplo, veja este e outros relatos:
<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>
Para usar este script, basta dizer:
<blockquote>
<a href="https://github.com/zenfish/ipmi/blob/master/dump_SM.py">dump_SM.py</a> password_file
</blockquote>
Funciona para mim, sem garantias implícitas, garantido, etc.
<h4>Detecção</h4>
Bem, se você conseguir falar com a porta UDP 623, é bem simples
descobrir se um sistema remoto está executando IPMI. A menos que você esteja dentro
de um data center, porém, a maioria das pessoas bloqueia UDP. E mesmo que
não bloqueiem... a varredura UDP é tão lenta quanto se pode imaginar. Então eu
atualmente uso dois métodos básicos, aproveitando o venerável Nmap e
o ipmiping (das ferramentas GNU FreeIPMI). A coisa mais fácil de fazer é:
</p> <p>
<ul>
<li>Use o ipmiping para perguntar a um sistema remoto se ele fala IPMI ou não. Uma resposta
positiva é a indicação mais forte de que um sistema fala IPMI
(mas nada é certo!) Mais tecnicamente, ele envia duas chamadas IPMI
Get Channel Authentication Capabilities por meio de um datagrama de requisição
Get Channel Authentication Capabilities na porta UDP 623 (duas
requisições, já que usa UDP, e conexões não são garantidas.)
</p> <p>
Como o Nmap é muito mais eficiente na varredura de redes em larga escala
do que o ipmiping, este método só é usado se o Nmap disser que um host
tem a UDP 623 aberta.
</p> <p>
Para o bem ou para o mal, essa porta costuma estar bloqueada, então na maior parte
do tempo outros métodos têm mais chance de descobrir de forma oblíqua se
o IPMI está ou não em execução.
<li>O segundo método é um pouco vago e depende de um pouco de
indução (também conhecido como adivinhação). O Nmap varre portas conhecidas por
estarem associadas ao IPMI e a adições de fabricantes; a UDP 623 é óbvia (a
porta padrão do IPMI), mas há uma variedade de portas (tanto UDP quanto
TCP) que, por si só, podem não dar uma resposta imediata,
mas que, tomadas em conjunto, podem indicar fortemente sua presença.
TFTP, SNMP, SSH/SMASH, VNC e muitas outras estão entre elas.
</p> <p>
As portas são ponderadas pela sua capacidade indicativa e por se o
Nmap as encontra abertas, filtradas ou em outros estados.
</p> <p>
O Nmap também pode mostrar os banners dos serviços conectados. Eu uso
expressões regulares para caçar alvos - por exemplo, as strings
"iLO" e "DRAC" são bons indicadores de que um sistema pode estar executando
o Integrated Lights Out da HP, ou iLO.
</p> <p>
<strong>Nota:</strong> Atualmente eu NÃO uso o método de
broadcast ping (uma forma muito rápida de percorrer a sub-rede em que você
está); simplesmente não tenho dados sobre sua eficácia
nisso; embora seja muito rápido quando funciona, não senti que
permitisse o controle e a confiabilidade de varreduras arbitrárias.
Dois dos meus três sistemas (Dell e HP) responderam a um
RMCP ping. Nenhum respondeu a um broadcast ping pelo idiscover
(ipmiutil discover.) Todos, porém, responderam à minha ferramenta de
auditoria em Python abaixo.
</p> <p>
Infelizmente (é claro!) o espectro das comunicações e
redes entra em jogo - o nmap dá vários motivos diferentes
para uma porta estar aberta ou não (aberta, fechada, filtrada, etc.)
Mais uma tabela tem um conjunto de pesos que dá mais pontos a
uma porta aberta do que a um acerto "open|filtered" (como o Nmap
poderia dizer). Interpretar o nmap e ponderar é um pouco frustrante,
mas c'est la vie.
</p> <p>
Pegue todos os pesos, some todos os pontos e você tem um nível de
certeza de IPMI. Descobri em testes ad hoc que 15 pontos ou
mais são fortes indicadores de que o sistema está executando IPMI.
</p> <p>
Atualmente tenho vários limiares (não, possivelmente, provavelmente,
sim.) Nos testes - sem ter conhecimento de acesso a quaisquer outros servidores
além do meu próprio - parece funcionar razoavelmente bem. Ou seja,
as coisas que considero suspeitas e o meu modelo de pensamento
básico acima de facto fazem com que certos servidores subam ao topo e
deixam os hosts aleatórios em paz. Há alguns problemas reais com
falsos positivos, no entanto - muitas firewalls parecem indicar ao nmap que
há algo em qualquer porta (pensei em incluir uma ou duas portas raras
(se estiveres à escuta de algo como a porta 1 e 31313,
por exemplo, provavelmente não estás *realmente* à escuta disso!)
</p> <p>
Mas isto não pretende ser a palavra final sobre o tema. Deveria
ser bastante simples obter alguns dados decentes sobre banners IPMI, o meu
palpite é que seria de longe a melhor forma de varrer rapidamente grandes
quantidades de sistemas.
</ul>
</p> <p>
Aqui estão quatro peças de Perl para implementar o acima; uma faz a varredura,
outra interpreta, e as outras duas são usadas para ponderação. É uma
ferramenta de investigação ou uma prova de conceito, não um scanner de produção, mas
produz alguns resultados razoáveis.
</p> <p>
<strong>REQUERIDO: Nmap versão 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 básico, usa Nmap e, se disponível, 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">página man do ipmi_scan</a> - página man para o acima</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> - analisa a saída do acima, produz alguns resultados ponderados </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> - Alguns dados básicos de fornecedores... quais usam quais portas?</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> - Algumas ponderações básicas de fornecedores para o acima</span> </span></td> </tr>
</table>
</p> <p>
A utilização é bastante simples, embora um pouco peculiar. Deve ser executado como root. Verbose (-v) para muita saída.
<blockquote>
<pre>
# standard run:
./ipmi_scan.pl -A -v -O yes 192.168.0.0/24
# fast
./ipmi_scan.pl -tcp -v 192.168.0.0/24
# kitchen sink
./ipmi_scan.pl -A -v -O high 192.168.0.0/24
</pre>
</blockquote>
A varredura criará um par de ficheiros de resultados que correspondem aos
nomes de destino (as barras são convertidas em underscores.) Basta executar o
pós-processador sobre eles; passá-los por uma ordenação numérica inversa coloca-os
numa ordem mais interessante. Qualquer coisa acima de 10 eu chamaria suspeita,
onde maior que 20 é bastante certo que está a correr IPMI.
Neste caso usei
a flag terse (-t) para reduzir a saída ao mínimo.
<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>
Nos resultados acima, os 3 sistemas do topo estão realmente a correr IPMI,
mas apenas o HP indicou ao Nmap que a porta UDP 623 estava aberta - o meu Dell e
Supermicro devolveram a resposta mais ambígua "open|filtered",
que é bastante comummente um falso alarme, bleah. Talvez seja melhor
simplesmente aceitar e fazer o ping IPMI em paralelo com o scanner
(ou escrever um NSE para o fazer corretamente no Nmap.)
</p> <p>
<h4>Auditoria</h4>
Aqui estão alguns pequenos programas em python que - usando as ferramentas FreeIPMI - (a) absorvem a
configuração básica IPMI/BMC de um servidor e (b) fazem uma pequena verificação de segurança aos resultados.
Porque eu... bem, na verdade não há um bom motivo. Um está em python3 e o
outro em python2. Acho que estou testando sua preparação. Os programas estão
bastante comentados, especialmente ipmifreely.py, então confira isso para
mais detalhes sobre o que está acontecendo. Requer simplejson e ConfigParser,
talvez mais alguns.
</p> <p>
<span style="color: #ff0000;">VOCÊ DEVE</span> ter o <a title="FreeIPMI"
href="https://github.com/zenfish/ipmi/blob/master/www.gnu.org/software/freeipmi" target="_blank">FreeIPMI</a>
instalado, o que, no momento em que escrevo, acaba com as chances de Mac e Windows
de baixar um belo arquivo JSON de um servidor. E você realmente,
realmente deveria ter uma versão recente. Não diga que não avisei.
Mas a vida continua.
</p> <p>
A aquisição de dados é feita por meio de um programa python (I-check.py) que
requer credenciais válidas para obter dados. Ele converte os resultados em
JSON, que por sua vez pode ser verificado pela ferramenta de auditoria (ipmifreely.py.)
Há uma política de exemplo em "IPMI-policy.ini", onde coloquei alguns valores
para teste.
</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> - obtém os dados de configuração do 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> - analisa a saída do acima, gera alguns resultados</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> - arquivo de política do IPMI</span></td> </tr>
</table>
</p> <p>
Exemplo de uso:
<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>
Você pode conferir algumas <a href="https://github.com/zenfish/ipmi/blob/master/ipmi/bp.pdf">Práticas Recomendadas de Segurança do IPMI</a> para saber mais
sobre o que verificar e o que considero serem boas práticas a adotar, em termos de segurança.