تجاوز مخزن EVP_EncodeBlock في OpenSSL: 5 خرافات مُختبَرة
ثغرة تجاوز المخزن في EVP_EncodeBlock بدرجة CVSS 9.8 تكشف كيف تفلت واجهات ترميز base64 من التدقيق. خمس خرافات عن أمان المرمِّزات، مختبرة.

وظيفة لا تفعل شيئًا سوى تحويل البايتات إلى نص base64 حصلت للتو على درجة CVSS تبلغ 9.8. ثغرة تجاوز المخزن في EVP_EncodeBlock ضمن OpenSSL، والمتتبَّعة تحت الرقم CVE-2026-121481، من النوع الذي يبدو مملًّا حتى تدرك أن ترميز base64 يقع تحت معالجة الشهادات، وعملاء HTTP، ومصادقة الوكيل، ونصف الشيفرة اللاصقة في بنيتك التحتية. الإصلاح نفسه استغرق أربعة commits وجدالًا حادًا بين القائمين على المشروع حول الشكل الذي ينبغي أن تبدو عليه قيمة الإرجاع عند الخطأ.
النقاش حول هذه الثغرة هدية لكل من يهتم بتصميم الواجهات البرمجية، لأنه يكشف كومة من الافتراضات التي يبنيها المهندسون حول دوال الترميز، وهي افتراضات تواصل إنتاج فئة الخلل نفسها عبر عقود ومكتبات مختلفة. لنأخذ خمسة من أشيع المعتقدات ونقارنها بما حدث فعلًا.
كيف تعمل ثغرة تجاوز المخزن في EVP_EncodeBlock فعليًا
ترميز Base64 يُضخّم البيانات: كل ثلاثة بايتات مدخلة تصبح أربعة محارف في المخرجات. لذلك حجم المخرجات هو 4 * ((n + 2) / 3)، مع إضافة واحد لمحرف NUL الختامي إذا أردت سلسلة C. تجعل الدالة EVP_EncodeBlock() في OpenSSL المُستدعي يحسب هذا الحجم ويخصص المخزن الوجهة بنفسه. أما الدالة نفسها فتستقبل مؤشر المدخلات، ومؤشر المخرجات، وطول المدخلات بوصفه int. لا تعرف أبدًا حجم مخزن المخرجات، ولذلك لا تستطيع التحقق من شيء. تكتب فقط.
لنجرِ الحساب الآن. أكبر قيمة لـ int هي 2,147,483,647. عندما يتجاوز طول المدخلات (INT_MAX / 4) * 3، أي 1,610,612,733 بايتًا تقريبًا، أو نحو 1.6 جيجابايت، يفيض حساب الحجم الداخلي عن عدد صحيح موقّع بـ 32 بت. يلتف الحساب، فلا يعود تصور الدالة لمكان انتهاء المخرجات مطابقًا للواقع، فتحصل على كتابات تتجاوز نهاية أي مخزن خصّصه المُستدعي. والمُستدعي، باتباعه الصيغة الموثقة، أجرى الحساب المتجاوز نفسه، فقد يختلف الطرفان اختلافًا كارثيًا حول المساحة المتاحة فعلًا.
أضاف الإصلاح في المشروع الأصلي شرطًا للحماية: رفض المدخلات التي يكون فيها dlen > (INT_MAX / 4) * 3، إضافة إلى المخازن الفارغة (NULL) والأطوال السالبة. إذا كنت تغلف هذه الواجهة، وينبغي عليك ذلك، فيجب أن يوجد الفحص عند حدودك أنت أيضًا:
#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;
}
لاحظ ما تفرضه هذه الواجهة: عليك إعادة تنفيذ صيغة الحجم الداخلية للمكتبة في المُستدعي، بشكل صحيح، إلى الأبد. هذا العقد هو الثغرة الحقيقية. التجاوز مجرد المكان الذي انكسر فيه العقد أخيرًا.
الخرافة الأولى: "فكّ الترميز هو سطح الهجوم، أما الترميز فممل"
ثقافة مراجعة الأمان تحمل انحيازًا قويًا: التحليل خطير، والتسلسل مجرد حسابات دفترية. فكّاكات الترميز تستهلك بايتات معادية، لذلك تُخضع للـ fuzzing والتدقيق وإعادة الكتابة بلغات آمنة للذاكرة. أما المُرمِّزات فتنتج مخرجات، والمخرجات تبدو آمنة. هذا الاعتقاد خاطئ بطريقة محددة وقابلة للتكرار: أخطاء المُرمِّزات تعيش في حساب حجم المخرجات، وهذا الحساب موثوق من الطرفين في الاستدعاء.
النمط يتكرر. يشير خيط الـ PR نفسه إلى أن CVE-2026-121481 يشبه CVE-2021-23840، وهي ثغرة تجاوز سابقة في OpenSSL ضمن دوال EVP update، حيث فاض حساب الطول عند مدخلات ضخمة. وبالنسبة لـ base64 تحديدًا، فالأمر مألوف هنا: عندما حوّل فكّ ترميز Base64 في OpenJDK 65 بايتًا إلى تنفيذ كود عن بُعد، تناولنا كيف تحوّل ترميز "تافه" إلى أداة RCE. تحصل الفكّاكات على ثغرات لقبولها مدخلات سيئة، وتحصل المُرمِّزات عليها لأنها تحسب أطوالًا جيدة بشكل خاطئ. كلاهما من النوع نفسه: حساب على أطوال تتأثر بالمهاجم.
الحكم: خرافة مدحوضة. إذا توقف نموذج التهديد عند المحلل، فقد تركت الباب الخلفي مفتوحًا بينما تحرس الباب الأمامي.
الخرافة الثانية: "درجة CVSS 9.8 تعني أن تترك كل شيء الليلة"
هنا سأدافع قليلًا عن المتشككين. درجة 9.8 لمُرمِّز يحتاج إلى مدخلات بحجم 1.6 جيجابايت ليست Heartbleed. لا يوجد ترميز base64 لبيانات ضخمة في أي مكان في مصافحة TLS، فالشهادات تنتقل بصيغة DER داخل TLS لا PEM. لكي تؤذيك هذه الثغرة، يجب أن تصل بيانات غير موثوقة إلى EVP_EncodeBlock() (أو إلى مُستدعٍ داخلي مثل base64encode() في عميل HTTP الخاص بـ OpenSSL) بحجم يتجاوز 1.6 جيجابايت. حقل بروتوكول بطول مسبوق بـ 16 بت لن يصل إلى هذا الحجم أبدًا.
لكن وصفها بأنها "افتراضية" يُقلل من شأنها أيضًا. أظهر المُبلِّغ مسار سطر أوامر حقيقيًا: تمرير قيمة -proxy_pass ضخمة إلى openssl s_client، عبر متغير بيئة لتجاوز حدود وسائط الصدفة، وبعض الإعدادات، إذ تقبل محركات GOST كلمات مرور كبيرة افتراضيًا، ستُرمّزها بـ base64 بكل سرور لطلب CONNECT إلى الوكيل. هذه ليست فضولًا مخبريًا، إنها أداة قياسية تقوم بمصادقة وكيل قياسية باستخدام متغير بيئة قياسي.
موقفي: اعتبر CVSS مقياسًا لوظيفة الدالة، واعتبر مخطط استدعاءاتك مقياسًا لتعرضك. قبل أن تجدول نافذة تصحيح طارئة، ابحث في شيفرتك وتبعياتك عمّن يرمّز فعلًا ما، وما مدى كبر المدخلات الممكن. ثم صحّح على أي حال، لكن بالترتيب الصحيح. الحكم: صحيح جزئيًا. الدرجة حقيقية، لكن الذعر يجب أن يكون متناسبًا مع قابلية الوصول، وقابلية الوصول سؤال لا تجيب عنه إلا شيفرتك.
الخرافة الثالثة: "الإصلاح سهل، فقط أعد رمز خطأ"
هذا أحب جزء لديّ في القصة كلها، لأن تجاوز المخزن كان الجزء السهل. الجزء الصعب كان تحديد ما ينبغي أن تفعله EVP_EncodeBlock() حياله، ولم يتفق القائمون على المشروع.
أعاد التصحيح الأصلي القيمة -1 للمدخلات غير الصالحة، تماشيًا مع الطبقة التوافقية في wolfSSL ومسارات الفشل الموجودة في EVP_DecodeBlock(). وجاء الاعتراض فورًا. قلق أحد القائمين من أن المُستدعين من طرف ثالث يحوّلون قيمة الإرجاع إلى size_t دون تحقق، و-1 تصبح SIZE_MAX تحت هذا التحويل، وهذا أسوأ من التجاوز الذي تمنعه على الأرجح. إذن فلنُرجع 0؟ لكن 0 نجاح مشروع أصلًا: ترميز صفر بايت يعيد صفرًا. وكما قال أحدهم، سبق أن احترق لأنه رفع خطأ في حالة نجاح. قال آخر: استخدم OPENSSL_assert() إذن، وأوقف التنفيذ عند خرق العقد ووثّق الشرط المسبق. فردّ قائم كبير بحزم: الـ assert داخل المكتبة "DoS ينتظر حدوثه".
كانت كل الخيارات سيئة، ولكل منها سبب مختلف: -1 يكسر التحويلات غير الموقعة، و0 يتعارض مع النجاح، والـ assert يحوّل خطأ منطقيًا إلى انهيار يتحكم فيه المهاجم. هذا ما يحدث عندما لا تُصمَّم دلالات الخطأ في الواجهة أصلًا، بل تُوَرَّث. إنها فجوة المواصفة والتنفيذ في أنقى صورها، فقد كان التوثيق يقول "تعيد عدد البايتات المرمّزة"، ولم يكتب أحد يومًا ما يحدث عندما يكون الترميز مستحيلًا.
تفصيلتان أخريان من الخيط تستحقان الانتباه. أولًا، لاحظ مراجع أن التصحيح الأولي رفض f == NULL بشكل مطلق، لكن ترميز مخزن فارغ بمؤشر مدخلات NULL وdlen == 0 كان يعمل دائمًا، والتطبيقات الحقيقية كانت تعتمد عليه. حتى التحقق "الصحيح بوضوح" كسر حالة حدّية مشروعة. ثانيًا، بحث مراجع عن مواقع الاستدعاء التي لا تتحقق من قيمة الإرجاع، فوجدها داخل OpenSSL نفسها: PEM_SignFinal() وNETSCAPE_SPKI_b64_encode(). جعل دالة قابلة للفشل حديثًا لا يفيد شيئًا إذا كان مستدعوها كُتبوا عندما لم تكن قادرة على الفشل. الحكم: مدحوضة تمامًا. دلالات الخطأ جزء من تصميم الواجهة، وإعادة تركيبها جراحة، لا تصحيح.

الخرافة الرابعة: "لا أحد يغذي جيجابايت واحدًا إلى مُرمِّز base64"
الحدس هنا أن base64 مخصص للأشياء الصغيرة: الشهادات والمفاتيح والرموز القصيرة. وفي الغالب هذا صحيح. لكن الأنظمة الحديثة نمت بهدوء لتتعامل مع كتل ضخمة تُرمَّز طوال الوقت: مستندات الإثبات، واستجابات SAML، وبيانات manifest لصور الحاويات، وبيانات اعتماد الوكلاء، وحمولات webhooks يقرر وسيط ما إعادة ترميزها. لم يكن مُعيد إنتاج هذه الثغرة غريبًا، فقد كان كلمة مرور تُمرَّر عبر متغير بيئة، في مسار شيفرة يرمّز بيانات الاعتماد لوكيل HTTP. لم يُصمَّم أي شيء في هذا المسار مع سقف 1.6 جيجابايت في الحسبان، لأن أحدًا لم يكتب هذا السقف في أي مكان.
هناك أيضًا عادة معمارية تزيد الأمر سوءًا: واجهات الترميز الدفعية تشجّع على تحميل الحمولة كاملة في الذاكرة قبل تحويلها. يوفر OpenSSL بدائل متدفقة، هي EVP_EncodeInit() وEVP_EncodeUpdate() وEVP_EncodeFinal()، وتعالج البيانات على دفعات وتتجنب مشكلة "حساب الحجم الإجمالي للمخرجات مسبقًا". التدفق يكلفك كائن سياق وحلقة تكرار. ما يقدمه هو أنه لا يتعين على أي طول مفرد أن يكون في الوقت نفسه متأثرًا بالمهاجم وموثوقًا به. الحكم: مدحوضة. تكبر المدخلات حتى تبلغ حدًا، وإذا كان هذا الحد فيض عدد صحيح موقّع، فسيجدك الحد.
الخرافة الخامسة: "أدوات الـ fuzzing لدينا كانت ستكتشف هذا"
لم تكن لتكتشفه، ويستحق الأمر فهم السبب. تستخدم أدوات الـ fuzzing الموجّهة بالتغطية مثل libFuzzer حدودًا قصوى لأطوال المدخلات تُقاس بالكيلوبايت، أي 4096 بايت افتراضيًا. الخلل الذي يتطلب 1.6 مليار بايت من المدخلات ليس مجرد غير مرجح العثور عليه، بل هو خارج فضاء البحث كليًا. يمكنك إجراء fuzzing على EVP_EncodeBlock() لقرن كامل دون أن تلامس التجاوز، لأن السلوك المثير للاهتمام لا يوجد إلا عند حجم لن تزوره أداة الـ fuzzing أبدًا.
الحل ليس مدخلات fuzzing أكبر، فلا أحد يريد تخصيص 1.6 جيجابايت في كل تكرار للـ fuzzing. الحل هو اختبار الحساب بمعزل عن الترميز. استخرج حساب الحجم واضرب حدوده باختبارات وحدة بسيطة:
#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;
}
ثم أضف فحصًا تفاضليًا عند أحجام متوسطة: احسب طول المخرجات المتوقع بصيغة المُستدعي، ثم رمّز، وأكّد أن الدالة كتبت عدد البايتات المحدد بالضبط ولا أكثر. شغّل كل ذلك تحت AddressSanitizer مع مدخلات بحجم بضع مئات الميغابايت في CI، كبيرة بما يكفي لتمرين الحلقات الواسعة، وصغيرة بما يكفي لتنتهي قبل الغداء. يظل الـ fuzzing الأداة الصحيحة لمنطق الترميز على مستوى البايتات، لكنه لم يكن الأداة الصحيحة يومًا لتجاوز الأعداد الصحيحة على نطاق واسع، والخلط بين هاتين المهمتين هو ما يجعل أخطاء كهذه تعيش عقدًا تحت fuzzing مستمر. الحكم: مدحوضة.
كيف تدقق واجهة المُرمِّز قبل أن تدقق هي فيك
سواء كنت تراجع استخدام OpenSSL في شيفرتك، أو تقيّم مسار الترميز في أي مكتبة، فإن حفنة الأسئلة نفسها تكشف فئة الخلل هذه بأكملها:
- من يحسب حجم المخرجات؟ إذا قام المُستدعي بذلك باستخدام صيغة غير بسيطة، فقد ينحرف الطرفان. فضّل الواجهات التي تأخذ سعة المخرجات معاملًا، وتفشل بشكل نظيف عندما تكون غير كافية.
- ما نوع العدد الصحيح الذي يحمل الأطوال؟ معامل طول من نوع
intهو سقف 2 جيجابايت مع بت إشارة. لا يجعلsize_tالتجاوز مستحيلًا، لكنه ينقل السقف إلى ما بعد حافة أي مخزن يمكنك تخصيصه فعلًا على جهاز 64 بت. - ماذا يحدث عند الصفر، وعند الحد، وعند ما بعده بواحد؟ مدخلات فارغة، والقيمة
(INT_MAX/4)*3تمامًا، وتلك القيمة زائد واحد هي الحالات الثلاث التي تهم. - هل أصبحت الدالة قابلة للفشل مؤخرًا؟ إذا أضاف تصحيح قيم إرجاع خطأ إلى شيء لم يكن قادرًا على الفشل من قبل، فابحث في كل موقع استدعاء. القيم المرتجعة غير المفحوصة تحوّل خللًا مُصلحًا إلى خلل صامت.
- هل يوجد متغير متدفق؟ واجهات encode/update/final المجزأة تلغي الحاجة إلى أي طول إجمالي موثوق واحد.
سأذهب أبعد في النقطة الأولى: أي واجهة تجعل المُستدعي يكرر صيغة الحجم الداخلية للمكتبة هي مصنع للأخطاء، وينبغي للصناعة أن تتوقف عن بنائها. الدالة المُستدعاة تعرف معامل التمدد وقواعد الحشو وعُرف محرف النهاية. إجبار كل مُستدعٍ على إعادة اشتقاق 4 * ((n + 2) / 3) + 1 يضمن أن شخصًا ما في مكان ما سيخطئ فيها، أو يصيبها في نوع صغير أكثر من اللازم.

الخلاصة لـ Base64 وما بعده
ستختفي CVE-2026-121481 من الخلاصات خلال أسبوع، لكن فئة الخلل لن تختفي. تقع دوال الترميز في النقطة العمياء لمراجعة الأمان: موثوقة في الأطوال، ومعفاة من الـ fuzzing على نطاق واسع، ومغلفة بواجهات لم تُحدَّد دلالات الخطأ فيها أبدًا. قضى القائمون على OpenSSL كلمات أكثر في الجدال حول ما إذا كان ينبغي إرجاع -1 أو 0 أو الانهيار، مما قضوه في التجاوز نفسه، وكانوا محقين، لأن هذا هو الجزء الذي سيعيش معه كل مُستدعٍ لاحق لسنوات.
إذن: صحّح، نعم، لكن ابحث أيضًا. اعثر على مواقع استدعاء الترميز لديك، وتحقق من يحسب حجم المخزن، وتأكد من أن القيم المرتجعة تُفحص فعلًا، وانقل أي شيء يتعامل مع بيانات ضخمة غير موثوقة إلى واجهة متدفقة. الـ 9.8 التالية في مُرمِّز موجودة الآن في صيغة حجم أحدهم، تنتظر مدخلات كبيرة بما يكفي لتكشفها.


