कॉपी फेल (CVE-2026-31431) — Kubernetes कंटेनर एस्केप PoC

एक प्रूफ-ऑफ-कॉन्सेप्ट जो दर्शाता है कि कैसे एक पूर्णतः अनप्रिविलेज्ड कंटेनर Kubernetes पर नोड-स्तरीय कोड निष्पादन प्राप्त कर सकता है, साझा कंटेनर इमेज लेयर्स के माध्यम से CVE-2026-31431 Linux कर्नेल पेज-कैश भ्रष्टाचार बग का शोषण करके।

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

पृष्ठभूमि

CVE-2026-31431 ("कॉपी फेल") पेज-कैश कॉपी-ऑन-राइट (CoW) पथ में एक Linux कर्नेल भेद्यता है। एक AF_ALG स्प्लिस रेस एक अनप्रिविलेज्ड प्रक्रिया को रीड-ओनली फ़ाइल के पेज-कैश पृष्ठों को भ्रष्ट करने की अनुमति देता है। भ्रष्टाचार कर्नेल पेज कैश में बना रहता है और हर उस प्रक्रिया को दिखाई देता है जो बाद में फ़ाइल को पढ़ती या निष्पादित करती है — जिसमें अन्य कंटेनरों या होस्ट की प्रक्रियाएँ भी शामिल हैं।

मूल भेद्यता के पूर्ण विवरण के लिए, copy.fail देखें।

यह कैसे काम करता है

हमले की श्रृंखला के तीन चरण हैं: पेज-कैश भ्रष्टाचार, क्रॉस-कंटेनर प्रसार, और विशेषाधिकार प्राप्त निष्पादन।

1. AF_ALG स्प्लिस रेस के माध्यम से पेज-कैश भ्रष्टाचार

कर्नेल का AF_ALG (क्रिप्टो) सबसिस्टम उपयोगकर्ता-स्थान क्रिप्टोग्राफिक संचालन के लिए सॉकेट-आधारित इंटरफ़ेस प्रदान करता है। शोषण कर्नेल द्वारा splice() को फ़ाइल से AF_ALG सॉकेट में संभालने के तरीके में एक रेस कंडीशन का दुरुपयोग करता है:

1. लक्ष्य बाइनरी खोलें (जैसे /usr/sbin/ipset) रीड-ओनली।
2. authencesn(hmac(sha256),cbc(aes)) से बंधा एक AF_ALG AEAD सॉकेट बनाएं।
3. MSG_MORE के साथ AF_ALG सॉकेट के माध्यम से एक छोटा पेलोड चंक भेजें, कर्नेल को अधिक डेटा की अपेक्षा करने के लिए कहें।
4. लक्ष्य फ़ाइल की सामग्री को fd → पाइप → AF_ALG सॉकेट से splice() करें।
5. CoW बग के कारण, कर्नेल उन्हें ठीक से अलग करने के बजाय हमलावर के पेलोड बाइट्स को लक्ष्य फ़ाइल के पेज-कैश पृष्ठों में लिखता है।

शोषण इसे प्रत्येक 4-बाइट विंडो के लिए दोहराता है जब तक कि पूरे लक्ष्य बाइनरी के कैश्ड पृष्ठ कस्टम पेलोड के साथ अधिलेखित नहीं हो जाते।

फ़ाइल पर लिखने की अनुमति की आवश्यकता नहीं है। डिस्क पर फ़ाइल अपरिवर्तित है — केवल इन-मेमोरी पेज कैश भ्रष्ट है।

2. इमेज लेयर साझाकरण के माध्यम से क्रॉस-कंटेनर प्रसार

कंटेनर रनटाइम (containerd, CRI-O) ओवरले फाइलसिस्टम का उपयोग करते हैं। जब दो कंटेनर एक ही इमेज लेयर साझा करते हैं, तो कर्नेल उनकी फ़ाइल रीड को समान पेज-कैश पृष्ठों से सेवा प्रदान करता है।

यह PoC इमेज FROM registry.k8s.io/kube-proxy:v1.35.2 से बनाई गई है। प्रत्येक Kubernetes नोड पर kube-proxy DaemonSet बिल्कुल समान आधार लेयर का उपयोग करता है। परिणामस्वरूप, दोनों कंटेनरों में /usr/sbin/ipset पेज-कैश पृष्ठों के समान सेट पर मैप होता है।

जब अनप्रिविलेज्ड PoC कंटेनर ipset के पेज कैश को भ्रष्ट करता है, तो भ्रष्टाचार तुरंत उसी नोड पर विशेषाधिकार प्राप्त kube-proxy कंटेनर को दिखाई देता है — शून्य क्रॉस-कंटेनर संचार के साथ।

3. kube-proxy द्वारा विशेषाधिकार प्राप्त निष्पादन

kube-proxy hostNetwork: true के साथ एक विशेषाधिकार प्राप्त DaemonSet के रूप में चलता है। यह समय-समय पर iptables/ipset नियमों को प्रबंधित करने के लिए /usr/sbin/ipset को आमंत्रित करता है। जब यह अगली बार ipset निष्पादित करता है, तो कर्नेल भ्रष्ट पेज-कैश पृष्ठों को लोड करता है, kube-proxy के पूर्ण विशेषाधिकारों के साथ हमलावर के पेलोड को निष्पादित करता है:

• नोड पर पूर्ण रूट
• सभी क्षमताएँ
• होस्ट नेमस्पेस तक पहुंच

इस PoC में पेलोड (payload/payload.c) केवल होस्ट रूट फाइलसिस्टम को माउंट करता है और नोड-स्तरीय कोड निष्पादन के प्रमाण के रूप में /root/res पर एक मार्कर फ़ाइल लिखता है।

हमले का प्रवाह आरेख

┌──────────────────────────┐     ┌──────────────────────────┐
│   PoC कंटेनर             │     │   kube-proxy कंटेनर      │
│   (अनप्रिविलेज्ड)         │     │   (विशेषाधिकार प्राप्त)   │
│                          │     │                          │
│  1. /usr/sbin/ipset खोलें │     │                          │
│     (रीड-ओनली)           │     │                          │
│                          │     │                          │
│  2. AF_ALG स्प्लिस रेस   │     │                          │
│     पेज कैश भ्रष्ट करता है│     │                          │
│          │               │     │                          │
└──────────┼───────────────┘     └──────────────────────────┘
           │                                  │
           ▼                                  │
  ┌─────────────────────┐                     │
  │  कर्नेल पेज कैश      │                     │
  │  /usr/sbin/ipset     │◄────────────────────┘
  │  (भ्रष्ट)            │     3. kube-proxy ipset निष्पादित करता है
  │  हमलावर के पेलोड     │        → भ्रष्ट पृष्ठ लोड करता है
  │  बाइट्स शामिल हैं    │        → पेलोड होस्ट पर रूट के रूप में
  └─────────────────────┘           चलता है

रिपॉजिटरी संरचना

.
├── cmd/copyfail/main.go          # प्रवेश बिंदु; संकलित पेलोड एम्बेड करता है
├── internal/
│   ├── exploit/
│   │   ├── exploit.go            # मुख्य शोषण: AF_ALG स्प्लिस रेस लूप
│   │   └── patch.go              # पेलोड को 4-बाइट पैच विंडो में विभाजित करता है
│   └── alg/
│       └── alg.go                # AF_ALG AEAD सॉकेट एब्स्ट्रैक्शन
├── payload/
│   ├── payload.c                 # सत्यापन पेलोड (होस्ट fs माउंट करें, मार्कर लिखें)
│   └── nolibc/                   # स्थिर, नो-डिपेंडेंसी पेलोड के लिए कर्नेल की छोटी libc
├── deploy/
│   └── poc.yaml                  # Kubernetes डिप्लॉयमेंट मैनिफेस्ट
├── Dockerfile                    # इमेज लेयर साझा करने के लिए kube-proxy से बनाया गया
├── Makefile                      # बिल्ड ऑर्केस्ट्रेशन
└── docs/                         # ACK (Alibaba Cloud) से सत्यापन साक्ष्य

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

• Go 1.25+
• nolibc पेलोड के लिए एक क्रॉस-कंपाइलर (डिफ़ॉल्ट: x86_64-linux-gnu-gcc)
• Docker / Buildx
• kube-proxy को DaemonSet के रूप में imagePullPolicy: IfNotPresent (डिफ़ॉल्ट) के साथ चलाने वाला एक Kubernetes क्लस्टर
• Linux कर्नेल CVE-2026-31431 फिक्स से पहले

निर्माण

# पेलोड + Go बाइनरी बनाएं
make build

# Docker इमेज बनाएं
make docker-build

# GHCR पर बनाएं और पुश करें
make docker-push IMAGE=ghcr.io/<you>/copy-fail-poc TAG=latest

arm64 लक्ष्यों के लिए:

make build CC=aarch64-linux-gnu-gcc GOARCH=arm64

उपयोग

PoC तैनात करें

kubectl apply -f deploy/poc.yaml

डिप्लॉयमेंट एक एकल अनप्रिविलेज्ड पॉड बनाता है। यह:

1. पेज कैश को भ्रष्ट करने के लिए /bin/copyfail -target /usr/sbin/ipset चलाता है।
2. अनिश्चित काल तक सोता है ताकि पॉड अवलोकन के लिए चलता रहे।

एस्केप सत्यापित करें

kube-proxy द्वारा अगली बार ipset निष्पादित करने के बाद (यह आमतौर पर इसके पुनर्संयोजन लूप के कारण सेकंडों के भीतर होता है, या इसके अगले पुनरारंभ पर), नोड की जाँच करें:

# नोड में SSH करें, या एक विशेषाधिकार प्राप्त डीबग पॉड का उपयोग करें
cat /root/res
# अपेक्षित आउटपुट: [*] success

होस्ट फाइलसिस्टम पर /root/res की उपस्थिति साबित करती है कि हमलावर-आपूर्ति कोड नोड-स्तरीय विशेषाधिकारों के साथ निष्पादित हुआ — kube-proxy के विशेषाधिकार प्राप्त कंटेनर संदर्भ के अंदर से लिखा गया।

सफाई

kubectl delete -f deploy/poc.yaml

# प्रभावित नोड(ओं) पर, मार्कर हटाएं और kube-proxy पुनरारंभ करें:
rm -f /root/res
systemctl restart kubelet   # या पुनः-पुल को मजबूर करने के लिए kube-proxy पॉड हटाएं

kube-proxy + ipset क्यों?

kube-proxy एक आदर्श लक्ष्य है क्योंकि यह:

1. हर नोड पर मौजूद है — DaemonSet के रूप में चलता है।
2. अत्यधिक विशेषाधिकार प्राप्त — privileged: true, hostNetwork: true।
3. अपनी इमेज में ipset शामिल करता है — ipset iptables प्रबंधन के लिए उपयोग किया जाने वाला एक setuid बाइनरी है।
4. imagePullPolicy: IfNotPresent का उपयोग करता है — एक बार हमलावर की इमेज खींची जाती है और समान आधार लेयर साझा करती है, ओवरले लोअर-डिर पृष्ठ साझा होते हैं।

कोई भी विशेषाधिकार प्राप्त DaemonSet जिसकी इमेज में एक पूर्वानुमानित बाइनरी होती है, उसे उसी तरह लक्षित किया जा सकता है।

पेलोड को अनुकूलित करना

डिफ़ॉल्ट पेलोड (payload/payload.c) एक सत्यापन-केवल प्रोग्राम है जो एक मार्कर फ़ाइल लिखता है। कस्टम पेलोड बनाने के लिए:

1. payload/payload.c संपादित करें। प्रोग्राम स्थिर, डिपेंडेंसी-मुक्त बाइनरी के लिए nolibc (कर्नेल की न्यूनतम C लाइब्रेरी) के विरुद्ध बनाया गया है।
2. क्रॉस-कंपाइल करने के लिए make payload चलाएं।
3. संकलित पेलोड //go:embed के माध्यम से Go बाइनरी में एम्बेड किया गया है।

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

• Linux कर्नेल: CVE-2026-31431 पैच से पहले के सभी संस्करण।
• Kubernetes: अनपैच्ड नोड कर्नेल का उपयोग करने वाला कोई भी संस्करण। भेद्यता कर्नेल में है, Kubernetes में नहीं। Kubernetes केवल निष्पादन संदर्भ (साझा इमेज लेयर्स + विशेषाधिकार प्राप्त DaemonSets) प्रदान करता है जो प्रभाव को स्थानीय पेज-कैश भ्रष्टाचार से पूर्ण कंटेनर एस्केप तक बढ़ाता है।

शमन

• कर्नेल पैच करें। यह निश्चित समाधान है।
• इमेज लेयर अलगाव सक्षम करें। कुछ रनटाइम प्रति-कंटेनर फाइलसिस्टम स्नैपशॉट का समर्थन करते हैं जो पेज-कैश साझाकरण को रोकते हैं।
• kube-proxy के लिए रीड-ओनली रूट फाइलसिस्टम का उपयोग करें (पूरी तरह से शमन नहीं करता, लेकिन पेलोड क्षमताओं को सीमित करता है)।
• पॉड शेड्यूलिंग प्रतिबंधित करें ताकि अविश्वसनीय वर्कलोड साझा आधार इमेज वाले विशेषाधिकार प्राप्त DaemonSets चलाने वाले नोड्स पर न उतरें।

श्रेय

• CVE-2026-31431 खोज और प्रकटीकरण: Theori / Xint
• क्रॉस-प्लेटफ़ॉर्म C पेलोड: Tony Gies (LGPL-2.1-or-later OR MIT)
• nolibc: Linux कर्नेल selftests (tools/include/nolibc/)

लाइसेंस

इस रिपॉजिटरी में Go शोषण कोड शोध उद्देश्यों के लिए यथा-स्थिति प्रदान किया गया है।

पेलोड (payload/payload.c) copy-fail-c से व्युत्पन्न है और LGPL-2.1-or-later OR MIT के तहत द्वि-लाइसेंस प्राप्त है। LICENSE-LGPL और LICENSE-MIT देखें।