Debian Codegraph @

fuzz/fuzz_bio.c

raw
1 /*
2 * Copyright (c) 2019-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 #undef NDEBUG
9
10 #include <assert.h>
11 #include <stdint.h>
12 #include <stdio.h>
13 #include <stdlib.h>
14 #include <string.h>
15
16 #include "mutator_aux.h"
17 #include "wiredata_fido2.h"
18 #include "dummy.h"
19
20 #include "../openbsd-compat/openbsd-compat.h"
21
22 #define PACK_ARRAY_LEN 10
23
24 enum {
25 OPT_NO_PIN = 1,
26 OPT_PUAT = 2,
27
28 OPT_EDGE,
29 OPT_MASK = (((OPT_EDGE - 1) << 1) - 1),
30 };
31
32 /* Parameter set defining a FIDO2 credential management operation. */
33 struct param {
34 char pin[MAXSTR];
35 char name[MAXSTR];
36 uint8_t opt;
37 int seed;
38 struct blob id;
39 struct blob info_wire_data;
40 struct blob enroll_wire_data;
41 struct blob list_wire_data;
42 struct blob set_name_wire_data;
43 struct blob remove_wire_data;
44 };
45
46 /*
47 * Collection of HID reports from an authenticator issued with a FIDO2
48 * 'getFingerprintSensorInfo' bio enrollment command.
49 */
50 static const uint8_t dummy_info_wire_data[] = {
51 WIREDATA_CTAP_INIT,
52 WIREDATA_CTAP_CBOR_INFO,
53 WIREDATA_CTAP_CBOR_BIO_INFO,
54 };
55
56 /*
57 * Collection of HID reports from an authenticator issued with FIDO2
58 * 'enrollBegin' + 'enrollCaptureNextSample' bio enrollment commands.
59 */
60 static const uint8_t dummy_enroll_wire_data[] = {
61 WIREDATA_CTAP_INIT,
62 WIREDATA_CTAP_CBOR_INFO,
63 WIREDATA_CTAP_CBOR_AUTHKEY,
64 WIREDATA_CTAP_CBOR_PINTOKEN,
65 WIREDATA_CTAP_CBOR_BIO_ENROLL,
66 };
67
68 /*
69 * Collection of HID reports from an authenticator issued with a FIDO2
70 * 'enumerateEnrollments' bio enrollment command.
71 */
72 static const uint8_t dummy_list_wire_data[] = {
73 WIREDATA_CTAP_INIT,
74 WIREDATA_CTAP_CBOR_INFO,
75 WIREDATA_CTAP_CBOR_AUTHKEY,
76 WIREDATA_CTAP_CBOR_PINTOKEN,
77 WIREDATA_CTAP_CBOR_BIO_ENUM,
78 };
79
80 /*
81 * Collection of HID reports from an authenticator issued with a FIDO2
82 * 'setFriendlyName' bio enrollment command.
83 */
84 static const uint8_t dummy_set_name_wire_data[] = {
85 WIREDATA_CTAP_INIT,
86 WIREDATA_CTAP_CBOR_INFO,
87 WIREDATA_CTAP_CBOR_AUTHKEY,
88 WIREDATA_CTAP_CBOR_PINTOKEN,
89 WIREDATA_CTAP_CBOR_STATUS,
90 };
91
92 /*
93 * Collection of HID reports from an authenticator issued with a FIDO2
94 * 'removeEnrollment' bio enrollment command.
95 */
96 static const uint8_t dummy_remove_wire_data[] = {
97 WIREDATA_CTAP_INIT,
98 WIREDATA_CTAP_CBOR_INFO,
99 WIREDATA_CTAP_CBOR_AUTHKEY,
100 WIREDATA_CTAP_CBOR_PINTOKEN,
101 WIREDATA_CTAP_CBOR_STATUS,
102 };
103
104 struct param *
105 unpack(const uint8_t *ptr, size_t len)
106 {
107 cbor_item_t *item = NULL, **v;
108 struct cbor_load_result cbor;
109 struct param *p;
110 int ok = -1;
111
112 if ((p = calloc(1, sizeof(*p))) == NULL ||
113 (item = cbor_load(ptr, len, &cbor)) == NULL ||
114 cbor.read != len ||
115 cbor_isa_array(item) == false ||
116 cbor_array_is_definite(item) == false ||
117 cbor_array_size(item) != PACK_ARRAY_LEN ||
118 (v = cbor_array_handle(item)) == NULL)
119 goto fail;
120
121 if (unpack_int(v[0], &p->seed) < 0 ||
122 unpack_string(v[1], p->pin) < 0 ||
123 unpack_string(v[2], p->name) < 0 ||
124 unpack_blob(v[3], &p->id) < 0 ||
125 unpack_blob(v[4], &p->info_wire_data) < 0 ||
126 unpack_blob(v[5], &p->enroll_wire_data) < 0 ||
127 unpack_blob(v[6], &p->list_wire_data) < 0 ||
128 unpack_blob(v[7], &p->set_name_wire_data) < 0 ||
129 unpack_blob(v[8], &p->remove_wire_data) < 0 ||
130 unpack_byte(v[9], &p->opt) < 0)
131 goto fail;
132
133 ok = 0;
134 fail:
135 if (ok < 0) {
136 free(p);
137 p = NULL;
138 }
139
140 if (item)
141 cbor_decref(&item);
142
143 return p;
144 }
145
146 size_t
147 pack(uint8_t *ptr, size_t len, const struct param *p)
148 {
149 cbor_item_t *argv[PACK_ARRAY_LEN], *array = NULL;
150 size_t cbor_alloc_len, cbor_len = 0;
151 unsigned char *cbor = NULL;
152
153 memset(argv, 0, sizeof(argv));
154
155 if ((array = cbor_new_definite_array(PACK_ARRAY_LEN)) == NULL ||
156 (argv[0] = pack_int(p->seed)) == NULL ||
157 (argv[1] = pack_string(p->pin)) == NULL ||
158 (argv[2] = pack_string(p->name)) == NULL ||
159 (argv[3] = pack_blob(&p->id)) == NULL ||
160 (argv[4] = pack_blob(&p->info_wire_data)) == NULL ||
161 (argv[5] = pack_blob(&p->enroll_wire_data)) == NULL ||
162 (argv[6] = pack_blob(&p->list_wire_data)) == NULL ||
163 (argv[7] = pack_blob(&p->set_name_wire_data)) == NULL ||
164 (argv[8] = pack_blob(&p->remove_wire_data)) == NULL ||
165 (argv[9] = pack_byte(p->opt)) == NULL)
166 goto fail;
167
168 for (size_t i = 0; i < PACK_ARRAY_LEN; i++)
169 if (cbor_array_push(array, argv[i]) == false)
170 goto fail;
171
172 if ((cbor_len = cbor_serialize_alloc(array, &cbor,
173 &cbor_alloc_len)) == 0 || cbor_len > len) {
174 cbor_len = 0;
175 goto fail;
176 }
177
178 memcpy(ptr, cbor, cbor_len);
179 fail:
180 for (size_t i = 0; i < PACK_ARRAY_LEN; i++)
181 if (argv[i])
182 cbor_decref(&argv[i]);
183
184 if (array)
185 cbor_decref(&array);
186
187 free(cbor);
188
189 return cbor_len;
190 }
191
192 size_t
193 pack_dummy(uint8_t *ptr, size_t len)
194 {
195 struct param dummy;
196 uint8_t blob[MAXCORPUS];
197 size_t blob_len;
198
199 memset(&dummy, 0, sizeof(dummy));
200
201 strlcpy(dummy.pin, dummy_pin, sizeof(dummy.pin));
202 strlcpy(dummy.name, dummy_name, sizeof(dummy.name));
203
204 dummy.info_wire_data.len = sizeof(dummy_info_wire_data);
205 dummy.enroll_wire_data.len = sizeof(dummy_enroll_wire_data);
206 dummy.list_wire_data.len = sizeof(dummy_list_wire_data);
207 dummy.set_name_wire_data.len = sizeof(dummy_set_name_wire_data);
208 dummy.remove_wire_data.len = sizeof(dummy_remove_wire_data);
209 dummy.id.len = sizeof(dummy_id);
210
211 memcpy(&dummy.info_wire_data.body, &dummy_info_wire_data,
212 dummy.info_wire_data.len);
213 memcpy(&dummy.enroll_wire_data.body, &dummy_enroll_wire_data,
214 dummy.enroll_wire_data.len);
215 memcpy(&dummy.list_wire_data.body, &dummy_list_wire_data,
216 dummy.list_wire_data.len);
217 memcpy(&dummy.set_name_wire_data.body, &dummy_set_name_wire_data,
218 dummy.set_name_wire_data.len);
219 memcpy(&dummy.remove_wire_data.body, &dummy_remove_wire_data,
220 dummy.remove_wire_data.len);
221 memcpy(&dummy.id.body, &dummy_id, dummy.id.len);
222
223 assert((blob_len = pack(blob, sizeof(blob), &dummy)) != 0);
224
225 if (blob_len > len) {
226 memcpy(ptr, blob, len);
227 return len;
228 }
229
230 memcpy(ptr, blob, blob_len);
231
232 return blob_len;
233 }
234
235 static const char *
236 maybe_pin(const struct param *p)
237 {
238 return p->opt & OPT_NO_PIN ? NULL : p->pin;
239 }
240
241 static fido_dev_t *
242 prepare_dev(const struct blob *wire_data, const struct param *p)
243 {
244 fido_dev_t *dev;
245 bool x;
246
247 set_wire_data(wire_data->body, wire_data->len);
248
249 if ((dev = open_dev(0)) == NULL)
250 return NULL;
251
252 x = fido_dev_is_fido2(dev);
253 consume(&x, sizeof(x));
254 x = fido_dev_supports_pin(dev);
255 consume(&x, sizeof(x));
256 x = fido_dev_has_pin(dev);
257 consume(&x, sizeof(x));
258 x = fido_dev_supports_uv(dev);
259 consume(&x, sizeof(x));
260 x = fido_dev_has_uv(dev);
261 consume(&x, sizeof(x));
262
263 if (p->opt & OPT_PUAT)
264 fido_dev_get_puat(dev, FIDO_PUAT_BIOENROLL, NULL, maybe_pin(p));
265
266 return dev;
267 }
268
269 static void
270 get_info(const struct param *p)
271 {
272 fido_dev_t *dev = NULL;
273 fido_bio_info_t *i = NULL;
274 uint8_t type;
275 uint8_t max_samples;
276 int r;
277
278 if ((dev = prepare_dev(&p->info_wire_data, p)) == NULL ||
279 (i = fido_bio_info_new()) == NULL)
280 goto done;
281
282 r = fido_bio_dev_get_info(dev, i);
283 consume_str(fido_strerr(r));
284
285 type = fido_bio_info_type(i);
286 max_samples = fido_bio_info_max_samples(i);
287 consume(&type, sizeof(type));
288 consume(&max_samples, sizeof(max_samples));
289
290 done:
291 if (dev)
292 fido_dev_close(dev);
293
294 fido_dev_free(&dev);
295 fido_bio_info_free(&i);
296 }
297
298 static void
299 consume_template(const fido_bio_template_t *t)
300 {
301 consume_str(fido_bio_template_name(t));
302 consume(fido_bio_template_id_ptr(t), fido_bio_template_id_len(t));
303 }
304
305 static void
306 consume_enroll(fido_bio_enroll_t *e)
307 {
308 uint8_t last_status;
309 uint8_t remaining_samples;
310
311 last_status = fido_bio_enroll_last_status(e);
312 remaining_samples = fido_bio_enroll_remaining_samples(e);
313 consume(&last_status, sizeof(last_status));
314 consume(&remaining_samples, sizeof(remaining_samples));
315 }
316
317 static void
318 enroll(const struct param *p)
319 {
320 fido_dev_t *dev = NULL;
321 fido_bio_template_t *t = NULL;
322 fido_bio_enroll_t *e = NULL;
323 size_t cnt = 0;
324
325 if ((dev = prepare_dev(&p->enroll_wire_data, p)) == NULL ||
326 (t = fido_bio_template_new()) == NULL ||
327 (e = fido_bio_enroll_new()) == NULL)
328 goto done;
329
330 fido_bio_dev_enroll_begin(dev, t, e, (uint32_t)p->seed, maybe_pin(p));
331
332 consume_template(t);
333 consume_enroll(e);
334
335 while (fido_bio_enroll_remaining_samples(e) > 0 && cnt++ < 5) {
336 fido_bio_dev_enroll_continue(dev, t, e, (uint32_t)p->seed);
337 consume_template(t);
338 consume_enroll(e);
339 }
340
341 done:
342 if (dev)
343 fido_dev_close(dev);
344
345 fido_dev_free(&dev);
346 fido_bio_template_free(&t);
347 fido_bio_enroll_free(&e);
348 }
349
350 static void
351 list(const struct param *p)
352 {
353 fido_dev_t *dev = NULL;
354 fido_bio_template_array_t *ta = NULL;
355 const fido_bio_template_t *t = NULL;
356
357 if ((dev = prepare_dev(&p->list_wire_data, p)) == NULL ||
358 (ta = fido_bio_template_array_new()) == NULL)
359 goto done;
360
361 fido_bio_dev_get_template_array(dev, ta, maybe_pin(p));
362
363 /* +1 on purpose */
364 for (size_t i = 0; i < fido_bio_template_array_count(ta) + 1; i++)
365 if ((t = fido_bio_template(ta, i)) != NULL)
366 consume_template(t);
367
368 done:
369 if (dev)
370 fido_dev_close(dev);
371
372 fido_dev_free(&dev);
373 fido_bio_template_array_free(&ta);
374 }
375
376 static void
377 set_name(const struct param *p)
378 {
379 fido_dev_t *dev = NULL;
380 fido_bio_template_t *t = NULL;
381
382 if ((dev = prepare_dev(&p->set_name_wire_data, p)) == NULL ||
383 (t = fido_bio_template_new()) == NULL)
384 goto done;
385
386 fido_bio_template_set_name(t, p->name);
387 fido_bio_template_set_id(t, p->id.body, p->id.len);
388 consume_template(t);
389
390 fido_bio_dev_set_template_name(dev, t, maybe_pin(p));
391
392 done:
393 if (dev)
394 fido_dev_close(dev);
395
396 fido_dev_free(&dev);
397 fido_bio_template_free(&t);
398 }
399
400 static void
401 del(const struct param *p)
402 {
403 fido_dev_t *dev = NULL;
404 fido_bio_template_t *t = NULL;
405 int r;
406
407 if ((dev = prepare_dev(&p->remove_wire_data, p)) == NULL ||
408 (t = fido_bio_template_new()) == NULL)
409 goto done;
410
411 r = fido_bio_template_set_id(t, p->id.body, p->id.len);
412 consume_template(t);
413 consume_str(fido_strerr(r));
414
415 fido_bio_dev_enroll_remove(dev, t, maybe_pin(p));
416
417 done:
418 if (dev)
419 fido_dev_close(dev);
420
421 fido_dev_free(&dev);
422 fido_bio_template_free(&t);
423 }
424
425 void
426 test(const struct param *p)
427 {
428 prng_init((unsigned int)p->seed);
429 fuzz_clock_reset();
430 fido_init(FIDO_DEBUG);
431 fido_set_log_handler(consume_str);
432
433 get_info(p);
434 enroll(p);
435 list(p);
436 set_name(p);
437 del(p);
438 }
439
440 void
441 mutate(struct param *p, unsigned int seed, unsigned int flags) NO_MSAN
442 {
443 if (flags & MUTATE_SEED)
444 p->seed = (int)seed;
445
446 if (flags & MUTATE_PARAM) {
447 mutate_blob(&p->id);
448 mutate_string(p->pin);
449 mutate_string(p->name);
450 mutate_byte(&p->opt);
451
452 p->opt &= OPT_MASK;
453 }
454
455 if (flags & MUTATE_WIREDATA) {
456 mutate_blob(&p->info_wire_data);
457 mutate_blob(&p->enroll_wire_data);
458 mutate_blob(&p->list_wire_data);
459 mutate_blob(&p->set_name_wire_data);
460 mutate_blob(&p->remove_wire_data);
461 }
462 }