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.
7 #include <openssl/sha.h>
10 #include "fido/credman.h"
11 #include "fido/es256.h"
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
22 credman_grow_array(void **ptr, size_t *n_alloc, size_t *n_rx, size_t n,
29 fido_log_debug("%s: n > UINT8_MAX", __func__);
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,
44 if ((new_ptr = recallocarray(*ptr, *n_alloc, n, size)) == NULL)
54 credman_prepare_hmac(uint8_t cmd, const void *body, cbor_item_t **param,
55 fido_blob_t *hmac_data)
57 cbor_item_t *param_cbor[3];
58 const fido_cred_t *cred;
62 memset(¶m_cbor, 0, sizeof(param_cbor));
65 return (fido_blob_set(hmac_data, &cmd, sizeof(cmd)));
70 if ((param_cbor[0] = fido_blob_encode(body)) == NULL) {
71 fido_log_debug("%s: cbor encode", __func__);
77 if ((param_cbor[1] = cbor_encode_pubkey(body)) == NULL) {
78 fido_log_debug("%s: cbor encode", __func__);
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__);
93 fido_log_debug("%s: unknown cmd=0x%02x", __func__, cmd);
97 if ((*param = cbor_flatten_vector(param_cbor, n)) == NULL) {
98 fido_log_debug("%s: cbor_flatten_vector", __func__);
101 if (cbor_build_frame(cmd, param_cbor, n, hmac_data) < 0) {
102 fido_log_debug("%s: cbor_build_frame", __func__);
108 cbor_vector_free(param_cbor, nitems(param_cbor));
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)
118 fido_blob_t *ecdh = NULL;
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;
125 memset(&f, 0, sizeof(f));
126 memset(&hmac, 0, sizeof(hmac));
127 memset(&argv, 0, sizeof(argv));
129 if (fido_dev_is_fido2(dev) == false) {
130 fido_log_debug("%s: fido_dev_is_fido2", __func__);
131 r = FIDO_ERR_INVALID_COMMAND;
136 if ((argv[0] = cbor_build_uint8(subcmd)) == NULL) {
137 fido_log_debug("%s: cbor encode", __func__);
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__);
147 if ((r = fido_do_ecdh(dev, &pk, &ecdh)) != FIDO_OK) {
148 fido_log_debug("%s: fido_do_ecdh", __func__);
151 if ((r = cbor_add_uv_params(dev, cmd, &hmac, pk, ecdh, pin,
152 rp_id, &argv[3], &argv[2])) != FIDO_OK) {
153 fido_log_debug("%s: cbor_add_uv_params", __func__);
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) < 0) {
161 fido_log_debug("%s: fido_tx", __func__);
169 fido_blob_free(&ecdh);
170 cbor_vector_free(argv, nitems(argv));
178 credman_parse_metadata(const cbor_item_t *key, const cbor_item_t *val,
181 fido_credman_metadata_t *metadata = arg;
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 */
189 switch (cbor_get_uint8(key)) {
191 return (cbor_decode_uint64(val, &metadata->rk_existing));
193 return (cbor_decode_uint64(val, &metadata->rk_remaining));
195 fido_log_debug("%s: cbor type", __func__);
196 return (0); /* ignore */
201 credman_rx_metadata(fido_dev_t *dev, fido_credman_metadata_t *metadata, int ms)
203 unsigned char reply[FIDO_MAXMSG];
207 memset(metadata, 0, sizeof(*metadata));
209 if ((reply_len = fido_rx(dev, CTAP_CMD_CBOR, &reply, sizeof(reply),
211 fido_log_debug("%s: fido_rx", __func__);
212 return (FIDO_ERR_RX);
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__);
225 credman_get_metadata_wait(fido_dev_t *dev, fido_credman_metadata_t *metadata,
226 const char *pin, int ms)
230 if ((r = credman_tx(dev, CMD_CRED_METADATA, NULL, pin, NULL,
231 FIDO_OPT_TRUE)) != FIDO_OK ||
232 (r = credman_rx_metadata(dev, metadata, ms)) != FIDO_OK)
239 fido_credman_get_dev_metadata(fido_dev_t *dev, fido_credman_metadata_t *metadata,
242 return (credman_get_metadata_wait(dev, metadata, pin, -1));
246 credman_parse_rk(const cbor_item_t *key, const cbor_item_t *val, void *arg)
248 fido_cred_t *cred = arg;
251 if (cbor_isa_uint(key) == false ||
252 cbor_int_get_width(key) != CBOR_INT_8) {
253 fido_log_debug("%s: cbor type", __func__);
254 return (0); /* ignore */
257 switch (cbor_get_uint8(key)) {
259 return (cbor_decode_user(val, &cred->user));
261 return (cbor_decode_cred_id(val, &cred->attcred.id));
263 if (cbor_decode_pubkey(val, &cred->attcred.type,
264 &cred->attcred.pubkey) < 0)
266 cred->type = cred->attcred.type; /* XXX */
269 if (cbor_decode_uint64(val, &prot) < 0 || prot > INT_MAX ||
270 fido_cred_set_prot(cred, (int)prot) != FIDO_OK)
274 return (fido_blob_decode(val, &cred->largeblob_key));
276 fido_log_debug("%s: cbor type", __func__);
277 return (0); /* ignore */
282 credman_reset_rk(fido_credman_rk_t *rk)
284 for (size_t i = 0; i < rk->n_alloc; i++) {
285 fido_cred_reset_tx(&rk->ptr[i]);
286 fido_cred_reset_rx(&rk->ptr[i]);
291 memset(rk, 0, sizeof(*rk));
295 credman_parse_rk_count(const cbor_item_t *key, const cbor_item_t *val,
298 fido_credman_rk_t *rk = arg;
301 /* totalCredentials */
302 if (cbor_isa_uint(key) == false ||
303 cbor_int_get_width(key) != CBOR_INT_8 ||
304 cbor_get_uint8(key) != 9) {
305 fido_log_debug("%s: cbor_type", __func__);
306 return (0); /* ignore */
309 if (cbor_decode_uint64(val, &n) < 0 || n > SIZE_MAX) {
310 fido_log_debug("%s: cbor_decode_uint64", __func__);
314 if (credman_grow_array((void **)&rk->ptr, &rk->n_alloc, &rk->n_rx,
315 (size_t)n, sizeof(*rk->ptr)) < 0) {
316 fido_log_debug("%s: credman_grow_array", __func__);
324 credman_rx_rk(fido_dev_t *dev, fido_credman_rk_t *rk, int ms)
326 unsigned char reply[FIDO_MAXMSG];
330 credman_reset_rk(rk);
332 if ((reply_len = fido_rx(dev, CTAP_CMD_CBOR, &reply, sizeof(reply),
334 fido_log_debug("%s: fido_rx", __func__);
335 return (FIDO_ERR_RX);
338 /* adjust as needed */
339 if ((r = cbor_parse_reply(reply, (size_t)reply_len, rk,
340 credman_parse_rk_count)) != FIDO_OK) {
341 fido_log_debug("%s: credman_parse_rk_count", __func__);
345 if (rk->n_alloc == 0) {
346 fido_log_debug("%s: n_alloc=0", __func__);
350 /* parse the first rk */
351 if ((r = cbor_parse_reply(reply, (size_t)reply_len, &rk->ptr[0],
352 credman_parse_rk)) != FIDO_OK) {
353 fido_log_debug("%s: credman_parse_rk", __func__);
363 credman_rx_next_rk(fido_dev_t *dev, fido_credman_rk_t *rk, int ms)
365 unsigned char reply[FIDO_MAXMSG];
369 if ((reply_len = fido_rx(dev, CTAP_CMD_CBOR, &reply, sizeof(reply),
371 fido_log_debug("%s: fido_rx", __func__);
372 return (FIDO_ERR_RX);
376 if (rk->n_rx >= rk->n_alloc) {
377 fido_log_debug("%s: n_rx=%zu, n_alloc=%zu", __func__, rk->n_rx,
379 return (FIDO_ERR_INTERNAL);
382 if ((r = cbor_parse_reply(reply, (size_t)reply_len, &rk->ptr[rk->n_rx],
383 credman_parse_rk)) != FIDO_OK) {
384 fido_log_debug("%s: credman_parse_rk", __func__);
392 credman_get_rk_wait(fido_dev_t *dev, const char *rp_id, fido_credman_rk_t *rk,
393 const char *pin, int ms)
396 uint8_t dgst[SHA256_DIGEST_LENGTH];
399 if (SHA256((const unsigned char *)rp_id, strlen(rp_id), dgst) != dgst) {
400 fido_log_debug("%s: sha256", __func__);
401 return (FIDO_ERR_INTERNAL);
405 rp_dgst.len = sizeof(dgst);
407 if ((r = credman_tx(dev, CMD_RK_BEGIN, &rp_dgst, pin, rp_id,
408 FIDO_OPT_TRUE)) != FIDO_OK ||
409 (r = credman_rx_rk(dev, rk, ms)) != FIDO_OK)
412 while (rk->n_rx < rk->n_alloc) {
413 if ((r = credman_tx(dev, CMD_RK_NEXT, NULL, NULL, NULL,
414 FIDO_OPT_FALSE)) != FIDO_OK ||
415 (r = credman_rx_next_rk(dev, rk, ms)) != FIDO_OK)
424 fido_credman_get_dev_rk(fido_dev_t *dev, const char *rp_id,
425 fido_credman_rk_t *rk, const char *pin)
427 return (credman_get_rk_wait(dev, rp_id, rk, pin, -1));
431 credman_del_rk_wait(fido_dev_t *dev, const unsigned char *cred_id,
432 size_t cred_id_len, const char *pin, int ms)
437 memset(&cred, 0, sizeof(cred));
439 if (fido_blob_set(&cred, cred_id, cred_id_len) < 0)
440 return (FIDO_ERR_INVALID_ARGUMENT);
442 if ((r = credman_tx(dev, CMD_DELETE_CRED, &cred, pin, NULL,
443 FIDO_OPT_TRUE)) != FIDO_OK ||
444 (r = fido_rx_cbor_status(dev, ms)) != FIDO_OK)
455 fido_credman_del_dev_rk(fido_dev_t *dev, const unsigned char *cred_id,
456 size_t cred_id_len, const char *pin)
458 return (credman_del_rk_wait(dev, cred_id, cred_id_len, pin, -1));
462 credman_parse_rp(const cbor_item_t *key, const cbor_item_t *val, void *arg)
464 struct fido_credman_single_rp *rp = arg;
466 if (cbor_isa_uint(key) == false ||
467 cbor_int_get_width(key) != CBOR_INT_8) {
468 fido_log_debug("%s: cbor type", __func__);
469 return (0); /* ignore */
472 switch (cbor_get_uint8(key)) {
474 return (cbor_decode_rp_entity(val, &rp->rp_entity));
476 return (fido_blob_decode(val, &rp->rp_id_hash));
478 fido_log_debug("%s: cbor type", __func__);
479 return (0); /* ignore */
484 credman_reset_rp(fido_credman_rp_t *rp)
486 for (size_t i = 0; i < rp->n_alloc; i++) {
487 free(rp->ptr[i].rp_entity.id);
488 free(rp->ptr[i].rp_entity.name);
489 rp->ptr[i].rp_entity.id = NULL;
490 rp->ptr[i].rp_entity.name = NULL;
491 fido_blob_reset(&rp->ptr[i].rp_id_hash);
496 memset(rp, 0, sizeof(*rp));
500 credman_parse_rp_count(const cbor_item_t *key, const cbor_item_t *val,
503 fido_credman_rp_t *rp = arg;
507 if (cbor_isa_uint(key) == false ||
508 cbor_int_get_width(key) != CBOR_INT_8 ||
509 cbor_get_uint8(key) != 5) {
510 fido_log_debug("%s: cbor_type", __func__);
511 return (0); /* ignore */
514 if (cbor_decode_uint64(val, &n) < 0 || n > SIZE_MAX) {
515 fido_log_debug("%s: cbor_decode_uint64", __func__);
519 if (credman_grow_array((void **)&rp->ptr, &rp->n_alloc, &rp->n_rx,
520 (size_t)n, sizeof(*rp->ptr)) < 0) {
521 fido_log_debug("%s: credman_grow_array", __func__);
529 credman_rx_rp(fido_dev_t *dev, fido_credman_rp_t *rp, int ms)
531 unsigned char reply[FIDO_MAXMSG];
535 credman_reset_rp(rp);
537 if ((reply_len = fido_rx(dev, CTAP_CMD_CBOR, &reply, sizeof(reply),
539 fido_log_debug("%s: fido_rx", __func__);
540 return (FIDO_ERR_RX);
543 /* adjust as needed */
544 if ((r = cbor_parse_reply(reply, (size_t)reply_len, rp,
545 credman_parse_rp_count)) != FIDO_OK) {
546 fido_log_debug("%s: credman_parse_rp_count", __func__);
550 if (rp->n_alloc == 0) {
551 fido_log_debug("%s: n_alloc=0", __func__);
555 /* parse the first rp */
556 if ((r = cbor_parse_reply(reply, (size_t)reply_len, &rp->ptr[0],
557 credman_parse_rp)) != FIDO_OK) {
558 fido_log_debug("%s: credman_parse_rp", __func__);
568 credman_rx_next_rp(fido_dev_t *dev, fido_credman_rp_t *rp, int ms)
570 unsigned char reply[FIDO_MAXMSG];
574 if ((reply_len = fido_rx(dev, CTAP_CMD_CBOR, &reply, sizeof(reply),
576 fido_log_debug("%s: fido_rx", __func__);
577 return (FIDO_ERR_RX);
581 if (rp->n_rx >= rp->n_alloc) {
582 fido_log_debug("%s: n_rx=%zu, n_alloc=%zu", __func__, rp->n_rx,
584 return (FIDO_ERR_INTERNAL);
587 if ((r = cbor_parse_reply(reply, (size_t)reply_len, &rp->ptr[rp->n_rx],
588 credman_parse_rp)) != FIDO_OK) {
589 fido_log_debug("%s: credman_parse_rp", __func__);
597 credman_get_rp_wait(fido_dev_t *dev, fido_credman_rp_t *rp, const char *pin,
602 if ((r = credman_tx(dev, CMD_RP_BEGIN, NULL, pin, NULL,
603 FIDO_OPT_TRUE)) != FIDO_OK ||
604 (r = credman_rx_rp(dev, rp, ms)) != FIDO_OK)
607 while (rp->n_rx < rp->n_alloc) {
608 if ((r = credman_tx(dev, CMD_RP_NEXT, NULL, NULL, NULL,
609 FIDO_OPT_FALSE)) != FIDO_OK ||
610 (r = credman_rx_next_rp(dev, rp, ms)) != FIDO_OK)
619 fido_credman_get_dev_rp(fido_dev_t *dev, fido_credman_rp_t *rp, const char *pin)
621 return (credman_get_rp_wait(dev, rp, pin, -1));
625 credman_set_dev_rk_wait(fido_dev_t *dev, fido_cred_t *cred, const char *pin,
630 if ((r = credman_tx(dev, CMD_UPDATE_CRED, cred, pin, NULL,
631 FIDO_OPT_TRUE)) != FIDO_OK ||
632 (r = fido_rx_cbor_status(dev, ms)) != FIDO_OK)
639 fido_credman_set_dev_rk(fido_dev_t *dev, fido_cred_t *cred, const char *pin)
641 return (credman_set_dev_rk_wait(dev, cred, pin, -1));
645 fido_credman_rk_new(void)
647 return (calloc(1, sizeof(fido_credman_rk_t)));
651 fido_credman_rk_free(fido_credman_rk_t **rk_p)
653 fido_credman_rk_t *rk;
655 if (rk_p == NULL || (rk = *rk_p) == NULL)
658 credman_reset_rk(rk);
664 fido_credman_rk_count(const fido_credman_rk_t *rk)
670 fido_credman_rk(const fido_credman_rk_t *rk, size_t idx)
672 if (idx >= rk->n_alloc)
675 return (&rk->ptr[idx]);
678 fido_credman_metadata_t *
679 fido_credman_metadata_new(void)
681 return (calloc(1, sizeof(fido_credman_metadata_t)));
685 fido_credman_metadata_free(fido_credman_metadata_t **metadata_p)
687 fido_credman_metadata_t *metadata;
689 if (metadata_p == NULL || (metadata = *metadata_p) == NULL)
697 fido_credman_rk_existing(const fido_credman_metadata_t *metadata)
699 return (metadata->rk_existing);
703 fido_credman_rk_remaining(const fido_credman_metadata_t *metadata)
705 return (metadata->rk_remaining);
709 fido_credman_rp_new(void)
711 return (calloc(1, sizeof(fido_credman_rp_t)));
715 fido_credman_rp_free(fido_credman_rp_t **rp_p)
717 fido_credman_rp_t *rp;
719 if (rp_p == NULL || (rp = *rp_p) == NULL)
722 credman_reset_rp(rp);
728 fido_credman_rp_count(const fido_credman_rp_t *rp)
734 fido_credman_rp_id(const fido_credman_rp_t *rp, size_t idx)
736 if (idx >= rp->n_alloc)
739 return (rp->ptr[idx].rp_entity.id);
743 fido_credman_rp_name(const fido_credman_rp_t *rp, size_t idx)
745 if (idx >= rp->n_alloc)
748 return (rp->ptr[idx].rp_entity.name);
752 fido_credman_rp_id_hash_len(const fido_credman_rp_t *rp, size_t idx)
754 if (idx >= rp->n_alloc)
757 return (rp->ptr[idx].rp_id_hash.len);
760 const unsigned char *
761 fido_credman_rp_id_hash_ptr(const fido_credman_rp_t *rp, size_t idx)
763 if (idx >= rp->n_alloc)
766 return (rp->ptr[idx].rp_id_hash.ptr);