क्या cigarette lighter से root अधिकार पाए जा सकते हैं?

 (da.vidbuchanan.co.uk)
2 पॉइंट द्वारा GN⁺ 2024-10-08 | 2 टिप्पणियां | WhatsApp पर शेयर करें
  • सिर्फ piezoelectric cigarette lighter से laptop के DDR3 memory bus में electromagnetic fault induce करके, unprivileged Linux user से root shell तक पाने वाला local privilege escalation प्रयोग सफल हुआ
  • Samsung S3520 laptop के SODIMM data pin पर 15Ω resistor और antenna की तरह काम करने वाला wire solder किया गया, और पास में lighter click करके ऐसी memory error बनाई गई जिसमें खास bit flip होता था
  • CPython प्रयोग में DQ7 line fault से object pointer का bit 7 flip कराकर उसे bytes के अंदर मौजूद नकली bytearray structure को reference कराने दिया गया, और arbitrary memory read/write primitive बनाया गया
  • Linux privilege escalation page table को physical memory में बड़े पैमाने पर spray करने के बाद, PTE पढ़ते समय bit 29 fault induce करके इस तरह काम करता है कि user-accessible mapping page table की ओर point करने लगे
  • सफलता के बाद /usr/bin/su का पहला page physical memory में ढूंढकर उसे छोटे setuid root ELF से replace किया गया और page cache को दूषित किया गया; प्रयोग environment में reliability SSH access पर अनुभव के अनुसार करीब 50%, और graphical shell में करीब 20% थी

Lighter-आधारित EMFI प्रयोग की शुरुआत

  • Software bug न होने पर भी fault injection से असामान्य behavior पैदा किया जा सकता है
    • fault injection तरीकों में software-controlled data corruption, power glitch, clock glitch, electromagnetic pulse, laser आदि शामिल हैं
  • Hardware fault injection में आमतौर पर fault डालने के समय और स्थान की precision चाहिए, इसलिए specialist equipment और cost की जरूरत होती है
  • शुरुआती बिंदु piezoelectric BBQ igniter को inductor से जोड़कर low-budget electromagnetic fault injection (EMFI) tool के रूप में इस्तेमाल करने का approach था
    • पहले Arduino पर चलने वाले software AES implementation को DFA से attack करने में सफलता मिली थी
  • Nintendo Switch 2 announcement करीब आने के संदर्भ में, Switch 1 जैसी system software और software bugs की कमी की उम्मीद करते हुए low-cost EMFI experiment फिर से किया गया

Test target और DDR bus fault

  • Test target 2011 में बना Samsung S3520 laptop था, जिसमें Intel i3-2310M CPU और 1GB DDR3 RAM है
    • यह lightweight desktop Linux distribution Arch चला सकता था और खराब हो जाने पर ज्यादा नुकसान न हो, इसलिए चुना गया
  • लक्ष्य injected hardware fault पर आधारित local privilege escalation exploit लिखना था
  • सबसे physically vulnerable point के रूप में DRAM memory और system को जोड़ने वाला DDR bus चुना गया
    • SODIMM में read/write data bits ले जाने वाले 64 DQ pins, DQ0~DQ63 होते हैं
  • Experimental setup में DQ26 माने गए pin पर 15Ω resistor और एक wire solder किया गया था
    • wire antenna की तरह आसपास की electromagnetic interference लेकर data bus तक पहुंचाता है
    • resistor interference strength को limit करने के लिए था ताकि normal memory operation लगातार बाधित न हो; वास्तव में शायद इसकी जरूरत न भी हो
  • साधारण piezoelectric lighter को antenna wire के पास click करने भर से memtest में memory errors reliably दिखने लगीं
    • दिखाई गई सभी errors bit 29 flip के रूप में थीं
    • solder किया गया pin DQ26 माना गया था, लेकिन bit 29 flip होने की वजह pin गलत गिनना या motherboard का data lines को बदले हुए तरीके से route करना हो सकता है
  • finger reaction speed के स्तर पर होने के कारण fault injection timing control precise नहीं है
    • fault होने पर किसी specific 64-bit read या write में वही bit flip होने की संभावना अधिक होती है

CPython में bit flip का दुरुपयोग

  • पहला experiment CPython में sandbox escape जैसे exploit को बनाने का था
    • CPython खुद sandbox नहीं है, इसलिए यह कोई वास्तविक security boundary bypass नहीं है; यह familiar internals का इस्तेमाल करने वाला preparation step था
  • इस experiment में पहले वाली photo के DQ26 की जगह DQ7 पर solder किए गए wire का इस्तेमाल किया गया
  • CPython objects garbage collection heap में होते हैं, और object header में refcount और type object pointer होता है, उसके बाद type-specific fields आते हैं
    • bytes object में length field के बाद data खुद उसी heap allocation में होता है
    • bytearray object में length field के बाद actual data storage buffer की ओर point करने वाला pointer होता है
  • मुख्य strategy bytes object के अंदर data के रूप में fake bytearray structure रखना है
    • अगर CPython को इस fake object का reference देने के लिए trick किया जाए, तो attacker द्वारा चुने गए bytearray के length और pointer fields से arbitrary memory read/write संभव हो जाता है
  • bit 7 flip करने वाला fault 64-bit word में pointer में 128 जोड़ने या घटाने का effect देता है
    • fake bytearray को bytes object के अंदर +128-byte offset पर रखने से, bytes object pointer fault के कारण fake bytearray pointer बन सकता है
    • यह conversion 50% probability के साथ इच्छित direction में होता है
  • यह बात महत्वपूर्ण है कि memory content itself नहीं, बल्कि memory bus की read/write operation glitch होती है
    • Rowhammer की तरह stored data बदलने का तरीका नहीं है; bus पर चल रही access corrupt होती है
  • इच्छित pointer access bus activity का ज्यादातर हिस्सा बने, इसके लिए उसी object reference को बड़े tuple में भरा गया
    • CPU cache DRAM access कम कर देता है, इसलिए 3MiB cache से बड़ी structure को sequentially access कराया गया ताकि हर बार DRAM से read हो
    • Python का is pointer comparison की तरह काम करता है, इसलिए pointer बदला या नहीं यह check करने में इस्तेमाल हुआ
  • पूरा CPython exploit source ddr3_dq7.py में है
    • TESTING variable से hardware के बिना software में bit flip simulate किया जा सकता है

Linux privilege escalation के लिए जरूरी memory structures

  • Linux local privilege escalation में cache, virtual memory और page tables, TLB मुख्य structures के रूप में इस्तेमाल हुए
  • DRAM अपेक्षाकृत slow है, इसलिए CPU L1, L2, L3 cache इस्तेमाल करता है
    • experiment laptop का L3 cache 3MiB है
    • cache hit होने पर DRAM access नहीं होता, और cache miss होना जरूरी है तभी DRAM read होता है
  • cache के नजरिए से minimum unit cache line है, और इस laptop में यह 64 bytes है
    • एक byte पढ़ने पर भी अगर data cached नहीं है, तो 64-byte DRAM read होता है
    • DDR data bus 64-bit width का है, इसलिए यह read 8 sequential access bursts में process होता है
  • x86-64 virtual memory 4KiB pages और tree-like page tables से implement होती है
    • इस platform में 4-level page table है
    • हर page table 4KiB page है और 512 64-bit PTE रखता है
    • upper-level PTE अगले level के page table के physical address की ओर point करता है, और level 0 PTE target physical page की ओर point करता है
    • root page table का physical address CR3 CPU register में store होता है
  • PTE में जरूरी हिस्सा physical address field है
    • flag bits mask करने पर page-aligned physical memory address बचता है
  • TLB CPU के अंदर hardware है जो virtual address से physical address तक page mappings cache करता है
    • experiment laptop का exact TLB size पता नहीं है, लेकिन यह लगभग 1024 entries के स्तर का लगता है

Page table को user memory में खींचना

  • Linux exploit strategy Mark Seaborn के Rowhammer exploit के elements से inspired थी
  • लक्ष्य अपने process के page tables को user-accessible memory के रूप में map करना है
    • ऐसा होने पर PTE modify करके arbitrary physical memory access किया जा सकता है
  • physical memory layout को precise control करने के बजाय, physical memory का ठीक 50% level-0 page tables से भरा गया
  • इसके बाद R/W mappings को repeatedly access करके TLB को bypass किया गया
    • mappings की संख्या TLB size से अधिक होने के कारण हर access में page table walk force किया जा सकता है
    • उस walk के दौरान level-0 PTE read में bit 29 fault पैदा करना लक्ष्य है
  • bit 29 flip होने पर PTE जिस physical address की ओर point करता है, वह 512MiB offset जितना बदल जाता है
    • अगर luck अच्छा हो, तो बदला हुआ address पहले spray किए गए level-0 page tables में से किसी एक की ओर point करता है
    • इस स्थिति में जो mapping मूल रूप से normal R/W page दिखनी चाहिए, वह page table को normal R/W page की तरह expose करती है
  • सिद्धांत रूप में bit 29 से bit 12 तक कोई भी bit flip काम कर सकता है
    • bit 12 4KiB offset के बराबर है
    • मुख्य बात यह है कि PTE “कहीं और” point करे, और physical memory का लगभग 50% exploitable page tables से भरा हो
  • Antenna wire solder करना अनिवार्य नहीं भी हो सकता है
    • अगर पर्याप्त strong electromagnetic interference बनाई जा सके तो संभावना है, लेकिन system crash या damage की संभावना कहीं ज्यादा बढ़ जाती है

level-0 page table spray करने का तरीका

  • पहले Linux के memfd_create से memory-based file बनाई गई
    • यह Mark Seaborn exploit की /dev/shm/ file जैसा role निभाती है, लेकिन filesystem को सीधे touch नहीं करती
  • उसी buffer को mmap से कई बार map किया गया
    • MAP_FIXED option से हर mapping को virtual memory में 2MiB-aligned होने के लिए force किया गया
    • यह alignment हर बार नया level-0 page table बनना सुनिश्चित करता है
  • Linux में per-process mappings, यानी VMA, की लगभग 2^16 limit होती है
    • हर mapping को 32MiB length का बनाया गया ताकि एक mapping 16 level-0 page tables बनाए
  • हर mapping virtual address space में 32MiB लेती है, लेकिन PTEs उसी physical page की ओर point करते हैं
    • physical memory cost केवल level-0 page tables की है
    • इस तरीके से memory भरने तक page tables spray किए जा सकते हैं

Physical memory read/write और su page cache contamination

  • Fault का इंतजार करते हुए R/W mapping को repeatedly access किया गया, और expected से अलग value लौटे तो fault detect किया गया
    • अगर returned data PTE जैसा दिखे, तो मतलब page table पर R/W access मिल चुका है
  • अगला step यह पता करना है कि यह page table किस virtual address से संबंधित है
    • PTE को physical address 0 की ओर point करने के लिए modify किया गया
    • फिर R/W mappings को scan करके देखा गया कि कौन सी mapping बदली है
  • PTE modify करने पर भी MMU तुरंत notice नहीं करता
    • क्योंकि virtual-physical mapping TLB में cached होती है
    • user space से सीधे TLB flush करने का तरीका न पता होने के कारण, हजारों R/W mappings को repeatedly access करके TLB को new values से भरा गया और old values को evict किया गया
  • इस point पर पूरी physical memory के लिए read/write access संभव हो जाता है
  • इसके बाद /usr/bin/su executable को read-only mode में open करके पहला page mmap किया गया
    • /usr/bin/su एक setuid root executable है
    • पूरी physical memory scan करके वही page ढूंढा गया
    • मिले हुए physical page पर write access करके, उसे root shell खोलने वाले 4KiB से छोटे ELF payload से replace किया गया
  • अगली बार su execute होने पर Linux देखता है कि पहला page पहले से memory में है और उसे disk से फिर नहीं पढ़ता
    • contaminated page cache reuse करके injected ELF execute होता है
    • injected ELF echo 1 > /proc/sys/vm/drop_caches से page cache खाली करता है, ताकि अगली su execution normal तरीके से काम करे
  • पूरा Linux exploit source linux_x86_64_lpe.c में है

Reliability और environment constraints

  • demo run में luck अच्छा रहा और lighter के एक click से अच्छा glitch हो गया
    • पहले की कई कोशिशों में पूरा system crash हो गया था
  • पूरे exploit की reliability strict तरीके से measure नहीं की गई
    • laptop screen बंद रखकर SSH से connect रहने पर अनुभव के अनुसार करीब 50% लगती है
    • graphical shell में करीब 20% के पास है
  • experiment system integrated graphics इस्तेमाल करता है
    • GPU की memory access exploit में बाधा डाल सकती है
  • pipewire, sshd, systemd से जुड़ी background services और swap भी चालू थे
    • यह realistic desktop Linux environment बनाए रखने का choice था, और इन्हें disable करने पर reliability बढ़ सकती है
  • अगर ज्यादा RAM install होती, तो page tables से higher ratio भरा जा सकता था, जिससे overall reliability बढ़ सकती थी

संभावित उपयोग और बचे हुए सवाल

  • अगर Windows में reliable EMFI local privilege escalation संभव हो, तो TPM-based anti-cheat द्वारा system पर allowed software को restrict करने की स्थिति पर असर पड़ सकता है
  • Android के SafetyNet या Play Integrity checks के लिए भी ऐसी ही कहानी संभव है, लेकिन phone में glitch modchip लगाना ज्यादा कठिन है
  • low-level performance optimization में page tables और TLB की जानकारी अक्सर सीधे जरूरी नहीं होती, लेकिन इस exploit में virtual memory illusion बनाए रखने वाली structure सीधे attack target बन जाती है
  • applicability को लेकर अभी कई चीजें verify करनी बाकी हैं
    • क्या यह DDR4, DDR5 पर भी काम करता है
    • क्या यह ARM पर भी काम करता है
    • ECC के अलग-अलग types, खासकर DDR5 Link-ECC, इसे कितना mitigate करते हैं
    • RP2040 जैसे device से similar fault electronically trigger करने का सबसे simple तरीका क्या है
    • क्या इसे hypervisor escape में इस्तेमाल किया जा सकता है
    • क्या इसे WebKit exploit या Nintendo Switch kernel exploit बनाया जा सकता है

संबंधित पढ़ाई

2 टिप्पणियां

 
mammal 2024-10-08

इससे मुझे लाइटर से इग्नाइटर निकालकर आर्केड मशीन में सिक्के ऊपर चढ़ाने की तरकीब याद आ गई।
 
GN⁺ 2024-10-08
Hacker News की राय

  • यहाँ प्रेरणा Switch 2 पर root privileges हासिल करने की थी, और Linux पर root पाना बस concept proof था
    लक्ष्य व्यावहारिक रूप से exploit की जा सकने वाली कोई मूलभूत security vulnerability दिखाना नहीं था, बल्कि TPM या गेम के kernel-level anti-cheat को तोड़े बिना अपने hardware की असली ownership वापस पाने जैसा था

    • इरादा समझ आता है, लेकिन असली point मुझे साफ नहीं है। 20 साल पहले, जब consoles घाटे या कम margin पर बिकने वाले शक्तिशाली computers थे, तब यह ज़्यादा समझ आता था; लेकिन अब Nintendo consoles को profit पर बेचता है और Switch 2 के साथ भी संभवतः ऐसा ही होगा
      काम impressive है और software freedom बचाने की कोशिश का स्वागत है, लेकिन मैं तो किसी विकल्प को support करना पसंद करूँगा। उन्हें install base जैसे दिखने वाले numbers और profit क्यों दें? शुरू से ही root access को feature की तरह देने वाला Steam Deck या कोई और handheld device खरीद लें

  • लेख बहुत अच्छी तरह लिखा गया है और चुनौती भी शानदार है, लेकिन मेरा दिमाग “physical access हो तो game over” वाली hacking common wisdom की तरफ प्रतिक्रिया देता है
    सबसे पहले दिमाग में यही आया कि physical access हो तो BIOS को reflash करें, driver backdoor डालें, live OS से boot करके /etc/{passwd,shadow,groups, etc} में छेड़छाड़ कर दें।
    लेकिन फिर याद आया कि disk encrypted हो तो physical access वाले ज़्यादातर attacks संभव नहीं होते, और तब ऐसा attack बेहद आकर्षक लगता है। antenna वाला idea interference device लगे हुए hardware तक extend किया जा सकता है, और wireless medium से बाहर communicate करवा कर attacker remote तरीके से interference पैदा कर सकता है। अगर इसके साथ attacker-controlled website हो जिस पर victim को जाने के लिए trick किया जाए, तो यह practical लगने लगता है

    • introduction में motivation portable game console को root/jailbreak करने की है। physical access तो है, लेकिन फिर भी “unauthorized” access पाना चाहते हैं—ऐसी स्थिति काफ़ी plausible है
    • मेरे हिसाब से BIOS reflash करने से ख़ास फायदा नहीं होगा। execution शुरू होने से पहले CPU hardware सही private-key signature check करता है, इसलिए पहले आपको sign करना पड़ेगा
      यह electromagnetic interference technique CPU को ही trick करती है, इसलिए जब तक कोई नया paging algorithm न आए, मुझे नहीं पता इसे कैसे fix किया जा सकता है
    • “disk encrypted हो तो ज़्यादातर physical access hacking असंभव है” यह बात सिर्फ़ तब सही है जब PC बंद हो और अभी keyfile या passphrase से data decrypt करके system में boot न किया गया हो
      मेरा PC भी full-disk encryption इस्तेमाल करता है, लेकिन boot होने पर decrypt करने के लिए keyfile इस्तेमाल होती है, और उसी पल से यह physically accessible PC बन जाता है

  • पसंद आया। सार यह है कि memory read या write के दौरान electrostatic bit flip होता है, और soldering करने पर आप “safe” pointer को अपनी पसंद के malicious pointer में deterministic तरीके से बदल सकते हैं
    ऐतिहासिक रूप से physical access को लेकर नजरिया यह था कि “अगर दूसरे के हाथ में device आ गया, तो game over।” TPM और trusted execution environments ने इस नजरिए को बदलकर “भले ही user के पास physical access हो, enclave के अंदर कुछ operations पर भरोसा किया जा सकता है” कर दिया।
    अगला step सबसे दिलचस्प है। क्या soldering के बिना भी कुछ हद तक reliable नतीजे मिल सकते हैं? electrical interference संभालने में पहले ही काफी सोच-विचार लगा है, इसलिए यह बहुत मुश्किल लग सकता है, लेकिन संभव भी हो सकता है। अगर lighter दबाने पर हर बार 64-bit read में random 1 bit flip हो, और exploit, मान लीजिए, 4 bit flips में से केवल किसी एक से भी काम कर जाए, तो average attempts बहुत ज़्यादा नहीं होंगे

    • अगर physical access है और antenna solder कर सकते हैं, तो “पीछे की तरफ” programmable custom DIMM लगा कर TPM हो या कुछ और, उसे bypass किया जा सकता है
      memory के किसी भी हिस्से को मनचाहे समय पर मनचाही value में बदल सकते हैं, इसलिए random bit flip पर निर्भर होने की ज़रूरत नहीं। बस पूरा program inject कर दें
    • antenna न हो तो flip को single bit तक सीमित रखना मुश्किल होगा। कम से कम मेरा अनुमान तो यही है

  • सिर्फ़ title देखकर लगा कि किसी ने cigarette lighter पर root privileges हासिल कर लिए हैं, और मैं इस पर विश्वास करने के लिए पूरी तरह तैयार था
    मेरे माता-पिता के oven को भी regular software updates मिलते हैं, इसलिए lighter “smart” है या नहीं, इस पर मुझे शक भी नहीं हुआ

    • title देखकर मैं आधा उम्मीद कर रहा था कि यह rubber-hose cryptanalysis का आग वाला version होगा
    • सोच रहा था कि एक lighter हो जिसमें छोटा solar panel और battery हो, और lidar पास की cigarette या cigar detect करे तो छोटे taser की तरह spark दे। उंगली या hot dog पर react न करे, कोई button न हो, और lighter fluid भी कभी भरने की ज़रूरत न पड़े
      ज़ाहिर है, lidar चलाने के साथ-साथ intense LED flash और fade, haptic shock, और sound effects के लिए chip भी चाहिए होगा। काश कोई इसे demo के तौर पर बना दे। अच्छा होगा अगर यह छोटे revolver जैसा दिखे, लेकिन उंगली और hot dog की safety के लिए virtual memory controller को harden करना पड़ेगा
    • मेरा सबसे ज़्यादा इस्तेमाल होने वाला soldering iron भी modifiable firmware चलाता है, वह भी RISC-V SoC पर। (https://pine64.com/product/pinecil-smart-mini-portable-solde...)
      solder पिघलाने का काम इतना complex हो सकता है—किसने सोचा था। इसलिए lighter को root करने वाली पोस्ट पर भी मैं आसानी से विश्वास कर सकता हूँ
    • मुझे लगा था कि flame के shape से square root calculate कर रहे होंगे

  • 80–90 के दशक में Sydney के arcade machines पर किए जाने वाले exploit की याद आ गई। स्कूल के gas heaters में एक piezoelectric igniter होता था, जिसे हम “clicker” कहते थे, और उसे heater से निकाल सकते थे।
    उस clicker को मोहल्ले के arcade में ले जाकर CRT के किसी एक कोने पर क्लिक करते, तो system को झटका लगता और game credits बढ़ जाते। शायद इसलिए कि CRT की grounding, सिक्के को physically verify करने वाले device वाली ही ground wire share करती थी।
    समय के साथ owners को पता चल गया और उन्होंने alarm जैसी चीजें जोड़ दीं, लेकिन उससे पहले तक वाकई सुनहरे दिन थे।

    • 80 के दशक की शुरुआत में हमने भी यही किया था, बस हम disposable lighter के अंदर वाला clicker इस्तेमाल करते थे।
      कुछ साल तक ऐसा करने के बाद owners को पता चला और वे arcade cabinets को transparent plastic से ढकने लगे। उसी समय, cabinets plastic से बंद हो गए तो ventilation के लिए पीछे छेद किए गए, और हमें पता चला कि bamboo stick से coin insertion register करने वाले lever को दबाया जा सकता है।
      फिर उन्होंने vent को पीछे की बजाय ऊपर कर दिया ताकि lever तक न पहुंचा जा सके, लेकिन इस बार हमें पता चला कि return slot से coin को ऊपर धकेलने पर coin register lever को छुआ जा सकता है, इसलिए free games जारी रहे। आखिरकार उन्होंने return slot box के अंदर sharp screws लगा दिए ताकि उंगलियां कट जाएं, और उसके बाद हमने SEGA खरीद लिया। बहुत मजेदार था।
    • एक machine याद आ गई जिसमें मेरा दोस्त arcade machine के पीछे जाकर power off/on करता था तो एक free token मिल जाता था।
      पता नहीं यह जानबूझकर ऐसा design किया गया था ताकि staff मुफ्त में test कर सके, लेकिन मेरा दोस्त पीछे घुसकर free में लगातार खेलता रहता था।
    • अमेरिका में भी यह चलता था। 1990 के दशक के आसपास ज्यादातर arcades cash coins की जगह proprietary tokens इस्तेमाल करते थे, और ऐसे skill-based gambling machines भी बहुत थे जिनमें tokens कतार में फिसलते हुए जमा होते थे।
      “Jungle Jive” version में cigarette lighter के electric igniter से metal input slot को हल्का झटका देने पर machine के दूसरी तरफ tokens निकल आते थे। अगर बहुत तेजी से बहुत बार click करते तो warning mode चालू हो जाता था। अकेले भी संभव था, लेकिन optimal setup तीन लोगों का था: 1 staff पर नजर रखने वाला, 1 click करने वाला, और 1 tokens इकट्ठा करने वाला।
    • धुंधली-सी याद है कि pinball machine के side को बिल्कुल सही जगह मारने पर free game मिल जाता था। शायद वही principle रहा होगा।
    • याद है कि इस किताब में पढ़ा था कि hacker Pengo ने इसी तरीके से arcade credits add किए थे।
      https://www.amazon.com/CYBERPUNK-Outlaws-Hackers-Computer-Fr...

  • ऑस्ट्रेलियाई के तौर पर पढ़ें तो इसका मतलब अलग निकलता है। negotiation skills पर निर्भर करता है, लेकिन सिर्फ एक cigarette lighter से भी root हासिल किया जा सकता है।

  • यह सिर्फ एक मजेदार exploit नहीं है, बल्कि CPU में cache कैसे काम करता है इसे समझाने वाला शानदार mini intro भी है।
    करीब 1 साल पहले एक लेख आया था जो बताता था कि computer कैसे काम करता है और कैसे बनाया जाता है, सबसे छोटे हिस्से यानी logic gates से शुरू करके। किसी को याद है वह website कौन-सी थी?

  • “बस एक 15-ohm resistor और एक wire को DQ26 पर solder किया गया है। wire antenna की तरह काम करता है, आसपास की electromagnetic interference पकड़ता है और उसे सीधे data bus में भेज देता है।”
    वाकई शानदार hacking है। lighter से electromagnetic interference बनाना—कमाल है। DDR bus के पास आग जलाकर देखना पड़ेगा कि क्या होता है।

  • बेशक, अगर पहले memory पर antenna solder करना पड़े तो ही संभव है :-)
    फिर भी, ऐसे glitch को सच में exploit करने के तरीके पर यह बेहतरीन और बहुत thorough लेख है। cigarette lighter का इस्तेमाल data center के back door के पास मंडराते हुए admin के smoke break पर बाहर आने का इंतजार करने में भी किया जा सकता है।

    • “सैद्धांतिक रूप से, bit flip अगर bit 29 से bit 12 के बीच कहीं भी हो जाए तो यह काम करता है। इसलिए अगर पर्याप्त मजबूत electromagnetic interference बनाई जा सके, तो antenna wire solder करना शायद पूरी तरह अनिवार्य न हो।”
    • “Practical use” section में एक उपयोग console की copy protection bypass करना है।

  • Title देखकर लगा था कि यह USB-C cigarette lighter device से Hyundai cars को hack करने की कहानी होगी।