ELM FatFs भेद्यता अनुसंधान

यह रिपॉजिटरी FatFs में पुष्टि की गई छह सुरक्षा भेद्यताओं का दस्तावेजीकरण करती है, साथ ही एक परीक्षण हार्नेस, फज़र और स्टैंडअलोन एक्सप्लॉइट डिस्क-इमेज जनरेटर भी शामिल है।

मूल FatFs सोर्स कोड FatFs-R0.16 निर्देशिका में पाया जा सकता है।

यह प्रोजेक्ट 2017 के सुरक्षा मूल्यांकन की वापसी है, जब मैन्युअल ऑडिट और कई दिनों के फज़िंग प्रयास ने FatFs ड्राइवर में कुछ बुनियादी, लेकिन दिलचस्प नहीं, बग की पहचान की थी। नौ साल बाद, मार्च 2026 में, हमने इस प्रोजेक्ट को विज़ुअल स्टूडियो कोड, GitHub Copilot को "auto" मोड में, और कुछ बुनियादी प्रॉम्प्ट का उपयोग करके दोबारा देखा, बिना किसी विशेष लूप, हार्नेस या स्किल्स के। परिणाम आश्चर्यजनक थे - मैन्युअल ऑडिट के दौरान अनदेखी किए गए बग, LLM की मदद से नए इनपुट के साथ स्वचालित रूप से फज़र बनाने पर तुच्छ रूप से खोजने योग्य बन गए। इस प्रयास ने न केवल दिलचस्प बग खोजे, बल्कि विभिन्न एम्बेडेड विकास परिदृश्यों में शोषण क्षमता को सत्यापित करने की प्रक्रिया को भी स्वचालित किया।

विस्तृत नोट्स के लिए कृपया निम्नलिखित फ़ाइलें देखें:

• 00_INITIAL.md: प्रारंभिक जाँच और निष्कर्ष
• 01_PROJECTS.md: प्रोजेक्ट गणना और FatFs संस्करण सर्वेक्षण
• 02_CRITICAL.md: सबसे अधिक प्रभाव वाले प्रोजेक्टों का विश्लेषण

FatFs क्या है?

FatFs ChaN (elm-chan.org) द्वारा C में लिखी गई एक पोर्टेबल, रॉयल्टी-मुक्त FAT/exFAT फाइलसिस्टम लाइब्रेरी है। यह संसाधन-सीमित एम्बेडेड सिस्टम के लिए डिज़ाइन की गई है, जिसमें OS पर कोई निर्भरता नहीं होती और इसे आमतौर पर सीधे फर्मवेयर में संकलित किया जाता है। यह FAT12, FAT16, FAT32, और exFAT, साथ ही वैकल्पिक LFN (लॉन्ग फाइल नेम) और GPT पार्टीशन समर्थन का समर्थन करती है।

क्योंकि FatFs छोटी, स्व-निहित और उदार लाइसेंस वाली है, यह माइक्रोकंट्रोलर फर्मवेयर के लिए डी-फैक्टो मानक FAT कार्यान्वयन बन गई है। लाइब्रेरी को आधिकारिक SDK, RTOS, बूटलोडर और एप्लिकेशन फ्रेमवर्क में शब्दशः वेंडर किया जाता है - जिसका अर्थ है कि एक एकल अपस्ट्रीम भेद्यता हर डाउनस्ट्रीम प्रोजेक्ट तक फैल जाती है जिसने ff.c की प्रतिलिपि बनाई है।

प्रमुख प्रोजेक्ट

निम्नलिखित प्रोजेक्टों में FatFs का एक भेद्य संस्करण बंडल किए जाने की पुष्टि की गई है। संपूर्ण विश्लेषण, प्रति-प्रोजेक्ट प्रसार पथ, और सुरक्षा संपर्क जानकारी के लिए 02_CRITICAL.md देखें।

CVE सारांश

हमलावर के लिए महत्व

FatFs का कोई CVE इतिहास, कोई सुरक्षा मेलिंग सूची, और कोई पैच अधिसूचना तंत्र नहीं है। हर डाउनस्ट्रीम प्रोजेक्ट जो ff.c को वेंडर करता है, उसे इन भेद्यताओं को स्वतंत्र रूप से खोजना, ट्रायेज करना और पैच करना होता है, आमतौर पर यह जाने बिना कि वे प्रभावित हैं। इसका मतलब है कि सार्वजनिक प्रकटीकरण और व्यापक सुधार के बीच की खिड़की दिनों में नहीं, बल्कि वर्षों में मापी जाएगी। इसलिए व्यावहारिक हमले की सतह एक सॉफ़्टवेयर एप्लिकेशन या सेवा नहीं है, बल्कि दर्जनों स्वतंत्र कोडबेस में फैले करोड़ों डिवाइस हैं, जिनमें से कई को कभी पैच नहीं मिलेगा।

सबसे विशिष्ट शोषण परिदृश्य ईविल SD कार्ड है: कुछ सेकंड के भौतिक एक्सेस वाला हमलावर किसी डिवाइस में स्टोरेज माध्यम बदल देता है - उपभोक्ता कैमरों से लेकर ड्रोन, 3-डी प्रिंटर से लेकर हज़ारों अन्य उत्पाद परिवारों तक। इस सेट में हर भेद्यता एक क्राफ्टेड FAT इमेज को माउंट करने पर ट्रिगर होती है, जो लगभग हमेशा इंसर्शन पर स्वचालित रूप से होती है, बिना किसी उपयोगकर्ता इंटरैक्शन की आवश्यकता के। हालांकि, भौतिक एक्सेस ही एकमात्र रास्ता नहीं है।

जो डिवाइस नेटवर्क स्रोत से FAT-स्वरूपित अपडेट पैकेज ग्रहण करते हैं, जैसे OTA अपडेट फ्रेमवर्क और ड्रैग-एंड-ड्रॉप बूटलोडर अपडेट, वे किसी भी हमलावर द्वारा शोषण योग्य हैं जो अपडेट पाइपलाइन में दुर्भावनापूर्ण इमेज पहुंचा सकता है। सप्लाई चेन समझौते, क्लियरटेक्स्ट HTTP अपडेट फीड पर AitM इंजेक्शन, या शौकिया फर्मवेयर वितरण पोर्टल पर पोस्ट की गई दुर्भावनापूर्ण इमेज। OTA पथ उन सभी डिवाइसों पर पूरी तरह से रिमोट है जिनमें FatFs के साथ माउंट करने से पहले अपडेट कंटेनर के एंड-टू-एंड प्रमाणित अखंडता सत्यापन का अभाव है।

CVE के अनुसार हमलावर के लिए महत्व

CVE-2026-6682 - पूर्णांक अतिप्रवाह जो हमलावर-नियंत्रित रीड लंबाई की ओर ले जाता है

किसी विशिष्ट फ़ील्ड को अतिप्रवाहित करने के लिए FAT32 वॉल्यूम तैयार करके, एक हमलावर पीड़ित डिवाइस से एक निश्चित बफर में हमलावर द्वारा चुने गए बाइट्स की संख्या को पढ़वा सकता है - कोड निष्पादन का एक सीधा रास्ता। बेयर-मेटल एम्बेडेड टारगेट पर एक्सप्लॉइट नियतिवादी है और इसके लिए हीप स्प्रे, ब्रूट फोर्स, या पूर्वापेक्षा के रूप में सूचना लीक की आवश्यकता नहीं होती।

हमलावर को उस FAT वॉल्यूम पर नियंत्रण चाहिए जिसे टारगेट माउंट करेगा। अधिकांश डिवाइसों के लिए इसका अर्थ SD कार्ड बदलने के लिए भौतिक एक्सेस है। जो डिवाइस नेटवर्क पर फर्मवेयर अपडेट स्वीकार करते हैं, या जो केवल FatFs द्वारा पार्स किए जाने के बाद अपडेट पैकेज की अखंडता पर भरोसा करते हैं, वे रिमोट रूप से शोषण योग्य हैं।

CVE-2026-6683 - exFAT सिंक में शून्य से भाग

जो हमलावर प्री-R0.16 FatFs चलाने वाले डिवाइस पर क्राफ्टेड exFAT वॉल्यूम पहुंचा सकता है, वह किसी भी बाद की राइट पर क्रैश की गारंटी दे सकता है। FatFs R0.16 ने आंशिक माउंट-समय गार्ड जोड़ा है जो राइट होने से पहले क्राफ्टेड वॉल्यूम को अस्वीकार कर सकता है, लेकिन अंतर्निहित अंकगणितीय दोष पूरी तरह से ठीक नहीं हुआ है। जो डिवाइस FAT-स्वरूपित माध्यम पर लिखकर OTA फर्मवेयर अपडेट लागू करते हैं, उनके खिलाफ एक सफल ट्रिगर एक-शॉट रिमोट ब्रिक बन जाता है: अपडेट प्रक्रिया बीच-राइट में क्रैश हो जाती है और डिवाइस हार्डवेयर डीबगर तक भौतिक एक्सेस के बिना पुनर्प्राप्त नहीं हो सकता।

हमलावर को चाहिए कि टारगेट उनके नियंत्रण वाले exFAT वॉल्यूम को माउंट करे और फिर कोई राइट या सिंक ऑपरेशन करे। ईविल-SD-कार्ड परिदृश्य अधिकांश एम्बेडेड डिवाइसों को कवर करता है; रिमोट शोषण के लिए टारगेट की OTA पाइपलाइन को बिना पहले अखंडता सत्यापन के हमलावर-आपूर्ति इमेज को स्वीकार और माउंट करना चाहिए।

CVE-2026-6684 - GPT पार्टीशन स्कैन में अनंत लूप

एकल फ़ील्ड को उसके अधिकतम मान पर सेट करके GPT डिस्क इमेज वितरित करने से टारगेट बिजली बंद होने तक डिस्क सेक्टर पढ़ने के लूप में फंस जाता है। बूटलोडर और बेयर-मेटल फर्मवेयर जो वॉचडॉग के बिना चलते हैं, उनके लिए यह स्थायी ब्रिक है: डिवाइस फिर कभी बूट पूरा नहीं करता। यह भेद्यता FatFs R0.16 में ठीक कर दी गई है, इसलिए यह केवल उन डिवाइसों को प्रभावित करती है जो पुराने रिलीज़ को वेंडर करते हैं।

हमलावर को चाहिए कि टारगेट उनके नियंत्रण वाली GPT-स्वरूपित डिस्क को माउंट करे, और टारगेट पर 64-बिट LBA समर्थन सक्षम के साथ प्री-R0.16 FatFs बिल्ड चल रहा हो। ध्यान दें कि बूटलोडर यहां सबसे आकर्षक टारगेट हैं, ठीक इसलिए क्योंकि उनमें कोई वॉचडॉग और कोई पुनर्प्राप्ति पथ नहीं होता।

CVE-2026-6686 - EOF से आगे सीक करने के बाद पुराना क्लस्टर डेटा पठनीय

जब किसी फ़ाइल को उसके अंत से आगे सीक करके बढ़ाया जाता है, तो FatFs नई आवंटित स्टोरेज को शून्य नहीं करता। पहले किसी हटाई गई फ़ाइल द्वारा उन सेक्टरों में लिखा गया कोई भी डेटा अगली प्रक्रिया द्वारा पठनीय होता है जो बढ़ाई गई फ़ाइल को खोलती है। जो डिवाइस OTA स्टेजिंग क्षेत्र में फर्मवेयर इमेज घुमाते हैं, या बूटलोडर और एप्लिकेशन के बीच SD कार्ड साझा करते हैं, वे पिछले फर्मवेयर ब्लॉब्स, कुंजियाँ, या अन्य संवेदनशील सामग्री को कम-विशेषाधिकार वाले पाठक को उजागर कर सकते हैं।

हमलावर को टारगेट के FAT वॉल्यूम पर किसी ऐसी फ़ाइल तक रीड एक्सेस चाहिए जिसे सीक ऑपरेशन के माध्यम से बढ़ाया गया हो। यह मुख्य रूप से स्थानीय या भौतिक-एक्सेस परिदृश्य है।

CVE-2026-6687 - exFAT वॉल्यूम लेबल के माध्यम से स्टैक अतिप्रवाह

अत्यधिक बड़े लेबल वाला exFAT वॉल्यूम प्रदान करने से, जब एप्लिकेशन f_getlabel() कॉल करता है, FatFs कॉलर के लेबल बफर को अतिप्रवाहित कर देता है। ST का STM32CubeMX कोड जनरेटर अपने द्वारा उत्पन्न हर FatFs-सक्षम प्रोजेक्ट में भेद्य बफर आकार उत्सर्जित करता है, जिसका अर्थ है कि यह भेद्यता वाणिज्यिक STM32 फर्मवेयर की एक विशाल और काफी हद तक अनारक्षित आबादी में मौजूद है। बिना स्टैक कुकीज़ या ASLR वाले बेयर-मेटल Cortex-M डिवाइसों पर (सामान्य स्थिति) यह एक-शॉट कोड निष्पादन प्रिमिटिव है।

हमलावर को चाहिए कि टारगेट उनके नियंत्रण वाले exFAT वॉल्यूम को माउंट करे और फिर f_getlabel() कॉल करे। FatFs लाइब्रेरी इसे आंतरिक रूप से कॉल नहीं करती - एप्लिकेशन को इसे स्पष्ट रूप से कॉल करना चाहिए। अधिकांश प्रोजेक्ट अपने स्वयं के माउंट-समय आरंभीकरण के भाग के रूप में ऐसा करते हैं, जिससे व्यवहार में उन प्रोजेक्टों के लिए आगे किसी हमलावर इंटरैक्शन की आवश्यकता नहीं होती।

CVE-2026-6688 - डायरेक्ट्री सूची में लंबे LFN फ़ाइलनाम के माध्यम से बफर अतिप्रवाह

FAT डायरेक्ट्री में लंबे नाम वाली फ़ाइल रखकर, एक हमलावर उस बफर को अतिप्रवाहित कर सकता है जिसे कॉलिंग एप्लिकेशन डायरेक्ट्री को इटरेट करते समय उस नाम को संग्रहीत करने के लिए उपयोग करता है। अतिप्रवाह फ़ाइलनाम की लंबाई के अनुपात में होता है, अधिकतम 255 बाइट्स तक। यह भेद्यता कॉलिंग कोड में है, स्वयं FatFs में नहीं, इसलिए प्रभाव टारगेट के अनुसार भिन्न होता है - लेकिन कोई भी एप्लिकेशन जो डायरेक्ट्री को इटरेट करता है और फ़ाइलनामों को बिना लंबाई जाँचे एक निश्चित-आकार बफर में कॉपी करता है, प्रभावित होता है।

हमलावर को चाहिए कि टारगेट उनके नियंत्रण वाले FAT वॉल्यूम पर डायरेक्ट्री ट्रैवर्स करे। exFAT आवश्यक नहीं है; यह FAT12, FAT16, और FAT32 पर काम करता है। FatFs कॉन्फ़िगरेशन में लॉन्ग फ़ाइलनाम समर्थन सक्षम होना चाहिए, जो हर प्रमुख वितरण में डिफ़ॉल्ट और अनुशंसित सेटिंग है।

भेद्यता विवरण

FatFs R0.16 और पुराने संस्करणों में छह अलग-अलग बग पहचाने गए।

CVE-2026-6682 - mount_volume() में FAT32 पूर्णांक अतिप्रवाह → हमलावर-नियंत्रित finfo.fsize

स्थान: ff.c mount_volume() - fasize *= fs->n_fats

DWORD गुणन अतिप्रवाह तब होता है जब BPB_FATSz32 को बड़ा मान उत्पन्न करने के लिए क्राफ्ट किया जाता है। BPB_FATSz32 = 0x80000001 और NumFATs = 2 के साथ:```c fasize = 0x80000001; fasize *= 2; // DWORD overflow → 0x00000002

छोटा किया गया `fasize` `fs->database` (डेटा क्षेत्र की शुरुआत) को FAT क्षेत्र के अंदर पहुँचा देता है। डिस्क इमेज को नियंत्रित करने वाला हमलावर ओवरलैपिंग सेक्टर पर एक नकली निर्देशिका प्रविष्टि रख सकता है, जिससे `f_stat()` हमलावर-नियंत्रित `finfo.fsize` लौटाता है। कोई भी एप्लिकेशन जो फिर `f_read(fp, buf, finfo.fsize, &br)` को `sizeof(buf)` के विरुद्ध काउंट सीमित किए बिना कॉल करता है, वह गंतव्य बफर को पूरी तरह से हमलावर-नियंत्रित बाइट्स से ओवरफ्लो कर देता है - RCE का सीधा रास्ता।

**सबसे खराब स्थिति का प्रभाव:** किसी भी एम्बेडेड डिवाइस पर रिमोट कोड निष्पादन (हीप या स्टैक ओवरफ्लो) जो FatFs से फ़ाइल का आकार पढ़ता है और उसे रीड लंबाई के रूप में उपयोग करता है।

---

### CVE-2026-6683 - `sync_fs()` में शून्य-से-भाग (Division-by-zero) (exFAT)

**स्थान:** `ff.c` `sync_fs()` - `(n_fatent - 2 - free_clst) * 100 / (n_fatent - 2)`

जब `BPB_NumClusEx = 0` होता है, `n_fatent = 2` हो जाता है, जिससे भाजक `(n_fatent - 2) = 0` बन जाता है। यह किसी भी क्राफ्टेड exFAT वॉल्यूम पर राइट या सिंक ऑपरेशन पर पहुँचा जाता है, जिससे SIGFPE / हार्ड-फॉल्ट उत्पन्न होता है और लक्ष्य क्रैश हो जाता है।

FatFs R0.16 माउंट समय पर आंशिक रूप से इससे सुरक्षा करता है (जब `NumClusEx = 0` होता है तो bitmap-cluster सत्यापन विफल हो जाता है)। पुराने संस्करण - R0.14b (ArduPilot, Mbed OS), R0.15 (RIOT OS, STM32), R0.13c (MicroPython) - में ऐसी कोई सुरक्षा नहीं है और वे बिना शर्त क्रैश होते हैं।

**सबसे खराब स्थिति का प्रभाव:** क्राफ्टेड exFAT वॉल्यूम पर किसी भी राइट पर सेवा से वंचित करना / सिस्टम क्रैश। OTA अपडेट के दौरान यह डिवाइस को ब्रिक कर सकता है।

---

### CVE-2026-6684 - `find_volume()` में असीमित GPT पार्टीशन स्कैन लूप (pre-R0.16)

**स्थान:** `ff.c` `find_volume()` - `for (i = 0; i < n_ent; i++) disk_read()`

जब `FF_LBA64 = 1` होता है, `find_volume()` FAT पार्टीशन की खोज के लिए हर GPT पार्टीशन प्रविष्टि पर पुनरावृत्ति करता है। pre-R0.16 बिल्ड में लूप काउंट सीधे डिस्क पर मौजूद `GPTH_PtNum` फ़ील्ड (0–0xFFFFFFFF) से लिया जाता है, जिसकी कोई ऊपरी सीमा नहीं होती। `GPTH_PtNum = 0xFFFFFFFF` वाली क्राफ्टेड GPT इमेज फ़ंक्शन के "not found" लौटाने से पहले लगभग एक अरब डिस्क रीड कराती है, जिससे सिस्टम स्थायी रूप से हैंग हो जाता है।

R0.16 ने `test_gpt_header()` पेश किया जो CRC32 को मान्य करता है और लूप में प्रवेश करने से पहले `PtNum ≤ 128` लागू करता है।

**सबसे खराब स्थिति का प्रभाव:** माउंट-समय पर स्थायी सेवा से वंचित करना। बिना वॉचडॉग वाले डिवाइसों (बूटलोडर, बेयर-मेटल FPGA बूटरॉम) पर यह सिस्टम को स्थायी रूप से ब्रिक कर देता है।

### CVE-2026-6686 - EOF से आगे `f_lseek()` के माध्यम से अप्रारंभित क्लस्टर डेटा

**स्थान:** `ff.c` `f_lseek()`:```c
if (!FF_FS_READONLY && fp->fptr > fp->obj.objsize) {
    fp->obj.objsize = fp->fptr;   // extend, but never zero-fill
    fp->flag |= FA_MODIFIED;
}

EOF से आगे सीक करने पर नए क्लस्टर आवंटित करने के लिए create_chain() कॉल होती है, लेकिन उनके सेक्टर कभी शून्य नहीं किए जाते। विस्तारित क्षेत्र का कोई भी बाद का रीड कच्चा पुराना डेटा लौटाता है - पहले हटाई गई फ़ाइलों की सामग्री जो रीसाइकिल किए गए क्लस्टर में बची रहती है।

सबसे खराब स्थिति का प्रभाव: हटाई गई फ़ाइल सामग्री (पुराने फर्मवेयर इमेज, निजी कुंजियाँ, सेंसर डेटा) का कम-विशेषाधिकार प्राप्त पाठक या कनेक्टेड इंटरफ़ेस के माध्यम से सूचना प्रकटीकरण।

CVE-2026-6687 - f_getlabel() में exFAT XDIR_NumLabel के माध्यम से स्टैक बफ़र ओवरफ़्लो

स्थान: ff.c f_getlabel():```c for (si = di = hs = 0; si < dj.dir[XDIR_NumLabel]; si++) { wc = ld_16(dj.dir + XDIR_Label + si * 2); nw = put_utf((DWORD)hs << 16 | wc, &label[di], 4); di += nw; }

The exFAT specification limits `XDIR_NumLabel` to 11 characters.  FatFs reads
this as a raw `BYTE` (0–255) with no validation.  A crafted volume with
`XDIR_NumLabel = 128` causes `f_getlabel` to write 128 characters into the
caller's buffer - typically `char label[12]` or `char label[24]` as generated
by STM32CubeMX - overflowing the stack by up to 244 bytes.

**Worst-case impact:** Stack buffer overflow in any caller of `f_getlabel()` on
an exFAT volume.  The canonical vulnerable pattern (`char label[12]`) appears
in every project generated by STM32CubeMX, AN3224, and UM1721.

---

### CVE-2026-6688 - लंबे LFN फ़ाइलनाम के माध्यम से कॉलर स्टैक/हीप ओवरफ्लो

**मूल कारण:** `FF_USE_LFN` सक्षम होने पर, `f_readdir()` `fno.fname` को पूर्ण लॉन्ग फ़ाइल नाम से भरता है - अधिकतम `FF_LFN_BUF` (255) वर्णों तक। केवल-SFN ऑपरेशन के लिए लिखे गए कॉलर निश्चित-आकार के पथ या नाम बफर (जैसे, `char path[16]`, `char name[14]`) का उपयोग करते हैं और `fno.fname` को बाउंड्स जाँच के बिना कॉपी करते हैं।

कई प्रोजेक्ट्स में पाए जाने वाले सामान्य कमजोर पैटर्न:```c
strcpy(entry->name, fno.fname);          // Zephyr: entry->name[14]
sprintf(path, "0:/%s", fno.fname);       // NodeMCU, ChibiOS demo, StarryPilot
sprintf(&cur_path[n], "/%s", fn);        // Samsung TizenRT

सबसे खराब स्थिति प्रभाव: किसी भी निर्मित FAT वॉल्यूम पर निर्देशिका ट्रैवर्सल के दौरान LFN लंबाई (255 बाइट्स तक) के अनुपात में स्टैक या हीप ओवरफ़्लो। एक निर्मित SD कार्ड जो entry->name[14] को 241 बाइट्स द्वारा ओवरफ़्लो करता है, Zephyr शेड्यूलर स्टैक फ्रेम को विश्वसनीय रूप से दूषित करता है।

रिपॉज़िटरी लेआउट```

├── harness/ Security test harness and exploit tools │ ├── Makefile Build system (see targets below) │ ├── test_ffconf.h FatFs config for the harness (LFN+exFAT+LBA64) │ ├── diskio_ramdisk.c/h In-memory block device (2 MiB RAM disk) │ ├── ffunicode_stub.c Minimal Unicode stub (CP437 pass-through) │ ├── test_harness.c Deterministic per-bug test suite (CVE-2026-6682 through CVE-2026-6688) │ ├── rce_demo.c Standalone CVE-2026-6682 RCE demo: OTA struct-pointer overwrite │ ├── libfuzzer_harness.c libFuzzer / AFL++ entry point │ ├── exploit_disks.c Standalone disk-image generator (see below) │ ├── build/ Compiled binaries │ └── img/ Generated exploit disk images (*.img) │ ├── fuzzer/ Go corpus generator and structural fuzzer │ ├── main.go Corpus builder + Go native fuzz targets │ ├── fat_image.go FAT12/16/32/exFAT/GPT image construction helpers │ └── corpus/ Seed corpus written by make corpus

---

## हार्नेस बिल्ड लक्ष्य

सभी लक्ष्य `harness/` निर्देशिका से चलाए जाते हैं।  `clang` की आवश्यकता है (या `CC=gcc` सेट करें)।

macOS पर `afl` लक्ष्य बनाने के लिए, `brew install afl++` का उपयोग करें और फिर अपने सिस्टम को तैयार करने के लिए `sudo afl-system-config` चलाएँ।

| लक्ष्य | विवरण |
|--------|-------------|
| `make` / `make test` | ASan + UBSan के साथ नियतात्मक परीक्षण सूट बनाएँ और चलाएँ |
| `make rce_demo` | CVE-2026-6682 RCE डेमो बनाएँ और चलाएँ (कोई सैनिटाइज़र नहीं, कोई स्टैक-प्रोटेक्टर नहीं) |
| `make exploit_disks` | सभी 14 एक्सप्लॉइट डिस्क इमेज बनाएँ और `harness/img/` में जनरेट करें |
| `make fuzz_asan` | libFuzzer बाइनरी बनाएँ (`build/fuzz_fatfs`) |
| `make afl` | AFL++ लक्ष्य बनाएँ (`PATH` में `afl-clang-fast` आवश्यक) |
| `make corpus` | Go जनरेटर के माध्यम से सीड कॉर्पस `harness/corpus/` में जनरेट करें |
| `make clean` | `build/` और `img/` हटाएँ |

### त्वरित आरंभ```sh
# Run the full deterministic test suite
cd harness && make

# Run the CVE-2026-6682 RCE demo
make rce_demo

# Generate all exploit disk images
make exploit_disks

# Fuzz with libFuzzer (requires clang)
make fuzz_asan
build/fuzz_fatfs -max_len=2097152 corpus/

# Fuzz with AFL++
make corpus afl
afl-fuzz -i corpus/ -o findings/ -- build/afl_fatfs @@

एक्सप्लॉइट डिस्क इमेजेस

make exploit_disks 14 रॉ डिस्क इमेजेस harness/img/ में बनाता है, एक प्रति प्रोजेक्ट/भेद्यता संयोजन के लिए। प्रत्येक इमेज का जनरेशन समय पर बंडल किए गए FatFs के साथ माउंट करके स्व-परीक्षण किया जाता है। इमेजेस को एक भौतिक SD कार्ड पर लिखा जा सकता है:```sh dd if=harness/img/exploit_bug1_espidf.img of=/dev/sdX bs=512

| छवि | बग | लक्षित प्रोजेक्ट | प्रभाव |
|-------|-----|------------------|--------|
| `exploit_bug1_fat32.img` | CVE-2026-6682 | सामान्य | `f_read` के माध्यम से पॉइंटर-आकार का पेलोड पहुँचाता है |
| `exploit_bug1_espidf.img` | CVE-2026-6682 | espressif/esp-idf | `finfo.fsize=16 MB` → `malloc`/`fread` हीप ओवरफ़्लो |
| `exploit_bug1_stm32.img` | CVE-2026-6682 | STMicro stm32-mw-fatfs | `finfo.fsize=1 MB` → 1 KB फर्मवेयर बफर ओवरफ़्लो |
| `exploit_bug1_keystone3.img` | CVE-2026-6682 | KeystoneHQ वॉलेट | `finfo.fsize=512 KB` → OTA बफर ओवरफ़्लो |
| `exploit_bug1_ardupilot.img` | CVE-2026-6682 | ArduPilot / Mbed OS / RIOT / MicroPython | `finfo.fsize=2 MB` → लॉग-रीड बफर ओवरफ़्लो |
| `exploit_bug2_exfat.img` | CVE-2026-6683 | ArduPilot / Mbed OS / MicroPython / RIOT | `BPB_NumClusEx=0` → `sync_fs` डिवाइड-बाय-ज़ीरो (पूर्व-R0.16 पर SIGFPE) |
| `exploit_bug3_gpt.img` | CVE-2026-6684 | vivado-risc-v / tinyuf2 / circle | `GPTH_PtNum=0xFFFFFFFF` → बूट पर अनंत लूप (पूर्व-R0.16) |
| `exploit_bug5_stale.img` | CVE-2026-6686 | RT-Thread / tinyuf2 / ArduPilot / RIOT | `f_lseek` विस्तार `0xAA`-सीडेड डिलीटेड-क्लस्टर डेटा उजागर करता है |
| `exploit_bug6_stm32.img` | CVE-2026-6687 | STMicro stm32-mw-fatfs | `XDIR_NumLabel=128` → CubeMX `label[12]` का 117-बाइट ओवरफ़्लो |
| `exploit_bug6_zephyr.img` | CVE-2026-6687 | Zephyr / ArduPilot / RIOT / MicroPython | `XDIR_NumLabel=255` → `label[24]` का 216-बाइट ओवरफ़्लो |
| `exploit_bug7_max255.img` | CVE-2026-6688 | NodeMCU / ChibiOS / StarryPilot / TizenRT | 255-अक्षर LFN किसी भी निश्चित बफर < 255 बाइट्स को ओवरफ़्लो करता है |
| `exploit_bug7_zephyr.img` | CVE-2026-6688 | Zephyr | 14-अक्षर LFN → `entry->name[14]` का 1-बाइट NUL ओवरफ़्लो |
| `exploit_bug7_grblhal.img` | CVE-2026-6688 | grblHAL | ऑफ-बाय-वन: गार्ड पिछली एंट्री की जाँच करता है; 11-अक्षर LFN `dirent.name[12]` को 1 NUL बाइट से ओवरफ़्लो करता है |

---

## नियतात्मक टेस्ट सूट (`test_harness.c`)

टेस्ट हार्नेस मेमोरी में बनाई गई हाथ से तैयार डिस्क इमेज के साथ छह बगों का परीक्षण करता है, फिर पुष्टि करता है कि कमजोर कोड पथ तक पहुँचा गया था:

- **CVE-2026-6682** - एक `BPB_FATSz32=0x80000001` FAT32 इमेज बनाता है, उसे माउंट करता है, और
  पुष्टि करता है कि `fs.database` FAT क्षेत्र के अंदर आता है; फिर पूरी
  RCE श्रृंखला निष्पादित करता है (नकली निर्देशिका प्रविष्टि → प्लांटेड फ़ंक्शन पॉइंटर का `f_read` →
  `rce_proof_of_execution()` कॉल किया गया)।
- **CVE-2026-6683** - `(n_fatent-2)` भाजक को दस्तावेज़ित करता है और अंकगणितीय
  पथ की पुष्टि करता है; जाँच करता है कि R0.16 इमेज को माउंट समय पर अस्वीकार करता है।
- **CVE-2026-6684** - एक `GPTH_PtNum=0xFFFFFFFF` GPT इमेज बनाता है और पुष्टि करता है कि
  R0.16 इसे `test_gpt_header()` के माध्यम से ≤ 3 डिस्क रीड के भीतर अस्वीकार करता है।
- **CVE-2026-6686** - सभी डेटा क्लस्टरों को `0xAA` से पहले से सीड करता है, एक छोटी फ़ाइल लिखता है,
  `f_lseek` के माध्यम से उसे बढ़ाता है, और पुष्टि करने के लिए वापस पढ़ता है कि पुराने बाइट्स दिखाई देते हैं।
- **CVE-2026-6687** - `XDIR_NumLabel=128` के साथ एक exFAT इमेज बनाता है, प्रोब बफर पर
  `f_getlabel` कॉल करता है, और बाइट 24 से आगे के ओवरफ़्लो की गिनती करता है।
- **CVE-2026-6688** - 50-अक्षर LFN के साथ एक FAT16 निर्देशिका बनाता है, इसे
  `f_readdir` के माध्यम से पढ़ता है, और पुष्टि करता है कि `fno.fname` की लंबाई विशिष्ट कॉलर बफर से अधिक है।

---

## CVE-2026-6682 RCE डेमो (`rce_demo.c`)

CVE-2026-6682 शोषण श्रृंखला का एक स्व-निहित, यथार्थवादी प्रदर्शन, जो एम्बेडेड OTA फर्मवेयर-अपडेट कोड पर आधारित है।  एक struct को एक निश्चित-आकार वाले हेडर बफर के साथ घोषित किया जाता है, जिसके तुरंत बाद एक फ़ंक्शन-पॉइंटर कॉलबैक होता है:```c
typedef struct {
    uint8_t  fw_header[128];   // buffer the developer reads into
    uint32_t crc32;
    uint32_t version;
    void   (*on_apply)(void);  // callback - attacker target
} ota_ctx_t;

डेमो एक निर्मित डिस्क इमेज बनाता है जहाँ DIR_FileSize = sizeof(ota_ctx_t) होता है, पेलोड सेक्टर में सही बाइट ऑफसेट पर rce_win() का पता रखता है, फिर OTA चेकर चलाता है। f_read fw_header से आगे on_apply में लिखता है, और उसके बाद ctx.on_apply() कॉल rce_win() को आह्वानित करता है, जिससे rce_canary = 0xDEAD सेट हो जाता है।

बिल्ड करें और चलाएँ: cd harness && make rce_demo

फ़ज़र (fuzzer/)

Go फ़ज़र के दो मोड हैं:

1. कॉर्पस जनरेटर (go run . -out ./corpus या make corpus): 18 संरचित सीड इमेज लिखता है जो छह बग वर्गों, तीनों FAT वेरिएंट्स, सामान्य और विकृत GPT, और एक वैध FAT32 इमेज के 50 यादृच्छिक सिंगल-बाइट म्यूटेशन को कवर करती हैं।
2. Go नेटिव फ़ज़र (go test -fuzz=FuzzFAT32BPB): BPB फ़ील्ड मानों का संरचनात्मक फ़ज़िंग, Go के बिल्ट-इन फ़ज़र के साथ; यह सत्यापित करता है कि फ़ील्ड संबंध C में कॉल किए बिना बने रहते हैं।

सीड कॉर्पस libFuzzer बाइनरी (build/fuzz_fatfs) और AFL++ टार्गेट (build/afl_fatfs) दोनों को फीड करता है।

QEMU के माध्यम से ESP-IDF

इस रिपॉजिटरी में एक सेल्फ-कंटेन्ड Docker टेस्ट केस शामिल है जो एक ESP32-प्रासंगिक CVE-2026-6688 कॉलर ओवरफ्लो पैटर्न को FatFs डायरेक्टरी ट्रैवर्सल का उपयोग करते हुए Espressif QEMU ESP32 इम्यूलेटर के अंदर ESP-IDF फर्मवेयर पर प्रदर्शित करता है।

वर्तमान PoC इमेज जानबूझकर हाइब्रिड है:

• यह CVE-2026-6682-शैली की निर्मित FAT32 ज्योमेट्री को बनाए रखता है ताकि जाली रूट डायरेक्टरी विश्वसनीय रूप से नियंत्रित हो।
• यह एक लंबा VFAT फ़ाइलनाम एम्बेड करता है जो readdir() द्वारा लौटाया जाता है।
• फिर एप्लिकेशन सार्वजनिक ESP32 कोड पैटर्न (strcpy / strcat पथ असेंबली) को मिरर करता है और लंबे फ़ाइलनाम को एक निश्चित 32-बाइट बफर में कॉपी करता है।

वह अंतिम कॉपी CVE-2026-6688-शैली की स्थिति है: कॉलर-साइड ओवरफ्लो लंबे फ़ाइलनामों के असीमित उपयोग के माध्यम से।``` cd esp32-qemu-test ./run.sh

या वैकल्पिक रूप से:```
docker build -t fatfs-esp32-vuln-test esp32-qemu-test/
docker run --rm fatfs-esp32-vuln-test

यह CVE-2026-6688 से क्यों मेल खाता है

f_readdir() 255 वर्णों तक लंबे नाम (LFN) लौटा सकता है। कई वास्तविक एम्बेडेड कॉलर अभी भी नामों को छोटे फिक्स्ड बफ़र्स में कॉपी करते हैं। सार्वजनिक ESP32 उदाहरणों में इसके समतुल्य पैटर्न शामिल हैं:``` strcpy(fn, entry->d_name); strcat(path, "/"); strcat(path, entry->d_name);

एक निर्मित FAT इमेज के साथ जिसमें एक लंबा फ़ाइल नाम होता है, ये प्रतियाँ कॉलर बफ़र को ओवरफ्लो कर देती हैं।

### इस रिपॉजिटरी में PoC श्रृंखला

| चरण | विवरण | मार्कर |
|------|-------------|--------|
| 1 | निर्मित स्टोरेज इमेज माउंट होती है और हमलावर-नियंत्रित निर्देशिका प्रविष्टियाँ लौटाती है | (माउंट सफल) |
| 2 | लंबा फ़ाइल नाम `char name[32]` में सार्वजनिक-पैटर्न असुरक्षित कॉपी पथ के माध्यम से कॉपी किया जाता है | `[VULN-BUG7-CONFIRMED]` |
| 3 | गार्ड भ्रष्टाचार लॉग किया जाता है, उसके बाद QEMU में कंट्रोल-डेटा क्रैश होता है | `guard=0x61616161`, `Guru Meditation Error` |

PoC अभी भी संदर्भ और मार्कर आउटपुट के लिए एक विरासत CVE-2026-6682-शैली OTA कॉलबैक ओवरराइट पथ बनाए रखता है (`PWNED-UART`), लेकिन यहाँ बग-विशिष्ट प्रमाण ऊपर दिया गया लंबे-फ़ाइल-नाम कॉलर ओवरफ्लो मार्कर है।

प्रतिनिधि आउटपुट:```
I (...) fatfs_vuln: PoC: CVE-2026-6688 long-LFN caller overflow probe (ESP32 public-pattern copy path)
...
PWNED-UART
E (...) fatfs_vuln: [VULN-BUG7-CONFIRMED] guard corrupted after filename copy
E (...) fatfs_vuln: entry='esp32_lfn_trigger_aaaa...aaaa.bin' len=78 guard=0x61616161
Guru Meditation Error: Core  0 panic'ed (...)

CVE क्रमांकन पर नोट

इस शोध के दौरान एक unsigned-subtraction व्यवहार को पहले नोट किया गया और रिपोर्ट किया गया था, जिसे बाद में CVE कॉर्पस से हटा दिया गया। इसी कारण आपको क्रमांकन में एक अंतर दिखेगा, क्योंकि हमने उस वापस लिए गए रिकॉर्ड को जानबूझकर इस रिपॉज़िटरी के सक्रिय CVE सेट से हटा दिया है। CVE प्रोग्राम अप्रकाशित रिकॉर्ड के संदर्भों को लेकर कुछ विशेष हो सकता है, इसलिए यह इतिहास को सटीक रखते हुए क्रॉस-लिंकिंग की उलझन से बचाता है। अत्यधिक जिज्ञासुओं के लिए, आप उस निष्कर्ष के विवरण के लिए इस रिपॉज़िटरी के git इतिहास को देख सकते हैं।

विवादित रिपोर्ट पर हमारा ध्यान आकर्षित करने के लिए David Brown का धन्यवाद। अपस्ट्रीम स्थिति और पैच मार्गदर्शन के लिए, ChaN के आधिकारिक FatFs पैच पेज पर जाएँ: https://elm-chan.org/fsw/ff/patches.html