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