diff options
Diffstat (limited to 'regress/assert.c')
-rw-r--r-- | regress/assert.c | 511 |
1 files changed, 511 insertions, 0 deletions
diff --git a/regress/assert.c b/regress/assert.c new file mode 100644 index 0000000..ebf0652 --- /dev/null +++ b/regress/assert.c | |||
@@ -0,0 +1,511 @@ | |||
1 | /* | ||
2 | * Copyright (c) 2018 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 <assert.h> | ||
8 | #include <fido.h> | ||
9 | #include <fido/es256.h> | ||
10 | #include <fido/rs256.h> | ||
11 | #include <string.h> | ||
12 | |||
13 | #define FAKE_DEV_HANDLE ((void *)0xdeadbeef) | ||
14 | |||
15 | static const unsigned char es256_pk[64] = { | ||
16 | 0x34, 0xeb, 0x99, 0x77, 0x02, 0x9c, 0x36, 0x38, | ||
17 | 0xbb, 0xc2, 0xae, 0xa0, 0xa0, 0x18, 0xc6, 0x64, | ||
18 | 0xfc, 0xe8, 0x49, 0x92, 0xd7, 0x74, 0x9e, 0x0c, | ||
19 | 0x46, 0x8c, 0x9d, 0xa6, 0xdf, 0x46, 0xf7, 0x84, | ||
20 | 0x60, 0x1e, 0x0f, 0x8b, 0x23, 0x85, 0x4a, 0x9a, | ||
21 | 0xec, 0xc1, 0x08, 0x9f, 0x30, 0xd0, 0x0d, 0xd7, | ||
22 | 0x76, 0x7b, 0x55, 0x48, 0x91, 0x7c, 0x4f, 0x0f, | ||
23 | 0x64, 0x1a, 0x1d, 0xf8, 0xbe, 0x14, 0x90, 0x8a, | ||
24 | }; | ||
25 | |||
26 | static const unsigned char cdh[32] = { | ||
27 | 0xec, 0x8d, 0x8f, 0x78, 0x42, 0x4a, 0x2b, 0xb7, | ||
28 | 0x82, 0x34, 0xaa, 0xca, 0x07, 0xa1, 0xf6, 0x56, | ||
29 | 0x42, 0x1c, 0xb6, 0xf6, 0xb3, 0x00, 0x86, 0x52, | ||
30 | 0x35, 0x2d, 0xa2, 0x62, 0x4a, 0xbe, 0x89, 0x76, | ||
31 | }; | ||
32 | |||
33 | static const unsigned char authdata[39] = { | ||
34 | 0x58, 0x25, 0x49, 0x96, 0x0d, 0xe5, 0x88, 0x0e, | ||
35 | 0x8c, 0x68, 0x74, 0x34, 0x17, 0x0f, 0x64, 0x76, | ||
36 | 0x60, 0x5b, 0x8f, 0xe4, 0xae, 0xb9, 0xa2, 0x86, | ||
37 | 0x32, 0xc7, 0x99, 0x5c, 0xf3, 0xba, 0x83, 0x1d, | ||
38 | 0x97, 0x63, 0x00, 0x00, 0x00, 0x00, 0x03, | ||
39 | }; | ||
40 | |||
41 | static const unsigned char sig[72] = { | ||
42 | 0x30, 0x46, 0x02, 0x21, 0x00, 0xf6, 0xd1, 0xa3, | ||
43 | 0xd5, 0x24, 0x2b, 0xde, 0xee, 0xa0, 0x90, 0x89, | ||
44 | 0xcd, 0xf8, 0x9e, 0xbd, 0x6b, 0x4d, 0x55, 0x79, | ||
45 | 0xe4, 0xc1, 0x42, 0x27, 0xb7, 0x9b, 0x9b, 0xa4, | ||
46 | 0x0a, 0xe2, 0x47, 0x64, 0x0e, 0x02, 0x21, 0x00, | ||
47 | 0xe5, 0xc9, 0xc2, 0x83, 0x47, 0x31, 0xc7, 0x26, | ||
48 | 0xe5, 0x25, 0xb2, 0xb4, 0x39, 0xa7, 0xfc, 0x3d, | ||
49 | 0x70, 0xbe, 0xe9, 0x81, 0x0d, 0x4a, 0x62, 0xa9, | ||
50 | 0xab, 0x4a, 0x91, 0xc0, 0x7d, 0x2d, 0x23, 0x1e, | ||
51 | }; | ||
52 | |||
53 | static void * | ||
54 | dummy_open(const char *path) | ||
55 | { | ||
56 | (void)path; | ||
57 | |||
58 | return (FAKE_DEV_HANDLE); | ||
59 | } | ||
60 | |||
61 | static void | ||
62 | dummy_close(void *handle) | ||
63 | { | ||
64 | assert(handle == FAKE_DEV_HANDLE); | ||
65 | } | ||
66 | |||
67 | static int | ||
68 | dummy_read(void *handle, unsigned char *buf, size_t len, int ms) | ||
69 | { | ||
70 | (void)handle; | ||
71 | (void)buf; | ||
72 | (void)len; | ||
73 | (void)ms; | ||
74 | |||
75 | abort(); | ||
76 | /* NOTREACHED */ | ||
77 | } | ||
78 | |||
79 | static int | ||
80 | dummy_write(void *handle, const unsigned char *buf, size_t len) | ||
81 | { | ||
82 | (void)handle; | ||
83 | (void)buf; | ||
84 | (void)len; | ||
85 | |||
86 | abort(); | ||
87 | /* NOTREACHED */ | ||
88 | } | ||
89 | |||
90 | static fido_assert_t * | ||
91 | alloc_assert(void) | ||
92 | { | ||
93 | fido_assert_t *a; | ||
94 | |||
95 | a = fido_assert_new(); | ||
96 | assert(a != NULL); | ||
97 | |||
98 | return (a); | ||
99 | } | ||
100 | |||
101 | static void | ||
102 | free_assert(fido_assert_t *a) | ||
103 | { | ||
104 | fido_assert_free(&a); | ||
105 | assert(a == NULL); | ||
106 | } | ||
107 | |||
108 | static fido_dev_t * | ||
109 | alloc_dev(void) | ||
110 | { | ||
111 | fido_dev_t *d; | ||
112 | |||
113 | d = fido_dev_new(); | ||
114 | assert(d != NULL); | ||
115 | |||
116 | return (d); | ||
117 | } | ||
118 | |||
119 | static void | ||
120 | free_dev(fido_dev_t *d) | ||
121 | { | ||
122 | fido_dev_free(&d); | ||
123 | assert(d == NULL); | ||
124 | } | ||
125 | |||
126 | static es256_pk_t * | ||
127 | alloc_es256_pk(void) | ||
128 | { | ||
129 | es256_pk_t *pk; | ||
130 | |||
131 | pk = es256_pk_new(); | ||
132 | assert(pk != NULL); | ||
133 | |||
134 | return (pk); | ||
135 | } | ||
136 | |||
137 | static void | ||
138 | free_es256_pk(es256_pk_t *pk) | ||
139 | { | ||
140 | es256_pk_free(&pk); | ||
141 | assert(pk == NULL); | ||
142 | } | ||
143 | |||
144 | static rs256_pk_t * | ||
145 | alloc_rs256_pk(void) | ||
146 | { | ||
147 | rs256_pk_t *pk; | ||
148 | |||
149 | pk = rs256_pk_new(); | ||
150 | assert(pk != NULL); | ||
151 | |||
152 | return (pk); | ||
153 | } | ||
154 | |||
155 | static void | ||
156 | free_rs256_pk(rs256_pk_t *pk) | ||
157 | { | ||
158 | rs256_pk_free(&pk); | ||
159 | assert(pk == NULL); | ||
160 | } | ||
161 | |||
162 | static void | ||
163 | empty_assert(fido_dev_t *d, fido_assert_t *a, int idx) | ||
164 | { | ||
165 | es256_pk_t *es256; | ||
166 | rs256_pk_t *rs256; | ||
167 | |||
168 | assert(fido_assert_flags(a, idx) == 0); | ||
169 | assert(fido_assert_authdata_len(a, idx) == 0); | ||
170 | assert(fido_assert_authdata_ptr(a, idx) == NULL); | ||
171 | assert(fido_assert_clientdata_hash_len(a) == 0); | ||
172 | assert(fido_assert_clientdata_hash_ptr(a) == NULL); | ||
173 | assert(fido_assert_id_len(a, idx) == 0); | ||
174 | assert(fido_assert_id_ptr(a, idx) == NULL); | ||
175 | assert(fido_assert_rp_id(a) == NULL); | ||
176 | assert(fido_assert_sig_len(a, idx) == 0); | ||
177 | assert(fido_assert_sig_ptr(a, idx) == NULL); | ||
178 | assert(fido_assert_user_display_name(a, idx) == NULL); | ||
179 | assert(fido_assert_user_icon(a, idx) == NULL); | ||
180 | assert(fido_assert_user_id_len(a, idx) == 0); | ||
181 | assert(fido_assert_user_id_ptr(a, idx) == NULL); | ||
182 | assert(fido_assert_user_name(a, idx) == NULL); | ||
183 | |||
184 | es256 = alloc_es256_pk(); | ||
185 | rs256 = alloc_rs256_pk(); | ||
186 | |||
187 | fido_dev_force_u2f(d); | ||
188 | assert(fido_dev_get_assert(d, a, NULL) == FIDO_ERR_INVALID_ARGUMENT); | ||
189 | assert(fido_dev_get_assert(d, a, "") == FIDO_ERR_INVALID_ARGUMENT); | ||
190 | assert(fido_assert_verify(a, COSE_ES256, idx, | ||
191 | NULL) == FIDO_ERR_INVALID_ARGUMENT); | ||
192 | assert(fido_assert_verify(a, COSE_ES256, idx, | ||
193 | es256) == FIDO_ERR_INVALID_ARGUMENT); | ||
194 | assert(fido_assert_verify(a, COSE_RS256, idx, | ||
195 | rs256) == FIDO_ERR_INVALID_ARGUMENT); | ||
196 | |||
197 | fido_dev_force_fido2(d); | ||
198 | assert(fido_dev_get_assert(d, a, NULL) == FIDO_ERR_INVALID_ARGUMENT); | ||
199 | assert(fido_dev_get_assert(d, a, "") == FIDO_ERR_INVALID_ARGUMENT); | ||
200 | assert(fido_assert_verify(a, COSE_ES256, idx, | ||
201 | NULL) == FIDO_ERR_INVALID_ARGUMENT); | ||
202 | assert(fido_assert_verify(a, COSE_ES256, idx, | ||
203 | es256) == FIDO_ERR_INVALID_ARGUMENT); | ||
204 | assert(fido_assert_verify(a, COSE_RS256, idx, | ||
205 | rs256) == FIDO_ERR_INVALID_ARGUMENT); | ||
206 | |||
207 | free_es256_pk(es256); | ||
208 | free_rs256_pk(rs256); | ||
209 | } | ||
210 | |||
211 | static void | ||
212 | empty_assert_tests(void) | ||
213 | { | ||
214 | fido_assert_t *a; | ||
215 | fido_dev_t *d; | ||
216 | fido_dev_io_t io_f; | ||
217 | int i; | ||
218 | |||
219 | a = alloc_assert(); | ||
220 | d = alloc_dev(); | ||
221 | io_f.open = dummy_open; | ||
222 | io_f.close = dummy_close; | ||
223 | io_f.read = dummy_read; | ||
224 | io_f.write = dummy_write; | ||
225 | assert(fido_dev_set_io_functions(d, &io_f) == FIDO_OK); | ||
226 | |||
227 | empty_assert(d, a, 0); | ||
228 | assert(fido_assert_count(a) == 0); | ||
229 | assert(fido_assert_set_count(a, 4) == FIDO_OK); | ||
230 | assert(fido_assert_count(a) == 4); | ||
231 | for (i = 0; i < 4; i++) { | ||
232 | empty_assert(d, a, i); | ||
233 | } | ||
234 | empty_assert(d, a, 10); | ||
235 | free_assert(a); | ||
236 | free_dev(d); | ||
237 | } | ||
238 | |||
239 | static void | ||
240 | valid_assert(void) | ||
241 | { | ||
242 | fido_assert_t *a; | ||
243 | es256_pk_t *pk; | ||
244 | |||
245 | a = alloc_assert(); | ||
246 | pk = alloc_es256_pk(); | ||
247 | assert(es256_pk_from_ptr(pk, es256_pk, sizeof(es256_pk)) == FIDO_OK); | ||
248 | assert(fido_assert_set_clientdata_hash(a, cdh, sizeof(cdh)) == FIDO_OK); | ||
249 | assert(fido_assert_set_rp(a, "localhost") == FIDO_OK); | ||
250 | assert(fido_assert_set_count(a, 1) == FIDO_OK); | ||
251 | assert(fido_assert_set_authdata(a, 0, authdata, | ||
252 | sizeof(authdata)) == FIDO_OK); | ||
253 | assert(fido_assert_set_up(a, FIDO_OPT_FALSE) == FIDO_OK); | ||
254 | assert(fido_assert_set_uv(a, FIDO_OPT_FALSE) == FIDO_OK); | ||
255 | assert(fido_assert_set_sig(a, 0, sig, sizeof(sig)) == FIDO_OK); | ||
256 | assert(fido_assert_verify(a, 0, COSE_ES256, pk) == FIDO_OK); | ||
257 | free_assert(a); | ||
258 | free_es256_pk(pk); | ||
259 | } | ||
260 | |||
261 | static void | ||
262 | no_cdh(void) | ||
263 | { | ||
264 | fido_assert_t *a; | ||
265 | es256_pk_t *pk; | ||
266 | |||
267 | a = alloc_assert(); | ||
268 | pk = alloc_es256_pk(); | ||
269 | assert(es256_pk_from_ptr(pk, es256_pk, sizeof(es256_pk)) == FIDO_OK); | ||
270 | assert(fido_assert_set_rp(a, "localhost") == FIDO_OK); | ||
271 | assert(fido_assert_set_count(a, 1) == FIDO_OK); | ||
272 | assert(fido_assert_set_authdata(a, 0, authdata, | ||
273 | sizeof(authdata)) == FIDO_OK); | ||
274 | assert(fido_assert_set_up(a, FIDO_OPT_FALSE) == FIDO_OK); | ||
275 | assert(fido_assert_set_uv(a, FIDO_OPT_FALSE) == FIDO_OK); | ||
276 | assert(fido_assert_set_sig(a, 0, sig, sizeof(sig)) == FIDO_OK); | ||
277 | assert(fido_assert_verify(a, 0, COSE_ES256, | ||
278 | pk) == FIDO_ERR_INVALID_ARGUMENT); | ||
279 | free_assert(a); | ||
280 | free_es256_pk(pk); | ||
281 | } | ||
282 | |||
283 | static void | ||
284 | no_rp(void) | ||
285 | { | ||
286 | fido_assert_t *a; | ||
287 | es256_pk_t *pk; | ||
288 | |||
289 | a = alloc_assert(); | ||
290 | pk = alloc_es256_pk(); | ||
291 | assert(es256_pk_from_ptr(pk, es256_pk, sizeof(es256_pk)) == FIDO_OK); | ||
292 | assert(fido_assert_set_clientdata_hash(a, cdh, sizeof(cdh)) == FIDO_OK); | ||
293 | assert(fido_assert_set_count(a, 1) == FIDO_OK); | ||
294 | assert(fido_assert_set_authdata(a, 0, authdata, | ||
295 | sizeof(authdata)) == FIDO_OK); | ||
296 | assert(fido_assert_set_up(a, FIDO_OPT_FALSE) == FIDO_OK); | ||
297 | assert(fido_assert_set_uv(a, FIDO_OPT_FALSE) == FIDO_OK); | ||
298 | assert(fido_assert_set_sig(a, 0, sig, sizeof(sig)) == FIDO_OK); | ||
299 | assert(fido_assert_verify(a, 0, COSE_ES256, | ||
300 | pk) == FIDO_ERR_INVALID_ARGUMENT); | ||
301 | free_assert(a); | ||
302 | free_es256_pk(pk); | ||
303 | } | ||
304 | |||
305 | static void | ||
306 | no_authdata(void) | ||
307 | { | ||
308 | fido_assert_t *a; | ||
309 | es256_pk_t *pk; | ||
310 | |||
311 | a = alloc_assert(); | ||
312 | pk = alloc_es256_pk(); | ||
313 | assert(es256_pk_from_ptr(pk, es256_pk, sizeof(es256_pk)) == FIDO_OK); | ||
314 | assert(fido_assert_set_clientdata_hash(a, cdh, sizeof(cdh)) == FIDO_OK); | ||
315 | assert(fido_assert_set_rp(a, "localhost") == FIDO_OK); | ||
316 | assert(fido_assert_set_count(a, 1) == FIDO_OK); | ||
317 | assert(fido_assert_set_up(a, FIDO_OPT_FALSE) == FIDO_OK); | ||
318 | assert(fido_assert_set_uv(a, FIDO_OPT_FALSE) == FIDO_OK); | ||
319 | assert(fido_assert_set_sig(a, 0, sig, sizeof(sig)) == FIDO_OK); | ||
320 | assert(fido_assert_verify(a, 0, COSE_ES256, | ||
321 | pk) == FIDO_ERR_INVALID_ARGUMENT); | ||
322 | free_assert(a); | ||
323 | free_es256_pk(pk); | ||
324 | } | ||
325 | |||
326 | static void | ||
327 | no_sig(void) | ||
328 | { | ||
329 | fido_assert_t *a; | ||
330 | es256_pk_t *pk; | ||
331 | |||
332 | a = alloc_assert(); | ||
333 | pk = alloc_es256_pk(); | ||
334 | assert(es256_pk_from_ptr(pk, es256_pk, sizeof(es256_pk)) == FIDO_OK); | ||
335 | assert(fido_assert_set_clientdata_hash(a, cdh, sizeof(cdh)) == FIDO_OK); | ||
336 | assert(fido_assert_set_rp(a, "localhost") == FIDO_OK); | ||
337 | assert(fido_assert_set_count(a, 1) == FIDO_OK); | ||
338 | assert(fido_assert_set_authdata(a, 0, authdata, | ||
339 | sizeof(authdata)) == FIDO_OK); | ||
340 | assert(fido_assert_set_up(a, FIDO_OPT_FALSE) == FIDO_OK); | ||
341 | assert(fido_assert_set_uv(a, FIDO_OPT_FALSE) == FIDO_OK); | ||
342 | assert(fido_assert_verify(a, 0, COSE_ES256, | ||
343 | pk) == FIDO_ERR_INVALID_ARGUMENT); | ||
344 | free_assert(a); | ||
345 | free_es256_pk(pk); | ||
346 | } | ||
347 | |||
348 | static void | ||
349 | junk_cdh(void) | ||
350 | { | ||
351 | fido_assert_t *a; | ||
352 | es256_pk_t *pk; | ||
353 | unsigned char *junk; | ||
354 | |||
355 | junk = malloc(sizeof(cdh)); | ||
356 | assert(junk != NULL); | ||
357 | memcpy(junk, cdh, sizeof(cdh)); | ||
358 | junk[0] = ~junk[0]; | ||
359 | |||
360 | a = alloc_assert(); | ||
361 | pk = alloc_es256_pk(); | ||
362 | assert(es256_pk_from_ptr(pk, es256_pk, sizeof(es256_pk)) == FIDO_OK); | ||
363 | assert(fido_assert_set_clientdata_hash(a, junk, sizeof(cdh)) == FIDO_OK); | ||
364 | assert(fido_assert_set_rp(a, "localhost") == FIDO_OK); | ||
365 | assert(fido_assert_set_count(a, 1) == FIDO_OK); | ||
366 | assert(fido_assert_set_authdata(a, 0, authdata, | ||
367 | sizeof(authdata)) == FIDO_OK); | ||
368 | assert(fido_assert_set_up(a, FIDO_OPT_FALSE) == FIDO_OK); | ||
369 | assert(fido_assert_set_uv(a, FIDO_OPT_FALSE) == FIDO_OK); | ||
370 | assert(fido_assert_set_sig(a, 0, sig, sizeof(sig)) == FIDO_OK); | ||
371 | assert(fido_assert_verify(a, 0, COSE_ES256, pk) == FIDO_ERR_INVALID_SIG); | ||
372 | free_assert(a); | ||
373 | free_es256_pk(pk); | ||
374 | free(junk); | ||
375 | } | ||
376 | |||
377 | static void | ||
378 | junk_rp(void) | ||
379 | { | ||
380 | fido_assert_t *a; | ||
381 | es256_pk_t *pk; | ||
382 | |||
383 | a = alloc_assert(); | ||
384 | pk = alloc_es256_pk(); | ||
385 | assert(es256_pk_from_ptr(pk, es256_pk, sizeof(es256_pk)) == FIDO_OK); | ||
386 | assert(fido_assert_set_clientdata_hash(a, cdh, sizeof(cdh)) == FIDO_OK); | ||
387 | assert(fido_assert_set_rp(a, "potato") == FIDO_OK); | ||
388 | assert(fido_assert_set_count(a, 1) == FIDO_OK); | ||
389 | assert(fido_assert_set_authdata(a, 0, authdata, | ||
390 | sizeof(authdata)) == FIDO_OK); | ||
391 | assert(fido_assert_set_up(a, FIDO_OPT_FALSE) == FIDO_OK); | ||
392 | assert(fido_assert_set_uv(a, FIDO_OPT_FALSE) == FIDO_OK); | ||
393 | assert(fido_assert_set_sig(a, 0, sig, sizeof(sig)) == FIDO_OK); | ||
394 | assert(fido_assert_verify(a, 0, COSE_ES256, | ||
395 | pk) == FIDO_ERR_INVALID_PARAM); | ||
396 | free_assert(a); | ||
397 | free_es256_pk(pk); | ||
398 | } | ||
399 | |||
400 | static void | ||
401 | junk_authdata(void) | ||
402 | { | ||
403 | fido_assert_t *a; | ||
404 | unsigned char *junk; | ||
405 | |||
406 | junk = malloc(sizeof(authdata)); | ||
407 | assert(junk != NULL); | ||
408 | memcpy(junk, authdata, sizeof(authdata)); | ||
409 | junk[0] = ~junk[0]; | ||
410 | |||
411 | a = alloc_assert(); | ||
412 | assert(fido_assert_set_count(a, 1) == FIDO_OK); | ||
413 | assert(fido_assert_set_authdata(a, 0, junk, | ||
414 | sizeof(authdata)) == FIDO_ERR_INVALID_ARGUMENT); | ||
415 | free_assert(a); | ||
416 | free(junk); | ||
417 | } | ||
418 | |||
419 | static void | ||
420 | junk_sig(void) | ||
421 | { | ||
422 | fido_assert_t *a; | ||
423 | es256_pk_t *pk; | ||
424 | unsigned char *junk; | ||
425 | |||
426 | junk = malloc(sizeof(sig)); | ||
427 | assert(junk != NULL); | ||
428 | memcpy(junk, sig, sizeof(sig)); | ||
429 | junk[0] = ~junk[0]; | ||
430 | |||
431 | a = alloc_assert(); | ||
432 | pk = alloc_es256_pk(); | ||
433 | assert(es256_pk_from_ptr(pk, es256_pk, sizeof(es256_pk)) == FIDO_OK); | ||
434 | assert(fido_assert_set_clientdata_hash(a, cdh, sizeof(cdh)) == FIDO_OK); | ||
435 | assert(fido_assert_set_rp(a, "localhost") == FIDO_OK); | ||
436 | assert(fido_assert_set_count(a, 1) == FIDO_OK); | ||
437 | assert(fido_assert_set_authdata(a, 0, authdata, | ||
438 | sizeof(authdata)) == FIDO_OK); | ||
439 | assert(fido_assert_set_up(a, FIDO_OPT_FALSE) == FIDO_OK); | ||
440 | assert(fido_assert_set_uv(a, FIDO_OPT_FALSE) == FIDO_OK); | ||
441 | assert(fido_assert_set_sig(a, 0, junk, sizeof(sig)) == FIDO_OK); | ||
442 | assert(fido_assert_verify(a, 0, COSE_ES256, pk) == FIDO_ERR_INVALID_SIG); | ||
443 | free_assert(a); | ||
444 | free_es256_pk(pk); | ||
445 | free(junk); | ||
446 | } | ||
447 | |||
448 | static void | ||
449 | wrong_options(void) | ||
450 | { | ||
451 | fido_assert_t *a; | ||
452 | es256_pk_t *pk; | ||
453 | |||
454 | a = alloc_assert(); | ||
455 | pk = alloc_es256_pk(); | ||
456 | assert(es256_pk_from_ptr(pk, es256_pk, sizeof(es256_pk)) == FIDO_OK); | ||
457 | assert(fido_assert_set_clientdata_hash(a, cdh, sizeof(cdh)) == FIDO_OK); | ||
458 | assert(fido_assert_set_rp(a, "localhost") == FIDO_OK); | ||
459 | assert(fido_assert_set_count(a, 1) == FIDO_OK); | ||
460 | assert(fido_assert_set_authdata(a, 0, authdata, | ||
461 | sizeof(authdata)) == FIDO_OK); | ||
462 | assert(fido_assert_set_up(a, FIDO_OPT_TRUE) == FIDO_OK); | ||
463 | assert(fido_assert_set_uv(a, FIDO_OPT_FALSE) == FIDO_OK); | ||
464 | assert(fido_assert_set_sig(a, 0, sig, sizeof(sig)) == FIDO_OK); | ||
465 | assert(fido_assert_verify(a, 0, COSE_ES256, | ||
466 | pk) == FIDO_ERR_INVALID_PARAM); | ||
467 | assert(fido_assert_set_up(a, FIDO_OPT_FALSE) == FIDO_OK); | ||
468 | assert(fido_assert_set_uv(a, FIDO_OPT_TRUE) == FIDO_OK); | ||
469 | assert(fido_assert_verify(a, 0, COSE_ES256, | ||
470 | pk) == FIDO_ERR_INVALID_PARAM); | ||
471 | assert(fido_assert_set_up(a, FIDO_OPT_FALSE) == FIDO_OK); | ||
472 | assert(fido_assert_set_uv(a, FIDO_OPT_FALSE) == FIDO_OK); | ||
473 | assert(fido_assert_verify(a, 0, COSE_ES256, pk) == FIDO_OK); | ||
474 | free_assert(a); | ||
475 | free_es256_pk(pk); | ||
476 | } | ||
477 | |||
478 | /* cbor_serialize_alloc misuse */ | ||
479 | static void | ||
480 | bad_cbor_serialize(void) | ||
481 | { | ||
482 | fido_assert_t *a; | ||
483 | |||
484 | a = alloc_assert(); | ||
485 | assert(fido_assert_set_count(a, 1) == FIDO_OK); | ||
486 | assert(fido_assert_set_authdata(a, 0, authdata, | ||
487 | sizeof(authdata)) == FIDO_OK); | ||
488 | assert(fido_assert_authdata_len(a, 0) == sizeof(authdata)); | ||
489 | free_assert(a); | ||
490 | } | ||
491 | |||
492 | int | ||
493 | main(void) | ||
494 | { | ||
495 | fido_init(0); | ||
496 | |||
497 | empty_assert_tests(); | ||
498 | valid_assert(); | ||
499 | no_cdh(); | ||
500 | no_rp(); | ||
501 | no_authdata(); | ||
502 | no_sig(); | ||
503 | junk_cdh(); | ||
504 | junk_rp(); | ||
505 | junk_authdata(); | ||
506 | junk_sig(); | ||
507 | wrong_options(); | ||
508 | bad_cbor_serialize(); | ||
509 | |||
510 | exit(0); | ||
511 | } | ||