// https://syzkaller.appspot.com/bug?id=2f3b2a50c5ba580d44d59128dc497480142588ae #define _GNU_SOURCE #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef MEMGETINFO struct mtd_info_user { uint8_t type; uint32_t flags; uint32_t size; uint32_t erasesize; uint32_t writesize; uint32_t oobsize; uint64_t padding; }; #define MEMGETINFO _IOR('M', 1, struct mtd_info_user) #endif /* JFFS2 node header */ struct __attribute__((packed)) poc_jffs2_node { uint16_t magic; /* 0x1985 */ uint16_t nodetype; /* 0x2003 (CLEANMARKER) or 0x6000 (RWCOMPAT_COPY) */ uint32_t totlen; uint32_t hdr_crc; }; /* Standard JFFS2 CRC32 (polynomial 0xedb88320, non-inverted seed/result) */ static uint32_t jffs2_crc32(uint32_t crc, const void *data, size_t len) { const uint8_t *p = (const uint8_t *)data; while (len--) { crc ^= *p++; for (int i = 0; i < 8; i++) crc = (crc >> 1) ^ ((crc & 1) ? 0xedb88320 : 0); } return crc; } int main(void) { setvbuf(stdout, NULL, _IONBF, 0); printf("[*] Starting JFFS2 bad unlock balance reproducer...\n"); /* 1. Namespace unshare */ int res = unshare(CLONE_NEWNS); if (res < 0) { printf("[-] Failed to unshare(CLONE_NEWNS): %s\n", strerror(errno)); exit(1); } printf("[+] unshare(CLONE_NEWNS) successful.\n"); /* 2. Remount root as MS_PRIVATE */ res = mount(NULL, "/", NULL, MS_REC | MS_PRIVATE, NULL); if (res < 0) { printf("[-] Failed to remount / as private: %s\n", strerror(errno)); exit(1); } printf("[+] remount / as private successful.\n"); /* 3. Mount debugfs */ res = mount("debugfs", "/sys/kernel/debug", "debugfs", 0, NULL); if (res < 0 && errno != EBUSY) { printf("[-] Failed to mount debugfs: %s\n", strerror(errno)); exit(1); } printf("[+] debugfs mount ready.\n"); /* 4. Configure failslab parameters */ int fd = open("/sys/kernel/debug/failslab/ignore-gfp-wait", O_WRONLY); if (fd < 0) { printf("[-] Failed to open /sys/kernel/debug/failslab/ignore-gfp-wait: %s\n", strerror(errno)); exit(1); } res = write(fd, "N\n", 2); if (res < 0) { printf("[-] Failed to write to ignore-gfp-wait: %s\n", strerror(errno)); exit(1); } close(fd); printf("[+] Configured failslab/ignore-gfp-wait.\n"); fd = open("/sys/kernel/debug/failslab/cache-filter", O_WRONLY); if (fd < 0) { printf("[-] Failed to open /sys/kernel/debug/failslab/cache-filter: %s\n", strerror(errno)); exit(1); } res = write(fd, "N\n", 2); if (res < 0) { printf("[-] Failed to write to cache-filter: %s\n", strerror(errno)); exit(1); } close(fd); printf("[+] Configured failslab/cache-filter.\n"); fd = open("/sys/kernel/debug/failslab/times", O_WRONLY); if (fd < 0) { printf("[-] Failed to open /sys/kernel/debug/failslab/times: %s\n", strerror(errno)); exit(1); } res = write(fd, "1000000\n", 8); if (res < 0) { printf("[-] Failed to write to times: %s\n", strerror(errno)); exit(1); } close(fd); printf("[+] Configured failslab/times.\n"); fd = open("/sys/kernel/debug/failslab/probability", O_WRONLY); if (fd >= 0) { write(fd, "0\n", 2); close(fd); printf("[+] Configured failslab/probability to 0.\n"); } /* 5. Create mount point directory */ res = mkdir("/tmp/mnt_jffs2", 0755); if (res < 0 && errno != EEXIST) { printf("[-] Failed to mkdir /tmp/mnt_jffs2: %s\n", strerror(errno)); exit(1); } printf("[+] Mount directory /tmp/mnt_jffs2 ready.\n"); /* 6. Ensure device nodes exist */ res = mknod("/dev/mtd0", S_IFCHR | 0666, makedev(90, 0)); if (res < 0 && errno != EEXIST) { printf("[-] Failed to mknod /dev/mtd0: %s\n", strerror(errno)); exit(1); } res = mknod("/dev/mtdblock0", S_IFBLK | 0666, makedev(31, 0)); if (res < 0 && errno != EEXIST) { printf("[-] Failed to mknod /dev/mtdblock0: %s\n", strerror(errno)); exit(1); } printf("[+] Device nodes /dev/mtd0 and /dev/mtdblock0 ready.\n"); /* 7. Query MTD device geometry */ int mfd = open("/dev/mtd0", O_RDWR); if (mfd < 0) { printf("[-] Failed to open /dev/mtd0: %s\n", strerror(errno)); exit(1); } struct mtd_info_user mtd_info; res = ioctl(mfd, MEMGETINFO, &mtd_info); if (res < 0) { printf("[-] Failed to query MEMGETINFO on /dev/mtd0: %s\n", strerror(errno)); exit(1); } close(mfd); uint32_t flash_size = mtd_info.size ? mtd_info.size : 131072; uint32_t sector_size = mtd_info.erasesize ? mtd_info.erasesize : 4096; printf("[+] MTD0 geometry: size=%u (0x%x), erasesize=%u (0x%x)\n", flash_size, flash_size, sector_size, sector_size); /* 8. Compute block allocation trigger levels */ uint32_t nr_blocks = flash_size / sector_size; uint32_t calc_size = flash_size / 50; calc_size += nr_blocks * 100; calc_size += sector_size - 1; uint32_t resv_blocks_write = 2 + (calc_size / sector_size); uint32_t free_blocks = resv_blocks_write; uint32_t clean_blocks = nr_blocks - free_blocks; printf("[+] Calculated trigger levels: nr_blocks=%u, resv_blocks_write=%u (clean=%u, free=%u)\n", nr_blocks, resv_blocks_write, clean_blocks, free_blocks); /* 9. Construct formatted flash image in memory */ char *img = malloc(flash_size); if (!img) { printf("[-] Failed to allocate %u bytes for flash image: %s\n", flash_size, strerror(errno)); exit(1); } memset(img, 0xff, flash_size); struct poc_jffs2_node cleanmarker; cleanmarker.magic = 0x1985; cleanmarker.nodetype = 0x2003; /* JFFS2_NODETYPE_CLEANMARKER */ cleanmarker.totlen = 12; cleanmarker.hdr_crc = jffs2_crc32(0, &cleanmarker, 8); struct poc_jffs2_node filler; filler.magic = 0x1985; filler.nodetype = 0x6000; /* JFFS2_FEATURE_RWCOMPAT_COPY (0x4000) | JFFS2_NODE_ACCURATE (0x2000) */ filler.totlen = sector_size - 12; filler.hdr_crc = jffs2_crc32(0, &filler, 8); /* Clean blocks: cleanmarker + filler node covering entire block, zero dirty space */ for (uint32_t i = 0; i < clean_blocks; i++) { char *blk = img + i * sector_size; memcpy(blk, &cleanmarker, sizeof(cleanmarker)); memcpy(blk + 12, &filler, sizeof(filler)); memset(blk + 24, 0, sector_size - 24); } /* Free blocks: cleanmarker at offset 0, rest 0xFF */ for (uint32_t i = clean_blocks; i < nr_blocks; i++) { char *blk = img + i * sector_size; memcpy(blk, &cleanmarker, sizeof(cleanmarker)); } printf("[+] Formatted image buffer constructed successfully.\n"); /* 10. Open fail-nth and /dev/kmsg for monitoring */ int fail_fd = open("/proc/self/fail-nth", O_RDWR); if (fail_fd < 0) { printf("[-] Failed to open /proc/self/fail-nth: %s\n", strerror(errno)); exit(1); } printf("[+] Opened /proc/self/fail-nth.\n"); int kmsg_fd = open("/dev/kmsg", O_RDONLY | O_NONBLOCK); if (kmsg_fd < 0) { printf("[-] Failed to open /dev/kmsg: %s\n", strerror(errno)); exit(1); } lseek(kmsg_fd, 0, SEEK_END); printf("[+] Opened /dev/kmsg and positioned at SEEK_END.\n"); /* 11. Fault injection sweep across N = 1..50 */ printf("[*] Starting fault injection sweep N = 1..50...\n"); int bug_triggered = 0; for (int N = 1; N <= 50; N++) { /* Write pristine formatted image to /dev/mtd0 */ mfd = open("/dev/mtd0", O_RDWR); if (mfd < 0) { printf("[-] Failed to open /dev/mtd0 at N=%d: %s\n", N, strerror(errno)); exit(1); } res = pwrite(mfd, img, flash_size, 0); if (res != (ssize_t)flash_size) { printf("[-] Failed to write image to /dev/mtd0 at N=%d: %s\n", N, strerror(errno)); exit(1); } close(mfd); /* Mount JFFS2 */ res = mount("mtd0", "/tmp/mnt_jffs2", "jffs2", 0, "compr=none"); if (res < 0) { res = mount("mtd:mtdram test device", "/tmp/mnt_jffs2", "jffs2", 0, "compr=none"); } if (res < 0) { res = mount("/dev/mtdblock0", "/tmp/mnt_jffs2", "jffs2", 0, "compr=none"); } if (res < 0) { printf("[-] Failed to mount JFFS2 at N=%d: %s\n", N, strerror(errno)); exit(1); } /* Arm fail-nth */ char n_buf[32]; int n_len = snprintf(n_buf, sizeof(n_buf), "%d\n", N); res = pwrite(fail_fd, n_buf, n_len, 0); if (res < 0) { printf("[-] Failed to arm fail-nth at N=%d: %s\n", N, strerror(errno)); umount2("/tmp/mnt_jffs2", MNT_FORCE | MNT_DETACH); exit(1); } /* Trigger file creation */ int cfd = creat("/tmp/mnt_jffs2/poc_file", 0644); /* Disarm fail-nth immediately */ pwrite(fail_fd, "0\n", 2, 0); if (cfd >= 0) { close(cfd); printf("[*] N=%d: creat succeeded.\n", N); } else { printf("[*] N=%d: creat returned %d (%s).\n", N, errno, strerror(errno)); } /* Small pause to allow kernel logging */ usleep(5000); /* Inspect kernel log for lockdep warning */ char kmsg_buf[2048]; while (1) { ssize_t bytes_read = read(kmsg_fd, kmsg_buf, sizeof(kmsg_buf) - 1); if (bytes_read <= 0) break; kmsg_buf[bytes_read] = '\0'; if (strstr(kmsg_buf, "bad unlock balance") || (strstr(kmsg_buf, "alloc_sem") && strstr(kmsg_buf, "trying to release lock"))) { printf("[!] TARGET LOCKDEP WARNING DETECTED AT N=%d:\n%s\n", N, kmsg_buf); bug_triggered = 1; break; } } /* Cleanly unmount after each iteration */ res = umount2("/tmp/mnt_jffs2", MNT_FORCE | MNT_DETACH); if (res < 0) { printf("[-] Failed to unmount /tmp/mnt_jffs2 at N=%d: %s\n", N, strerror(errno)); exit(1); } if (bug_triggered) { printf("[+] Target bug reproduced successfully at iteration N=%d!\n", N); break; } } /* 12. Cleanup */ close(fail_fd); close(kmsg_fd); free(img); rmdir("/tmp/mnt_jffs2"); if (bug_triggered) { printf("[+] Reproducer finished successfully.\n"); return 0; } else { printf("[-] Reproducer finished without detecting the target warning.\n"); return 1; } }