| Line | Count | Source | 
| 1 |  | /* | 
| 2 |  |  * Copyright (c) 2018 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 |  |  * SPDX-License-Identifier: BSD-2-Clause | 
| 6 |  |  */ | 
| 7 |  |  | 
| 8 |  | #include "fido.h" | 
| 9 |  |  | 
| 10 |  | static int | 
| 11 |  | get_key_len(uint8_t tag, uint8_t *key, size_t *key_len) | 
| 12 | 7.06M | { | 
| 13 | 7.06M |         *key = tag & 0xfc; | 
| 14 | 7.06M |         if ((*key & 0xf0) == 0xf0) { | 
| 15 | 112k |                 fido_log_debug("%s: *key=0x%02x", __func__, *key); | 
| 16 | 112k |                 return (-1); | 
| 17 | 112k |         } | 
| 18 |  |  | 
| 19 | 6.95M |         *key_len = tag & 0x3; | 
| 20 | 6.95M |         if (*key_len == 3) { | 
| 21 | 327k |                 *key_len = 4; | 
| 22 | 327k |         } | 
| 23 |  |  | 
| 24 | 6.95M |         return (0); | 
| 25 | 7.06M | } | 
| 26 |  |  | 
| 27 |  | static int | 
| 28 |  | get_key_val(const void *body, size_t key_len, uint32_t *val) | 
| 29 | 5.83M | { | 
| 30 | 5.83M |         const uint8_t *ptr = body; | 
| 31 |  |  | 
| 32 | 5.83M |         switch (key_len) { | 
| 33 | 3.56M |         case 0: | 
| 34 | 3.56M |                 *val = 0; | 
| 35 | 3.56M |                 break; | 
| 36 | 797k |         case 1: | 
| 37 | 797k |                 *val = ptr[0]; | 
| 38 | 797k |                 break; | 
| 39 | 1.44M |         case 2: | 
| 40 | 1.44M |                 *val = (uint32_t)((ptr[1] << 8) | ptr[0]); | 
| 41 | 1.44M |                 break; | 
| 42 | 29.6k |         default: | 
| 43 | 29.6k |                 fido_log_debug("%s: key_len=%zu", __func__, key_len); | 
| 44 | 29.6k |                 return (-1); | 
| 45 | 5.83M |         } | 
| 46 |  |  | 
| 47 | 5.80M |         return (0); | 
| 48 | 5.83M | } | 
| 49 |  |  | 
| 50 |  | int | 
| 51 |  | fido_hid_get_usage(const uint8_t *report_ptr, size_t report_len, | 
| 52 |  |     uint32_t *usage_page) | 
| 53 | 2.48M | { | 
| 54 | 2.48M |         const uint8_t   *ptr = report_ptr; | 
| 55 | 2.48M |         size_t           len = report_len; | 
| 56 |  |  | 
| 57 | 8.26M |         while (len > 0) { | 
| 58 | 7.05M |                 const uint8_t tag = ptr[0]; | 
| 59 | 7.05M |                 ptr++; | 
| 60 | 7.05M |                 len--; | 
| 61 |  |  | 
| 62 | 7.05M |                 uint8_t  key; | 
| 63 | 7.05M |                 size_t   key_len; | 
| 64 | 7.05M |                 uint32_t key_val; | 
| 65 |  |  | 
| 66 | 7.05M |                 if (get_key_len(tag, &key, &key_len) < 0 || key_len > len || | 
| 67 | 7.05M |                     get_key_val(ptr, key_len, &key_val) < 0) { | 
| 68 | 1.26M |                         return (-1); | 
| 69 | 1.26M |                 } | 
| 70 |  |  | 
| 71 | 5.78M |                 if (key == 0x4) { | 
| 72 | 476k |                         *usage_page = key_val; | 
| 73 | 476k |                 } | 
| 74 |  |  | 
| 75 | 5.78M |                 ptr += key_len; | 
| 76 | 5.78M |                 len -= key_len; | 
| 77 | 5.78M |         } | 
| 78 |  |  | 
| 79 | 1.21M |         return (0); | 
| 80 | 2.48M | } | 
| 81 |  |  | 
| 82 |  | int | 
| 83 |  | fido_hid_get_report_len(const uint8_t *report_ptr, size_t report_len, | 
| 84 |  |     size_t *report_in_len, size_t *report_out_len) | 
| 85 | 6.02k | { | 
| 86 | 6.02k |         const uint8_t   *ptr = report_ptr; | 
| 87 | 6.02k |         size_t           len = report_len; | 
| 88 | 6.02k |         uint32_t         report_size = 0; | 
| 89 |  |  | 
| 90 | 19.2k |         while (len > 0) { | 
| 91 | 16.4k |                 const uint8_t tag = ptr[0]; | 
| 92 | 16.4k |                 ptr++; | 
| 93 | 16.4k |                 len--; | 
| 94 |  |  | 
| 95 | 16.4k |                 uint8_t  key; | 
| 96 | 16.4k |                 size_t   key_len; | 
| 97 | 16.4k |                 uint32_t key_val; | 
| 98 |  |  | 
| 99 | 16.4k |                 if (get_key_len(tag, &key, &key_len) < 0 || key_len > len || | 
| 100 | 16.4k |                     get_key_val(ptr, key_len, &key_val) < 0) { | 
| 101 | 3.22k |                         return (-1); | 
| 102 | 3.22k |                 } | 
| 103 |  |  | 
| 104 | 13.2k |                 if (key == 0x94) { | 
| 105 | 1.31k |                         report_size = key_val; | 
| 106 | 11.9k |                 } else if (key == 0x80) { | 
| 107 | 1.04k |                         *report_in_len = (size_t)report_size; | 
| 108 | 10.8k |                 } else if (key == 0x90) { | 
| 109 | 979 |                         *report_out_len = (size_t)report_size; | 
| 110 | 979 |                 } | 
| 111 |  |  | 
| 112 | 13.2k |                 ptr += key_len; | 
| 113 | 13.2k |                 len -= key_len; | 
| 114 | 13.2k |         } | 
| 115 |  |  | 
| 116 | 2.79k |         return (0); | 
| 117 | 6.02k | } | 
| 118 |  |  | 
| 119 |  | fido_dev_info_t * | 
| 120 |  | fido_dev_info_new(size_t n) | 
| 121 | 17.9k | { | 
| 122 | 17.9k |         return (calloc(n, sizeof(fido_dev_info_t))); | 
| 123 | 17.9k | } | 
| 124 |  |  | 
| 125 |  | static void | 
| 126 |  | fido_dev_info_reset(fido_dev_info_t *di) | 
| 127 | 409k | { | 
| 128 | 409k |         free(di->path); | 
| 129 | 409k |         free(di->manufacturer); | 
| 130 | 409k |         free(di->product); | 
| 131 | 409k |         memset(di, 0, sizeof(*di)); | 
| 132 | 409k | } | 
| 133 |  |  | 
| 134 |  | void | 
| 135 |  | fido_dev_info_free(fido_dev_info_t **devlist_p, size_t n) | 
| 136 | 17.9k | { | 
| 137 | 17.9k |         fido_dev_info_t *devlist; | 
| 138 |  |  | 
| 139 | 17.9k |         if (devlist_p == NULL || (devlist = *devlist_p) == NULL) | 
| 140 | 97 |                 return; | 
| 141 |  |  | 
| 142 | 418k |         for (size_t i = 0; i < n; i++) | 
| 143 | 400k |                 fido_dev_info_reset(&devlist[i]); | 
| 144 |  |  | 
| 145 | 17.8k |         free(devlist); | 
| 146 |  |  | 
| 147 | 17.8k |         *devlist_p = NULL; | 
| 148 | 17.8k | } | 
| 149 |  |  | 
| 150 |  | const fido_dev_info_t * | 
| 151 |  | fido_dev_info_ptr(const fido_dev_info_t *devlist, size_t i) | 
| 152 | 9.61k | { | 
| 153 | 9.61k |         return (&devlist[i]); | 
| 154 | 9.61k | } | 
| 155 |  |  | 
| 156 |  | int | 
| 157 |  | fido_dev_info_set(fido_dev_info_t *devlist, size_t i, | 
| 158 |  |     const char *path, const char *manufacturer, const char *product, | 
| 159 |  |     const fido_dev_io_t *io, const fido_dev_transport_t *transport) | 
| 160 | 8.64k | { | 
| 161 | 8.64k |         char *path_copy = NULL, *manu_copy = NULL, *prod_copy = NULL; | 
| 162 | 8.64k |         int r; | 
| 163 |  |  | 
| 164 | 8.64k |         if (path == NULL || manufacturer == NULL || product == NULL || | 
| 165 | 8.64k |             io == NULL) { | 
| 166 | 0 |                 r = FIDO_ERR_INVALID_ARGUMENT; | 
| 167 | 0 |                 goto out; | 
| 168 | 0 |         } | 
| 169 |  |  | 
| 170 | 8.64k |         if ((path_copy = strdup(path)) == NULL || | 
| 171 | 8.64k |             (manu_copy = strdup(manufacturer)) == NULL || | 
| 172 | 8.64k |             (prod_copy = strdup(product)) == NULL) { | 
| 173 | 200 |                 r = FIDO_ERR_INTERNAL; | 
| 174 | 200 |                 goto out; | 
| 175 | 200 |         } | 
| 176 |  |  | 
| 177 | 8.44k |         fido_dev_info_reset(&devlist[i]); | 
| 178 | 8.44k |         devlist[i].path = path_copy; | 
| 179 | 8.44k |         devlist[i].manufacturer = manu_copy; | 
| 180 | 8.44k |         devlist[i].product = prod_copy; | 
| 181 | 8.44k |         devlist[i].io = *io; | 
| 182 | 8.44k |         if (transport) | 
| 183 | 8.44k |                 devlist[i].transport = *transport; | 
| 184 | 8.44k |         r = FIDO_OK; | 
| 185 | 8.64k | out: | 
| 186 | 8.64k |         if (r != FIDO_OK) { | 
| 187 | 200 |                 free(prod_copy); | 
| 188 | 200 |                 free(manu_copy); | 
| 189 | 200 |                 free(path_copy); | 
| 190 | 200 |         } | 
| 191 | 8.64k |         return (r); | 
| 192 | 8.44k | } | 
| 193 |  |  | 
| 194 |  | const char * | 
| 195 |  | fido_dev_info_path(const fido_dev_info_t *di) | 
| 196 | 18.2k | { | 
| 197 | 18.2k |         return (di->path); | 
| 198 | 18.2k | } | 
| 199 |  |  | 
| 200 |  | int16_t | 
| 201 |  | fido_dev_info_vendor(const fido_dev_info_t *di) | 
| 202 | 9.61k | { | 
| 203 | 9.61k |         return (di->vendor_id); | 
| 204 | 9.61k | } | 
| 205 |  |  | 
| 206 |  | int16_t | 
| 207 |  | fido_dev_info_product(const fido_dev_info_t *di) | 
| 208 | 9.61k | { | 
| 209 | 9.61k |         return (di->product_id); | 
| 210 | 9.61k | } | 
| 211 |  |  | 
| 212 |  | const char * | 
| 213 |  | fido_dev_info_manufacturer_string(const fido_dev_info_t *di) | 
| 214 | 18.2k | { | 
| 215 | 18.2k |         return (di->manufacturer); | 
| 216 | 18.2k | } | 
| 217 |  |  | 
| 218 |  | const char * | 
| 219 |  | fido_dev_info_product_string(const fido_dev_info_t *di) | 
| 220 | 18.2k | { | 
| 221 | 18.2k |         return (di->product); | 
| 222 | 18.2k | } |