contrib/libfido2/src/hid_linux.c

   1 /*
   2  * Copyright (c) 2019 Yubico AB. All rights reserved.
   3  * Use of this source code is governed by a BSD-style
   4  * license that can be found in the LICENSE file.
   5  */
   6
   7 #include <sys/types.h>
   8 #include <sys/file.h>
   9 #include <sys/ioctl.h>
  10
  11 #include <linux/hidraw.h>
  12 #include <linux/input.h>
  13
  14 #include <errno.h>
  15 #include <libudev.h>
  16 #include <time.h>
  17 #include <unistd.h>
  18
  19 #include "fido.h"
  20
  21 struct hid_linux {
  22         int             fd;
  23         size_t          report_in_len;
  24         size_t          report_out_len;
  25         sigset_t        sigmask;
  26         const sigset_t *sigmaskp;
  27 };
  28
  29 static int
  30 get_report_descriptor(int fd, struct hidraw_report_descriptor *hrd)
  31 {
  32         int s = -1;
  33
  34         if (ioctl(fd, IOCTL_REQ(HIDIOCGRDESCSIZE), &s) == -1) {
  35                 fido_log_error(errno, "%s: ioctl HIDIOCGRDESCSIZE", __func__);
  36                 return (-1);
  37         }
  38
  39         if (s < 0 || (unsigned)s > HID_MAX_DESCRIPTOR_SIZE) {
  40                 fido_log_debug("%s: HIDIOCGRDESCSIZE %d", __func__, s);
  41                 return (-1);
  42         }
  43
  44         hrd->size = (unsigned)s;
  45
  46         if (ioctl(fd, IOCTL_REQ(HIDIOCGRDESC), hrd) == -1) {
  47                 fido_log_error(errno, "%s: ioctl HIDIOCGRDESC", __func__);
  48                 return (-1);
  49         }
  50
  51         return (0);
  52 }
  53
  54 static bool
  55 is_fido(const char *path)
  56 {
  57         int                             fd;
  58         uint32_t                        usage_page = 0;
  59         struct hidraw_report_descriptor hrd;
  60
  61         memset(&hrd, 0, sizeof(hrd));
  62
  63         if ((fd = fido_hid_unix_open(path)) == -1)
  64                 return (false);
  65
  66         if (get_report_descriptor(fd, &hrd) < 0 ||
  67             fido_hid_get_usage(hrd.value, hrd.size, &usage_page) < 0)
  68                 usage_page = 0;
  69
  70         if (close(fd) == -1)
  71                 fido_log_error(errno, "%s: close", __func__);
  72
  73         return (usage_page == 0xf1d0);
  74 }
  75
  76 static int
  77 parse_uevent(const char *uevent, int *bus, int16_t *vendor_id,
  78     int16_t *product_id)
  79 {
  80         char                    *cp;
  81         char                    *p;
  82         char                    *s;
  83         int                      ok = -1;
  84         short unsigned int       x;
  85         short unsigned int       y;
  86         short unsigned int       z;
  87
  88         if ((s = cp = strdup(uevent)) == NULL)
  89                 return (-1);
  90
  91         while ((p = strsep(&cp, "\n")) != NULL && *p != '\0') {
  92                 if (strncmp(p, "HID_ID=", 7) == 0) {
  93                         if (sscanf(p + 7, "%hx:%hx:%hx", &x, &y, &z) == 3) {
  94                                 *bus = (int)x;
  95                                 *vendor_id = (int16_t)y;
  96                                 *product_id = (int16_t)z;
  97                                 ok = 0;
  98                                 break;
  99                         }
 100                 }
 101         }
 102
 103         free(s);
 104
 105         return (ok);
 106 }
 107
 108 static char *
 109 get_parent_attr(struct udev_device *dev, const char *subsystem,
 110     const char *devtype, const char *attr)
 111 {
 112         struct udev_device      *parent;
 113         const char              *value;
 114
 115         if ((parent = udev_device_get_parent_with_subsystem_devtype(dev,
 116             subsystem, devtype)) == NULL || (value =
 117             udev_device_get_sysattr_value(parent, attr)) == NULL)
 118                 return (NULL);
 119
 120         return (strdup(value));
 121 }
 122
 123 static char *
 124 get_usb_attr(struct udev_device *dev, const char *attr)
 125 {
 126         return (get_parent_attr(dev, "usb", "usb_device", attr));
 127 }
 128
 129 static int
 130 copy_info(fido_dev_info_t *di, struct udev *udev,
 131     struct udev_list_entry *udev_entry)
 132 {
 133         const char              *name;
 134         const char              *path;
 135         char                    *uevent = NULL;
 136         struct udev_device      *dev = NULL;
 137         int                      bus = 0;
 138         int                      ok = -1;
 139
 140         memset(di, 0, sizeof(*di));
 141
 142         if ((name = udev_list_entry_get_name(udev_entry)) == NULL ||
 143             (dev = udev_device_new_from_syspath(udev, name)) == NULL ||
 144             (path = udev_device_get_devnode(dev)) == NULL ||
 145             is_fido(path) == 0)
 146                 goto fail;
 147
 148         if ((uevent = get_parent_attr(dev, "hid", NULL, "uevent")) == NULL ||
 149             parse_uevent(uevent, &bus, &di->vendor_id, &di->product_id) < 0) {
 150                 fido_log_debug("%s: uevent", __func__);
 151                 goto fail;
 152         }
 153
 154 #ifndef FIDO_HID_ANY
 155         if (bus != BUS_USB) {
 156                 fido_log_debug("%s: bus", __func__);
 157                 goto fail;
 158         }
 159 #endif
 160
 161         di->path = strdup(path);
 162         if ((di->manufacturer = get_usb_attr(dev, "manufacturer")) == NULL)
 163                 di->manufacturer = strdup("unknown");
 164         if ((di->product = get_usb_attr(dev, "product")) == NULL)
 165                 di->product = strdup("unknown");
 166         if (di->path == NULL || di->manufacturer == NULL || di->product == NULL)
 167                 goto fail;
 168
 169         ok = 0;
 170 fail:
 171         if (dev != NULL)
 172                 udev_device_unref(dev);
 173
 174         free(uevent);
 175
 176         if (ok < 0) {
 177                 free(di->path);
 178                 free(di->manufacturer);
 179                 free(di->product);
 180                 explicit_bzero(di, sizeof(*di));
 181         }
 182
 183         return (ok);
 184 }
 185
 186 int
 187 fido_hid_manifest(fido_dev_info_t *devlist, size_t ilen, size_t *olen)
 188 {
 189         struct udev             *udev = NULL;
 190         struct udev_enumerate   *udev_enum = NULL;
 191         struct udev_list_entry  *udev_list;
 192         struct udev_list_entry  *udev_entry;
 193         int                      r = FIDO_ERR_INTERNAL;
 194
 195         *olen = 0;
 196
 197         if (ilen == 0)
 198                 return (FIDO_OK); /* nothing to do */
 199
 200         if (devlist == NULL)
 201                 return (FIDO_ERR_INVALID_ARGUMENT);
 202
 203         if ((udev = udev_new()) == NULL ||
 204             (udev_enum = udev_enumerate_new(udev)) == NULL)
 205                 goto fail;
 206
 207         if (udev_enumerate_add_match_subsystem(udev_enum, "hidraw") < 0 ||
 208             udev_enumerate_scan_devices(udev_enum) < 0)
 209                 goto fail;
 210
 211         if ((udev_list = udev_enumerate_get_list_entry(udev_enum)) == NULL) {
 212                 r = FIDO_OK; /* zero hidraw devices */
 213                 goto fail;
 214         }
 215
 216         udev_list_entry_foreach(udev_entry, udev_list) {
 217                 if (copy_info(&devlist[*olen], udev, udev_entry) == 0) {
 218                         devlist[*olen].io = (fido_dev_io_t) {
 219                                 fido_hid_open,
 220                                 fido_hid_close,
 221                                 fido_hid_read,
 222                                 fido_hid_write,
 223                         };
 224                         if (++(*olen) == ilen)
 225                                 break;
 226                 }
 227         }
 228
 229         r = FIDO_OK;
 230 fail:
 231         if (udev_enum != NULL)
 232                 udev_enumerate_unref(udev_enum);
 233         if (udev != NULL)
 234                 udev_unref(udev);
 235
 236         return (r);
 237 }
 238
 239 void *
 240 fido_hid_open(const char *path)
 241 {
 242         struct hid_linux *ctx;
 243         struct hidraw_report_descriptor hrd;
 244         struct timespec tv_pause;
 245         long interval_ms, retries = 0;
 246
 247         if ((ctx = calloc(1, sizeof(*ctx))) == NULL ||
 248             (ctx->fd = fido_hid_unix_open(path)) == -1) {
 249                 free(ctx);
 250                 return (NULL);
 251         }
 252
 253         while (flock(ctx->fd, LOCK_EX|LOCK_NB) == -1) {
 254                 if (errno != EWOULDBLOCK) {
 255                         fido_log_error(errno, "%s: flock", __func__);
 256                         fido_hid_close(ctx);
 257                         return (NULL);
 258                 }
 259                 if (retries++ >= 15) {
 260                         fido_log_debug("%s: flock timeout", __func__);
 261                         fido_hid_close(ctx);
 262                         return (NULL);
 263                 }
 264                 interval_ms = retries * 100000000L;
 265                 tv_pause.tv_sec = interval_ms / 1000000000L;
 266                 tv_pause.tv_nsec = interval_ms % 1000000000L;
 267                 if (nanosleep(&tv_pause, NULL) == -1) {
 268                         fido_log_error(errno, "%s: nanosleep", __func__);
 269                         fido_hid_close(ctx);
 270                         return (NULL);
 271                 }
 272         }
 273
 274         if (get_report_descriptor(ctx->fd, &hrd) < 0 ||
 275             fido_hid_get_report_len(hrd.value, hrd.size, &ctx->report_in_len,
 276             &ctx->report_out_len) < 0 || ctx->report_in_len == 0 ||
 277             ctx->report_out_len == 0) {
 278                 fido_log_debug("%s: using default report sizes", __func__);
 279                 ctx->report_in_len = CTAP_MAX_REPORT_LEN;
 280                 ctx->report_out_len = CTAP_MAX_REPORT_LEN;
 281         }
 282
 283         return (ctx);
 284 }
 285
 286 void
 287 fido_hid_close(void *handle)
 288 {
 289         struct hid_linux *ctx = handle;
 290
 291         if (close(ctx->fd) == -1)
 292                 fido_log_error(errno, "%s: close", __func__);
 293
 294         free(ctx);
 295 }
 296
 297 int
 298 fido_hid_set_sigmask(void *handle, const fido_sigset_t *sigmask)
 299 {
 300         struct hid_linux *ctx = handle;
 301
 302         ctx->sigmask = *sigmask;
 303         ctx->sigmaskp = &ctx->sigmask;
 304
 305         return (FIDO_OK);
 306 }
 307
 308 int
 309 fido_hid_read(void *handle, unsigned char *buf, size_t len, int ms)
 310 {
 311         struct hid_linux        *ctx = handle;
 312         ssize_t                  r;
 313
 314         if (len != ctx->report_in_len) {
 315                 fido_log_debug("%s: len %zu", __func__, len);
 316                 return (-1);
 317         }
 318
 319         if (fido_hid_unix_wait(ctx->fd, ms, ctx->sigmaskp) < 0) {
 320                 fido_log_debug("%s: fd not ready", __func__);
 321                 return (-1);
 322         }
 323
 324         if ((r = read(ctx->fd, buf, len)) == -1) {
 325                 fido_log_error(errno, "%s: read", __func__);
 326                 return (-1);
 327         }
 328
 329         if (r < 0 || (size_t)r != len) {
 330                 fido_log_debug("%s: %zd != %zu", __func__, r, len);
 331                 return (-1);
 332         }
 333
 334         return ((int)r);
 335 }
 336
 337 int
 338 fido_hid_write(void *handle, const unsigned char *buf, size_t len)
 339 {
 340         struct hid_linux        *ctx = handle;
 341         ssize_t                  r;
 342
 343         if (len != ctx->report_out_len + 1) {
 344                 fido_log_debug("%s: len %zu", __func__, len);
 345                 return (-1);
 346         }
 347
 348         if ((r = write(ctx->fd, buf, len)) == -1) {
 349                 fido_log_error(errno, "%s: write", __func__);
 350                 return (-1);
 351         }
 352
 353         if (r < 0 || (size_t)r != len) {
 354                 fido_log_debug("%s: %zd != %zu", __func__, r, len);
 355                 return (-1);
 356         }
 357
 358         return ((int)r);
 359 }
 360
 361 size_t
 362 fido_hid_report_in_len(void *handle)
 363 {
 364         struct hid_linux *ctx = handle;
 365
 366         return (ctx->report_in_len);
 367 }
 368
 369 size_t
 370 fido_hid_report_out_len(void *handle)
 371 {
 372         struct hid_linux *ctx = handle;
 373
 374         return (ctx->report_out_len);
 375 }