Ruby Regex की कमज़ोरियाँ: Unicode Case Folding का खतरा
Ruby की सात regex और string case conversion कमज़ोरियाँ दिखाती हैं कि Unicode case folding memory-safety का खतरा क्यों है। अपने कोड का ऑडिट कैसे करें, जानें।

एक Rails ऐप ईमेल पते स्टोर करने से पहले upcase चलाकर उन्हें normalize करता है, जैसा हज़ारों tutorials सिफ़ारिश करते हैं। एक यूज़र mueller@straße.example के साथ साइन अप करता है, ऐसे फ़ॉर्म से जिसने पाइपलाइन में कहीं यह तय कर लिया कि Windows-1252 एक ठीक encoding है। upcase कॉल अंतिम ß को SS में बदल देती है — जहाँ पहले एक byte था वहाँ अब दो — और उनमें से एक byte heap buffer के आख़िर के बाद लिख दिया जाता है। यह कोई काल्पनिक बात नहीं है। यह उन सात Ruby regex और string case conversion कमज़ोरियों में से एक का संभावित पुनर्निर्माण है, जिन्हें core team ने अभी पैच किया है, और इनमें से कई के काम करने वाले remote code execution proof of concept मौजूद हैं।
यह advisory तीन emergency releases के साथ आया — Ruby 4.0.10, 3.4.13 और 3.3.14 — और यह एक गहरी सच्चाई का अच्छा केस स्टडी है: case conversion string library का सबसे सरल दिखने वाला ऑपरेशन है, जबकि असल में वह सबसे ख़तरनाक ऑपरेशनों में से एक है। यहीं Unicode की विशाल specification दशकों पुराने C कोड से मिलती है, और ठीक यही जोड़ heap overflows के पनपने की जगह है।
सात बग, दो सबसिस्टम, एक मूल कारण
सातों advisories को GHSA identifiers से ट्रैक किया जा रहा है, जबकि CVE नंबर backlogged assignment process में अटके हैं। ये दो परिवारों में बँटते हैं। दो String case conversion में हैं: एक one-byte heap buffer overflow और एक integer overflow जो heap overflow में बदल जाता है। पाँच Ruby के regular expression engine में हैं — pattern compilation के दौरान double free, compilation के दौरान integer overflow, case-insensitive matching में out-of-bounds read, case-insensitive backreference matching में out-of-bounds read, और Regexp#to_s में heap buffer overflow।
ध्यान दीजिए कि इन्हें क्या एक जोड़ता है। यह लापरवाही से लिखा कोड नहीं है — Ruby का C core पुराना, समय से परखा हुआ और भारी मात्रा में fuzz किया हुआ है। असल बात यह है कि दोनों सबसिस्टम Unicode case semantics लागू करते हैं, और Unicode case semantics एक जाल हैं। Case-insensitive regex matching में pattern और input दोनों को fold करना पड़ता है, यानी engine वही खतरनाक mapping tables चला रहा है जो String#upcase चलाता है, बस ज़्यादा गर्म path पर और attacker के इनपुट पर ज़्यादा असर के साथ। Case-insensitive mode में backreferences को folded substrings की तुलना करनी होती है। Regexp#to_s को pattern का source text उसके options के साथ दोबारा emit करना होता है, और उस reconstruction के लिए buffer का आकार तय करना पड़ता है जिसमें खुद case-aware logic शामिल है। इन सभी code paths को एक ही कठिन सवाल का जवाब देना होता है: अपना case बदलने के बाद यह string कितनी बड़ी होगी?
Ruby 3.3 को फ़िक्स मिल रहा है क्योंकि वह अब भी security maintenance में है। Ruby 3.2 और पुराने End of Life हो चुके हैं और उन्हें कुछ नहीं मिलेगा — अगर आप इनमें से किसी पर हैं, तो यह advisory चेतावनी नहीं, आपकी migration की आख़िरी तारीख है।
Case Conversion के गलत होने का एक संक्षिप्त इतिहास
ASCII में case बदलना एक bit-flip है। छब्बीस अक्षर-जोड़े, एक-से-एक, लंबाई वही रहने वाली, locale पर निर्भर नहीं। K&R-युग की C से toupper() एक ही lookup table में यह पूरा विचार समेट देता है। ज़्यादातर लोग वयस्क होने तक यही mental model लेकर चलते हैं, और दुनिया भर के C कोड में buffer-sizing logic में यही model बसा है। लेकिन बुनियादी Latin से आगे के लगभग हर writing system के लिए यह गलत है।
Unicode में हज़ारों case mappings परिभाषित हैं, और उनमें से काफ़ी बड़ा हिस्सा एक-से-एक नहीं है। जर्मन sharp s (ß) का uppercase SS होता है। ff ligature का uppercase FF है। Armenian ligatures फैलते हैं। Greek में context-sensitive sigma है — σ बनाम शब्द के अंत में ς — तो सही folding आसपास के अक्षरों पर निर्भर करती है। Turkish और Azerbaijani में dotted/dotless I की समस्या है, जहाँ i का uppercase İ और ı का I होता है; यह Turkish locale में Java ऐप्स से लेकर PHP के strtoupper तक सब कुछ तोड़ने के लिए कुख्यात है। और Cherokee में 2015 में Unicode 8.0 के साथ पीछे जाकर lowercase अक्षर जोड़े गए, जिससे जो लिपि कभी caseless थी वह cased बन गई और हर जगह के सॉफ़्टवेयर की मान्यताएँ टूट गईं।
Legacy encodings स्थिति और बिगाड़ते हैं। Windows-1252 में lowercase ß के लिए एक byte (0xDF) है, पर किसी काल्पनिक uppercase version के लिए कोई byte नहीं — क्योंकि ऐतिहासिक रूप से जर्मन में running text में कभी उसका इस्तेमाल ही नहीं हुआ; आप SS लिखते थे। तो जब Windows-1252 string पर काम करने वाली case-conversion routine ß से टकराती है और सही तरीके से SS डालती है, तो string एक byte बड़ी हो जाती है। Advisory के बाद घूम रहे तीखे विश्लेषण बताते हैं कि यही एक-byte overflow है: conversion loop buffer में जगह को एक-एक character करके जाँचता प्रतीत होता है, इसलिए एक कसकर बनी string के आख़िरी character के रूप में ß एक भटका हुआ S allocation के बाहर लिख देता है। Attacker-controlled S वाला one-byte heap overflow exploit करने के लिए बहुत ही झंझट भरा primitive है — पर advisory पुष्टि करता है कि RCE PoCs मौजूद हैं, तो किसी ने heap grooming कर ली है।
Case conversion न bijection है, न length-preserving, न locale-independent, और न हर encoding में दर्शाया जा सकता है। जो कोड इसके उलट मानकर चलता है, वह fuzzer का इंतज़ार करती कमज़ोरी है।
Regex Engine ज़्यादा बड़ी चिंता क्यों है
Ruby का regex engine Onigmo है, जो Oniguruma का fork है, और यह वाकई प्रभावशाली software है — यह दर्जनों encodings, पूरी Unicode case folding, lookbehind, named groups और backreferences सब कुछ संभालता है, और यह सब C में है, जिसकी layering 1990 के दशक के आख़िर तक जाती है। यही layering समस्या है। Onigmo में case-insensitive matching का मतलब है कि हर comparison point पर fold logic चल सकता है, और folding लंबाई बदलती है, इसलिए pattern offsets, string offsets और match boundaries के बीच का हिसाब-किताब बेहद पेचीदा है। पैच किए गए बगों में से दो ठीक इसी मशीनरी में out-of-bounds reads हैं — एक सामान्य case-insensitive matching में, और दूसरा खास तौर पर case-insensitive backreference matching में, जहाँ engine पहले से capture किए गए (folded) substring की तुलना मौजूदा position से करता है।
पर exploitation का मॉडल internals से ज़्यादा मायने रखता है। पाँच regex बगों में से तीन pattern compilation के दौरान trigger होते हैं, और advisory साफ़ बताता है कि कौन खुला है: वे ऐप्स जो attacker-controlled patterns compile करते हैं। आप सोचेंगे कि यह दुर्लभ है। ऐसा नहीं है। हर search box जो Regexp.new(query) में लिपटा है, database से लोड होने वाला हर configurable validation rule, हर log-parsing या routing layer जो किसी operator (या किसी compromised tenant) के नियंत्रण वाली config files से patterns बनाती है — ये सब ऐसे compilation paths हैं जहाँ तक hostile input पहुँच सकता है। इस advisory से पहले, hostile pattern compile करने का सबसे बुरा नतीजा ReDoS था: एक catastrophic-backtracking pattern जो CPU को जकड़ लेता है। परेशान करने वाला, पर ठीक हो जाने वाला। अब सबसे बुरा नतीजा RCE PoCs वाला memory corruption है। जिस एक लाइन को आप सालों से production में चला रहे हैं, उसके लिए यह बिल्कुल अलग किस्म का जोखिम है।
यहाँ एक पैटर्न का नाम लेना ज़रूरी है: specification कुछ कहती है, C कुछ और करता है, और इस अंतर का फ़ायदा उठाया जा सकता है। इस गतिशीलता पर हम पहले भी बात कर चुके हैं — specification और implementation का अंतर ही बग्स का घर है — और Unicode की case folding tables उन सबसे समृद्ध specifications में से हैं जो एक C प्रोग्रामर से लागू करने को कहा जा सकता है। Tables Unicode versions के बीच बदलती हैं, special-casing नियमों की अपनी उप-धाराएँ हैं, और 2003 में buffer-sizing कोड लिखने वाले व्यक्ति ने एक छोटे, सरल Unicode पर काम किया था, न कि उस Unicode पर जिसमें आपके strings आज पहुँचते हैं।
Integer Overflow: चार गीगाबाइट बन जाते हैं छह बाइट
दूसरा string bug एक अलग failure mode का सुंदर उदाहरण है: 64-bit दुनिया में 32-bit length arithmetic। यह proof of concept, जो advisory के बाद सार्वजनिक रूप से घूम रहा है, Shift_JIS और चार गीगाबाइट से ज़्यादा लंबी string इस्तेमाल करता है:
str = ("\x82\xA0" + ("A" * (2**32 + 4))).force_encoding(Encoding::Shift_JIS)
puts "str.bytesize: #{str.bytesize}" # 4294967302
new_str = str.downcase
puts new_str.bytesize # 6 on unpatched builds (!)
puts new_str.bytes # [130, 160, 97, 97, 97, 97]
4,294,967,302 बाइट की string अंदर जाती है, और downcase हुआ परिणाम आकार 6 बताता है। Conversion path में कहीं लंबाई 32-bit type से गणना या truncate हुई — 2³² + 6 घूमकर 6 हो गया — और उसके बाद का allocation या copy उसी हिसाब से तय हुआ, जो एक क्लासिक integer-overflow-से-heap-overflow pipeline है। चार गीगाबाइट बेतुका इनपुट लगता है, पर याद रखिए कि चलती process में strings वायर पर एक टुकड़े में नहीं आतीं: वे chunks से, decompression से, import jobs और file parsers में concatenation से बनती हैं। जो attacker यह प्रभावित कर सके कि string में कितना डेटा जमा होता है, और फिर उस पर downcase कॉल करवा सके, वह इस बग के दोनों हिस्सों पर नियंत्रण रखता है।
दोनों string bugs एक architectural सबक साझा करते हैं, जैसा Alpine के दशक पुराने asterisk bug में: खतरनाक कोड ऐसे path पर बैठा है जिसे कोई attack surface नहीं मानता। upcase का कोई threat model नहीं बनाता। यही वजह है कि ये बग सालों तक बचे रहते हैं — ये ऐसे paths में पड़े थे जिनका इंसान ऑडिट नहीं करते, और जहाँ हाल तक fuzzers valid multi-byte encoded strings बनाकर पहुँच ही नहीं पाते थे।
मशीनों ने ये बग खोजे, और इससे गणित बदल जाता है
Credits पर नज़र डालिए। सात में से चार advisories Stephan Lipp को धन्यवाद देते हैं, जो Ada Logics से हैं — वही फ़र्म जो OSS-Fuzz के harness development के बड़े हिस्से के पीछे है — और Anthropic। यह एक fuzzing-infrastructure विशेषज्ञ और एक AI model की जोड़ी है, और हाल की याद में यह इस तरह की पहली advisory नहीं है। इस वंशावली की सराहना करने लायक है: fuzzing की शुरुआत 1990 में Barton Miller ने Unix utilities को random कचरा खिलाकर की, 2013 में AFL के coverage-guided mutation से यह स्मार्ट बनी, 2016 से OSS-Fuzz ने open source projects पर लगातार हमला करके इसे औद्योगिक बनाया, और अब इसमें एक ऐसी परत जुड़ गई है जो कोड के बारे में तर्क कर सकती है — 4 GiB का Shift_JIS string या ß पर खत्म होने वाला Windows-1252 buffer बनाने के लिए encoding validity और length arithmetic समझनी पड़ती है, सिर्फ़ bytes बदलना काफ़ी नहीं।

रणनीतिक निहितार्थ दोनों तरफ़ जाता है। Defenders को ऐसे codebases का लगातार, अथक ऑडिट मिलता है जिनकी हाथ से समीक्षा करने का किसी टीम के पास बजट नहीं होता। पर वही क्षमता हर उस व्यक्ति के पास है जिसके पास model और compute है, और हर कोई advisories दर्ज नहीं करता। वह आरामदेह दौर ख़त्म हो रहा है जब किसी अनजान code path में memory-corruption बग सालों तक बिना छेड़े जीवित रह सकता था; उन्हें खोजने का अर्थशास्त्र ढह चुका है। मैं पहले भी कह चुका हूँ कि AI scanners हमारा technical debt वसूल रहे हैं, और यह उसकी रसीद है: लाखों लोगों द्वारा इस्तेमाल होने वाला एक language runtime, जिसमें खामी किसी उबे हुए researcher ने नहीं, बल्कि एक स्वचालित pipeline ने पकड़ी, जो बस चलती रहेगी।
मेरा मत: यह memory-safe languages के पक्ष को मज़बूत करता है, पर उस सतही तरीके से नहीं जिस तरह चर्चा अक्सर इसे पेश करती है। Onigmo को Rust में लिख देने से logic की समस्या हल नहीं होती — ऐसी case folding जो string की लंबाई बदलती है, अब भी spec-स्तर का खतरा है, और buffer-size का सवाल फिर भी सही जवाब माँगता है। Memory safety जो हटाती है वह है परिणामों की गंभीरता की सीढ़ी। Logic bug बन जाता है एक panic, एक गलत नतीजा, एक असफल request — RCE नहीं। यह छोटी बात नहीं है; यही घटना और outage notice के बीच का फ़र्क है।
अपने exposure का ऑडिट कैसे करें
सबसे स्पष्ट बात से शुरू करें और बाहर की ओर बढ़ें। 4.0.10, 3.4.13 या 3.3.14 पर अपग्रेड करें — Onigmo Ruby build में embedded है, इसलिए कोई अलग library पैच करने की ज़रूरत नहीं; runtime ही पैच है। फिर अपने application code में दो खतरनाक रूप खोजें: attacker-प्रभावित strings जो case operations में जा रही हैं, और attacker-प्रभावित patterns जो Regexp.new या Regexp.compile में जा रहे हैं।
- उपयोगकर्ता के इनपुट को patterns में compile करना बंद करें। अगर उपयोगकर्ता search terms देते हैं, तो उन्हें
Regexp.escapeसे escape करें। अगर उन्हें सच में regex की ताकत चाहिए, तो उसके सामने allowlist और सख़्त timeout लगाएँ — और जानें कि timeout ReDoS में मदद करता है, memory corruption में नहीं। - Trust boundary पर encodings normalize करें। दोनों string bugs विदेशी encodings (Windows-1252, Shift_JIS) पर टिके हैं। अगर आपका ऐप केवल UTF-8 बोलता है, तो किनारों पर यह साफ़ कहें: ingress पर encoding force या transcode करें, और जो साफ़ तौर पर convert न हो उसे अस्वीकार करें।
- Case conversion के बजाय case-insensitive तुलना को प्राथमिकता दें।
a.casecmp?(b)एक सवाल पूछता है;a.upcase == b.upcaseइनपुट द्वारा दावा की गई encoding में दो नई strings allocate करता है। तुलना API का semantic दायरा कहीं छोटा है। - Untrusted data पर
upcase,downcase,swapcaseऔरcapitalizeखोजें। हर call site वह जगह है जहाँ लंबाई की कोई धारणा छिपी है। यही बात उस किसी भी C extension पर लागू होती है जो अपना case logic खुद चलाती है — उन्हें core team के फ़िक्स का कोई लाभ नहीं मिलता। - जो आपका है उसे fuzz करें। Ruby खुद OSS-Fuzz से fuzz होता है, पर आपके C extensions नहीं होते। ASan के साथ AFL++ या libFuzzer वही bug classes आपके कोड में पकड़ सकते हैं जो मशीनों ने Ruby में पकड़ी हैं।
- अपने runtime की maintenance स्थिति जानें। Ruby 3.2 End of Life है और उसे ये फ़िक्स नहीं मिले। जब patch stream रुक गया हो, तब ‘अब भी चलता है’ कोई security posture नहीं है।
सबसे आम पैटर्न के लिए पहले-और-बाद का ठोस उदाहरण — uniqueness check के लिए usernames या emails normalize करना:
# Before: allocates a new string, trusting the input's claimed encoding
def normalize(username)
username.upcase
end
# After: pin the encoding at the boundary, fold for comparison only
def normalize(username)
utf8 = username.encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
utf8.downcase(:fold)
end
# And for comparisons, skip allocation entirely:
def same_user?(a, b)
a.encode(Encoding::UTF_8).casecmp?(b.encode(Encoding::UTF_8))
end
पैच किए बिना कोई रनटाइम आपको सुरक्षित नहीं बनाता — इसीलिए अपग्रेड है। पर ये आदतें उन बगों की श्रेणी को छोटा करती हैं जो आपका ऐप नीचे की परत से विरासत में ले सकता है, और ये आपके अपने कोड को इस सच्चाई के प्रति ईमानदार बनाती हैं कि text, bytes नहीं है।

Language Runtimes के लिए गहरा सबक
यह मानने का मन करता है कि यह ‘C खतरनाक है, और ज़्यादा जानने के लिए बने रहें’ वाली बात है, और advisory पर आए सतही जवाबों ने ठीक यही किया। पर मैं इससे आगे जाऊँगा। ये सात बग असल में C के बारे में नहीं हैं — ये एक विकसित होते internationalization standard और जमी हुई implementation मान्यताओं के बीच के बेमेल के बारे में हैं। Unicode नई लिपियाँ जोड़ता रहेगा और mappings को परिष्कृत करता रहेगा। धरती पर हर language runtime में case-conversion कोड है जो Unicode के किसी पुराने संस्करण की tables पर लिखा गया है, और जो इस बात की किसी पुरानी समझ से तय हुआ कि string कितनी बड़ी हो सकती है। Ruby इस महीने पकड़ में आया; अगला नंबर किसी और के regex engine, case folder या normalization routine का होगा।
व्यावहारिक सबक यह है कि text transformation को सुरक्षा सीमा मानें, सिर्फ़ utility function नहीं। जो कुछ भी re-encode, re-case, normalize या fold करता है, वह एक parser है, और memory bugs parsers में ही रहते हैं। ऐतिहासिक सबक — जो एक भाषा-प्रेमी के रूप में मुझे सच में संतोषजनक लगता है — यह है कि जर्मन का विनम्र ß, जिस अक्षर से प्रिंटर Fraktur के दिनों से जूझते आए हैं, छह सदियों के टाइपोग्राफ़िक इतिहास को पार करके आज भी heap buffer के आख़िर के बाद एक byte लिख सकता है। भाषा कभी सरल नहीं थी। हमने ही अपनी मशीनें यह मानकर बनाईं कि वह सरल है।


