xref: /freebsd/contrib/libfido2/src/cbor.c (revision 81ad6265) 
1 /*
2  * Copyright (c) 2018 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  */
6 
7 #include <openssl/hmac.h>
8 #include <openssl/sha.h>
9 #include "fido.h"
10 
11 static int
12 check_key_type(cbor_item_t *item)
13 {
14 	if (item->type == CBOR_TYPE_UINT || item->type == CBOR_TYPE_NEGINT ||
15 	    item->type == CBOR_TYPE_STRING)
16 		return (0);
17 
18 	fido_log_debug("%s: invalid type: %d", __func__, item->type);
19 
20 	return (-1);
21 }
22 
23 /*
24  * Validate CTAP2 canonical CBOR encoding rules for maps.
25  */
26 static int
27 ctap_check_cbor(cbor_item_t *prev, cbor_item_t *curr)
28 {
29 	size_t	curr_len;
30 	size_t	prev_len;
31 
32 	if (check_key_type(prev) < 0 || check_key_type(curr) < 0)
33 		return (-1);
34 
35 	if (prev->type != curr->type) {
36 		if (prev->type < curr->type)
37 			return (0);
38 		fido_log_debug("%s: unsorted types", __func__);
39 		return (-1);
40 	}
41 
42 	if (curr->type == CBOR_TYPE_UINT || curr->type == CBOR_TYPE_NEGINT) {
43 		if (cbor_int_get_width(curr) >= cbor_int_get_width(prev) &&
44 		    cbor_get_int(curr) > cbor_get_int(prev))
45 			return (0);
46 	} else {
47 		curr_len = cbor_string_length(curr);
48 		prev_len = cbor_string_length(prev);
49 
50 		if (curr_len > prev_len || (curr_len == prev_len &&
51 		    memcmp(cbor_string_handle(prev), cbor_string_handle(curr),
52 		    curr_len) < 0))
53 			return (0);
54 	}
55 
56 	fido_log_debug("%s: invalid cbor", __func__);
57 
58 	return (-1);
59 }
60 
61 int
62 cbor_map_iter(const cbor_item_t *item, void *arg, int(*f)(const cbor_item_t *,
63     const cbor_item_t *, void *))
64 {
65 	struct cbor_pair	*v;
66 	size_t			 n;
67 
68 	if ((v = cbor_map_handle(item)) == NULL) {
69 		fido_log_debug("%s: cbor_map_handle", __func__);
70 		return (-1);
71 	}
72 
73 	n = cbor_map_size(item);
74 
75 	for (size_t i = 0; i < n; i++) {
76 		if (v[i].key == NULL || v[i].value == NULL) {
77 			fido_log_debug("%s: key=%p, value=%p for i=%zu",
78 			    __func__, (void *)v[i].key, (void *)v[i].value, i);
79 			return (-1);
80 		}
81 		if (i && ctap_check_cbor(v[i - 1].key, v[i].key) < 0) {
82 			fido_log_debug("%s: ctap_check_cbor", __func__);
83 			return (-1);
84 		}
85 		if (f(v[i].key, v[i].value, arg) < 0) {
86 			fido_log_debug("%s: iterator < 0 on i=%zu", __func__,
87 			    i);
88 			return (-1);
89 		}
90 	}
91 
92 	return (0);
93 }
94 
95 int
96 cbor_array_iter(const cbor_item_t *item, void *arg, int(*f)(const cbor_item_t *,
97     void *))
98 {
99 	cbor_item_t	**v;
100 	size_t		  n;
101 
102 	if ((v = cbor_array_handle(item)) == NULL) {
103 		fido_log_debug("%s: cbor_array_handle", __func__);
104 		return (-1);
105 	}
106 
107 	n = cbor_array_size(item);
108 
109 	for (size_t i = 0; i < n; i++)
110 		if (v[i] == NULL || f(v[i], arg) < 0) {
111 			fido_log_debug("%s: iterator < 0 on i=%zu,%p",
112 			    __func__, i, (void *)v[i]);
113 			return (-1);
114 		}
115 
116 	return (0);
117 }
118 
119 int
120 cbor_parse_reply(const unsigned char *blob, size_t blob_len, void *arg,
121     int(*parser)(const cbor_item_t *, const cbor_item_t *, void *))
122 {
123 	cbor_item_t		*item = NULL;
124 	struct cbor_load_result	 cbor;
125 	int			 r;
126 
127 	if (blob_len < 1) {
128 		fido_log_debug("%s: blob_len=%zu", __func__, blob_len);
129 		r = FIDO_ERR_RX;
130 		goto fail;
131 	}
132 
133 	if (blob[0] != FIDO_OK) {
134 		fido_log_debug("%s: blob[0]=0x%02x", __func__, blob[0]);
135 		r = blob[0];
136 		goto fail;
137 	}
138 
139 	if ((item = cbor_load(blob + 1, blob_len - 1, &cbor)) == NULL) {
140 		fido_log_debug("%s: cbor_load", __func__);
141 		r = FIDO_ERR_RX_NOT_CBOR;
142 		goto fail;
143 	}
144 
145 	if (cbor_isa_map(item) == false ||
146 	    cbor_map_is_definite(item) == false) {
147 		fido_log_debug("%s: cbor type", __func__);
148 		r = FIDO_ERR_RX_INVALID_CBOR;
149 		goto fail;
150 	}
151 
152 	if (cbor_map_iter(item, arg, parser) < 0) {
153 		fido_log_debug("%s: cbor_map_iter", __func__);
154 		r = FIDO_ERR_RX_INVALID_CBOR;
155 		goto fail;
156 	}
157 
158 	r = FIDO_OK;
159 fail:
160 	if (item != NULL)
161 		cbor_decref(&item);
162 
163 	return (r);
164 }
165 
166 void
167 cbor_vector_free(cbor_item_t **item, size_t len)
168 {
169 	for (size_t i = 0; i < len; i++)
170 		if (item[i] != NULL)
171 			cbor_decref(&item[i]);
172 }
173 
174 int
175 cbor_bytestring_copy(const cbor_item_t *item, unsigned char **buf, size_t *len)
176 {
177 	if (*buf != NULL || *len != 0) {
178 		fido_log_debug("%s: dup", __func__);
179 		return (-1);
180 	}
181 
182 	if (cbor_isa_bytestring(item) == false ||
183 	    cbor_bytestring_is_definite(item) == false) {
184 		fido_log_debug("%s: cbor type", __func__);
185 		return (-1);
186 	}
187 
188 	*len = cbor_bytestring_length(item);
189 	if ((*buf = malloc(*len)) == NULL) {
190 		*len = 0;
191 		return (-1);
192 	}
193 
194 	memcpy(*buf, cbor_bytestring_handle(item), *len);
195 
196 	return (0);
197 }
198 
199 int
200 cbor_string_copy(const cbor_item_t *item, char **str)
201 {
202 	size_t len;
203 
204 	if (*str != NULL) {
205 		fido_log_debug("%s: dup", __func__);
206 		return (-1);
207 	}
208 
209 	if (cbor_isa_string(item) == false ||
210 	    cbor_string_is_definite(item) == false) {
211 		fido_log_debug("%s: cbor type", __func__);
212 		return (-1);
213 	}
214 
215 	if ((len = cbor_string_length(item)) == SIZE_MAX ||
216 	    (*str = malloc(len + 1)) == NULL)
217 		return (-1);
218 
219 	memcpy(*str, cbor_string_handle(item), len);
220 	(*str)[len] = '\0';
221 
222 	return (0);
223 }
224 
225 int
226 cbor_add_bytestring(cbor_item_t *item, const char *key,
227     const unsigned char *value, size_t value_len)
228 {
229 	struct cbor_pair pair;
230 	int ok = -1;
231 
232 	memset(&pair, 0, sizeof(pair));
233 
234 	if ((pair.key = cbor_build_string(key)) == NULL ||
235 	    (pair.value = cbor_build_bytestring(value, value_len)) == NULL) {
236 		fido_log_debug("%s: cbor_build", __func__);
237 		goto fail;
238 	}
239 
240 	if (!cbor_map_add(item, pair)) {
241 		fido_log_debug("%s: cbor_map_add", __func__);
242 		goto fail;
243 	}
244 
245 	ok = 0;
246 fail:
247 	if (pair.key)
248 		cbor_decref(&pair.key);
249 	if (pair.value)
250 		cbor_decref(&pair.value);
251 
252 	return (ok);
253 }
254 
255 int
256 cbor_add_string(cbor_item_t *item, const char *key, const char *value)
257 {
258 	struct cbor_pair pair;
259 	int ok = -1;
260 
261 	memset(&pair, 0, sizeof(pair));
262 
263 	if ((pair.key = cbor_build_string(key)) == NULL ||
264 	    (pair.value = cbor_build_string(value)) == NULL) {
265 		fido_log_debug("%s: cbor_build", __func__);
266 		goto fail;
267 	}
268 
269 	if (!cbor_map_add(item, pair)) {
270 		fido_log_debug("%s: cbor_map_add", __func__);
271 		goto fail;
272 	}
273 
274 	ok = 0;
275 fail:
276 	if (pair.key)
277 		cbor_decref(&pair.key);
278 	if (pair.value)
279 		cbor_decref(&pair.value);
280 
281 	return (ok);
282 }
283 
284 int
285 cbor_add_bool(cbor_item_t *item, const char *key, fido_opt_t value)
286 {
287 	struct cbor_pair pair;
288 	int ok = -1;
289 
290 	memset(&pair, 0, sizeof(pair));
291 
292 	if ((pair.key = cbor_build_string(key)) == NULL ||
293 	    (pair.value = cbor_build_bool(value == FIDO_OPT_TRUE)) == NULL) {
294 		fido_log_debug("%s: cbor_build", __func__);
295 		goto fail;
296 	}
297 
298 	if (!cbor_map_add(item, pair)) {
299 		fido_log_debug("%s: cbor_map_add", __func__);
300 		goto fail;
301 	}
302 
303 	ok = 0;
304 fail:
305 	if (pair.key)
306 		cbor_decref(&pair.key);
307 	if (pair.value)
308 		cbor_decref(&pair.value);
309 
310 	return (ok);
311 }
312 
313 static int
314 cbor_add_uint8(cbor_item_t *item, const char *key, uint8_t value)
315 {
316 	struct cbor_pair pair;
317 	int ok = -1;
318 
319 	memset(&pair, 0, sizeof(pair));
320 
321 	if ((pair.key = cbor_build_string(key)) == NULL ||
322 	    (pair.value = cbor_build_uint8(value)) == NULL) {
323 		fido_log_debug("%s: cbor_build", __func__);
324 		goto fail;
325 	}
326 
327 	if (!cbor_map_add(item, pair)) {
328 		fido_log_debug("%s: cbor_map_add", __func__);
329 		goto fail;
330 	}
331 
332 	ok = 0;
333 fail:
334 	if (pair.key)
335 		cbor_decref(&pair.key);
336 	if (pair.value)
337 		cbor_decref(&pair.value);
338 
339 	return (ok);
340 }
341 
342 static int
343 cbor_add_arg(cbor_item_t *item, uint8_t n, cbor_item_t *arg)
344 {
345 	struct cbor_pair pair;
346 	int ok = -1;
347 
348 	memset(&pair, 0, sizeof(pair));
349 
350 	if (arg == NULL)
351 		return (0); /* empty argument */
352 
353 	if ((pair.key = cbor_build_uint8(n)) == NULL) {
354 		fido_log_debug("%s: cbor_build", __func__);
355 		goto fail;
356 	}
357 
358 	pair.value = arg;
359 
360 	if (!cbor_map_add(item, pair)) {
361 		fido_log_debug("%s: cbor_map_add", __func__);
362 		goto fail;
363 	}
364 
365 	ok = 0;
366 fail:
367 	if (pair.key)
368 		cbor_decref(&pair.key);
369 
370 	return (ok);
371 }
372 
373 cbor_item_t *
374 cbor_flatten_vector(cbor_item_t *argv[], size_t argc)
375 {
376 	cbor_item_t	*map;
377 	uint8_t		 i;
378 
379 	if (argc > UINT8_MAX - 1)
380 		return (NULL);
381 
382 	if ((map = cbor_new_definite_map(argc)) == NULL)
383 		return (NULL);
384 
385 	for (i = 0; i < argc; i++)
386 		if (cbor_add_arg(map, (uint8_t)(i + 1), argv[i]) < 0)
387 			break;
388 
389 	if (i != argc) {
390 		cbor_decref(&map);
391 		map = NULL;
392 	}
393 
394 	return (map);
395 }
396 
397 int
398 cbor_build_frame(uint8_t cmd, cbor_item_t *argv[], size_t argc, fido_blob_t *f)
399 {
400 	cbor_item_t	*flat = NULL;
401 	unsigned char	*cbor = NULL;
402 	size_t		 cbor_len;
403 	size_t		 cbor_alloc_len;
404 	int		 ok = -1;
405 
406 	if ((flat = cbor_flatten_vector(argv, argc)) == NULL)
407 		goto fail;
408 
409 	cbor_len = cbor_serialize_alloc(flat, &cbor, &cbor_alloc_len);
410 	if (cbor_len == 0 || cbor_len == SIZE_MAX) {
411 		fido_log_debug("%s: cbor_len=%zu", __func__, cbor_len);
412 		goto fail;
413 	}
414 
415 	if ((f->ptr = malloc(cbor_len + 1)) == NULL)
416 		goto fail;
417 
418 	f->len = cbor_len + 1;
419 	f->ptr[0] = cmd;
420 	memcpy(f->ptr + 1, cbor, f->len - 1);
421 
422 	ok = 0;
423 fail:
424 	if (flat != NULL)
425 		cbor_decref(&flat);
426 
427 	free(cbor);
428 
429 	return (ok);
430 }
431 
432 cbor_item_t *
433 cbor_encode_rp_entity(const fido_rp_t *rp)
434 {
435 	cbor_item_t *item = NULL;
436 
437 	if ((item = cbor_new_definite_map(2)) == NULL)
438 		return (NULL);
439 
440 	if ((rp->id && cbor_add_string(item, "id", rp->id) < 0) ||
441 	    (rp->name && cbor_add_string(item, "name", rp->name) < 0)) {
442 		cbor_decref(&item);
443 		return (NULL);
444 	}
445 
446 	return (item);
447 }
448 
449 cbor_item_t *
450 cbor_encode_user_entity(const fido_user_t *user)
451 {
452 	cbor_item_t		*item = NULL;
453 	const fido_blob_t	*id = &user->id;
454 	const char		*display = user->display_name;
455 
456 	if ((item = cbor_new_definite_map(4)) == NULL)
457 		return (NULL);
458 
459 	if ((id->ptr && cbor_add_bytestring(item, "id", id->ptr, id->len) < 0) ||
460 	    (user->icon && cbor_add_string(item, "icon", user->icon) < 0) ||
461 	    (user->name && cbor_add_string(item, "name", user->name) < 0) ||
462 	    (display && cbor_add_string(item, "displayName", display) < 0)) {
463 		cbor_decref(&item);
464 		return (NULL);
465 	}
466 
467 	return (item);
468 }
469 
470 cbor_item_t *
471 cbor_encode_pubkey_param(int cose_alg)
472 {
473 	cbor_item_t		*item = NULL;
474 	cbor_item_t		*body = NULL;
475 	struct cbor_pair	 alg;
476 	int			 ok = -1;
477 
478 	memset(&alg, 0, sizeof(alg));
479 
480 	if ((item = cbor_new_definite_array(1)) == NULL ||
481 	    (body = cbor_new_definite_map(2)) == NULL ||
482 	    cose_alg > -1 || cose_alg < INT16_MIN)
483 		goto fail;
484 
485 	alg.key = cbor_build_string("alg");
486 
487 	if (-cose_alg - 1 > UINT8_MAX)
488 		alg.value = cbor_build_negint16((uint16_t)(-cose_alg - 1));
489 	else
490 		alg.value = cbor_build_negint8((uint8_t)(-cose_alg - 1));
491 
492 	if (alg.key == NULL || alg.value == NULL) {
493 		fido_log_debug("%s: cbor_build", __func__);
494 		goto fail;
495 	}
496 
497 	if (cbor_map_add(body, alg) == false ||
498 	    cbor_add_string(body, "type", "public-key") < 0 ||
499 	    cbor_array_push(item, body) == false)
500 		goto fail;
501 
502 	ok  = 0;
503 fail:
504 	if (ok < 0) {
505 		if (item != NULL) {
506 			cbor_decref(&item);
507 			item = NULL;
508 		}
509 	}
510 
511 	if (body != NULL)
512 		cbor_decref(&body);
513 	if (alg.key != NULL)
514 		cbor_decref(&alg.key);
515 	if (alg.value != NULL)
516 		cbor_decref(&alg.value);
517 
518 	return (item);
519 }
520 
521 cbor_item_t *
522 cbor_encode_pubkey(const fido_blob_t *pubkey)
523 {
524 	cbor_item_t *cbor_key = NULL;
525 
526 	if ((cbor_key = cbor_new_definite_map(2)) == NULL ||
527 	    cbor_add_bytestring(cbor_key, "id", pubkey->ptr, pubkey->len) < 0 ||
528 	    cbor_add_string(cbor_key, "type", "public-key") < 0) {
529 		if (cbor_key)
530 			cbor_decref(&cbor_key);
531 		return (NULL);
532 	}
533 
534 	return (cbor_key);
535 }
536 
537 cbor_item_t *
538 cbor_encode_pubkey_list(const fido_blob_array_t *list)
539 {
540 	cbor_item_t	*array = NULL;
541 	cbor_item_t	*key = NULL;
542 
543 	if ((array = cbor_new_definite_array(list->len)) == NULL)
544 		goto fail;
545 
546 	for (size_t i = 0; i < list->len; i++) {
547 		if ((key = cbor_encode_pubkey(&list->ptr[i])) == NULL ||
548 		    cbor_array_push(array, key) == false)
549 			goto fail;
550 		cbor_decref(&key);
551 	}
552 
553 	return (array);
554 fail:
555 	if (key != NULL)
556 		cbor_decref(&key);
557 	if (array != NULL)
558 		cbor_decref(&array);
559 
560 	return (NULL);
561 }
562 
563 static int
564 cbor_encode_largeblob_key_ext(cbor_item_t *map)
565 {
566 	if (map == NULL ||
567 	    cbor_add_bool(map, "largeBlobKey", FIDO_OPT_TRUE) < 0)
568 		return (-1);
569 
570 	return (0);
571 }
572 
573 cbor_item_t *
574 cbor_encode_cred_ext(const fido_cred_ext_t *ext, const fido_blob_t *blob)
575 {
576 	cbor_item_t *item = NULL;
577 	size_t size = 0;
578 
579 	if (ext->mask & FIDO_EXT_CRED_BLOB)
580 		size++;
581 	if (ext->mask & FIDO_EXT_HMAC_SECRET)
582 		size++;
583 	if (ext->mask & FIDO_EXT_CRED_PROTECT)
584 		size++;
585 	if (ext->mask & FIDO_EXT_LARGEBLOB_KEY)
586 		size++;
587 
588 	if (size == 0 || (item = cbor_new_definite_map(size)) == NULL)
589 		return (NULL);
590 
591 	if (ext->mask & FIDO_EXT_CRED_BLOB) {
592 		if (cbor_add_bytestring(item, "credBlob", blob->ptr,
593 		    blob->len) < 0) {
594 			cbor_decref(&item);
595 			return (NULL);
596 		}
597 	}
598 	if (ext->mask & FIDO_EXT_CRED_PROTECT) {
599 		if (ext->prot < 0 || ext->prot > UINT8_MAX ||
600 		    cbor_add_uint8(item, "credProtect",
601 		    (uint8_t)ext->prot) < 0) {
602 			cbor_decref(&item);
603 			return (NULL);
604 		}
605 	}
606 	if (ext->mask & FIDO_EXT_HMAC_SECRET) {
607 		if (cbor_add_bool(item, "hmac-secret", FIDO_OPT_TRUE) < 0) {
608 			cbor_decref(&item);
609 			return (NULL);
610 		}
611 	}
612 	if (ext->mask & FIDO_EXT_LARGEBLOB_KEY) {
613 		if (cbor_encode_largeblob_key_ext(item) < 0) {
614 			cbor_decref(&item);
615 			return (NULL);
616 		}
617 	}
618 
619 	return (item);
620 }
621 
622 cbor_item_t *
623 cbor_encode_cred_opt(fido_opt_t rk, fido_opt_t uv)
624 {
625 	cbor_item_t *item = NULL;
626 
627 	if ((item = cbor_new_definite_map(2)) == NULL)
628 		return (NULL);
629 	if ((rk != FIDO_OPT_OMIT && cbor_add_bool(item, "rk", rk) < 0) ||
630 	    (uv != FIDO_OPT_OMIT && cbor_add_bool(item, "uv", uv) < 0)) {
631 		cbor_decref(&item);
632 		return (NULL);
633 	}
634 
635 	return (item);
636 }
637 
638 cbor_item_t *
639 cbor_encode_assert_opt(fido_opt_t up, fido_opt_t uv)
640 {
641 	cbor_item_t *item = NULL;
642 
643 	if ((item = cbor_new_definite_map(2)) == NULL)
644 		return (NULL);
645 	if ((up != FIDO_OPT_OMIT && cbor_add_bool(item, "up", up) < 0) ||
646 	    (uv != FIDO_OPT_OMIT && cbor_add_bool(item, "uv", uv) < 0)) {
647 		cbor_decref(&item);
648 		return (NULL);
649 	}
650 
651 	return (item);
652 }
653 
654 cbor_item_t *
655 cbor_encode_pin_auth(const fido_dev_t *dev, const fido_blob_t *secret,
656     const fido_blob_t *data)
657 {
658 	const EVP_MD	*md = NULL;
659 	unsigned char	 dgst[SHA256_DIGEST_LENGTH];
660 	unsigned int	 dgst_len;
661 	size_t		 outlen;
662 	uint8_t		 prot;
663 	fido_blob_t	 key;
664 
665 
666 	key.ptr = secret->ptr;
667 	key.len = secret->len;
668 
669 	if ((prot = fido_dev_get_pin_protocol(dev)) == 0) {
670 		fido_log_debug("%s: fido_dev_get_pin_protocol", __func__);
671 		return (NULL);
672 	}
673 
674 	/* select hmac portion of the shared secret */
675 	if (prot == CTAP_PIN_PROTOCOL2 && key.len > 32)
676 		key.len = 32;
677 
678 	if ((md = EVP_sha256()) == NULL || HMAC(md, key.ptr,
679 	    (int)key.len, data->ptr, data->len, dgst,
680 	    &dgst_len) == NULL || dgst_len != SHA256_DIGEST_LENGTH)
681 		return (NULL);
682 
683 	outlen = (prot == CTAP_PIN_PROTOCOL1) ? 16 : dgst_len;
684 
685 	return (cbor_build_bytestring(dgst, outlen));
686 }
687 
688 cbor_item_t *
689 cbor_encode_pin_opt(const fido_dev_t *dev)
690 {
691 	uint8_t	    prot;
692 
693 	if ((prot = fido_dev_get_pin_protocol(dev)) == 0) {
694 		fido_log_debug("%s: fido_dev_get_pin_protocol", __func__);
695 		return (NULL);
696 	}
697 
698 	return (cbor_build_uint8(prot));
699 }
700 
701 cbor_item_t *
702 cbor_encode_change_pin_auth(const fido_dev_t *dev, const fido_blob_t *secret,
703     const fido_blob_t *new_pin_enc, const fido_blob_t *pin_hash_enc)
704 {
705 	unsigned char	 dgst[SHA256_DIGEST_LENGTH];
706 	unsigned int	 dgst_len;
707 	cbor_item_t	*item = NULL;
708 	const EVP_MD	*md = NULL;
709 #if OPENSSL_VERSION_NUMBER < 0x10100000L
710 	HMAC_CTX	 ctx;
711 #else
712 	HMAC_CTX	*ctx = NULL;
713 #endif
714 	fido_blob_t	 key;
715 	uint8_t		 prot;
716 	size_t		 outlen;
717 
718 	key.ptr = secret->ptr;
719 	key.len = secret->len;
720 
721 	if ((prot = fido_dev_get_pin_protocol(dev)) == 0) {
722 		fido_log_debug("%s: fido_dev_get_pin_protocol", __func__);
723 		goto fail;
724 	}
725 
726 	if (prot == CTAP_PIN_PROTOCOL2 && key.len > 32)
727 		key.len = 32;
728 
729 #if OPENSSL_VERSION_NUMBER < 0x10100000L
730 	HMAC_CTX_init(&ctx);
731 
732 	if ((md = EVP_sha256()) == NULL ||
733 	    HMAC_Init_ex(&ctx, key.ptr, (int)key.len, md, NULL) == 0 ||
734 	    HMAC_Update(&ctx, new_pin_enc->ptr, new_pin_enc->len) == 0 ||
735 	    HMAC_Update(&ctx, pin_hash_enc->ptr, pin_hash_enc->len) == 0 ||
736 	    HMAC_Final(&ctx, dgst, &dgst_len) == 0 ||
737 	    dgst_len != SHA256_DIGEST_LENGTH) {
738 		fido_log_debug("%s: HMAC", __func__);
739 		goto fail;
740 	}
741 #else
742 	if ((ctx = HMAC_CTX_new()) == NULL ||
743 	    (md = EVP_sha256())  == NULL ||
744 	    HMAC_Init_ex(ctx, key.ptr, (int)key.len, md, NULL) == 0 ||
745 	    HMAC_Update(ctx, new_pin_enc->ptr, new_pin_enc->len) == 0 ||
746 	    HMAC_Update(ctx, pin_hash_enc->ptr, pin_hash_enc->len) == 0 ||
747 	    HMAC_Final(ctx, dgst, &dgst_len) == 0 ||
748 	    dgst_len != SHA256_DIGEST_LENGTH) {
749 		fido_log_debug("%s: HMAC", __func__);
750 		goto fail;
751 	}
752 #endif /* OPENSSL_VERSION_NUMBER < 0x10100000L */
753 
754 	outlen = (prot == CTAP_PIN_PROTOCOL1) ? 16 : dgst_len;
755 
756 	if ((item = cbor_build_bytestring(dgst, outlen)) == NULL) {
757 		fido_log_debug("%s: cbor_build_bytestring", __func__);
758 		goto fail;
759 	}
760 
761 fail:
762 #if OPENSSL_VERSION_NUMBER >= 0x10100000L
763 	if (ctx != NULL)
764 		HMAC_CTX_free(ctx);
765 #endif
766 
767 	return (item);
768 }
769 
770 static int
771 cbor_encode_hmac_secret_param(const fido_dev_t *dev, cbor_item_t *item,
772     const fido_blob_t *ecdh, const es256_pk_t *pk, const fido_blob_t *salt)
773 {
774 	cbor_item_t		*param = NULL;
775 	cbor_item_t		*argv[4];
776 	struct cbor_pair	 pair;
777 	fido_blob_t		*enc = NULL;
778 	int			 r;
779 
780 	memset(argv, 0, sizeof(argv));
781 	memset(&pair, 0, sizeof(pair));
782 
783 	if (item == NULL || ecdh == NULL || pk == NULL || salt->ptr == NULL) {
784 		fido_log_debug("%s: ecdh=%p, pk=%p, salt->ptr=%p", __func__,
785 		    (const void *)ecdh, (const void *)pk,
786 		    (const void *)salt->ptr);
787 		r = FIDO_ERR_INTERNAL;
788 		goto fail;
789 	}
790 
791 	if (salt->len != 32 && salt->len != 64) {
792 		fido_log_debug("%s: salt->len=%zu", __func__, salt->len);
793 		r = FIDO_ERR_INTERNAL;
794 		goto fail;
795 	}
796 
797 	if ((enc = fido_blob_new()) == NULL ||
798 	    aes256_cbc_enc(dev, ecdh, salt, enc) < 0) {
799 		fido_log_debug("%s: aes256_cbc_enc", __func__);
800 		r = FIDO_ERR_INTERNAL;
801 		goto fail;
802 	}
803 
804 	/* XXX not pin, but salt */
805 	if ((argv[0] = es256_pk_encode(pk, 1)) == NULL ||
806 	    (argv[1] = fido_blob_encode(enc)) == NULL ||
807 	    (argv[2] = cbor_encode_pin_auth(dev, ecdh, enc)) == NULL ||
808 	    (argv[3] = cbor_encode_pin_opt(dev)) == NULL) {
809 		fido_log_debug("%s: cbor encode", __func__);
810 		r = FIDO_ERR_INTERNAL;
811 		goto fail;
812 	}
813 
814 	if ((param = cbor_flatten_vector(argv, nitems(argv))) == NULL) {
815 		fido_log_debug("%s: cbor_flatten_vector", __func__);
816 		r = FIDO_ERR_INTERNAL;
817 		goto fail;
818 	}
819 
820 	if ((pair.key = cbor_build_string("hmac-secret")) == NULL) {
821 		fido_log_debug("%s: cbor_build", __func__);
822 		r = FIDO_ERR_INTERNAL;
823 		goto fail;
824 	}
825 
826 	pair.value = param;
827 
828 	if (!cbor_map_add(item, pair)) {
829 		fido_log_debug("%s: cbor_map_add", __func__);
830 		r = FIDO_ERR_INTERNAL;
831 		goto fail;
832 	}
833 
834 	r = FIDO_OK;
835 
836 fail:
837 	cbor_vector_free(argv, nitems(argv));
838 
839 	if (param != NULL)
840 		cbor_decref(&param);
841 	if (pair.key != NULL)
842 		cbor_decref(&pair.key);
843 
844 	fido_blob_free(&enc);
845 
846 	return (r);
847 }
848 
849 cbor_item_t *
850 cbor_encode_assert_ext(fido_dev_t *dev, const fido_assert_ext_t *ext,
851     const fido_blob_t *ecdh, const es256_pk_t *pk)
852 {
853 	cbor_item_t *item = NULL;
854 	size_t size = 0;
855 
856 	if (ext->mask & FIDO_EXT_CRED_BLOB)
857 		size++;
858 	if (ext->mask & FIDO_EXT_HMAC_SECRET)
859 		size++;
860 	if (ext->mask & FIDO_EXT_LARGEBLOB_KEY)
861 		size++;
862 	if (size == 0 || (item = cbor_new_definite_map(size)) == NULL)
863 		return (NULL);
864 
865 	if (ext->mask & FIDO_EXT_CRED_BLOB) {
866 		if (cbor_add_bool(item, "credBlob", FIDO_OPT_TRUE) < 0) {
867 			cbor_decref(&item);
868 			return (NULL);
869 		}
870 	}
871 	if (ext->mask & FIDO_EXT_HMAC_SECRET) {
872 		if (cbor_encode_hmac_secret_param(dev, item, ecdh, pk,
873 		    &ext->hmac_salt) < 0) {
874 			cbor_decref(&item);
875 			return (NULL);
876 		}
877 	}
878 	if (ext->mask & FIDO_EXT_LARGEBLOB_KEY) {
879 		if (cbor_encode_largeblob_key_ext(item) < 0) {
880 			cbor_decref(&item);
881 			return (NULL);
882 		}
883 	}
884 
885 	return (item);
886 }
887 
888 int
889 cbor_decode_fmt(const cbor_item_t *item, char **fmt)
890 {
891 	char	*type = NULL;
892 
893 	if (cbor_string_copy(item, &type) < 0) {
894 		fido_log_debug("%s: cbor_string_copy", __func__);
895 		return (-1);
896 	}
897 
898 	if (strcmp(type, "packed") && strcmp(type, "fido-u2f") &&
899 	    strcmp(type, "none")) {
900 		fido_log_debug("%s: type=%s", __func__, type);
901 		free(type);
902 		return (-1);
903 	}
904 
905 	*fmt = type;
906 
907 	return (0);
908 }
909 
910 struct cose_key {
911 	int kty;
912 	int alg;
913 	int crv;
914 };
915 
916 static int
917 find_cose_alg(const cbor_item_t *key, const cbor_item_t *val, void *arg)
918 {
919 	struct cose_key *cose_key = arg;
920 
921 	if (cbor_isa_uint(key) == true &&
922 	    cbor_int_get_width(key) == CBOR_INT_8) {
923 		switch (cbor_get_uint8(key)) {
924 		case 1:
925 			if (cbor_isa_uint(val) == false ||
926 			    cbor_get_int(val) > INT_MAX || cose_key->kty != 0) {
927 				fido_log_debug("%s: kty", __func__);
928 				return (-1);
929 			}
930 
931 			cose_key->kty = (int)cbor_get_int(val);
932 
933 			break;
934 		case 3:
935 			if (cbor_isa_negint(val) == false ||
936 			    cbor_get_int(val) > INT_MAX || cose_key->alg != 0) {
937 				fido_log_debug("%s: alg", __func__);
938 				return (-1);
939 			}
940 
941 			cose_key->alg = -(int)cbor_get_int(val) - 1;
942 
943 			break;
944 		}
945 	} else if (cbor_isa_negint(key) == true &&
946 	    cbor_int_get_width(key) == CBOR_INT_8) {
947 		if (cbor_get_uint8(key) == 0) {
948 			/* get crv if not rsa, otherwise ignore */
949 			if (cbor_isa_uint(val) == true &&
950 			    cbor_get_int(val) <= INT_MAX &&
951 			    cose_key->crv == 0)
952 				cose_key->crv = (int)cbor_get_int(val);
953 		}
954 	}
955 
956 	return (0);
957 }
958 
959 static int
960 get_cose_alg(const cbor_item_t *item, int *cose_alg)
961 {
962 	struct cose_key cose_key;
963 
964 	memset(&cose_key, 0, sizeof(cose_key));
965 
966 	*cose_alg = 0;
967 
968 	if (cbor_isa_map(item) == false ||
969 	    cbor_map_is_definite(item) == false ||
970 	    cbor_map_iter(item, &cose_key, find_cose_alg) < 0) {
971 		fido_log_debug("%s: cbor type", __func__);
972 		return (-1);
973 	}
974 
975 	switch (cose_key.alg) {
976 	case COSE_ES256:
977 		if (cose_key.kty != COSE_KTY_EC2 ||
978 		    cose_key.crv != COSE_P256) {
979 			fido_log_debug("%s: invalid kty/crv", __func__);
980 			return (-1);
981 		}
982 
983 		break;
984 	case COSE_EDDSA:
985 		if (cose_key.kty != COSE_KTY_OKP ||
986 		    cose_key.crv != COSE_ED25519) {
987 			fido_log_debug("%s: invalid kty/crv", __func__);
988 			return (-1);
989 		}
990 
991 		break;
992 	case COSE_RS256:
993 		if (cose_key.kty != COSE_KTY_RSA) {
994 			fido_log_debug("%s: invalid kty/crv", __func__);
995 			return (-1);
996 		}
997 
998 		break;
999 	default:
1000 		fido_log_debug("%s: unknown alg %d", __func__, cose_key.alg);
1001 
1002 		return (-1);
1003 	}
1004 
1005 	*cose_alg = cose_key.alg;
1006 
1007 	return (0);
1008 }
1009 
1010 int
1011 cbor_decode_pubkey(const cbor_item_t *item, int *type, void *key)
1012 {
1013 	if (get_cose_alg(item, type) < 0) {
1014 		fido_log_debug("%s: get_cose_alg", __func__);
1015 		return (-1);
1016 	}
1017 
1018 	switch (*type) {
1019 	case COSE_ES256:
1020 		if (es256_pk_decode(item, key) < 0) {
1021 			fido_log_debug("%s: es256_pk_decode", __func__);
1022 			return (-1);
1023 		}
1024 		break;
1025 	case COSE_RS256:
1026 		if (rs256_pk_decode(item, key) < 0) {
1027 			fido_log_debug("%s: rs256_pk_decode", __func__);
1028 			return (-1);
1029 		}
1030 		break;
1031 	case COSE_EDDSA:
1032 		if (eddsa_pk_decode(item, key) < 0) {
1033 			fido_log_debug("%s: eddsa_pk_decode", __func__);
1034 			return (-1);
1035 		}
1036 		break;
1037 	default:
1038 		fido_log_debug("%s: invalid cose_alg %d", __func__, *type);
1039 		return (-1);
1040 	}
1041 
1042 	return (0);
1043 }
1044 
1045 static int
1046 decode_attcred(const unsigned char **buf, size_t *len, int cose_alg,
1047     fido_attcred_t *attcred)
1048 {
1049 	cbor_item_t		*item = NULL;
1050 	struct cbor_load_result	 cbor;
1051 	uint16_t		 id_len;
1052 	int			 ok = -1;
1053 
1054 	fido_log_xxd(*buf, *len, "%s", __func__);
1055 
1056 	if (fido_buf_read(buf, len, &attcred->aaguid,
1057 	    sizeof(attcred->aaguid)) < 0) {
1058 		fido_log_debug("%s: fido_buf_read aaguid", __func__);
1059 		return (-1);
1060 	}
1061 
1062 	if (fido_buf_read(buf, len, &id_len, sizeof(id_len)) < 0) {
1063 		fido_log_debug("%s: fido_buf_read id_len", __func__);
1064 		return (-1);
1065 	}
1066 
1067 	attcred->id.len = (size_t)be16toh(id_len);
1068 	if ((attcred->id.ptr = malloc(attcred->id.len)) == NULL)
1069 		return (-1);
1070 
1071 	fido_log_debug("%s: attcred->id.len=%zu", __func__, attcred->id.len);
1072 
1073 	if (fido_buf_read(buf, len, attcred->id.ptr, attcred->id.len) < 0) {
1074 		fido_log_debug("%s: fido_buf_read id", __func__);
1075 		return (-1);
1076 	}
1077 
1078 	if ((item = cbor_load(*buf, *len, &cbor)) == NULL) {
1079 		fido_log_debug("%s: cbor_load", __func__);
1080 		goto fail;
1081 	}
1082 
1083 	if (cbor_decode_pubkey(item, &attcred->type, &attcred->pubkey) < 0) {
1084 		fido_log_debug("%s: cbor_decode_pubkey", __func__);
1085 		goto fail;
1086 	}
1087 
1088 	if (attcred->type != cose_alg) {
1089 		fido_log_debug("%s: cose_alg mismatch (%d != %d)", __func__,
1090 		    attcred->type, cose_alg);
1091 		goto fail;
1092 	}
1093 
1094 	*buf += cbor.read;
1095 	*len -= cbor.read;
1096 
1097 	ok = 0;
1098 fail:
1099 	if (item != NULL)
1100 		cbor_decref(&item);
1101 
1102 	return (ok);
1103 }
1104 
1105 static int
1106 decode_cred_extension(const cbor_item_t *key, const cbor_item_t *val, void *arg)
1107 {
1108 	fido_cred_ext_t	*authdata_ext = arg;
1109 	char		*type = NULL;
1110 	int		 ok = -1;
1111 
1112 	if (cbor_string_copy(key, &type) < 0) {
1113 		fido_log_debug("%s: cbor type", __func__);
1114 		ok = 0; /* ignore */
1115 		goto out;
1116 	}
1117 
1118 	if (strcmp(type, "hmac-secret") == 0) {
1119 		if (cbor_isa_float_ctrl(val) == false ||
1120 		    cbor_float_get_width(val) != CBOR_FLOAT_0 ||
1121 		    cbor_is_bool(val) == false) {
1122 			fido_log_debug("%s: cbor type", __func__);
1123 			goto out;
1124 		}
1125 		if (cbor_ctrl_value(val) == CBOR_CTRL_TRUE)
1126 			authdata_ext->mask |= FIDO_EXT_HMAC_SECRET;
1127 	} else if (strcmp(type, "credProtect") == 0) {
1128 		if (cbor_isa_uint(val) == false ||
1129 		    cbor_int_get_width(val) != CBOR_INT_8) {
1130 			fido_log_debug("%s: cbor type", __func__);
1131 			goto out;
1132 		}
1133 		authdata_ext->mask |= FIDO_EXT_CRED_PROTECT;
1134 		authdata_ext->prot = cbor_get_uint8(val);
1135 	} else if (strcmp(type, "credBlob") == 0) {
1136 		if (cbor_isa_float_ctrl(val) == false ||
1137 		    cbor_float_get_width(val) != CBOR_FLOAT_0 ||
1138 		    cbor_is_bool(val) == false) {
1139 			fido_log_debug("%s: cbor type", __func__);
1140 			goto out;
1141 		}
1142 		if (cbor_ctrl_value(val) == CBOR_CTRL_TRUE)
1143 			authdata_ext->mask |= FIDO_EXT_CRED_BLOB;
1144 	}
1145 
1146 	ok = 0;
1147 out:
1148 	free(type);
1149 
1150 	return (ok);
1151 }
1152 
1153 static int
1154 decode_cred_extensions(const unsigned char **buf, size_t *len,
1155     fido_cred_ext_t *authdata_ext)
1156 {
1157 	cbor_item_t		*item = NULL;
1158 	struct cbor_load_result	 cbor;
1159 	int			 ok = -1;
1160 
1161 	memset(authdata_ext, 0, sizeof(*authdata_ext));
1162 
1163 	fido_log_xxd(*buf, *len, "%s", __func__);
1164 
1165 	if ((item = cbor_load(*buf, *len, &cbor)) == NULL) {
1166 		fido_log_debug("%s: cbor_load", __func__);
1167 		goto fail;
1168 	}
1169 
1170 	if (cbor_isa_map(item) == false ||
1171 	    cbor_map_is_definite(item) == false ||
1172 	    cbor_map_iter(item, authdata_ext, decode_cred_extension) < 0) {
1173 		fido_log_debug("%s: cbor type", __func__);
1174 		goto fail;
1175 	}
1176 
1177 	*buf += cbor.read;
1178 	*len -= cbor.read;
1179 
1180 	ok = 0;
1181 fail:
1182 	if (item != NULL)
1183 		cbor_decref(&item);
1184 
1185 	return (ok);
1186 }
1187 
1188 static int
1189 decode_assert_extension(const cbor_item_t *key, const cbor_item_t *val,
1190     void *arg)
1191 {
1192 	fido_assert_extattr_t	*authdata_ext = arg;
1193 	char			*type = NULL;
1194 	int			 ok = -1;
1195 
1196 	if (cbor_string_copy(key, &type) < 0) {
1197 		fido_log_debug("%s: cbor type", __func__);
1198 		ok = 0; /* ignore */
1199 		goto out;
1200 	}
1201 
1202 	if (strcmp(type, "hmac-secret") == 0) {
1203 		if (fido_blob_decode(val, &authdata_ext->hmac_secret_enc) < 0) {
1204 			fido_log_debug("%s: fido_blob_decode", __func__);
1205 			goto out;
1206 		}
1207 		authdata_ext->mask |= FIDO_EXT_HMAC_SECRET;
1208 	} else if (strcmp(type, "credBlob") == 0) {
1209 		if (fido_blob_decode(val, &authdata_ext->blob) < 0) {
1210 			fido_log_debug("%s: fido_blob_decode", __func__);
1211 			goto out;
1212 		}
1213 		authdata_ext->mask |= FIDO_EXT_CRED_BLOB;
1214 	}
1215 
1216 	ok = 0;
1217 out:
1218 	free(type);
1219 
1220 	return (ok);
1221 }
1222 
1223 static int
1224 decode_assert_extensions(const unsigned char **buf, size_t *len,
1225     fido_assert_extattr_t *authdata_ext)
1226 {
1227 	cbor_item_t		*item = NULL;
1228 	struct cbor_load_result	 cbor;
1229 	int			 ok = -1;
1230 
1231 	fido_log_xxd(*buf, *len, "%s", __func__);
1232 
1233 	if ((item = cbor_load(*buf, *len, &cbor)) == NULL) {
1234 		fido_log_debug("%s: cbor_load", __func__);
1235 		goto fail;
1236 	}
1237 
1238 	if (cbor_isa_map(item) == false ||
1239 	    cbor_map_is_definite(item) == false ||
1240 	    cbor_map_iter(item, authdata_ext, decode_assert_extension) < 0) {
1241 		fido_log_debug("%s: cbor type", __func__);
1242 		goto fail;
1243 	}
1244 
1245 	*buf += cbor.read;
1246 	*len -= cbor.read;
1247 
1248 	ok = 0;
1249 fail:
1250 	if (item != NULL)
1251 		cbor_decref(&item);
1252 
1253 	return (ok);
1254 }
1255 
1256 int
1257 cbor_decode_cred_authdata(const cbor_item_t *item, int cose_alg,
1258     fido_blob_t *authdata_cbor, fido_authdata_t *authdata,
1259     fido_attcred_t *attcred, fido_cred_ext_t *authdata_ext)
1260 {
1261 	const unsigned char	*buf = NULL;
1262 	size_t			 len;
1263 	size_t			 alloc_len;
1264 
1265 	if (cbor_isa_bytestring(item) == false ||
1266 	    cbor_bytestring_is_definite(item) == false) {
1267 		fido_log_debug("%s: cbor type", __func__);
1268 		return (-1);
1269 	}
1270 
1271 	if (authdata_cbor->ptr != NULL ||
1272 	    (authdata_cbor->len = cbor_serialize_alloc(item,
1273 	    &authdata_cbor->ptr, &alloc_len)) == 0) {
1274 		fido_log_debug("%s: cbor_serialize_alloc", __func__);
1275 		return (-1);
1276 	}
1277 
1278 	buf = cbor_bytestring_handle(item);
1279 	len = cbor_bytestring_length(item);
1280 	fido_log_xxd(buf, len, "%s", __func__);
1281 
1282 	if (fido_buf_read(&buf, &len, authdata, sizeof(*authdata)) < 0) {
1283 		fido_log_debug("%s: fido_buf_read", __func__);
1284 		return (-1);
1285 	}
1286 
1287 	authdata->sigcount = be32toh(authdata->sigcount);
1288 
1289 	if (attcred != NULL) {
1290 		if ((authdata->flags & CTAP_AUTHDATA_ATT_CRED) == 0 ||
1291 		    decode_attcred(&buf, &len, cose_alg, attcred) < 0)
1292 			return (-1);
1293 	}
1294 
1295 	if (authdata_ext != NULL) {
1296 		if ((authdata->flags & CTAP_AUTHDATA_EXT_DATA) != 0 &&
1297 		    decode_cred_extensions(&buf, &len, authdata_ext) < 0)
1298 			return (-1);
1299 	}
1300 
1301 	/* XXX we should probably ensure that len == 0 at this point */
1302 
1303 	return (FIDO_OK);
1304 }
1305 
1306 int
1307 cbor_decode_assert_authdata(const cbor_item_t *item, fido_blob_t *authdata_cbor,
1308     fido_authdata_t *authdata, fido_assert_extattr_t *authdata_ext)
1309 {
1310 	const unsigned char	*buf = NULL;
1311 	size_t			 len;
1312 	size_t			 alloc_len;
1313 
1314 	if (cbor_isa_bytestring(item) == false ||
1315 	    cbor_bytestring_is_definite(item) == false) {
1316 		fido_log_debug("%s: cbor type", __func__);
1317 		return (-1);
1318 	}
1319 
1320 	if (authdata_cbor->ptr != NULL ||
1321 	    (authdata_cbor->len = cbor_serialize_alloc(item,
1322 	    &authdata_cbor->ptr, &alloc_len)) == 0) {
1323 		fido_log_debug("%s: cbor_serialize_alloc", __func__);
1324 		return (-1);
1325 	}
1326 
1327 	buf = cbor_bytestring_handle(item);
1328 	len = cbor_bytestring_length(item);
1329 
1330 	fido_log_debug("%s: buf=%p, len=%zu", __func__, (const void *)buf, len);
1331 
1332 	if (fido_buf_read(&buf, &len, authdata, sizeof(*authdata)) < 0) {
1333 		fido_log_debug("%s: fido_buf_read", __func__);
1334 		return (-1);
1335 	}
1336 
1337 	authdata->sigcount = be32toh(authdata->sigcount);
1338 
1339 	if ((authdata->flags & CTAP_AUTHDATA_EXT_DATA) != 0) {
1340 		if (decode_assert_extensions(&buf, &len, authdata_ext) < 0) {
1341 			fido_log_debug("%s: decode_assert_extensions",
1342 			    __func__);
1343 			return (-1);
1344 		}
1345 	}
1346 
1347 	/* XXX we should probably ensure that len == 0 at this point */
1348 
1349 	return (FIDO_OK);
1350 }
1351 
1352 static int
1353 decode_x5c(const cbor_item_t *item, void *arg)
1354 {
1355 	fido_blob_t *x5c = arg;
1356 
1357 	if (x5c->len)
1358 		return (0); /* ignore */
1359 
1360 	return (fido_blob_decode(item, x5c));
1361 }
1362 
1363 static int
1364 decode_attstmt_entry(const cbor_item_t *key, const cbor_item_t *val, void *arg)
1365 {
1366 	fido_attstmt_t	*attstmt = arg;
1367 	char		*name = NULL;
1368 	int		 cose_alg = 0;
1369 	int		 ok = -1;
1370 
1371 	if (cbor_string_copy(key, &name) < 0) {
1372 		fido_log_debug("%s: cbor type", __func__);
1373 		ok = 0; /* ignore */
1374 		goto out;
1375 	}
1376 
1377 	if (!strcmp(name, "alg")) {
1378 		if (cbor_isa_negint(val) == false ||
1379 		    cbor_get_int(val) > UINT16_MAX) {
1380 			fido_log_debug("%s: alg", __func__);
1381 			goto out;
1382 		}
1383 		if ((cose_alg = -(int)cbor_get_int(val) - 1) != COSE_ES256 &&
1384 		    cose_alg != COSE_RS256 && cose_alg != COSE_EDDSA) {
1385 			fido_log_debug("%s: unsupported cose_alg=%d", __func__,
1386 			    cose_alg);
1387 			goto out;
1388 		}
1389 	} else if (!strcmp(name, "sig")) {
1390 		if (fido_blob_decode(val, &attstmt->sig) < 0) {
1391 			fido_log_debug("%s: sig", __func__);
1392 			goto out;
1393 		}
1394 	} else if (!strcmp(name, "x5c")) {
1395 		if (cbor_isa_array(val) == false ||
1396 		    cbor_array_is_definite(val) == false ||
1397 		    cbor_array_iter(val, &attstmt->x5c, decode_x5c) < 0) {
1398 			fido_log_debug("%s: x5c", __func__);
1399 			goto out;
1400 		}
1401 	}
1402 
1403 	ok = 0;
1404 out:
1405 	free(name);
1406 
1407 	return (ok);
1408 }
1409 
1410 int
1411 cbor_decode_attstmt(const cbor_item_t *item, fido_attstmt_t *attstmt)
1412 {
1413 	if (cbor_isa_map(item) == false ||
1414 	    cbor_map_is_definite(item) == false ||
1415 	    cbor_map_iter(item, attstmt, decode_attstmt_entry) < 0) {
1416 		fido_log_debug("%s: cbor type", __func__);
1417 		return (-1);
1418 	}
1419 
1420 	return (0);
1421 }
1422 
1423 int
1424 cbor_decode_uint64(const cbor_item_t *item, uint64_t *n)
1425 {
1426 	if (cbor_isa_uint(item) == false) {
1427 		fido_log_debug("%s: cbor type", __func__);
1428 		return (-1);
1429 	}
1430 
1431 	*n = cbor_get_int(item);
1432 
1433 	return (0);
1434 }
1435 
1436 static int
1437 decode_cred_id_entry(const cbor_item_t *key, const cbor_item_t *val, void *arg)
1438 {
1439 	fido_blob_t	*id = arg;
1440 	char		*name = NULL;
1441 	int		 ok = -1;
1442 
1443 	if (cbor_string_copy(key, &name) < 0) {
1444 		fido_log_debug("%s: cbor type", __func__);
1445 		ok = 0; /* ignore */
1446 		goto out;
1447 	}
1448 
1449 	if (!strcmp(name, "id"))
1450 		if (fido_blob_decode(val, id) < 0) {
1451 			fido_log_debug("%s: cbor_bytestring_copy", __func__);
1452 			goto out;
1453 		}
1454 
1455 	ok = 0;
1456 out:
1457 	free(name);
1458 
1459 	return (ok);
1460 }
1461 
1462 int
1463 cbor_decode_cred_id(const cbor_item_t *item, fido_blob_t *id)
1464 {
1465 	if (cbor_isa_map(item) == false ||
1466 	    cbor_map_is_definite(item) == false ||
1467 	    cbor_map_iter(item, id, decode_cred_id_entry) < 0) {
1468 		fido_log_debug("%s: cbor type", __func__);
1469 		return (-1);
1470 	}
1471 
1472 	return (0);
1473 }
1474 
1475 static int
1476 decode_user_entry(const cbor_item_t *key, const cbor_item_t *val, void *arg)
1477 {
1478 	fido_user_t	*user = arg;
1479 	char		*name = NULL;
1480 	int		 ok = -1;
1481 
1482 	if (cbor_string_copy(key, &name) < 0) {
1483 		fido_log_debug("%s: cbor type", __func__);
1484 		ok = 0; /* ignore */
1485 		goto out;
1486 	}
1487 
1488 	if (!strcmp(name, "icon")) {
1489 		if (cbor_string_copy(val, &user->icon) < 0) {
1490 			fido_log_debug("%s: icon", __func__);
1491 			goto out;
1492 		}
1493 	} else if (!strcmp(name, "name")) {
1494 		if (cbor_string_copy(val, &user->name) < 0) {
1495 			fido_log_debug("%s: name", __func__);
1496 			goto out;
1497 		}
1498 	} else if (!strcmp(name, "displayName")) {
1499 		if (cbor_string_copy(val, &user->display_name) < 0) {
1500 			fido_log_debug("%s: display_name", __func__);
1501 			goto out;
1502 		}
1503 	} else if (!strcmp(name, "id")) {
1504 		if (fido_blob_decode(val, &user->id) < 0) {
1505 			fido_log_debug("%s: id", __func__);
1506 			goto out;
1507 		}
1508 	}
1509 
1510 	ok = 0;
1511 out:
1512 	free(name);
1513 
1514 	return (ok);
1515 }
1516 
1517 int
1518 cbor_decode_user(const cbor_item_t *item, fido_user_t *user)
1519 {
1520 	if (cbor_isa_map(item) == false ||
1521 	    cbor_map_is_definite(item) == false ||
1522 	    cbor_map_iter(item, user, decode_user_entry) < 0) {
1523 		fido_log_debug("%s: cbor type", __func__);
1524 		return (-1);
1525 	}
1526 
1527 	return (0);
1528 }
1529 
1530 static int
1531 decode_rp_entity_entry(const cbor_item_t *key, const cbor_item_t *val,
1532     void *arg)
1533 {
1534 	fido_rp_t	*rp = arg;
1535 	char		*name = NULL;
1536 	int		 ok = -1;
1537 
1538 	if (cbor_string_copy(key, &name) < 0) {
1539 		fido_log_debug("%s: cbor type", __func__);
1540 		ok = 0; /* ignore */
1541 		goto out;
1542 	}
1543 
1544 	if (!strcmp(name, "id")) {
1545 		if (cbor_string_copy(val, &rp->id) < 0) {
1546 			fido_log_debug("%s: id", __func__);
1547 			goto out;
1548 		}
1549 	} else if (!strcmp(name, "name")) {
1550 		if (cbor_string_copy(val, &rp->name) < 0) {
1551 			fido_log_debug("%s: name", __func__);
1552 			goto out;
1553 		}
1554 	}
1555 
1556 	ok = 0;
1557 out:
1558 	free(name);
1559 
1560 	return (ok);
1561 }
1562 
1563 int
1564 cbor_decode_rp_entity(const cbor_item_t *item, fido_rp_t *rp)
1565 {
1566 	if (cbor_isa_map(item) == false ||
1567 	    cbor_map_is_definite(item) == false ||
1568 	    cbor_map_iter(item, rp, decode_rp_entity_entry) < 0) {
1569 		fido_log_debug("%s: cbor type", __func__);
1570 		return (-1);
1571 	}
1572 
1573 	return (0);
1574 }
1575 
1576 cbor_item_t *
1577 cbor_build_uint(const uint64_t value)
1578 {
1579 	if (value <= UINT8_MAX)
1580 		return cbor_build_uint8((uint8_t)value);
1581 	else if (value <= UINT16_MAX)
1582 		return cbor_build_uint16((uint16_t)value);
1583 	else if (value <= UINT32_MAX)
1584 		return cbor_build_uint32((uint32_t)value);
1585 
1586 	return cbor_build_uint64(value);
1587 }
1588 
1589 int
1590 cbor_array_append(cbor_item_t **array, cbor_item_t *item)
1591 {
1592 	cbor_item_t **v, *ret;
1593 	size_t n;
1594 
1595 	if ((v = cbor_array_handle(*array)) == NULL ||
1596 	    (n = cbor_array_size(*array)) == SIZE_MAX ||
1597 	    (ret = cbor_new_definite_array(n + 1)) == NULL)
1598 		return -1;
1599 	for (size_t i = 0; i < n; i++) {
1600 		if (cbor_array_push(ret, v[i]) == 0) {
1601 			cbor_decref(&ret);
1602 			return -1;
1603 		}
1604 	}
1605 	if (cbor_array_push(ret, item) == 0) {
1606 		cbor_decref(&ret);
1607 		return -1;
1608 	}
1609 	cbor_decref(array);
1610 	*array = ret;
1611 
1612 	return 0;
1613 }
1614 
1615 int
1616 cbor_array_drop(cbor_item_t **array, size_t idx)
1617 {
1618 	cbor_item_t **v, *ret;
1619 	size_t n;
1620 
1621 	if ((v = cbor_array_handle(*array)) == NULL ||
1622 	    (n = cbor_array_size(*array)) == 0 || idx >= n ||
1623 	    (ret = cbor_new_definite_array(n - 1)) == NULL)
1624 		return -1;
1625 	for (size_t i = 0; i < n; i++) {
1626 		if (i != idx && cbor_array_push(ret, v[i]) == 0) {
1627 			cbor_decref(&ret);
1628 			return -1;
1629 		}
1630 	}
1631 	cbor_decref(array);
1632 	*array = ret;
1633 
1634 	return 0;
1635 }
1636