Debian Codegraph @

fuzz/fuzz_credman.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_ARR_LEN 9
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 rp_id[MAXSTR];
36 uint8_t opt;
37 int seed;
38 struct blob cred_id;
39 struct blob del_wire_data;
40 struct blob meta_wire_data;
41 struct blob rk_wire_data;
42 struct blob rp_wire_data;
43 };
44
45 /*
46 * Collection of HID reports from an authenticator issued with a FIDO2
47 * 'getCredsMetadata' credential management command.
48 */
49 static const uint8_t dummy_meta_wire_data[] = {
50 WIREDATA_CTAP_INIT,
51 WIREDATA_CTAP_CBOR_INFO,
52 WIREDATA_CTAP_CBOR_AUTHKEY,
53 WIREDATA_CTAP_CBOR_PINTOKEN,
54 WIREDATA_CTAP_CBOR_CREDMAN_META,
55 };
56
57 /*
58 * Collection of HID reports from an authenticator issued with a FIDO2
59 * 'enumerateRPsBegin' credential management command.
60 */
61 static const uint8_t dummy_rp_wire_data[] = {
62 WIREDATA_CTAP_INIT,
63 WIREDATA_CTAP_CBOR_INFO,
64 WIREDATA_CTAP_CBOR_AUTHKEY,
65 WIREDATA_CTAP_CBOR_PINTOKEN,
66 WIREDATA_CTAP_CBOR_CREDMAN_RPLIST,
67 };
68
69 /*
70 * Collection of HID reports from an authenticator issued with a FIDO2
71 * 'enumerateCredentialsBegin' credential management command.
72 */
73 static const uint8_t dummy_rk_wire_data[] = {
74 WIREDATA_CTAP_INIT,
75 WIREDATA_CTAP_CBOR_INFO,
76 WIREDATA_CTAP_CBOR_AUTHKEY,
77 WIREDATA_CTAP_CBOR_PINTOKEN,
78 WIREDATA_CTAP_CBOR_CREDMAN_RKLIST,
79 };
80
81 /*
82 * Collection of HID reports from an authenticator issued with a FIDO2
83 * 'deleteCredential' credential management command.
84 */
85 static const uint8_t dummy_del_wire_data[] = {
86 WIREDATA_CTAP_INIT,
87 WIREDATA_CTAP_CBOR_INFO,
88 WIREDATA_CTAP_CBOR_AUTHKEY,
89 WIREDATA_CTAP_CBOR_PINTOKEN,
90 WIREDATA_CTAP_CBOR_STATUS,
91 };
92
93 struct param *
94 unpack(const uint8_t *ptr, size_t len)
95 {
96 cbor_item_t *item = NULL, **v;
97 struct cbor_load_result cbor;
98 struct param *p;
99 int ok = -1;
100
101 if ((p = calloc(1, sizeof(*p))) == NULL ||
102 (item = cbor_load(ptr, len, &cbor)) == NULL ||
103 cbor.read != len ||
104 cbor_isa_array(item) == false ||
105 cbor_array_is_definite(item) == false ||
106 cbor_array_size(item) != PACK_ARR_LEN ||
107 (v = cbor_array_handle(item)) == NULL)
108 goto fail;
109
110 if (unpack_int(v[0], &p->seed) < 0 ||
111 unpack_string(v[1], p->pin) < 0 ||
112 unpack_string(v[2], p->rp_id) < 0 ||
113 unpack_blob(v[3], &p->cred_id) < 0 ||
114 unpack_blob(v[4], &p->meta_wire_data) < 0 ||
115 unpack_blob(v[5], &p->rp_wire_data) < 0 ||
116 unpack_blob(v[6], &p->rk_wire_data) < 0 ||
117 unpack_blob(v[7], &p->del_wire_data) < 0 ||
118 unpack_byte(v[8], &p->opt) < 0)
119 goto fail;
120
121 ok = 0;
122 fail:
123 if (ok < 0) {
124 free(p);
125 p = NULL;
126 }
127
128 if (item)
129 cbor_decref(&item);
130
131 return p;
132 }
133
134 size_t
135 pack(uint8_t *ptr, size_t len, const struct param *p)
136 {
137 cbor_item_t *argv[PACK_ARR_LEN], *array = NULL;
138 size_t cbor_alloc_len, cbor_len = 0;
139 unsigned char *cbor = NULL;
140
141 memset(argv, 0, sizeof(argv));
142
143 if ((array = cbor_new_definite_array(PACK_ARR_LEN)) == NULL ||
144 (argv[0] = pack_int(p->seed)) == NULL ||
145 (argv[1] = pack_string(p->pin)) == NULL ||
146 (argv[2] = pack_string(p->rp_id)) == NULL ||
147 (argv[3] = pack_blob(&p->cred_id)) == NULL ||
148 (argv[4] = pack_blob(&p->meta_wire_data)) == NULL ||
149 (argv[5] = pack_blob(&p->rp_wire_data)) == NULL ||
150 (argv[6] = pack_blob(&p->rk_wire_data)) == NULL ||
151 (argv[7] = pack_blob(&p->del_wire_data)) == NULL ||
152 (argv[8] = pack_byte(p->opt)) == NULL)
153 goto fail;
154
155 for (size_t i = 0; i < PACK_ARR_LEN; i++)
156 if (cbor_array_push(array, argv[i]) == false)
157 goto fail;
158
159 if ((cbor_len = cbor_serialize_alloc(array, &cbor,
160 &cbor_alloc_len)) == 0 || cbor_len > len) {
161 cbor_len = 0;
162 goto fail;
163 }
164
165 memcpy(ptr, cbor, cbor_len);
166 fail:
167 for (size_t i = 0; i < PACK_ARR_LEN; i++)
168 if (argv[i])
169 cbor_decref(&argv[i]);
170
171 if (array)
172 cbor_decref(&array);
173
174 free(cbor);
175
176 return cbor_len;
177 }
178
179 size_t
180 pack_dummy(uint8_t *ptr, size_t len)
181 {
182 struct param dummy;
183 uint8_t blob[MAXCORPUS];
184 size_t blob_len;
185
186 memset(&dummy, 0, sizeof(dummy));
187
188 strlcpy(dummy.pin, dummy_pin, sizeof(dummy.pin));
189 strlcpy(dummy.rp_id, dummy_rp_id, sizeof(dummy.rp_id));
190
191 dummy.meta_wire_data.len = sizeof(dummy_meta_wire_data);
192 dummy.rp_wire_data.len = sizeof(dummy_rp_wire_data);
193 dummy.rk_wire_data.len = sizeof(dummy_rk_wire_data);
194 dummy.del_wire_data.len = sizeof(dummy_del_wire_data);
195 dummy.cred_id.len = sizeof(dummy_cred_id);
196
197 memcpy(&dummy.meta_wire_data.body, &dummy_meta_wire_data,
198 dummy.meta_wire_data.len);
199 memcpy(&dummy.rp_wire_data.body, &dummy_rp_wire_data,
200 dummy.rp_wire_data.len);
201 memcpy(&dummy.rk_wire_data.body, &dummy_rk_wire_data,
202 dummy.rk_wire_data.len);
203 memcpy(&dummy.del_wire_data.body, &dummy_del_wire_data,
204 dummy.del_wire_data.len);
205 memcpy(&dummy.cred_id.body, &dummy_cred_id, dummy.cred_id.len);
206
207 assert((blob_len = pack(blob, sizeof(blob), &dummy)) != 0);
208
209 if (blob_len > len) {
210 memcpy(ptr, blob, len);
211 return len;
212 }
213
214 memcpy(ptr, blob, blob_len);
215
216 return blob_len;
217 }
218
219 static const char *
220 maybe_pin(const struct param *p)
221 {
222 return p->opt & OPT_NO_PIN ? NULL : p->pin;
223 }
224
225 static fido_dev_t *
226 prepare_dev(const struct blob *wire_data, const struct param *p)
227 {
228 fido_dev_t *dev;
229 bool x;
230
231 set_wire_data(wire_data->body, wire_data->len);
232
233 if ((dev = open_dev(0)) == NULL)
234 return NULL;
235
236 x = fido_dev_is_fido2(dev);
237 consume(&x, sizeof(x));
238 x = fido_dev_supports_cred_prot(dev);
239 consume(&x, sizeof(x));
240 x = fido_dev_supports_credman(dev);
241 consume(&x, sizeof(x));
242
243 if (p->opt & OPT_PUAT)
244 fido_dev_get_puat(dev, FIDO_PUAT_CREDMAN, NULL, maybe_pin(p));
245
246 return dev;
247 }
248
249 static void
250 get_metadata(const struct param *p)
251 {
252 fido_dev_t *dev;
253 fido_credman_metadata_t *metadata;
254 uint64_t existing;
255 uint64_t remaining;
256
257 if ((dev = prepare_dev(&p->meta_wire_data, p)) == NULL)
258 return;
259
260 if ((metadata = fido_credman_metadata_new()) == NULL) {
261 fido_dev_close(dev);
262 fido_dev_free(&dev);
263 return;
264 }
265
266 fido_credman_get_dev_metadata(dev, metadata, maybe_pin(p));
267
268 existing = fido_credman_rk_existing(metadata);
269 remaining = fido_credman_rk_remaining(metadata);
270 consume(&existing, sizeof(existing));
271 consume(&remaining, sizeof(remaining));
272
273 fido_credman_metadata_free(&metadata);
274 fido_dev_close(dev);
275 fido_dev_free(&dev);
276 }
277
278 static void
279 get_rp_list(const struct param *p)
280 {
281 fido_dev_t *dev;
282 fido_credman_rp_t *rp;
283
284 if ((dev = prepare_dev(&p->rp_wire_data, p)) == NULL)
285 return;
286
287 if ((rp = fido_credman_rp_new()) == NULL) {
288 fido_dev_close(dev);
289 fido_dev_free(&dev);
290 return;
291 }
292
293 fido_credman_get_dev_rp(dev, rp, maybe_pin(p));
294
295 /* +1 on purpose */
296 for (size_t i = 0; i < fido_credman_rp_count(rp) + 1; i++) {
297 consume(fido_credman_rp_id_hash_ptr(rp, i),
298 fido_credman_rp_id_hash_len(rp, i));
299 consume_str(fido_credman_rp_id(rp, i));
300 consume_str(fido_credman_rp_name(rp, i));
301 }
302
303 fido_credman_rp_free(&rp);
304 fido_dev_close(dev);
305 fido_dev_free(&dev);
306 }
307
308 static void
309 get_rk_list(const struct param *p)
310 {
311 fido_dev_t *dev;
312 fido_credman_rk_t *rk;
313 const fido_cred_t *cred;
314 int val;
315
316 if ((dev = prepare_dev(&p->rk_wire_data, p)) == NULL)
317 return;
318
319 if ((rk = fido_credman_rk_new()) == NULL) {
320 fido_dev_close(dev);
321 fido_dev_free(&dev);
322 return;
323 }
324
325 fido_credman_get_dev_rk(dev, p->rp_id, rk, maybe_pin(p));
326
327 /* +1 on purpose */
328 for (size_t i = 0; i < fido_credman_rk_count(rk) + 1; i++) {
329 if ((cred = fido_credman_rk(rk, i)) == NULL) {
330 assert(i >= fido_credman_rk_count(rk));
331 continue;
332 }
333 val = fido_cred_type(cred);
334 consume(&val, sizeof(val));
335 consume(fido_cred_id_ptr(cred), fido_cred_id_len(cred));
336 consume(fido_cred_pubkey_ptr(cred), fido_cred_pubkey_len(cred));
337 consume(fido_cred_user_id_ptr(cred),
338 fido_cred_user_id_len(cred));
339 consume_str(fido_cred_user_name(cred));
340 consume_str(fido_cred_display_name(cred));
341 val = fido_cred_prot(cred);
342 consume(&val, sizeof(val));
343 val = fido_cred_payment(cred);
344 consume(&val, sizeof(val));
345 }
346
347 fido_credman_rk_free(&rk);
348 fido_dev_close(dev);
349 fido_dev_free(&dev);
350 }
351
352 static void
353 del_rk(const struct param *p)
354 {
355 fido_dev_t *dev;
356
357 if ((dev = prepare_dev(&p->del_wire_data, p)) == NULL)
358 return;
359
360 fido_credman_del_dev_rk(dev, p->cred_id.body, p->cred_id.len, maybe_pin(p));
361 fido_dev_close(dev);
362 fido_dev_free(&dev);
363 }
364
365 static void
366 set_rk(const struct param *p)
367 {
368 fido_dev_t *dev = NULL;
369 fido_cred_t *cred = NULL;
370 int r0, r1, r2;
371
372 if ((dev = prepare_dev(&p->del_wire_data, p)) == NULL)
373 return;
374 if ((cred = fido_cred_new()) == NULL)
375 goto out;
376 r0 = fido_cred_set_id(cred, p->cred_id.body, p->cred_id.len);
377 r1 = fido_cred_set_user(cred, p->cred_id.body, p->cred_id.len, p->rp_id,
378 NULL, NULL);
379 r2 = fido_credman_set_dev_rk(dev, cred, maybe_pin(p));
380 consume(&r0, sizeof(r0));
381 consume(&r1, sizeof(r1));
382 consume(&r2, sizeof(r2));
383 out:
384 fido_dev_close(dev);
385 fido_dev_free(&dev);
386 fido_cred_free(&cred);
387 }
388
389 void
390 test(const struct param *p)
391 {
392 prng_init((unsigned int)p->seed);
393 fuzz_clock_reset();
394 fido_init(FIDO_DEBUG);
395 fido_set_log_handler(consume_str);
396
397 get_metadata(p);
398 get_rp_list(p);
399 get_rk_list(p);
400 del_rk(p);
401 set_rk(p);
402 }
403
404 void
405 mutate(struct param *p, unsigned int seed, unsigned int flags) NO_MSAN
406 {
407 if (flags & MUTATE_SEED)
408 p->seed = (int)seed;
409
410 if (flags & MUTATE_PARAM) {
411 mutate_blob(&p->cred_id);
412 mutate_string(p->pin);
413 mutate_string(p->rp_id);
414 mutate_byte(&p->opt);
415
416 p->opt &= OPT_MASK;
417 }
418
419 if (flags & MUTATE_WIREDATA) {
420 mutate_blob(&p->meta_wire_data);
421 mutate_blob(&p->rp_wire_data);
422 mutate_blob(&p->rk_wire_data);
423 mutate_blob(&p->del_wire_data);
424 }
425 }