android-gadget

요약

Android에서 사용되는 일부 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인 경우 값이 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 버퍼에 기록되고 이를 초과하는 데이터 양은 공격자가 제어합니다.

static int mtp_ctrlrequest(struct usb_composite_dev *cdev,
				const struct usb_ctrlrequest *ctrl)
{
	struct mtp_dev *dev = _mtp_dev;
	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);
	unsigned long	flags;
    ...
    	} else if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_CLASS) {
		mtp_log("class request: %d index: %d value: %d length: %d\n",
			ctrl->bRequest, w_index, w_value, w_length);
		if (ctrl->bRequest == MTP_REQ_CANCEL && w_index == 0
				&& w_value == 0) {
			mtp_log("MTP_REQ_CANCEL\n");
			spin_lock_irqsave(&dev->lock, flags);
			if (dev->state == STATE_BUSY) {
				dev->state = STATE_CANCELED;
				wake_up(&dev->read_wq);
				wake_up(&dev->write_wq);
			}
			spin_unlock_irqrestore(&dev->lock, flags);
			/* We need to queue a request to read the remaining
			 *  bytes, but we don't actually need to look at
			 * the contents.
			 */
			value = w_length;
    ...
    /* respond with data transfer or status phase? */
	if (value >= 0) {
		int rc;
		cdev->req->zero = value < w_length;
		cdev->req->length = value;
		rc = usb_ep_queue(cdev->gadget->ep0, cdev->req, GFP_ATOMIC);
		if (rc < 0)
			pr_err("%s: response queue error\n", __func__);
	}

e) f_qc_rndis

composite.c에 할당된 EP0 버퍼는 USB_COMP_EP0_BUFSIZ (4096) 바이트 크기입니다.
함수의 제어 전송 핸들러 rndis_qc_setup은 ctrl->wLength를 w_length로 읽습니다.
bRequest가 USB_CDC_SEND_ENCAPSULATED_COMMAND로 설정된 경우 value가 w_length로 설정됩니다.
데이터 전송 단계 길이는 value로 설정됩니다. req->length = value;
데이터 전송 결과 wLength - 4096 바이트만큼 버퍼 오버플로우가 발생합니다.
EP0 버퍼에 기록되고 이를 초과하는 데이터 양은 공격자가 제어합니다.

static int
rndis_qc_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
{
	struct f_rndis_qc		*rndis = func_to_rndis_qc(f);
	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);
    ...
	switch ((ctrl->bRequestType << 8) | ctrl->bRequest) {
	/* RNDIS uses the CDC command encapsulation mechanism to implement
	 * an RPC scheme, with much getting/setting of attributes by OID.
	 */
	case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
			| USB_CDC_SEND_ENCAPSULATED_COMMAND:
		if (w_value || w_index != rndis->ctrl_id)
			goto invalid;
		/* read the request; process it later */
		value = w_length;
		req->complete = rndis_qc_command_complete;
		/* later, rndis_response_available() sends a notification */
		break;
    ...
	/* respond with data transfer or status phase? */
	if (value >= 0) {
		DBG(cdev, "rndis req%02x.%02x v%04x i%04x l%d\n",
			ctrl->bRequestType, ctrl->bRequest,
			w_value, w_index, w_length);
		req->context = rndis;
		req->zero = (value < w_length);
		req->length = value;
		value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
		if (value < 0)
			pr_err("rndis response on err %d\n", value);
	}

f) f_rmnet

composite.c에 할당된 EP0 버퍼는 USB_COMP_EP0_BUFSIZ (4096) 바이트 크기입니다.
함수의 제어 전송 핸들러 frmnet_setup은 ctrl->wLength를 w_length로 읽습니다.
bRequest가 USB_CDC_SEND_ENCAPSULATED_COMMAND로 설정된 경우 ret가 w_length로 설정됩니다.
데이터 전송 단계 길이는 ret로 설정됩니다. req->length = ret;
데이터 전송 결과 wLength - 4096 바이트만큼 버퍼 오버플로우가 발생합니다.
EP0 버퍼에 기록되고 이를 초과하는 데이터 양은 공격자가 제어합니다.

static int
frmnet_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
{
	struct f_rmnet			*dev = func_to_rmnet(f);
	struct usb_composite_dev	*cdev = dev->cdev;
	struct usb_request		*req = cdev->req;
	u16				w_index = le16_to_cpu(ctrl->wIndex);
	u16				w_value = le16_to_cpu(ctrl->wValue);
	u16				w_length = le16_to_cpu(ctrl->wLength);
	int				ret = -EOPNOTSUPP;
    ...

	switch ((ctrl->bRequestType << 8) | ctrl->bRequest) {
	case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
			| USB_CDC_SEND_ENCAPSULATED_COMMAND:
		pr_debug("%s: USB_CDC_SEND_ENCAPSULATED_COMMAND\n"
				 , __func__);
		ret = w_length;
		req->complete = frmnet_cmd_complete;
		req->context = dev;
		break;
    ...
    /* respond with data transfer or status phase? */
	if (ret >= 0) {
		VDBG(cdev, "rmnet req%02x.%02x v%04x i%04x l%d\n",
			ctrl->bRequestType, ctrl->bRequest,
			w_value, w_index, w_length);
		req->zero = (ret < w_length);
		req->length = ret;
		ret = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
		if (ret < 0)
			ERROR(cdev, "rmnet ep0 enqueue err %d\n", ret);
	}

영향

영향을 받는 USB 장치 가젯 클래스(f_accessory, f_audio_source, f_gsi, f_mtp, f_qc_rndis, f_rmnet)를 구현하는 기기는 정보 유출, 서비스 거부 또는 커널 컨텍스트에서 임의 코드 실행으로 이어질 수 있는 버퍼 오버플로우 취약점의 영향을 받을 수 있습니다.

CVE

CVE-2022-20009

익스플로잇

표준 4096바이트보다 큰 wLength를 사용하는 제어 전송 요청을 실행하려면 호스트가 MAX_CTRL_BUFFER_LENGTH를 0xffff로 증가시킨 사용자 정의 libusb 빌드를 사용해야 합니다. 이 값은 빌드 전에 libusb/os/linux_usbfs.h에서 변경할 수 있습니다.

gadget.py 스크립트는 pyusb를 필요로 합니다. 아래와 같이 pip를 통해 이 패키지를 설치할 수 있습니다.

python3 -m pip install pyusb

도움말은 -h 또는 --help 매개변수로 확인할 수 있습니다.

usage: gadget.py [-h] -v VID -p PID [-l LENGTH] [-d {read,write}] [-f {accessory,audio_source,gsi,qc_rndis,rmnet,mtp}]

CVE-2022-20009에 대한 샘플 익스플로잇

optional arguments:
  -h, --help            show this help message and exit
  -v VID, --vid VID     vendor id
  -p PID, --pid PID     product id
  -l LENGTH, --length LENGTH
                        lenght of data to write
  -d {read,write}, --direction {read,write}
                        direction of operation from host perspective
  -f {accessory,audio_source,gsi,qc_rndis,rmnet,mtp}, --function {accessory,audio_source,gsi,qc_rndis,rmnet,mtp}

호출 예시:

./gadget.py -v 0x1b67 -p 0x400c -f audio_source
./gadget.py -v 0x18d1 -p 0x4e23 -f mtp

마지막 메모

Android를 최신 안정 버전으로 업데이트하시기 바랍니다.

android-gadget

인기

android-gadget

요약

설명

영향

CVE

익스플로잇

마지막 메모