xref: /freebsd/contrib/libfido2/src/credman.c (revision f540a43052c12c76d3453ead881248d5467a1ab0) 
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
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
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(&param_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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 *
655 fido_credman_rk_new(void)
656 {
657 	return (calloc(1, sizeof(fido_credman_rk_t)));
658 }
659 
660 void
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
674 fido_credman_rk_count(const fido_credman_rk_t *rk)
675 {
676 	return (rk->n_rx);
677 }
678 
679 const fido_cred_t *
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 *
689 fido_credman_metadata_new(void)
690 {
691 	return (calloc(1, sizeof(fido_credman_metadata_t)));
692 }
693 
694 void
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
707 fido_credman_rk_existing(const fido_credman_metadata_t *metadata)
708 {
709 	return (metadata->rk_existing);
710 }
711 
712 uint64_t
713 fido_credman_rk_remaining(const fido_credman_metadata_t *metadata)
714 {
715 	return (metadata->rk_remaining);
716 }
717 
718 fido_credman_rp_t *
719 fido_credman_rp_new(void)
720 {
721 	return (calloc(1, sizeof(fido_credman_rp_t)));
722 }
723 
724 void
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
738 fido_credman_rp_count(const fido_credman_rp_t *rp)
739 {
740 	return (rp->n_rx);
741 }
742 
743 const char *
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 *
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
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 *
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