Debian Codegraph @

src/assert.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
10 #include "fido.h"
11 #include "fido/es256.h"
12 #include "fido/rs256.h"
13 #include "fido/eddsa.h"
14
15 static int
16 adjust_assert_count(const cbor_item_t *key, const cbor_item_t *val, void *arg)
17 {
18 fido_assert_t *assert = arg;
19 uint64_t n;
20
21 /* numberOfCredentials; see section 6.2 */
22 if (cbor_isa_uint(key) == false ||
23 cbor_int_get_width(key) != CBOR_INT_8 ||
24 cbor_get_uint8(key) != 5) {
25 fido_log_debug("%s: cbor_type", __func__);
26 return (0); /* ignore */
27 }
28
29 if (cbor_decode_uint64(val, &n) < 0 || n > SIZE_MAX) {
30 fido_log_debug("%s: cbor_decode_uint64", __func__);
31 return (-1);
32 }
33
34 if (assert->stmt_len != 0 || assert->stmt_cnt != 1 ||
35 (size_t)n < assert->stmt_cnt) {
36 fido_log_debug("%s: stmt_len=%zu, stmt_cnt=%zu, n=%zu",
37 __func__, assert->stmt_len, assert->stmt_cnt, (size_t)n);
38 return (-1);
39 }
40
41 if (fido_assert_set_count(assert, (size_t)n) != FIDO_OK) {
42 fido_log_debug("%s: fido_assert_set_count", __func__);
43 return (-1);
44 }
45
46 assert->stmt_len = 0; /* XXX */
47
48 return (0);
49 }
50
51 static int
52 parse_assert_reply(const cbor_item_t *key, const cbor_item_t *val, void *arg)
53 {
54 fido_assert_stmt *stmt = arg;
55
56 if (cbor_isa_uint(key) == false ||
57 cbor_int_get_width(key) != CBOR_INT_8) {
58 fido_log_debug("%s: cbor type", __func__);
59 return (0); /* ignore */
60 }
61
62 switch (cbor_get_uint8(key)) {
63 case 1: /* credential id */
64 return (cbor_decode_cred_id(val, &stmt->id));
65 case 2: /* authdata */
66 if (fido_blob_decode(val, &stmt->authdata_raw) < 0) {
67 fido_log_debug("%s: fido_blob_decode", __func__);
68 return (-1);
69 }
70 return (cbor_decode_assert_authdata(val, &stmt->authdata_cbor,
71 &stmt->authdata, &stmt->authdata_ext));
72 case 3: /* signature */
73 return (fido_blob_decode(val, &stmt->sig));
74 case 4: /* user attributes */
75 return (cbor_decode_user(val, &stmt->user));
76 case 7: /* large blob key */
77 return (fido_blob_decode(val, &stmt->largeblob_key));
78 default: /* ignore */
79 fido_log_debug("%s: cbor type", __func__);
80 return (0);
81 }
82 }
83
84 static int
85 fido_dev_get_assert_tx(fido_dev_t *dev, fido_assert_t *assert,
86 const es256_pk_t *pk, const fido_blob_t *ecdh, const char *pin, int *ms)
87 {
88 fido_blob_t f;
89 fido_opt_t uv = assert->uv;
90 cbor_item_t *argv[7];
91 const uint8_t cmd = CTAP_CBOR_ASSERT;
92 int r;
93
94 memset(argv, 0, sizeof(argv));
95 memset(&f, 0, sizeof(f));
96
97 /* do we have everything we need? */
98 if (assert->rp_id == NULL || assert->cdh.ptr == NULL) {
99 fido_log_debug("%s: rp_id=%p, cdh.ptr=%p", __func__,
100 (void *)assert->rp_id, (void *)assert->cdh.ptr);
101 r = FIDO_ERR_INVALID_ARGUMENT;
102 goto fail;
103 }
104
105 if ((argv[0] = cbor_build_string(assert->rp_id)) == NULL ||
106 (argv[1] = fido_blob_encode(&assert->cdh)) == NULL) {
107 fido_log_debug("%s: cbor encode", __func__);
108 r = FIDO_ERR_INTERNAL;
109 goto fail;
110 }
111
112 /* allowed credentials */
113 if (assert->allow_list.len) {
114 const fido_blob_array_t *cl = &assert->allow_list;
115 if ((argv[2] = cbor_encode_pubkey_list(cl)) == NULL) {
116 fido_log_debug("%s: cbor_encode_pubkey_list", __func__);
117 r = FIDO_ERR_INTERNAL;
118 goto fail;
119 }
120 }
121
122 if (assert->ext.mask)
123 if ((argv[3] = cbor_encode_assert_ext(dev, &assert->ext, ecdh,
124 pk)) == NULL) {
125 fido_log_debug("%s: cbor_encode_assert_ext", __func__);
126 r = FIDO_ERR_INTERNAL;
127 goto fail;
128 }
129
130 /* user verification */
131 if (pin != NULL || fido_dev_puat_blob(dev) != NULL ||
132 (uv == FIDO_OPT_TRUE && fido_dev_supports_permissions(dev))) {
133 if ((r = cbor_add_uv_params(dev, cmd, &assert->cdh, pk, ecdh,
134 pin, assert->rp_id, &argv[5], &argv[6], ms)) != FIDO_OK) {
135 fido_log_debug("%s: cbor_add_uv_params", __func__);
136 goto fail;
137 }
138 uv = FIDO_OPT_OMIT;
139 }
140
141 /* options */
142 if (assert->up != FIDO_OPT_OMIT || uv != FIDO_OPT_OMIT)
143 if ((argv[4] = cbor_encode_assert_opt(assert->up, uv)) == NULL) {
144 fido_log_debug("%s: cbor_encode_assert_opt", __func__);
145 r = FIDO_ERR_INTERNAL;
146 goto fail;
147 }
148
149 /* frame and transmit */
150 if (cbor_build_frame(cmd, argv, nitems(argv), &f) < 0 ||
151 fido_tx(dev, CTAP_CMD_CBOR, f.ptr, f.len, ms) < 0) {
152 fido_log_debug("%s: fido_tx", __func__);
153 r = FIDO_ERR_TX;
154 goto fail;
155 }
156
157 r = FIDO_OK;
158 fail:
159 cbor_vector_free(argv, nitems(argv));
160 free(f.ptr);
161
162 return (r);
163 }
164
165 static int
166 fido_dev_get_assert_rx(fido_dev_t *dev, fido_assert_t *assert, int *ms)
167 {
168 unsigned char *msg;
169 int msglen;
170 int r;
171
172 fido_assert_reset_rx(assert);
173
174 if ((msg = malloc(FIDO_MAXMSG)) == NULL) {
175 r = FIDO_ERR_INTERNAL;
176 goto out;
177 }
178
179 if ((msglen = fido_rx(dev, CTAP_CMD_CBOR, msg, FIDO_MAXMSG, ms)) < 0) {
180 fido_log_debug("%s: fido_rx", __func__);
181 r = FIDO_ERR_RX;
182 goto out;
183 }
184
185 /* start with room for a single assertion */
186 if ((assert->stmt = calloc(1, sizeof(fido_assert_stmt))) == NULL) {
187 r = FIDO_ERR_INTERNAL;
188 goto out;
189 }
190 assert->stmt_len = 0;
191 assert->stmt_cnt = 1;
192
193 /* adjust as needed */
194 if ((r = cbor_parse_reply(msg, (size_t)msglen, assert,
195 adjust_assert_count)) != FIDO_OK) {
196 fido_log_debug("%s: adjust_assert_count", __func__);
197 goto out;
198 }
199
200 /* parse the first assertion */
201 if ((r = cbor_parse_reply(msg, (size_t)msglen, &assert->stmt[0],
202 parse_assert_reply)) != FIDO_OK) {
203 fido_log_debug("%s: parse_assert_reply", __func__);
204 goto out;
205 }
206 assert->stmt_len = 1;
207
208 r = FIDO_OK;
209 out:
210 freezero(msg, FIDO_MAXMSG);
211
212 return (r);
213 }
214
215 static int
216 fido_get_next_assert_tx(fido_dev_t *dev, int *ms)
217 {
218 const unsigned char cbor[] = { CTAP_CBOR_NEXT_ASSERT };
219
220 if (fido_tx(dev, CTAP_CMD_CBOR, cbor, sizeof(cbor), ms) < 0) {
221 fido_log_debug("%s: fido_tx", __func__);
222 return (FIDO_ERR_TX);
223 }
224
225 return (FIDO_OK);
226 }
227
228 static int
229 fido_get_next_assert_rx(fido_dev_t *dev, fido_assert_t *assert, int *ms)
230 {
231 unsigned char *msg;
232 int msglen;
233 int r;
234
235 if ((msg = malloc(FIDO_MAXMSG)) == NULL) {
236 r = FIDO_ERR_INTERNAL;
237 goto out;
238 }
239
240 if ((msglen = fido_rx(dev, CTAP_CMD_CBOR, msg, FIDO_MAXMSG, ms)) < 0) {
241 fido_log_debug("%s: fido_rx", __func__);
242 r = FIDO_ERR_RX;
243 goto out;
244 }
245
246 /* sanity check */
247 if (assert->stmt_len >= assert->stmt_cnt) {
248 fido_log_debug("%s: stmt_len=%zu, stmt_cnt=%zu", __func__,
249 assert->stmt_len, assert->stmt_cnt);
250 r = FIDO_ERR_INTERNAL;
251 goto out;
252 }
253
254 if ((r = cbor_parse_reply(msg, (size_t)msglen,
255 &assert->stmt[assert->stmt_len], parse_assert_reply)) != FIDO_OK) {
256 fido_log_debug("%s: parse_assert_reply", __func__);
257 goto out;
258 }
259
260 r = FIDO_OK;
261 out:
262 freezero(msg, FIDO_MAXMSG);
263
264 return (r);
265 }
266
267 static int
268 fido_dev_get_assert_wait(fido_dev_t *dev, fido_assert_t *assert,
269 const es256_pk_t *pk, const fido_blob_t *ecdh, const char *pin, int *ms)
270 {
271 int r;
272
273 if ((r = fido_dev_get_assert_tx(dev, assert, pk, ecdh, pin,
274 ms)) != FIDO_OK ||
275 (r = fido_dev_get_assert_rx(dev, assert, ms)) != FIDO_OK)
276 return (r);
277
278 while (assert->stmt_len < assert->stmt_cnt) {
279 if ((r = fido_get_next_assert_tx(dev, ms)) != FIDO_OK ||
280 (r = fido_get_next_assert_rx(dev, assert, ms)) != FIDO_OK)
281 return (r);
282 assert->stmt_len++;
283 }
284
285 return (FIDO_OK);
286 }
287
288 static int
289 decrypt_hmac_secrets(const fido_dev_t *dev, fido_assert_t *assert,
290 const fido_blob_t *key)
291 {
292 for (size_t i = 0; i < assert->stmt_cnt; i++) {
293 fido_assert_stmt *stmt = &assert->stmt[i];
294 if (stmt->authdata_ext.hmac_secret_enc.ptr != NULL) {
295 if (aes256_cbc_dec(dev, key,
296 &stmt->authdata_ext.hmac_secret_enc,
297 &stmt->hmac_secret) < 0) {
298 fido_log_debug("%s: aes256_cbc_dec %zu",
299 __func__, i);
300 return (-1);
301 }
302 }
303 }
304
305 return (0);
306 }
307
308 static bool
309 need_ecdh(const fido_dev_t *dev, const fido_assert_t *assert, const char *pin)
310 {
311 if (assert->ext.mask & FIDO_EXT_HMAC_SECRET)
312 return true;
313
314 /* If available, prefer cached PUAT */
315 if (fido_dev_puat_blob(dev) != NULL)
316 return false;
317
318 if (pin != NULL)
319 return true;
320
321 return assert->uv == FIDO_OPT_TRUE &&
322 fido_dev_supports_permissions(dev);
323 }
324
325 int
326 fido_dev_get_assert(fido_dev_t *dev, fido_assert_t *assert, const char *pin)
327 {
328 fido_blob_t *ecdh = NULL;
329 es256_pk_t *pk = NULL;
330 int ms = dev->timeout_ms;
331 int r;
332
333 #ifdef USE_WINHELLO
334 if (dev->flags & FIDO_DEV_WINHELLO)
335 return (fido_winhello_get_assert(dev, assert, pin, ms));
336 #endif
337
338 if (assert->rp_id == NULL || assert->cdh.ptr == NULL) {
339 fido_log_debug("%s: rp_id=%p, cdh.ptr=%p", __func__,
340 (void *)assert->rp_id, (void *)assert->cdh.ptr);
341 return (FIDO_ERR_INVALID_ARGUMENT);
342 }
343
344 if (fido_dev_is_fido2(dev) == false) {
345 if (pin != NULL || assert->ext.mask != 0)
346 return (FIDO_ERR_UNSUPPORTED_OPTION);
347 return (u2f_authenticate(dev, assert, &ms));
348 }
349
350 if (need_ecdh(dev, assert, pin) && (r = fido_do_ecdh(dev, &pk, &ecdh,
351 &ms)) != FIDO_OK) {
352 fido_log_debug("%s: fido_do_ecdh", __func__);
353 goto fail;
354 }
355
356 r = fido_dev_get_assert_wait(dev, assert, pk, ecdh, pin, &ms);
357 if (r == FIDO_OK && (assert->ext.mask & FIDO_EXT_HMAC_SECRET))
358 if (decrypt_hmac_secrets(dev, assert, ecdh) < 0) {
359 fido_log_debug("%s: decrypt_hmac_secrets", __func__);
360 r = FIDO_ERR_INTERNAL;
361 goto fail;
362 }
363
364 fail:
365 es256_pk_free(&pk);
366 fido_blob_free(&ecdh);
367
368 return (r);
369 }
370
371 int
372 fido_check_flags(uint8_t flags, fido_opt_t up, fido_opt_t uv)
373 {
374 fido_log_debug("%s: flags=%02x", __func__, flags);
375 fido_log_debug("%s: up=%d, uv=%d", __func__, up, uv);
376
377 if (up == FIDO_OPT_TRUE &&
378 (flags & CTAP_AUTHDATA_USER_PRESENT) == 0) {
379 fido_log_debug("%s: CTAP_AUTHDATA_USER_PRESENT", __func__);
380 return (-1); /* user not present */
381 }
382
383 if (uv == FIDO_OPT_TRUE &&
384 (flags & CTAP_AUTHDATA_USER_VERIFIED) == 0) {
385 fido_log_debug("%s: CTAP_AUTHDATA_USER_VERIFIED", __func__);
386 return (-1); /* user not verified */
387 }
388
389 return (0);
390 }
391
392 static int
393 check_extensions(int authdata_ext, int ext)
394 {
395 /* XXX: largeBlobKey is not part of extensions map */
396 ext &= ~FIDO_EXT_LARGEBLOB_KEY;
397 if (authdata_ext != ext) {
398 fido_log_debug("%s: authdata_ext=0x%x != ext=0x%x", __func__,
399 authdata_ext, ext);
400 return (-1);
401 }
402
403 return (0);
404 }
405
406 static int
407 get_es256_hash(fido_blob_t *dgst, const fido_blob_t *clientdata,
408 const fido_blob_t *authdata)
409 {
410 const EVP_MD *md;
411 EVP_MD_CTX *ctx = NULL;
412
413 if (dgst->len < SHA256_DIGEST_LENGTH ||
414 (md = EVP_sha256()) == NULL ||
415 (ctx = EVP_MD_CTX_new()) == NULL ||
416 EVP_DigestInit_ex(ctx, md, NULL) != 1 ||
417 EVP_DigestUpdate(ctx, authdata->ptr, authdata->len) != 1 ||
418 EVP_DigestUpdate(ctx, clientdata->ptr, clientdata->len) != 1 ||
419 EVP_DigestFinal_ex(ctx, dgst->ptr, NULL) != 1) {
420 EVP_MD_CTX_free(ctx);
421 return (-1);
422 }
423 dgst->len = SHA256_DIGEST_LENGTH;
424
425 EVP_MD_CTX_free(ctx);
426
427 return (0);
428 }
429
430 static int
431 get_es384_hash(fido_blob_t *dgst, const fido_blob_t *clientdata,
432 const fido_blob_t *authdata)
433 {
434 const EVP_MD *md;
435 EVP_MD_CTX *ctx = NULL;
436
437 if (dgst->len < SHA384_DIGEST_LENGTH ||
438 (md = EVP_sha384()) == NULL ||
439 (ctx = EVP_MD_CTX_new()) == NULL ||
440 EVP_DigestInit_ex(ctx, md, NULL) != 1 ||
441 EVP_DigestUpdate(ctx, authdata->ptr, authdata->len) != 1 ||
442 EVP_DigestUpdate(ctx, clientdata->ptr, clientdata->len) != 1 ||
443 EVP_DigestFinal_ex(ctx, dgst->ptr, NULL) != 1) {
444 EVP_MD_CTX_free(ctx);
445 return (-1);
446 }
447 dgst->len = SHA384_DIGEST_LENGTH;
448
449 EVP_MD_CTX_free(ctx);
450
451 return (0);
452 }
453
454 static int
455 get_eddsa_hash(fido_blob_t *dgst, const fido_blob_t *clientdata,
456 const fido_blob_t *authdata)
457 {
458 if (SIZE_MAX - authdata->len < clientdata->len ||
459 dgst->len < authdata->len + clientdata->len)
460 return (-1);
461
462 memcpy(dgst->ptr, authdata->ptr, authdata->len);
463 memcpy(dgst->ptr + authdata->len, clientdata->ptr, clientdata->len);
464 dgst->len = authdata->len + clientdata->len;
465
466 return (0);
467 }
468
469 int
470 fido_get_signed_hash(int cose_alg, fido_blob_t *dgst,
471 const fido_blob_t *clientdata, const fido_blob_t *authdata_cbor)
472 {
473 cbor_item_t *item = NULL;
474 fido_blob_t authdata;
475 struct cbor_load_result cbor;
476 int ok = -1;
477
478 fido_log_debug("%s: cose_alg=%d", __func__, cose_alg);
479
480 if ((item = cbor_load(authdata_cbor->ptr, authdata_cbor->len,
481 &cbor)) == NULL || cbor_isa_bytestring(item) == false ||
482 cbor_bytestring_is_definite(item) == false) {
483 fido_log_debug("%s: authdata", __func__);
484 goto fail;
485 }
486 authdata.ptr = cbor_bytestring_handle(item);
487 authdata.len = cbor_bytestring_length(item);
488
489 switch (cose_alg) {
490 case COSE_ES256:
491 case COSE_RS256:
492 ok = get_es256_hash(dgst, clientdata, &authdata);
493 break;
494 case COSE_ES384:
495 ok = get_es384_hash(dgst, clientdata, &authdata);
496 break;
497 case COSE_EDDSA:
498 ok = get_eddsa_hash(dgst, clientdata, &authdata);
499 break;
500 default:
501 fido_log_debug("%s: unknown cose_alg", __func__);
502 break;
503 }
504 fail:
505 if (item != NULL)
506 cbor_decref(&item);
507
508 return (ok);
509 }
510
511 int
512 fido_assert_verify(const fido_assert_t *assert, size_t idx, int cose_alg,
513 const void *pk)
514 {
515 unsigned char buf[1024]; /* XXX */
516 fido_blob_t dgst;
517 const fido_assert_stmt *stmt = NULL;
518 int ok = -1;
519 int r;
520
521 dgst.ptr = buf;
522 dgst.len = sizeof(buf);
523
524 if (idx >= assert->stmt_len || pk == NULL) {
525 r = FIDO_ERR_INVALID_ARGUMENT;
526 goto out;
527 }
528
529 stmt = &assert->stmt[idx];
530
531 /* do we have everything we need? */
532 if (assert->cdh.ptr == NULL || assert->rp_id == NULL ||
533 stmt->authdata_cbor.ptr == NULL || stmt->sig.ptr == NULL) {
534 fido_log_debug("%s: cdh=%p, rp_id=%s, authdata=%p, sig=%p",
535 __func__, (void *)assert->cdh.ptr, assert->rp_id,
536 (void *)stmt->authdata_cbor.ptr, (void *)stmt->sig.ptr);
537 r = FIDO_ERR_INVALID_ARGUMENT;
538 goto out;
539 }
540
541 if (fido_check_flags(stmt->authdata.flags, assert->up,
542 assert->uv) < 0) {
543 fido_log_debug("%s: fido_check_flags", __func__);
544 r = FIDO_ERR_INVALID_PARAM;
545 goto out;
546 }
547
548 if (check_extensions(stmt->authdata_ext.mask, assert->ext.mask) < 0) {
549 fido_log_debug("%s: check_extensions", __func__);
550 r = FIDO_ERR_INVALID_PARAM;
551 goto out;
552 }
553
554 if (fido_check_rp_id(assert->rp_id, stmt->authdata.rp_id_hash) != 0) {
555 fido_log_debug("%s: fido_check_rp_id", __func__);
556 r = FIDO_ERR_INVALID_PARAM;
557 goto out;
558 }
559
560 if (fido_get_signed_hash(cose_alg, &dgst, &assert->cdh,
561 &stmt->authdata_cbor) < 0) {
562 fido_log_debug("%s: fido_get_signed_hash", __func__);
563 r = FIDO_ERR_INTERNAL;
564 goto out;
565 }
566
567 switch (cose_alg) {
568 case COSE_ES256:
569 ok = es256_pk_verify_sig(&dgst, pk, &stmt->sig);
570 break;
571 case COSE_ES384:
572 ok = es384_pk_verify_sig(&dgst, pk, &stmt->sig);
573 break;
574 case COSE_RS256:
575 ok = rs256_pk_verify_sig(&dgst, pk, &stmt->sig);
576 break;
577 case COSE_EDDSA:
578 ok = eddsa_pk_verify_sig(&dgst, pk, &stmt->sig);
579 break;
580 default:
581 fido_log_debug("%s: unsupported cose_alg %d", __func__,
582 cose_alg);
583 r = FIDO_ERR_UNSUPPORTED_OPTION;
584 goto out;
585 }
586
587 if (ok < 0)
588 r = FIDO_ERR_INVALID_SIG;
589 else
590 r = FIDO_OK;
591 out:
592 explicit_bzero(buf, sizeof(buf));
593
594 return (r);
595 }
596
597 int
598 fido_assert_set_clientdata(fido_assert_t *assert, const unsigned char *data,
599 size_t data_len)
600 {
601 if (!fido_blob_is_empty(&assert->cdh) ||
602 fido_blob_set(&assert->cd, data, data_len) < 0) {
603 return (FIDO_ERR_INVALID_ARGUMENT);
604 }
605 if (fido_sha256(&assert->cdh, data, data_len) < 0) {
606 fido_blob_reset(&assert->cd);
607 return (FIDO_ERR_INTERNAL);
608 }
609
610 return (FIDO_OK);
611 }
612
613 int
614 fido_assert_set_clientdata_hash(fido_assert_t *assert,
615 const unsigned char *hash, size_t hash_len)
616 {
617 if (!fido_blob_is_empty(&assert->cd) ||
618 fido_blob_set(&assert->cdh, hash, hash_len) < 0)
619 return (FIDO_ERR_INVALID_ARGUMENT);
620
621 return (FIDO_OK);
622 }
623
624 int
625 fido_assert_set_hmac_salt(fido_assert_t *assert, const unsigned char *salt,
626 size_t salt_len)
627 {
628 if ((salt_len != 32 && salt_len != 64) ||
629 fido_blob_set(&assert->ext.hmac_salt, salt, salt_len) < 0)
630 return (FIDO_ERR_INVALID_ARGUMENT);
631
632 return (FIDO_OK);
633 }
634
635 int
636 fido_assert_set_hmac_secret(fido_assert_t *assert, size_t idx,
637 const unsigned char *secret, size_t secret_len)
638 {
639 if (idx >= assert->stmt_len || (secret_len != 32 && secret_len != 64) ||
640 fido_blob_set(&assert->stmt[idx].hmac_secret, secret,
641 secret_len) < 0)
642 return (FIDO_ERR_INVALID_ARGUMENT);
643
644 return (FIDO_OK);
645 }
646
647 int
648 fido_assert_set_rp(fido_assert_t *assert, const char *id)
649 {
650 if (assert->rp_id != NULL) {
651 free(assert->rp_id);
652 assert->rp_id = NULL;
653 }
654
655 if (id == NULL)
656 return (FIDO_ERR_INVALID_ARGUMENT);
657
658 if ((assert->rp_id = strdup(id)) == NULL)
659 return (FIDO_ERR_INTERNAL);
660
661 return (FIDO_OK);
662 }
663
664 #ifdef USE_WINHELLO
665 int
666 fido_assert_set_winhello_appid(fido_assert_t *assert, const char *id)
667 {
668 if (assert->appid != NULL) {
669 free(assert->appid);
670 assert->appid = NULL;
671 }
672
673 if (id == NULL)
674 return (FIDO_ERR_INVALID_ARGUMENT);
675
676 if ((assert->appid = strdup(id)) == NULL)
677 return (FIDO_ERR_INTERNAL);
678
679 return (FIDO_OK);
680 }
681 #else
682 int
683 fido_assert_set_winhello_appid(fido_assert_t *assert, const char *id)
684 {
685 (void)assert;
686 (void)id;
687
688 return (FIDO_ERR_UNSUPPORTED_EXTENSION);
689 }
690 #endif /* USE_WINHELLO */
691
692 int
693 fido_assert_allow_cred(fido_assert_t *assert, const unsigned char *ptr,
694 size_t len)
695 {
696 fido_blob_t id;
697 fido_blob_t *list_ptr;
698 int r;
699
700 memset(&id, 0, sizeof(id));
701
702 if (assert->allow_list.len == SIZE_MAX) {
703 r = FIDO_ERR_INVALID_ARGUMENT;
704 goto fail;
705 }
706
707 if (fido_blob_set(&id, ptr, len) < 0 || (list_ptr =
708 recallocarray(assert->allow_list.ptr, assert->allow_list.len,
709 assert->allow_list.len + 1, sizeof(fido_blob_t))) == NULL) {
710 r = FIDO_ERR_INVALID_ARGUMENT;
711 goto fail;
712 }
713
714 list_ptr[assert->allow_list.len++] = id;
715 assert->allow_list.ptr = list_ptr;
716
717 return (FIDO_OK);
718 fail:
719 free(id.ptr);
720
721 return (r);
722 }
723
724 int
725 fido_assert_empty_allow_list(fido_assert_t *assert)
726 {
727 fido_free_blob_array(&assert->allow_list);
728 memset(&assert->allow_list, 0, sizeof(assert->allow_list));
729
730 return (FIDO_OK);
731 }
732
733 int
734 fido_assert_set_extensions(fido_assert_t *assert, int ext)
735 {
736 if (ext == 0)
737 assert->ext.mask = 0;
738 else {
739 if ((ext & FIDO_EXT_ASSERT_MASK) != ext)
740 return (FIDO_ERR_INVALID_ARGUMENT);
741 assert->ext.mask |= ext;
742 }
743
744 return (FIDO_OK);
745 }
746
747 int
748 fido_assert_set_options(fido_assert_t *assert, bool up, bool uv)
749 {
750 assert->up = up ? FIDO_OPT_TRUE : FIDO_OPT_FALSE;
751 assert->uv = uv ? FIDO_OPT_TRUE : FIDO_OPT_FALSE;
752
753 return (FIDO_OK);
754 }
755
756 int
757 fido_assert_set_up(fido_assert_t *assert, fido_opt_t up)
758 {
759 assert->up = up;
760
761 return (FIDO_OK);
762 }
763
764 int
765 fido_assert_set_uv(fido_assert_t *assert, fido_opt_t uv)
766 {
767 assert->uv = uv;
768
769 return (FIDO_OK);
770 }
771
772 const unsigned char *
773 fido_assert_clientdata_hash_ptr(const fido_assert_t *assert)
774 {
775 return (assert->cdh.ptr);
776 }
777
778 size_t
779 fido_assert_clientdata_hash_len(const fido_assert_t *assert)
780 {
781 return (assert->cdh.len);
782 }
783
784 fido_assert_t *
785 fido_assert_new(void)
786 {
787 return (calloc(1, sizeof(fido_assert_t)));
788 }
789
790 void
791 fido_assert_reset_tx(fido_assert_t *assert)
792 {
793 free(assert->rp_id);
794 free(assert->appid);
795 fido_blob_reset(&assert->cd);
796 fido_blob_reset(&assert->cdh);
797 fido_blob_reset(&assert->ext.hmac_salt);
798 fido_assert_empty_allow_list(assert);
799 memset(&assert->ext, 0, sizeof(assert->ext));
800 assert->rp_id = NULL;
801 assert->appid = NULL;
802 assert->up = FIDO_OPT_OMIT;
803 assert->uv = FIDO_OPT_OMIT;
804 }
805
806 static void
807 fido_assert_reset_extattr(fido_assert_extattr_t *ext)
808 {
809 fido_blob_reset(&ext->hmac_secret_enc);
810 fido_blob_reset(&ext->blob);
811 memset(ext, 0, sizeof(*ext));
812 }
813
814 void
815 fido_assert_reset_rx(fido_assert_t *assert)
816 {
817 for (size_t i = 0; i < assert->stmt_cnt; i++) {
818 free(assert->stmt[i].user.icon);
819 free(assert->stmt[i].user.name);
820 free(assert->stmt[i].user.display_name);
821 fido_blob_reset(&assert->stmt[i].user.id);
822 fido_blob_reset(&assert->stmt[i].id);
823 fido_blob_reset(&assert->stmt[i].hmac_secret);
824 fido_blob_reset(&assert->stmt[i].authdata_cbor);
825 fido_blob_reset(&assert->stmt[i].authdata_raw);
826 fido_blob_reset(&assert->stmt[i].largeblob_key);
827 fido_blob_reset(&assert->stmt[i].sig);
828 fido_assert_reset_extattr(&assert->stmt[i].authdata_ext);
829 memset(&assert->stmt[i], 0, sizeof(assert->stmt[i]));
830 }
831 free(assert->stmt);
832 assert->stmt = NULL;
833 assert->stmt_len = 0;
834 assert->stmt_cnt = 0;
835 }
836
837 void
838 fido_assert_free(fido_assert_t **assert_p)
839 {
840 fido_assert_t *assert;
841
842 if (assert_p == NULL || (assert = *assert_p) == NULL)
843 return;
844 fido_assert_reset_tx(assert);
845 fido_assert_reset_rx(assert);
846 free(assert);
847 *assert_p = NULL;
848 }
849
850 size_t
851 fido_assert_count(const fido_assert_t *assert)
852 {
853 return (assert->stmt_len);
854 }
855
856 const char *
857 fido_assert_rp_id(const fido_assert_t *assert)
858 {
859 return (assert->rp_id);
860 }
861
862 uint8_t
863 fido_assert_flags(const fido_assert_t *assert, size_t idx)
864 {
865 if (idx >= assert->stmt_len)
866 return (0);
867
868 return (assert->stmt[idx].authdata.flags);
869 }
870
871 uint32_t
872 fido_assert_sigcount(const fido_assert_t *assert, size_t idx)
873 {
874 if (idx >= assert->stmt_len)
875 return (0);
876
877 return (assert->stmt[idx].authdata.sigcount);
878 }
879
880 const unsigned char *
881 fido_assert_authdata_ptr(const fido_assert_t *assert, size_t idx)
882 {
883 if (idx >= assert->stmt_len)
884 return (NULL);
885
886 return (assert->stmt[idx].authdata_cbor.ptr);
887 }
888
889 size_t
890 fido_assert_authdata_len(const fido_assert_t *assert, size_t idx)
891 {
892 if (idx >= assert->stmt_len)
893 return (0);
894
895 return (assert->stmt[idx].authdata_cbor.len);
896 }
897
898 const unsigned char *
899 fido_assert_authdata_raw_ptr(const fido_assert_t *assert, size_t idx)
900 {
901 if (idx >= assert->stmt_len)
902 return (NULL);
903
904 return (assert->stmt[idx].authdata_raw.ptr);
905 }
906
907 size_t
908 fido_assert_authdata_raw_len(const fido_assert_t *assert, size_t idx)
909 {
910 if (idx >= assert->stmt_len)
911 return (0);
912
913 return (assert->stmt[idx].authdata_raw.len);
914 }
915
916 const unsigned char *
917 fido_assert_sig_ptr(const fido_assert_t *assert, size_t idx)
918 {
919 if (idx >= assert->stmt_len)
920 return (NULL);
921
922 return (assert->stmt[idx].sig.ptr);
923 }
924
925 size_t
926 fido_assert_sig_len(const fido_assert_t *assert, size_t idx)
927 {
928 if (idx >= assert->stmt_len)
929 return (0);
930
931 return (assert->stmt[idx].sig.len);
932 }
933
934 const unsigned char *
935 fido_assert_id_ptr(const fido_assert_t *assert, size_t idx)
936 {
937 if (idx >= assert->stmt_len)
938 return (NULL);
939
940 return (assert->stmt[idx].id.ptr);
941 }
942
943 size_t
944 fido_assert_id_len(const fido_assert_t *assert, size_t idx)
945 {
946 if (idx >= assert->stmt_len)
947 return (0);
948
949 return (assert->stmt[idx].id.len);
950 }
951
952 const unsigned char *
953 fido_assert_user_id_ptr(const fido_assert_t *assert, size_t idx)
954 {
955 if (idx >= assert->stmt_len)
956 return (NULL);
957
958 return (assert->stmt[idx].user.id.ptr);
959 }
960
961 size_t
962 fido_assert_user_id_len(const fido_assert_t *assert, size_t idx)
963 {
964 if (idx >= assert->stmt_len)
965 return (0);
966
967 return (assert->stmt[idx].user.id.len);
968 }
969
970 const char *
971 fido_assert_user_icon(const fido_assert_t *assert, size_t idx)
972 {
973 if (idx >= assert->stmt_len)
974 return (NULL);
975
976 return (assert->stmt[idx].user.icon);
977 }
978
979 const char *
980 fido_assert_user_name(const fido_assert_t *assert, size_t idx)
981 {
982 if (idx >= assert->stmt_len)
983 return (NULL);
984
985 return (assert->stmt[idx].user.name);
986 }
987
988 const char *
989 fido_assert_user_display_name(const fido_assert_t *assert, size_t idx)
990 {
991 if (idx >= assert->stmt_len)
992 return (NULL);
993
994 return (assert->stmt[idx].user.display_name);
995 }
996
997 const unsigned char *
998 fido_assert_hmac_secret_ptr(const fido_assert_t *assert, size_t idx)
999 {
1000 if (idx >= assert->stmt_len)
1001 return (NULL);
1002
1003 return (assert->stmt[idx].hmac_secret.ptr);
1004 }
1005
1006 size_t
1007 fido_assert_hmac_secret_len(const fido_assert_t *assert, size_t idx)
1008 {
1009 if (idx >= assert->stmt_len)
1010 return (0);
1011
1012 return (assert->stmt[idx].hmac_secret.len);
1013 }
1014
1015 const unsigned char *
1016 fido_assert_largeblob_key_ptr(const fido_assert_t *assert, size_t idx)
1017 {
1018 if (idx >= assert->stmt_len)
1019 return (NULL);
1020
1021 return (assert->stmt[idx].largeblob_key.ptr);
1022 }
1023
1024 size_t
1025 fido_assert_largeblob_key_len(const fido_assert_t *assert, size_t idx)
1026 {
1027 if (idx >= assert->stmt_len)
1028 return (0);
1029
1030 return (assert->stmt[idx].largeblob_key.len);
1031 }
1032
1033 const unsigned char *
1034 fido_assert_blob_ptr(const fido_assert_t *assert, size_t idx)
1035 {
1036 if (idx >= assert->stmt_len)
1037 return (NULL);
1038
1039 return (assert->stmt[idx].authdata_ext.blob.ptr);
1040 }
1041
1042 size_t
1043 fido_assert_blob_len(const fido_assert_t *assert, size_t idx)
1044 {
1045 if (idx >= assert->stmt_len)
1046 return (0);
1047
1048 return (assert->stmt[idx].authdata_ext.blob.len);
1049 }
1050
1051 static void
1052 fido_assert_clean_authdata(fido_assert_stmt *stmt)
1053 {
1054 fido_blob_reset(&stmt->authdata_cbor);
1055 fido_blob_reset(&stmt->authdata_raw);
1056 fido_assert_reset_extattr(&stmt->authdata_ext);
1057 memset(&stmt->authdata, 0, sizeof(stmt->authdata));
1058 }
1059
1060 int
1061 fido_assert_set_authdata(fido_assert_t *assert, size_t idx,
1062 const unsigned char *ptr, size_t len)
1063 {
1064 cbor_item_t *item = NULL;
1065 fido_assert_stmt *stmt = NULL;
1066 struct cbor_load_result cbor;
1067 int r;
1068
1069 if (idx >= assert->stmt_len || ptr == NULL || len == 0)
1070 return (FIDO_ERR_INVALID_ARGUMENT);
1071
1072 stmt = &assert->stmt[idx];
1073 fido_assert_clean_authdata(stmt);
1074
1075 if ((item = cbor_load(ptr, len, &cbor)) == NULL) {
1076 fido_log_debug("%s: cbor_load", __func__);
1077 r = FIDO_ERR_INVALID_ARGUMENT;
1078 goto fail;
1079 }
1080
1081 if (fido_blob_decode(item, &stmt->authdata_raw) < 0) {
1082 fido_log_debug("%s: fido_blob_decode", __func__);
1083 r = FIDO_ERR_INTERNAL;
1084 goto fail;
1085 }
1086
1087 if (cbor_decode_assert_authdata(item, &stmt->authdata_cbor,
1088 &stmt->authdata, &stmt->authdata_ext) < 0) {
1089 fido_log_debug("%s: cbor_decode_assert_authdata", __func__);
1090 r = FIDO_ERR_INVALID_ARGUMENT;
1091 goto fail;
1092 }
1093
1094 r = FIDO_OK;
1095 fail:
1096 if (item != NULL)
1097 cbor_decref(&item);
1098
1099 if (r != FIDO_OK)
1100 fido_assert_clean_authdata(stmt);
1101
1102 return (r);
1103 }
1104
1105 int
1106 fido_assert_set_authdata_raw(fido_assert_t *assert, size_t idx,
1107 const unsigned char *ptr, size_t len)
1108 {
1109 cbor_item_t *item = NULL;
1110 fido_assert_stmt *stmt = NULL;
1111 int r;
1112
1113 if (idx >= assert->stmt_len || ptr == NULL || len == 0)
1114 return (FIDO_ERR_INVALID_ARGUMENT);
1115
1116 stmt = &assert->stmt[idx];
1117 fido_assert_clean_authdata(stmt);
1118
1119 if (fido_blob_set(&stmt->authdata_raw, ptr, len) < 0) {
1120 fido_log_debug("%s: fido_blob_set", __func__);
1121 r = FIDO_ERR_INTERNAL;
1122 goto fail;
1123 }
1124
1125 if ((item = cbor_build_bytestring(ptr, len)) == NULL) {
1126 fido_log_debug("%s: cbor_build_bytestring", __func__);
1127 r = FIDO_ERR_INTERNAL;
1128 goto fail;
1129 }
1130
1131 if (cbor_decode_assert_authdata(item, &stmt->authdata_cbor,
1132 &stmt->authdata, &stmt->authdata_ext) < 0) {
1133 fido_log_debug("%s: cbor_decode_assert_authdata", __func__);
1134 r = FIDO_ERR_INVALID_ARGUMENT;
1135 goto fail;
1136 }
1137
1138 r = FIDO_OK;
1139 fail:
1140 if (item != NULL)
1141 cbor_decref(&item);
1142
1143 if (r != FIDO_OK)
1144 fido_assert_clean_authdata(stmt);
1145
1146 return (r);
1147 }
1148
1149 int
1150 fido_assert_set_sig(fido_assert_t *a, size_t idx, const unsigned char *ptr,
1151 size_t len)
1152 {
1153 if (idx >= a->stmt_len || ptr == NULL || len == 0)
1154 return (FIDO_ERR_INVALID_ARGUMENT);
1155 if (fido_blob_set(&a->stmt[idx].sig, ptr, len) < 0)
1156 return (FIDO_ERR_INTERNAL);
1157
1158 return (FIDO_OK);
1159 }
1160
1161 /* XXX shrinking leaks memory; fortunately that shouldn't happen */
1162 int
1163 fido_assert_set_count(fido_assert_t *assert, size_t n)
1164 {
1165 void *new_stmt;
1166
1167 #ifdef FIDO_FUZZ
1168 if (n > UINT8_MAX) {
1169 fido_log_debug("%s: n > UINT8_MAX", __func__);
1170 return (FIDO_ERR_INTERNAL);
1171 }
1172 #endif
1173
1174 new_stmt = recallocarray(assert->stmt, assert->stmt_cnt, n,
1175 sizeof(fido_assert_stmt));
1176 if (new_stmt == NULL)
1177 return (FIDO_ERR_INTERNAL);
1178
1179 assert->stmt = new_stmt;
1180 assert->stmt_cnt = n;
1181 assert->stmt_len = n;
1182
1183 return (FIDO_OK);
1184 }