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

OpenSSL EVP_EncodeBlock ओवरफ़्लो: 5 मिथक, परखे गए

OpenSSL EVP_EncodeBlock ओवरफ़्लो (CVSS 9.8) दिखाता है कि base64 एन्कोडर API जाँच से कैसे बचते हैं। एन्कोडर सिक्योरिटी के पाँच मिथक, परखे गए।

एक विशाल कीप चमकते क्यूब्स को एक छोटे, छलकते कांच के प्याले में उड़ेल रही है।
EVP_EncodeBlock मानकर चलता है कि caller ने प्याला सही आकार का रखा है। वह कभी जाँचता नहीं।

बेस-64 में बाइट्स को टेक्स्ट में बदलने भर का काम करने वाले एक फ़ंक्शन को अभी 9.8 का CVSS स्कोर मिला है। OpenSSL में EVP_EncodeBlock का बफ़र ओवरफ़्लो, जिसे CVE-2026-121481 नाम दिया गया है, उन बगों में से है जो सुनने में उबाऊ लगते हैं, जब तक आप यह न समझें कि base64 एन्कोडिंग सर्टिफ़िकेट हैंडलिंग, HTTP क्लाइंट, प्रॉक्सी ऑथेंटिकेशन और आपके इन्फ़्रास्ट्रक्चर के आधे glue code के नीचे बैठी है। इस फ़िक्स में चार कमिट लगे, और maintainers के बीच इस पर काफ़ी गरमागरम बहस हुई कि error return आख़िर दिखना कैसा चाहिए।

इस CVE के आसपास की चर्चा API डिज़ाइन में दिलचस्पी रखने वालों के लिए खजाना है, क्योंकि यह एन्कोडिंग फ़ंक्शनों के बारे में इंजीनियरों की उन धारणाओं को सामने लाती है जो दशकों और अलग-अलग लाइब्रेरी में वही बग पैदा करती आई हैं। आइए ऐसी पाँच सबसे आम मान्यताएँ लें और उन्हें असल में हुई घटना के सामने रखकर देखें।

EVP_EncodeBlock बफ़र ओवरफ़्लो असल में कैसे काम करता है

Base64 एन्कोडिंग डेटा को फुला देती है: हर तीन इनपुट बाइट्स चार आउटपुट कैरेक्टर बन जाते हैं। यानी आउटपुट का आकार 4 * ((n + 2) / 3) होता है, और अगर आपको C स्ट्रिंग चाहिए तो NUL टर्मिनेटर के लिए एक और बाइट। OpenSSL का EVP_EncodeBlock() caller से यह आकार निकालने और डेस्टिनेशन बफ़र आवंटित करने की उम्मीद करता है। फ़ंक्शन खुद इनपुट पॉइंटर, आउटपुट पॉइंटर और इनपुट की लंबाई, जो int है, प्राप्त करता है। उसे यह नहीं पता होता कि आउटपुट बफ़र कितना बड़ा है, इसलिए वह कुछ भी वैलिडेट नहीं कर सकता। वह बस लिखता जाता है।

अब गणित करें। सबसे बड़ा int 2,147,483,647 है। जब इनपुट की लंबाई (INT_MAX / 4) * 3 से अधिक हो जाती है, यानी 1,610,612,733 बाइट्स, लगभग 1.6 GB, तो आंतरिक आकार गणना साइन्ड 32-बिट इंटीजर में ओवरफ़्लो कर जाती है। लंबाई की गणना लपेटी जाती है, फ़ंक्शन का अनुमान कि आउटपुट कहाँ खत्म होता है असलियत से मेल नहीं खाता, और caller द्वारा आवंटित बफ़र के अंत से आगे लिखा जाने लगता है। caller ने भी दस्तावेज़ में दिए फ़ॉर्मूले के अनुसार वही ओवरफ़्लो वाला गणित किया, इसलिए दोनों पक्ष इस पर भयंकर रूप से असहमत हो सकते हैं कि कितनी जगह उपलब्ध है।

upstream फ़िक्स में एक गार्ड जोड़ा गया: ऐसे इनपुट को रद्द करना जहाँ dlen > (INT_MAX / 4) * 3 हो, साथ ही NULL बफ़र और नेगेटिव लंबाइयाँ भी। अगर आप इस API को रैप करते हैं, और आपको करना चाहिए, तो यह जाँच आपकी सीमा पर भी होनी चाहिए:

#include <limits.h>
#include <stddef.h>
#include <openssl/evp.h>
/*
* Mirrors the upstream guard: refuse inputs whose encoded size
* cannot be represented in an int, and verify the destination
* capacity ourselves since the API never sees it.
*/
int b64_encode_checked(const unsigned char *in, size_t n,
unsigned char *out, size_t out_cap)
{
size_t need;
if (in == NULL || n > ((size_t)INT_MAX / 4) * 3)
return -1;
need = ((n + 2) / 3) * 4 + 1;   /* +1 for the NUL terminator */
if (out == NULL || out_cap < need)
return -1;
if (EVP_EncodeBlock(out, in, (int)n) < 0)
return -1;
return 0;
}

ध्यान दें कि यह API आपसे क्या करवाता है: caller में लाइब्रेरी के आंतरिक आकार फ़ॉर्मूले को सही ढंग से, हमेशा के लिए दोबारा लागू करना। असली कमजोरी यही कॉन्ट्रैक्ट है। ओवरफ़्लो बस वह जगह है जहाँ यह कॉन्ट्रैक्ट आख़िरकार टूट गया।

मिथक 1: "डिकोडर हमले की सतह हैं, एन्कोडर उबाऊ हैं"

सिक्योरिटी रिव्यू कल्चर में एक मज़बूत झुकाव है: पार्सिंग खतरनाक है, सीरियलाइज़ेशन बस हिसाब-किताब है। डिकोडर दुश्मन के भेजे बाइट्स खाते हैं, इसलिए उन्हें फ़ज़्ड, ऑडिट और मेमोरी-सेफ़ भाषाओं में दोबारा लिखा जाता है। एन्कोडर आउटपुट बनाते हैं, और आउटपुट सुरक्षित लगता है। यह धारणा एक खास, दोहराए जाने वाले तरीके से गलत है: एन्कोडर के बग आउटपुट आकार की गणना में रहते हैं, और उस गणित पर कॉल के दोनों पक्ष भरोसा करते हैं।

यह पैटर्न बार-बार दिखता है। PR थ्रेड खुद ध्यान दिलाता है कि CVE-2026-121481 एक पुराने OpenSSL ओवरफ़्लो CVE-2021-23840 से मिलता है, जिसमें EVP update फ़ंक्शनों में बहुत बड़े इनपुट पर लंबाई की गणना ओवरफ़्लो हो गई थी। और base64 के साथ तो यह खास तौर पर दिखता है: जब OpenJDK के Base64 डिकोडर ने 65 बाइट्स को रिमोट कोड एक्ज़िक्यूशन में बदल दिया, तब हमने बताया था कि एक "मामूली" कोडेक RCE प्रिमिटिव कैसे बन गया। डिकोडर बुरे इनपुट स्वीकार करने पर CVE पाते हैं; एन्कोडर अच्छे इनपुट की गलत गणना पर। दोनों एक ही प्रजाति हैं: हमलावर-प्रभावित लंबाइयों पर अंकगणित।

फ़ैसला: मिथक झूठा। अगर आपका थ्रेट मॉडल सिर्फ़ पार्सर पर रुकता है, तो आपने सामने का दरवाज़ा पहरे में रखा है और पिछला खुला छोड़ दिया है।

मिथक 2: "CVSS 9.8 का मतलब है आज रात सब छोड़ दो"

यहाँ मैं संशयवादियों का थोड़ा बचाव करूँगा। 1.6 GB इनपुट माँगने वाले एन्कोडर पर 9.8 Heartbleed जैसा नहीं है। TLS हैंडशेक में कहीं भी बल्क डेटा का base64 एन्कोडिंग नहीं होती, क्योंकि सर्टिफ़िकेट TLS के अंदर DER के रूप में जाते हैं, PEM के रूप में नहीं। आपको नुकसान तभी हो सकता है जब अविश्वसनीय डेटा EVP_EncodeBlock() तक पहुँचे (या OpenSSL के HTTP क्लाइंट में base64encode() जैसे आंतरिक caller तक) और 1.6 GB से ऊपर के पैमाने पर। 16-बिट लंबाई प्रीफ़िक्स वाला प्रोटोकॉल फ़ील्ड वहाँ कभी नहीं पहुँच सकता।

लेकिन "सिंथेटिक" कहना भी इसे कम आँकना है। रिपोर्टर ने एक असली कमांड-लाइन रास्ता दिखाया: openssl s_client को एक बहुत बड़ी -proxy_pass वैल्यू दी गई, जो शेल आर्गुमेंट सीमा से बचने के लिए एन्वायरनमेंट वेरिएबल से दी गई, और कुछ कॉन्फ़िगरेशन (GOST इंजन डिफ़ॉल्ट रूप से बहुत बड़े पासवर्ड स्वीकार कर लेते हैं) उसे प्रॉक्सी CONNECT रिक्वेस्ट के लिए खुशी-खुशी base64 में एन्कोड कर देंगे। यह लैब की कोई जिज्ञासा नहीं है; यह एक मानक टूल का मानक एन्वायरनमेंट वेरिएबल के साथ मानक प्रॉक्सी ऑथ करना है।

मेरी राय: CVSS को फ़ंक्शन का माप मानें, और अपने कॉल ग्राफ़ को अपने एक्सपोज़र का माप। इमरजेंसी पैच विंडो तय करने से पहले अपने कोडबेस और डिपेंडेंसी में grep करें कि असल में कौन क्या एन्कोड करता है और इनपुट कितना बड़ा हो सकता है। फिर भी पैच करें, बस सही क्रम में। फ़ैसला: आधा सच। स्कोर असली है, पर घबराहट रीचेबिलिटी के अनुपात में होनी चाहिए, और रीचेबिलिटी ऐसा सवाल है जिसका जवाब सिर्फ़ आपका कोड दे सकता है।

मिथक 3: "फ़िक्स आसान है, बस एरर कोड लौटा दो"

पूरी कहानी का मेरा सबसे पसंदीदा हिस्सा यही है, क्योंकि ओवरफ़्लो तो सरल हिस्सा था। कठिन हिस्सा यह तय करना था कि EVP_EncodeBlock() इसके बारे में क्या करे, और maintainers सहमत नहीं हो पाए।

मूल पैच ने अमान्य इनपुट के लिए -1 लौटाया, जो wolfSSL की compatibility layer और EVP_DecodeBlock() के मौजूदा फ़ेल्योर पाथ से मेल खाता था। तुरंत विरोध आया। एक maintainer को चिंता थी कि थर्ड-पार्टी caller रिटर्न वैल्यू को बिना जाँचे size_t में कास्ट कर देते हैं, और उस कास्ट के तहत -1 SIZE_MAX बन जाता है, जो उस ओवरफ़्लो से शायद भी बुरा है जिसे यह रोकता है। तो 0 लौटाएँ? पर 0 पहले से एक वैध सफलता है: शून्य बाइट्स एन्कोड करने पर भी शून्य लौटता है। जैसा एक maintainer ने कहा, वे पहले ही एक सफल केस पर एरर उठाने की वजह से जल चुके हैं। तो OPENSSL_assert() का इस्तेमाल करें, बोला एक और: कॉन्ट्रैक्ट उल्लंघन पर क्रैश करें और प्रीकंडीशन दस्तावेज़ में लिखें। जिस पर एक सीनियर maintainer ने सपाट जवाब दिया: लाइब्रेरी के अंदर assert "एक DoS जो होने का इंतज़ार कर रहा है" है।

हर विकल्प बुरा था, और हर एक किसी अलग वजह से बुरा था: -1 अनसाइन्ड कास्ट तोड़ता है, 0 सफलता से टकराता है, और assert एक लॉजिक एरर को हमलावर के नियंत्रण वाले क्रैश में बदल देता है। यही होता है जब किसी API की एरर सिमैंटिक्स कभी डिज़ाइन नहीं की गईं, बस विरासत में मिली हों। यह स्पेसिफ़िकेशन-इम्प्लीमेंटेशन गैप अपने शुद्धतम रूप में है: दस्तावेज़ में लिखा था "encode किए गए बाइट्स की संख्या लौटाता है", और किसी ने कभी यह लिखा ही नहीं कि जब एन्कोडिंग असंभव हो तब क्या होता है।

थ्रेड की दो और बातें ध्यान देने लायक हैं। पहली, एक रिव्यूअर ने पकड़ा कि शुरुआती पैच f == NULL को बिना शर्त रद्द कर देता था, जबकि NULL इनपुट पॉइंटर और dlen == 0 के साथ खाली बफ़र एन्कोड करना हमेशा काम करता था, और असली एप्लिकेशन उस पर निर्भर थे। यानी "स्पष्ट रूप से सही" वैलिडेशन ने भी एक वैध edge case तोड़ दिया। दूसरी, एक रिव्यूअर ने उन call sites को grep किया जो रिटर्न वैल्यू नहीं जाँचते, और वे OpenSSL के भीतर ही मिले: PEM_SignFinal() और NETSCAPE_SPKI_b64_encode()। जब कोई फ़ंक्शन नए सिरे से फ़ेल हो सकने वाला बनता है, तो उसे तब लिखे गए callers अपने आप ठीक नहीं होते जब वह फ़ेल नहीं हो सकता था। फ़ैसला: पूरी तरह झूठा। एरर सिमैंटिक्स API डिज़ाइन का हिस्सा हैं, और उन्हें बाद में जोड़ना पैच नहीं, सर्जरी है।

कोहरे भरी शाम में एक रेलवे ट्रैक तीन अलग-अलग रास्तों में बँट जाता है।
-1 लौटाएँ, 0 लौटाएँ, या assert: फ़िक्स की बहस की हर शाखा का अपना खतरा था।

मिथक 4: "कोई भी base64 एन्कोडर में एक गीगाबाइट नहीं डालता"

इसके पीछे धारणा यह है कि base64 छोटी चीज़ों के लिए है: सर्टिफ़िकेट, की, छोटे टोकन। और ज़्यादातर यह सच भी है। लेकिन आधुनिक सिस्टम में चुपचाप बड़े-बड़े ब्लॉब्स बढ़ गए हैं जो लगातार एन्कोड होते हैं, जैसे attestation दस्तावेज़, SAML रिस्पॉन्स, कंटेनर इमेज मेनिफ़ेस्ट, प्रॉक्सी क्रेडेंशियल, और वे webhook payloads जिन्हें कोई middlebox दोबारा एन्कोड करने का फ़ैसला करता है। इस CVE का रीप्रोड्यूसर कोई विदेशी चीज़ नहीं था: यह एक पासवर्ड था, जो एन्वायरनमेंट वेरिएबल से आया, और उस कोड पाथ पर था जो HTTP प्रॉक्सी के लिए क्रेडेंशियल एन्कोड करता है। उस पाइपलाइन को 1.6 GB की सीमा ध्यान में रखकर कभी डिज़ाइन नहीं किया गया था, क्योंकि वह सीमा कहीं लिखी ही नहीं गई थी।

एक आर्किटेक्चरल आदत इसे और बदतर बनाती है: एक-शॉट एन्कोडिंग API पूरे पेलोड को transform करने से पहले मेमोरी में पढ़ने को बढ़ावा देते हैं। OpenSSL के पास स्ट्रीमिंग विकल्प हैं, EVP_EncodeInit(), EVP_EncodeUpdate(), EVP_EncodeFinal(), जो डेटा को चंक्स में प्रोसेस करते हैं और "शुरू में कुल आउटपुट आकार की गणना" वाली पूरी समस्या से बच निकलते हैं। स्ट्रीमिंग में एक context ऑब्जेक्ट और एक लूप की कीमत लगती है। बदले में मिलता है यह कि कोई भी एक लंबाई एक साथ हमलावर-प्रभावित और भरोसेमंद नहीं होती। फ़ैसला: झूठा। इनपुट तब तक बढ़ते रहते हैं जब तक किसी सीमा तक न पहुँच जाएँ, और अगर वह सीमा साइन्ड इंटीजर ओवरफ़्लो है, तो सीमा आपको ढूँढ लेती है।

मिथक 5: "हमारे फ़ज़र्स यह पकड़ लेते"

नहीं पकड़ते, और यह समझना उपयोगी है कि क्यों। libFuzzer जैसे coverage-guided फ़ज़र्स का डिफ़ॉल्ट अधिकतम इनपुट आकार किलोबाइट्स में होता है, बॉक्स से बाहर 4096 बाइट्स। जिस बग को 1.6 अरब बाइट्स का इनपुट चाहिए, उसे सिर्फ़ मिलने की संभावना कम नहीं है; वह पूरी तरह खोज के दायरे से बाहर है। आप EVP_EncodeBlock() को एक सदी तक फ़ज़ कर सकते हैं और ओवरफ़्लो को छू भी न पाएँ, क्योंकि दिलचस्प व्यवहार सिर्फ़ उस पैमाने पर मौजूद है जहाँ फ़ज़र कभी नहीं जाएगा।

फ़िक्स फ़ज़ इनपुट बड़े करना नहीं है। कोई भी हर फ़ज़ इटरेशन में 1.6 GB आवंटित नहीं करना चाहेगा। फ़िक्स है गणित को एन्कोडिंग से अलग टेस्ट करना। आकार की गणना को अलग निकालें और उसकी सीमाओं पर सादे unit tests चलाएँ:

#include <assert.h>
#include <limits.h>
/* Mirrors the upstream guard, computed in a wide type. */
static int encoded_len_fits_int(long long dlen)
{
return dlen >= 0 && dlen <= ((long long)INT_MAX / 4) * 3;
}
int main(void)
{
long long limit = ((long long)INT_MAX / 4) * 3; /* 1,610,612,733 */
assert(encoded_len_fits_int(0));
assert(encoded_len_fits_int(limit));
assert(!encoded_len_fits_int(limit + 1));
assert(!encoded_len_fits_int(-1));
/* The encoded size at the limit must itself fit in an int. */
assert(4 * ((limit + 2) / 3) <= INT_MAX);
return 0;
}

फिर मध्यम आकार पर एक differential check जोड़ें: अपने caller-side फ़ॉर्मूले से अपेक्षित आउटपुट लंबाई निकालें, एन्कोड करें, और assert करें कि फ़ंक्शन ने ठीक उतने ही बाइट्स लिखे, एक भी ज़्यादा नहीं। CI में कुछ सौ-मेगाबाइट के इनपुट पर AddressSanitizer के तहत सब कुछ चलाएँ, इतना बड़ा कि चौड़े लूप्स का व्यायाम हो, और इतना छोटा कि लंच से पहले खत्म हो जाए। Fuzzing अब भी codec के बाइट-स्तरीय लॉजिक के लिए सही औज़ार है; वह कभी भी पैमाने पर integer overflow के लिए सही औज़ार नहीं था, और इन दोनों कामों को मिलाना ही वह तरीका है जिससे ऐसे बग एक दशक की लगातार फ़ज़िंग में भी बच निकलते हैं। फ़ैसला: झूठा।

किसी एन्कोडर API का ऑडिट करें, इससे पहले कि वह आपका ऑडिट करे

चाहे आप अपने कोड में OpenSSL के इस्तेमाल की समीक्षा कर रहे हों या किसी भी लाइब्रेरी के encode पाथ का मूल्यांकन, ये कुछ सवाल पूरी बग-श्रेणी को पकड़ लेते हैं:

  • आउटपुट आकार कौन निकालता है? अगर caller इसे किसी गैर-तुच्छ फ़ॉर्मूले से करता है, तो दोनों पक्ष अलग हो सकते हैं। ऐसे API को प्राथमिकता दें जो आउटपुट क्षमता को पैरामीटर के रूप में लें और अपर्याप्त होने पर साफ़ तरीके से फ़ेल करें।
  • लंबाइयाँ कौन-सा इंटीजर टाइप ढोता है? int लंबाई पैरामीटर साइन बिट के साथ 2 GB की सीमा है। size_t ओवरफ़्लो को असंभव नहीं बनाता, पर 64-बिट मशीन पर आप जितना बफ़र वास्तव में आवंटित कर सकते हैं, उसकी सीमा से उसे आगे खिसका देता है।
  • शून्य पर, सीमा पर, और उससे एक आगे क्या होता है? खाली इनपुट, ठीक (INT_MAX/4)*3, और उसमें एक जोड़ने पर वही तीन टेस्ट केस मायने रखते हैं।
  • क्या फ़ंक्शन हाल ही में फ़ेल हो सकने वाला बना? अगर किसी पैच ने ऐसी चीज़ में एरर रिटर्न जोड़ा जो पहले फ़ेल नहीं हो सकती थी, तो हर call site को grep करें। बिना जाँचे रिटर्न एक तय बग को चुपचाप बग में बदल देते हैं।
  • क्या कोई स्ट्रीमिंग वेरिएंट है? चंक्ड encode/update/final API किसी भी एक भरोसेमंद कुल लंबाई की ज़रूरत खत्म कर देते हैं।

पहले बिंदु पर मैं और आगे जाऊँगा: जो भी API caller से लाइब्रेरी का आंतरिक आकार फ़ॉर्मूला दोहराने को कहता है, वह बग बनाने की फ़ैक्ट्री है, और इंडस्ट्री को ऐसे API बनाना बंद कर देना चाहिए। कॉल होने वाले को विस्तार गुणांक, padding नियम और टर्मिनेटर परंपरा पता होती है। हर caller को 4 * ((n + 2) / 3) + 1 दोबारा निकालने पर मजबूर करना यह तय कर देता है कि कहीं न कहीं कोई इसे गलत करेगा, या किसी ऐसे टाइप में सही करेगा जो बहुत छोटा है।

एक मैग्निफ़ाइंग ग्लास कन्वेयर बेल्ट पर चमकते ब्लॉक्स को जाँचता है; एक में दरार है।
एन्कोडर ऑडिट को सिर्फ़ बाइट्स की अदला-बदली पर नहीं, आकार की गणना पर ध्यान देना चाहिए।

Base64 और उससे आगे के लिए सबक

CVE-2026-121481 एक हफ़्ते में फ़ीड्स से गायब हो जाएगा, पर बग की यह श्रेणी नहीं जाएगी। एन्कोडिंग फ़ंक्शन सिक्योरिटी रिव्यू के ब्लाइंड स्पॉट में बैठते हैं: लंबाइयों पर भरोसा किया जाता है, बड़े पैमाने पर फ़ज़िंग से छूट मिलती है, और ऐसे API में लपेटे जाते हैं जिनका एरर व्यवहार कभी स्पेसिफ़ाई ही नहीं हुआ। OpenSSL के maintainers ने ओवरफ़्लो पर जितने शब्द खर्च किए, उससे ज़्यादा इस पर बहस में लगाए कि -1 लौटाएँ, 0 लौटाएँ, या क्रैश करें। और वे सही थे, क्योंकि वही वह हिस्सा है जिसके साथ हर डाउनस्ट्रीम caller सालों तक जिएगा।

तो हाँ, पैच करें, पर grep भी करें। अपने encode call sites खोजें, देखें कि बफ़र आकार कौन निकालता है, जाँचें कि रिटर्न सच में जाँचे जाते हैं, और जो भी अविश्वसनीय बल्क डेटा संभालता है उसे स्ट्रीमिंग API पर ले जाएँ। किसी एन्कोडर में अगला 9.8 पहले से ही किसी के आकार फ़ॉर्मूले में बैठा है, बस एक इतने बड़े इनपुट का इंतज़ार कर रहा है जो उसे ढूँढ निकाले।