DIRTY FRAG डिटेक्शन Wazuh 4.14.4 के साथ - CVE-2026-43284 / CVE-2026-43500

Dirty Frag कर्नेल LPE के लिए डिटेक्शन इंजीनियरिंग - Ubuntu / RHEL / Debian / Amazon Linux

Dirty Frag क्या है?

CVE-2026-43284 / CVE-2026-43500 एक Linux कर्नेल Local Privilege Escalation (LPE) है जो दो स्वतंत्र page-cache write primitives को जोड़कर एक अन-विशेषाधिकार प्राप्त उपयोगकर्ता खाते से रूट प्राप्त करता है। एक संकलित बाइनरी सभी प्रमुख Linux वितरणों पर रूट प्राप्त करती है। कोई race condition नहीं। कोई heap spray नहीं। कोई kernel offset आवश्यक नहीं।

वेरिएंट 1 - CVE-2026-43284 (xfrm-ESP):``` unshare(CLONE_NEWUSER|CLONE_NEWNET) -> register XFRM SA via netlink (CAP_NET_ADMIN inside new namespace) -> vmsplice(ESP header into pipe) -> splice(target file into pipe) -> splice(pipe to UDP socket) -> esp_input() in-place AEAD decrypt writes 4 bytes into page cache

**वेरिएंट 2 - CVE-2026-43500 (RxRPC):**```
add_key("rxrpc", ...)       no privileges required
-> socket(AF_RXRPC=35)
-> RxRPC handshake + forged DATA packet
-> vmsplice(RxRPC wire header into pipe)
-> splice(target file into pipe)
-> splice(pipe to UDP socket)
-> rxkad_verify_packet_1() in-place pcbc(fcrypt) decrypt writes 8 bytes into page cache

When CLONE_NEWUSER is blocked by AppArmor (Ubuntu 24.04+ default), the exploit automatically falls back from the ESP variant to the RxRPC variant. The same binary achieves root on both cases.

महत्वपूर्ण: Copy Fail शमन (algif_aead को ब्लैकलिस्ट करना) Dirty Frag के विरुद्ध सुरक्षा प्रदान नहीं करता। दोनों कमजोरियाँ एक ही authencesn sink साझा करती हैं, लेकिन Dirty Frag पूरी तरह से भिन्न कोड पथ के माध्यम से ट्रिगर होती है। यदि आपने Copy Fail शमन तैनात किया है, तब भी आप असुरक्षित हैं।

V4bel द्वारा खोजा गया और प्रकाशित - https://github.com/V4bel/dirtyfrag

आधिकारिक संदर्भ

FIM क्यों विफल होता है - यह रेपो क्यों मौजूद है

Dirty Frag सीधे इन-मेमोरी पेज कैश में लिखता है। डिस्क पर मौजूद बाइनरी कभी संशोधित नहीं होती। कर्नेल कभी भी दूषित पेज को गंदा (dirty) चिह्नित नहीं करता, इसलिए writeback कभी नहीं चलता। डिस्क फ़ाइल शोषण से पहले और बाद में मूल से बाइट-दर-बाइट समान रहती है।``` Traditional FIM approach: read file from disk -> compute hash -> compare -> no anomaly reported

Dirty Frag reality: on-disk /usr/bin/su = UNCHANGED page cache of /usr/bin/su = CONTAINS ROOT SHELL ELF FIM result = BLIND

एकमात्र प्रभावी पहचान व्यवहार-आधारित है, कर्नेल स्तर पर syscall निगरानी के माध्यम से। यह रिपॉजिटरी उत्पादन-सत्यापित Wazuh नियम प्रदान करती है जो कर्नेल संस्करण या पैच स्थिति की परवाह किए बिना, syscall स्तर पर दोनों exploit वेरिएंट का पता लगाती है।

---

## Exploit श्रृंखला```
ESP variant (CVE-2026-43284):
  unshare(CLONE_NEWUSER)    privilege boundary bypass via user namespace
  -> XFRM SA registration  CAP_NET_ADMIN gained inside new netns
  -> vmsplice()        [!]  ESP header planted into pipe
  -> splice()          [!]  /usr/bin/su page cache enters pipe
  -> splice()               pipe delivered to UDP socket
  -> esp_input() decrypt    4 bytes written deterministically into page cache
  -> execve(/usr/bin/su)    corrupted setuid binary runs shellcode as UID 0

RxRPC variant (CVE-2026-43500):
  add_key("rxrpc")          session key K planted - no privileges needed
  -> socket(AF_RXRPC)       rxrpc.ko auto-loaded
  -> vmsplice()        [!]  RxRPC wire header planted into pipe
  -> splice()          [!]  /etc/passwd page cache enters pipe
  -> splice()               pipe delivered to UDP socket
  -> rxkad_verify_packet_1() 8 bytes written deterministically into page cache
  -> su -                   /etc/passwd root entry has empty password field

पेज कैश भ्रष्टाचार दोनों वेरिएंट में मुख्य प्रिमिटिव है। vmsplice हमलावर-नियंत्रित प्रोटोकॉल हेडर को पाइप में डालता है। splice लक्ष्य फ़ाइल के पेज कैश पृष्ठों को बिना कॉपी किए उसी पाइप में पहुँचाता है। जब कर्नेल संयुक्त बफ़र को डिक्रिप्ट पथ के माध्यम से संसाधित करता है, तो वह हमलावर-नियंत्रित बाइट्स को लक्ष्य फ़ाइल के पेज कैश में लिखता है।

प्रभावित सिस्टम

@m0us3r द्वारा पुष्टि - Ubuntu 24.04.2 LTS डिटेक्शन लैब

लेखक द्वारा पुष्टि (github.com/V4bel/dirtyfrag)

2017 से सभी Linux कर्नेल प्रभावित हैं। Ubuntu 24.04+ पर AppArmor unprivileged_userns प्रतिबंध ESP वेरिएंट को ब्लॉक करता है, लेकिन RxRPC वेरिएंट इसे पूरी तरह से बायपास कर देता है।

CVE-2026-43284 (ESP): कमिट cac2661c53f3 (2017-01-17) से f4c50a4034e6 (2026-05-05) तक दायरे में - मेनलाइन में पैच किया गया

CVE-2026-43500 (RxRPC): कमिट 2dc334f1a63a (2023-06-08) से अपस्ट्रीम तक दायरे में - अभी तक कोई पैच मौजूद नहीं है

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

DIRTY-FRAG-Detection-with-Wazuh-4.14.4/ | |- rules/ | '- local_rules.xml # 9 Wazuh detection rules (200000-200008) | |- auditd/ | '- cve-dirty-frag.rules # auditd syscall sensor rules (v2 - auid fix) | |- sca/ | '- cve-dirty-frag.yml # SCA policy - kernel-version independent | '- docs/ |- dirty_frag_dash_rules.png # Wazuh Rules Management - 200000-200008 deployed and active |- SCA.png # SCA policy score 50% - 3 passed / 3 failed |- SCA-hits.png # Wazuh Discover - SCA check results across 3 scan cycles |- discover-dirty-frag.png # Wazuh Discover - 52 hits - initial validation run (May 8) '- discover-dirty-frag_more.png # Wazuh Discover - 13 hits - chain rule 200007 level 15 (May 15)

> **local_rules.xml पर नोट:** नियम `local_rules.xml` में दिए गए हैं, जो `/var/ossec/etc/rules/local_rules.xml` पर कस्टम नियमों के लिए मानक Wazuh फ़ाइल है। यदि आप अपने डिटेक्शन नियमों को CVE के अनुसार व्यवस्थित रखना पसंद करते हैं, तो आप सामग्री को उसी निर्देशिका में एक स्टैंडअलोन फ़ाइल (जैसे `cve-2026-43284_rules.xml`) के रूप में तैनात कर सकते हैं। दोनों तरीके समान रूप से काम करते हैं।

---

## पहचान आर्किटेक्चर

दो स्वतंत्र परतें - कोई भी कर्नेल संस्करण या पैच स्थिति पर निर्भर नहीं करती।

### परत 1 - व्यवहारिक पहचान (auditd + Wazuh)

**uid बनाम auid पर महत्वपूर्ण नोट:** ESP प्रकार की चाइल्ड प्रक्रिया `unshare(CLONE_NEWUSER)` को कॉल करती है और नए यूज़र नेमस्पेस के अंदर स्वयं को `uid=0` के रूप में मैप करती है। Linux ऑडिट सबसिस्टम SYSCALL इवेंट्स में नेमस्पेस-स्थानीय uid को रिकॉर्ड करता है, जिसका अर्थ है कि `-F uid!=0` फ़िल्टर एक्सप्लॉइट चाइल्ड से `vmsplice` और `splice` इवेंट्स को कैप्चर नहीं करते। `auid` (ऑडिट uid / लॉगिन uid) लॉगिन समय पर सेट होता है और नेमस्पेस रीमैपिंग के साथ कभी नहीं बदलता। `vmsplice` और `splice` के लिए सेंसर नियम `-F auid>=1000` का उपयोग करते हैं ताकि वास्तविक लॉगिन उपयोगकर्ता को सही ढंग से कैप्चर किया जा सके, भले ही एक्सप्लॉइट नेमस्पेस के अंदर कुछ भी करे।

**Auditd सेंसर नियम** (`auditd/cve-dirty-frag.rules`):```
-a always,exit -F arch=b64 -S vmsplice -F auid>=1000 -F auid!=-1 -k dirty_frag_vmsplice
-a always,exit -F arch=b32 -S vmsplice -F auid>=1000 -F auid!=-1 -k dirty_frag_vmsplice
-a always,exit -F arch=b64 -S splice   -F auid>=1000 -F auid!=-1 -k dirty_frag_splice
-a always,exit -F arch=b32 -S splice   -F auid>=1000 -F auid!=-1 -k dirty_frag_splice
-a always,exit -F arch=b64 -S unshare  -F uid!=0                  -k dirty_frag_ns_escape
-a always,exit -F arch=b64 -S add_key  -F uid!=0                  -k dirty_frag_add_key
-a always,exit -F arch=b64 -S socket   -F a0=0x23 -F uid!=0       -k dirty_frag_rxrpc_socket
-w /usr/bin/kmod -p x                                             -k dirty_frag_modload
-a always,exit -F arch=b64 -S execve -F exe=/usr/bin/su -F auid>=1000 -F auid!=-1 -k dirty_frag_execve_su

परत 2 - भेद्यता सतह (SCA नीति)

sca/cve-dirty-frag.yml के माध्यम से स्वचालित कॉन्फ़िगरेशन जाँचें। हर 12 घंटे में सभी पंजीकृत एजेंटों पर चलती हैं। कोई कर्नेल संस्करण जाँच आवश्यक नहीं है।

नियम श्रृंखला आर्किटेक्चर

इंजीनियरिंग नोट: चेन नियम (200007/200008) तब सक्रिय होते हैं जब एक ही प्रक्रिया से दो सिग्नल 120 सेकंड के भीतर पहुंचते हैं। एक ही pid से vmsplice के बाद splice आना दोनों वेरिएंट का मुख्य पाइप-प्लांट अनुक्रम है। एक ही pid से AF_RXRPC सॉकेट के बाद splice आना RxRPC पथ के लिए विशिष्ट है। दोनों चेन wazuh-logtest के माध्यम से 9/9 पास के साथ मान्य किए गए हैं।

Wazuh डैशबोर्ड - नियम तैनात

नियम 200000-200008 तैनात और सक्रिय हैं। अनुपालन टैग: PCI_DSS, HIPAA, GDPR, NIST_800_53, MITRE ATT&CK। नियम 200007 और 200008 सहसंबद्ध श्रृंखला पहचान पर स्तर 15 (क्रिटिकल) तक पहुंचते हैं।

तैनाती

चरण 1 - auditd स्थापित करें```bash

Ubuntu / Debian

apt install auditd audispd-plugins -y systemctl enable --now auditd auditctl -s | grep enabled

RHEL / Amazon Linux

yum install audit -y systemctl enable --now auditd

SUSE

zypper install audit -y systemctl enable --now auditd

### चरण 2 - auditd सेंसर नियम तैनात करें```bash
cp auditd/cve-dirty-frag.rules /etc/audit/rules.d/
augenrules --load
auditctl -l | grep dirty_frag

I apologize, but the input content appears to be missing — the "INPUT:" section is empty, so there is no source text to translate. Please provide the chunk content, and I will translate it into Hindi according to the rules.``` -a always,exit -F arch=b64 -S vmsplice -F auid>=1000 -F auid!=-1 -F key=dirty_frag_vmsplice -a always,exit -F arch=b32 -S vmsplice -F auid>=1000 -F auid!=-1 -F key=dirty_frag_vmsplice -a always,exit -F arch=b64 -S splice -F auid>=1000 -F auid!=-1 -F key=dirty_frag_splice -a always,exit -F arch=b32 -S splice -F auid>=1000 -F auid!=-1 -F key=dirty_frag_splice -a always,exit -F arch=b64 -S unshare -F uid!=0 -F key=dirty_frag_ns_escape -a always,exit -F arch=b64 -S add_key -F uid!=0 -F key=dirty_frag_add_key -a always,exit -F arch=b64 -S socket -F a0=0x23 -F uid!=0 -F key=dirty_frag_rxrpc_socket -w /usr/bin/kmod -p x -k dirty_frag_modload -a always,exit -F arch=b64 -S execve -F exe=/usr/bin/su -F auid>=1000 -F auid!=-1 -F key=dirty_frag_execve_su

### चरण 3 - Wazuh डिटेक्शन नियम तैनात करें

`rules/local_rules.xml` की सामग्री को अपनी मौजूदा `/var/ossec/etc/rules/local_rules.xml` में जोड़ें, या यदि आप नियमों को CVE द्वारा व्यवस्थित रखना पसंद करते हैं तो इसे एक स्टैंडअलोन फ़ाइल के रूप में तैनात करें:```bash
# Option A - append to local_rules.xml (recommended)
cat rules/local_rules.xml >> /var/ossec/etc/rules/local_rules.xml

# Option B - standalone file
cp rules/local_rules.xml /var/ossec/etc/rules/cve-2026-43284_rules.xml

| प्रमाणीकरण | वेब टूल के लिए आवश्यक है कि उपयोगकर्ता सत्र की शुरुआत में Azure से एक ऐसे उपयोगकर्ता खाते से प्रमाणित हो जिसके पास परीक्षण की जा रही सब्सक्रिप्शन या प्रबंधन समूह पर कम से कम पाठक भूमिका हो। वैकल्पिक रूप से, इस गाइड का पालन करके सेवा प्रिंसिपल प्रमाणीकरण समर्थन उपलब्ध है। प्रबंधित पहचान प्रमाणीकरण उपयोग करने के लिए, यहां क्लिक करें। |```bash

Validate syntax - must exit 0 with zero warnings

/var/ossec/bin/wazuh-analysisd -t 2>&1 | tail -5

Restart manager

systemctl restart wazuh-manager

### चरण 4 - SCA नीति तैनात करें```bash
# On the Wazuh manager - distribute to all agents via shared group
cp sca/cve-dirty-frag.yml /var/ossec/etc/shared/default/
chown root:wazuh /var/ossec/etc/shared/default/cve-dirty-frag.yml
chmod 660 /var/ossec/etc/shared/default/cve-dirty-frag.yml

एजेंट समूह कॉन्फ़िगरेशन में जोड़ें (/var/ossec/etc/shared/default/agent.conf):```xml <agent_config> /var/ossec/etc/shared/cve-dirty-frag.yml </agent_config>

> **आवश्यक:** प्रत्येक एजेंट पर रिमोट कमांड निष्पादन सक्षम होना चाहिए ताकि `c:lsmod` और `c:systemctl` जाँचें चल सकें:
>
> ```bash
> echo "sca.remote_commands=1" >> /var/ossec/etc/local_internal_options.conf
> systemctl restart wazuh-agent
> ``````bash
systemctl restart wazuh-manager

चरण 5 - ossec.conf localfile कॉन्फ़िगर करें

सुनिश्चित करें कि Wazuh एजेंट auditd लॉग को इन्जेस्ट करता है। प्रत्येक मॉनिटर किए गए होस्ट पर /var/ossec/etc/ossec.conf में <ossec_config> के अंदर जोड़ें, या agent.conf के माध्यम से वितरित करें:```xml <log_format>audit</log_format> /var/log/audit/audit.log

---

## सत्यापन

### wazuh-logtest - सभी 9 नियम```bash
# SIGNAL 1 - vmsplice (rule 200000)
echo 'type=SYSCALL msg=audit(1778261582.230:1155): arch=c000003e syscall=316 success=yes exit=8 a0=3 a1=7fff00000000 a2=1 a3=0 items=0 ppid=1000 pid=93321 auid=1000 uid=1000 gid=1000 euid=1000 suid=1000 fsuid=1000 egid=1000 sgid=1000 fsgid=1000 tty=pts0 ses=58 comm="exp" exe="/home/kr/exp" subj=unconfined key="dirty_frag_vmsplice"' | /var/ossec/bin/wazuh-logtest 2>&1 | grep -E "rule|level|200"

# SIGNAL 7 - CHAIN ESP (rules 200000 + 200007, same pid)
printf 'type=SYSCALL msg=audit(1777570010.000:200): arch=c000003e syscall=316 success=yes exit=8 a0=3 a1=7fff00000000 a2=1 a3=0 items=0 ppid=1000 pid=55001 auid=1000 uid=1000 gid=1000 euid=1000 suid=1000 fsuid=1000 egid=1000 sgid=1000 fsgid=1000 tty=pts0 ses=58 comm="exp" exe="/home/kr/exp" key="dirty_frag_vmsplice"\ntype=SYSCALL msg=audit(1777570011.000:201): arch=c000003e syscall=275 success=yes exit=4 a0=4 a1=5 a2=6 a3=0 items=0 ppid=1000 pid=55001 auid=1000 uid=1000 gid=1000 euid=1000 suid=1000 fsuid=1000 egid=1000 sgid=1000 fsgid=1000 tty=pts0 ses=58 comm="exp" exe="/home/kr/exp" key="dirty_frag_splice"\n' | /var/ossec/bin/wazuh-logtest 2>&1 | grep -E "rule|level|200"

चेन टेस्ट के लिए अपेक्षित:``` id: '200000' level: '10' <- vmsplice signal id: '200007' level: '15' <- CHAIN ESP confirmed - IMMEDIATE INVESTIGATION REQUIRED

### सत्यापित करें कि auditd ने एक्सप्लॉइट चलाने के बाद घटनाओं को कैप्चर किया```bash
ausearch -k dirty_frag_vmsplice --start today 2>/dev/null | grep "exe=" | head -5
ausearch -k dirty_frag_ns_escape --start today 2>/dev/null | grep "exe=" | head -5
ausearch -k dirty_frag_execve_su --start today 2>/dev/null | grep "EUID=" | head -5

Wazuh द्वारा उत्पन्न अलर्ट सत्यापित करें```bash

grep -E "200002|200005|200006" /var/ossec/logs/alerts/alerts.log | tail -10

अपेक्षित SCA स्कोर (बेसलाइन प्रणाली जिसमें सेंसर या auditd तैनात नहीं है): **50%** (3 पास / 3 फेल).

---

## उत्पादन सत्यापन साक्ष्य

### एक्सप्लॉइट निष्पादन - एजेंट wazuh5beta (Ubuntu 24.04.2 LTS kernel 6.8.0-111-generic)```
kr@wazuh5beta:~$ ./exp
root@wazuh5beta:~# date ; uname -a ; id ; whoami
Sat May 9 04:59:08 AM UTC 2026
Linux wazuh5beta 6.8.0-111-generic #111-Ubuntu SMP PREEMPT_DYNAMIC Sat Apr 11 23:16:02 UTC 2026 x86_64
uid=0(root) gid=0(root) groups=0(root)
root

User kr (uid=1000) with no privileges executed the PoC binary and obtained root shell (uid=0). Wazuh captured and alerted in real time.

बिना विशेषाधिकार वाले उपयोगकर्ता kr (uid=1000) ने PoC बाइनरी निष्पादित की और रूट शेल (uid=0) प्राप्त किया। Wazuh ने वास्तविक समय में कैप्चर किया और अलर्ट किया।

Initial validation run - May 8, 2026 (52 hits)

प्रारंभिक सत्यापन रन - 8 मई, 2026 (52 हिट)

Context: This run was executed before the complete auditd sensor rules were deployed. Rules 200002, 200005, and 200006 fired via baseline auditd coverage. The full chain rule (200007) requires the cve-dirty-frag.rules sensor file to be active - see the full validation run below.

संदर्भ: यह रन पूर्ण auditd सेंसर नियम तैनात किए जाने से पहले निष्पादित किया गया था। नियम 200002, 200005, और 200006 आधारभूत auditd कवरेज के माध्यम से सक्रिय हुए। पूर्ण श्रृंखला नियम (200007) के लिए cve-dirty-frag.rules सेंसर फ़ाइल सक्रिय होना आवश्यक है - नीचे पूर्ण सत्यापन रन देखें।

Full validation run - chain rule 200007 firing (May 15, 2026)

पूर्ण सत्यापन रन - श्रृंखला नियम 200007 सक्रिय (15 मई, 2026)

Rule 200007 fired after deploying the complete auditd sensor rules (cve-dirty-frag.rules). The chain correlated vmsplice() + splice() from pid=5670 (exe=/home/kr/exp) within the 120-second window. This is the highest-confidence signal in the detection set.

नियम 200007 पूर्ण auditd सेंसर नियम (cve-dirty-frag.rules) तैनात करने के बाद सक्रिय हुआ। श्रृंखला ने 120-सेकंड की विंडो के भीतर pid=5670 (exe=/home/kr/exp) से vmsplice() + splice() को सहसंबद्ध किया। यह डिटेक्शन सेट में सबसे उच्च-विश्वास वाला संकेत है।

SCA Policy - Score 50% (baseline without sensor deployed)

SCA नीति - स्कोर 50% (सेंसर तैनात किए बिना बेसलाइन)

Score 50% represents a clean baseline system with the vulnerable modules absent (unloaded) but without the detection and hardening stack deployed. This is the expected starting point for a system that has not yet applied the remediation steps in this repository.

स्कोर 50% एक स्वच्छ बेसलाइन प्रणाली का प्रतिनिधित्व करता है जिसमें कमजोर मॉड्यूल अनुपस्थित (लोड नहीं किए गए) हैं, लेकिन डिटेक्शन और हार्डनिंग स्टैक तैनात नहीं किया गया है। यह उस प्रणाली के लिए अपेक्षित प्रारंभिक बिंदु है जिसने अभी तक इस भंडार में दिए गए सुधार चरणों को लागू नहीं किया है।

wazuh-analysisd -t: exit 0 - zero warnings - all 9 rules loaded.

wazuh-analysisd -t: निकास 0 - शून्य चेतावनियाँ - सभी 9 नियम लोड किए गए।

Ubuntu 24.04 Note - AppArmor and Variant Fallback

Ubuntu 24.04 नोट - AppArmor और वेरिएंट फ़ॉलबैक

Ubuntu 24.04 ships with apparmor_restrict_unprivileged_userns=1 by default (kernel 6.1+). This setting restricts unshare(CLONE_NEWUSER) for unprivileged processes, which partially mitigates the ESP variant (CVE-2026-43284). The kernel logs an AppArmor AUDIT event for the attempt, which is what triggers rule 200002 in our lab.

Ubuntu 24.04 डिफ़ॉल्ट रूप से apparmor_restrict_unprivileged_userns=1 के साथ आता है (कर्नेल 6.1+). यह सेटिंग विशेषाधिकार रहित प्रक्रियाओं के लिए unshare(CLONE_NEWUSER) को प्रतिबंधित करती है, जो ESP वेरिएंट (CVE-2026-43284) को आंशिक रूप से शमन करती है। कर्नेल इस प्रयास के लिए एक AppArmor AUDIT ईवेंट लॉग करता है, जो हमारे प्रयोगशाला में नियम 200002 को ट्रिगर करता है।

The exploit binary automatically falls back to the RxRPC variant (CVE-2026-43500) when the ESP path fails. The RxRPC variant does not require CLONE_NEWUSER and bypasses this restriction.

एक्सप्लॉइट बाइनरी ESP पथ विफल होने पर स्वचालित रूप से RxRPC वेरिएंट (CVE-2026-43500) पर फ़ॉलबैक करती है। RxRPC वेरिएंट को CLONE_NEWUSER की आवश्यकता नहीं होती है और यह इस प्रतिबंध को बायपास करता है।```bash

Check if your Ubuntu system has this restriction active

cat /proc/sys/kernel/apparmor_restrict_unprivileged_userns

1 = restricted (ESP variant blocked, RxRPC still active)

0 = not restricted (both variants active)

Rules 200000/200001 (vmsplice/splice) सक्रिय और प्रासंगिक बने हुए हैं:
- Ubuntu 22.04 और पुराने संस्करण
- Debian 11/12
- RHEL 8/9
- कोई भी कर्नेल जिसमें `apparmor_restrict_unprivileged_userns=0` है

पूर्ण 9/9 नियम कवरेज को Wazuh 4.14.4 पर `wazuh-logtest` के माध्यम से मान्य किया गया था।

---

## निवारण

### तत्काल शमन (कर्नेल पैच से पहले)

**RxRPC वेरिएंट (CVE-2026-43500) के लिए:**```bash
echo 'install rxrpc /bin/false' >> /etc/modprobe.d/dirty-frag.conf
rmmod rxrpc 2>/dev/null || true

सभी गैर-AFS सिस्टम पर सुरक्षित। यह IPsec, kTLS, SSH या सामान्य नेटवर्क स्टैक को प्रभावित नहीं करता है।

ESP वेरिएंट (CVE-2026-43284) के लिए - केवल तभी जब कोई IPsec टनल उपयोग में न हों:```bash echo 'install esp4 /bin/false' >> /etc/modprobe.d/dirty-frag.conf echo 'install esp6 /bin/false' >> /etc/modprobe.d/dirty-frag.conf rmmod esp4 esp6 2>/dev/null || true

> **चेतावनी:** `esp4`/`esp6` को ब्लैकलिस्ट करने से strongSwan/Libreswan IPsec टनल टूट जाती हैं। सक्रिय IPsec कनेक्शन चला रहे होस्ट पर इसे लागू न करें।

### स्थायी समाधान

अपने डिस्ट्रीब्यूशन कर्नेल अपडेट के माध्यम से कर्नेल कमिट `f4c50a4034e6` लागू करें।```bash
# Ubuntu / Debian
apt update && apt upgrade linux-generic

# RHEL / Amazon Linux
dnf update kernel

# SUSE
zypper update kernel-default

Copy Fail (CVE-2026-31431) के साथ संबंध

दोनों कमजोरियाँ Linux कर्नेल में समान authencesn decrypt sink का शोषण करके page cache में हमलावर-नियंत्रित बाइट्स लिखती हैं। अंतर यह है कि वे उस sink तक कैसे पहुँचती हैं।

दोनों नियमसेट एक ही Wazuh manager पर सुरक्षित रूप से सह-अस्तित्व में रह सकते हैं। auditd कुंजी नेमस्पेस अलग-अलग हैं और कोई नियम ID विरोध नहीं है।

प्रकटीकरण समयरेखा

SCA नीति सारांश

डिटेक्शन नियम, auditd सेंसर कॉन्फ़िगरेशन और SCA नीति Wazuh 4.14.4, Ubuntu 24.04.2 LTS (कर्नेल 6.8.0-111-generic) पर मान्य की गई।

लेखक

Kislley Rodrigues (m0us3r) Wazuh राजदूत | डिटेक्शन इंजीनियरिंग | ब्लू टीम

आभार

• V4bel को CVE-2026-43284 / CVE-2026-43500 की खोज, सार्वजनिक प्रकटीकरण और PoC के लिए - https://github.com/V4bel/dirtyfrag
• Wazuh टीम को ओपन SIEM/XDR प्लेटफ़ॉर्म के लिए
• Anthony Faruna और Katia Bukcovac - Wazuh Ambassador Program, इस डिटेक्शन डिलिवरेबल पर समीक्षा और फीडबैक के लिए
• CloudLinux को https://blog.cloudlinux.com/dirty-frag-mitigation-and-kernel-update पर प्रारंभिक शमन संदर्भ के लिए

Wazuh

यह प्रोजेक्ट Wazuh Ambassador Program के हिस्से के रूप में विकसित किया गया था।

Wazuh एक मुफ़्त, ओपन सोर्स सुरक्षा प्लेटफ़ॉर्म है जो एकीकृत XDR और SIEM सुरक्षा प्रदान करता है। wazuh.com पर अधिक जानें।