Debian Codegraph @

fuzz/fuzz_mgmt.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 MAXRPID 64
23
24 struct param {
25 char pin1[MAXSTR];
26 char pin2[MAXSTR];
27 struct blob reset_wire_data;
28 struct blob info_wire_data;
29 struct blob set_pin_wire_data;
30 struct blob change_pin_wire_data;
31 struct blob retry_wire_data;
32 struct blob config_wire_data;
33 int seed;
34 };
35
36 static const uint8_t dummy_reset_wire_data[] = {
37 WIREDATA_CTAP_INIT,
38 WIREDATA_CTAP_CBOR_INFO,
39 WIREDATA_CTAP_KEEPALIVE,
40 WIREDATA_CTAP_KEEPALIVE,
41 WIREDATA_CTAP_KEEPALIVE,
42 WIREDATA_CTAP_CBOR_STATUS,
43 };
44
45 static const uint8_t dummy_info_wire_data[] = {
46 WIREDATA_CTAP_INIT,
47 WIREDATA_CTAP_CBOR_INFO,
48 WIREDATA_CTAP_CBOR_INFO,
49 };
50
51 static const uint8_t dummy_set_pin_wire_data[] = {
52 WIREDATA_CTAP_INIT,
53 WIREDATA_CTAP_CBOR_INFO,
54 WIREDATA_CTAP_CBOR_AUTHKEY,
55 WIREDATA_CTAP_CBOR_STATUS,
56 };
57
58 static const uint8_t dummy_change_pin_wire_data[] = {
59 WIREDATA_CTAP_INIT,
60 WIREDATA_CTAP_CBOR_INFO,
61 WIREDATA_CTAP_CBOR_AUTHKEY,
62 WIREDATA_CTAP_CBOR_STATUS,
63 };
64
65 static const uint8_t dummy_retry_wire_data[] = {
66 WIREDATA_CTAP_INIT,
67 WIREDATA_CTAP_CBOR_INFO,
68 WIREDATA_CTAP_CBOR_RETRIES,
69 };
70
71 static const uint8_t dummy_config_wire_data[] = {
72 WIREDATA_CTAP_INIT,
73 WIREDATA_CTAP_CBOR_INFO,
74 WIREDATA_CTAP_CBOR_STATUS,
75 };
76
77 struct param *
78 unpack(const uint8_t *ptr, size_t len)
79 {
80 cbor_item_t *item = NULL, **v;
81 struct cbor_load_result cbor;
82 struct param *p;
83 int ok = -1;
84
85 if ((p = calloc(1, sizeof(*p))) == NULL ||
86 (item = cbor_load(ptr, len, &cbor)) == NULL ||
87 cbor.read != len ||
88 cbor_isa_array(item) == false ||
89 cbor_array_is_definite(item) == false ||
90 cbor_array_size(item) != 9 ||
91 (v = cbor_array_handle(item)) == NULL)
92 goto fail;
93
94 if (unpack_int(v[0], &p->seed) < 0 ||
95 unpack_string(v[1], p->pin1) < 0 ||
96 unpack_string(v[2], p->pin2) < 0 ||
97 unpack_blob(v[3], &p->reset_wire_data) < 0 ||
98 unpack_blob(v[4], &p->info_wire_data) < 0 ||
99 unpack_blob(v[5], &p->set_pin_wire_data) < 0 ||
100 unpack_blob(v[6], &p->change_pin_wire_data) < 0 ||
101 unpack_blob(v[7], &p->retry_wire_data) < 0 ||
102 unpack_blob(v[8], &p->config_wire_data) < 0)
103 goto fail;
104
105 ok = 0;
106 fail:
107 if (ok < 0) {
108 free(p);
109 p = NULL;
110 }
111
112 if (item)
113 cbor_decref(&item);
114
115 return p;
116 }
117
118 size_t
119 pack(uint8_t *ptr, size_t len, const struct param *p)
120 {
121 cbor_item_t *argv[9], *array = NULL;
122 size_t cbor_alloc_len, cbor_len = 0;
123 unsigned char *cbor = NULL;
124
125 memset(argv, 0, sizeof(argv));
126
127 if ((array = cbor_new_definite_array(9)) == NULL ||
128 (argv[0] = pack_int(p->seed)) == NULL ||
129 (argv[1] = pack_string(p->pin1)) == NULL ||
130 (argv[2] = pack_string(p->pin2)) == NULL ||
131 (argv[3] = pack_blob(&p->reset_wire_data)) == NULL ||
132 (argv[4] = pack_blob(&p->info_wire_data)) == NULL ||
133 (argv[5] = pack_blob(&p->set_pin_wire_data)) == NULL ||
134 (argv[6] = pack_blob(&p->change_pin_wire_data)) == NULL ||
135 (argv[7] = pack_blob(&p->retry_wire_data)) == NULL ||
136 (argv[8] = pack_blob(&p->config_wire_data)) == NULL)
137 goto fail;
138
139 for (size_t i = 0; i < 9; i++)
140 if (cbor_array_push(array, argv[i]) == false)
141 goto fail;
142
143 if ((cbor_len = cbor_serialize_alloc(array, &cbor,
144 &cbor_alloc_len)) == 0 || cbor_len > len) {
145 cbor_len = 0;
146 goto fail;
147 }
148
149 memcpy(ptr, cbor, cbor_len);
150 fail:
151 for (size_t i = 0; i < 9; i++)
152 if (argv[i])
153 cbor_decref(&argv[i]);
154
155 if (array)
156 cbor_decref(&array);
157
158 free(cbor);
159
160 return cbor_len;
161 }
162
163 size_t
164 pack_dummy(uint8_t *ptr, size_t len)
165 {
166 struct param dummy;
167 uint8_t blob[MAXCORPUS];
168 size_t blob_len;
169
170 memset(&dummy, 0, sizeof(dummy));
171
172 strlcpy(dummy.pin1, dummy_pin1, sizeof(dummy.pin1));
173 strlcpy(dummy.pin2, dummy_pin2, sizeof(dummy.pin2));
174
175 dummy.reset_wire_data.len = sizeof(dummy_reset_wire_data);
176 dummy.info_wire_data.len = sizeof(dummy_info_wire_data);
177 dummy.set_pin_wire_data.len = sizeof(dummy_set_pin_wire_data);
178 dummy.change_pin_wire_data.len = sizeof(dummy_change_pin_wire_data);
179 dummy.retry_wire_data.len = sizeof(dummy_retry_wire_data);
180 dummy.config_wire_data.len = sizeof(dummy_config_wire_data);
181
182 memcpy(&dummy.reset_wire_data.body, &dummy_reset_wire_data,
183 dummy.reset_wire_data.len);
184 memcpy(&dummy.info_wire_data.body, &dummy_info_wire_data,
185 dummy.info_wire_data.len);
186 memcpy(&dummy.set_pin_wire_data.body, &dummy_set_pin_wire_data,
187 dummy.set_pin_wire_data.len);
188 memcpy(&dummy.change_pin_wire_data.body, &dummy_change_pin_wire_data,
189 dummy.change_pin_wire_data.len);
190 memcpy(&dummy.retry_wire_data.body, &dummy_retry_wire_data,
191 dummy.retry_wire_data.len);
192 memcpy(&dummy.config_wire_data.body, &dummy_config_wire_data,
193 dummy.config_wire_data.len);
194
195 assert((blob_len = pack(blob, sizeof(blob), &dummy)) != 0);
196
197 if (blob_len > len) {
198 memcpy(ptr, blob, len);
199 return len;
200 }
201
202 memcpy(ptr, blob, blob_len);
203
204 return blob_len;
205 }
206
207 static void
208 dev_reset(const struct param *p)
209 {
210 fido_dev_t *dev;
211
212 set_wire_data(p->reset_wire_data.body, p->reset_wire_data.len);
213
214 if ((dev = open_dev(0)) == NULL)
215 return;
216
217 fido_dev_reset(dev);
218 fido_dev_close(dev);
219 fido_dev_free(&dev);
220 }
221
222 static void
223 dev_get_cbor_info(const struct param *p)
224 {
225 fido_dev_t *dev;
226 fido_cbor_info_t *ci;
227 uint64_t n;
228 uint8_t proto, major, minor, build, flags;
229 bool v;
230 int r;
231 const unsigned char *ppuat;
232 size_t ppuat_len;
233
234 set_wire_data(p->info_wire_data.body, p->info_wire_data.len);
235
236 if ((dev = open_dev(0)) == NULL)
237 return;
238
239 /* XXX: re-use PIN */
240 ppuat = (const unsigned char *)p->pin1;
241 ppuat_len = strlen(p->pin1);
242 if (ppuat_len == 0)
243 ppuat = NULL;
244
245 proto = fido_dev_protocol(dev);
246 major = fido_dev_major(dev);
247 minor = fido_dev_minor(dev);
248 build = fido_dev_build(dev);
249 flags = fido_dev_flags(dev);
250
251 consume(&proto, sizeof(proto));
252 consume(&major, sizeof(major));
253 consume(&minor, sizeof(minor));
254 consume(&build, sizeof(build));
255 consume(&flags, sizeof(flags));
256
257 if ((ci = fido_cbor_info_new()) == NULL)
258 goto out;
259
260 r = fido_dev_get_cbor_info(dev, ci);
261 consume_str(fido_strerr(r));
262
263 r = fido_cbor_info_decrypt(ci, ppuat, ppuat_len);
264 consume_str(fido_strerr(r));
265
266 for (size_t i = 0; i < fido_cbor_info_versions_len(ci); i++) {
267 char * const *sa = fido_cbor_info_versions_ptr(ci);
268 consume(sa[i], strlen(sa[i]));
269 }
270
271 for (size_t i = 0; i < fido_cbor_info_extensions_len(ci); i++) {
272 char * const *sa = fido_cbor_info_extensions_ptr(ci);
273 consume(sa[i], strlen(sa[i]));
274 }
275
276 for (size_t i = 0; i < fido_cbor_info_transports_len(ci); i++) {
277 char * const *sa = fido_cbor_info_transports_ptr(ci);
278 consume(sa[i], strlen(sa[i]));
279 }
280
281 for (size_t i = 0; i < fido_cbor_info_attfmts_len(ci); i++) {
282 char * const *sa = fido_cbor_info_attfmts_ptr(ci);
283 consume(sa[i], strlen(sa[i]));
284 }
285
286 for (size_t i = 0; i < fido_cbor_info_reset_transports_len(ci); i++) {
287 char * const *sa = fido_cbor_info_reset_transports_ptr(ci);
288 consume(sa[i], strlen(sa[i]));
289 }
290
291 for (size_t i = 0; i < fido_cbor_info_options_len(ci); i++) {
292 char * const *sa = fido_cbor_info_options_name_ptr(ci);
293 const bool *va = fido_cbor_info_options_value_ptr(ci);
294 consume(sa[i], strlen(sa[i]));
295 consume(&va[i], sizeof(va[i]));
296 }
297
298 /* +1 on purpose */
299 for (size_t i = 0; i <= fido_cbor_info_algorithm_count(ci); i++) {
300 const char *type = fido_cbor_info_algorithm_type(ci, i);
301 int cose = fido_cbor_info_algorithm_cose(ci, i);
302 consume_str(type);
303 consume(&cose, sizeof(cose));
304 }
305
306 for (size_t i = 0; i < fido_cbor_info_certs_len(ci); i++) {
307 char * const *na = fido_cbor_info_certs_name_ptr(ci);
308 const uint64_t *va = fido_cbor_info_certs_value_ptr(ci);
309 consume(na[i], strlen(na[i]));
310 consume(&va[i], sizeof(va[i]));
311 }
312
313 n = fido_cbor_info_maxmsgsiz(ci);
314 consume(&n, sizeof(n));
315 n = fido_cbor_info_maxcredbloblen(ci);
316 consume(&n, sizeof(n));
317 n = fido_cbor_info_maxcredcntlst(ci);
318 consume(&n, sizeof(n));
319 n = fido_cbor_info_maxcredidlen(ci);
320 consume(&n, sizeof(n));
321 n = fido_cbor_info_maxlargeblob(ci);
322 consume(&n, sizeof(n));
323 n = fido_cbor_info_fwversion(ci);
324 consume(&n, sizeof(n));
325 n = fido_cbor_info_minpinlen(ci);
326 consume(&n, sizeof(n));
327 n = fido_cbor_info_maxrpid_minpinlen(ci);
328 consume(&n, sizeof(n));
329 n = fido_cbor_info_uv_attempts(ci);
330 consume(&n, sizeof(n));
331 n = fido_cbor_info_uv_modality(ci);
332 consume(&n, sizeof(n));
333 n = (uint64_t)fido_cbor_info_rk_remaining(ci);
334 consume(&n, sizeof(n));
335 n = (uint64_t)fido_cbor_info_uv_count_since_pin(ci);
336 consume(&n, sizeof(n));
337 n = (uint64_t)fido_cbor_info_pin_policy(ci);
338 consume(&n, sizeof(n));
339 n = (uint64_t)fido_cbor_info_maxpinlen(ci);
340 consume(&n, sizeof(n));
341
342 consume(fido_cbor_info_aaguid_ptr(ci), fido_cbor_info_aaguid_len(ci));
343 consume(fido_cbor_info_protocols_ptr(ci),
344 fido_cbor_info_protocols_len(ci));
345 consume(fido_cbor_info_cfgcmds_ptr(ci), fido_cbor_info_cfgcmds_len(ci));
346 consume(fido_cbor_info_encid_ptr(ci), fido_cbor_info_encid_len(ci));
347 consume(fido_cbor_info_id_ptr(ci), fido_cbor_info_id_len(ci));
348 consume(fido_cbor_info_encstate_ptr(ci), fido_cbor_info_encstate_len(ci));
349 consume(fido_cbor_info_state_ptr(ci), fido_cbor_info_state_len(ci));
350 consume(fido_cbor_info_pin_policy_url_ptr(ci),
351 fido_cbor_info_pin_policy_url_len(ci));
352
353 v = fido_cbor_info_new_pin_required(ci);
354 consume(&v, sizeof(v));
355 v = fido_cbor_info_long_touch_reset(ci);
356 consume(&v, sizeof(v));
357
358 out:
359 fido_dev_close(dev);
360 fido_dev_free(&dev);
361
362 fido_cbor_info_free(&ci);
363 }
364
365 static void
366 dev_set_pin(const struct param *p)
367 {
368 fido_dev_t *dev;
369
370 set_wire_data(p->set_pin_wire_data.body, p->set_pin_wire_data.len);
371
372 if ((dev = open_dev(0)) == NULL)
373 return;
374
375 fido_dev_set_pin(dev, p->pin1, NULL);
376 fido_dev_close(dev);
377 fido_dev_free(&dev);
378 }
379
380 static void
381 dev_change_pin(const struct param *p)
382 {
383 fido_dev_t *dev;
384
385 set_wire_data(p->change_pin_wire_data.body, p->change_pin_wire_data.len);
386
387 if ((dev = open_dev(0)) == NULL)
388 return;
389
390 fido_dev_set_pin(dev, p->pin2, p->pin1);
391 fido_dev_close(dev);
392 fido_dev_free(&dev);
393 }
394
395 static void
396 dev_get_retry_count(const struct param *p)
397 {
398 fido_dev_t *dev;
399 int n = 0;
400
401 set_wire_data(p->retry_wire_data.body, p->retry_wire_data.len);
402
403 if ((dev = open_dev(0)) == NULL)
404 return;
405
406 fido_dev_get_retry_count(dev, &n);
407 consume(&n, sizeof(n));
408 fido_dev_close(dev);
409 fido_dev_free(&dev);
410 }
411
412 static void
413 dev_get_uv_retry_count(const struct param *p)
414 {
415 fido_dev_t *dev;
416 int n = 0;
417
418 set_wire_data(p->retry_wire_data.body, p->retry_wire_data.len);
419
420 if ((dev = open_dev(0)) == NULL)
421 return;
422
423 fido_dev_get_uv_retry_count(dev, &n);
424 consume(&n, sizeof(n));
425 fido_dev_close(dev);
426 fido_dev_free(&dev);
427 }
428
429 static void
430 dev_enable_entattest(const struct param *p)
431 {
432 fido_dev_t *dev;
433 const char *pin;
434 int r;
435
436 set_wire_data(p->config_wire_data.body, p->config_wire_data.len);
437 if ((dev = open_dev(0)) == NULL)
438 return;
439 pin = p->pin1;
440 if (strlen(pin) == 0)
441 pin = NULL;
442 r = fido_dev_enable_entattest(dev, pin);
443 consume_str(fido_strerr(r));
444 fido_dev_close(dev);
445 fido_dev_free(&dev);
446 }
447
448 static void
449 dev_toggle_always_uv(const struct param *p)
450 {
451 fido_dev_t *dev;
452 const char *pin;
453 int r;
454
455 set_wire_data(p->config_wire_data.body, p->config_wire_data.len);
456 if ((dev = open_dev(0)) == NULL)
457 return;
458 pin = p->pin1;
459 if (strlen(pin) == 0)
460 pin = NULL;
461 r = fido_dev_toggle_always_uv(dev, pin);
462 consume_str(fido_strerr(r));
463 fido_dev_close(dev);
464 fido_dev_free(&dev);
465 }
466
467 static void
468 dev_force_pin_change(const struct param *p)
469 {
470 fido_dev_t *dev;
471 const char *pin;
472 int r;
473
474 set_wire_data(p->config_wire_data.body, p->config_wire_data.len);
475 if ((dev = open_dev(0)) == NULL)
476 return;
477 pin = p->pin1;
478 if (strlen(pin) == 0)
479 pin = NULL;
480 r = fido_dev_force_pin_change(dev, pin);
481 consume_str(fido_strerr(r));
482 fido_dev_close(dev);
483 fido_dev_free(&dev);
484 }
485
486 static void
487 dev_set_pin_minlen(const struct param *p)
488 {
489 fido_dev_t *dev;
490 const char *pin;
491 int r;
492
493 set_wire_data(p->config_wire_data.body, p->config_wire_data.len);
494 if ((dev = open_dev(0)) == NULL)
495 return;
496 pin = p->pin1;
497 if (strlen(pin) == 0)
498 pin = NULL;
499 r = fido_dev_set_pin_minlen(dev, strlen(p->pin2), pin);
500 consume_str(fido_strerr(r));
501 fido_dev_close(dev);
502 fido_dev_free(&dev);
503 }
504
505 static void
506 dev_set_pin_minlen_rpid(const struct param *p)
507 {
508 fido_dev_t *dev;
509 const char *rpid[MAXRPID];
510 const char *pin;
511 size_t n;
512 int r;
513
514 set_wire_data(p->config_wire_data.body, p->config_wire_data.len);
515 if ((dev = open_dev(0)) == NULL)
516 return;
517 n = uniform_random(MAXRPID);
518 for (size_t i = 0; i < n; i++)
519 rpid[i] = dummy_rp_id;
520 pin = p->pin1;
521 if (strlen(pin) == 0)
522 pin = NULL;
523 r = fido_dev_set_pin_minlen_rpid(dev, rpid, n, pin);
524 consume_str(fido_strerr(r));
525 fido_dev_close(dev);
526 fido_dev_free(&dev);
527 }
528
529 void
530 test(const struct param *p)
531 {
532 prng_init((unsigned int)p->seed);
533 fuzz_clock_reset();
534 fido_init(FIDO_DEBUG);
535 fido_set_log_handler(consume_str);
536
537 dev_reset(p);
538 dev_get_cbor_info(p);
539 dev_set_pin(p);
540 dev_change_pin(p);
541 dev_get_retry_count(p);
542 dev_get_uv_retry_count(p);
543 dev_enable_entattest(p);
544 dev_toggle_always_uv(p);
545 dev_force_pin_change(p);
546 dev_set_pin_minlen(p);
547 dev_set_pin_minlen_rpid(p);
548 }
549
550 void
551 mutate(struct param *p, unsigned int seed, unsigned int flags) NO_MSAN
552 {
553 if (flags & MUTATE_SEED)
554 p->seed = (int)seed;
555
556 if (flags & MUTATE_PARAM) {
557 mutate_string(p->pin1);
558 mutate_string(p->pin2);
559 }
560
561 if (flags & MUTATE_WIREDATA) {
562 mutate_blob(&p->reset_wire_data);
563 mutate_blob(&p->info_wire_data);
564 mutate_blob(&p->set_pin_wire_data);
565 mutate_blob(&p->change_pin_wire_data);
566 mutate_blob(&p->retry_wire_data);
567 }
568 }