Debian Codegraph @

fuzz/fuzz_assert.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 "wiredata_u2f.h"
19 #include "dummy.h"
20
21 #include "../openbsd-compat/openbsd-compat.h"
22
23 enum {
24 OPT_FORCE_U2F = 1,
25 OPT_NFC = 2,
26 OPT_PUAT = 4,
27
28 OPT_EDGE,
29 OPT_MASK = (((OPT_EDGE - 1) << 1) - 1),
30 };
31
32 /* Parameter set defining a FIDO2 get assertion operation. */
33 struct param {
34 char pin[MAXSTR];
35 char rp_id[MAXSTR];
36 int ext;
37 int seed;
38 struct blob cdh;
39 struct blob cred;
40 struct blob es256;
41 struct blob rs256;
42 struct blob eddsa;
43 struct blob wire_data;
44 uint8_t cred_count;
45 uint8_t type;
46 uint8_t opt;
47 uint8_t up;
48 uint8_t uv;
49 };
50
51 /*
52 * Collection of HID reports from an authenticator issued with a FIDO2
53 * get assertion using the example parameters above.
54 */
55 static const uint8_t dummy_wire_data_fido[] = {
56 WIREDATA_CTAP_INIT,
57 WIREDATA_CTAP_CBOR_INFO,
58 WIREDATA_CTAP_CBOR_AUTHKEY,
59 WIREDATA_CTAP_CBOR_PINTOKEN,
60 WIREDATA_CTAP_CBOR_ASSERT,
61 };
62
63 /*
64 * Collection of HID reports from an authenticator issued with a U2F
65 * authentication using the example parameters above.
66 */
67 static const uint8_t dummy_wire_data_u2f[] = {
68 WIREDATA_CTAP_INIT,
69 WIREDATA_CTAP_U2F_6985,
70 WIREDATA_CTAP_U2F_6985,
71 WIREDATA_CTAP_U2F_6985,
72 WIREDATA_CTAP_U2F_6985,
73 WIREDATA_CTAP_U2F_AUTH,
74 };
75
76 struct param *
77 unpack(const uint8_t *ptr, size_t len)
78 {
79 cbor_item_t *item = NULL, **v;
80 struct cbor_load_result cbor;
81 struct param *p;
82 int ok = -1;
83
84 if ((p = calloc(1, sizeof(*p))) == NULL ||
85 (item = cbor_load(ptr, len, &cbor)) == NULL ||
86 cbor.read != len ||
87 cbor_isa_array(item) == false ||
88 cbor_array_is_definite(item) == false ||
89 cbor_array_size(item) != 15 ||
90 (v = cbor_array_handle(item)) == NULL)
91 goto fail;
92
93 if (unpack_byte(v[0], &p->uv) < 0 ||
94 unpack_byte(v[1], &p->up) < 0 ||
95 unpack_byte(v[2], &p->opt) < 0 ||
96 unpack_byte(v[3], &p->type) < 0 ||
97 unpack_byte(v[4], &p->cred_count) < 0 ||
98 unpack_int(v[5], &p->ext) < 0 ||
99 unpack_int(v[6], &p->seed) < 0 ||
100 unpack_string(v[7], p->rp_id) < 0 ||
101 unpack_string(v[8], p->pin) < 0 ||
102 unpack_blob(v[9], &p->wire_data) < 0 ||
103 unpack_blob(v[10], &p->rs256) < 0 ||
104 unpack_blob(v[11], &p->es256) < 0 ||
105 unpack_blob(v[12], &p->eddsa) < 0 ||
106 unpack_blob(v[13], &p->cred) < 0 ||
107 unpack_blob(v[14], &p->cdh) < 0)
108 goto fail;
109
110 ok = 0;
111 fail:
112 if (ok < 0) {
113 free(p);
114 p = NULL;
115 }
116
117 if (item)
118 cbor_decref(&item);
119
120 return p;
121 }
122
123 size_t
124 pack(uint8_t *ptr, size_t len, const struct param *p)
125 {
126 cbor_item_t *argv[15], *array = NULL;
127 size_t cbor_alloc_len, cbor_len = 0;
128 unsigned char *cbor = NULL;
129
130 memset(argv, 0, sizeof(argv));
131
132 if ((array = cbor_new_definite_array(15)) == NULL ||
133 (argv[0] = pack_byte(p->uv)) == NULL ||
134 (argv[1] = pack_byte(p->up)) == NULL ||
135 (argv[2] = pack_byte(p->opt)) == NULL ||
136 (argv[3] = pack_byte(p->type)) == NULL ||
137 (argv[4] = pack_byte(p->cred_count)) == NULL ||
138 (argv[5] = pack_int(p->ext)) == NULL ||
139 (argv[6] = pack_int(p->seed)) == NULL ||
140 (argv[7] = pack_string(p->rp_id)) == NULL ||
141 (argv[8] = pack_string(p->pin)) == NULL ||
142 (argv[9] = pack_blob(&p->wire_data)) == NULL ||
143 (argv[10] = pack_blob(&p->rs256)) == NULL ||
144 (argv[11] = pack_blob(&p->es256)) == NULL ||
145 (argv[12] = pack_blob(&p->eddsa)) == NULL ||
146 (argv[13] = pack_blob(&p->cred)) == NULL ||
147 (argv[14] = pack_blob(&p->cdh)) == NULL)
148 goto fail;
149
150 for (size_t i = 0; i < 15; i++)
151 if (cbor_array_push(array, argv[i]) == false)
152 goto fail;
153
154 if ((cbor_len = cbor_serialize_alloc(array, &cbor,
155 &cbor_alloc_len)) == 0 || cbor_len > len) {
156 cbor_len = 0;
157 goto fail;
158 }
159
160 memcpy(ptr, cbor, cbor_len);
161 fail:
162 for (size_t i = 0; i < 15; i++)
163 if (argv[i])
164 cbor_decref(&argv[i]);
165
166 if (array)
167 cbor_decref(&array);
168
169 free(cbor);
170
171 return cbor_len;
172 }
173
174 size_t
175 pack_dummy(uint8_t *ptr, size_t len)
176 {
177 struct param dummy;
178 uint8_t blob[MAXCORPUS];
179 size_t blob_len;
180
181 memset(&dummy, 0, sizeof(dummy));
182
183 dummy.type = 1; /* rsa */
184 dummy.ext = FIDO_EXT_HMAC_SECRET;
185
186 strlcpy(dummy.pin, dummy_pin, sizeof(dummy.pin));
187 strlcpy(dummy.rp_id, dummy_rp_id, sizeof(dummy.rp_id));
188
189 dummy.cred.len = sizeof(dummy_cdh); /* XXX */
190 dummy.cdh.len = sizeof(dummy_cdh);
191 dummy.es256.len = sizeof(dummy_es256);
192 dummy.rs256.len = sizeof(dummy_rs256);
193 dummy.eddsa.len = sizeof(dummy_eddsa);
194 dummy.wire_data.len = sizeof(dummy_wire_data_fido);
195
196 memcpy(&dummy.cred.body, &dummy_cdh, dummy.cred.len); /* XXX */
197 memcpy(&dummy.cdh.body, &dummy_cdh, dummy.cdh.len);
198 memcpy(&dummy.wire_data.body, &dummy_wire_data_fido,
199 dummy.wire_data.len);
200 memcpy(&dummy.es256.body, &dummy_es256, dummy.es256.len);
201 memcpy(&dummy.rs256.body, &dummy_rs256, dummy.rs256.len);
202 memcpy(&dummy.eddsa.body, &dummy_eddsa, dummy.eddsa.len);
203
204 assert((blob_len = pack(blob, sizeof(blob), &dummy)) != 0);
205
206 if (blob_len > len) {
207 memcpy(ptr, blob, len);
208 return len;
209 }
210
211 memcpy(ptr, blob, blob_len);
212
213 return blob_len;
214 }
215
216 static void
217 get_assert(fido_assert_t *assert, uint8_t opt, const struct blob *cdh,
218 const char *rp_id, int ext, uint8_t up, uint8_t uv, const char *pin,
219 uint8_t cred_count, const struct blob *cred)
220 {
221 fido_dev_t *dev;
222
223 if ((dev = open_dev(opt & OPT_NFC)) == NULL)
224 return;
225 if (opt & OPT_FORCE_U2F)
226 fido_dev_force_u2f(dev);
227 if (ext & FIDO_EXT_HMAC_SECRET)
228 fido_assert_set_extensions(assert, FIDO_EXT_HMAC_SECRET);
229 if (ext & FIDO_EXT_CRED_BLOB)
230 fido_assert_set_extensions(assert, FIDO_EXT_CRED_BLOB);
231 if (ext & FIDO_EXT_LARGEBLOB_KEY)
232 fido_assert_set_extensions(assert, FIDO_EXT_LARGEBLOB_KEY);
233 if (ext & FIDO_EXT_PAYMENT)
234 fido_assert_set_extensions(assert, FIDO_EXT_PAYMENT);
235 if (up & 1)
236 fido_assert_set_up(assert, FIDO_OPT_TRUE);
237 else if (opt & OPT_FORCE_U2F)
238 fido_assert_set_up(assert, FIDO_OPT_FALSE);
239 if (uv & 1)
240 fido_assert_set_uv(assert, FIDO_OPT_TRUE);
241
242 for (uint8_t i = 0; i < cred_count; i++)
243 fido_assert_allow_cred(assert, cred->body, cred->len);
244
245 fido_assert_set_clientdata_hash(assert, cdh->body, cdh->len);
246 fido_assert_set_rp(assert, rp_id);
247 /* XXX reuse cred as hmac salt */
248 fido_assert_set_hmac_salt(assert, cred->body, cred->len);
249
250 /* repeat memory operations to trigger reallocation paths */
251 fido_assert_set_clientdata_hash(assert, cdh->body, cdh->len);
252 fido_assert_set_rp(assert, rp_id);
253 fido_assert_set_hmac_salt(assert, cred->body, cred->len);
254
255 if (opt & OPT_FORCE_U2F || strlen(pin) == 0)
256 pin = NULL;
257
258 if (opt & OPT_PUAT) {
259 /* the actual PUAT permission is not relevant for libfido2 */
260 fido_dev_get_puat(dev, FIDO_PUAT_GETASSERT, rp_id, pin);
261 }
262
263 fido_dev_get_assert(dev, assert, pin);
264
265 fido_dev_cancel(dev);
266 fido_dev_close(dev);
267 fido_dev_free(&dev);
268 }
269
270 static void
271 verify_assert(int type, const unsigned char *cdh_ptr, size_t cdh_len,
272 const char *rp_id, const unsigned char *authdata_ptr, size_t authdata_len,
273 const unsigned char *sig_ptr, size_t sig_len, uint8_t up, uint8_t uv,
274 int ext, void *pk)
275 {
276 fido_assert_t *assert = NULL;
277 int r;
278
279 if ((assert = fido_assert_new()) == NULL)
280 return;
281
282 fido_assert_set_clientdata_hash(assert, cdh_ptr, cdh_len);
283 fido_assert_set_rp(assert, rp_id);
284 fido_assert_set_count(assert, 1);
285
286 if (fido_assert_set_authdata(assert, 0, authdata_ptr,
287 authdata_len) != FIDO_OK) {
288 fido_assert_set_authdata_raw(assert, 0, authdata_ptr,
289 authdata_len);
290 }
291
292 if (up & 1)
293 fido_assert_set_up(assert, FIDO_OPT_TRUE);
294 if (uv & 1)
295 fido_assert_set_uv(assert, FIDO_OPT_TRUE);
296
297 fido_assert_set_extensions(assert, ext);
298 fido_assert_set_sig(assert, 0, sig_ptr, sig_len);
299
300 /* repeat memory operations to trigger reallocation paths */
301 if (fido_assert_set_authdata(assert, 0, authdata_ptr,
302 authdata_len) != FIDO_OK) {
303 fido_assert_set_authdata_raw(assert, 0, authdata_ptr,
304 authdata_len);
305 }
306 fido_assert_set_sig(assert, 0, sig_ptr, sig_len);
307
308 r = fido_assert_verify(assert, 0, type, pk);
309 consume(&r, sizeof(r));
310
311 fido_assert_free(&assert);
312 }
313
314 /*
315 * Do a dummy conversion to exercise es256_pk_from_EVP_PKEY().
316 */
317 static void
318 es256_convert(const es256_pk_t *k)
319 {
320 EVP_PKEY *pkey = NULL;
321 es256_pk_t *pk = NULL;
322 int r;
323
324 if ((pkey = es256_pk_to_EVP_PKEY(k)) == NULL ||
325 (pk = es256_pk_new()) == NULL)
326 goto out;
327
328 r = es256_pk_from_EVP_PKEY(pk, pkey);
329 consume(&r, sizeof(r));
330 out:
331 es256_pk_free(&pk);
332 EVP_PKEY_free(pkey);
333 }
334
335 /*
336 * Do a dummy conversion to exercise es384_pk_from_EVP_PKEY().
337 */
338 static void
339 es384_convert(const es384_pk_t *k)
340 {
341 EVP_PKEY *pkey = NULL;
342 es384_pk_t *pk = NULL;
343 int r;
344
345 if ((pkey = es384_pk_to_EVP_PKEY(k)) == NULL ||
346 (pk = es384_pk_new()) == NULL)
347 goto out;
348
349 r = es384_pk_from_EVP_PKEY(pk, pkey);
350 consume(&r, sizeof(r));
351 out:
352 es384_pk_free(&pk);
353 EVP_PKEY_free(pkey);
354 }
355
356 /*
357 * Do a dummy conversion to exercise rs256_pk_from_EVP_PKEY().
358 */
359 static void
360 rs256_convert(const rs256_pk_t *k)
361 {
362 EVP_PKEY *pkey = NULL;
363 rs256_pk_t *pk = NULL;
364 int r;
365
366 if ((pkey = rs256_pk_to_EVP_PKEY(k)) == NULL ||
367 (pk = rs256_pk_new()) == NULL)
368 goto out;
369
370 r = rs256_pk_from_EVP_PKEY(pk, pkey);
371 consume(&r, sizeof(r));
372 out:
373 rs256_pk_free(&pk);
374 EVP_PKEY_free(pkey);
375 }
376
377 /*
378 * Do a dummy conversion to exercise eddsa_pk_from_EVP_PKEY().
379 */
380 static void
381 eddsa_convert(const eddsa_pk_t *k)
382 {
383 EVP_PKEY *pkey = NULL;
384 eddsa_pk_t *pk = NULL;
385 int r;
386
387 if ((pkey = eddsa_pk_to_EVP_PKEY(k)) == NULL ||
388 (pk = eddsa_pk_new()) == NULL)
389 goto out;
390
391 r = eddsa_pk_from_EVP_PKEY(pk, pkey);
392 consume(&r, sizeof(r));
393 out:
394 if (pk)
395 eddsa_pk_free(&pk);
396 if (pkey)
397 EVP_PKEY_free(pkey);
398 }
399
400 void
401 test(const struct param *p)
402 {
403 fido_assert_t *assert = NULL;
404 es256_pk_t *es256_pk = NULL;
405 es384_pk_t *es384_pk = NULL;
406 rs256_pk_t *rs256_pk = NULL;
407 eddsa_pk_t *eddsa_pk = NULL;
408 uint8_t flags;
409 uint32_t sigcount;
410 int cose_alg = 0;
411 void *pk;
412
413 prng_init((unsigned int)p->seed);
414 fuzz_clock_reset();
415 fido_init(FIDO_DEBUG);
416 fido_set_log_handler(consume_str);
417
418 switch (p->type & 3) {
419 case 0:
420 cose_alg = COSE_ES256;
421
422 if ((es256_pk = es256_pk_new()) == NULL)
423 return;
424
425 es256_pk_from_ptr(es256_pk, p->es256.body, p->es256.len);
426 pk = es256_pk;
427
428 es256_convert(pk);
429
430 break;
431 case 1:
432 cose_alg = COSE_RS256;
433
434 if ((rs256_pk = rs256_pk_new()) == NULL)
435 return;
436
437 rs256_pk_from_ptr(rs256_pk, p->rs256.body, p->rs256.len);
438 pk = rs256_pk;
439
440 rs256_convert(pk);
441
442 break;
443 case 2:
444 cose_alg = COSE_ES384;
445
446 if ((es384_pk = es384_pk_new()) == NULL)
447 return;
448
449 /* XXX reuse p->es256 as es384 */
450 es384_pk_from_ptr(es384_pk, p->es256.body, p->es256.len);
451 pk = es384_pk;
452
453 es384_convert(pk);
454
455 break;
456 default:
457 cose_alg = COSE_EDDSA;
458
459 if ((eddsa_pk = eddsa_pk_new()) == NULL)
460 return;
461
462 eddsa_pk_from_ptr(eddsa_pk, p->eddsa.body, p->eddsa.len);
463 pk = eddsa_pk;
464
465 eddsa_convert(pk);
466
467 break;
468 }
469
470 if ((assert = fido_assert_new()) == NULL)
471 goto out;
472
473 set_wire_data(p->wire_data.body, p->wire_data.len);
474
475 get_assert(assert, p->opt, &p->cdh, p->rp_id, p->ext, p->up, p->uv,
476 p->pin, p->cred_count, &p->cred);
477
478 /* XXX +1 on purpose */
479 for (size_t i = 0; i <= fido_assert_count(assert); i++) {
480 verify_assert(cose_alg,
481 fido_assert_clientdata_hash_ptr(assert),
482 fido_assert_clientdata_hash_len(assert),
483 fido_assert_rp_id(assert),
484 fido_assert_authdata_ptr(assert, i),
485 fido_assert_authdata_len(assert, i),
486 fido_assert_sig_ptr(assert, i),
487 fido_assert_sig_len(assert, i), p->up, p->uv, p->ext, pk);
488 consume(fido_assert_authdata_raw_ptr(assert, i),
489 fido_assert_authdata_raw_len(assert, i));
490 consume(fido_assert_id_ptr(assert, i),
491 fido_assert_id_len(assert, i));
492 consume(fido_assert_user_id_ptr(assert, i),
493 fido_assert_user_id_len(assert, i));
494 consume(fido_assert_hmac_secret_ptr(assert, i),
495 fido_assert_hmac_secret_len(assert, i));
496 consume_str(fido_assert_user_icon(assert, i));
497 consume_str(fido_assert_user_name(assert, i));
498 consume_str(fido_assert_user_display_name(assert, i));
499 consume(fido_assert_blob_ptr(assert, i),
500 fido_assert_blob_len(assert, i));
501 consume(fido_assert_largeblob_key_ptr(assert, i),
502 fido_assert_largeblob_key_len(assert, i));
503 flags = fido_assert_flags(assert, i);
504 consume(&flags, sizeof(flags));
505 sigcount = fido_assert_sigcount(assert, i);
506 consume(&sigcount, sizeof(sigcount));
507 }
508
509 out:
510 es256_pk_free(&es256_pk);
511 es384_pk_free(&es384_pk);
512 rs256_pk_free(&rs256_pk);
513 eddsa_pk_free(&eddsa_pk);
514
515 fido_assert_free(&assert);
516 }
517
518 void
519 mutate(struct param *p, unsigned int seed, unsigned int flags) NO_MSAN
520 {
521 if (flags & MUTATE_SEED)
522 p->seed = (int)seed;
523
524 if (flags & MUTATE_PARAM) {
525 mutate_byte(&p->uv);
526 mutate_byte(&p->up);
527 mutate_byte(&p->opt);
528 mutate_byte(&p->type);
529 mutate_byte(&p->cred_count);
530 mutate_int(&p->ext);
531 mutate_blob(&p->rs256);
532 mutate_blob(&p->es256);
533 mutate_blob(&p->eddsa);
534 mutate_blob(&p->cred);
535 mutate_blob(&p->cdh);
536 mutate_string(p->rp_id);
537 mutate_string(p->pin);
538
539 p->opt &= OPT_MASK;
540 }
541
542 if (flags & MUTATE_WIREDATA) {
543 if (p->opt & OPT_FORCE_U2F) {
544 p->wire_data.len = sizeof(dummy_wire_data_u2f);
545 memcpy(&p->wire_data.body, &dummy_wire_data_u2f,
546 p->wire_data.len);
547 } else {
548 p->wire_data.len = sizeof(dummy_wire_data_fido);
549 memcpy(&p->wire_data.body, &dummy_wire_data_fido,
550 p->wire_data.len);
551 }
552 mutate_blob(&p->wire_data);
553 }
554 }