hw/usb/u2f.c

   1 /*
   2  * U2F USB device.
   3  *
   4  * Copyright (c) 2020 César Belley <cesar.belley@lse.epita.fr>
   5  * Written by César Belley <cesar.belley@lse.epita.fr>
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a copy
   8  * of this software and associated documentation files (the "Software"), to deal
   9  * in the Software without restriction, including without limitation the rights
  10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11  * copies of the Software, and to permit persons to whom the Software is
  12  * furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included in
  15  * all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  23  * THE SOFTWARE.
  24  */
  25
  26 #include "qemu/osdep.h"
  27 #include "qemu/module.h"
  28 #include "qapi/error.h"
  29 #include "hw/usb.h"
  30 #include "hw/usb/hid.h"
  31 #include "migration/vmstate.h"
  32 #include "desc.h"
  33
  34 #include "u2f.h"
  35
  36 /* U2F key Vendor / Product */
  37 #define U2F_KEY_VENDOR_NUM     0x46f4 /* CRC16() of "QEMU" */
  38 #define U2F_KEY_PRODUCT_NUM    0x0005
  39
  40 enum {
  41     STR_MANUFACTURER = 1,
  42     STR_PRODUCT,
  43     STR_SERIALNUMBER,
  44     STR_CONFIG,
  45     STR_INTERFACE
  46 };
  47
  48 static const USBDescStrings desc_strings = {
  49     [STR_MANUFACTURER]     = "QEMU",
  50     [STR_PRODUCT]          = "U2F USB key",
  51     [STR_SERIALNUMBER]     = "0",
  52     [STR_CONFIG]           = "U2F key config",
  53     [STR_INTERFACE]        = "U2F key interface"
  54 };
  55
  56 static const USBDescIface desc_iface_u2f_key = {
  57     .bInterfaceNumber              = 0,
  58     .bNumEndpoints                 = 2,
  59     .bInterfaceClass               = USB_CLASS_HID,
  60     .bInterfaceSubClass            = 0x0,
  61     .bInterfaceProtocol            = 0x0,
  62     .ndesc                         = 1,
  63     .descs = (USBDescOther[]) {
  64         {
  65             /* HID descriptor */
  66             .data = (uint8_t[]) {
  67                 0x09,          /*  u8  bLength */
  68                 USB_DT_HID,    /*  u8  bDescriptorType */
  69                 0x10, 0x01,    /*  u16 HID_class */
  70                 0x00,          /*  u8  country_code */
  71                 0x01,          /*  u8  num_descriptors */
  72                 USB_DT_REPORT, /*  u8  type: Report */
  73                 0x22, 0,       /*  u16 len */
  74             },
  75         },
  76     },
  77     .eps = (USBDescEndpoint[]) {
  78         {
  79             .bEndpointAddress      = USB_DIR_IN | 0x01,
  80             .bmAttributes          = USB_ENDPOINT_XFER_INT,
  81             .wMaxPacketSize        = U2FHID_PACKET_SIZE,
  82             .bInterval             = 0x05,
  83         }, {
  84             .bEndpointAddress      = USB_DIR_OUT | 0x01,
  85             .bmAttributes          = USB_ENDPOINT_XFER_INT,
  86             .wMaxPacketSize        = U2FHID_PACKET_SIZE,
  87             .bInterval             = 0x05,
  88         },
  89     },
  90
  91 };
  92
  93 static const USBDescDevice desc_device_u2f_key = {
  94     .bcdUSB                        = 0x0100,
  95     .bMaxPacketSize0               = U2FHID_PACKET_SIZE,
  96     .bNumConfigurations            = 1,
  97     .confs = (USBDescConfig[]) {
  98         {
  99             .bNumInterfaces        = 1,
 100             .bConfigurationValue   = 1,
 101             .iConfiguration        = STR_CONFIG,
 102             .bmAttributes          = USB_CFG_ATT_ONE,
 103             .bMaxPower             = 15,
 104             .nif = 1,
 105             .ifs = &desc_iface_u2f_key,
 106         },
 107     },
 108 };
 109
 110 static const USBDesc desc_u2f_key = {
 111     .id = {
 112         .idVendor          = U2F_KEY_VENDOR_NUM,
 113         .idProduct         = U2F_KEY_PRODUCT_NUM,
 114         .bcdDevice         = 0,
 115         .iManufacturer     = STR_MANUFACTURER,
 116         .iProduct          = STR_PRODUCT,
 117         .iSerialNumber     = STR_SERIALNUMBER,
 118     },
 119     .full = &desc_device_u2f_key,
 120     .str  = desc_strings,
 121 };
 122
 123 static const uint8_t u2f_key_hid_report_desc[] = {
 124     0x06, 0xd0, 0xf1, /* Usage Page (FIDO) */
 125     0x09, 0x01,       /* Usage (FIDO) */
 126     0xa1, 0x01,       /* Collection (HID Application) */
 127     0x09, 0x20,       /*    Usage (FIDO data in) */
 128     0x15, 0x00,       /*        Logical Minimum (0) */
 129     0x26, 0xFF, 0x00, /*        Logical Maximum (0xff) */
 130     0x75, 0x08,       /*        Report Size (8) */
 131     0x95, 0x40,       /*        Report Count (0x40) */
 132     0x81, 0x02,       /*        Input (Data, Variable, Absolute) */
 133     0x09, 0x21,       /*    Usage (FIDO data out) */
 134     0x15, 0x00,       /*        Logical Minimum (0) */
 135     0x26, 0xFF, 0x00, /*        Logical Maximum  (0xFF) */
 136     0x75, 0x08,       /*        Report Size (8) */
 137     0x95, 0x40,       /*        Report Count (0x40) */
 138     0x91, 0x02,       /*        Output (Data, Variable, Absolute) */
 139     0xC0              /* End Collection */
 140 };
 141
 142 static void u2f_key_reset(U2FKeyState *key)
 143 {
 144     key->pending_in_start = 0;
 145     key->pending_in_end = 0;
 146     key->pending_in_num = 0;
 147 }
 148
 149 static void u2f_key_handle_reset(USBDevice *dev)
 150 {
 151     U2FKeyState *key = U2F_KEY(dev);
 152
 153     u2f_key_reset(key);
 154 }
 155
 156 static void u2f_key_handle_control(USBDevice *dev, USBPacket *p,
 157                int request, int value, int index, int length, uint8_t *data)
 158 {
 159     U2FKeyState *key = U2F_KEY(dev);
 160     int ret;
 161
 162     ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
 163     if (ret >= 0) {
 164         return;
 165     }
 166
 167     switch (request) {
 168     case InterfaceRequest | USB_REQ_GET_DESCRIPTOR:
 169         switch (value >> 8) {
 170         case 0x22:
 171             memcpy(data, u2f_key_hid_report_desc,
 172                    sizeof(u2f_key_hid_report_desc));
 173             p->actual_length = sizeof(u2f_key_hid_report_desc);
 174             break;
 175         default:
 176             goto fail;
 177         }
 178         break;
 179     case HID_GET_IDLE:
 180         data[0] = key->idle;
 181         p->actual_length = 1;
 182         break;
 183     case HID_SET_IDLE:
 184         key->idle = (uint8_t)(value >> 8);
 185         break;
 186     default:
 187     fail:
 188         p->status = USB_RET_STALL;
 189         break;
 190     }
 191
 192 }
 193
 194 static void u2f_key_recv_from_guest(U2FKeyState *key, USBPacket *p)
 195 {
 196     U2FKeyClass *kc = U2F_KEY_GET_CLASS(key);
 197     uint8_t packet[U2FHID_PACKET_SIZE];
 198
 199     if (kc->recv_from_guest == NULL || p->iov.size != U2FHID_PACKET_SIZE) {
 200         return;
 201     }
 202
 203     usb_packet_copy(p, packet, p->iov.size);
 204     kc->recv_from_guest(key, packet);
 205 }
 206
 207 static void u2f_pending_in_add(U2FKeyState *key,
 208                                const uint8_t packet[U2FHID_PACKET_SIZE])
 209 {
 210     uint8_t index;
 211
 212     if (key->pending_in_num >= U2FHID_PENDING_IN_NUM) {
 213         return;
 214     }
 215
 216     index = key->pending_in_end;
 217     key->pending_in_end = (index + 1) % U2FHID_PENDING_IN_NUM;
 218     ++key->pending_in_num;
 219
 220     memcpy(key->pending_in[index], packet, U2FHID_PACKET_SIZE);
 221 }
 222
 223 static uint8_t *u2f_pending_in_get(U2FKeyState *key)
 224 {
 225     uint8_t index;
 226
 227     if (key->pending_in_num == 0) {
 228         return NULL;
 229     }
 230
 231     index = key->pending_in_start;
 232     key->pending_in_start = (index + 1) % U2FHID_PENDING_IN_NUM;
 233     --key->pending_in_num;
 234
 235     return key->pending_in[index];
 236 }
 237
 238 static void u2f_key_handle_data(USBDevice *dev, USBPacket *p)
 239 {
 240     U2FKeyState *key = U2F_KEY(dev);
 241     uint8_t *packet_in;
 242
 243     /* Endpoint number check */
 244     if (p->ep->nr != 1) {
 245         p->status = USB_RET_STALL;
 246         return;
 247     }
 248
 249     switch (p->pid) {
 250     case USB_TOKEN_OUT:
 251         u2f_key_recv_from_guest(key, p);
 252         break;
 253     case USB_TOKEN_IN:
 254         packet_in = u2f_pending_in_get(key);
 255         if (packet_in == NULL) {
 256             p->status = USB_RET_NAK;
 257             return;
 258         }
 259         usb_packet_copy(p, packet_in, U2FHID_PACKET_SIZE);
 260         break;
 261     default:
 262         p->status = USB_RET_STALL;
 263         break;
 264     }
 265 }
 266
 267 void u2f_send_to_guest(U2FKeyState *key,
 268                        const uint8_t packet[U2FHID_PACKET_SIZE])
 269 {
 270     u2f_pending_in_add(key, packet);
 271     usb_wakeup(key->ep, 0);
 272 }
 273
 274 static void u2f_key_unrealize(USBDevice *dev)
 275 {
 276     U2FKeyState *key = U2F_KEY(dev);
 277     U2FKeyClass *kc = U2F_KEY_GET_CLASS(key);
 278
 279     if (kc->unrealize != NULL) {
 280         kc->unrealize(key);
 281     }
 282 }
 283
 284 static void u2f_key_realize(USBDevice *dev, Error **errp)
 285 {
 286     U2FKeyState *key = U2F_KEY(dev);
 287     U2FKeyClass *kc = U2F_KEY_GET_CLASS(key);
 288     Error *local_err = NULL;
 289
 290     usb_desc_create_serial(dev);
 291     usb_desc_init(dev);
 292     u2f_key_reset(key);
 293
 294     if (kc->realize != NULL) {
 295         kc->realize(key, &local_err);
 296         if (local_err != NULL) {
 297             error_propagate(errp, local_err);
 298             return;
 299         }
 300     }
 301     key->ep = usb_ep_get(dev, USB_TOKEN_IN, 1);
 302 }
 303
 304 const VMStateDescription vmstate_u2f_key = {
 305     .name = "u2f-key",
 306     .version_id = 1,
 307     .minimum_version_id = 1,
 308     .fields = (const VMStateField[]) {
 309         VMSTATE_USB_DEVICE(dev, U2FKeyState),
 310         VMSTATE_UINT8(idle, U2FKeyState),
 311         VMSTATE_UINT8_2DARRAY(pending_in, U2FKeyState,
 312             U2FHID_PENDING_IN_NUM, U2FHID_PACKET_SIZE),
 313         VMSTATE_UINT8(pending_in_start, U2FKeyState),
 314         VMSTATE_UINT8(pending_in_end, U2FKeyState),
 315         VMSTATE_UINT8(pending_in_num, U2FKeyState),
 316         VMSTATE_END_OF_LIST()
 317     }
 318 };
 319
 320 static void u2f_key_class_init(ObjectClass *klass, void *data)
 321 {
 322     DeviceClass *dc = DEVICE_CLASS(klass);
 323     USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
 324
 325     uc->product_desc   = "QEMU U2F USB key";
 326     uc->usb_desc       = &desc_u2f_key;
 327     uc->handle_reset   = u2f_key_handle_reset;
 328     uc->handle_control = u2f_key_handle_control;
 329     uc->handle_data    = u2f_key_handle_data;
 330     uc->handle_attach  = usb_desc_attach;
 331     uc->realize        = u2f_key_realize;
 332     uc->unrealize      = u2f_key_unrealize;
 333     dc->desc           = "QEMU U2F key";
 334     dc->vmsd           = &vmstate_u2f_key;
 335 }
 336
 337 static const TypeInfo u2f_key_info = {
 338     .name          = TYPE_U2F_KEY,
 339     .parent        = TYPE_USB_DEVICE,
 340     .instance_size = sizeof(U2FKeyState),
 341     .abstract      = true,
 342     .class_size    = sizeof(U2FKeyClass),
 343     .class_init    = u2f_key_class_init,
 344 };
 345
 346 static void u2f_key_register_types(void)
 347 {
 348     type_register_static(&u2f_key_info);
 349 }
 350
 351 type_init(u2f_key_register_types)