xref: /freebsd/contrib/libfido2/src/assert.c (revision 60a517b66a69b8c011b04063ef63a938738719bd) 
1 /*
2  * Copyright (c) 2018-2023 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 || (uv == FIDO_OPT_TRUE &&
132 	    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 int
309 fido_dev_get_assert(fido_dev_t *dev, fido_assert_t *assert, const char *pin)
310 {
311 	fido_blob_t	*ecdh = NULL;
312 	es256_pk_t	*pk = NULL;
313 	int		 ms = dev->timeout_ms;
314 	int		 r;
315 
316 #ifdef USE_WINHELLO
317 	if (dev->flags & FIDO_DEV_WINHELLO)
318 		return (fido_winhello_get_assert(dev, assert, pin, ms));
319 #endif
320 
321 	if (assert->rp_id == NULL || assert->cdh.ptr == NULL) {
322 		fido_log_debug("%s: rp_id=%p, cdh.ptr=%p", __func__,
323 		    (void *)assert->rp_id, (void *)assert->cdh.ptr);
324 		return (FIDO_ERR_INVALID_ARGUMENT);
325 	}
326 
327 	if (fido_dev_is_fido2(dev) == false) {
328 		if (pin != NULL || assert->ext.mask != 0)
329 			return (FIDO_ERR_UNSUPPORTED_OPTION);
330 		return (u2f_authenticate(dev, assert, &ms));
331 	}
332 
333 	if (pin != NULL || (assert->uv == FIDO_OPT_TRUE &&
334 	    fido_dev_supports_permissions(dev)) ||
335 	    (assert->ext.mask & FIDO_EXT_HMAC_SECRET)) {
336 		if ((r = fido_do_ecdh(dev, &pk, &ecdh, &ms)) != FIDO_OK) {
337 			fido_log_debug("%s: fido_do_ecdh", __func__);
338 			goto fail;
339 		}
340 	}
341 
342 	r = fido_dev_get_assert_wait(dev, assert, pk, ecdh, pin, &ms);
343 	if (r == FIDO_OK && (assert->ext.mask & FIDO_EXT_HMAC_SECRET))
344 		if (decrypt_hmac_secrets(dev, assert, ecdh) < 0) {
345 			fido_log_debug("%s: decrypt_hmac_secrets", __func__);
346 			r = FIDO_ERR_INTERNAL;
347 			goto fail;
348 		}
349 
350 fail:
351 	es256_pk_free(&pk);
352 	fido_blob_free(&ecdh);
353 
354 	return (r);
355 }
356 
357 int
358 fido_check_flags(uint8_t flags, fido_opt_t up, fido_opt_t uv)
359 {
360 	fido_log_debug("%s: flags=%02x", __func__, flags);
361 	fido_log_debug("%s: up=%d, uv=%d", __func__, up, uv);
362 
363 	if (up == FIDO_OPT_TRUE &&
364 	    (flags & CTAP_AUTHDATA_USER_PRESENT) == 0) {
365 		fido_log_debug("%s: CTAP_AUTHDATA_USER_PRESENT", __func__);
366 		return (-1); /* user not present */
367 	}
368 
369 	if (uv == FIDO_OPT_TRUE &&
370 	    (flags & CTAP_AUTHDATA_USER_VERIFIED) == 0) {
371 		fido_log_debug("%s: CTAP_AUTHDATA_USER_VERIFIED", __func__);
372 		return (-1); /* user not verified */
373 	}
374 
375 	return (0);
376 }
377 
378 static int
379 check_extensions(int authdata_ext, int ext)
380 {
381 	/* XXX: largeBlobKey is not part of extensions map */
382 	ext &= ~FIDO_EXT_LARGEBLOB_KEY;
383 	if (authdata_ext != ext) {
384 		fido_log_debug("%s: authdata_ext=0x%x != ext=0x%x", __func__,
385 		    authdata_ext, ext);
386 		return (-1);
387 	}
388 
389 	return (0);
390 }
391 
392 static int
393 get_es256_hash(fido_blob_t *dgst, const fido_blob_t *clientdata,
394     const fido_blob_t *authdata)
395 {
396 	const EVP_MD	*md;
397 	EVP_MD_CTX	*ctx = NULL;
398 
399 	if (dgst->len < SHA256_DIGEST_LENGTH ||
400 	    (md = EVP_sha256()) == NULL ||
401 	    (ctx = EVP_MD_CTX_new()) == NULL ||
402 	    EVP_DigestInit_ex(ctx, md, NULL) != 1 ||
403 	    EVP_DigestUpdate(ctx, authdata->ptr, authdata->len) != 1 ||
404 	    EVP_DigestUpdate(ctx, clientdata->ptr, clientdata->len) != 1 ||
405 	    EVP_DigestFinal_ex(ctx, dgst->ptr, NULL) != 1) {
406 		EVP_MD_CTX_free(ctx);
407 		return (-1);
408 	}
409 	dgst->len = SHA256_DIGEST_LENGTH;
410 
411 	EVP_MD_CTX_free(ctx);
412 
413 	return (0);
414 }
415 
416 static int
417 get_es384_hash(fido_blob_t *dgst, const fido_blob_t *clientdata,
418     const fido_blob_t *authdata)
419 {
420 	const EVP_MD	*md;
421 	EVP_MD_CTX	*ctx = NULL;
422 
423 	if (dgst->len < SHA384_DIGEST_LENGTH ||
424 	    (md = EVP_sha384()) == NULL ||
425 	    (ctx = EVP_MD_CTX_new()) == NULL ||
426 	    EVP_DigestInit_ex(ctx, md, NULL) != 1 ||
427 	    EVP_DigestUpdate(ctx, authdata->ptr, authdata->len) != 1 ||
428 	    EVP_DigestUpdate(ctx, clientdata->ptr, clientdata->len) != 1 ||
429 	    EVP_DigestFinal_ex(ctx, dgst->ptr, NULL) != 1) {
430 		EVP_MD_CTX_free(ctx);
431 		return (-1);
432 	}
433 	dgst->len = SHA384_DIGEST_LENGTH;
434 
435 	EVP_MD_CTX_free(ctx);
436 
437 	return (0);
438 }
439 
440 static int
441 get_eddsa_hash(fido_blob_t *dgst, const fido_blob_t *clientdata,
442     const fido_blob_t *authdata)
443 {
444 	if (SIZE_MAX - authdata->len < clientdata->len ||
445 	    dgst->len < authdata->len + clientdata->len)
446 		return (-1);
447 
448 	memcpy(dgst->ptr, authdata->ptr, authdata->len);
449 	memcpy(dgst->ptr + authdata->len, clientdata->ptr, clientdata->len);
450 	dgst->len = authdata->len + clientdata->len;
451 
452 	return (0);
453 }
454 
455 int
456 fido_get_signed_hash(int cose_alg, fido_blob_t *dgst,
457     const fido_blob_t *clientdata, const fido_blob_t *authdata_cbor)
458 {
459 	cbor_item_t		*item = NULL;
460 	fido_blob_t		 authdata;
461 	struct cbor_load_result	 cbor;
462 	int			 ok = -1;
463 
464 	fido_log_debug("%s: cose_alg=%d", __func__, cose_alg);
465 
466 	if ((item = cbor_load(authdata_cbor->ptr, authdata_cbor->len,
467 	    &cbor)) == NULL || cbor_isa_bytestring(item) == false ||
468 	    cbor_bytestring_is_definite(item) == false) {
469 		fido_log_debug("%s: authdata", __func__);
470 		goto fail;
471 	}
472 	authdata.ptr = cbor_bytestring_handle(item);
473 	authdata.len = cbor_bytestring_length(item);
474 
475 	switch (cose_alg) {
476 	case COSE_ES256:
477 	case COSE_RS256:
478 		ok = get_es256_hash(dgst, clientdata, &authdata);
479 		break;
480 	case COSE_ES384:
481 		ok = get_es384_hash(dgst, clientdata, &authdata);
482 		break;
483 	case COSE_EDDSA:
484 		ok = get_eddsa_hash(dgst, clientdata, &authdata);
485 		break;
486 	default:
487 		fido_log_debug("%s: unknown cose_alg", __func__);
488 		break;
489 	}
490 fail:
491 	if (item != NULL)
492 		cbor_decref(&item);
493 
494 	return (ok);
495 }
496 
497 int
498 fido_assert_verify(const fido_assert_t *assert, size_t idx, int cose_alg,
499     const void *pk)
500 {
501 	unsigned char		 buf[1024]; /* XXX */
502 	fido_blob_t		 dgst;
503 	const fido_assert_stmt	*stmt = NULL;
504 	int			 ok = -1;
505 	int			 r;
506 
507 	dgst.ptr = buf;
508 	dgst.len = sizeof(buf);
509 
510 	if (idx >= assert->stmt_len || pk == NULL) {
511 		r = FIDO_ERR_INVALID_ARGUMENT;
512 		goto out;
513 	}
514 
515 	stmt = &assert->stmt[idx];
516 
517 	/* do we have everything we need? */
518 	if (assert->cdh.ptr == NULL || assert->rp_id == NULL ||
519 	    stmt->authdata_cbor.ptr == NULL || stmt->sig.ptr == NULL) {
520 		fido_log_debug("%s: cdh=%p, rp_id=%s, authdata=%p, sig=%p",
521 		    __func__, (void *)assert->cdh.ptr, assert->rp_id,
522 		    (void *)stmt->authdata_cbor.ptr, (void *)stmt->sig.ptr);
523 		r = FIDO_ERR_INVALID_ARGUMENT;
524 		goto out;
525 	}
526 
527 	if (fido_check_flags(stmt->authdata.flags, assert->up,
528 	    assert->uv) < 0) {
529 		fido_log_debug("%s: fido_check_flags", __func__);
530 		r = FIDO_ERR_INVALID_PARAM;
531 		goto out;
532 	}
533 
534 	if (check_extensions(stmt->authdata_ext.mask, assert->ext.mask) < 0) {
535 		fido_log_debug("%s: check_extensions", __func__);
536 		r = FIDO_ERR_INVALID_PARAM;
537 		goto out;
538 	}
539 
540 	if (fido_check_rp_id(assert->rp_id, stmt->authdata.rp_id_hash) != 0) {
541 		fido_log_debug("%s: fido_check_rp_id", __func__);
542 		r = FIDO_ERR_INVALID_PARAM;
543 		goto out;
544 	}
545 
546 	if (fido_get_signed_hash(cose_alg, &dgst, &assert->cdh,
547 	    &stmt->authdata_cbor) < 0) {
548 		fido_log_debug("%s: fido_get_signed_hash", __func__);
549 		r = FIDO_ERR_INTERNAL;
550 		goto out;
551 	}
552 
553 	switch (cose_alg) {
554 	case COSE_ES256:
555 		ok = es256_pk_verify_sig(&dgst, pk, &stmt->sig);
556 		break;
557 	case COSE_ES384:
558 		ok = es384_pk_verify_sig(&dgst, pk, &stmt->sig);
559 		break;
560 	case COSE_RS256:
561 		ok = rs256_pk_verify_sig(&dgst, pk, &stmt->sig);
562 		break;
563 	case COSE_EDDSA:
564 		ok = eddsa_pk_verify_sig(&dgst, pk, &stmt->sig);
565 		break;
566 	default:
567 		fido_log_debug("%s: unsupported cose_alg %d", __func__,
568 		    cose_alg);
569 		r = FIDO_ERR_UNSUPPORTED_OPTION;
570 		goto out;
571 	}
572 
573 	if (ok < 0)
574 		r = FIDO_ERR_INVALID_SIG;
575 	else
576 		r = FIDO_OK;
577 out:
578 	explicit_bzero(buf, sizeof(buf));
579 
580 	return (r);
581 }
582 
583 int
584 fido_assert_set_clientdata(fido_assert_t *assert, const unsigned char *data,
585     size_t data_len)
586 {
587 	if (!fido_blob_is_empty(&assert->cdh) ||
588 	    fido_blob_set(&assert->cd, data, data_len) < 0) {
589 		return (FIDO_ERR_INVALID_ARGUMENT);
590 	}
591 	if (fido_sha256(&assert->cdh, data, data_len) < 0) {
592 		fido_blob_reset(&assert->cd);
593 		return (FIDO_ERR_INTERNAL);
594 	}
595 
596 	return (FIDO_OK);
597 }
598 
599 int
600 fido_assert_set_clientdata_hash(fido_assert_t *assert,
601     const unsigned char *hash, size_t hash_len)
602 {
603 	if (!fido_blob_is_empty(&assert->cd) ||
604 	    fido_blob_set(&assert->cdh, hash, hash_len) < 0)
605 		return (FIDO_ERR_INVALID_ARGUMENT);
606 
607 	return (FIDO_OK);
608 }
609 
610 int
611 fido_assert_set_hmac_salt(fido_assert_t *assert, const unsigned char *salt,
612     size_t salt_len)
613 {
614 	if ((salt_len != 32 && salt_len != 64) ||
615 	    fido_blob_set(&assert->ext.hmac_salt, salt, salt_len) < 0)
616 		return (FIDO_ERR_INVALID_ARGUMENT);
617 
618 	return (FIDO_OK);
619 }
620 
621 int
622 fido_assert_set_hmac_secret(fido_assert_t *assert, size_t idx,
623     const unsigned char *secret, size_t secret_len)
624 {
625 	if (idx >= assert->stmt_len || (secret_len != 32 && secret_len != 64) ||
626 	    fido_blob_set(&assert->stmt[idx].hmac_secret, secret,
627 	    secret_len) < 0)
628 		return (FIDO_ERR_INVALID_ARGUMENT);
629 
630 	return (FIDO_OK);
631 }
632 
633 int
634 fido_assert_set_rp(fido_assert_t *assert, const char *id)
635 {
636 	if (assert->rp_id != NULL) {
637 		free(assert->rp_id);
638 		assert->rp_id = NULL;
639 	}
640 
641 	if (id == NULL)
642 		return (FIDO_ERR_INVALID_ARGUMENT);
643 
644 	if ((assert->rp_id = strdup(id)) == NULL)
645 		return (FIDO_ERR_INTERNAL);
646 
647 	return (FIDO_OK);
648 }
649 
650 #ifdef USE_WINHELLO
651 int
652 fido_assert_set_winhello_appid(fido_assert_t *assert, const char *id)
653 {
654 	if (assert->appid != NULL) {
655 		free(assert->appid);
656 		assert->appid = NULL;
657 	}
658 
659 	if (id == NULL)
660 		return (FIDO_ERR_INVALID_ARGUMENT);
661 
662 	if ((assert->appid = strdup(id)) == NULL)
663 		return (FIDO_ERR_INTERNAL);
664 
665 	return (FIDO_OK);
666 }
667 #else
668 int
669 fido_assert_set_winhello_appid(fido_assert_t *assert, const char *id)
670 {
671 	(void)assert;
672 	(void)id;
673 
674 	return (FIDO_ERR_UNSUPPORTED_EXTENSION);
675 }
676 #endif /* USE_WINHELLO */
677 
678 int
679 fido_assert_allow_cred(fido_assert_t *assert, const unsigned char *ptr,
680     size_t len)
681 {
682 	fido_blob_t	 id;
683 	fido_blob_t	*list_ptr;
684 	int		 r;
685 
686 	memset(&id, 0, sizeof(id));
687 
688 	if (assert->allow_list.len == SIZE_MAX) {
689 		r = FIDO_ERR_INVALID_ARGUMENT;
690 		goto fail;
691 	}
692 
693 	if (fido_blob_set(&id, ptr, len) < 0 || (list_ptr =
694 	    recallocarray(assert->allow_list.ptr, assert->allow_list.len,
695 	    assert->allow_list.len + 1, sizeof(fido_blob_t))) == NULL) {
696 		r = FIDO_ERR_INVALID_ARGUMENT;
697 		goto fail;
698 	}
699 
700 	list_ptr[assert->allow_list.len++] = id;
701 	assert->allow_list.ptr = list_ptr;
702 
703 	return (FIDO_OK);
704 fail:
705 	free(id.ptr);
706 
707 	return (r);
708 }
709 
710 int
711 fido_assert_empty_allow_list(fido_assert_t *assert)
712 {
713 	fido_free_blob_array(&assert->allow_list);
714 	memset(&assert->allow_list, 0, sizeof(assert->allow_list));
715 
716 	return (FIDO_OK);
717 }
718 
719 int
720 fido_assert_set_extensions(fido_assert_t *assert, int ext)
721 {
722 	if (ext == 0)
723 		assert->ext.mask = 0;
724 	else {
725 		if ((ext & FIDO_EXT_ASSERT_MASK) != ext)
726 			return (FIDO_ERR_INVALID_ARGUMENT);
727 		assert->ext.mask |= ext;
728 	}
729 
730 	return (FIDO_OK);
731 }
732 
733 int
734 fido_assert_set_options(fido_assert_t *assert, bool up, bool uv)
735 {
736 	assert->up = up ? FIDO_OPT_TRUE : FIDO_OPT_FALSE;
737 	assert->uv = uv ? FIDO_OPT_TRUE : FIDO_OPT_FALSE;
738 
739 	return (FIDO_OK);
740 }
741 
742 int
743 fido_assert_set_up(fido_assert_t *assert, fido_opt_t up)
744 {
745 	assert->up = up;
746 
747 	return (FIDO_OK);
748 }
749 
750 int
751 fido_assert_set_uv(fido_assert_t *assert, fido_opt_t uv)
752 {
753 	assert->uv = uv;
754 
755 	return (FIDO_OK);
756 }
757 
758 const unsigned char *
759 fido_assert_clientdata_hash_ptr(const fido_assert_t *assert)
760 {
761 	return (assert->cdh.ptr);
762 }
763 
764 size_t
765 fido_assert_clientdata_hash_len(const fido_assert_t *assert)
766 {
767 	return (assert->cdh.len);
768 }
769 
770 fido_assert_t *
771 fido_assert_new(void)
772 {
773 	return (calloc(1, sizeof(fido_assert_t)));
774 }
775 
776 void
777 fido_assert_reset_tx(fido_assert_t *assert)
778 {
779 	free(assert->rp_id);
780 	free(assert->appid);
781 	fido_blob_reset(&assert->cd);
782 	fido_blob_reset(&assert->cdh);
783 	fido_blob_reset(&assert->ext.hmac_salt);
784 	fido_assert_empty_allow_list(assert);
785 	memset(&assert->ext, 0, sizeof(assert->ext));
786 	assert->rp_id = NULL;
787 	assert->appid = NULL;
788 	assert->up = FIDO_OPT_OMIT;
789 	assert->uv = FIDO_OPT_OMIT;
790 }
791 
792 static void
793 fido_assert_reset_extattr(fido_assert_extattr_t *ext)
794 {
795 	fido_blob_reset(&ext->hmac_secret_enc);
796 	fido_blob_reset(&ext->blob);
797 	memset(ext, 0, sizeof(*ext));
798 }
799 
800 void
801 fido_assert_reset_rx(fido_assert_t *assert)
802 {
803 	for (size_t i = 0; i < assert->stmt_cnt; i++) {
804 		free(assert->stmt[i].user.icon);
805 		free(assert->stmt[i].user.name);
806 		free(assert->stmt[i].user.display_name);
807 		fido_blob_reset(&assert->stmt[i].user.id);
808 		fido_blob_reset(&assert->stmt[i].id);
809 		fido_blob_reset(&assert->stmt[i].hmac_secret);
810 		fido_blob_reset(&assert->stmt[i].authdata_cbor);
811 		fido_blob_reset(&assert->stmt[i].authdata_raw);
812 		fido_blob_reset(&assert->stmt[i].largeblob_key);
813 		fido_blob_reset(&assert->stmt[i].sig);
814 		fido_assert_reset_extattr(&assert->stmt[i].authdata_ext);
815 		memset(&assert->stmt[i], 0, sizeof(assert->stmt[i]));
816 	}
817 	free(assert->stmt);
818 	assert->stmt = NULL;
819 	assert->stmt_len = 0;
820 	assert->stmt_cnt = 0;
821 }
822 
823 void
824 fido_assert_free(fido_assert_t **assert_p)
825 {
826 	fido_assert_t *assert;
827 
828 	if (assert_p == NULL || (assert = *assert_p) == NULL)
829 		return;
830 	fido_assert_reset_tx(assert);
831 	fido_assert_reset_rx(assert);
832 	free(assert);
833 	*assert_p = NULL;
834 }
835 
836 size_t
837 fido_assert_count(const fido_assert_t *assert)
838 {
839 	return (assert->stmt_len);
840 }
841 
842 const char *
843 fido_assert_rp_id(const fido_assert_t *assert)
844 {
845 	return (assert->rp_id);
846 }
847 
848 uint8_t
849 fido_assert_flags(const fido_assert_t *assert, size_t idx)
850 {
851 	if (idx >= assert->stmt_len)
852 		return (0);
853 
854 	return (assert->stmt[idx].authdata.flags);
855 }
856 
857 uint32_t
858 fido_assert_sigcount(const fido_assert_t *assert, size_t idx)
859 {
860 	if (idx >= assert->stmt_len)
861 		return (0);
862 
863 	return (assert->stmt[idx].authdata.sigcount);
864 }
865 
866 const unsigned char *
867 fido_assert_authdata_ptr(const fido_assert_t *assert, size_t idx)
868 {
869 	if (idx >= assert->stmt_len)
870 		return (NULL);
871 
872 	return (assert->stmt[idx].authdata_cbor.ptr);
873 }
874 
875 size_t
876 fido_assert_authdata_len(const fido_assert_t *assert, size_t idx)
877 {
878 	if (idx >= assert->stmt_len)
879 		return (0);
880 
881 	return (assert->stmt[idx].authdata_cbor.len);
882 }
883 
884 const unsigned char *
885 fido_assert_authdata_raw_ptr(const fido_assert_t *assert, size_t idx)
886 {
887 	if (idx >= assert->stmt_len)
888 		return (NULL);
889 
890 	return (assert->stmt[idx].authdata_raw.ptr);
891 }
892 
893 size_t
894 fido_assert_authdata_raw_len(const fido_assert_t *assert, size_t idx)
895 {
896 	if (idx >= assert->stmt_len)
897 		return (0);
898 
899 	return (assert->stmt[idx].authdata_raw.len);
900 }
901 
902 const unsigned char *
903 fido_assert_sig_ptr(const fido_assert_t *assert, size_t idx)
904 {
905 	if (idx >= assert->stmt_len)
906 		return (NULL);
907 
908 	return (assert->stmt[idx].sig.ptr);
909 }
910 
911 size_t
912 fido_assert_sig_len(const fido_assert_t *assert, size_t idx)
913 {
914 	if (idx >= assert->stmt_len)
915 		return (0);
916 
917 	return (assert->stmt[idx].sig.len);
918 }
919 
920 const unsigned char *
921 fido_assert_id_ptr(const fido_assert_t *assert, size_t idx)
922 {
923 	if (idx >= assert->stmt_len)
924 		return (NULL);
925 
926 	return (assert->stmt[idx].id.ptr);
927 }
928 
929 size_t
930 fido_assert_id_len(const fido_assert_t *assert, size_t idx)
931 {
932 	if (idx >= assert->stmt_len)
933 		return (0);
934 
935 	return (assert->stmt[idx].id.len);
936 }
937 
938 const unsigned char *
939 fido_assert_user_id_ptr(const fido_assert_t *assert, size_t idx)
940 {
941 	if (idx >= assert->stmt_len)
942 		return (NULL);
943 
944 	return (assert->stmt[idx].user.id.ptr);
945 }
946 
947 size_t
948 fido_assert_user_id_len(const fido_assert_t *assert, size_t idx)
949 {
950 	if (idx >= assert->stmt_len)
951 		return (0);
952 
953 	return (assert->stmt[idx].user.id.len);
954 }
955 
956 const char *
957 fido_assert_user_icon(const fido_assert_t *assert, size_t idx)
958 {
959 	if (idx >= assert->stmt_len)
960 		return (NULL);
961 
962 	return (assert->stmt[idx].user.icon);
963 }
964 
965 const char *
966 fido_assert_user_name(const fido_assert_t *assert, size_t idx)
967 {
968 	if (idx >= assert->stmt_len)
969 		return (NULL);
970 
971 	return (assert->stmt[idx].user.name);
972 }
973 
974 const char *
975 fido_assert_user_display_name(const fido_assert_t *assert, size_t idx)
976 {
977 	if (idx >= assert->stmt_len)
978 		return (NULL);
979 
980 	return (assert->stmt[idx].user.display_name);
981 }
982 
983 const unsigned char *
984 fido_assert_hmac_secret_ptr(const fido_assert_t *assert, size_t idx)
985 {
986 	if (idx >= assert->stmt_len)
987 		return (NULL);
988 
989 	return (assert->stmt[idx].hmac_secret.ptr);
990 }
991 
992 size_t
993 fido_assert_hmac_secret_len(const fido_assert_t *assert, size_t idx)
994 {
995 	if (idx >= assert->stmt_len)
996 		return (0);
997 
998 	return (assert->stmt[idx].hmac_secret.len);
999 }
1000 
1001 const unsigned char *
1002 fido_assert_largeblob_key_ptr(const fido_assert_t *assert, size_t idx)
1003 {
1004 	if (idx >= assert->stmt_len)
1005 		return (NULL);
1006 
1007 	return (assert->stmt[idx].largeblob_key.ptr);
1008 }
1009 
1010 size_t
1011 fido_assert_largeblob_key_len(const fido_assert_t *assert, size_t idx)
1012 {
1013 	if (idx >= assert->stmt_len)
1014 		return (0);
1015 
1016 	return (assert->stmt[idx].largeblob_key.len);
1017 }
1018 
1019 const unsigned char *
1020 fido_assert_blob_ptr(const fido_assert_t *assert, size_t idx)
1021 {
1022 	if (idx >= assert->stmt_len)
1023 		return (NULL);
1024 
1025 	return (assert->stmt[idx].authdata_ext.blob.ptr);
1026 }
1027 
1028 size_t
1029 fido_assert_blob_len(const fido_assert_t *assert, size_t idx)
1030 {
1031 	if (idx >= assert->stmt_len)
1032 		return (0);
1033 
1034 	return (assert->stmt[idx].authdata_ext.blob.len);
1035 }
1036 
1037 static void
1038 fido_assert_clean_authdata(fido_assert_stmt *stmt)
1039 {
1040 	fido_blob_reset(&stmt->authdata_cbor);
1041 	fido_blob_reset(&stmt->authdata_raw);
1042 	fido_assert_reset_extattr(&stmt->authdata_ext);
1043 	memset(&stmt->authdata, 0, sizeof(stmt->authdata));
1044 }
1045 
1046 int
1047 fido_assert_set_authdata(fido_assert_t *assert, size_t idx,
1048     const unsigned char *ptr, size_t len)
1049 {
1050 	cbor_item_t		*item = NULL;
1051 	fido_assert_stmt	*stmt = NULL;
1052 	struct cbor_load_result	 cbor;
1053 	int			 r;
1054 
1055 	if (idx >= assert->stmt_len || ptr == NULL || len == 0)
1056 		return (FIDO_ERR_INVALID_ARGUMENT);
1057 
1058 	stmt = &assert->stmt[idx];
1059 	fido_assert_clean_authdata(stmt);
1060 
1061 	if ((item = cbor_load(ptr, len, &cbor)) == NULL) {
1062 		fido_log_debug("%s: cbor_load", __func__);
1063 		r = FIDO_ERR_INVALID_ARGUMENT;
1064 		goto fail;
1065 	}
1066 
1067 	if (fido_blob_decode(item, &stmt->authdata_raw) < 0) {
1068 	    fido_log_debug("%s: fido_blob_decode", __func__);
1069 	    r = FIDO_ERR_INTERNAL;
1070 	    goto fail;
1071 	}
1072 
1073 	if (cbor_decode_assert_authdata(item, &stmt->authdata_cbor,
1074 	    &stmt->authdata, &stmt->authdata_ext) < 0) {
1075 		fido_log_debug("%s: cbor_decode_assert_authdata", __func__);
1076 		r = FIDO_ERR_INVALID_ARGUMENT;
1077 		goto fail;
1078 	}
1079 
1080 	r = FIDO_OK;
1081 fail:
1082 	if (item != NULL)
1083 		cbor_decref(&item);
1084 
1085 	if (r != FIDO_OK)
1086 		fido_assert_clean_authdata(stmt);
1087 
1088 	return (r);
1089 }
1090 
1091 int
1092 fido_assert_set_authdata_raw(fido_assert_t *assert, size_t idx,
1093     const unsigned char *ptr, size_t len)
1094 {
1095 	cbor_item_t		*item = NULL;
1096 	fido_assert_stmt	*stmt = NULL;
1097 	int			 r;
1098 
1099 	if (idx >= assert->stmt_len || ptr == NULL || len == 0)
1100 		return (FIDO_ERR_INVALID_ARGUMENT);
1101 
1102 	stmt = &assert->stmt[idx];
1103 	fido_assert_clean_authdata(stmt);
1104 
1105 	if (fido_blob_set(&stmt->authdata_raw, ptr, len) < 0) {
1106 		fido_log_debug("%s: fido_blob_set", __func__);
1107 		r = FIDO_ERR_INTERNAL;
1108 		goto fail;
1109 	}
1110 
1111 	if ((item = cbor_build_bytestring(ptr, len)) == NULL) {
1112 		fido_log_debug("%s: cbor_build_bytestring", __func__);
1113 		r = FIDO_ERR_INTERNAL;
1114 		goto fail;
1115 	}
1116 
1117 	if (cbor_decode_assert_authdata(item, &stmt->authdata_cbor,
1118 	    &stmt->authdata, &stmt->authdata_ext) < 0) {
1119 		fido_log_debug("%s: cbor_decode_assert_authdata", __func__);
1120 		r = FIDO_ERR_INVALID_ARGUMENT;
1121 		goto fail;
1122 	}
1123 
1124 	r = FIDO_OK;
1125 fail:
1126 	if (item != NULL)
1127 		cbor_decref(&item);
1128 
1129 	if (r != FIDO_OK)
1130 		fido_assert_clean_authdata(stmt);
1131 
1132 	return (r);
1133 }
1134 
1135 int
1136 fido_assert_set_sig(fido_assert_t *a, size_t idx, const unsigned char *ptr,
1137     size_t len)
1138 {
1139 	if (idx >= a->stmt_len || ptr == NULL || len == 0)
1140 		return (FIDO_ERR_INVALID_ARGUMENT);
1141 	if (fido_blob_set(&a->stmt[idx].sig, ptr, len) < 0)
1142 		return (FIDO_ERR_INTERNAL);
1143 
1144 	return (FIDO_OK);
1145 }
1146 
1147 /* XXX shrinking leaks memory; fortunately that shouldn't happen */
1148 int
1149 fido_assert_set_count(fido_assert_t *assert, size_t n)
1150 {
1151 	void *new_stmt;
1152 
1153 #ifdef FIDO_FUZZ
1154 	if (n > UINT8_MAX) {
1155 		fido_log_debug("%s: n > UINT8_MAX", __func__);
1156 		return (FIDO_ERR_INTERNAL);
1157 	}
1158 #endif
1159 
1160 	new_stmt = recallocarray(assert->stmt, assert->stmt_cnt, n,
1161 	    sizeof(fido_assert_stmt));
1162 	if (new_stmt == NULL)
1163 		return (FIDO_ERR_INTERNAL);
1164 
1165 	assert->stmt = new_stmt;
1166 	assert->stmt_cnt = n;
1167 	assert->stmt_len = n;
1168 
1169 	return (FIDO_OK);
1170 }
1171