Debian Codegraph @

src/credman.c

raw
1 /*
2 * Copyright (c) 2019-2026 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
10 #include "fido.h"
11 #include "fido/credman.h"
12 #include "fido/es256.h"
13
14 #define CMD_CRED_METADATA 0x01
15 #define CMD_RP_BEGIN 0x02
16 #define CMD_RP_NEXT 0x03
17 #define CMD_RK_BEGIN 0x04
18 #define CMD_RK_NEXT 0x05
19 #define CMD_DELETE_CRED 0x06
20 #define CMD_UPDATE_CRED 0x07
21
22 static int
23 credman_grow_array(void **ptr, size_t *n_alloc, const size_t *n_rx, size_t n,
24 size_t size)
25 {
26 void *new_ptr;
27
28 #ifdef FIDO_FUZZ
29 if (n > UINT8_MAX) {
30 fido_log_debug("%s: n > UINT8_MAX", __func__);
31 return (-1);
32 }
33 #endif
34
35 if (n < *n_alloc)
36 return (0);
37
38 /* sanity check */
39 if (*n_rx > 0 || *n_rx > *n_alloc || n < *n_alloc) {
40 fido_log_debug("%s: n=%zu, n_rx=%zu, n_alloc=%zu", __func__, n,
41 *n_rx, *n_alloc);
42 return (-1);
43 }
44
45 if ((new_ptr = recallocarray(*ptr, *n_alloc, n, size)) == NULL)
46 return (-1);
47
48 *ptr = new_ptr;
49 *n_alloc = n;
50
51 return (0);
52 }
53
54 static int
55 credman_prepare_hmac(uint8_t cmd, const void *body, cbor_item_t **param,
56 fido_blob_t *hmac_data)
57 {
58 cbor_item_t *param_cbor[3];
59 const fido_cred_t *cred;
60 size_t n;
61 int ok = -1;
62
63 memset(&param_cbor, 0, sizeof(param_cbor));
64
65 if (body == NULL)
66 return (fido_blob_set(hmac_data, &cmd, sizeof(cmd)));
67
68 switch (cmd) {
69 case CMD_RK_BEGIN:
70 n = 1;
71 if ((param_cbor[0] = fido_blob_encode(body)) == NULL) {
72 fido_log_debug("%s: cbor encode", __func__);
73 goto fail;
74 }
75 break;
76 case CMD_DELETE_CRED:
77 n = 2;
78 if ((param_cbor[1] = cbor_encode_pubkey(body)) == NULL) {
79 fido_log_debug("%s: cbor encode", __func__);
80 goto fail;
81 }
82 break;
83 case CMD_UPDATE_CRED:
84 n = 3;
85 cred = body;
86 param_cbor[1] = cbor_encode_pubkey(&cred->attcred.id);
87 param_cbor[2] = cbor_encode_user_entity(&cred->user);
88 if (param_cbor[1] == NULL || param_cbor[2] == NULL) {
89 fido_log_debug("%s: cbor encode", __func__);
90 goto fail;
91 }
92 break;
93 default:
94 fido_log_debug("%s: unknown cmd=0x%02x", __func__, cmd);
95 return (-1);
96 }
97
98 if ((*param = cbor_flatten_vector(param_cbor, n)) == NULL) {
99 fido_log_debug("%s: cbor_flatten_vector", __func__);
100 goto fail;
101 }
102 if (cbor_build_frame(cmd, param_cbor, n, hmac_data) < 0) {
103 fido_log_debug("%s: cbor_build_frame", __func__);
104 goto fail;
105 }
106
107 ok = 0;
108 fail:
109 cbor_vector_free(param_cbor, nitems(param_cbor));
110
111 return (ok);
112 }
113
114 static uint8_t
115 credman_get_cmd(const fido_dev_t *dev)
116 {
117 if (dev->flags & FIDO_DEV_CREDMAN)
118 return (CTAP_CBOR_CRED_MGMT);
119
120 return (CTAP_CBOR_CRED_MGMT_PRE);
121 }
122
123 static int
124 credman_tx(fido_dev_t *dev, uint8_t subcmd, const void *param, const char *pin,
125 const char *rp_id, fido_opt_t uv, int *ms)
126 {
127 fido_blob_t f;
128 fido_blob_t *ecdh = NULL;
129 fido_blob_t hmac;
130 es256_pk_t *pk = NULL;
131 cbor_item_t *argv[4];
132 const uint8_t cmd = credman_get_cmd(dev);
133 int r = FIDO_ERR_INTERNAL;
134
135 memset(&f, 0, sizeof(f));
136 memset(&hmac, 0, sizeof(hmac));
137 memset(&argv, 0, sizeof(argv));
138
139 if (fido_dev_is_fido2(dev) == false) {
140 fido_log_debug("%s: fido_dev_is_fido2", __func__);
141 r = FIDO_ERR_INVALID_COMMAND;
142 goto fail;
143 }
144
145 /* subCommand */
146 if ((argv[0] = cbor_build_uint8(subcmd)) == NULL) {
147 fido_log_debug("%s: cbor encode", __func__);
148 goto fail;
149 }
150
151 /* pinProtocol, pinAuth */
152 if (pin != NULL || fido_dev_puat_blob(dev) != NULL ||
153 uv == FIDO_OPT_TRUE) {
154 if (credman_prepare_hmac(subcmd, param, &argv[1], &hmac) < 0) {
155 fido_log_debug("%s: credman_prepare_hmac", __func__);
156 goto fail;
157 }
158
159 if (fido_dev_puat_blob(dev) == NULL) {
160 if ((r = fido_do_ecdh(dev, &pk, &ecdh, ms)) != FIDO_OK) {
161 fido_log_debug("%s: fido_do_ecdh", __func__);
162 goto fail;
163 }
164 }
165 if ((r = cbor_add_uv_params(dev, cmd, &hmac, pk, ecdh, pin,
166 rp_id, &argv[3], &argv[2], ms)) != FIDO_OK) {
167 fido_log_debug("%s: cbor_add_uv_params", __func__);
168 goto fail;
169 }
170 }
171
172 /* framing and transmission */
173 if (cbor_build_frame(cmd, argv, nitems(argv), &f) < 0 ||
174 fido_tx(dev, CTAP_CMD_CBOR, f.ptr, f.len, ms) < 0) {
175 fido_log_debug("%s: fido_tx", __func__);
176 r = FIDO_ERR_TX;
177 goto fail;
178 }
179
180 r = FIDO_OK;
181 fail:
182 es256_pk_free(&pk);
183 fido_blob_free(&ecdh);
184 cbor_vector_free(argv, nitems(argv));
185 free(f.ptr);
186 free(hmac.ptr);
187
188 return (r);
189 }
190
191 static int
192 credman_parse_metadata(const cbor_item_t *key, const cbor_item_t *val,
193 void *arg)
194 {
195 fido_credman_metadata_t *metadata = arg;
196
197 if (cbor_isa_uint(key) == false ||
198 cbor_int_get_width(key) != CBOR_INT_8) {
199 fido_log_debug("%s: cbor type", __func__);
200 return (0); /* ignore */
201 }
202
203 switch (cbor_get_uint8(key)) {
204 case 1:
205 return (cbor_decode_uint64(val, &metadata->rk_existing));
206 case 2:
207 return (cbor_decode_uint64(val, &metadata->rk_remaining));
208 default:
209 fido_log_debug("%s: cbor type", __func__);
210 return (0); /* ignore */
211 }
212 }
213
214 static int
215 credman_rx_metadata(fido_dev_t *dev, fido_credman_metadata_t *metadata, int *ms)
216 {
217 unsigned char *msg;
218 int msglen;
219 int r;
220
221 memset(metadata, 0, sizeof(*metadata));
222
223 if ((msg = malloc(FIDO_MAXMSG)) == NULL) {
224 r = FIDO_ERR_INTERNAL;
225 goto out;
226 }
227
228 if ((msglen = fido_rx(dev, CTAP_CMD_CBOR, msg, FIDO_MAXMSG, ms)) < 0) {
229 fido_log_debug("%s: fido_rx", __func__);
230 r = FIDO_ERR_RX;
231 goto out;
232 }
233
234 if ((r = cbor_parse_reply(msg, (size_t)msglen, metadata,
235 credman_parse_metadata)) != FIDO_OK) {
236 fido_log_debug("%s: credman_parse_metadata", __func__);
237 goto out;
238 }
239
240 r = FIDO_OK;
241 out:
242 freezero(msg, FIDO_MAXMSG);
243
244 return (r);
245 }
246
247 static int
248 credman_get_metadata_wait(fido_dev_t *dev, fido_credman_metadata_t *metadata,
249 const char *pin, int *ms)
250 {
251 int r;
252
253 if ((r = credman_tx(dev, CMD_CRED_METADATA, NULL, pin, NULL,
254 FIDO_OPT_TRUE, ms)) != FIDO_OK ||
255 (r = credman_rx_metadata(dev, metadata, ms)) != FIDO_OK)
256 return (r);
257
258 return (FIDO_OK);
259 }
260
261 int
262 fido_credman_get_dev_metadata(fido_dev_t *dev, fido_credman_metadata_t *metadata,
263 const char *pin)
264 {
265 int ms = dev->timeout_ms;
266
267 return (credman_get_metadata_wait(dev, metadata, pin, &ms));
268 }
269
270 static int
271 credman_parse_rk(const cbor_item_t *key, const cbor_item_t *val, void *arg)
272 {
273 fido_cred_t *cred = arg;
274 uint64_t prot;
275
276 if (cbor_isa_uint(key) == false ||
277 cbor_int_get_width(key) != CBOR_INT_8) {
278 fido_log_debug("%s: cbor type", __func__);
279 return (0); /* ignore */
280 }
281
282 switch (cbor_get_uint8(key)) {
283 case 6:
284 return (cbor_decode_user(val, &cred->user));
285 case 7:
286 return (cbor_decode_cred_id(val, &cred->attcred.id));
287 case 8:
288 if (cbor_decode_pubkey(val, &cred->attcred.type,
289 &cred->attcred.pubkey) < 0)
290 return (-1);
291 cred->type = cred->attcred.type; /* XXX */
292 return (0);
293 case 10:
294 if (cbor_decode_uint64(val, &prot) < 0 || prot > INT_MAX ||
295 fido_cred_set_prot(cred, (int)prot) != FIDO_OK)
296 return (-1);
297 return (0);
298 case 11:
299 return (fido_blob_decode(val, &cred->largeblob_key));
300 case 12:
301 if (cbor_decode_bool(val, NULL) < 0)
302 return (-1);
303 if (cbor_ctrl_value(val) == CBOR_CTRL_TRUE)
304 cred->ext.attr.mask |= FIDO_EXT_PAYMENT;
305 return (0);
306 default:
307 fido_log_debug("%s: cbor type", __func__);
308 return (0); /* ignore */
309 }
310 }
311
312 static void
313 credman_reset_rk(fido_credman_rk_t *rk)
314 {
315 for (size_t i = 0; i < rk->n_alloc; i++) {
316 fido_cred_reset_tx(&rk->ptr[i]);
317 fido_cred_reset_rx(&rk->ptr[i]);
318 }
319
320 free(rk->ptr);
321 rk->ptr = NULL;
322 memset(rk, 0, sizeof(*rk));
323 }
324
325 static int
326 credman_parse_rk_count(const cbor_item_t *key, const cbor_item_t *val,
327 void *arg)
328 {
329 fido_credman_rk_t *rk = arg;
330 uint64_t n;
331
332 /* totalCredentials */
333 if (cbor_isa_uint(key) == false ||
334 cbor_int_get_width(key) != CBOR_INT_8 ||
335 cbor_get_uint8(key) != 9) {
336 fido_log_debug("%s: cbor_type", __func__);
337 return (0); /* ignore */
338 }
339
340 if (cbor_decode_uint64(val, &n) < 0 || n > SIZE_MAX) {
341 fido_log_debug("%s: cbor_decode_uint64", __func__);
342 return (-1);
343 }
344
345 if (credman_grow_array((void **)&rk->ptr, &rk->n_alloc, &rk->n_rx,
346 (size_t)n, sizeof(*rk->ptr)) < 0) {
347 fido_log_debug("%s: credman_grow_array", __func__);
348 return (-1);
349 }
350
351 return (0);
352 }
353
354 static int
355 credman_rx_rk(fido_dev_t *dev, fido_credman_rk_t *rk, int *ms)
356 {
357 unsigned char *msg;
358 int msglen;
359 int r;
360
361 credman_reset_rk(rk);
362
363 if ((msg = malloc(FIDO_MAXMSG)) == NULL) {
364 r = FIDO_ERR_INTERNAL;
365 goto out;
366 }
367
368 if ((msglen = fido_rx(dev, CTAP_CMD_CBOR, msg, FIDO_MAXMSG, ms)) < 0) {
369 fido_log_debug("%s: fido_rx", __func__);
370 r = FIDO_ERR_RX;
371 goto out;
372 }
373
374 /* adjust as needed */
375 if ((r = cbor_parse_reply(msg, (size_t)msglen, rk,
376 credman_parse_rk_count)) != FIDO_OK) {
377 fido_log_debug("%s: credman_parse_rk_count", __func__);
378 goto out;
379 }
380
381 if (rk->n_alloc == 0) {
382 fido_log_debug("%s: n_alloc=0", __func__);
383 r = FIDO_OK;
384 goto out;
385 }
386
387 /* parse the first rk */
388 if ((r = cbor_parse_reply(msg, (size_t)msglen, &rk->ptr[0],
389 credman_parse_rk)) != FIDO_OK) {
390 fido_log_debug("%s: credman_parse_rk", __func__);
391 goto out;
392 }
393 rk->n_rx = 1;
394
395 r = FIDO_OK;
396 out:
397 freezero(msg, FIDO_MAXMSG);
398
399 return (r);
400 }
401
402 static int
403 credman_rx_next_rk(fido_dev_t *dev, fido_credman_rk_t *rk, int *ms)
404 {
405 unsigned char *msg;
406 int msglen;
407 int r;
408
409 if ((msg = malloc(FIDO_MAXMSG)) == NULL) {
410 r = FIDO_ERR_INTERNAL;
411 goto out;
412 }
413
414 if ((msglen = fido_rx(dev, CTAP_CMD_CBOR, msg, FIDO_MAXMSG, ms)) < 0) {
415 fido_log_debug("%s: fido_rx", __func__);
416 r = FIDO_ERR_RX;
417 goto out;
418 }
419
420 /* sanity check */
421 if (rk->n_rx >= rk->n_alloc) {
422 fido_log_debug("%s: n_rx=%zu, n_alloc=%zu", __func__, rk->n_rx,
423 rk->n_alloc);
424 r = FIDO_ERR_INTERNAL;
425 goto out;
426 }
427
428 if ((r = cbor_parse_reply(msg, (size_t)msglen, &rk->ptr[rk->n_rx],
429 credman_parse_rk)) != FIDO_OK) {
430 fido_log_debug("%s: credman_parse_rk", __func__);
431 goto out;
432 }
433
434 r = FIDO_OK;
435 out:
436 freezero(msg, FIDO_MAXMSG);
437
438 return (r);
439 }
440
441 static int
442 credman_get_rk_wait(fido_dev_t *dev, const char *rp_id, fido_credman_rk_t *rk,
443 const char *pin, int *ms)
444 {
445 fido_blob_t rp_dgst;
446 uint8_t dgst[SHA256_DIGEST_LENGTH];
447 int r;
448
449 if (SHA256((const unsigned char *)rp_id, strlen(rp_id), dgst) != dgst) {
450 fido_log_debug("%s: sha256", __func__);
451 return (FIDO_ERR_INTERNAL);
452 }
453
454 rp_dgst.ptr = dgst;
455 rp_dgst.len = sizeof(dgst);
456
457 if ((r = credman_tx(dev, CMD_RK_BEGIN, &rp_dgst, pin, rp_id,
458 FIDO_OPT_TRUE, ms)) != FIDO_OK ||
459 (r = credman_rx_rk(dev, rk, ms)) != FIDO_OK)
460 return (r);
461
462 while (rk->n_rx < rk->n_alloc) {
463 if ((r = credman_tx(dev, CMD_RK_NEXT, NULL, NULL, NULL,
464 FIDO_OPT_FALSE, ms)) != FIDO_OK ||
465 (r = credman_rx_next_rk(dev, rk, ms)) != FIDO_OK)
466 return (r);
467 rk->n_rx++;
468 }
469
470 return (FIDO_OK);
471 }
472
473 int
474 fido_credman_get_dev_rk(fido_dev_t *dev, const char *rp_id,
475 fido_credman_rk_t *rk, const char *pin)
476 {
477 int ms = dev->timeout_ms;
478
479 return (credman_get_rk_wait(dev, rp_id, rk, pin, &ms));
480 }
481
482 static int
483 credman_del_rk_wait(fido_dev_t *dev, const unsigned char *cred_id,
484 size_t cred_id_len, const char *pin, int *ms)
485 {
486 fido_blob_t cred;
487 int r;
488
489 memset(&cred, 0, sizeof(cred));
490
491 if (fido_blob_set(&cred, cred_id, cred_id_len) < 0)
492 return (FIDO_ERR_INVALID_ARGUMENT);
493
494 if ((r = credman_tx(dev, CMD_DELETE_CRED, &cred, pin, NULL,
495 FIDO_OPT_TRUE, ms)) != FIDO_OK ||
496 (r = fido_rx_cbor_status(dev, ms)) != FIDO_OK)
497 goto fail;
498
499 r = FIDO_OK;
500 fail:
501 free(cred.ptr);
502
503 return (r);
504 }
505
506 int
507 fido_credman_del_dev_rk(fido_dev_t *dev, const unsigned char *cred_id,
508 size_t cred_id_len, const char *pin)
509 {
510 int ms = dev->timeout_ms;
511
512 return (credman_del_rk_wait(dev, cred_id, cred_id_len, pin, &ms));
513 }
514
515 static int
516 credman_parse_rp(const cbor_item_t *key, const cbor_item_t *val, void *arg)
517 {
518 struct fido_credman_single_rp *rp = arg;
519
520 if (cbor_isa_uint(key) == false ||
521 cbor_int_get_width(key) != CBOR_INT_8) {
522 fido_log_debug("%s: cbor type", __func__);
523 return (0); /* ignore */
524 }
525
526 switch (cbor_get_uint8(key)) {
527 case 3:
528 return (cbor_decode_rp_entity(val, &rp->rp_entity));
529 case 4:
530 return (fido_blob_decode(val, &rp->rp_id_hash));
531 default:
532 fido_log_debug("%s: cbor type", __func__);
533 return (0); /* ignore */
534 }
535 }
536
537 static void
538 credman_reset_rp(fido_credman_rp_t *rp)
539 {
540 for (size_t i = 0; i < rp->n_alloc; i++) {
541 free(rp->ptr[i].rp_entity.id);
542 free(rp->ptr[i].rp_entity.name);
543 rp->ptr[i].rp_entity.id = NULL;
544 rp->ptr[i].rp_entity.name = NULL;
545 fido_blob_reset(&rp->ptr[i].rp_id_hash);
546 }
547
548 free(rp->ptr);
549 rp->ptr = NULL;
550 memset(rp, 0, sizeof(*rp));
551 }
552
553 static int
554 credman_parse_rp_count(const cbor_item_t *key, const cbor_item_t *val,
555 void *arg)
556 {
557 fido_credman_rp_t *rp = arg;
558 uint64_t n;
559
560 /* totalRPs */
561 if (cbor_isa_uint(key) == false ||
562 cbor_int_get_width(key) != CBOR_INT_8 ||
563 cbor_get_uint8(key) != 5) {
564 fido_log_debug("%s: cbor_type", __func__);
565 return (0); /* ignore */
566 }
567
568 if (cbor_decode_uint64(val, &n) < 0 || n > SIZE_MAX) {
569 fido_log_debug("%s: cbor_decode_uint64", __func__);
570 return (-1);
571 }
572
573 if (credman_grow_array((void **)&rp->ptr, &rp->n_alloc, &rp->n_rx,
574 (size_t)n, sizeof(*rp->ptr)) < 0) {
575 fido_log_debug("%s: credman_grow_array", __func__);
576 return (-1);
577 }
578
579 return (0);
580 }
581
582 static int
583 credman_rx_rp(fido_dev_t *dev, fido_credman_rp_t *rp, int *ms)
584 {
585 unsigned char *msg;
586 int msglen;
587 int r;
588
589 credman_reset_rp(rp);
590
591 if ((msg = malloc(FIDO_MAXMSG)) == NULL) {
592 r = FIDO_ERR_INTERNAL;
593 goto out;
594 }
595
596 if ((msglen = fido_rx(dev, CTAP_CMD_CBOR, msg, FIDO_MAXMSG, ms)) < 0) {
597 fido_log_debug("%s: fido_rx", __func__);
598 r = FIDO_ERR_RX;
599 goto out;
600 }
601
602 /* adjust as needed */
603 if ((r = cbor_parse_reply(msg, (size_t)msglen, rp,
604 credman_parse_rp_count)) != FIDO_OK) {
605 fido_log_debug("%s: credman_parse_rp_count", __func__);
606 goto out;
607 }
608
609 if (rp->n_alloc == 0) {
610 fido_log_debug("%s: n_alloc=0", __func__);
611 r = FIDO_OK;
612 goto out;
613 }
614
615 /* parse the first rp */
616 if ((r = cbor_parse_reply(msg, (size_t)msglen, &rp->ptr[0],
617 credman_parse_rp)) != FIDO_OK) {
618 fido_log_debug("%s: credman_parse_rp", __func__);
619 goto out;
620 }
621 rp->n_rx = 1;
622
623 r = FIDO_OK;
624 out:
625 freezero(msg, FIDO_MAXMSG);
626
627 return (r);
628 }
629
630 static int
631 credman_rx_next_rp(fido_dev_t *dev, fido_credman_rp_t *rp, int *ms)
632 {
633 unsigned char *msg;
634 int msglen;
635 int r;
636
637 if ((msg = malloc(FIDO_MAXMSG)) == NULL) {
638 r = FIDO_ERR_INTERNAL;
639 goto out;
640 }
641
642 if ((msglen = fido_rx(dev, CTAP_CMD_CBOR, msg, FIDO_MAXMSG, ms)) < 0) {
643 fido_log_debug("%s: fido_rx", __func__);
644 r = FIDO_ERR_RX;
645 goto out;
646 }
647
648 /* sanity check */
649 if (rp->n_rx >= rp->n_alloc) {
650 fido_log_debug("%s: n_rx=%zu, n_alloc=%zu", __func__, rp->n_rx,
651 rp->n_alloc);
652 r = FIDO_ERR_INTERNAL;
653 goto out;
654 }
655
656 if ((r = cbor_parse_reply(msg, (size_t)msglen, &rp->ptr[rp->n_rx],
657 credman_parse_rp)) != FIDO_OK) {
658 fido_log_debug("%s: credman_parse_rp", __func__);
659 goto out;
660 }
661
662 r = FIDO_OK;
663 out:
664 freezero(msg, FIDO_MAXMSG);
665
666 return (r);
667 }
668
669 static int
670 credman_get_rp_wait(fido_dev_t *dev, fido_credman_rp_t *rp, const char *pin,
671 int *ms)
672 {
673 int r;
674
675 if ((r = credman_tx(dev, CMD_RP_BEGIN, NULL, pin, NULL,
676 FIDO_OPT_TRUE, ms)) != FIDO_OK ||
677 (r = credman_rx_rp(dev, rp, ms)) != FIDO_OK)
678 return (r);
679
680 while (rp->n_rx < rp->n_alloc) {
681 if ((r = credman_tx(dev, CMD_RP_NEXT, NULL, NULL, NULL,
682 FIDO_OPT_FALSE, ms)) != FIDO_OK ||
683 (r = credman_rx_next_rp(dev, rp, ms)) != FIDO_OK)
684 return (r);
685 rp->n_rx++;
686 }
687
688 return (FIDO_OK);
689 }
690
691 int
692 fido_credman_get_dev_rp(fido_dev_t *dev, fido_credman_rp_t *rp, const char *pin)
693 {
694 int ms = dev->timeout_ms;
695
696 return (credman_get_rp_wait(dev, rp, pin, &ms));
697 }
698
699 static int
700 credman_set_dev_rk_wait(fido_dev_t *dev, fido_cred_t *cred, const char *pin,
701 int *ms)
702 {
703 int r;
704
705 if ((r = credman_tx(dev, CMD_UPDATE_CRED, cred, pin, NULL,
706 FIDO_OPT_TRUE, ms)) != FIDO_OK ||
707 (r = fido_rx_cbor_status(dev, ms)) != FIDO_OK)
708 return (r);
709
710 return (FIDO_OK);
711 }
712
713 int
714 fido_credman_set_dev_rk(fido_dev_t *dev, fido_cred_t *cred, const char *pin)
715 {
716 int ms = dev->timeout_ms;
717
718 return (credman_set_dev_rk_wait(dev, cred, pin, &ms));
719 }
720
721 fido_credman_rk_t *
722 fido_credman_rk_new(void)
723 {
724 return (calloc(1, sizeof(fido_credman_rk_t)));
725 }
726
727 void
728 fido_credman_rk_free(fido_credman_rk_t **rk_p)
729 {
730 fido_credman_rk_t *rk;
731
732 if (rk_p == NULL || (rk = *rk_p) == NULL)
733 return;
734
735 credman_reset_rk(rk);
736 free(rk);
737 *rk_p = NULL;
738 }
739
740 size_t
741 fido_credman_rk_count(const fido_credman_rk_t *rk)
742 {
743 return (rk->n_rx);
744 }
745
746 const fido_cred_t *
747 fido_credman_rk(const fido_credman_rk_t *rk, size_t idx)
748 {
749 if (idx >= rk->n_alloc)
750 return (NULL);
751
752 return (&rk->ptr[idx]);
753 }
754
755 fido_credman_metadata_t *
756 fido_credman_metadata_new(void)
757 {
758 return (calloc(1, sizeof(fido_credman_metadata_t)));
759 }
760
761 void
762 fido_credman_metadata_free(fido_credman_metadata_t **metadata_p)
763 {
764 fido_credman_metadata_t *metadata;
765
766 if (metadata_p == NULL || (metadata = *metadata_p) == NULL)
767 return;
768
769 free(metadata);
770 *metadata_p = NULL;
771 }
772
773 uint64_t
774 fido_credman_rk_existing(const fido_credman_metadata_t *metadata)
775 {
776 return (metadata->rk_existing);
777 }
778
779 uint64_t
780 fido_credman_rk_remaining(const fido_credman_metadata_t *metadata)
781 {
782 return (metadata->rk_remaining);
783 }
784
785 fido_credman_rp_t *
786 fido_credman_rp_new(void)
787 {
788 return (calloc(1, sizeof(fido_credman_rp_t)));
789 }
790
791 void
792 fido_credman_rp_free(fido_credman_rp_t **rp_p)
793 {
794 fido_credman_rp_t *rp;
795
796 if (rp_p == NULL || (rp = *rp_p) == NULL)
797 return;
798
799 credman_reset_rp(rp);
800 free(rp);
801 *rp_p = NULL;
802 }
803
804 size_t
805 fido_credman_rp_count(const fido_credman_rp_t *rp)
806 {
807 return (rp->n_rx);
808 }
809
810 const char *
811 fido_credman_rp_id(const fido_credman_rp_t *rp, size_t idx)
812 {
813 if (idx >= rp->n_alloc)
814 return (NULL);
815
816 return (rp->ptr[idx].rp_entity.id);
817 }
818
819 const char *
820 fido_credman_rp_name(const fido_credman_rp_t *rp, size_t idx)
821 {
822 if (idx >= rp->n_alloc)
823 return (NULL);
824
825 return (rp->ptr[idx].rp_entity.name);
826 }
827
828 size_t
829 fido_credman_rp_id_hash_len(const fido_credman_rp_t *rp, size_t idx)
830 {
831 if (idx >= rp->n_alloc)
832 return (0);
833
834 return (rp->ptr[idx].rp_id_hash.len);
835 }
836
837 const unsigned char *
838 fido_credman_rp_id_hash_ptr(const fido_credman_rp_t *rp, size_t idx)
839 {
840 if (idx >= rp->n_alloc)
841 return (NULL);
842
843 return (rp->ptr[idx].rp_id_hash.ptr);
844 }