Introduction

Diese Schwachstelle ist eine Race-Condition-Schwachstelle, die in drivers/media/dvb-core/dmxdev.c auftritt. Daher kann eine Race-Condition in dem USB-Gerätetreiber auftreten, der dieses dmxdev verwendet.

Diese Schwachstelle könnte verwendet werden, um 3 UAFs auszulösen.

Vulnerability

1. vmalloc UAF write

Zuerst ist die Reihenfolge des Exploits wie folgt(I habe mit drivers/media/usb/ttusb-dec/ttusb_dec.c debuggt):``` cpu0 cpu1 cpu 2 1. dvb_dvr_open() 2. ttusb_dec_disconnect() ttusb_dec_exit_dvb() dvb_dmxdev_release() wait_event(dmxdev->dvr_dvbdev->wait_queue, …) 3. dvb_demux_open() dvb_demux_ioctl() dvb_usercopy() copy_from_user() <- userfaultfd stuck 4. dvb_dvr_release() 5. vfree(dmxdev->filter) 6. copy_from_user() <- userfaultfd release dvb_demux_do_ioctl() struct dmxdev *dmxdev = dmxdevfilter->dev; <- UAF!!

Der detaillierte Exploit-Ablauf ist wie folgt:

1. Öffnen Sie dvr0 unter den Geräteknoten. Dies führt dazu, dass dvb_dvr_open() aufgerufen wird, um `dvbdev->users++` auszuführen.
In diesem Fall wird bei Ausführung von ttusb_dec_disconnect() durch Entfernen des USB-Geräts die Bedingung `wait_event(dmxdev->dvr_dvbdev->wait_queue, …)` abgefangen.

2. Entfernen Sie das USB-Gerät physisch.
In diesem Fall wartet es bei der Ausführung der Funktion ttusb_dec_disconnect() auf `wait_event(dmxdev->dvr_dvbdev->wait_queue, …)`.

3. Öffnen Sie den demux0-Knoten, sodass die Funktion dvb_demux_open() aufgerufen wird.
Diese Funktion führt ebenfalls `dvbdev->users++` aus, ähnlich wie die Funktion dvb_dvr_open() in Schritt 1.
Allerdings tritt diese fehlerhafte Referenzzählung auf, weil die derzeit wartende Funktion dvb_dmxdev_release() die Prüfung auf `dvbdev->users` bereits bestanden hat:```
void dvb_dmxdev_release(struct dmxdev *dmxdev)
{
        dmxdev->exit = 1;
        if (dmxdev->dvbdev->users > 1) {    // This check is bypassed. improper reference counting.
                wait_event(dmxdev->dvbdev->wait_queue,
                                dmxdev->dvbdev->users == 1);
        }
        if (dmxdev->dvr_dvbdev->users > 1) {
                wait_event(dmxdev->dvr_dvbdev->wait_queue,    // Currently wait()ing here.
                                dmxdev->dvr_dvbdev->users == 1);
        }

        dvb_unregister_device(dmxdev->dvbdev);
        dvb_unregister_device(dmxdev->dvr_dvbdev);

        vfree(dmxdev->filter);
        dmxdev->filter = NULL;
        dmxdev->demux->close(dmxdev->demux);
}

Es ruft dann ioctl() auf dem demux0 auf. Beim Aufruf übergibt das 3. Argument die Benutzerraum-Adresse, die von userfaultfd (oder FUSE fs) gesetzt wurde. Während ioctl läuft, wird es bei copy_from_user() von dvb_usercopy() hängen bleiben:``` int dvb_usercopy(struct file *file, unsigned int cmd, unsigned long arg, int (*func)(struct file *file, unsigned int cmd, void *arg)) { char sbuf[128]; void *mbuf = NULL; void *parg = NULL; int err = -EINVAL;

    /*  Copy arguments into temp kernel buffer  */
    switch (_IOC_DIR(cmd)) {
    case _IOC_NONE:
            /*
             * For this command, the pointer is actually an integer
             * argument.
             */
            parg = (void *) arg;
            break;
    case _IOC_READ: /* some v4l ioctls are marked wrong ... */
    case _IOC_WRITE:
    case (_IOC_WRITE | _IOC_READ):
            if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
                    parg = sbuf;
            } else {
                    /* too big to allocate from stack */
                    mbuf = kmalloc(_IOC_SIZE(cmd), GFP_KERNEL);
                    if (NULL == mbuf)
                            return -ENOMEM;
                    parg = mbuf;
            }

            err = -EFAULT;
            if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd)))   // here
                    goto out;
            break;
    }

4. Schließen Sie den fd in dem Thread, der das dvr0-Node geöffnet hat.
Dann wird `dvb_dvr_release()` aufgerufen, und `dvbdev->users--` sowie `wake_up(&dvbdev->wait_queue)` werden ausgeführt, um die Funktion `dvb_dmxdev_release()` zu wecken, die den .disconnect-Ablauf darstellt.

5. Im .disconnect-Ablauf, Funktion `dvb_dmxdev_release()`, wird `vfree(dmxdev->filter)` ausgeführt.

6. Geben Sie userfaultfd aus dem demux0-ioctl-Thread frei, der userfaultfd gesetzt hat.
Dies führt zur UAF, indem die `dmxdev->filter`-Adresse gelesen wird, die Sie gerade aus .disconnect freigegeben haben.
UAF kann nun in allen Fällen von `dvb_demux_do_ioctl()` genutzt werden, und sogar LPE ist möglich, wenn es mit eBPF kombiniert wird.