भविष्य को आकार देने वाली तकनीक पर गहन लेख।

Java4Shell: OpenJDK के Base64 बग से 65 बाइट्स में RCE

Java4Shell OpenJDK के AVX-512 Base64 डिकोडर में मेमरी-करप्शन बग है। जानिए 65 बाइट्स कैसे हीप बिगाड़कर RCE देते हैं और अभी क्या करें।

एक कन्वेयर बेल्ट पर चमकती छोटी खराबी का चित्रण, जो एक विशाल औद्योगिक मशीन को भ्रष्ट कर रही है
स्टैक का सबसे छोटा हिस्सा — Base64 का फ़ास्ट पाथ — वही निकला जिससे पूरी मशीन टूट जाती है।

64 अक्षर A और एक बराबर का चिह्न। बस इतना इनपुट काफ़ी है एक अपडेट न हुए OpenJDK सर्वर के हीप को करप्ट करने के लिए — 65 कैरेक्टर की एक Base64 स्ट्रिंग जो Java की मशहूर मेमरी सेफ़्टी को चुपचाप लांघकर एक एरे के आख़िर से 62 बाइट्स आगे तक लिख देती है। Calif नाम की सिक्योरिटी फ़र्म ने इसे Java4Shell (CVE-2026-114938, CVSS 9.2) नाम से उजागर किया है। यह कमज़ोरी एप्लिकेशन कोड में नहीं, बल्कि JVM के Base64 डिकोडर में छिपे हाथ से लिखे असेंबली कोड में है। प्री-ऑथ रिमोट कोड एक्ज़ीक्यूशन Keycloak, Jenkins, Jira, Confluence, Artifactory और PingFederate पर दिखाया जा चुका है। अगर आपकी संस्था x86-64 सर्वर पर Java चलाती है — और आँकड़े बताते हैं कि चलाती ही है — तो यह आपकी समस्या है।

मैं पेशे से कमज़ोरियों पर काम करता हूँ, और ज़्यादातर बग आपस में मिल जाते हैं: एक और deserialization बग, एक और auth bypass, एक और path traversal। Java4Shell अलग है, और सिर्फ़ स्कोर की वजह से नहीं। अलग इसलिए है क्योंकि यह बग कहाँ रहता है। यह एक ऑप्टिमाइज़ेशन में है — AVX-512 वेक्टर इंस्ट्रक्शन से Base64 डिकोड करने की रफ़्तार बढ़ाने का तरीका — जिसकी शायद ही कोई एप्लिकेशन असल में ज़रूरत रखती है। इसे कैसे खोजा गया, कैसे एक्सप्लॉइट हुआ, और आपके प्रॉक्सी शायद आपको पहले से क्यों बचा रहे हों, यह कहानी बताती है कि सॉफ़्टवेयर सिक्योरिटी किस दिशा में जा रही है।

समस्या: एक टूटे मास्क वाला JIT इंट्रिंसिक

बग समझने के लिए जानना होगा कि OpenJDK Base64 को तेज़ कैसे बनाता है। HotSpot JVM देखता है कि कौन से मेथड बार-बार चलते हैं, और उन्हें उसका C2 कंपाइलर नेटिव कोड में बदल देता है। कुछ ऑपरेशनों के लिए वह एक कदम आगे जाता है और हाथ से ट्यून किए गए असेंबली रूटीन लगा देता है जिन्हें इंट्रिंसिक कहते हैं, जो CPU की खास इंस्ट्रक्शन इस्तेमाल करते हैं। AVX-512 VBMI सपोर्ट वाले x86-64 चिप्स पर Base64 डिकोडिंग को ठीक यही ट्रीटमेंट मिलता है: इंट्रिंसिक इनपुट को 256 या 64 बाइट के ब्लॉक में चबाता है, VMOVDQU8 इंस्ट्रक्शन और 64-बिट मास्क के साथ, जो तय करता है कि कौन से बाइट डेस्टिनेशन बफ़र में लिखे जाएँगे।

खामी उस मास्क की गणना में है जो इनपुट के padding वाले हिस्से के लिए बनता है। Base64 अपने आउटपुट को = कैरेक्टर से पैड करता है, और असेंबली हर padding बाइट के लिए आउटपुट लंबाई घटाती है। कुछ गड़बड़ इनपुट के लिए — जैसे ब्लॉक के आख़िर में अकेला = — गणना की गई आउटपुट लंबाई -1 या -2 पर underflow कर जाती है। यह ऋणात्मक मान bzhiq बिट-मैनिपुलेशन इंस्ट्रक्शन में जाता है, जो 64 या उससे ज़्यादा के इनपुट के लिए मास्क को बदलता नहीं: सारे 64 बिट सेट रहते हैं। हर बिट सेट का मतलब हर बाइट लिखा जाएगा।

ट्रिगर को ठोस रूप में देखें। आप 64 A भेजते हैं, उसके बाद =, कुल 65 कैरेक्टर। JVM डिकोड की गई लंबाई 50 बाइट गिनता है और 50 बाइट का एरे बनाता है। इंट्रिंसिक पहले 64 कैरेक्टर ठीक से डिकोड करता है, फिर बेमेल = पर पहुँचता है, लंबाई underflow करता है, फ़ुल मास्क सेट करता है — और 50 बाइट के बफ़र के आख़िर के पास से शुरू होकर 64 बाइट का वेक्टराइज़्ड राइट चला देता है। पड़ोसी हीप ऑब्जेक्ट्स के 62 बाइट्स हमलावर-प्रभावित स्थिर डेटा से रौंद दिए जाते हैं। Java की अपनी वैलिडेशन कोड आख़िर में पकड़ लेता है कि इनपुट गलत है और IllegalArgumentException फेंकता है, लेकिन तब तक नुकसान हो चुका होता है। एक्सेप्शन हैंडलर तब फ़र्श पोंछ रहा होता है जब घर में आग लगी है।

// Pseudocode of the mask calculation (after Calif's write-up)
input_mask := bzhiq(-1, input_length)
output_len := (input_length / 4) * 3
// handle padding
if input[input_length - 1] == '=':
output_len -= 1
input_mask >>= 1
if input[input_length - 2] == '=':
output_len -= 1
input_mask >>= 1
// For a lone '=' tail, output_len was already 0
// -> now it's -1, and bzhiq(-1, 255) leaves all bits set
output_mask := bzhiq(-1, output_len)   // == -1u64, all 64 bits 1
// evmovdqub then writes all 64 bytes where ~50 were allocated

ट्रायेज के लिए एक बात अहम है: यह सिर्फ़ x86-64 होस्ट पर चलता है जिनके CPU AVX-512 VBMI सपोर्ट करते हैं। AWS Graviton जैसे ARM सर्वर बग वाला स्टब कभी नहीं चलाते, और पुराने Xeon भी नहीं। कमज़ोर कोड पाथ सिर्फ़ HotSpot-आधारित JVM में दिखता है — OpenJDK, Oracle JDK, GraalVM। OpenJ9 और Azul Prime, जो अलग JIT आर्किटेक्चर इस्तेमाल करते हैं, प्रभावित नहीं हैं। वैसे OpenJDK 17 पर ट्रिगर 64 नहीं बल्कि 128 A और = है, क्योंकि फ़ास्ट पाथ में घुसने की सीमा ऊँची है। छोटे फ़र्क हैं, पर डिटेक्शन रूल लिखते समय मायने रखते हैं।

पहली नाकाम सोच: “Java मेमरी-सेफ़ है”

जब यह सामने आया तो इंजीनियरिंग Slack चैनलों पर पहली प्रतिक्रिया अविश्वास की थी। Java में मेमरी करप्शन? मेमरी सेफ़्टी ही तो पूरा मकसद है न? यह धारणा — कि रनटाइम एक किला है और सिर्फ़ एप्लिकेशन कोड ही धोखा दे सकता है — पहली नाकाम मॉडल है। इसे परखना ज़रूरी है क्योंकि यही तय करती है कि टीमें अपने स्टैक का ऑडिट कैसे करती हैं।

Java-भाषा हर एरे एक्सेस की जाँच करती है और हर allocation मैनेज करती है। लेकिन Java-रनटाइम C, C++ और असेंबली का विशाल ढाँचा है। JIT कंपाइलर, गार्बेज कलेक्टर, इंट्रिंसिक, नेटिव इमेज कोड — यह सब पूरी प्रोसेस की अनियंत्रित ताकत के साथ चलता है, और इनमें से किसी को भी वह गारंटी नहीं मिलती जो आपका बाइटकोड पाता है। हर इंट्रिंसिक रफ़्तार के नाम पर सेफ़्टी दीवार में बनाया गया एक छोटा छेद है, और वे छेद गिने-चुने VM इंजीनियर संभालते हैं। यह वही ढाँचागत सबक है जो Alpine Linux के दशक पुराने SSH asterisk बग में दिखा: सबसे डरावनी खामियाँ उस कोड में रहती हैं जिस पर सब निर्भर हैं और जिसे लगभग कोई नहीं पढ़ता।

यहाँ एक ऑडिट की अंधी जगह है जो मैं लगातार देखता हूँ। टीमें अपने JSON parsers को फ़ज़ करेंगी, REST handlers की पेन-टेस्टिंग करेंगी, और अपनी लिखी हर लाइन पर static analysis चलाएँगी — फिर JDK को ब्लैक बॉक्स मान लेंगी क्योंकि वह परिपक्व है, व्यापक रूप से तैनात है और समझदार लोग उसे चलाते हैं। परिपक्वता बचाव नहीं है। अक्सर उल्टा होती है: दशकों के जमे हुए ऑप्टिमाइज़ेशन, जिनमें से हर एक अपने समय पर समझदारी भरा था, और हर एक हमले की सतह जोड़ता है जो सबको मिलती है, चाहे वे फ़ायदा लें या नहीं। Base64 AVX-512 इंट्रिंसिक बड़ी मात्रा में डेटा डिकोड करने वाले एप्लिकेशन को तेज़ करने के लिए है। आपका REST API, जो 200 बाइट का auth header डिकोड करता है, जोखिम उठाता है और इनाम लगभग कुछ नहीं पाता। Calif इसे commons की त्रासदी कहता है, और वह सही है: जिन्हें फ़ीचर चाहिए था उन्हें फ़ायदा मिला, बाकी सबको बस बग मिला।

नाकाम सोच दो: “लिखना इतना सीमित है कि उसका फ़ायदा नहीं उठाया जा सकता”

दूसरी नाकाम सोच उन लोगों से आई जिन्होंने तकनीकी ब्योरा पढ़ा और ढील दे दी। एक तय ऑफ़सेट पर स्थिर मान का ओवरराइट, जिसमें लिखे जाने वाले बाइट पर कोई नियंत्रण नहीं? ऐसे कई बग “सिर्फ़ क्रैश” में डाल दिए जाते हैं और प्राथमिकता घटा दी जाती है। यह खारिज करना समझ में आता है, पर गलत है, और इसके गलत होने का कारण इस पूरे प्रसंग का सबसे सीखने लायक हिस्सा है।

आधुनिक एक्सप्लॉइट इस बात पर नहीं टिका कि अकेला प्रिमिटिव क्या कर सकता है; वह इस बात पर टिका है कि आसपास का सिस्टम उसके इर्द-गिर्द चीज़ें कितनी आसानी से जमा देता है। Calif की तकनीक heap grooming थी — रिमोट से allocator के व्यवहार को इस तरह आकार देना कि ओवरफ़्लो हुए बफ़र के ठीक बाद एक अनुमानित, काम का ऑब्जेक्ट आ बैठे। यह उन्होंने नेटवर्क के ऊपर से किया, रिक्वेस्ट की टाइमिंग से यह तय करते हुए कि टारगेट पर allocation और free कब हों। लिखना भले स्थिर मान का हो, पर अगर आप नियंत्रित करते हैं कि विस्फोट के दायरे में कौन सा ऑब्जेक्ट बैठा है, तो आप तय करते हैं कि क्या करप्ट होगा। इसके बाद उन्होंने Heartbleed-शैली की मेमरी डिसक्लोज़र बनाई, ASLR को तोड़ने जितनी जानकारी लीक की, और पूरे रिमोट कोड एक्ज़ीक्यूशन तक चेन कर दिया।

मेमरी ब्लॉक्स से बना एक अमूर्त शहर का ग्रिड जो एक सोची-समझी आकृति में व्यवस्थित है, बीच में एक लाल ब्लॉक
Heap grooming एक सीमित, स्थिर मान वाले राइट को हथियार बना देता है, यह नियंत्रित करके कि राइट कहाँ गिरेगा।

रिसर्च राइटअप में असली इंटरनेट पर इसे काम करने के बारे में एक मज़ेदार व्यावहारिक ब्योरा है। रिमोट heap grooming round-trip time और jitter के प्रति संवेदनशील है — allocator के वांछित अवस्था में होने के लिए रिक्वेस्ट एक खास लय में पहुँचनी चाहिए। TCP स्टैक को रिवर्स-इंजीनियर करने के बजाय शोधकर्ताओं ने अपने टारगेट के उसी क्लाउड रीजन में एक VM किराए पर लिया। उन्होंने भौतिकी की समस्या को पैसे से हल किया। मैंने एलीट एक्सप्लॉइट डेवलपर्स को सालों से इसके वर्ज़न करते देखा है, और यह याद दिलाता है कि हमलावर की बाधाएँ तकनीकी जितनी आर्थिक भी होती हैं। एक अच्छे संसाधन वाला प्रतिद्वंद्वी नेटवर्क jitter को बजट की एक लाइन-आइटम मानता है।

यह भी ध्यान देने लायक है: कोई सार्वभौमिक एक्सप्लॉइट नहीं है। हर एप्लिकेशन — Jira, Jenkins, Keycloak — Base64 को अलग तरह इस्तेमाल करता है, अलग तरह allocate करता है, अलग grooming सतहें दिखाता है। यह अच्छी खबर है। बुरी खबर एंट्री पॉइंट्स की भारी विविधता है। Authentication headers, file upload fields, client certificate हैंडलिंग, message payloads — जहाँ भी Base64 टेक्स्ट JVM में पहुँचता है, वह संभावित ट्रिगर है। एक योगदानकर्ता ने क्लाइंट-साइड वैरिएंट भी दिखाया: एक Java एप्लिकेशन जो किसी दुर्भावनापूर्ण सर्वर से TLS कनेक्शन खोलता है, बिना कोई सेवा खोले भी समझौता हो सकता है। आपके batch jobs और internal tooling भी दायरे में हैं, सिर्फ़ इंटरनेट-फ़ेसिंग गेटवे नहीं।

कमरे में सेंटॉर: AI ने यह एक घंटे में ढूँढ़ा

अब वह हिस्सा जो हर सिक्योरिटी टीम के थ्रेट मॉडल को फिर से तौलना चाहिए। शोधकर्ता Quang Luong ने कमज़ोरी लगभग एक घंटे में खोजी, और उसके लगभग दो घंटे बाद एक काम करने वाला एक्सप्लॉइट तैयार था। कुल AI टोकन लागत $200 से कम थी। उनका तरीका था AI कोडिंग एजेंट को HotSpot के उन इलाकों की ओर भेजना जहाँ जटिलता सीमाएँ पार करती है — JIT, इंट्रिंसिक, व्यापक रूप से पहुँचने वाले APIs, crypto — और फिर शोर छानना। एजेंट ने जो सामने रखा उसका ज़्यादातर हिस्सा पहुँच से बाहर का कचरा था। वे प्रॉम्प्ट देते रहे, और बीस मिनट की लगातार कोशिश के बाद Base64 वाली खोज सामने आ गई।

Calif इसे “centaur hacker” कहता है: इंसान बताता है कि जटिल सिस्टम कहाँ गलत होते हैं, AI धीरज देता है। मुझे लगता है यह सटीक है, और इसके निहितार्थ दोनों तरफ़ जाते हैं। जिस लूप ने Java4Shell खोजा, वह हर उस व्यक्ति के लिए उपलब्ध है जिसके पास API key है, और एक्सप्लॉइट-डेवलपमेंट का चरण — दोबारा इस्तेमाल होने वाली grooming पाइपलाइन बनाना, फिर एजेंट्स से हर एप्लिकेशन की चेन निकलवाना — तेज़ी से ऑटोमेटेबल होता जा रहा है। परिपक्व, व्यापक रूप से तैनात C और असेंबली में बग खोजने की अर्थव्यवस्था अभी ढह गई है। डिफ़ेंडर्स को मान लेना चाहिए कि Java4Shell जैसे अगले दर्जन बग पहले से खोजे जा रहे हैं, उन लोगों द्वारा जो डिसक्लोज़र फ़ाइल नहीं करते। यही दबाव Project Zero की घटती disclosure deadlines जैसी बहसों के पीछे है: जब खोज सस्ती हो जाती है, तो पैच की खिड़की ही पूरा खेल है।

Calif का प्रस्तावित जवाबी कदम उकसाने वाला है, और मैं ज़्यादातर इससे सहमत हूँ: उसी AI लीवरेज का इस्तेमाल कोड जोड़ने के बजाय हटाने में करें। वे इसे “vibe-uncoding” कहते हैं — कोडबेस का ऑडिट करना कि कौन से फ़ीचर मृत हैं, कौन सा पुराना प्रोटोकॉल सपोर्ट है, कौन से बेकार ऑप्टिमाइज़ेशन हैं, और फिर उन्हें उखाड़कर हमले की सतह घटाना। ईमानदार आपत्ति यह है कि हटाना जोखिमभरा है: जो फ़ीचर अनुपयोगी लगते हैं उनके छिपे डिपेंडेंट हो सकते हैं, और हटाने के लिए जो टेस्टिंग चाहिए, टीमें उसके लिए बजट नियमित रूप से कम देती हैं। पर दिशा सही है। अगर आपके JDK में ऐसे workload के लिए हाथ से लिखा असेंबली फ़ास्ट पाथ है जो आपके पास कभी होगा ही नहीं, तो सबसे अच्छा सिक्योरिटी रुख यह है कि वह पाथ कभी शिप ही न हो। उसके न होने तक JVM कम से कम उसे बंद करने का स्विच देता है। अब बात उस पर जो सच में काम करता है।

जो सच में काम करता है: पैच, फ़्लैग, प्रॉक्सी

आपकी on-call रोटेशन जिस हिस्से की परवाह करती है, वह यह है। सुधार तीन स्तरों में आते हैं, और मेरा तर्क है कि आपको आज ही उनमें से कम से कम दो पर काम शुरू कर देना चाहिए, अगले change window के बाद नहीं।

  1. तय OpenJDK बिल्ड पर पैच करें। अपस्ट्रीम फ़िक्स (JDK commit 5177a70) मास्क गणना को ठीक करता है। यही एकमात्र पूरा समाधान है। प्रभावित वर्ज़न 17 लाइन पर 17.0.6 से शुरू होते हैं और 21 व बाद के वर्तमान रिलीज़ तक जाते हैं; अपनी specific train के लिए fixed-in सूची जाँचें, और हर HotSpot JVM — OpenJDK, Oracle JDK, GraalVM — को तब तक दायरे में मानें जब तक पुष्टि न हो जाए।
  2. अंतरिम नियंत्रण के रूप में इंट्रिंसिक बंद करें। JVM को -XX:-UseBASE64Intrinsics के साथ शुरू करें ताकि हार्डवेयर-एक्सेलरेटेड Base64 पूरी तरह बंद हो जाए। प्रदर्शन पर लागत नगण्य है, जब तक आप गीगाबाइट Base64 डिकोड न कर रहे हों, जो लगभग कोई नहीं करता। वैकल्पिक रूप से, -XX:UseAVX=2 x86-64 पर AVX-512 बंद करता है — पर इस फ़्लैग को ARM पर न लगाएँ, वहाँ JVM स्टार्ट होने से इनकार कर देगा। यही दर्शन PHP CVE playbook वाला है: जब कमज़ोर घटक एक संकीर्ण, बदले जा सकने वाला फ़ास्ट पाथ हो, तो फ़ास्ट पाथ मार देना इंतज़ार करने से बेहतर है।
  3. प्रॉक्सी से एक्सप्लॉइट की टाइमिंग तोड़ें। Calif की अपनी limitations वाली सेक्शन बताती है कि मौजूदा रिमोट grooming प्रोफ़ाइल सटीक टाइमिंग के साथ आंशिक रिक्वेस्ट बॉडी पर निर्भर करती हैं। एक reverse proxy जो पूरी रिक्वेस्ट बॉडी बफ़र करता है — जो nginx डिफ़ॉल्ट रूप से करता है — वह उस टाइमिंग को नष्ट कर देता है। यह किसी भी हाल में फ़िक्स नहीं है, पर पैच करते समय सबसे व्यावहारिक हमले के रास्ते को काफ़ी कमज़ोर कर देता है।

डिटेक्शन पर भी एक वाक्य: Semgrep ने मुफ़्त स्क्रिप्ट प्रकाशित की हैं जो उन शर्तों के संयोजन की जाँच करती हैं जो किसी होस्ट को एक्सप्लॉइटेबल बनाती हैं: HotSpot-परिवार का VM, संबंधित इंस्ट्रक्शन सपोर्ट वाला x86-64 हार्डवेयर, और प्रभावित रेंज में वर्ज़न। मान लेने से पहले अपने पूरे फ़्लीट पर यह चलाएँ — आपके ARM-आधारित containers और OpenJ9 वाले बचे हुए सर्वर ठीक हैं, और यह जल्दी जानना एक वीकेंड बचाता है। स्कैन करते समय याद रखें कि वर्ज़न लाइन मायने रखती है: फ़िक्स हर train में विशिष्ट patch releases में आया, इसलिए “हम 21 पर हैं” कोई जवाब नहीं है।

एक चमकते कोर की रक्षा करती तीन संकेंद्रित सुरक्षा परतें, सबसे भीतरी रिंग पर एक स्विच पलटता हाथ
रक्षा की परतें बनाएँ: कोर पर पैच करें, फ़ास्ट पाथ बंद करें, और प्रॉक्सी को हमलावर की टाइमिंग तोड़ने दें।

सबसे बड़ा सबक: ऑप्टिमाइज़ेशन वे देनदारियाँ हैं जिनका आपने ऑडिट नहीं किया

घटना-प्रतिक्रिया से पीछे हटकर देखें तो Java4Shell एक असहज अवशेष छोड़ जाता है। बग किसी अस्पष्ट कोने के फ़ीचर में नहीं था। वह Base64 में था — कंप्यूटिंग के शायद सबसे उबाऊ, सबसे सर्वव्यापी, “अब तो यह ठीक ही होगा” वाले ऑपरेशन में। खामी इसलिए मौजूद थी क्योंकि किसी ने उस उबाऊ चीज़ को तेज़ बनाने का फ़ैसला किया — नवीनतम वेक्टर इंस्ट्रक्शन का इस्तेमाल करके, असेंबली में, एक tail-handling एज केस के साथ जो code review में बच निकला। हर परिपक्व रनटाइम ऐसी चीज़ों से भरा है। और अब उनमें से हर एक का शिकार ऐसे अथक एजेंट कर रहे हैं जिनकी लागत एक अच्छे डिनर से भी कम है।

आज हर कोई पूछ रहा है कि AI क्या बना सकता है। सुरक्षा का बेहतर सवाल शायद यह है कि वह हमें क्या मिटाने में मदद कर सकता है।

मेरी राय: उद्योग को जल्द ही “ऑडिट किए गए कोड” और “सुरक्षित मान लिए गए कोड” का फ़र्क सीखना होगा, और उसकी फ़ीस महँगी पड़ेगी। Standard libraries, VM इंट्रिंसिक, compression codecs, image decoders — वे बुनियादी परतें जिन पर हम कभी सवाल नहीं उठाते — ठीक वही जगहें हैं जहाँ इंसानी ध्यान सबसे कम है और जहाँ AI-सहायता वाली खोज सबसे ऊँचे bounties देती है। centaur मॉडल सिर्फ़ बग तेज़ी से नहीं खोजता; वह उन जगहों पर खोजता है जिन्हें इंसान रिसर्चर इसलिए छोड़ देते थे क्योंकि “solved” कोड का ऑडिट करने की अपेक्षित वैल्यू बहुत कम लगती थी।

तो अपने JVM पैच करें, जहाँ कर सकें वहाँ intrinsic फ़्लैग बदलें, और nginx को थोड़ा समय खरीदने दें। पर अपने dependency tree को भी देखें और uncoding वाला सवाल पूछें: इनमें से कौन से फ़ीचर हमने चुने थे और कौन से बस विरासत में मिले? वह 65 कैरेक्टर की स्ट्रिंग जो आपका वीकेंड जलाएगी, शायद पहले ही लिखी जा चुकी है। सवाल बस यह है कि उसे थामे हुए व्यक्ति डिसक्लोज़र फ़ाइल करेगा या नहीं।