Debian Codegraph @

src/cred.c

raw
1 /*
2 * Copyright (c) 2018-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 #include <openssl/x509.h>
10
11 #include "fido.h"
12 #include "fido/es256.h"
13
14 #ifndef FIDO_MAXMSG_CRED
15 #define FIDO_MAXMSG_CRED 4096
16 #endif
17
18 static int
19 parse_makecred_reply(const cbor_item_t *key, const cbor_item_t *val, void *arg)
20 {
21 fido_cred_t *cred = arg;
22
23 if (cbor_isa_uint(key) == false ||
24 cbor_int_get_width(key) != CBOR_INT_8) {
25 fido_log_debug("%s: cbor type", __func__);
26 return (0); /* ignore */
27 }
28
29 switch (cbor_get_uint8(key)) {
30 case 1: /* fmt */
31 return (cbor_decode_fmt(val, &cred->fmt));
32 case 2: /* authdata */
33 if (fido_blob_decode(val, &cred->authdata_raw) < 0) {
34 fido_log_debug("%s: fido_blob_decode", __func__);
35 return (-1);
36 }
37 return (cbor_decode_cred_authdata(val, cred->type,
38 &cred->authdata_cbor, &cred->authdata, &cred->attcred,
39 &cred->authdata_ext));
40 case 3: /* attestation statement */
41 return (cbor_decode_attstmt(val, &cred->attstmt));
42 case 4: /* enterprise attestation */
43 return (cbor_decode_bool(val, &cred->ea.att));
44 case 5: /* large blob key */
45 return (fido_blob_decode(val, &cred->largeblob_key));
46 default: /* ignore */
47 fido_log_debug("%s: cbor type", __func__);
48 return (0);
49 }
50 }
51
52 static int
53 fido_dev_make_cred_tx(fido_dev_t *dev, fido_cred_t *cred,
54 const es256_pk_t *pk, const fido_blob_t *ecdh, const char *pin, int *ms)
55 {
56 fido_blob_t f;
57 fido_opt_t uv = cred->uv;
58 cbor_item_t *argv[10];
59 const uint8_t cmd = CTAP_CBOR_MAKECRED;
60 int r;
61
62 memset(&f, 0, sizeof(f));
63 memset(argv, 0, sizeof(argv));
64
65 if ((argv[0] = fido_blob_encode(&cred->cdh)) == NULL ||
66 (argv[1] = cbor_encode_rp_entity(&cred->rp)) == NULL ||
67 (argv[2] = cbor_encode_user_entity(&cred->user)) == NULL ||
68 (argv[3] = cbor_encode_pubkey_param(cred->type)) == NULL) {
69 fido_log_debug("%s: cbor encode", __func__);
70 r = FIDO_ERR_INTERNAL;
71 goto fail;
72 }
73
74 /* excluded credentials */
75 if (cred->excl.len)
76 if ((argv[4] = cbor_encode_pubkey_list(&cred->excl)) == NULL) {
77 fido_log_debug("%s: cbor_encode_pubkey_list", __func__);
78 r = FIDO_ERR_INTERNAL;
79 goto fail;
80 }
81
82 /* extensions */
83 if (cred->ext.attr.mask)
84 if ((argv[5] = cbor_encode_cred_ext(dev, &cred->ext, ecdh,
85 pk)) == NULL) {
86 fido_log_debug("%s: cbor_encode_cred_ext", __func__);
87 r = FIDO_ERR_INTERNAL;
88 goto fail;
89 }
90
91 /* user verification */
92 if (pin != NULL ||
93 fido_dev_puat_blob(dev) != NULL ||
94 (uv == FIDO_OPT_TRUE && fido_dev_supports_permissions(dev))) {
95 if ((r = cbor_add_uv_params(dev, cmd, &cred->cdh, pk, ecdh,
96 pin, cred->rp.id, &argv[7], &argv[8], ms)) != FIDO_OK) {
97 fido_log_debug("%s: cbor_add_uv_params", __func__);
98 goto fail;
99 }
100 uv = FIDO_OPT_OMIT;
101 }
102
103 /* options */
104 if (cred->rk != FIDO_OPT_OMIT || uv != FIDO_OPT_OMIT)
105 if ((argv[6] = cbor_encode_cred_opt(cred->rk, uv)) == NULL) {
106 fido_log_debug("%s: cbor_encode_cred_opt", __func__);
107 r = FIDO_ERR_INTERNAL;
108 goto fail;
109 }
110
111 /* enterprise attestation */
112 if (cred->ea.mode != 0)
113 if ((argv[9] = cbor_build_uint8((uint8_t)cred->ea.mode)) ==
114 NULL) {
115 fido_log_debug("%s: cbor_build_uint8", __func__);
116 r = FIDO_ERR_INTERNAL;
117 goto fail;
118 }
119
120 /* framing and transmission */
121 if (cbor_build_frame(cmd, argv, nitems(argv), &f) < 0 ||
122 fido_tx(dev, CTAP_CMD_CBOR, f.ptr, f.len, ms) < 0) {
123 fido_log_debug("%s: fido_tx", __func__);
124 r = FIDO_ERR_TX;
125 goto fail;
126 }
127
128 r = FIDO_OK;
129 fail:
130 cbor_vector_free(argv, nitems(argv));
131 free(f.ptr);
132
133 return (r);
134 }
135
136 static int
137 fido_dev_make_cred_rx(fido_dev_t *dev, fido_cred_t *cred, int *ms)
138 {
139 unsigned char *reply;
140 int reply_len;
141 int r;
142
143 fido_cred_reset_rx(cred);
144
145 if ((reply = malloc(FIDO_MAXMSG_CRED)) == NULL) {
146 r = FIDO_ERR_INTERNAL;
147 goto fail;
148 }
149
150 if ((reply_len = fido_rx(dev, CTAP_CMD_CBOR, reply, FIDO_MAXMSG_CRED,
151 ms)) < 0) {
152 fido_log_debug("%s: fido_rx", __func__);
153 r = FIDO_ERR_RX;
154 goto fail;
155 }
156
157 if ((r = cbor_parse_reply(reply, (size_t)reply_len, cred,
158 parse_makecred_reply)) != FIDO_OK) {
159 fido_log_debug("%s: parse_makecred_reply", __func__);
160 goto fail;
161 }
162
163 if (cred->fmt == NULL || fido_blob_is_empty(&cred->authdata_cbor) ||
164 fido_blob_is_empty(&cred->attcred.id)) {
165 r = FIDO_ERR_INVALID_CBOR;
166 goto fail;
167 }
168
169 r = FIDO_OK;
170 fail:
171 free(reply);
172
173 if (r != FIDO_OK)
174 fido_cred_reset_rx(cred);
175
176 return (r);
177 }
178
179 static int
180 fido_dev_make_cred_wait(fido_dev_t *dev, fido_cred_t *cred,
181 const es256_pk_t *pk, const fido_blob_t *ecdh, const char *pin, int *ms)
182 {
183 int r;
184
185 if ((r = fido_dev_make_cred_tx(dev, cred, pk, ecdh, pin, ms)) != FIDO_OK ||
186 (r = fido_dev_make_cred_rx(dev, cred, ms)) != FIDO_OK)
187 return (r);
188
189 return (FIDO_OK);
190 }
191
192 static int
193 decrypt_hmac_secret(const fido_dev_t *dev, fido_cred_t *cred,
194 const fido_blob_t *key)
195 {
196 return (aes256_cbc_dec(dev, key, &cred->authdata_ext.hmac_secret_enc,
197 &cred->hmac_secret));
198 }
199
200 static bool
201 need_ecdh(const fido_dev_t *dev, const fido_cred_t *cred, const char *pin)
202 {
203 if (cred->ext.attr.mask & FIDO_EXT_HMAC_SECRET_MC)
204 return true;
205
206 /* If available, prefer cached PUAT */
207 if (fido_dev_puat_blob(dev) != NULL)
208 return false;
209
210 if (pin != NULL)
211 return true;
212
213 return cred->uv == FIDO_OPT_TRUE && fido_dev_supports_permissions(dev);
214 }
215
216 int
217 fido_dev_make_cred(fido_dev_t *dev, fido_cred_t *cred, const char *pin)
218 {
219 fido_blob_t *ecdh = NULL;
220 es256_pk_t *pk = NULL;
221 int ms = dev->timeout_ms;
222 int r;
223
224 #ifdef USE_WINHELLO
225 if (dev->flags & FIDO_DEV_WINHELLO)
226 return (fido_winhello_make_cred(dev, cred, pin, ms));
227 #endif
228 if (fido_dev_is_fido2(dev) == false) {
229 if (pin != NULL || cred->rk == FIDO_OPT_TRUE ||
230 cred->ext.attr.mask != 0)
231 return (FIDO_ERR_UNSUPPORTED_OPTION);
232 return (u2f_register(dev, cred, &ms));
233 }
234
235 if (cred->cdh.ptr == NULL || cred->type == 0) {
236 fido_log_debug("%s: cdh=%p, type=%d", __func__,
237 (void *)cred->cdh.ptr, cred->type);
238 r = FIDO_ERR_INVALID_ARGUMENT;
239 goto fail;
240 }
241
242 if (need_ecdh(dev, cred, pin) && (r = fido_do_ecdh(dev, &pk, &ecdh,
243 &ms)) != FIDO_OK) {
244 fido_log_debug("%s: fido_do_ecdh", __func__);
245 goto fail;
246 }
247
248 r = fido_dev_make_cred_wait(dev, cred, pk, ecdh, pin, &ms);
249 if (r == FIDO_OK && (cred->ext.attr.mask & FIDO_EXT_HMAC_SECRET_MC)) {
250 if (decrypt_hmac_secret(dev, cred, ecdh) < 0) {
251 fido_log_debug("%s: decrypt_hmac_secret", __func__);
252 r = FIDO_ERR_INTERNAL;
253 goto fail;
254 }
255 }
256
257 fail:
258 es256_pk_free(&pk);
259 fido_blob_free(&ecdh);
260
261 return (r);
262 }
263
264 static int
265 check_extensions(const fido_cred_ext_t *authdata_ext,
266 const fido_cred_ext_t *ext)
267 {
268 fido_cred_ext_t tmp;
269
270 /*
271 * XXX: largeBlobKey is not part of the extensions map
272 * XXX: thirdPartyPayment has no output for make credential
273 */
274 memcpy(&tmp, ext, sizeof(tmp));
275 tmp.mask &= ~(FIDO_EXT_LARGEBLOB_KEY | FIDO_EXT_PAYMENT);
276
277 return (timingsafe_bcmp(authdata_ext, &tmp, sizeof(*authdata_ext)));
278 }
279
280 int
281 fido_check_rp_id(const char *id, const unsigned char *obtained_hash)
282 {
283 unsigned char expected_hash[SHA256_DIGEST_LENGTH];
284
285 explicit_bzero(expected_hash, sizeof(expected_hash));
286
287 if (SHA256((const unsigned char *)id, strlen(id),
288 expected_hash) != expected_hash) {
289 fido_log_debug("%s: sha256", __func__);
290 return (-1);
291 }
292
293 return (timingsafe_bcmp(expected_hash, obtained_hash,
294 SHA256_DIGEST_LENGTH));
295 }
296
297 static int
298 get_signed_hash_u2f(fido_blob_t *dgst, const unsigned char *rp_id,
299 size_t rp_id_len, const fido_blob_t *clientdata, const fido_blob_t *id,
300 const es256_pk_t *pk)
301 {
302 const uint8_t zero = 0;
303 const uint8_t four = 4; /* uncompressed point */
304 const EVP_MD *md = NULL;
305 EVP_MD_CTX *ctx = NULL;
306 int ok = -1;
307
308 if (dgst->len < SHA256_DIGEST_LENGTH ||
309 (md = EVP_sha256()) == NULL ||
310 (ctx = EVP_MD_CTX_new()) == NULL ||
311 EVP_DigestInit_ex(ctx, md, NULL) != 1 ||
312 EVP_DigestUpdate(ctx, &zero, sizeof(zero)) != 1 ||
313 EVP_DigestUpdate(ctx, rp_id, rp_id_len) != 1 ||
314 EVP_DigestUpdate(ctx, clientdata->ptr, clientdata->len) != 1 ||
315 EVP_DigestUpdate(ctx, id->ptr, id->len) != 1 ||
316 EVP_DigestUpdate(ctx, &four, sizeof(four)) != 1 ||
317 EVP_DigestUpdate(ctx, pk->x, sizeof(pk->x)) != 1 ||
318 EVP_DigestUpdate(ctx, pk->y, sizeof(pk->y)) != 1 ||
319 EVP_DigestFinal_ex(ctx, dgst->ptr, NULL) != 1) {
320 fido_log_debug("%s: sha256", __func__);
321 goto fail;
322 }
323 dgst->len = SHA256_DIGEST_LENGTH;
324
325 ok = 0;
326 fail:
327 EVP_MD_CTX_free(ctx);
328
329 return (ok);
330 }
331
332 static int
333 verify_attstmt(const fido_blob_t *dgst, const fido_attstmt_t *attstmt)
334 {
335 BIO *rawcert = NULL;
336 X509 *cert = NULL;
337 EVP_PKEY *pkey = NULL;
338 int ok = -1;
339
340 if (!attstmt->x5c.len) {
341 fido_log_debug("%s: x5c.len=%zu", __func__, attstmt->x5c.len);
342 return (-1);
343 }
344
345 /* openssl needs ints */
346 if (attstmt->x5c.ptr[0].len > INT_MAX) {
347 fido_log_debug("%s: x5c[0].len=%zu", __func__,
348 attstmt->x5c.ptr[0].len);
349 return (-1);
350 }
351
352 /* fetch key from x509 */
353 if ((rawcert = BIO_new_mem_buf(attstmt->x5c.ptr[0].ptr,
354 (int)attstmt->x5c.ptr[0].len)) == NULL ||
355 (cert = d2i_X509_bio(rawcert, NULL)) == NULL ||
356 (pkey = X509_get_pubkey(cert)) == NULL) {
357 fido_log_debug("%s: x509 key", __func__);
358 goto fail;
359 }
360
361 switch (attstmt->alg) {
362 case COSE_UNSPEC:
363 case COSE_ES256:
364 ok = es256_verify_sig(dgst, pkey, &attstmt->sig);
365 break;
366 case COSE_ES384:
367 ok = es384_verify_sig(dgst, pkey, &attstmt->sig);
368 break;
369 case COSE_RS256:
370 ok = rs256_verify_sig(dgst, pkey, &attstmt->sig);
371 break;
372 case COSE_RS1:
373 ok = rs1_verify_sig(dgst, pkey, &attstmt->sig);
374 break;
375 case COSE_EDDSA:
376 ok = eddsa_verify_sig(dgst, pkey, &attstmt->sig);
377 break;
378 default:
379 fido_log_debug("%s: unknown alg %d", __func__, attstmt->alg);
380 break;
381 }
382
383 fail:
384 BIO_free(rawcert);
385 X509_free(cert);
386 EVP_PKEY_free(pkey);
387
388 return (ok);
389 }
390
391 int
392 fido_cred_verify(const fido_cred_t *cred)
393 {
394 unsigned char buf[1024]; /* XXX */
395 fido_blob_t dgst;
396 int cose_alg;
397 int r;
398
399 dgst.ptr = buf;
400 dgst.len = sizeof(buf);
401
402 /* do we have everything we need? */
403 if (cred->cdh.ptr == NULL || cred->authdata_cbor.ptr == NULL ||
404 cred->attstmt.x5c.ptr == NULL || cred->attstmt.sig.ptr == NULL ||
405 cred->fmt == NULL || cred->attcred.id.ptr == NULL ||
406 cred->rp.id == NULL) {
407 fido_log_debug("%s: cdh=%p, authdata=%p, x5c=%p, sig=%p, "
408 "fmt=%p id=%p, rp.id=%s", __func__, (void *)cred->cdh.ptr,
409 (void *)cred->authdata_cbor.ptr,
410 (void *)cred->attstmt.x5c.ptr,
411 (void *)cred->attstmt.sig.ptr, (void *)cred->fmt,
412 (void *)cred->attcred.id.ptr, cred->rp.id);
413 r = FIDO_ERR_INVALID_ARGUMENT;
414 goto out;
415 }
416
417 if (fido_check_rp_id(cred->rp.id, cred->authdata.rp_id_hash) != 0) {
418 fido_log_debug("%s: fido_check_rp_id", __func__);
419 r = FIDO_ERR_INVALID_PARAM;
420 goto out;
421 }
422
423 if (fido_check_flags(cred->authdata.flags, FIDO_OPT_TRUE,
424 cred->uv) < 0) {
425 fido_log_debug("%s: fido_check_flags", __func__);
426 r = FIDO_ERR_INVALID_PARAM;
427 goto out;
428 }
429
430 if (check_extensions(&cred->authdata_ext.attr, &cred->ext.attr) != 0) {
431 fido_log_debug("%s: check_extensions", __func__);
432 r = FIDO_ERR_INVALID_PARAM;
433 goto out;
434 }
435
436 if ((cose_alg = cred->attstmt.alg) == COSE_UNSPEC)
437 cose_alg = COSE_ES256; /* backwards compat */
438
439 if (!strcmp(cred->fmt, "packed")) {
440 if (fido_get_signed_hash(cose_alg, &dgst, &cred->cdh,
441 &cred->authdata_cbor) < 0) {
442 fido_log_debug("%s: fido_get_signed_hash", __func__);
443 r = FIDO_ERR_INTERNAL;
444 goto out;
445 }
446 } else if (!strcmp(cred->fmt, "fido-u2f")) {
447 if (get_signed_hash_u2f(&dgst, cred->authdata.rp_id_hash,
448 sizeof(cred->authdata.rp_id_hash), &cred->cdh,
449 &cred->attcred.id, &cred->attcred.pubkey.es256) < 0) {
450 fido_log_debug("%s: get_signed_hash_u2f", __func__);
451 r = FIDO_ERR_INTERNAL;
452 goto out;
453 }
454 } else if (!strcmp(cred->fmt, "tpm")) {
455 if (fido_get_signed_hash_tpm(&dgst, &cred->cdh,
456 &cred->authdata_raw, &cred->attstmt, &cred->attcred) < 0) {
457 fido_log_debug("%s: fido_get_signed_hash_tpm", __func__);
458 r = FIDO_ERR_INTERNAL;
459 goto out;
460 }
461 } else {
462 fido_log_debug("%s: unknown fmt %s", __func__, cred->fmt);
463 r = FIDO_ERR_INVALID_ARGUMENT;
464 goto out;
465 }
466
467 if (verify_attstmt(&dgst, &cred->attstmt) < 0) {
468 fido_log_debug("%s: verify_attstmt", __func__);
469 r = FIDO_ERR_INVALID_SIG;
470 goto out;
471 }
472
473 r = FIDO_OK;
474 out:
475 explicit_bzero(buf, sizeof(buf));
476
477 return (r);
478 }
479
480 int
481 fido_cred_verify_self(const fido_cred_t *cred)
482 {
483 unsigned char buf[1024]; /* XXX */
484 fido_blob_t dgst;
485 int ok = -1;
486 int r;
487
488 dgst.ptr = buf;
489 dgst.len = sizeof(buf);
490
491 /* do we have everything we need? */
492 if (cred->cdh.ptr == NULL || cred->authdata_cbor.ptr == NULL ||
493 cred->attstmt.x5c.ptr != NULL || cred->attstmt.sig.ptr == NULL ||
494 cred->fmt == NULL || cred->attcred.id.ptr == NULL ||
495 cred->rp.id == NULL) {
496 fido_log_debug("%s: cdh=%p, authdata=%p, x5c=%p, sig=%p, "
497 "fmt=%p id=%p, rp.id=%s", __func__, (void *)cred->cdh.ptr,
498 (void *)cred->authdata_cbor.ptr,
499 (void *)cred->attstmt.x5c.ptr,
500 (void *)cred->attstmt.sig.ptr, (void *)cred->fmt,
501 (void *)cred->attcred.id.ptr, cred->rp.id);
502 r = FIDO_ERR_INVALID_ARGUMENT;
503 goto out;
504 }
505
506 if (fido_check_rp_id(cred->rp.id, cred->authdata.rp_id_hash) != 0) {
507 fido_log_debug("%s: fido_check_rp_id", __func__);
508 r = FIDO_ERR_INVALID_PARAM;
509 goto out;
510 }
511
512 if (fido_check_flags(cred->authdata.flags, FIDO_OPT_TRUE,
513 cred->uv) < 0) {
514 fido_log_debug("%s: fido_check_flags", __func__);
515 r = FIDO_ERR_INVALID_PARAM;
516 goto out;
517 }
518
519 if (check_extensions(&cred->authdata_ext.attr, &cred->ext.attr) != 0) {
520 fido_log_debug("%s: check_extensions", __func__);
521 r = FIDO_ERR_INVALID_PARAM;
522 goto out;
523 }
524
525 if (!strcmp(cred->fmt, "packed")) {
526 if (fido_get_signed_hash(cred->attcred.type, &dgst, &cred->cdh,
527 &cred->authdata_cbor) < 0) {
528 fido_log_debug("%s: fido_get_signed_hash", __func__);
529 r = FIDO_ERR_INTERNAL;
530 goto out;
531 }
532 } else if (!strcmp(cred->fmt, "fido-u2f")) {
533 if (get_signed_hash_u2f(&dgst, cred->authdata.rp_id_hash,
534 sizeof(cred->authdata.rp_id_hash), &cred->cdh,
535 &cred->attcred.id, &cred->attcred.pubkey.es256) < 0) {
536 fido_log_debug("%s: get_signed_hash_u2f", __func__);
537 r = FIDO_ERR_INTERNAL;
538 goto out;
539 }
540 } else {
541 fido_log_debug("%s: unknown fmt %s", __func__, cred->fmt);
542 r = FIDO_ERR_INVALID_ARGUMENT;
543 goto out;
544 }
545
546 switch (cred->attcred.type) {
547 case COSE_ES256:
548 ok = es256_pk_verify_sig(&dgst, &cred->attcred.pubkey.es256,
549 &cred->attstmt.sig);
550 break;
551 case COSE_ES384:
552 ok = es384_pk_verify_sig(&dgst, &cred->attcred.pubkey.es384,
553 &cred->attstmt.sig);
554 break;
555 case COSE_RS256:
556 ok = rs256_pk_verify_sig(&dgst, &cred->attcred.pubkey.rs256,
557 &cred->attstmt.sig);
558 break;
559 case COSE_EDDSA:
560 ok = eddsa_pk_verify_sig(&dgst, &cred->attcred.pubkey.eddsa,
561 &cred->attstmt.sig);
562 break;
563 default:
564 fido_log_debug("%s: unsupported cose_alg %d", __func__,
565 cred->attcred.type);
566 r = FIDO_ERR_UNSUPPORTED_OPTION;
567 goto out;
568 }
569
570 if (ok < 0)
571 r = FIDO_ERR_INVALID_SIG;
572 else
573 r = FIDO_OK;
574
575 out:
576 explicit_bzero(buf, sizeof(buf));
577
578 return (r);
579 }
580
581 fido_cred_t *
582 fido_cred_new(void)
583 {
584 return (calloc(1, sizeof(fido_cred_t)));
585 }
586
587 static void
588 fido_cred_clean_authdata(fido_cred_t *cred)
589 {
590 fido_blob_reset(&cred->authdata_cbor);
591 fido_blob_reset(&cred->authdata_raw);
592 fido_blob_reset(&cred->attcred.id);
593 fido_blob_reset(&cred->authdata_ext.hmac_secret_enc);
594
595 memset(&cred->authdata_ext, 0, sizeof(cred->authdata_ext));
596 memset(&cred->authdata, 0, sizeof(cred->authdata));
597 memset(&cred->attcred, 0, sizeof(cred->attcred));
598 }
599
600 static void
601 fido_cred_clean_attstmt(fido_attstmt_t *attstmt)
602 {
603 fido_blob_reset(&attstmt->certinfo);
604 fido_blob_reset(&attstmt->pubarea);
605 fido_blob_reset(&attstmt->cbor);
606 fido_free_blob_array(&attstmt->x5c);
607 fido_blob_reset(&attstmt->sig);
608
609 memset(attstmt, 0, sizeof(*attstmt));
610 }
611
612 static void
613 fido_cred_clean_attobj(fido_cred_t *cred)
614 {
615 free(cred->fmt);
616 cred->fmt = NULL;
617 fido_cred_clean_authdata(cred);
618 fido_cred_clean_attstmt(&cred->attstmt);
619 }
620
621 void
622 fido_cred_reset_tx(fido_cred_t *cred)
623 {
624 fido_blob_reset(&cred->cd);
625 fido_blob_reset(&cred->cdh);
626 fido_blob_reset(&cred->user.id);
627 fido_blob_reset(&cred->ext.blob);
628 fido_blob_reset(&cred->ext.hmac_salt);
629
630 free(cred->rp.id);
631 free(cred->rp.name);
632 free(cred->user.icon);
633 free(cred->user.name);
634 free(cred->user.display_name);
635 fido_cred_empty_exclude_list(cred);
636
637 memset(&cred->rp, 0, sizeof(cred->rp));
638 memset(&cred->user, 0, sizeof(cred->user));
639 memset(&cred->ext, 0, sizeof(cred->ext));
640
641 cred->type = 0;
642 cred->rk = FIDO_OPT_OMIT;
643 cred->uv = FIDO_OPT_OMIT;
644 cred->ea.mode = 0;
645 }
646
647 void
648 fido_cred_reset_rx(fido_cred_t *cred)
649 {
650 fido_cred_clean_attobj(cred);
651 fido_blob_reset(&cred->largeblob_key);
652 fido_blob_reset(&cred->hmac_secret);
653 cred->ea.att = false;
654 }
655
656 void
657 fido_cred_free(fido_cred_t **cred_p)
658 {
659 fido_cred_t *cred;
660
661 if (cred_p == NULL || (cred = *cred_p) == NULL)
662 return;
663 fido_cred_reset_tx(cred);
664 fido_cred_reset_rx(cred);
665 free(cred);
666 *cred_p = NULL;
667 }
668
669 int
670 fido_cred_set_authdata(fido_cred_t *cred, const unsigned char *ptr, size_t len)
671 {
672 cbor_item_t *item = NULL;
673 struct cbor_load_result cbor;
674 int r = FIDO_ERR_INVALID_ARGUMENT;
675
676 fido_cred_clean_authdata(cred);
677
678 if (ptr == NULL || len == 0)
679 goto fail;
680
681 if ((item = cbor_load(ptr, len, &cbor)) == NULL) {
682 fido_log_debug("%s: cbor_load", __func__);
683 goto fail;
684 }
685
686 if (fido_blob_decode(item, &cred->authdata_raw) < 0) {
687 fido_log_debug("%s: fido_blob_decode", __func__);
688 goto fail;
689 }
690
691 if (cbor_decode_cred_authdata(item, cred->type, &cred->authdata_cbor,
692 &cred->authdata, &cred->attcred, &cred->authdata_ext) < 0) {
693 fido_log_debug("%s: cbor_decode_cred_authdata", __func__);
694 goto fail;
695 }
696
697 r = FIDO_OK;
698 fail:
699 if (item != NULL)
700 cbor_decref(&item);
701
702 if (r != FIDO_OK)
703 fido_cred_clean_authdata(cred);
704
705 return (r);
706 }
707
708 int
709 fido_cred_set_authdata_raw(fido_cred_t *cred, const unsigned char *ptr,
710 size_t len)
711 {
712 cbor_item_t *item = NULL;
713 int r = FIDO_ERR_INVALID_ARGUMENT;
714
715 fido_cred_clean_authdata(cred);
716
717 if (ptr == NULL || len == 0)
718 goto fail;
719
720 if (fido_blob_set(&cred->authdata_raw, ptr, len) < 0) {
721 fido_log_debug("%s: fido_blob_set", __func__);
722 r = FIDO_ERR_INTERNAL;
723 goto fail;
724 }
725
726 if ((item = cbor_build_bytestring(ptr, len)) == NULL) {
727 fido_log_debug("%s: cbor_build_bytestring", __func__);
728 r = FIDO_ERR_INTERNAL;
729 goto fail;
730 }
731
732 if (cbor_decode_cred_authdata(item, cred->type, &cred->authdata_cbor,
733 &cred->authdata, &cred->attcred, &cred->authdata_ext) < 0) {
734 fido_log_debug("%s: cbor_decode_cred_authdata", __func__);
735 goto fail;
736 }
737
738 r = FIDO_OK;
739 fail:
740 if (item != NULL)
741 cbor_decref(&item);
742
743 if (r != FIDO_OK)
744 fido_cred_clean_authdata(cred);
745
746 return (r);
747 }
748
749 int
750 fido_cred_set_id(fido_cred_t *cred, const unsigned char *ptr, size_t len)
751 {
752 if (fido_blob_set(&cred->attcred.id, ptr, len) < 0)
753 return (FIDO_ERR_INVALID_ARGUMENT);
754
755 return (FIDO_OK);
756 }
757
758 int
759 fido_cred_set_x509(fido_cred_t *cred, const unsigned char *ptr, size_t len)
760 {
761 fido_blob_t x5c_blob;
762 fido_blob_t *list_ptr = NULL;
763
764 memset(&x5c_blob, 0, sizeof(x5c_blob));
765 fido_free_blob_array(&cred->attstmt.x5c);
766
767 if (fido_blob_set(&x5c_blob, ptr, len) < 0)
768 return (FIDO_ERR_INVALID_ARGUMENT);
769
770 if (cred->attstmt.x5c.len == SIZE_MAX) {
771 fido_blob_reset(&x5c_blob);
772 return (FIDO_ERR_INVALID_ARGUMENT);
773 }
774
775 if ((list_ptr = recallocarray(cred->attstmt.x5c.ptr,
776 cred->attstmt.x5c.len, cred->attstmt.x5c.len + 1,
777 sizeof(x5c_blob))) == NULL) {
778 fido_blob_reset(&x5c_blob);
779 return (FIDO_ERR_INTERNAL);
780 }
781
782 list_ptr[cred->attstmt.x5c.len++] = x5c_blob;
783 cred->attstmt.x5c.ptr = list_ptr;
784
785 return (FIDO_OK);
786 }
787
788 int
789 fido_cred_set_sig(fido_cred_t *cred, const unsigned char *ptr, size_t len)
790 {
791 if (fido_blob_set(&cred->attstmt.sig, ptr, len) < 0)
792 return (FIDO_ERR_INVALID_ARGUMENT);
793
794 return (FIDO_OK);
795 }
796
797 int
798 fido_cred_set_attstmt(fido_cred_t *cred, const unsigned char *ptr, size_t len)
799 {
800 cbor_item_t *item = NULL;
801 struct cbor_load_result cbor;
802 int r = FIDO_ERR_INVALID_ARGUMENT;
803
804 fido_cred_clean_attstmt(&cred->attstmt);
805
806 if (ptr == NULL || len == 0)
807 goto fail;
808
809 if ((item = cbor_load(ptr, len, &cbor)) == NULL) {
810 fido_log_debug("%s: cbor_load", __func__);
811 goto fail;
812 }
813
814 if (cbor_decode_attstmt(item, &cred->attstmt) < 0) {
815 fido_log_debug("%s: cbor_decode_attstmt", __func__);
816 goto fail;
817 }
818
819 r = FIDO_OK;
820 fail:
821 if (item != NULL)
822 cbor_decref(&item);
823
824 if (r != FIDO_OK)
825 fido_cred_clean_attstmt(&cred->attstmt);
826
827 return (r);
828 }
829
830 int
831 fido_cred_set_attobj(fido_cred_t *cred, const unsigned char *ptr, size_t len)
832 {
833 cbor_item_t *item = NULL;
834 struct cbor_load_result cbor;
835 int r = FIDO_ERR_INVALID_ARGUMENT;
836
837 fido_cred_clean_attobj(cred);
838
839 if (ptr == NULL || len == 0)
840 goto fail;
841
842 if ((item = cbor_load(ptr, len, &cbor)) == NULL) {
843 fido_log_debug("%s: cbor_load", __func__);
844 goto fail;
845 }
846 if (cbor_decode_attobj(item, cred) != 0) {
847 fido_log_debug("%s: cbor_decode_attobj", __func__);
848 goto fail;
849 }
850
851 r = FIDO_OK;
852 fail:
853 if (item != NULL)
854 cbor_decref(&item);
855
856 return (r);
857 }
858
859 int
860 fido_cred_exclude(fido_cred_t *cred, const unsigned char *id_ptr, size_t id_len)
861 {
862 fido_blob_t id_blob;
863 fido_blob_t *list_ptr;
864
865 memset(&id_blob, 0, sizeof(id_blob));
866
867 if (fido_blob_set(&id_blob, id_ptr, id_len) < 0)
868 return (FIDO_ERR_INVALID_ARGUMENT);
869
870 if (cred->excl.len == SIZE_MAX) {
871 free(id_blob.ptr);
872 return (FIDO_ERR_INVALID_ARGUMENT);
873 }
874
875 if ((list_ptr = recallocarray(cred->excl.ptr, cred->excl.len,
876 cred->excl.len + 1, sizeof(fido_blob_t))) == NULL) {
877 free(id_blob.ptr);
878 return (FIDO_ERR_INTERNAL);
879 }
880
881 list_ptr[cred->excl.len++] = id_blob;
882 cred->excl.ptr = list_ptr;
883
884 return (FIDO_OK);
885 }
886
887 int
888 fido_cred_empty_exclude_list(fido_cred_t *cred)
889 {
890 fido_free_blob_array(&cred->excl);
891 memset(&cred->excl, 0, sizeof(cred->excl));
892
893 return (FIDO_OK);
894 }
895
896 int
897 fido_cred_set_clientdata(fido_cred_t *cred, const unsigned char *data,
898 size_t data_len)
899 {
900 if (!fido_blob_is_empty(&cred->cdh) ||
901 fido_blob_set(&cred->cd, data, data_len) < 0) {
902 return (FIDO_ERR_INVALID_ARGUMENT);
903 }
904 if (fido_sha256(&cred->cdh, data, data_len) < 0) {
905 fido_blob_reset(&cred->cd);
906 return (FIDO_ERR_INTERNAL);
907 }
908
909 return (FIDO_OK);
910 }
911
912 int
913 fido_cred_set_clientdata_hash(fido_cred_t *cred, const unsigned char *hash,
914 size_t hash_len)
915 {
916 if (!fido_blob_is_empty(&cred->cd) ||
917 fido_blob_set(&cred->cdh, hash, hash_len) < 0)
918 return (FIDO_ERR_INVALID_ARGUMENT);
919
920 return (FIDO_OK);
921 }
922
923 int
924 fido_cred_set_rp(fido_cred_t *cred, const char *id, const char *name)
925 {
926 fido_rp_t *rp = &cred->rp;
927
928 if (rp->id != NULL) {
929 free(rp->id);
930 rp->id = NULL;
931 }
932 if (rp->name != NULL) {
933 free(rp->name);
934 rp->name = NULL;
935 }
936
937 if (id != NULL && (rp->id = strdup(id)) == NULL)
938 goto fail;
939 if (name != NULL && (rp->name = strdup(name)) == NULL)
940 goto fail;
941
942 return (FIDO_OK);
943 fail:
944 free(rp->id);
945 free(rp->name);
946 rp->id = NULL;
947 rp->name = NULL;
948
949 return (FIDO_ERR_INTERNAL);
950 }
951
952 int
953 fido_cred_set_user(fido_cred_t *cred, const unsigned char *user_id,
954 size_t user_id_len, const char *name, const char *display_name,
955 const char *icon)
956 {
957 fido_user_t *up = &cred->user;
958
959 if (up->id.ptr != NULL) {
960 free(up->id.ptr);
961 up->id.ptr = NULL;
962 up->id.len = 0;
963 }
964 if (up->name != NULL) {
965 free(up->name);
966 up->name = NULL;
967 }
968 if (up->display_name != NULL) {
969 free(up->display_name);
970 up->display_name = NULL;
971 }
972 if (up->icon != NULL) {
973 free(up->icon);
974 up->icon = NULL;
975 }
976
977 if (user_id != NULL && fido_blob_set(&up->id, user_id, user_id_len) < 0)
978 goto fail;
979 if (name != NULL && (up->name = strdup(name)) == NULL)
980 goto fail;
981 if (display_name != NULL &&
982 (up->display_name = strdup(display_name)) == NULL)
983 goto fail;
984 if (icon != NULL && (up->icon = strdup(icon)) == NULL)
985 goto fail;
986
987 return (FIDO_OK);
988 fail:
989 free(up->id.ptr);
990 free(up->name);
991 free(up->display_name);
992 free(up->icon);
993
994 up->id.ptr = NULL;
995 up->id.len = 0;
996 up->name = NULL;
997 up->display_name = NULL;
998 up->icon = NULL;
999
1000 return (FIDO_ERR_INTERNAL);
1001 }
1002
1003 int
1004 fido_cred_set_hmac_salt(fido_cred_t *cred, const unsigned char *salt,
1005 size_t salt_len)
1006 {
1007 if ((salt_len != 32 && salt_len != 64) ||
1008 fido_blob_set(&cred->ext.hmac_salt, salt, salt_len) < 0)
1009 return (FIDO_ERR_INVALID_ARGUMENT);
1010
1011 return (FIDO_OK);
1012 }
1013
1014 int
1015 fido_cred_set_hmac_secret(fido_cred_t *cred,
1016 const unsigned char *secret, size_t secret_len)
1017 {
1018 if ((secret_len != 32 && secret_len != 64) ||
1019 fido_blob_set(&cred->hmac_secret, secret, secret_len) < 0)
1020 return (FIDO_ERR_INVALID_ARGUMENT);
1021
1022 return (FIDO_OK);
1023 }
1024
1025 const unsigned char *
1026 fido_cred_hmac_secret_ptr(const fido_cred_t *cred)
1027 {
1028 return (cred->hmac_secret.ptr);
1029 }
1030
1031 size_t
1032 fido_cred_hmac_secret_len(const fido_cred_t *cred)
1033 {
1034 return (cred->hmac_secret.len);
1035 }
1036
1037 int
1038 fido_cred_set_extensions(fido_cred_t *cred, int ext)
1039 {
1040 if (ext == 0)
1041 cred->ext.attr.mask = 0;
1042 else {
1043 if ((ext & FIDO_EXT_CRED_MASK) != ext)
1044 return (FIDO_ERR_INVALID_ARGUMENT);
1045 cred->ext.attr.mask |= ext;
1046 }
1047
1048 return (FIDO_OK);
1049 }
1050
1051 int
1052 fido_cred_set_options(fido_cred_t *cred, bool rk, bool uv)
1053 {
1054 cred->rk = rk ? FIDO_OPT_TRUE : FIDO_OPT_FALSE;
1055 cred->uv = uv ? FIDO_OPT_TRUE : FIDO_OPT_FALSE;
1056
1057 return (FIDO_OK);
1058 }
1059
1060 int
1061 fido_cred_set_rk(fido_cred_t *cred, fido_opt_t rk)
1062 {
1063 cred->rk = rk;
1064
1065 return (FIDO_OK);
1066 }
1067
1068 int
1069 fido_cred_set_uv(fido_cred_t *cred, fido_opt_t uv)
1070 {
1071 cred->uv = uv;
1072
1073 return (FIDO_OK);
1074 }
1075
1076 int
1077 fido_cred_set_entattest(fido_cred_t *cred, int ea)
1078 {
1079 if (ea != 0 && ea != FIDO_ENTATTEST_VENDOR &&
1080 ea != FIDO_ENTATTEST_PLATFORM)
1081 return (FIDO_ERR_INVALID_ARGUMENT);
1082
1083 cred->ea.mode = ea;
1084
1085 return (FIDO_OK);
1086 }
1087
1088 int
1089 fido_cred_set_prot(fido_cred_t *cred, int prot)
1090 {
1091 if (prot == 0) {
1092 cred->ext.attr.mask &= ~FIDO_EXT_CRED_PROTECT;
1093 cred->ext.attr.prot = 0;
1094 } else {
1095 if (prot != FIDO_CRED_PROT_UV_OPTIONAL &&
1096 prot != FIDO_CRED_PROT_UV_OPTIONAL_WITH_ID &&
1097 prot != FIDO_CRED_PROT_UV_REQUIRED)
1098 return (FIDO_ERR_INVALID_ARGUMENT);
1099
1100 cred->ext.attr.mask |= FIDO_EXT_CRED_PROTECT;
1101 cred->ext.attr.prot = prot;
1102 }
1103
1104 return (FIDO_OK);
1105 }
1106
1107 int
1108 fido_cred_set_pin_minlen(fido_cred_t *cred, size_t len)
1109 {
1110 if (len == 0)
1111 cred->ext.attr.mask &= ~FIDO_EXT_MINPINLEN;
1112 else
1113 cred->ext.attr.mask |= FIDO_EXT_MINPINLEN;
1114
1115 cred->ext.attr.minpinlen = len;
1116
1117 return (FIDO_OK);
1118 }
1119
1120 int
1121 fido_cred_set_blob(fido_cred_t *cred, const unsigned char *ptr, size_t len)
1122 {
1123 if (ptr == NULL || len == 0)
1124 return (FIDO_ERR_INVALID_ARGUMENT);
1125 if (fido_blob_set(&cred->ext.blob, ptr, len) < 0)
1126 return (FIDO_ERR_INTERNAL);
1127
1128 cred->ext.attr.mask |= FIDO_EXT_CRED_BLOB;
1129
1130 return (FIDO_OK);
1131 }
1132
1133 int
1134 fido_cred_set_fmt(fido_cred_t *cred, const char *fmt)
1135 {
1136 free(cred->fmt);
1137 cred->fmt = NULL;
1138
1139 if (fmt == NULL)
1140 return (FIDO_ERR_INVALID_ARGUMENT);
1141
1142 if (strcmp(fmt, "packed") && strcmp(fmt, "fido-u2f") &&
1143 strcmp(fmt, "none") && strcmp(fmt, "tpm"))
1144 return (FIDO_ERR_INVALID_ARGUMENT);
1145
1146 if ((cred->fmt = strdup(fmt)) == NULL)
1147 return (FIDO_ERR_INTERNAL);
1148
1149 return (FIDO_OK);
1150 }
1151
1152 int
1153 fido_cred_set_type(fido_cred_t *cred, int cose_alg)
1154 {
1155 if (cred->type != 0)
1156 return (FIDO_ERR_INVALID_ARGUMENT);
1157 if (cose_alg != COSE_ES256 && cose_alg != COSE_ES384 &&
1158 cose_alg != COSE_RS256 && cose_alg != COSE_EDDSA)
1159 return (FIDO_ERR_INVALID_ARGUMENT);
1160
1161 cred->type = cose_alg;
1162
1163 return (FIDO_OK);
1164 }
1165
1166 int
1167 fido_cred_type(const fido_cred_t *cred)
1168 {
1169 return (cred->type);
1170 }
1171
1172 uint8_t
1173 fido_cred_flags(const fido_cred_t *cred)
1174 {
1175 return (cred->authdata.flags);
1176 }
1177
1178 uint32_t
1179 fido_cred_sigcount(const fido_cred_t *cred)
1180 {
1181 return (cred->authdata.sigcount);
1182 }
1183
1184 const unsigned char *
1185 fido_cred_clientdata_hash_ptr(const fido_cred_t *cred)
1186 {
1187 return (cred->cdh.ptr);
1188 }
1189
1190 size_t
1191 fido_cred_clientdata_hash_len(const fido_cred_t *cred)
1192 {
1193 return (cred->cdh.len);
1194 }
1195
1196 const unsigned char *
1197 fido_cred_x5c_ptr(const fido_cred_t *cred)
1198 {
1199 return (fido_cred_x5c_list_ptr(cred, 0));
1200 }
1201
1202 size_t
1203 fido_cred_x5c_len(const fido_cred_t *cred)
1204 {
1205 return (fido_cred_x5c_list_len(cred, 0));
1206 }
1207
1208 size_t
1209 fido_cred_x5c_list_count(const fido_cred_t *cred)
1210 {
1211 return (cred->attstmt.x5c.len);
1212 }
1213
1214 const unsigned char *
1215 fido_cred_x5c_list_ptr(const fido_cred_t *cred, size_t i)
1216 {
1217 if (i >= cred->attstmt.x5c.len)
1218 return (NULL);
1219
1220 return (cred->attstmt.x5c.ptr[i].ptr);
1221 }
1222
1223 size_t
1224 fido_cred_x5c_list_len(const fido_cred_t *cred, size_t i)
1225 {
1226 if (i >= cred->attstmt.x5c.len)
1227 return (0);
1228
1229 return (cred->attstmt.x5c.ptr[i].len);
1230 }
1231
1232 const unsigned char *
1233 fido_cred_sig_ptr(const fido_cred_t *cred)
1234 {
1235 return (cred->attstmt.sig.ptr);
1236 }
1237
1238 size_t
1239 fido_cred_sig_len(const fido_cred_t *cred)
1240 {
1241 return (cred->attstmt.sig.len);
1242 }
1243
1244 const unsigned char *
1245 fido_cred_authdata_ptr(const fido_cred_t *cred)
1246 {
1247 return (cred->authdata_cbor.ptr);
1248 }
1249
1250 size_t
1251 fido_cred_authdata_len(const fido_cred_t *cred)
1252 {
1253 return (cred->authdata_cbor.len);
1254 }
1255
1256 const unsigned char *
1257 fido_cred_authdata_raw_ptr(const fido_cred_t *cred)
1258 {
1259 return (cred->authdata_raw.ptr);
1260 }
1261
1262 size_t
1263 fido_cred_authdata_raw_len(const fido_cred_t *cred)
1264 {
1265 return (cred->authdata_raw.len);
1266 }
1267
1268 const unsigned char *
1269 fido_cred_attstmt_ptr(const fido_cred_t *cred)
1270 {
1271 return (cred->attstmt.cbor.ptr);
1272 }
1273
1274 size_t
1275 fido_cred_attstmt_len(const fido_cred_t *cred)
1276 {
1277 return (cred->attstmt.cbor.len);
1278 }
1279
1280 const unsigned char *
1281 fido_cred_pubkey_ptr(const fido_cred_t *cred)
1282 {
1283 const void *ptr;
1284
1285 switch (cred->attcred.type) {
1286 case COSE_ES256:
1287 ptr = &cred->attcred.pubkey.es256;
1288 break;
1289 case COSE_ES384:
1290 ptr = &cred->attcred.pubkey.es384;
1291 break;
1292 case COSE_RS256:
1293 ptr = &cred->attcred.pubkey.rs256;
1294 break;
1295 case COSE_EDDSA:
1296 ptr = &cred->attcred.pubkey.eddsa;
1297 break;
1298 default:
1299 ptr = NULL;
1300 break;
1301 }
1302
1303 return (ptr);
1304 }
1305
1306 size_t
1307 fido_cred_pubkey_len(const fido_cred_t *cred)
1308 {
1309 size_t len;
1310
1311 switch (cred->attcred.type) {
1312 case COSE_ES256:
1313 len = sizeof(cred->attcred.pubkey.es256);
1314 break;
1315 case COSE_ES384:
1316 len = sizeof(cred->attcred.pubkey.es384);
1317 break;
1318 case COSE_RS256:
1319 len = sizeof(cred->attcred.pubkey.rs256);
1320 break;
1321 case COSE_EDDSA:
1322 len = sizeof(cred->attcred.pubkey.eddsa);
1323 break;
1324 default:
1325 len = 0;
1326 break;
1327 }
1328
1329 return (len);
1330 }
1331
1332 const unsigned char *
1333 fido_cred_id_ptr(const fido_cred_t *cred)
1334 {
1335 return (cred->attcred.id.ptr);
1336 }
1337
1338 size_t
1339 fido_cred_id_len(const fido_cred_t *cred)
1340 {
1341 return (cred->attcred.id.len);
1342 }
1343
1344 const unsigned char *
1345 fido_cred_aaguid_ptr(const fido_cred_t *cred)
1346 {
1347 return (cred->attcred.aaguid);
1348 }
1349
1350 size_t
1351 fido_cred_aaguid_len(const fido_cred_t *cred)
1352 {
1353 return (sizeof(cred->attcred.aaguid));
1354 }
1355
1356 int
1357 fido_cred_prot(const fido_cred_t *cred)
1358 {
1359 return (cred->ext.attr.prot);
1360 }
1361
1362 size_t
1363 fido_cred_pin_minlen(const fido_cred_t *cred)
1364 {
1365 return (cred->ext.attr.minpinlen);
1366 }
1367
1368 const char *
1369 fido_cred_fmt(const fido_cred_t *cred)
1370 {
1371 return (cred->fmt);
1372 }
1373
1374 const char *
1375 fido_cred_rp_id(const fido_cred_t *cred)
1376 {
1377 return (cred->rp.id);
1378 }
1379
1380 const char *
1381 fido_cred_rp_name(const fido_cred_t *cred)
1382 {
1383 return (cred->rp.name);
1384 }
1385
1386 const char *
1387 fido_cred_user_name(const fido_cred_t *cred)
1388 {
1389 return (cred->user.name);
1390 }
1391
1392 const char *
1393 fido_cred_display_name(const fido_cred_t *cred)
1394 {
1395 return (cred->user.display_name);
1396 }
1397
1398 const unsigned char *
1399 fido_cred_user_id_ptr(const fido_cred_t *cred)
1400 {
1401 return (cred->user.id.ptr);
1402 }
1403
1404 size_t
1405 fido_cred_user_id_len(const fido_cred_t *cred)
1406 {
1407 return (cred->user.id.len);
1408 }
1409
1410 const unsigned char *
1411 fido_cred_largeblob_key_ptr(const fido_cred_t *cred)
1412 {
1413 return (cred->largeblob_key.ptr);
1414 }
1415
1416 size_t
1417 fido_cred_largeblob_key_len(const fido_cred_t *cred)
1418 {
1419 return (cred->largeblob_key.len);
1420 }
1421
1422 bool
1423 fido_cred_entattest(const fido_cred_t *cred)
1424 {
1425 return (cred->ea.att);
1426 }
1427
1428 /* XXX mainly useful for credentials retrieved via fido_credman_rk() */
1429 bool
1430 fido_cred_payment(const fido_cred_t *cred)
1431 {
1432 return (cred->ext.attr.mask & FIDO_EXT_PAYMENT);
1433 }