Debian Codegraph @

extra/libfido2/libfido2-1.15.0/src/pin.c

raw
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 <openssl/sha.h>
9 #include "fido.h"
10 #include "fido/es256.h"
11
12 #define CTAP21_UV_TOKEN_PERM_MAKECRED 0x01
13 #define CTAP21_UV_TOKEN_PERM_ASSERT 0x02
14 #define CTAP21_UV_TOKEN_PERM_CRED_MGMT 0x04
15 #define CTAP21_UV_TOKEN_PERM_BIO 0x08
16 #define CTAP21_UV_TOKEN_PERM_LARGEBLOB 0x10
17 #define CTAP21_UV_TOKEN_PERM_CONFIG 0x20
18
19 int
20 fido_sha256(fido_blob_t *digest, const u_char *data, size_t data_len)
21 {
22 if ((digest->ptr = calloc(1, SHA256_DIGEST_LENGTH)) == NULL)
23 return (-1);
24
25 digest->len = SHA256_DIGEST_LENGTH;
26
27 if (SHA256(data, data_len, digest->ptr) != digest->ptr) {
28 fido_blob_reset(digest);
29 return (-1);
30 }
31
32 return (0);
33 }
34
35 static int
36 pin_sha256_enc(const fido_dev_t *dev, const fido_blob_t *shared,
37 const fido_blob_t *pin, fido_blob_t **out)
38 {
39 fido_blob_t *ph = NULL;
40 int r;
41
42 if ((*out = fido_blob_new()) == NULL ||
43 (ph = fido_blob_new()) == NULL) {
44 r = FIDO_ERR_INTERNAL;
45 goto fail;
46 }
47
48 if (fido_sha256(ph, pin->ptr, pin->len) < 0 || ph->len < 16) {
49 fido_log_debug("%s: SHA256", __func__);
50 r = FIDO_ERR_INTERNAL;
51 goto fail;
52 }
53
54 ph->len = 16; /* first 16 bytes */
55
56 if (aes256_cbc_enc(dev, shared, ph, *out) < 0) {
57 fido_log_debug("%s: aes256_cbc_enc", __func__);
58 r = FIDO_ERR_INTERNAL;
59 goto fail;
60 }
61
62 r = FIDO_OK;
63 fail:
64 fido_blob_free(&ph);
65
66 return (r);
67 }
68
69 static int
70 pad64(const char *pin, fido_blob_t **ppin)
71 {
72 size_t pin_len;
73 size_t ppin_len;
74
75 pin_len = strlen(pin);
76 if (pin_len < 4 || pin_len > 63) {
77 fido_log_debug("%s: invalid pin length", __func__);
78 return (FIDO_ERR_PIN_POLICY_VIOLATION);
79 }
80
81 if ((*ppin = fido_blob_new()) == NULL)
82 return (FIDO_ERR_INTERNAL);
83
84 ppin_len = (pin_len + 63U) & ~63U;
85 if (ppin_len < pin_len ||
86 ((*ppin)->ptr = calloc(1, ppin_len)) == NULL) {
87 fido_blob_free(ppin);
88 return (FIDO_ERR_INTERNAL);
89 }
90
91 memcpy((*ppin)->ptr, pin, pin_len);
92 (*ppin)->len = ppin_len;
93
94 return (FIDO_OK);
95 }
96
97 static int
98 pin_pad64_enc(const fido_dev_t *dev, const fido_blob_t *shared,
99 const char *pin, fido_blob_t **out)
100 {
101 fido_blob_t *ppin = NULL;
102 int r;
103
104 if ((r = pad64(pin, &ppin)) != FIDO_OK) {
105 fido_log_debug("%s: pad64", __func__);
106 goto fail;
107 }
108
109 if ((*out = fido_blob_new()) == NULL) {
110 r = FIDO_ERR_INTERNAL;
111 goto fail;
112 }
113
114 if (aes256_cbc_enc(dev, shared, ppin, *out) < 0) {
115 fido_log_debug("%s: aes256_cbc_enc", __func__);
116 r = FIDO_ERR_INTERNAL;
117 goto fail;
118 }
119
120 r = FIDO_OK;
121 fail:
122 fido_blob_free(&ppin);
123
124 return (r);
125 }
126
127 static cbor_item_t *
128 encode_uv_permission(uint8_t cmd)
129 {
130 switch (cmd) {
131 case CTAP_CBOR_ASSERT:
132 return (cbor_build_uint8(CTAP21_UV_TOKEN_PERM_ASSERT));
133 case CTAP_CBOR_BIO_ENROLL_PRE:
134 case CTAP_CBOR_BIO_ENROLL:
135 return (cbor_build_uint8(CTAP21_UV_TOKEN_PERM_BIO));
136 case CTAP_CBOR_CONFIG:
137 return (cbor_build_uint8(CTAP21_UV_TOKEN_PERM_CONFIG));
138 case CTAP_CBOR_MAKECRED:
139 return (cbor_build_uint8(CTAP21_UV_TOKEN_PERM_MAKECRED));
140 case CTAP_CBOR_CRED_MGMT_PRE:
141 case CTAP_CBOR_CRED_MGMT:
142 return (cbor_build_uint8(CTAP21_UV_TOKEN_PERM_CRED_MGMT));
143 case CTAP_CBOR_LARGEBLOB:
144 return (cbor_build_uint8(CTAP21_UV_TOKEN_PERM_LARGEBLOB));
145 default:
146 fido_log_debug("%s: cmd 0x%02x", __func__, cmd);
147 return (NULL);
148 }
149 }
150
151 static int
152 ctap20_uv_token_tx(fido_dev_t *dev, const char *pin, const fido_blob_t *ecdh,
153 const es256_pk_t *pk, int *ms)
154 {
155 fido_blob_t f;
156 fido_blob_t *p = NULL;
157 fido_blob_t *phe = NULL;
158 cbor_item_t *argv[6];
159 int r;
160
161 memset(&f, 0, sizeof(f));
162 memset(argv, 0, sizeof(argv));
163
164 if (pin == NULL) {
165 fido_log_debug("%s: NULL pin", __func__);
166 r = FIDO_ERR_PIN_REQUIRED;
167 goto fail;
168 }
169
170 if ((p = fido_blob_new()) == NULL || fido_blob_set(p,
171 (const unsigned char *)pin, strlen(pin)) < 0) {
172 fido_log_debug("%s: fido_blob_set", __func__);
173 r = FIDO_ERR_INVALID_ARGUMENT;
174 goto fail;
175 }
176
177 if ((r = pin_sha256_enc(dev, ecdh, p, &phe)) != FIDO_OK) {
178 fido_log_debug("%s: pin_sha256_enc", __func__);
179 goto fail;
180 }
181
182 if ((argv[0] = cbor_encode_pin_opt(dev)) == NULL ||
183 (argv[1] = cbor_build_uint8(5)) == NULL ||
184 (argv[2] = es256_pk_encode(pk, 1)) == NULL ||
185 (argv[5] = fido_blob_encode(phe)) == NULL) {
186 fido_log_debug("%s: cbor encode", __func__);
187 r = FIDO_ERR_INTERNAL;
188 goto fail;
189 }
190
191 if (cbor_build_frame(CTAP_CBOR_CLIENT_PIN, argv, nitems(argv),
192 &f) < 0 || fido_tx(dev, CTAP_CMD_CBOR, f.ptr, f.len, ms) < 0) {
193 fido_log_debug("%s: fido_tx", __func__);
194 r = FIDO_ERR_TX;
195 goto fail;
196 }
197
198 r = FIDO_OK;
199 fail:
200 cbor_vector_free(argv, nitems(argv));
201 fido_blob_free(&p);
202 fido_blob_free(&phe);
203 free(f.ptr);
204
205 return (r);
206 }
207
208 static int
209 ctap21_uv_token_tx(fido_dev_t *dev, const char *pin, const fido_blob_t *ecdh,
210 const es256_pk_t *pk, uint8_t cmd, const char *rpid, int *ms)
211 {
212 fido_blob_t f;
213 fido_blob_t *p = NULL;
214 fido_blob_t *phe = NULL;
215 cbor_item_t *argv[10];
216 uint8_t subcmd;
217 int r;
218
219 memset(&f, 0, sizeof(f));
220 memset(argv, 0, sizeof(argv));
221
222 if (pin != NULL) {
223 if ((p = fido_blob_new()) == NULL || fido_blob_set(p,
224 (const unsigned char *)pin, strlen(pin)) < 0) {
225 fido_log_debug("%s: fido_blob_set", __func__);
226 r = FIDO_ERR_INVALID_ARGUMENT;
227 goto fail;
228 }
229 if ((r = pin_sha256_enc(dev, ecdh, p, &phe)) != FIDO_OK) {
230 fido_log_debug("%s: pin_sha256_enc", __func__);
231 goto fail;
232 }
233 subcmd = 9; /* getPinUvAuthTokenUsingPinWithPermissions */
234 } else {
235 if (fido_dev_has_uv(dev) == false) {
236 fido_log_debug("%s: fido_dev_has_uv", __func__);
237 r = FIDO_ERR_PIN_REQUIRED;
238 goto fail;
239 }
240 subcmd = 6; /* getPinUvAuthTokenUsingUvWithPermissions */
241 }
242
243 if ((argv[0] = cbor_encode_pin_opt(dev)) == NULL ||
244 (argv[1] = cbor_build_uint8(subcmd)) == NULL ||
245 (argv[2] = es256_pk_encode(pk, 1)) == NULL ||
246 (phe != NULL && (argv[5] = fido_blob_encode(phe)) == NULL) ||
247 (argv[8] = encode_uv_permission(cmd)) == NULL ||
248 (rpid != NULL && (argv[9] = cbor_build_string(rpid)) == NULL)) {
249 fido_log_debug("%s: cbor encode", __func__);
250 r = FIDO_ERR_INTERNAL;
251 goto fail;
252 }
253
254 if (cbor_build_frame(CTAP_CBOR_CLIENT_PIN, argv, nitems(argv),
255 &f) < 0 || fido_tx(dev, CTAP_CMD_CBOR, f.ptr, f.len, ms) < 0) {
256 fido_log_debug("%s: fido_tx", __func__);
257 r = FIDO_ERR_TX;
258 goto fail;
259 }
260
261 r = FIDO_OK;
262 fail:
263 cbor_vector_free(argv, nitems(argv));
264 fido_blob_free(&p);
265 fido_blob_free(&phe);
266 free(f.ptr);
267
268 return (r);
269 }
270
271 static int
272 parse_uv_token(const cbor_item_t *key, const cbor_item_t *val, void *arg)
273 {
274 fido_blob_t *token = arg;
275
276 if (cbor_isa_uint(key) == false ||
277 cbor_int_get_width(key) != CBOR_INT_8 ||
278 cbor_get_uint8(key) != 2) {
279 fido_log_debug("%s: cbor type", __func__);
280 return (0); /* ignore */
281 }
282
283 return (fido_blob_decode(val, token));
284 }
285
286 static int
287 uv_token_rx(fido_dev_t *dev, const fido_blob_t *ecdh, fido_blob_t *token,
288 int *ms)
289 {
290 fido_blob_t *aes_token = NULL;
291 unsigned char *msg = NULL;
292 int msglen;
293 int r;
294
295 if ((aes_token = fido_blob_new()) == NULL) {
296 r = FIDO_ERR_INTERNAL;
297 goto fail;
298 }
299
300 if ((msg = malloc(FIDO_MAXMSG)) == NULL) {
301 r = FIDO_ERR_INTERNAL;
302 goto fail;
303 }
304
305 if ((msglen = fido_rx(dev, CTAP_CMD_CBOR, msg, FIDO_MAXMSG, ms)) < 0) {
306 fido_log_debug("%s: fido_rx", __func__);
307 r = FIDO_ERR_RX;
308 goto fail;
309 }
310
311 if ((r = cbor_parse_reply(msg, (size_t)msglen, aes_token,
312 parse_uv_token)) != FIDO_OK) {
313 fido_log_debug("%s: parse_uv_token", __func__);
314 goto fail;
315 }
316
317 if (aes256_cbc_dec(dev, ecdh, aes_token, token) < 0) {
318 fido_log_debug("%s: aes256_cbc_dec", __func__);
319 r = FIDO_ERR_RX;
320 goto fail;
321 }
322
323 r = FIDO_OK;
324 fail:
325 fido_blob_free(&aes_token);
326 freezero(msg, FIDO_MAXMSG);
327
328 return (r);
329 }
330
331 static int
332 uv_token_wait(fido_dev_t *dev, uint8_t cmd, const char *pin,
333 const fido_blob_t *ecdh, const es256_pk_t *pk, const char *rpid,
334 fido_blob_t *token, int *ms)
335 {
336 int r;
337
338 if (ecdh == NULL || pk == NULL)
339 return (FIDO_ERR_INVALID_ARGUMENT);
340 if (fido_dev_supports_permissions(dev))
341 r = ctap21_uv_token_tx(dev, pin, ecdh, pk, cmd, rpid, ms);
342 else
343 r = ctap20_uv_token_tx(dev, pin, ecdh, pk, ms);
344 if (r != FIDO_OK)
345 return (r);
346
347 return (uv_token_rx(dev, ecdh, token, ms));
348 }
349
350 int
351 fido_dev_get_uv_token(fido_dev_t *dev, uint8_t cmd, const char *pin,
352 const fido_blob_t *ecdh, const es256_pk_t *pk, const char *rpid,
353 fido_blob_t *token, int *ms)
354 {
355 return (uv_token_wait(dev, cmd, pin, ecdh, pk, rpid, token, ms));
356 }
357
358 static int
359 fido_dev_change_pin_tx(fido_dev_t *dev, const char *pin, const char *oldpin,
360 int *ms)
361 {
362 fido_blob_t f;
363 fido_blob_t *ppine = NULL;
364 fido_blob_t *ecdh = NULL;
365 fido_blob_t *opin = NULL;
366 fido_blob_t *opinhe = NULL;
367 cbor_item_t *argv[6];
368 es256_pk_t *pk = NULL;
369 int r;
370
371 memset(&f, 0, sizeof(f));
372 memset(argv, 0, sizeof(argv));
373
374 if ((opin = fido_blob_new()) == NULL || fido_blob_set(opin,
375 (const unsigned char *)oldpin, strlen(oldpin)) < 0) {
376 fido_log_debug("%s: fido_blob_set", __func__);
377 r = FIDO_ERR_INVALID_ARGUMENT;
378 goto fail;
379 }
380
381 if ((r = fido_do_ecdh(dev, &pk, &ecdh, ms)) != FIDO_OK) {
382 fido_log_debug("%s: fido_do_ecdh", __func__);
383 goto fail;
384 }
385
386 /* pad and encrypt new pin */
387 if ((r = pin_pad64_enc(dev, ecdh, pin, &ppine)) != FIDO_OK) {
388 fido_log_debug("%s: pin_pad64_enc", __func__);
389 goto fail;
390 }
391
392 /* hash and encrypt old pin */
393 if ((r = pin_sha256_enc(dev, ecdh, opin, &opinhe)) != FIDO_OK) {
394 fido_log_debug("%s: pin_sha256_enc", __func__);
395 goto fail;
396 }
397
398 if ((argv[0] = cbor_encode_pin_opt(dev)) == NULL ||
399 (argv[1] = cbor_build_uint8(4)) == NULL ||
400 (argv[2] = es256_pk_encode(pk, 1)) == NULL ||
401 (argv[3] = cbor_encode_change_pin_auth(dev, ecdh, ppine, opinhe)) == NULL ||
402 (argv[4] = fido_blob_encode(ppine)) == NULL ||
403 (argv[5] = fido_blob_encode(opinhe)) == NULL) {
404 fido_log_debug("%s: cbor encode", __func__);
405 r = FIDO_ERR_INTERNAL;
406 goto fail;
407 }
408
409 if (cbor_build_frame(CTAP_CBOR_CLIENT_PIN, argv, nitems(argv),
410 &f) < 0 || fido_tx(dev, CTAP_CMD_CBOR, f.ptr, f.len, ms) < 0) {
411 fido_log_debug("%s: fido_tx", __func__);
412 r = FIDO_ERR_TX;
413 goto fail;
414 }
415
416 r = FIDO_OK;
417 fail:
418 cbor_vector_free(argv, nitems(argv));
419 es256_pk_free(&pk);
420 fido_blob_free(&ppine);
421 fido_blob_free(&ecdh);
422 fido_blob_free(&opin);
423 fido_blob_free(&opinhe);
424 free(f.ptr);
425
426 return (r);
427
428 }
429
430 static int
431 fido_dev_set_pin_tx(fido_dev_t *dev, const char *pin, int *ms)
432 {
433 fido_blob_t f;
434 fido_blob_t *ppine = NULL;
435 fido_blob_t *ecdh = NULL;
436 cbor_item_t *argv[5];
437 es256_pk_t *pk = NULL;
438 int r;
439
440 memset(&f, 0, sizeof(f));
441 memset(argv, 0, sizeof(argv));
442
443 if ((r = fido_do_ecdh(dev, &pk, &ecdh, ms)) != FIDO_OK) {
444 fido_log_debug("%s: fido_do_ecdh", __func__);
445 goto fail;
446 }
447
448 if ((r = pin_pad64_enc(dev, ecdh, pin, &ppine)) != FIDO_OK) {
449 fido_log_debug("%s: pin_pad64_enc", __func__);
450 goto fail;
451 }
452
453 if ((argv[0] = cbor_encode_pin_opt(dev)) == NULL ||
454 (argv[1] = cbor_build_uint8(3)) == NULL ||
455 (argv[2] = es256_pk_encode(pk, 1)) == NULL ||
456 (argv[3] = cbor_encode_pin_auth(dev, ecdh, ppine)) == NULL ||
457 (argv[4] = fido_blob_encode(ppine)) == NULL) {
458 fido_log_debug("%s: cbor encode", __func__);
459 r = FIDO_ERR_INTERNAL;
460 goto fail;
461 }
462
463 if (cbor_build_frame(CTAP_CBOR_CLIENT_PIN, argv, nitems(argv),
464 &f) < 0 || fido_tx(dev, CTAP_CMD_CBOR, f.ptr, f.len, ms) < 0) {
465 fido_log_debug("%s: fido_tx", __func__);
466 r = FIDO_ERR_TX;
467 goto fail;
468 }
469
470 r = FIDO_OK;
471 fail:
472 cbor_vector_free(argv, nitems(argv));
473 es256_pk_free(&pk);
474 fido_blob_free(&ppine);
475 fido_blob_free(&ecdh);
476 free(f.ptr);
477
478 return (r);
479 }
480
481 static int
482 fido_dev_set_pin_wait(fido_dev_t *dev, const char *pin, const char *oldpin,
483 int *ms)
484 {
485 int r;
486
487 if (oldpin != NULL) {
488 if ((r = fido_dev_change_pin_tx(dev, pin, oldpin,
489 ms)) != FIDO_OK) {
490 fido_log_debug("%s: fido_dev_change_pin_tx", __func__);
491 return (r);
492 }
493 } else {
494 if ((r = fido_dev_set_pin_tx(dev, pin, ms)) != FIDO_OK) {
495 fido_log_debug("%s: fido_dev_set_pin_tx", __func__);
496 return (r);
497 }
498 }
499
500 if ((r = fido_rx_cbor_status(dev, ms)) != FIDO_OK) {
501 fido_log_debug("%s: fido_rx_cbor_status", __func__);
502 return (r);
503 }
504
505 if (dev->flags & FIDO_DEV_PIN_UNSET) {
506 dev->flags &= ~FIDO_DEV_PIN_UNSET;
507 dev->flags |= FIDO_DEV_PIN_SET;
508 }
509
510 return (FIDO_OK);
511 }
512
513 int
514 fido_dev_set_pin(fido_dev_t *dev, const char *pin, const char *oldpin)
515 {
516 int ms = dev->timeout_ms;
517
518 return (fido_dev_set_pin_wait(dev, pin, oldpin, &ms));
519 }
520
521 static int
522 parse_retry_count(const uint8_t keyval, const cbor_item_t *key,
523 const cbor_item_t *val, void *arg)
524 {
525 int *retries = arg;
526 uint64_t n;
527
528 if (cbor_isa_uint(key) == false ||
529 cbor_int_get_width(key) != CBOR_INT_8 ||
530 cbor_get_uint8(key) != keyval) {
531 fido_log_debug("%s: cbor type", __func__);
532 return (0); /* ignore */
533 }
534
535 if (cbor_decode_uint64(val, &n) < 0 || n > INT_MAX) {
536 fido_log_debug("%s: cbor_decode_uint64", __func__);
537 return (-1);
538 }
539
540 *retries = (int)n;
541
542 return (0);
543 }
544
545 static int
546 parse_pin_retry_count(const cbor_item_t *key, const cbor_item_t *val, void *arg)
547 {
548 return (parse_retry_count(3, key, val, arg));
549 }
550
551 static int
552 parse_uv_retry_count(const cbor_item_t *key, const cbor_item_t *val, void *arg)
553 {
554 return (parse_retry_count(5, key, val, arg));
555 }
556
557 static int
558 fido_dev_get_retry_count_tx(fido_dev_t *dev, uint8_t subcmd, int *ms)
559 {
560 fido_blob_t f;
561 cbor_item_t *argv[2];
562 int r;
563
564 memset(&f, 0, sizeof(f));
565 memset(argv, 0, sizeof(argv));
566
567 if ((argv[0] = cbor_build_uint8(1)) == NULL ||
568 (argv[1] = cbor_build_uint8(subcmd)) == NULL) {
569 r = FIDO_ERR_INTERNAL;
570 goto fail;
571 }
572
573 if (cbor_build_frame(CTAP_CBOR_CLIENT_PIN, argv, nitems(argv),
574 &f) < 0 || fido_tx(dev, CTAP_CMD_CBOR, f.ptr, f.len, ms) < 0) {
575 fido_log_debug("%s: fido_tx", __func__);
576 r = FIDO_ERR_TX;
577 goto fail;
578 }
579
580 r = FIDO_OK;
581 fail:
582 cbor_vector_free(argv, nitems(argv));
583 free(f.ptr);
584
585 return (r);
586 }
587
588 static int
589 fido_dev_get_pin_retry_count_rx(fido_dev_t *dev, int *retries, int *ms)
590 {
591 unsigned char *msg;
592 int msglen;
593 int r;
594
595 *retries = 0;
596
597 if ((msg = malloc(FIDO_MAXMSG)) == NULL) {
598 r = FIDO_ERR_INTERNAL;
599 goto fail;
600 }
601
602 if ((msglen = fido_rx(dev, CTAP_CMD_CBOR, msg, FIDO_MAXMSG, ms)) < 0) {
603 fido_log_debug("%s: fido_rx", __func__);
604 r = FIDO_ERR_RX;
605 goto fail;
606 }
607
608 if ((r = cbor_parse_reply(msg, (size_t)msglen, retries,
609 parse_pin_retry_count)) != FIDO_OK) {
610 fido_log_debug("%s: parse_pin_retry_count", __func__);
611 goto fail;
612 }
613
614 r = FIDO_OK;
615 fail:
616 freezero(msg, FIDO_MAXMSG);
617
618 return (r);
619 }
620
621 static int
622 fido_dev_get_pin_retry_count_wait(fido_dev_t *dev, int *retries, int *ms)
623 {
624 int r;
625
626 if ((r = fido_dev_get_retry_count_tx(dev, 1, ms)) != FIDO_OK ||
627 (r = fido_dev_get_pin_retry_count_rx(dev, retries, ms)) != FIDO_OK)
628 return (r);
629
630 return (FIDO_OK);
631 }
632
633 int
634 fido_dev_get_retry_count(fido_dev_t *dev, int *retries)
635 {
636 int ms = dev->timeout_ms;
637
638 return (fido_dev_get_pin_retry_count_wait(dev, retries, &ms));
639 }
640
641 static int
642 fido_dev_get_uv_retry_count_rx(fido_dev_t *dev, int *retries, int *ms)
643 {
644 unsigned char *msg;
645 int msglen;
646 int r;
647
648 *retries = 0;
649
650 if ((msg = malloc(FIDO_MAXMSG)) == NULL) {
651 r = FIDO_ERR_INTERNAL;
652 goto fail;
653 }
654
655 if ((msglen = fido_rx(dev, CTAP_CMD_CBOR, msg, FIDO_MAXMSG, ms)) < 0) {
656 fido_log_debug("%s: fido_rx", __func__);
657 r = FIDO_ERR_RX;
658 goto fail;
659 }
660
661 if ((r = cbor_parse_reply(msg, (size_t)msglen, retries,
662 parse_uv_retry_count)) != FIDO_OK) {
663 fido_log_debug("%s: parse_uv_retry_count", __func__);
664 goto fail;
665 }
666
667 r = FIDO_OK;
668 fail:
669 freezero(msg, FIDO_MAXMSG);
670
671 return (r);
672 }
673
674 static int
675 fido_dev_get_uv_retry_count_wait(fido_dev_t *dev, int *retries, int *ms)
676 {
677 int r;
678
679 if ((r = fido_dev_get_retry_count_tx(dev, 7, ms)) != FIDO_OK ||
680 (r = fido_dev_get_uv_retry_count_rx(dev, retries, ms)) != FIDO_OK)
681 return (r);
682
683 return (FIDO_OK);
684 }
685
686 int
687 fido_dev_get_uv_retry_count(fido_dev_t *dev, int *retries)
688 {
689 int ms = dev->timeout_ms;
690
691 return (fido_dev_get_uv_retry_count_wait(dev, retries, &ms));
692 }
693
694 int
695 cbor_add_uv_params(fido_dev_t *dev, uint8_t cmd, const fido_blob_t *hmac_data,
696 const es256_pk_t *pk, const fido_blob_t *ecdh, const char *pin,
697 const char *rpid, cbor_item_t **auth, cbor_item_t **opt, int *ms)
698 {
699 fido_blob_t *token = NULL;
700 int r;
701
702 if ((token = fido_blob_new()) == NULL) {
703 r = FIDO_ERR_INTERNAL;
704 goto fail;
705 }
706
707 if ((r = fido_dev_get_uv_token(dev, cmd, pin, ecdh, pk, rpid,
708 token, ms)) != FIDO_OK) {
709 fido_log_debug("%s: fido_dev_get_uv_token", __func__);
710 goto fail;
711 }
712
713 if ((*auth = cbor_encode_pin_auth(dev, token, hmac_data)) == NULL ||
714 (*opt = cbor_encode_pin_opt(dev)) == NULL) {
715 fido_log_debug("%s: cbor encode", __func__);
716 r = FIDO_ERR_INTERNAL;
717 goto fail;
718 }
719
720 r = FIDO_OK;
721 fail:
722 fido_blob_free(&token);
723
724 return (r);
725 }