android-gadget

सारांश

एंड्रॉयड में उपयोग होने वाले Linux कर्नेल के कुछ संशोधन CVE-2021-39685 समस्या से प्रभावित हैं। CVE-2021-39685 के लिए विस्तृत जानकारी और POC inspector-gadget रिपॉज़िटरी में मिल सकती है।

इस रिपॉज़िटरी में कुछ Android-विशिष्ट USB गैजेट्स को लक्षित करने वाले POC शामिल हैं, जिनमें शामिल हैं:

• f_accessory
• f_audio_source
• f_gsi
• f_mtp
• f_qc_rndis
• f_rmnet

विवरण

a) f_accessory

• composite.c में आवंटित EP0 बफर USB_COMP_EP0_BUFSIZ (4096) बाइट्स का होता है
• फ़ंक्शन का कंट्रोल ट्रांसफ़र हैंडलर acc_ctrlrequest ctrl->wLength को w_length में पढ़ता है
• bRequest ACCESSORY_SEND_STRING या ACCESSORY_SEND_HID_EVENT के लिए value को w_length पर सेट किया जाता है
• डेटा ट्रांसफ़र चरण की लंबाई cdev->req->length = value; पर सेट होती है
• डेटा ट्रांसफ़र के परिणामस्वरूप wLength - 4096 बाइट्स तक बफर ओवरफ़्लो होता है
• EP0 बफर में और उससे आगे लिखे गए डेटा की मात्रा हमलावर द्वारा नियंत्रित होती है

int acc_ctrlrequest(struct usb_composite_dev *cdev,
				const struct usb_ctrlrequest *ctrl)
{
	struct acc_dev	*dev = get_acc_dev();
	int	value = -EOPNOTSUPP;
	struct acc_hid_dev *hid;
	int offset;
	u8 b_requestType = ctrl->bRequestType;
	u8 b_request = ctrl->bRequest;
	u16	w_index = le16_to_cpu(ctrl->wIndex);
	u16	w_value = le16_to_cpu(ctrl->wValue);
	u16	w_length = le16_to_cpu(ctrl->wLength);
	unsigned long flags;
    ...
	if (b_requestType == (USB_DIR_OUT | USB_TYPE_VENDOR)) {
        ...
        } else if (b_request == ACCESSORY_SEND_STRING) {
			dev_info(&cdev->gadget->dev, "%s: got ACCESSORY_SEND_STRING(52) request\n",
				__func__);
			schedule_work(&dev->sendstring_work);
			dev->string_index = w_index;
			cdev->gadget->ep0->driver_data = dev;
			cdev->req->complete = acc_complete_set_string;
			value = w_length;
            ...
		} else if (b_request == ACCESSORY_SEND_HID_EVENT) {
			spin_lock_irqsave(&dev->lock, flags);
			hid = acc_hid_get(&dev->hid_list, w_value);
			spin_unlock_irqrestore(&dev->lock, flags);
			if (!hid) {
				value = -EINVAL;
				goto err;
			}
			cdev->req->context = hid;
			cdev->req->complete = acc_complete_send_hid_event;
			value = w_length;
		}
...
	if (value >= 0) {
		cdev->req->zero = 0;
		cdev->req->length = value;
		value = usb_ep_queue(cdev->gadget->ep0, cdev->req, GFP_ATOMIC);
		if (value < 0)
			ERROR(cdev, "%s setup response queue error\n",
				__func__);
	}

b) f_audio_source

• composite.c में आवंटित EP0 बफर USB_COMP_EP0_BUFSIZ (4096) बाइट्स का होता है
• फ़ंक्शन का कंट्रोल ट्रांसफ़र हैंडलर audio_setup ctrl->wLength को w_length में पढ़ता है
• bRequestType के लिए मिलान की स्थिति USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_ENDPOINT पर value वेरिएबल को audio_set_endpoint_req के रिटर्न मान पर असाइन किया जाता है
• audio_set_endpoint_req, bRequest के UAC_SET_CUR, UAC_SET_MIN, UAC_SET_MAX या UAC_SET_RES के बराबर होने पर wLength लौटाता है
• डेटा ट्रांसफ़र चरण की लंबाई value पर सेट होती है; req->length = value;
• डेटा ट्रांसफ़र के परिणामस्वरूप wLength - 4096 बाइट्स तक बफर ओवरफ़्लो होता है
• EP0 बफर में और उससे आगे लिखे गए डेटा की मात्रा हमलावर द्वारा नियंत्रित होती है

static int
audio_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
{
	struct usb_composite_dev *cdev = f->config->cdev;
	struct usb_request *req = cdev->req;
	int value = -EOPNOTSUPP;
	u16 w_index = le16_to_cpu(ctrl->wIndex);
	u16 w_value = le16_to_cpu(ctrl->wValue);
	u16 w_length = le16_to_cpu(ctrl->wLength);

    /* composite driver infrastructure handles everything; interface
	 * activation uses set_alt().
	 */
	switch (ctrl->bRequestType) {
	case USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_ENDPOINT:
		value = audio_set_endpoint_req(f, ctrl);
		break;
	case USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT:
		value = audio_get_endpoint_req(f, ctrl);
		break;
	}
	/* respond with data transfer or status phase? */
	if (value >= 0) {
		pr_debug("audio req%02x.%02x v%04x i%04x l%d\n",
			ctrl->bRequestType, ctrl->bRequest,
			w_value, w_index, w_length);
		req->zero = 0;
		req->length = value;
		req->complete = audio_control_complete;
		value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
		if (value < 0)
			pr_err("audio response on err %d\n", value);
	}

static int audio_set_endpoint_req(struct usb_function *f,
		const struct usb_ctrlrequest *ctrl)
{
	int value = -EOPNOTSUPP;
	u16 ep = le16_to_cpu(ctrl->wIndex);
	u16 len = le16_to_cpu(ctrl->wLength);
	u16 w_value = le16_to_cpu(ctrl->wValue);
	pr_debug("bRequest 0x%x, w_value 0x%04x, len %d, endpoint %d\n",
			ctrl->bRequest, w_value, len, ep);
	switch (ctrl->bRequest) {
	case UAC_SET_CUR:
	case UAC_SET_MIN:
	case UAC_SET_MAX:
	case UAC_SET_RES:
		value = len;
		break;
	default:
		break;
	}
	return value;
}

c) f_gsi

• composite.c में आवंटित EP0 बफर USB_COMP_EP0_BUFSIZ (4096) बाइट्स का होता है
• फ़ंक्शन का कंट्रोल ट्रांसफ़र हैंडलर gsi_setup ctrl->wLength को w_length वेरिएबल में पढ़ता है
• bRequest के USB_CDC_SEND_ENCAPSULATED_COMMAND पर सेट होने पर value को w_length पर सेट किया जाता है
• डेटा ट्रांसफ़र चरण की लंबाई value पर सेट होती है; req->length = value;
• डेटा ट्रांसफ़र के परिणामस्वरूप wLength - 4096 बाइट्स तक बफर ओवरफ़्लो होता है
• EP0 बफर में और उससे आगे लिखे गए डेटा की मात्रा हमलावर द्वारा नियंत्रित होती है

static int
gsi_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
{
	struct f_gsi *gsi = func_to_gsi(f);
	struct usb_composite_dev *cdev = f->config->cdev;
	struct usb_request *req = cdev->req;
	int id, value = -EOPNOTSUPP;
	u16 w_index = le16_to_cpu(ctrl->wIndex);
	u16 w_value = le16_to_cpu(ctrl->wValue);
	u16 w_length = le16_to_cpu(ctrl->wLength);
	struct gsi_ctrl_pkt *cpkt;
	u8 *buf;
	u32 n;
	bool line_state;
    ...
    switch ((ctrl->bRequestType << 8) | ctrl->bRequest) {
    ...
	case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
			| USB_CDC_SEND_ENCAPSULATED_COMMAND:
		log_event_dbg("USB_CDC_SEND_ENCAPSULATED_COMMAND");
		if (w_value || w_index != id)
			goto invalid;
		/* read the request; process it later */
		value = w_length;
		req->context = gsi;
		if (gsi->prot_id == IPA_USB_RNDIS)
			req->complete = gsi_rndis_command_complete;
		else
			req->complete = gsi_ctrl_cmd_complete;
		/* later, rndis_response_available() sends a notification */
		break;
    ...
    ...
    /* respond with data transfer or status phase? */
	if (value >= 0) {
		log_event_dbg("req%02x.%02x v%04x i%04x l%d",
			ctrl->bRequestType, ctrl->bRequest,
			w_value, w_index, w_length);
		req->zero = (value < w_length);
		req->length = value;
		value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
		if (value < 0)
			log_event_err("response on err %d", value);
	}

d) f_mtp

• composite.c में आवंटित EP0 बफर USB_COMP_EP0_BUFSIZ (4096) बाइट्स का होता है
• फ़ंक्शन का कंट्रोल ट्रांसफ़र हैंडलर mtp_ctrlrequest ctrl->wLength को w_length में पढ़ता है
• bRequest के MTP_REQ_CANCEL पर सेट होने पर value को w_length पर सेट किया जाता है
• डेटा ट्रांसफ़र चरण की लंबाई value पर सेट होती है; req->length = value;
• डेटा ट्रांसफ़र के परिणामस्वरूप wLength - 4096 बाइट्स तक बफर ओवरफ़्लो होता है
• EP0 बफर में और उससे आगे लिखे गए डेटा की मात्रा हमलावर द्वारा नियंत्रित होती है