xref: /freebsd/contrib/libfido2/src/info.c (revision 9768746b) 
1 /*
2  * Copyright (c) 2018-2021 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 "fido.h"
8 
9 static int
10 decode_string(const cbor_item_t *item, void *arg)
11 {
12 	fido_str_array_t	*a = arg;
13 	const size_t		 i = a->len;
14 
15 	/* keep ptr[x] and len consistent */
16 	if (cbor_string_copy(item, &a->ptr[i]) < 0) {
17 		fido_log_debug("%s: cbor_string_copy", __func__);
18 		return (-1);
19 	}
20 
21 	a->len++;
22 
23 	return (0);
24 }
25 
26 static int
27 decode_string_array(const cbor_item_t *item, fido_str_array_t *v)
28 {
29 	v->ptr = NULL;
30 	v->len = 0;
31 
32 	if (cbor_isa_array(item) == false ||
33 	    cbor_array_is_definite(item) == false) {
34 		fido_log_debug("%s: cbor type", __func__);
35 		return (-1);
36 	}
37 
38 	v->ptr = calloc(cbor_array_size(item), sizeof(char *));
39 	if (v->ptr == NULL)
40 		return (-1);
41 
42 	if (cbor_array_iter(item, v, decode_string) < 0) {
43 		fido_log_debug("%s: decode_string", __func__);
44 		return (-1);
45 	}
46 
47 	return (0);
48 }
49 
50 static int
51 decode_aaguid(const cbor_item_t *item, unsigned char *aaguid, size_t aaguid_len)
52 {
53 	if (cbor_isa_bytestring(item) == false ||
54 	    cbor_bytestring_is_definite(item) == false ||
55 	    cbor_bytestring_length(item) != aaguid_len) {
56 		fido_log_debug("%s: cbor type", __func__);
57 		return (-1);
58 	}
59 
60 	memcpy(aaguid, cbor_bytestring_handle(item), aaguid_len);
61 
62 	return (0);
63 }
64 
65 static int
66 decode_option(const cbor_item_t *key, const cbor_item_t *val, void *arg)
67 {
68 	fido_opt_array_t	*o = arg;
69 	const size_t		 i = o->len;
70 
71 	if (cbor_isa_float_ctrl(val) == false ||
72 	    cbor_float_get_width(val) != CBOR_FLOAT_0 ||
73 	    cbor_is_bool(val) == false) {
74 		fido_log_debug("%s: cbor type", __func__);
75 		return (0); /* ignore */
76 	}
77 
78 	if (cbor_string_copy(key, &o->name[i]) < 0) {
79 		fido_log_debug("%s: cbor_string_copy", __func__);
80 		return (0); /* ignore */
81 	}
82 
83 	/* keep name/value and len consistent */
84 	o->value[i] = cbor_ctrl_value(val) == CBOR_CTRL_TRUE;
85 	o->len++;
86 
87 	return (0);
88 }
89 
90 static int
91 decode_options(const cbor_item_t *item, fido_opt_array_t *o)
92 {
93 	o->name = NULL;
94 	o->value = NULL;
95 	o->len = 0;
96 
97 	if (cbor_isa_map(item) == false ||
98 	    cbor_map_is_definite(item) == false) {
99 		fido_log_debug("%s: cbor type", __func__);
100 		return (-1);
101 	}
102 
103 	o->name = calloc(cbor_map_size(item), sizeof(char *));
104 	o->value = calloc(cbor_map_size(item), sizeof(bool));
105 	if (o->name == NULL || o->value == NULL)
106 		return (-1);
107 
108 	return (cbor_map_iter(item, o, decode_option));
109 }
110 
111 static int
112 decode_protocol(const cbor_item_t *item, void *arg)
113 {
114 	fido_byte_array_t	*p = arg;
115 	const size_t		 i = p->len;
116 
117 	if (cbor_isa_uint(item) == false ||
118 	    cbor_int_get_width(item) != CBOR_INT_8) {
119 		fido_log_debug("%s: cbor type", __func__);
120 		return (-1);
121 	}
122 
123 	/* keep ptr[x] and len consistent */
124 	p->ptr[i] = cbor_get_uint8(item);
125 	p->len++;
126 
127 	return (0);
128 }
129 
130 static int
131 decode_protocols(const cbor_item_t *item, fido_byte_array_t *p)
132 {
133 	p->ptr = NULL;
134 	p->len = 0;
135 
136 	if (cbor_isa_array(item) == false ||
137 	    cbor_array_is_definite(item) == false) {
138 		fido_log_debug("%s: cbor type", __func__);
139 		return (-1);
140 	}
141 
142 	p->ptr = calloc(cbor_array_size(item), sizeof(uint8_t));
143 	if (p->ptr == NULL)
144 		return (-1);
145 
146 	if (cbor_array_iter(item, p, decode_protocol) < 0) {
147 		fido_log_debug("%s: decode_protocol", __func__);
148 		return (-1);
149 	}
150 
151 	return (0);
152 }
153 
154 static int
155 decode_algorithm_entry(const cbor_item_t *key, const cbor_item_t *val,
156     void *arg)
157 {
158 	fido_algo_t *alg = arg;
159 	char *name = NULL;
160 	int ok = -1;
161 
162 	if (cbor_string_copy(key, &name) < 0) {
163 		fido_log_debug("%s: cbor type", __func__);
164 		ok = 0; /* ignore */
165 		goto out;
166 	}
167 
168 	if (!strcmp(name, "alg")) {
169 		if (cbor_isa_negint(val) == false ||
170 		    cbor_get_int(val) > INT_MAX || alg->cose != 0) {
171 			fido_log_debug("%s: alg", __func__);
172 			goto out;
173 		}
174 		alg->cose = -(int)cbor_get_int(val) - 1;
175 	} else if (!strcmp(name, "type")) {
176 		if (cbor_string_copy(val, &alg->type) < 0) {
177 			fido_log_debug("%s: type", __func__);
178 			goto out;
179 		}
180 	}
181 
182 	ok = 0;
183 out:
184 	free(name);
185 
186 	return (ok);
187 }
188 
189 static void
190 free_algo(fido_algo_t *a)
191 {
192 	free(a->type);
193 	a->type = NULL;
194 	a->cose = 0;
195 }
196 
197 static int
198 decode_algorithm(const cbor_item_t *item, void *arg)
199 {
200 	fido_algo_array_t *aa = arg;
201 	const size_t i = aa->len;
202 
203 	if (cbor_isa_map(item) == false ||
204 	    cbor_map_is_definite(item) == false) {
205 		fido_log_debug("%s: cbor type", __func__);
206 		return (-1);
207 	}
208 
209 	memset(&aa->ptr[i], 0, sizeof(aa->ptr[i]));
210 
211 	if (cbor_map_iter(item, &aa->ptr[i], decode_algorithm_entry) < 0) {
212 		fido_log_debug("%s: decode_algorithm_entry", __func__);
213 		free_algo(&aa->ptr[i]);
214 		return (-1);
215 	}
216 
217 	/* keep ptr[x] and len consistent */
218 	aa->len++;
219 
220 	return (0);
221 }
222 
223 static int
224 decode_algorithms(const cbor_item_t *item, fido_algo_array_t *aa)
225 {
226 	aa->ptr = NULL;
227 	aa->len = 0;
228 
229 	if (cbor_isa_array(item) == false ||
230 	    cbor_array_is_definite(item) == false) {
231 		fido_log_debug("%s: cbor type", __func__);
232 		return (-1);
233 	}
234 
235 	aa->ptr = calloc(cbor_array_size(item), sizeof(fido_algo_t));
236 	if (aa->ptr == NULL)
237 		return (-1);
238 
239 	if (cbor_array_iter(item, aa, decode_algorithm) < 0) {
240 		fido_log_debug("%s: decode_algorithm", __func__);
241 		return (-1);
242 	}
243 
244 	return (0);
245 }
246 
247 static int
248 parse_reply_element(const cbor_item_t *key, const cbor_item_t *val, void *arg)
249 {
250 	fido_cbor_info_t *ci = arg;
251 
252 	if (cbor_isa_uint(key) == false ||
253 	    cbor_int_get_width(key) != CBOR_INT_8) {
254 		fido_log_debug("%s: cbor type", __func__);
255 		return (0); /* ignore */
256 	}
257 
258 	switch (cbor_get_uint8(key)) {
259 	case 1: /* versions */
260 		return (decode_string_array(val, &ci->versions));
261 	case 2: /* extensions */
262 		return (decode_string_array(val, &ci->extensions));
263 	case 3: /* aaguid */
264 		return (decode_aaguid(val, ci->aaguid, sizeof(ci->aaguid)));
265 	case 4: /* options */
266 		return (decode_options(val, &ci->options));
267 	case 5: /* maxMsgSize */
268 		return (cbor_decode_uint64(val, &ci->maxmsgsiz));
269 	case 6: /* pinProtocols */
270 		return (decode_protocols(val, &ci->protocols));
271 	case 7: /* maxCredentialCountInList */
272 		return (cbor_decode_uint64(val, &ci->maxcredcntlst));
273 	case 8: /* maxCredentialIdLength */
274 		return (cbor_decode_uint64(val, &ci->maxcredidlen));
275 	case 9: /* transports */
276 		return (decode_string_array(val, &ci->transports));
277 	case 10: /* algorithms */
278 		return (decode_algorithms(val, &ci->algorithms));
279 	case 14: /* fwVersion */
280 		return (cbor_decode_uint64(val, &ci->fwversion));
281 	case 15: /* maxCredBlobLen */
282 		return (cbor_decode_uint64(val, &ci->maxcredbloblen));
283 	default: /* ignore */
284 		fido_log_debug("%s: cbor type", __func__);
285 		return (0);
286 	}
287 }
288 
289 static int
290 fido_dev_get_cbor_info_tx(fido_dev_t *dev)
291 {
292 	const unsigned char cbor[] = { CTAP_CBOR_GETINFO };
293 
294 	fido_log_debug("%s: dev=%p", __func__, (void *)dev);
295 
296 	if (fido_tx(dev, CTAP_CMD_CBOR, cbor, sizeof(cbor)) < 0) {
297 		fido_log_debug("%s: fido_tx", __func__);
298 		return (FIDO_ERR_TX);
299 	}
300 
301 	return (FIDO_OK);
302 }
303 
304 static int
305 fido_dev_get_cbor_info_rx(fido_dev_t *dev, fido_cbor_info_t *ci, int ms)
306 {
307 	unsigned char	reply[FIDO_MAXMSG];
308 	int		reply_len;
309 
310 	fido_log_debug("%s: dev=%p, ci=%p, ms=%d", __func__, (void *)dev,
311 	    (void *)ci, ms);
312 
313 	fido_cbor_info_reset(ci);
314 
315 	if ((reply_len = fido_rx(dev, CTAP_CMD_CBOR, &reply, sizeof(reply),
316 	    ms)) < 0) {
317 		fido_log_debug("%s: fido_rx", __func__);
318 		return (FIDO_ERR_RX);
319 	}
320 
321 	return (cbor_parse_reply(reply, (size_t)reply_len, ci,
322 	    parse_reply_element));
323 }
324 
325 int
326 fido_dev_get_cbor_info_wait(fido_dev_t *dev, fido_cbor_info_t *ci, int ms)
327 {
328 	int r;
329 
330 #ifdef USE_WINHELLO
331 	if (dev->flags & FIDO_DEV_WINHELLO)
332 		return (fido_winhello_get_cbor_info(dev, ci));
333 #endif
334 	if ((r = fido_dev_get_cbor_info_tx(dev)) != FIDO_OK ||
335 	    (r = fido_dev_get_cbor_info_rx(dev, ci, ms)) != FIDO_OK)
336 		return (r);
337 
338 	return (FIDO_OK);
339 }
340 
341 int
342 fido_dev_get_cbor_info(fido_dev_t *dev, fido_cbor_info_t *ci)
343 {
344 	return (fido_dev_get_cbor_info_wait(dev, ci, -1));
345 }
346 
347 /*
348  * get/set functions for fido_cbor_info_t; always at the end of the file
349  */
350 
351 fido_cbor_info_t *
352 fido_cbor_info_new(void)
353 {
354 	return (calloc(1, sizeof(fido_cbor_info_t)));
355 }
356 
357 static void
358 free_str_array(fido_str_array_t *sa)
359 {
360 	for (size_t i = 0; i < sa->len; i++)
361 		free(sa->ptr[i]);
362 
363 	free(sa->ptr);
364 	sa->ptr = NULL;
365 	sa->len = 0;
366 }
367 
368 static void
369 free_opt_array(fido_opt_array_t *oa)
370 {
371 	for (size_t i = 0; i < oa->len; i++)
372 		free(oa->name[i]);
373 
374 	free(oa->name);
375 	free(oa->value);
376 	oa->name = NULL;
377 	oa->value = NULL;
378 }
379 
380 static void
381 free_byte_array(fido_byte_array_t *ba)
382 {
383 	free(ba->ptr);
384 
385 	ba->ptr = NULL;
386 	ba->len = 0;
387 }
388 
389 static void
390 free_algo_array(fido_algo_array_t *aa)
391 {
392 	for (size_t i = 0; i < aa->len; i++)
393 		free_algo(&aa->ptr[i]);
394 
395 	free(aa->ptr);
396 	aa->ptr = NULL;
397 	aa->len = 0;
398 }
399 
400 void
401 fido_cbor_info_reset(fido_cbor_info_t *ci)
402 {
403 	free_str_array(&ci->versions);
404 	free_str_array(&ci->extensions);
405 	free_str_array(&ci->transports);
406 	free_opt_array(&ci->options);
407 	free_byte_array(&ci->protocols);
408 	free_algo_array(&ci->algorithms);
409 }
410 
411 void
412 fido_cbor_info_free(fido_cbor_info_t **ci_p)
413 {
414 	fido_cbor_info_t *ci;
415 
416 	if (ci_p == NULL || (ci = *ci_p) ==  NULL)
417 		return;
418 	fido_cbor_info_reset(ci);
419 	free(ci);
420 	*ci_p = NULL;
421 }
422 
423 char **
424 fido_cbor_info_versions_ptr(const fido_cbor_info_t *ci)
425 {
426 	return (ci->versions.ptr);
427 }
428 
429 size_t
430 fido_cbor_info_versions_len(const fido_cbor_info_t *ci)
431 {
432 	return (ci->versions.len);
433 }
434 
435 char **
436 fido_cbor_info_extensions_ptr(const fido_cbor_info_t *ci)
437 {
438 	return (ci->extensions.ptr);
439 }
440 
441 size_t
442 fido_cbor_info_extensions_len(const fido_cbor_info_t *ci)
443 {
444 	return (ci->extensions.len);
445 }
446 
447 char **
448 fido_cbor_info_transports_ptr(const fido_cbor_info_t *ci)
449 {
450 	return (ci->transports.ptr);
451 }
452 
453 size_t
454 fido_cbor_info_transports_len(const fido_cbor_info_t *ci)
455 {
456 	return (ci->transports.len);
457 }
458 
459 const unsigned char *
460 fido_cbor_info_aaguid_ptr(const fido_cbor_info_t *ci)
461 {
462 	return (ci->aaguid);
463 }
464 
465 size_t
466 fido_cbor_info_aaguid_len(const fido_cbor_info_t *ci)
467 {
468 	return (sizeof(ci->aaguid));
469 }
470 
471 char **
472 fido_cbor_info_options_name_ptr(const fido_cbor_info_t *ci)
473 {
474 	return (ci->options.name);
475 }
476 
477 const bool *
478 fido_cbor_info_options_value_ptr(const fido_cbor_info_t *ci)
479 {
480 	return (ci->options.value);
481 }
482 
483 size_t
484 fido_cbor_info_options_len(const fido_cbor_info_t *ci)
485 {
486 	return (ci->options.len);
487 }
488 
489 uint64_t
490 fido_cbor_info_maxcredbloblen(const fido_cbor_info_t *ci)
491 {
492 	return (ci->maxcredbloblen);
493 }
494 
495 uint64_t
496 fido_cbor_info_maxmsgsiz(const fido_cbor_info_t *ci)
497 {
498 	return (ci->maxmsgsiz);
499 }
500 
501 uint64_t
502 fido_cbor_info_maxcredcntlst(const fido_cbor_info_t *ci)
503 {
504 	return (ci->maxcredcntlst);
505 }
506 
507 uint64_t
508 fido_cbor_info_maxcredidlen(const fido_cbor_info_t *ci)
509 {
510 	return (ci->maxcredidlen);
511 }
512 
513 uint64_t
514 fido_cbor_info_fwversion(const fido_cbor_info_t *ci)
515 {
516 	return (ci->fwversion);
517 }
518 
519 const uint8_t *
520 fido_cbor_info_protocols_ptr(const fido_cbor_info_t *ci)
521 {
522 	return (ci->protocols.ptr);
523 }
524 
525 size_t
526 fido_cbor_info_protocols_len(const fido_cbor_info_t *ci)
527 {
528 	return (ci->protocols.len);
529 }
530 
531 size_t
532 fido_cbor_info_algorithm_count(const fido_cbor_info_t *ci)
533 {
534 	return (ci->algorithms.len);
535 }
536 
537 const char *
538 fido_cbor_info_algorithm_type(const fido_cbor_info_t *ci, size_t idx)
539 {
540 	if (idx >= ci->algorithms.len)
541 		return (NULL);
542 
543 	return (ci->algorithms.ptr[idx].type);
544 }
545 
546 int
547 fido_cbor_info_algorithm_cose(const fido_cbor_info_t *ci, size_t idx)
548 {
549 	if (idx >= ci->algorithms.len)
550 		return (0);
551 
552 	return (ci->algorithms.ptr[idx].cose);
553 }
554