Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | * Copyright (c) 2018-2022 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 | | decode_string(const cbor_item_t *item, void *arg) |
12 | 38.9k | { |
13 | 38.9k | fido_str_array_t *a = arg; |
14 | 38.9k | const size_t i = a->len; |
15 | | |
16 | | /* keep ptr[x] and len consistent */ |
17 | 38.9k | if (cbor_string_copy(item, &a->ptr[i]) < 0) { |
18 | 84 | fido_log_debug("%s: cbor_string_copy", __func__); |
19 | 84 | return (-1); |
20 | 84 | } |
21 | | |
22 | 38.8k | a->len++; |
23 | | |
24 | 38.8k | return (0); |
25 | 38.9k | } |
26 | | |
27 | | static int |
28 | | decode_string_array(const cbor_item_t *item, fido_str_array_t *v) |
29 | 16.1k | { |
30 | 16.1k | v->ptr = NULL; |
31 | 16.1k | v->len = 0; |
32 | | |
33 | 16.1k | if (cbor_isa_array(item) == false || |
34 | 16.1k | cbor_array_is_definite(item) == false) { |
35 | 59 | fido_log_debug("%s: cbor type", __func__); |
36 | 59 | return (-1); |
37 | 59 | } |
38 | | |
39 | 16.1k | v->ptr = calloc(cbor_array_size(item), sizeof(char *)); |
40 | 16.1k | if (v->ptr == NULL) |
41 | 18 | return (-1); |
42 | | |
43 | 16.1k | if (cbor_array_iter(item, v, decode_string) < 0) { |
44 | 96 | fido_log_debug("%s: decode_string", __func__); |
45 | 96 | return (-1); |
46 | 96 | } |
47 | | |
48 | 16.0k | return (0); |
49 | 16.1k | } |
50 | | |
51 | | static int |
52 | | decode_aaguid(const cbor_item_t *item, unsigned char *aaguid, size_t aaguid_len) |
53 | 7.29k | { |
54 | 7.29k | if (cbor_isa_bytestring(item) == false || |
55 | 7.29k | cbor_bytestring_is_definite(item) == false || |
56 | 7.29k | cbor_bytestring_length(item) != aaguid_len) { |
57 | 102 | fido_log_debug("%s: cbor type", __func__); |
58 | 102 | return (-1); |
59 | 102 | } |
60 | | |
61 | 7.19k | memcpy(aaguid, cbor_bytestring_handle(item), aaguid_len); |
62 | | |
63 | 7.19k | return (0); |
64 | 7.29k | } |
65 | | |
66 | | static int |
67 | | decode_option(const cbor_item_t *key, const cbor_item_t *val, void *arg) |
68 | 38.0k | { |
69 | 38.0k | fido_opt_array_t *o = arg; |
70 | 38.0k | const size_t i = o->len; |
71 | | |
72 | 38.0k | if (cbor_decode_bool(val, NULL) < 0) { |
73 | 2.64k | fido_log_debug("%s: cbor_decode_bool", __func__); |
74 | 2.64k | return (0); /* ignore */ |
75 | 2.64k | } |
76 | | |
77 | 35.4k | if (cbor_string_copy(key, &o->name[i]) < 0) { |
78 | 146 | fido_log_debug("%s: cbor_string_copy", __func__); |
79 | 146 | return (0); /* ignore */ |
80 | 146 | } |
81 | | |
82 | | /* keep name/value and len consistent */ |
83 | 35.2k | o->value[i] = cbor_ctrl_value(val) == CBOR_CTRL_TRUE; |
84 | 35.2k | o->len++; |
85 | | |
86 | 35.2k | return (0); |
87 | 35.4k | } |
88 | | |
89 | | static int |
90 | | decode_options(const cbor_item_t *item, fido_opt_array_t *o) |
91 | 6.97k | { |
92 | 6.97k | o->name = NULL; |
93 | 6.97k | o->value = NULL; |
94 | 6.97k | o->len = 0; |
95 | | |
96 | 6.97k | if (cbor_isa_map(item) == false || |
97 | 6.97k | cbor_map_is_definite(item) == false) { |
98 | 39 | fido_log_debug("%s: cbor type", __func__); |
99 | 39 | return (-1); |
100 | 39 | } |
101 | | |
102 | 6.93k | o->name = calloc(cbor_map_size(item), sizeof(char *)); |
103 | 6.93k | o->value = calloc(cbor_map_size(item), sizeof(bool)); |
104 | 6.93k | if (o->name == NULL || o->value == NULL) |
105 | 31 | return (-1); |
106 | | |
107 | 6.90k | return (cbor_map_iter(item, o, decode_option)); |
108 | 6.93k | } |
109 | | |
110 | | static int |
111 | | decode_protocol(const cbor_item_t *item, void *arg) |
112 | 9.50k | { |
113 | 9.50k | fido_byte_array_t *p = arg; |
114 | 9.50k | const size_t i = p->len; |
115 | | |
116 | 9.50k | if (cbor_isa_uint(item) == false || |
117 | 9.50k | cbor_int_get_width(item) != CBOR_INT_8) { |
118 | 65 | fido_log_debug("%s: cbor type", __func__); |
119 | 65 | return (-1); |
120 | 65 | } |
121 | | |
122 | | /* keep ptr[x] and len consistent */ |
123 | 9.44k | p->ptr[i] = cbor_get_uint8(item); |
124 | 9.44k | p->len++; |
125 | | |
126 | 9.44k | return (0); |
127 | 9.50k | } |
128 | | |
129 | | static int |
130 | | decode_protocols(const cbor_item_t *item, fido_byte_array_t *p) |
131 | 6.98k | { |
132 | 6.98k | p->ptr = NULL; |
133 | 6.98k | p->len = 0; |
134 | | |
135 | 6.98k | if (cbor_isa_array(item) == false || |
136 | 6.98k | cbor_array_is_definite(item) == false) { |
137 | 43 | fido_log_debug("%s: cbor type", __func__); |
138 | 43 | return (-1); |
139 | 43 | } |
140 | | |
141 | 6.94k | p->ptr = calloc(cbor_array_size(item), sizeof(uint8_t)); |
142 | 6.94k | if (p->ptr == NULL) |
143 | 16 | return (-1); |
144 | | |
145 | 6.92k | if (cbor_array_iter(item, p, decode_protocol) < 0) { |
146 | 72 | fido_log_debug("%s: decode_protocol", __func__); |
147 | 72 | return (-1); |
148 | 72 | } |
149 | | |
150 | 6.85k | return (0); |
151 | 6.92k | } |
152 | | |
153 | | static int |
154 | | decode_algorithm_entry(const cbor_item_t *key, const cbor_item_t *val, |
155 | | void *arg) |
156 | 19.4k | { |
157 | 19.4k | fido_algo_t *alg = arg; |
158 | 19.4k | char *name = NULL; |
159 | 19.4k | int ok = -1; |
160 | | |
161 | 19.4k | if (cbor_string_copy(key, &name) < 0) { |
162 | 237 | fido_log_debug("%s: cbor type", __func__); |
163 | 237 | ok = 0; /* ignore */ |
164 | 237 | goto out; |
165 | 237 | } |
166 | | |
167 | 19.1k | if (!strcmp(name, "alg")) { |
168 | 8.20k | if (cbor_isa_negint(val) == false || |
169 | 8.20k | cbor_get_int(val) > INT_MAX || alg->cose != 0) { |
170 | 387 | fido_log_debug("%s: alg", __func__); |
171 | 387 | goto out; |
172 | 387 | } |
173 | 7.81k | alg->cose = -(int)cbor_get_int(val) - 1; |
174 | 10.9k | } else if (!strcmp(name, "type")) { |
175 | 7.16k | if (cbor_string_copy(val, &alg->type) < 0) { |
176 | 41 | fido_log_debug("%s: type", __func__); |
177 | 41 | goto out; |
178 | 41 | } |
179 | 7.16k | } |
180 | | |
181 | 18.7k | ok = 0; |
182 | 19.4k | out: |
183 | 19.4k | free(name); |
184 | | |
185 | 19.4k | return (ok); |
186 | 18.7k | } |
187 | | |
188 | | static int |
189 | | decode_algorithm(const cbor_item_t *item, void *arg) |
190 | 10.5k | { |
191 | 10.5k | fido_algo_array_t *aa = arg; |
192 | 10.5k | const size_t i = aa->len; |
193 | | |
194 | 10.5k | if (cbor_isa_map(item) == false || |
195 | 10.5k | cbor_map_is_definite(item) == false) { |
196 | 76 | fido_log_debug("%s: cbor type", __func__); |
197 | 76 | return (-1); |
198 | 76 | } |
199 | | |
200 | 10.4k | memset(&aa->ptr[i], 0, sizeof(aa->ptr[i])); |
201 | | |
202 | 10.4k | if (cbor_map_iter(item, &aa->ptr[i], decode_algorithm_entry) < 0) { |
203 | 632 | fido_log_debug("%s: decode_algorithm_entry", __func__); |
204 | 632 | fido_algo_free(&aa->ptr[i]); |
205 | 632 | return (-1); |
206 | 632 | } |
207 | | |
208 | | /* keep ptr[x] and len consistent */ |
209 | 9.84k | aa->len++; |
210 | | |
211 | 9.84k | return (0); |
212 | 10.4k | } |
213 | | |
214 | | static int |
215 | | decode_algorithms(const cbor_item_t *item, fido_algo_array_t *aa) |
216 | 5.50k | { |
217 | 5.50k | aa->ptr = NULL; |
218 | 5.50k | aa->len = 0; |
219 | | |
220 | 5.50k | if (cbor_isa_array(item) == false || |
221 | 5.50k | cbor_array_is_definite(item) == false) { |
222 | 40 | fido_log_debug("%s: cbor type", __func__); |
223 | 40 | return (-1); |
224 | 40 | } |
225 | | |
226 | 5.46k | aa->ptr = calloc(cbor_array_size(item), sizeof(fido_algo_t)); |
227 | 5.46k | if (aa->ptr == NULL) |
228 | 16 | return (-1); |
229 | | |
230 | 5.44k | if (cbor_array_iter(item, aa, decode_algorithm) < 0) { |
231 | 713 | fido_log_debug("%s: decode_algorithm", __func__); |
232 | 713 | return (-1); |
233 | 713 | } |
234 | | |
235 | 4.73k | return (0); |
236 | 5.44k | } |
237 | | |
238 | | static int |
239 | | decode_cert(const cbor_item_t *key, const cbor_item_t *val, void *arg) |
240 | 1.27k | { |
241 | 1.27k | fido_cert_array_t *c = arg; |
242 | 1.27k | const size_t i = c->len; |
243 | | |
244 | 1.27k | if (cbor_is_int(val) == false) { |
245 | 397 | fido_log_debug("%s: cbor_is_int", __func__); |
246 | 397 | return (0); /* ignore */ |
247 | 397 | } |
248 | | |
249 | 880 | if (cbor_string_copy(key, &c->name[i]) < 0) { |
250 | 165 | fido_log_debug("%s: cbor_string_copy", __func__); |
251 | 165 | return (0); /* ignore */ |
252 | 165 | } |
253 | | |
254 | | /* keep name/value and len consistent */ |
255 | 715 | c->value[i] = cbor_get_int(val); |
256 | 715 | c->len++; |
257 | | |
258 | 715 | return (0); |
259 | 880 | } |
260 | | |
261 | | static int |
262 | | decode_certs(const cbor_item_t *item, fido_cert_array_t *c) |
263 | 494 | { |
264 | 494 | c->name = NULL; |
265 | 494 | c->value = NULL; |
266 | 494 | c->len = 0; |
267 | | |
268 | 494 | if (cbor_isa_map(item) == false || |
269 | 494 | cbor_map_is_definite(item) == false) { |
270 | 38 | fido_log_debug("%s: cbor type", __func__); |
271 | 38 | return (-1); |
272 | 38 | } |
273 | | |
274 | 456 | c->name = calloc(cbor_map_size(item), sizeof(char *)); |
275 | 456 | c->value = calloc(cbor_map_size(item), sizeof(uint64_t)); |
276 | 456 | if (c->name == NULL || c->value == NULL) |
277 | 24 | return (-1); |
278 | | |
279 | 432 | return (cbor_map_iter(item, c, decode_cert)); |
280 | 456 | } |
281 | | |
282 | | static int |
283 | | parse_reply_element(const cbor_item_t *key, const cbor_item_t *val, void *arg) |
284 | 71.8k | { |
285 | 71.8k | fido_cbor_info_t *ci = arg; |
286 | 71.8k | uint64_t x; |
287 | | |
288 | 71.8k | if (cbor_isa_uint(key) == false || |
289 | 71.8k | cbor_int_get_width(key) != CBOR_INT_8) { |
290 | 2.10k | fido_log_debug("%s: cbor type", __func__); |
291 | 2.10k | return (0); /* ignore */ |
292 | 2.10k | } |
293 | | |
294 | 69.6k | switch (cbor_get_uint8(key)) { |
295 | 7.20k | case 1: /* versions */ |
296 | 7.20k | return (decode_string_array(val, &ci->versions)); |
297 | 8.05k | case 2: /* extensions */ |
298 | 8.05k | return (decode_string_array(val, &ci->extensions)); |
299 | 7.29k | case 3: /* aaguid */ |
300 | 7.29k | return (decode_aaguid(val, ci->aaguid, sizeof(ci->aaguid))); |
301 | 6.97k | case 4: /* options */ |
302 | 6.97k | return (decode_options(val, &ci->options)); |
303 | 7.19k | case 5: /* maxMsgSize */ |
304 | 7.19k | return (cbor_decode_uint64(val, &ci->maxmsgsiz)); |
305 | 6.98k | case 6: /* pinProtocols */ |
306 | 6.98k | return (decode_protocols(val, &ci->protocols)); |
307 | 6.50k | case 7: /* maxCredentialCountInList */ |
308 | 6.50k | return (cbor_decode_uint64(val, &ci->maxcredcntlst)); |
309 | 6.24k | case 8: /* maxCredentialIdLength */ |
310 | 6.24k | return (cbor_decode_uint64(val, &ci->maxcredidlen)); |
311 | 928 | case 9: /* transports */ |
312 | 928 | return (decode_string_array(val, &ci->transports)); |
313 | 5.50k | case 10: /* algorithms */ |
314 | 5.50k | return (decode_algorithms(val, &ci->algorithms)); |
315 | 350 | case 11: /* maxSerializedLargeBlobArray */ |
316 | 350 | return (cbor_decode_uint64(val, &ci->maxlargeblob)); |
317 | 380 | case 12: /* forcePINChange */ |
318 | 380 | return (cbor_decode_bool(val, &ci->new_pin_reqd)); |
319 | 699 | case 13: /* minPINLength */ |
320 | 699 | return (cbor_decode_uint64(val, &ci->minpinlen)); |
321 | 817 | case 14: /* fwVersion */ |
322 | 817 | return (cbor_decode_uint64(val, &ci->fwversion)); |
323 | 446 | case 15: /* maxCredBlobLen */ |
324 | 446 | return (cbor_decode_uint64(val, &ci->maxcredbloblen)); |
325 | 363 | case 16: /* maxRPIDsForSetMinPINLength */ |
326 | 363 | return (cbor_decode_uint64(val, &ci->maxrpid_minlen)); |
327 | 378 | case 17: /* preferredPlatformUvAttempts */ |
328 | 378 | return (cbor_decode_uint64(val, &ci->uv_attempts)); |
329 | 353 | case 18: /* uvModality */ |
330 | 353 | return (cbor_decode_uint64(val, &ci->uv_modality)); |
331 | 494 | case 19: /* certifications */ |
332 | 494 | return (decode_certs(val, &ci->certs)); |
333 | 834 | case 20: /* remainingDiscoverableCredentials */ |
334 | 834 | if (cbor_decode_uint64(val, &x) < 0 || x > INT64_MAX) { |
335 | 58 | fido_log_debug("%s: cbor_decode_uint64", __func__); |
336 | 58 | return (-1); |
337 | 58 | } |
338 | 776 | ci->rk_remaining = (int64_t)x; |
339 | 776 | return (0); |
340 | 1.70k | default: /* ignore */ |
341 | 1.70k | fido_log_debug("%s: cbor type: 0x%02x", __func__, cbor_get_uint8(key)); |
342 | 1.70k | return (0); |
343 | 69.6k | } |
344 | 69.6k | } |
345 | | |
346 | | static int |
347 | | fido_dev_get_cbor_info_tx(fido_dev_t *dev, int *ms) |
348 | 19.7k | { |
349 | 19.7k | const unsigned char cbor[] = { CTAP_CBOR_GETINFO }; |
350 | | |
351 | 19.7k | fido_log_debug("%s: dev=%p", __func__, (void *)dev); |
352 | | |
353 | 19.7k | if (fido_tx(dev, CTAP_CMD_CBOR, cbor, sizeof(cbor), ms) < 0) { |
354 | 233 | fido_log_debug("%s: fido_tx", __func__); |
355 | 233 | return (FIDO_ERR_TX); |
356 | 233 | } |
357 | | |
358 | 19.5k | return (FIDO_OK); |
359 | 19.7k | } |
360 | | |
361 | | static int |
362 | | fido_dev_get_cbor_info_rx(fido_dev_t *dev, fido_cbor_info_t *ci, int *ms) |
363 | 19.5k | { |
364 | 19.5k | unsigned char *msg; |
365 | 19.5k | int msglen; |
366 | 19.5k | int r; |
367 | | |
368 | 19.5k | fido_log_debug("%s: dev=%p, ci=%p, ms=%d", __func__, (void *)dev, |
369 | 19.5k | (void *)ci, *ms); |
370 | | |
371 | 19.5k | fido_cbor_info_reset(ci); |
372 | | |
373 | 19.5k | if ((msg = malloc(FIDO_MAXMSG)) == NULL) { |
374 | 75 | r = FIDO_ERR_INTERNAL; |
375 | 75 | goto out; |
376 | 75 | } |
377 | | |
378 | 19.4k | if ((msglen = fido_rx(dev, CTAP_CMD_CBOR, msg, FIDO_MAXMSG, ms)) < 0) { |
379 | 5.24k | fido_log_debug("%s: fido_rx", __func__); |
380 | 5.24k | r = FIDO_ERR_RX; |
381 | 5.24k | goto out; |
382 | 5.24k | } |
383 | | |
384 | 14.2k | r = cbor_parse_reply(msg, (size_t)msglen, ci, parse_reply_element); |
385 | 19.5k | out: |
386 | 19.5k | freezero(msg, FIDO_MAXMSG); |
387 | | |
388 | 19.5k | return (r); |
389 | 14.2k | } |
390 | | |
391 | | int |
392 | | fido_dev_get_cbor_info_wait(fido_dev_t *dev, fido_cbor_info_t *ci, int *ms) |
393 | 19.7k | { |
394 | 19.7k | int r; |
395 | | |
396 | | #ifdef USE_WINHELLO |
397 | | if (dev->flags & FIDO_DEV_WINHELLO) |
398 | | return (fido_winhello_get_cbor_info(dev, ci)); |
399 | | #endif |
400 | 19.7k | if ((r = fido_dev_get_cbor_info_tx(dev, ms)) != FIDO_OK || |
401 | 19.7k | (r = fido_dev_get_cbor_info_rx(dev, ci, ms)) != FIDO_OK) |
402 | 12.4k | return (r); |
403 | | |
404 | 7.33k | return (FIDO_OK); |
405 | 19.7k | } |
406 | | |
407 | | int |
408 | | fido_dev_get_cbor_info(fido_dev_t *dev, fido_cbor_info_t *ci) |
409 | 160 | { |
410 | 160 | int ms = dev->timeout_ms; |
411 | | |
412 | 160 | return (fido_dev_get_cbor_info_wait(dev, ci, &ms)); |
413 | 160 | } |
414 | | |
415 | | /* |
416 | | * get/set functions for fido_cbor_info_t; always at the end of the file |
417 | | */ |
418 | | |
419 | | fido_cbor_info_t * |
420 | | fido_cbor_info_new(void) |
421 | 19.8k | { |
422 | 19.8k | fido_cbor_info_t *ci; |
423 | | |
424 | 19.8k | if ((ci = calloc(1, sizeof(fido_cbor_info_t))) == NULL) |
425 | 88 | return (NULL); |
426 | | |
427 | 19.7k | fido_cbor_info_reset(ci); |
428 | | |
429 | 19.7k | return (ci); |
430 | 19.8k | } |
431 | | |
432 | | void |
433 | | fido_cbor_info_reset(fido_cbor_info_t *ci) |
434 | 59.1k | { |
435 | 59.1k | fido_str_array_free(&ci->versions); |
436 | 59.1k | fido_str_array_free(&ci->extensions); |
437 | 59.1k | fido_str_array_free(&ci->transports); |
438 | 59.1k | fido_opt_array_free(&ci->options); |
439 | 59.1k | fido_byte_array_free(&ci->protocols); |
440 | 59.1k | fido_algo_array_free(&ci->algorithms); |
441 | 59.1k | fido_cert_array_free(&ci->certs); |
442 | 59.1k | ci->rk_remaining = -1; |
443 | 59.1k | } |
444 | | |
445 | | void |
446 | | fido_cbor_info_free(fido_cbor_info_t **ci_p) |
447 | 66.3k | { |
448 | 66.3k | fido_cbor_info_t *ci; |
449 | | |
450 | 66.3k | if (ci_p == NULL || (ci = *ci_p) == NULL) |
451 | 46.5k | return; |
452 | 19.7k | fido_cbor_info_reset(ci); |
453 | 19.7k | free(ci); |
454 | 19.7k | *ci_p = NULL; |
455 | 19.7k | } |
456 | | |
457 | | char ** |
458 | | fido_cbor_info_versions_ptr(const fido_cbor_info_t *ci) |
459 | 171 | { |
460 | 171 | return (ci->versions.ptr); |
461 | 171 | } |
462 | | |
463 | | size_t |
464 | | fido_cbor_info_versions_len(const fido_cbor_info_t *ci) |
465 | 331 | { |
466 | 331 | return (ci->versions.len); |
467 | 331 | } |
468 | | |
469 | | char ** |
470 | | fido_cbor_info_extensions_ptr(const fido_cbor_info_t *ci) |
471 | 7.42k | { |
472 | 7.42k | return (ci->extensions.ptr); |
473 | 7.42k | } |
474 | | |
475 | | size_t |
476 | | fido_cbor_info_extensions_len(const fido_cbor_info_t *ci) |
477 | 7.58k | { |
478 | 7.58k | return (ci->extensions.len); |
479 | 7.58k | } |
480 | | |
481 | | char ** |
482 | | fido_cbor_info_transports_ptr(const fido_cbor_info_t *ci) |
483 | 53 | { |
484 | 53 | return (ci->transports.ptr); |
485 | 53 | } |
486 | | |
487 | | size_t |
488 | | fido_cbor_info_transports_len(const fido_cbor_info_t *ci) |
489 | 213 | { |
490 | 213 | return (ci->transports.len); |
491 | 213 | } |
492 | | |
493 | | const unsigned char * |
494 | | fido_cbor_info_aaguid_ptr(const fido_cbor_info_t *ci) |
495 | 160 | { |
496 | 160 | return (ci->aaguid); |
497 | 160 | } |
498 | | |
499 | | size_t |
500 | | fido_cbor_info_aaguid_len(const fido_cbor_info_t *ci) |
501 | 160 | { |
502 | 160 | return (sizeof(ci->aaguid)); |
503 | 160 | } |
504 | | |
505 | | char ** |
506 | | fido_cbor_info_options_name_ptr(const fido_cbor_info_t *ci) |
507 | 7.43k | { |
508 | 7.43k | return (ci->options.name); |
509 | 7.43k | } |
510 | | |
511 | | const bool * |
512 | | fido_cbor_info_options_value_ptr(const fido_cbor_info_t *ci) |
513 | 7.43k | { |
514 | 7.43k | return (ci->options.value); |
515 | 7.43k | } |
516 | | |
517 | | size_t |
518 | | fido_cbor_info_options_len(const fido_cbor_info_t *ci) |
519 | 7.59k | { |
520 | 7.59k | return (ci->options.len); |
521 | 7.59k | } |
522 | | |
523 | | uint64_t |
524 | | fido_cbor_info_maxcredbloblen(const fido_cbor_info_t *ci) |
525 | 160 | { |
526 | 160 | return (ci->maxcredbloblen); |
527 | 160 | } |
528 | | |
529 | | uint64_t |
530 | | fido_cbor_info_maxmsgsiz(const fido_cbor_info_t *ci) |
531 | 7.48k | { |
532 | 7.48k | return (ci->maxmsgsiz); |
533 | 7.48k | } |
534 | | |
535 | | uint64_t |
536 | | fido_cbor_info_maxcredcntlst(const fido_cbor_info_t *ci) |
537 | 160 | { |
538 | 160 | return (ci->maxcredcntlst); |
539 | 160 | } |
540 | | |
541 | | uint64_t |
542 | | fido_cbor_info_maxcredidlen(const fido_cbor_info_t *ci) |
543 | 160 | { |
544 | 160 | return (ci->maxcredidlen); |
545 | 160 | } |
546 | | |
547 | | uint64_t |
548 | | fido_cbor_info_maxlargeblob(const fido_cbor_info_t *ci) |
549 | 160 | { |
550 | 160 | return (ci->maxlargeblob); |
551 | 160 | } |
552 | | |
553 | | uint64_t |
554 | | fido_cbor_info_fwversion(const fido_cbor_info_t *ci) |
555 | 160 | { |
556 | 160 | return (ci->fwversion); |
557 | 160 | } |
558 | | |
559 | | uint64_t |
560 | | fido_cbor_info_minpinlen(const fido_cbor_info_t *ci) |
561 | 160 | { |
562 | 160 | return (ci->minpinlen); |
563 | 160 | } |
564 | | |
565 | | uint64_t |
566 | | fido_cbor_info_maxrpid_minpinlen(const fido_cbor_info_t *ci) |
567 | 160 | { |
568 | 160 | return (ci->maxrpid_minlen); |
569 | 160 | } |
570 | | |
571 | | uint64_t |
572 | | fido_cbor_info_uv_attempts(const fido_cbor_info_t *ci) |
573 | 160 | { |
574 | 160 | return (ci->uv_attempts); |
575 | 160 | } |
576 | | |
577 | | uint64_t |
578 | | fido_cbor_info_uv_modality(const fido_cbor_info_t *ci) |
579 | 160 | { |
580 | 160 | return (ci->uv_modality); |
581 | 160 | } |
582 | | |
583 | | int64_t |
584 | | fido_cbor_info_rk_remaining(const fido_cbor_info_t *ci) |
585 | 160 | { |
586 | 160 | return (ci->rk_remaining); |
587 | 160 | } |
588 | | |
589 | | const uint8_t * |
590 | | fido_cbor_info_protocols_ptr(const fido_cbor_info_t *ci) |
591 | 7.48k | { |
592 | 7.48k | return (ci->protocols.ptr); |
593 | 7.48k | } |
594 | | |
595 | | size_t |
596 | | fido_cbor_info_protocols_len(const fido_cbor_info_t *ci) |
597 | 7.48k | { |
598 | 7.48k | return (ci->protocols.len); |
599 | 7.48k | } |
600 | | |
601 | | size_t |
602 | | fido_cbor_info_algorithm_count(const fido_cbor_info_t *ci) |
603 | 353 | { |
604 | 353 | return (ci->algorithms.len); |
605 | 353 | } |
606 | | |
607 | | const char * |
608 | | fido_cbor_info_algorithm_type(const fido_cbor_info_t *ci, size_t idx) |
609 | 193 | { |
610 | 193 | if (idx >= ci->algorithms.len) |
611 | 160 | return (NULL); |
612 | | |
613 | 33 | return (ci->algorithms.ptr[idx].type); |
614 | 193 | } |
615 | | |
616 | | int |
617 | | fido_cbor_info_algorithm_cose(const fido_cbor_info_t *ci, size_t idx) |
618 | 193 | { |
619 | 193 | if (idx >= ci->algorithms.len) |
620 | 160 | return (0); |
621 | | |
622 | 33 | return (ci->algorithms.ptr[idx].cose); |
623 | 193 | } |
624 | | |
625 | | bool |
626 | | fido_cbor_info_new_pin_required(const fido_cbor_info_t *ci) |
627 | 160 | { |
628 | 160 | return (ci->new_pin_reqd); |
629 | 160 | } |
630 | | |
631 | | char ** |
632 | | fido_cbor_info_certs_name_ptr(const fido_cbor_info_t *ci) |
633 | 16 | { |
634 | 16 | return (ci->certs.name); |
635 | 16 | } |
636 | | |
637 | | const uint64_t * |
638 | | fido_cbor_info_certs_value_ptr(const fido_cbor_info_t *ci) |
639 | 16 | { |
640 | 16 | return (ci->certs.value); |
641 | 16 | } |
642 | | |
643 | | size_t |
644 | | fido_cbor_info_certs_len(const fido_cbor_info_t *ci) |
645 | 176 | { |
646 | 176 | return (ci->certs.len); |
647 | 176 | } |