Debian Codegraph @

extra/libfido2/libfido2-1.15.0/src/cred.c

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