// https://syzkaller.appspot.com/bug?id=1e1010558c86c992dc1bacb9bc00002b31b4d739 #define _GNU_SOURCE #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #undef htole16 #undef le16toh #if (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) || \ (defined(__BYTE_ORDER) && __BYTE_ORDER == __BIG_ENDIAN) #define htole16(x) ((uint16_t)((((uint16_t)(x) & 0x00ffU) << 8) | (((uint16_t)(x) & 0xff00U) >> 8))) #else #define htole16(x) ((uint16_t)(x)) #endif #define le16toh(x) htole16(x) struct full_config_descriptor { struct usb_config_descriptor config; struct usb_interface_descriptor intf0; struct usb_interface_descriptor intf1; struct usb_endpoint_descriptor ep1; } __attribute__((packed)); static const struct usb_device_descriptor device_desc = { .bLength = sizeof(struct usb_device_descriptor), .bDescriptorType = USB_DT_DEVICE, .bcdUSB = htole16(0x0200), .bDeviceClass = 0, .bDeviceSubClass = 0, .bDeviceProtocol = 0, .bMaxPacketSize0 = 64, .idVendor = htole16(0x18b4), .idProduct = htole16(0x1689), .bcdDevice = htole16(0x0100), .iManufacturer = 0, .iProduct = 0, .iSerialNumber = 0, .bNumConfigurations = 1, }; static const struct full_config_descriptor config_bundle = { .config = { .bLength = sizeof(struct usb_config_descriptor), .bDescriptorType = USB_DT_CONFIG, .wTotalLength = htole16(sizeof(struct full_config_descriptor)), .bNumInterfaces = 2, .bConfigurationValue = 1, .iConfiguration = 0, .bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER, .bMaxPower = 250, }, .intf0 = { .bLength = sizeof(struct usb_interface_descriptor), .bDescriptorType = USB_DT_INTERFACE, .bInterfaceNumber = 0, .bAlternateSetting = 0, .bNumEndpoints = 0, .bInterfaceClass = USB_CLASS_HID, .bInterfaceSubClass = 0, .bInterfaceProtocol = 0, .iInterface = 0, }, .intf1 = { .bLength = sizeof(struct usb_interface_descriptor), .bDescriptorType = USB_DT_INTERFACE, .bInterfaceNumber = 1, .bAlternateSetting = 0, .bNumEndpoints = 1, .bInterfaceClass = USB_CLASS_VENDOR_SPEC, .bInterfaceSubClass = 0, .bInterfaceProtocol = 0, .iInterface = 0, }, .ep1 = { .bLength = sizeof(struct usb_endpoint_descriptor), .bDescriptorType = USB_DT_ENDPOINT, .bEndpointAddress = 0x82, /* Bulk IN */ .bmAttributes = USB_ENDPOINT_XFER_BULK, .wMaxPacketSize = htole16(512), .bInterval = 0, }, }; static volatile int stop_workers = 0; static char target_demux_path[64] = "/dev/dvb/adapter1/demux0"; static char static_demux_path[64] = "/tmp/dvb/demux_target"; static void sigalrm_handler(int sig) { (void)sig; } static int ep0_write(int fd, const void *data, uint32_t len) { struct { struct usb_raw_ep_io io; uint8_t data[512]; } req; memset(&req, 0, sizeof(req)); if (len > sizeof(req.data)) len = sizeof(req.data); req.io.length = len; if (data && len > 0) memcpy(req.data, data, len); int res = ioctl(fd, USB_RAW_IOCTL_EP0_WRITE, &req); if (res < 0 && errno != ESHUTDOWN && errno != ECONNRESET && errno != EINTR) { printf("[-] USB_RAW_IOCTL_EP0_WRITE failed (len=%u): %s\n", len, strerror(errno)); } return res; } static int ep0_read(int fd, uint32_t len) { struct { struct usb_raw_ep_io io; uint8_t data[512]; } req; memset(&req, 0, sizeof(req)); if (len > sizeof(req.data)) len = sizeof(req.data); req.io.length = len; int res = ioctl(fd, USB_RAW_IOCTL_EP0_READ, &req); if (res < 0 && errno != ESHUTDOWN && errno != ECONNRESET && errno != EINTR) { printf("[-] USB_RAW_IOCTL_EP0_READ failed (len=%u): %s\n", len, strerror(errno)); } return res; } static int ep0_stall(int fd) { int res = ioctl(fd, USB_RAW_IOCTL_EP0_STALL, 0); if (res < 0 && errno != ESHUTDOWN && errno != ECONNRESET && errno != EINTR) { printf("[-] USB_RAW_IOCTL_EP0_STALL failed: %s\n", strerror(errno)); } return res; } static void *worker_thread(void *arg) { (void)arg; sigset_t set; sigemptyset(&set); sigaddset(&set, SIGALRM); pthread_sigmask(SIG_BLOCK, &set, NULL); struct dmx_pes_filter_params params; memset(¶ms, 0, sizeof(params)); params.pid = 0x100; params.input = DMX_IN_FRONTEND; params.output = DMX_OUT_TS_TAP; params.pes_type = DMX_PES_OTHER; params.flags = DMX_IMMEDIATE_START; while (!stop_workers) { int fd = open(static_demux_path, O_RDWR | O_NONBLOCK); if (fd < 0 && target_demux_path[0]) fd = open(target_demux_path, O_RDWR | O_NONBLOCK); if (fd >= 0) { for (int k = 0; k < 5; k++) { ioctl(fd, DMX_SET_PES_FILTER, ¶ms); } close(fd); } else { sched_yield(); } } return NULL; } int main(void) { setvbuf(stdout, NULL, _IONBF, 0); printf("[*] Starting ec168_streaming_ctrl GPF reproducer...\n"); struct stat st; int target_adapter = (stat("/dev/dvb/adapter0/demux0", &st) == 0 || stat("/dev/dvb/adapter0", &st) == 0) ? 1 : 0; int target_minor = (target_adapter << 6) | 4; snprintf(target_demux_path, sizeof(target_demux_path), "/dev/dvb/adapter%d/demux0", target_adapter); printf("[+] Detected target DVB adapter: %d (minor: %d, path: %s)\n", target_adapter, target_minor, target_demux_path); int res = mkdir("/tmp/dvb", 0755); if (res < 0 && errno != EEXIST) { printf("[-] Failed to mkdir /tmp/dvb: %s\n", strerror(errno)); exit(1); } printf("[+] mkdir /tmp/dvb successful.\n"); unlink(static_demux_path); res = mknod(static_demux_path, S_IFCHR | 0666, makedev(212, target_minor)); if (res < 0) { printf("[-] Failed to mknod %s: %s\n", static_demux_path, strerror(errno)); exit(1); } printf("[+] Created static node %s (major=212, minor=%d) successfully.\n", static_demux_path, target_minor); DIR *dir = opendir("/sys/class/udc"); if (!dir) { printf("[-] Failed to opendir /sys/class/udc: %s\n", strerror(errno)); exit(1); } printf("[+] Opened /sys/class/udc successfully.\n"); struct dirent *entry; char dummy_udc_name[64] = {0}; while ((entry = readdir(dir)) != NULL) { if (strstr(entry->d_name, "dummy_udc") != NULL) { strncpy(dummy_udc_name, entry->d_name, sizeof(dummy_udc_name) - 1); printf("[+] Found UDC: %s\n", dummy_udc_name); break; } } res = closedir(dir); if (res < 0) { printf("[-] Failed to closedir /sys/class/udc: %s\n", strerror(errno)); exit(1); } if (dummy_udc_name[0] == '\0') { strncpy(dummy_udc_name, "dummy_udc.0", sizeof(dummy_udc_name) - 1); printf("[*] Defaulting to UDC: %s\n", dummy_udc_name); } struct sigaction sa; memset(&sa, 0, sizeof(sa)); sa.sa_handler = sigalrm_handler; if (sigaction(SIGALRM, &sa, NULL) < 0) { printf("[-] Failed to set sigaction for SIGALRM: %s\n", strerror(errno)); exit(1); } printf("[+] Installed SIGALRM handler successfully.\n"); pthread_t worker_tid; res = pthread_create(&worker_tid, NULL, worker_thread, NULL); if (res != 0) { printf("[-] Failed to create worker thread: %s\n", strerror(res)); exit(1); } printf("[+] Created worker thread successfully.\n"); long ncpus = sysconf(_SC_NPROCESSORS_ONLN); printf("[+] Detected %ld online CPUs.\n", ncpus); if (ncpus > 1) { cpu_set_t cpuset; CPU_ZERO(&cpuset); CPU_SET(1, &cpuset); res = pthread_setaffinity_np(worker_tid, sizeof(cpuset), &cpuset); if (res != 0) { printf("[-] Failed to pin worker thread to CPU 1: %s\n", strerror(res)); } else { printf("[+] Worker thread pinned to CPU 1.\n"); } CPU_ZERO(&cpuset); CPU_SET(0, &cpuset); res = pthread_setaffinity_np(pthread_self(), sizeof(cpuset), &cpuset); if (res != 0) { printf("[-] Failed to pin main thread to CPU 0: %s\n", strerror(res)); } else { printf("[+] Main thread pinned to CPU 0.\n"); } } const int MAX_ITERS = 30; for (int iter = 0; iter < MAX_ITERS; iter++) { printf("[*] Starting iteration %d/%d (target=%s)...\n", iter + 1, MAX_ITERS, target_demux_path); int raw_fd = open("/dev/raw-gadget", O_RDWR); if (raw_fd < 0) { printf("[-] Failed to open /dev/raw-gadget: %s\n", strerror(errno)); exit(1); } printf("[+] Opened /dev/raw-gadget successfully (iter %d).\n", iter + 1); struct usb_raw_init init; memset(&init, 0, sizeof(init)); init.speed = USB_SPEED_HIGH; strncpy((char *)init.driver_name, "dummy_udc", sizeof(init.driver_name) - 1); strncpy((char *)init.device_name, dummy_udc_name, sizeof(init.device_name) - 1); res = ioctl(raw_fd, USB_RAW_IOCTL_INIT, &init); if (res < 0) { printf("[-] Failed USB_RAW_IOCTL_INIT: %s\n", strerror(errno)); close(raw_fd); exit(1); } printf("[+] USB_RAW_IOCTL_INIT successful.\n"); res = ioctl(raw_fd, USB_RAW_IOCTL_RUN, 0); if (res < 0) { printf("[-] Failed USB_RAW_IOCTL_RUN: %s\n", strerror(errno)); close(raw_fd); exit(1); } printf("[+] USB_RAW_IOCTL_RUN successful.\n"); struct timespec start_ts; clock_gettime(CLOCK_MONOTONIC, &start_ts); ualarm(700000, 0); while (1) { struct { struct usb_raw_event event; uint8_t data[256]; } ev; memset(&ev, 0, sizeof(ev)); ev.event.length = sizeof(ev.data); res = ioctl(raw_fd, USB_RAW_IOCTL_EVENT_FETCH, &ev); if (res < 0) { if (errno == EINTR) { /* Iteration timer expired */ break; } printf("[-] USB_RAW_IOCTL_EVENT_FETCH returned %d: %s\n", res, strerror(errno)); break; } if (ev.event.type == USB_RAW_EVENT_CONNECT) { printf("[+] Event: USB_RAW_EVENT_CONNECT\n"); } else if (ev.event.type == USB_RAW_EVENT_CONTROL) { struct usb_ctrlrequest *ctrl = (struct usb_ctrlrequest *)ev.event.data; uint16_t wLength = le16toh(ctrl->wLength); uint16_t wValue = le16toh(ctrl->wValue); if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD) { if (ctrl->bRequest == USB_REQ_GET_DESCRIPTOR) { uint8_t desc_type = wValue >> 8; if (desc_type == USB_DT_DEVICE) { uint32_t len = sizeof(device_desc); if (len > wLength) len = wLength; ep0_write(raw_fd, &device_desc, len); } else if (desc_type == USB_DT_CONFIG) { uint32_t len = sizeof(config_bundle); if (len > wLength) len = wLength; ep0_write(raw_fd, &config_bundle, len); } else { ep0_stall(raw_fd); } } else if (ctrl->bRequest == USB_REQ_SET_CONFIGURATION) { ioctl(raw_fd, USB_RAW_IOCTL_CONFIGURE, 0); ep0_read(raw_fd, 0); } else if (ctrl->bRequest == USB_REQ_SET_INTERFACE) { ep0_read(raw_fd, 0); } else if (ctrl->bRequest == USB_REQ_GET_STATUS) { uint16_t status = 0; uint32_t len = sizeof(status); if (len > wLength) len = wLength; ep0_write(raw_fd, &status, len); } else { ep0_stall(raw_fd); } } else if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_VENDOR) { if ((ctrl->bRequestType & USB_DIR_IN) && wLength > 0) { uint8_t resp[64] = {0}; if (ctrl->bRequest == 0x01) { /* CONFIG / GET_CONFIG -> reply 0x01 for WARM state */ resp[0] = 0x01; } else if (ctrl->bRequest == 0x03) { /* DEMOD_RW -> reply 0x0b (EC100 demod ID) */ resp[0] = 0x0b; } uint32_t len = wLength; if (len > sizeof(resp)) len = sizeof(resp); ep0_write(raw_fd, resp, len); } else { ep0_read(raw_fd, wLength); } } else { ep0_stall(raw_fd); } } struct timespec cur_ts; clock_gettime(CLOCK_MONOTONIC, &cur_ts); long elapsed_ms = (cur_ts.tv_sec - start_ts.tv_sec) * 1000 + (cur_ts.tv_nsec - start_ts.tv_nsec) / 1000000; if (elapsed_ms >= 700) { break; } } ualarm(0, 0); res = close(raw_fd); if (res < 0) { printf("[-] Failed to close /dev/raw-gadget: %s\n", strerror(errno)); } else { printf("[+] Closed /dev/raw-gadget successfully (iter %d).\n", iter + 1); } /* Sleep 100 ms to allow driver teardown before the next bind */ usleep(100000); } stop_workers = 1; pthread_join(worker_tid, NULL); unlink(static_demux_path); printf("[*] Completed all iterations without crash.\n"); return 0; }