]>
Commit | Line | Data |
---|---|---|
031e5cce SM |
1 | // SPDX-License-Identifier: BSD-2-Clause-Patent |
2 | /* | |
3 | * test-sbat.c - test our sbat functions. | |
4 | */ | |
5 | ||
6 | #ifndef SHIM_UNIT_TEST | |
7 | #define SHIM_UNIT_TEST | |
8 | #endif | |
9 | #include "shim.h" | |
10 | ||
11 | #include <stdio.h> | |
12 | ||
13 | #define MAX_SIZE 512 | |
14 | ||
15 | list_t sbat_var; | |
16 | ||
e6ace38a SM |
17 | BOOLEAN |
18 | secure_mode() { | |
19 | return 1; | |
20 | } | |
21 | ||
031e5cce SM |
22 | #if 0 |
23 | /* | |
24 | * Mock test helpers | |
25 | */ | |
26 | static struct sbat_entry * | |
27 | create_mock_sbat_entry(const char* comp_name, const char* comp_gen, | |
28 | const char* vend_name, const char* vend_pkg_name, | |
29 | const char* vend_ver, const char* vend_url) | |
30 | { | |
31 | struct sbat_entry *new_entry = AllocatePool(sizeof(*new_entry)); | |
32 | if (!new_entry) | |
33 | return NULL; | |
34 | new_entry->component_name = comp_name; | |
35 | new_entry->component_generation = comp_gen; | |
36 | new_entry->vendor_name = vend_name; | |
37 | new_entry->vendor_package_name = vend_pkg_name; | |
38 | new_entry->vendor_version = vend_ver; | |
39 | new_entry->vendor_url = vend_url; | |
40 | return new_entry; | |
41 | } | |
42 | ||
43 | void | |
44 | free_mock_sbat_entry(struct sbat_entry *entry) | |
45 | { | |
46 | if (entry) | |
47 | FreePool(entry); | |
48 | } | |
49 | ||
50 | static struct sbat * | |
51 | create_mock_sbat_one_entry(char* comp_name, char* comp_gen, char* vend_name, | |
52 | char* vend_pkg_name, char* vend_ver, char* vend_url) | |
53 | { | |
54 | struct sbat *new_entry = AllocatePool(sizeof(*new_entry)); | |
55 | if (!new_entry) | |
56 | return NULL; | |
57 | struct sbat_entry *test_entry; | |
58 | struct sbat_entry **entries = AllocatePool(sizeof(*entries)); | |
59 | if (!entries) | |
60 | return NULL; | |
61 | test_entry = create_mock_sbat_entry(comp_name, comp_gen, vend_name, | |
62 | vend_pkg_name, vend_ver, vend_url); | |
63 | if (!test_entry) | |
64 | return NULL; | |
65 | entries[0] = test_entry; | |
66 | new_entry->size = 1; | |
67 | new_entry->entries = entries; | |
68 | return new_entry; | |
69 | } | |
70 | ||
71 | static struct sbat * | |
72 | create_mock_sbat_multiple_entries(struct sbat_entry *entry_array, | |
73 | size_t num_elem) | |
74 | { | |
75 | unsigned int i; | |
76 | struct sbat *new_entry = AllocatePool(sizeof(*new_entry)); | |
77 | if (!new_entry) | |
78 | return NULL; | |
79 | struct sbat_entry *test_entry; | |
80 | struct sbat_entry **entries = AllocatePool(num_elem * sizeof(*entries)); | |
81 | if (!entries) | |
82 | return NULL; | |
83 | for (i = 0; i < num_elem; i++) { | |
84 | test_entry = create_mock_sbat_entry(entry_array[i].component_name, | |
85 | entry_array[i].component_generation, | |
86 | entry_array[i].vendor_name, | |
87 | entry_array[i].vendor_package_name, | |
88 | entry_array[i].vendor_version, | |
89 | entry_array[i].vendor_url); | |
90 | if (!test_entry) | |
91 | return NULL; | |
92 | entries[i] = test_entry; | |
93 | } | |
94 | new_entry->size = num_elem; | |
95 | new_entry->entries = entries; | |
96 | ||
97 | return new_entry; | |
98 | } | |
99 | ||
100 | void | |
101 | free_mock_sbat(struct sbat *sbat) | |
102 | { | |
103 | unsigned int i; | |
104 | if (sbat) { | |
105 | for (i = 0; i < sbat->size; i++) { | |
106 | if (sbat->entries[i]) { | |
107 | FreePool(sbat->entries[i]); | |
108 | } | |
109 | } | |
110 | FreePool(sbat); | |
111 | } | |
112 | } | |
113 | ||
114 | static struct sbat_var * | |
115 | create_mock_sbat_var_entry(const char* comp_name, const char* comp_gen) | |
116 | { | |
117 | struct sbat_var *new_entry = AllocatePool(sizeof(*new_entry)); | |
118 | if (!new_entry) | |
119 | return NULL; | |
120 | INIT_LIST_HEAD(&new_entry->list); | |
121 | int comp_name_size = strlen(comp_name) + 1; | |
122 | CHAR8 *alloc_comp_name = AllocatePool(comp_name_size * sizeof(*alloc_comp_name)); | |
123 | if (!alloc_comp_name) | |
124 | return NULL; | |
125 | int comp_gen_size = strlen(comp_gen) + 1; | |
126 | CHAR8 *alloc_comp_gen = AllocatePool(comp_gen_size * sizeof(*alloc_comp_gen)); | |
127 | if (!alloc_comp_gen) | |
128 | return NULL; | |
129 | CopyMem(alloc_comp_name, comp_name, comp_name_size); | |
130 | CopyMem(alloc_comp_gen, comp_gen, comp_gen_size); | |
131 | new_entry->component_name = alloc_comp_name; | |
132 | new_entry->component_generation = alloc_comp_gen; | |
133 | return new_entry; | |
134 | } | |
135 | ||
136 | static list_t * | |
137 | create_mock_sbat_entries_one_entry(char* name, char* gen) | |
138 | { | |
139 | list_t *test_sbat_entries = AllocatePool(sizeof(*test_sbat_entries)); | |
140 | if (!test_sbat_entries) | |
141 | return NULL; | |
142 | INIT_LIST_HEAD(test_sbat_entries); | |
143 | struct sbat_var *test_entry; | |
144 | test_entry = create_mock_sbat_var_entry(name, gen); | |
145 | if (!test_entry) | |
146 | return NULL; | |
147 | list_add(&test_entry->list, test_sbat_entries); | |
148 | return test_sbat_entries; | |
149 | } | |
150 | ||
151 | static list_t * | |
152 | create_mock_sbat_entries_multiple_entries(struct sbat_var *var_array, | |
153 | size_t num_elem) | |
154 | { | |
155 | unsigned int i; | |
156 | list_t *test_sbat_entries = AllocatePool(sizeof(*test_sbat_entries)); | |
157 | if (!test_sbat_entries) | |
158 | return NULL; | |
159 | INIT_LIST_HEAD(test_sbat_entries); | |
160 | struct sbat_var *test_entry; | |
161 | for (i = 0; i < num_elem; i++) { | |
162 | test_entry = create_mock_sbat_var_entry(var_array[i].component_name, | |
163 | var_array[i].component_generation); | |
164 | if (!test_entry) | |
165 | return NULL; | |
166 | list_add(&test_entry->list, test_sbat_entries); | |
167 | } | |
168 | return test_sbat_entries; | |
169 | } | |
170 | ||
171 | void | |
172 | free_mock_sbat_entries(list_t *entries) | |
173 | { | |
174 | list_t *pos = NULL; | |
175 | list_t *n = NULL; | |
176 | struct sbat_var *entry; | |
177 | ||
178 | if (entries) | |
179 | { | |
180 | list_for_each_safe(pos, n, entries) | |
181 | { | |
182 | entry = list_entry(pos, struct sbat_var, list); | |
183 | list_del(&entry->list); | |
184 | if (entry->component_name) | |
185 | FreePool((CHAR8 *)entry->component_name); | |
186 | if (entry->component_generation) | |
187 | FreePool((CHAR8 *)entry->component_generation); | |
188 | FreePool(entry); | |
189 | } | |
190 | FreePool(entries); | |
191 | } | |
192 | } | |
193 | #endif | |
194 | ||
195 | /* | |
196 | * parse_sbat_section() tests | |
197 | */ | |
198 | int | |
199 | test_parse_sbat_section_null_sbat_base(void) | |
200 | { | |
201 | char *section_base = NULL; | |
202 | size_t section_size = 20; | |
203 | struct sbat_section_entry **entries; | |
204 | size_t n = 0; | |
205 | EFI_STATUS status; | |
206 | ||
207 | status = parse_sbat_section(section_base, section_size, &n, &entries); | |
208 | assert_equal_return(status, EFI_INVALID_PARAMETER, -1, "got %#hhx expected %#hhx\n"); | |
209 | ||
210 | return 0; | |
211 | } | |
212 | ||
213 | int | |
214 | test_parse_sbat_section_zero_sbat_size(void) | |
215 | { | |
216 | char section_base[] = "test1,1,SBAT test1,acme,1,testURL\n"; | |
217 | size_t section_size = 0; | |
218 | struct sbat_section_entry **entries; | |
219 | size_t n = 0; | |
220 | EFI_STATUS status; | |
221 | ||
222 | status = parse_sbat_section(section_base, section_size, &n, &entries); | |
223 | assert_equal_return(status, EFI_INVALID_PARAMETER, -1, "got %#hhx expected %#hhx\n"); | |
224 | ||
225 | return 0; | |
226 | } | |
227 | ||
228 | int | |
229 | test_parse_sbat_section_null_entries(void) | |
230 | { | |
231 | char section_base[] = "test1,1,SBAT test1,acme,1,testURL\n"; | |
232 | /* intentionally not NUL terminated */ | |
233 | size_t section_size = sizeof(section_base) - 1; | |
234 | size_t n = 0; | |
235 | EFI_STATUS status; | |
236 | ||
237 | status = parse_sbat_section(section_base, section_size, &n, NULL); | |
238 | assert_equal_return(status, EFI_INVALID_PARAMETER, -1, "got %#hhx expected %#hhx\n"); | |
239 | ||
240 | return 0; | |
241 | } | |
242 | ||
243 | int | |
244 | test_parse_sbat_section_null_count(void) | |
245 | { | |
246 | char section_base[] = "test1,1,SBAT test1,acme,1,testURL\n"; | |
247 | /* intentionally not NUL terminated */ | |
248 | size_t section_size = sizeof(section_base) - 1; | |
249 | struct sbat_section_entry **entries; | |
250 | EFI_STATUS status; | |
251 | ||
252 | status = parse_sbat_section(section_base, section_size, NULL, &entries); | |
253 | assert_equal_return(status, EFI_INVALID_PARAMETER, -1, "got %#hhx expected %#hhx\n"); | |
254 | ||
255 | return 0; | |
256 | } | |
257 | ||
258 | int | |
259 | test_parse_sbat_section_no_newline(void) | |
260 | { | |
261 | char section_base[] = "test1,1,SBAT test1,acme,1,testURL"; | |
262 | /* intentionally not NUL terminated */ | |
263 | size_t section_size = sizeof(section_base) - 1; | |
264 | struct sbat_section_entry **entries; | |
265 | size_t n = 0; | |
266 | EFI_STATUS status; | |
267 | ||
268 | status = parse_sbat_section(section_base, section_size, &n, &entries); | |
269 | cleanup_sbat_section_entries(n, entries); | |
270 | assert_equal_return(status, EFI_SUCCESS, -1, "got %#hhx expected %#hhx\n"); | |
271 | ||
272 | return 0; | |
273 | } | |
274 | ||
275 | int | |
276 | test_parse_sbat_section_no_commas(void) | |
277 | { | |
278 | char section_base[] = "test1"; | |
279 | /* intentionally not NUL terminated */ | |
280 | size_t section_size = sizeof(section_base) - 1; | |
281 | struct sbat_section_entry **entries; | |
282 | size_t n = 0; | |
283 | EFI_STATUS status; | |
284 | ||
285 | status = parse_sbat_section(section_base, section_size, &n, &entries); | |
286 | assert_equal_return(status, EFI_INVALID_PARAMETER, -1, "got %#hhx expected %#hhx\n"); | |
287 | ||
288 | return 0; | |
289 | } | |
290 | ||
291 | int | |
292 | test_parse_sbat_section_too_few_elem(void) | |
293 | { | |
294 | char section_base[] = "test1,1,acme"; | |
295 | /* intentionally not NUL terminated */ | |
296 | size_t section_size = sizeof(section_base) - 1; | |
297 | struct sbat_section_entry **entries; | |
298 | size_t n = 0; | |
299 | EFI_STATUS status; | |
300 | ||
301 | status = parse_sbat_section(section_base, section_size, &n, &entries); | |
302 | assert_equal_return(status, EFI_INVALID_PARAMETER, -1, "got %#hhx expected %#hhx\n"); | |
303 | ||
304 | return 0; | |
305 | } | |
306 | ||
307 | int | |
308 | test_parse_sbat_section_too_many_elem(void) | |
309 | { | |
310 | char section_base[] = "test1,1,SBAT test1,acme1,1,testURL1,other1,stuff,is,here\n" | |
311 | "test2,2,SBAT test2,acme2,2,testURL2,other2"; | |
312 | /* intentionally not NUL terminated */ | |
313 | size_t section_size = sizeof(section_base) - 1; | |
314 | struct sbat_section_entry **entries; | |
315 | size_t n = 0, i; | |
316 | list_t *pos = NULL; | |
317 | EFI_STATUS status; | |
318 | struct sbat_section_entry test_section_entry1 = { | |
319 | "test1", "1", "SBAT test1", "acme1", "1", "testURL1" | |
320 | }; | |
321 | struct sbat_section_entry test_section_entry2 = { | |
322 | "test2", "2", "SBAT test2", "acme2", "2", "testURL2" | |
323 | }; | |
324 | struct sbat_section_entry *test_entries[] = { | |
325 | &test_section_entry1, &test_section_entry2, | |
326 | }; | |
8119f718 | 327 | int rc = -1; |
031e5cce SM |
328 | |
329 | status = parse_sbat_section(section_base, section_size, &n, &entries); | |
330 | assert_equal_return(status, EFI_SUCCESS, -1, "got %#hhx expected %#hhx\n"); | |
331 | ||
332 | for (i = 0; i < n; i++) { | |
333 | struct sbat_section_entry *entry = entries[i]; | |
334 | struct sbat_section_entry *test_entry = test_entries[i]; | |
335 | ||
336 | #define mkassert(a) \ | |
337 | assert_equal_goto(strcmp(entry-> a, test_entry-> a), 0, fail, \ | |
338 | "got %zu expected %d\n") | |
339 | ||
340 | mkassert(component_name); | |
341 | mkassert(component_generation); | |
342 | mkassert(vendor_name); | |
343 | mkassert(vendor_package_name); | |
344 | mkassert(vendor_version); | |
345 | mkassert(vendor_url); | |
346 | ||
347 | #undef mkassert | |
348 | } | |
349 | assert_equal_goto(n, 2, fail, "got %zu expected %d\n"); | |
8119f718 | 350 | rc = 0; |
031e5cce SM |
351 | fail: |
352 | cleanup_sbat_section_entries(n, entries); | |
8119f718 | 353 | return rc; |
031e5cce SM |
354 | } |
355 | ||
356 | /* | |
357 | * parse_sbat_var() tests | |
358 | */ | |
359 | int | |
360 | test_parse_sbat_var_null_list(void) | |
361 | { | |
362 | EFI_STATUS status; | |
363 | ||
364 | INIT_LIST_HEAD(&sbat_var); | |
365 | status = parse_sbat_var(NULL); | |
366 | cleanup_sbat_var(&sbat_var); | |
367 | assert_equal_return(status, EFI_INVALID_PARAMETER, -1, "got %#hhx expected %#hhx\n"); | |
368 | ||
369 | return 0; | |
370 | } | |
371 | ||
372 | int | |
373 | test_parse_sbat_var_data_null_list(void) | |
374 | { | |
375 | char sbat_var_data[] = "test1,1,2021022400"; | |
376 | /* | |
377 | * intentionally including the NUL termination, because | |
378 | * get_variable() will always include it. | |
379 | */ | |
380 | size_t sbat_var_data_size = sizeof(sbat_var_data); | |
381 | EFI_STATUS status; | |
382 | ||
383 | INIT_LIST_HEAD(&sbat_var); | |
384 | status = parse_sbat_var_data(NULL, sbat_var_data, sbat_var_data_size); | |
385 | cleanup_sbat_var(&sbat_var); | |
386 | ||
387 | assert_equal_return(status, EFI_INVALID_PARAMETER, -1, "got %#hhx expected %#hhx\n"); | |
388 | ||
389 | return 0; | |
390 | } | |
391 | ||
392 | int | |
393 | test_parse_sbat_var_data_null_data(void) | |
394 | { | |
395 | size_t sbat_var_data_size = 4; | |
396 | EFI_STATUS status; | |
397 | ||
398 | INIT_LIST_HEAD(&sbat_var); | |
399 | status = parse_sbat_var_data(&sbat_var, NULL, sbat_var_data_size); | |
400 | cleanup_sbat_var(&sbat_var); | |
401 | ||
402 | assert_equal_return(status, EFI_INVALID_PARAMETER, -1, "got %#hhx expected %#hhx\n"); | |
403 | ||
404 | return 0; | |
405 | } | |
406 | ||
407 | int | |
408 | test_parse_sbat_var_data_zero_size(void) | |
409 | { | |
410 | char sbat_var_data[] = "test1,1,2021022400"; | |
411 | EFI_STATUS status; | |
412 | ||
413 | INIT_LIST_HEAD(&sbat_var); | |
414 | status = parse_sbat_var_data(&sbat_var, sbat_var_data, 0); | |
415 | cleanup_sbat_var(&sbat_var); | |
416 | ||
417 | assert_equal_return(status, EFI_INVALID_PARAMETER, -1, "got %#hhx expected %#hhx\n"); | |
418 | ||
419 | return 0; | |
420 | } | |
421 | ||
422 | int | |
423 | test_parse_sbat_var_data(void) | |
424 | { | |
425 | char sbat_var_data[] = "test1,1,2021022400"; | |
426 | EFI_STATUS status; | |
427 | ||
428 | INIT_LIST_HEAD(&sbat_var); | |
429 | status = parse_sbat_var_data(&sbat_var, sbat_var_data, 0); | |
430 | ||
431 | assert_equal_return(status, EFI_INVALID_PARAMETER, -1, "got %#hhx expected %#hhx\n"); | |
432 | ||
433 | return 0; | |
434 | } | |
435 | ||
436 | /* | |
437 | * verify_sbat() tests | |
438 | * Note: verify_sbat also frees the underlying "sbat_entries" memory. | |
439 | */ | |
440 | int | |
441 | test_verify_sbat_null_sbat_section(void) | |
442 | { | |
443 | char sbat_var_data[] = "test1,1"; | |
444 | EFI_STATUS status; | |
445 | list_t test_sbat_var; | |
446 | size_t n = 0; | |
447 | struct sbat_section_entry **entries = NULL; | |
8119f718 | 448 | int rc = -1; |
031e5cce SM |
449 | |
450 | INIT_LIST_HEAD(&test_sbat_var); | |
451 | status = parse_sbat_var_data(&test_sbat_var, sbat_var_data, sizeof(sbat_var_data)); | |
8119f718 | 452 | assert_equal_goto(status, EFI_SUCCESS, err, "got %#x expected %#x\n"); |
031e5cce | 453 | |
8119f718 SM |
454 | status = verify_sbat_helper(&test_sbat_var, n, entries); |
455 | assert_equal_goto(status, EFI_SUCCESS, err, "got %#x expected %#x\n"); | |
456 | rc = 0; | |
457 | err: | |
458 | cleanup_sbat_var(&test_sbat_var); | |
459 | ||
460 | return rc; | |
031e5cce SM |
461 | } |
462 | ||
463 | #if 0 | |
464 | int | |
465 | test_verify_sbat_null_sbat_entries(void) | |
466 | { | |
467 | struct sbat *test_sbat; | |
468 | test_sbat = create_mock_sbat_one_entry("test1","1","SBAT test1", | |
469 | "acme","1","testURL"); | |
470 | if (!test_sbat) | |
471 | return -1; | |
472 | ||
473 | list_t sbat_entries; | |
474 | INIT_LIST_HEAD(&sbat_entries); | |
475 | EFI_STATUS status; | |
476 | ||
477 | status = verify_sbat(test_sbat, &sbat_entries); | |
478 | ||
479 | assert(status == EFI_INVALID_PARAMETER); | |
480 | free_mock_sbat(test_sbat); | |
481 | return 0; | |
482 | } | |
483 | ||
484 | int | |
485 | test_verify_sbat_match_one_exact(void) | |
486 | { | |
487 | struct sbat *test_sbat; | |
488 | struct sbat_entry sbat_entry_array[2]; | |
489 | sbat_entry_array[0].component_name = "test1"; | |
490 | sbat_entry_array[0].component_generation = "1"; | |
491 | sbat_entry_array[0].vendor_name = "SBAT test1"; | |
492 | sbat_entry_array[0].vendor_package_name = "acme"; | |
493 | sbat_entry_array[0].vendor_version = "1"; | |
494 | sbat_entry_array[0].vendor_url = "testURL"; | |
495 | sbat_entry_array[1].component_name = "test2"; | |
496 | sbat_entry_array[1].component_generation = "2"; | |
497 | sbat_entry_array[1].vendor_name = "SBAT test2"; | |
498 | sbat_entry_array[1].vendor_package_name = "acme2"; | |
499 | sbat_entry_array[1].vendor_version = "2"; | |
500 | sbat_entry_array[1].vendor_url = "testURL2"; | |
501 | test_sbat = create_mock_sbat_multiple_entries(sbat_entry_array, 2); | |
502 | if (!test_sbat) | |
503 | return -1; | |
504 | ||
505 | list_t *test_sbat_entries; | |
506 | test_sbat_entries = create_mock_sbat_entries_one_entry("test1", "1"); | |
507 | if (!test_sbat_entries) | |
508 | return -1; | |
509 | EFI_STATUS status; | |
510 | ||
511 | status = verify_sbat(test_sbat, test_sbat_entries); | |
512 | ||
513 | assert(status == EFI_SUCCESS); | |
514 | free_mock_sbat(test_sbat); | |
515 | free_mock_sbat_entries(test_sbat_entries); | |
516 | return 0; | |
517 | } | |
518 | ||
519 | int | |
520 | test_verify_sbat_match_one_higher(void) | |
521 | { | |
522 | struct sbat *test_sbat; | |
523 | struct sbat_entry sbat_entry_array[2]; | |
524 | sbat_entry_array[0].component_name = "test1"; | |
525 | sbat_entry_array[0].component_generation = "1"; | |
526 | sbat_entry_array[0].vendor_name = "SBAT test1"; | |
527 | sbat_entry_array[0].vendor_package_name = "acme"; | |
528 | sbat_entry_array[0].vendor_version = "1"; | |
529 | sbat_entry_array[0].vendor_url = "testURL"; | |
530 | sbat_entry_array[1].component_name = "test2"; | |
531 | sbat_entry_array[1].component_generation = "2"; | |
532 | sbat_entry_array[1].vendor_name = "SBAT test2"; | |
533 | sbat_entry_array[1].vendor_package_name = "acme2"; | |
534 | sbat_entry_array[1].vendor_version = "2"; | |
535 | sbat_entry_array[1].vendor_url = "testURL2"; | |
536 | test_sbat = create_mock_sbat_multiple_entries(sbat_entry_array, 2); | |
537 | if (!test_sbat) | |
538 | return -1; | |
539 | ||
540 | list_t *test_sbat_entries; | |
541 | test_sbat_entries = create_mock_sbat_entries_one_entry("test2", "1"); | |
542 | if (!test_sbat_entries) | |
543 | return -1; | |
544 | EFI_STATUS status; | |
545 | ||
546 | status = verify_sbat(test_sbat, test_sbat_entries); | |
547 | ||
548 | assert(status == EFI_SUCCESS); | |
549 | free_mock_sbat(test_sbat); | |
550 | free_mock_sbat_entries(test_sbat_entries); | |
551 | return 0; | |
552 | } | |
553 | ||
554 | int | |
555 | test_verify_sbat_reject_one(void) | |
556 | { | |
557 | struct sbat *test_sbat; | |
558 | struct sbat_entry sbat_entry_array[2]; | |
559 | sbat_entry_array[0].component_name = "test1"; | |
560 | sbat_entry_array[0].component_generation = "1"; | |
561 | sbat_entry_array[0].vendor_name = "SBAT test1"; | |
562 | sbat_entry_array[0].vendor_package_name = "acme"; | |
563 | sbat_entry_array[0].vendor_version = "1"; | |
564 | sbat_entry_array[0].vendor_url = "testURL"; | |
565 | sbat_entry_array[1].component_name = "test2"; | |
566 | sbat_entry_array[1].component_generation = "2"; | |
567 | sbat_entry_array[1].vendor_name = "SBAT test2"; | |
568 | sbat_entry_array[1].vendor_package_name = "acme2"; | |
569 | sbat_entry_array[1].vendor_version = "2"; | |
570 | sbat_entry_array[1].vendor_url = "testURL2"; | |
571 | test_sbat = create_mock_sbat_multiple_entries(sbat_entry_array, 2); | |
572 | if (!test_sbat) | |
573 | return -1; | |
574 | ||
575 | list_t *test_sbat_entries; | |
576 | test_sbat_entries = create_mock_sbat_entries_one_entry("test2", "3"); | |
577 | if (!test_sbat_entries) | |
578 | return -1; | |
579 | EFI_STATUS status; | |
580 | ||
581 | status = verify_sbat(test_sbat, test_sbat_entries); | |
582 | ||
583 | assert(status == EFI_SECURITY_VIOLATION); | |
584 | free_mock_sbat(test_sbat); | |
585 | free_mock_sbat_entries(test_sbat_entries); | |
586 | return 0; | |
587 | } | |
588 | ||
589 | int | |
590 | test_verify_sbat_reject_many(void) | |
591 | { | |
592 | struct sbat *test_sbat; | |
593 | unsigned int sbat_entry_array_size = 2; | |
594 | struct sbat_entry sbat_entry_array[sbat_entry_array_size]; | |
595 | sbat_entry_array[0].component_name = "test1"; | |
596 | sbat_entry_array[0].component_generation = "1"; | |
597 | sbat_entry_array[0].vendor_name = "SBAT test1"; | |
598 | sbat_entry_array[0].vendor_package_name = "acme"; | |
599 | sbat_entry_array[0].vendor_version = "1"; | |
600 | sbat_entry_array[0].vendor_url = "testURL"; | |
601 | sbat_entry_array[1].component_name = "test2"; | |
602 | sbat_entry_array[1].component_generation = "2"; | |
603 | sbat_entry_array[1].vendor_name = "SBAT test2"; | |
604 | sbat_entry_array[1].vendor_package_name = "acme2"; | |
605 | sbat_entry_array[1].vendor_version = "2"; | |
606 | sbat_entry_array[1].vendor_url = "testURL2"; | |
607 | test_sbat = create_mock_sbat_multiple_entries(sbat_entry_array, | |
608 | sbat_entry_array_size); | |
609 | if (!test_sbat) | |
610 | return -1; | |
611 | ||
612 | list_t *test_sbat_entries; | |
613 | unsigned int sbat_var_array_size = 2; | |
614 | struct sbat_var sbat_var_array[sbat_var_array_size]; | |
615 | sbat_var_array[0].component_name = "test1"; | |
616 | sbat_var_array[0].component_generation = "1"; | |
617 | sbat_var_array[1].component_name = "test2"; | |
618 | sbat_var_array[1].component_generation = "3"; | |
619 | test_sbat_entries = create_mock_sbat_entries_multiple_entries(sbat_var_array, | |
620 | sbat_var_array_size); | |
621 | if (!test_sbat_entries) | |
622 | return -1; | |
623 | EFI_STATUS status; | |
624 | ||
625 | status = verify_sbat(test_sbat, test_sbat_entries); | |
626 | ||
627 | assert(status == EFI_SECURITY_VIOLATION); | |
628 | free_mock_sbat(test_sbat); | |
629 | free_mock_sbat_entries(test_sbat_entries); | |
630 | return 0; | |
631 | } | |
632 | ||
633 | int | |
634 | test_verify_sbat_match_many_higher(void) | |
635 | { | |
636 | struct sbat *test_sbat; | |
637 | unsigned int sbat_entry_array_size = 2; | |
638 | struct sbat_entry sbat_entry_array[sbat_entry_array_size]; | |
639 | sbat_entry_array[0].component_name = "test1"; | |
640 | sbat_entry_array[0].component_generation = "3"; | |
641 | sbat_entry_array[0].vendor_name = "SBAT test1"; | |
642 | sbat_entry_array[0].vendor_package_name = "acme"; | |
643 | sbat_entry_array[0].vendor_version = "1"; | |
644 | sbat_entry_array[0].vendor_url = "testURL"; | |
645 | sbat_entry_array[1].component_name = "test2"; | |
646 | sbat_entry_array[1].component_generation = "5"; | |
647 | sbat_entry_array[1].vendor_name = "SBAT test2"; | |
648 | sbat_entry_array[1].vendor_package_name = "acme2"; | |
649 | sbat_entry_array[1].vendor_version = "2"; | |
650 | sbat_entry_array[1].vendor_url = "testURL2"; | |
651 | test_sbat = create_mock_sbat_multiple_entries(sbat_entry_array, | |
652 | sbat_entry_array_size); | |
653 | if (!test_sbat) | |
654 | return -1; | |
655 | ||
656 | list_t *test_sbat_entries; | |
657 | unsigned int sbat_var_array_size = 2; | |
658 | struct sbat_var sbat_var_array[sbat_var_array_size]; | |
659 | sbat_var_array[0].component_name = "test1"; | |
660 | sbat_var_array[0].component_generation = "1"; | |
661 | sbat_var_array[1].component_name = "test2"; | |
662 | sbat_var_array[1].component_generation = "2"; | |
663 | test_sbat_entries = create_mock_sbat_entries_multiple_entries(sbat_var_array, | |
664 | sbat_var_array_size); | |
665 | if (!test_sbat_entries) | |
666 | return -1; | |
667 | EFI_STATUS status; | |
668 | ||
669 | status = verify_sbat(test_sbat, test_sbat_entries); | |
670 | ||
671 | assert(status == EFI_SUCCESS); | |
672 | free_mock_sbat(test_sbat); | |
673 | free_mock_sbat_entries(test_sbat_entries); | |
674 | return 0; | |
675 | } | |
676 | ||
677 | int | |
678 | test_verify_sbat_match_many_exact(void) | |
679 | { | |
680 | struct sbat *test_sbat; | |
681 | unsigned int sbat_entry_array_size = 2; | |
682 | struct sbat_entry sbat_entry_array[sbat_entry_array_size]; | |
683 | sbat_entry_array[0].component_name = "test1"; | |
684 | sbat_entry_array[0].component_generation = "1"; | |
685 | sbat_entry_array[0].vendor_name = "SBAT test1"; | |
686 | sbat_entry_array[0].vendor_package_name = "acme"; | |
687 | sbat_entry_array[0].vendor_version = "1"; | |
688 | sbat_entry_array[0].vendor_url = "testURL"; | |
689 | sbat_entry_array[1].component_name = "test2"; | |
690 | sbat_entry_array[1].component_generation = "2"; | |
691 | sbat_entry_array[1].vendor_name = "SBAT test2"; | |
692 | sbat_entry_array[1].vendor_package_name = "acme2"; | |
693 | sbat_entry_array[1].vendor_version = "2"; | |
694 | sbat_entry_array[1].vendor_url = "testURL2"; | |
695 | test_sbat = create_mock_sbat_multiple_entries(sbat_entry_array, | |
696 | sbat_entry_array_size); | |
697 | if (!test_sbat) | |
698 | return -1; | |
699 | ||
700 | list_t *test_sbat_entries; | |
701 | unsigned int sbat_var_array_size = 2; | |
702 | struct sbat_var sbat_var_array[sbat_var_array_size]; | |
703 | sbat_var_array[0].component_name = "test1"; | |
704 | sbat_var_array[0].component_generation = "1"; | |
705 | sbat_var_array[1].component_name = "test2"; | |
706 | sbat_var_array[1].component_generation = "2"; | |
707 | test_sbat_entries = create_mock_sbat_entries_multiple_entries(sbat_var_array, | |
708 | sbat_var_array_size); | |
709 | if (!test_sbat_entries) | |
710 | return -1; | |
711 | EFI_STATUS status; | |
712 | ||
713 | status = verify_sbat(test_sbat, test_sbat_entries); | |
714 | ||
715 | assert(status == EFI_SUCCESS); | |
716 | free_mock_sbat(test_sbat); | |
717 | free_mock_sbat_entries(test_sbat_entries); | |
718 | return 0; | |
719 | } | |
720 | ||
721 | int | |
722 | test_verify_sbat_reject_many_all(void) | |
723 | { | |
724 | struct sbat *test_sbat; | |
725 | unsigned int sbat_entry_array_size = 2; | |
726 | struct sbat_entry sbat_entry_array[sbat_entry_array_size]; | |
727 | sbat_entry_array[0].component_name = "test1"; | |
728 | sbat_entry_array[0].component_generation = "1"; | |
729 | sbat_entry_array[0].vendor_name = "SBAT test1"; | |
730 | sbat_entry_array[0].vendor_package_name = "acme"; | |
731 | sbat_entry_array[0].vendor_version = "1"; | |
732 | sbat_entry_array[0].vendor_url = "testURL"; | |
733 | sbat_entry_array[1].component_name = "test2"; | |
734 | sbat_entry_array[1].component_generation = "2"; | |
735 | sbat_entry_array[1].vendor_name = "SBAT test2"; | |
736 | sbat_entry_array[1].vendor_package_name = "acme2"; | |
737 | sbat_entry_array[1].vendor_version = "2"; | |
738 | sbat_entry_array[1].vendor_url = "testURL2"; | |
739 | test_sbat = create_mock_sbat_multiple_entries(sbat_entry_array, | |
740 | sbat_entry_array_size); | |
741 | if (!test_sbat) | |
742 | return -1; | |
743 | ||
744 | list_t *test_sbat_entries; | |
745 | unsigned int sbat_var_array_size = 2; | |
746 | struct sbat_var sbat_var_array[sbat_var_array_size]; | |
747 | sbat_var_array[0].component_name = "test1"; | |
748 | sbat_var_array[0].component_generation = "3"; | |
749 | sbat_var_array[1].component_name = "test2"; | |
750 | sbat_var_array[1].component_generation = "5"; | |
751 | test_sbat_entries = create_mock_sbat_entries_multiple_entries(sbat_var_array, | |
752 | sbat_var_array_size); | |
753 | if (!test_sbat_entries) | |
754 | return -1; | |
755 | EFI_STATUS status; | |
756 | ||
757 | status = verify_sbat(test_sbat, test_sbat_entries); | |
758 | ||
759 | assert(status == EFI_SECURITY_VIOLATION); | |
760 | free_mock_sbat(test_sbat); | |
761 | free_mock_sbat_entries(test_sbat_entries); | |
762 | return 0; | |
763 | } | |
764 | ||
765 | int | |
766 | test_verify_sbat_match_diff_name(void) | |
767 | { | |
768 | struct sbat *test_sbat; | |
769 | unsigned int sbat_entry_array_size = 2; | |
770 | struct sbat_entry sbat_entry_array[sbat_entry_array_size]; | |
771 | sbat_entry_array[0].component_name = "test1"; | |
772 | sbat_entry_array[0].component_generation = "1"; | |
773 | sbat_entry_array[0].vendor_name = "SBAT test1"; | |
774 | sbat_entry_array[0].vendor_package_name = "acme"; | |
775 | sbat_entry_array[0].vendor_version = "1"; | |
776 | sbat_entry_array[0].vendor_url = "testURL"; | |
777 | sbat_entry_array[1].component_name = "test2"; | |
778 | sbat_entry_array[1].component_generation = "2"; | |
779 | sbat_entry_array[1].vendor_name = "SBAT test2"; | |
780 | sbat_entry_array[1].vendor_package_name = "acme2"; | |
781 | sbat_entry_array[1].vendor_version = "2"; | |
782 | sbat_entry_array[1].vendor_url = "testURL2"; | |
783 | test_sbat = create_mock_sbat_multiple_entries(sbat_entry_array, | |
784 | sbat_entry_array_size); | |
785 | if (!test_sbat) | |
786 | return -1; | |
787 | ||
788 | list_t *test_sbat_entries; | |
789 | unsigned int sbat_var_array_size = 2; | |
790 | struct sbat_var sbat_var_array[sbat_var_array_size]; | |
791 | sbat_var_array[0].component_name = "foo"; | |
792 | sbat_var_array[0].component_generation = "5"; | |
793 | sbat_var_array[1].component_name = "bar"; | |
794 | sbat_var_array[1].component_generation = "2"; | |
795 | test_sbat_entries = create_mock_sbat_entries_multiple_entries(sbat_var_array, | |
796 | sbat_var_array_size); | |
797 | if (!test_sbat_entries) | |
798 | return -1; | |
799 | EFI_STATUS status; | |
800 | ||
801 | status = verify_sbat(test_sbat, test_sbat_entries); | |
802 | ||
803 | assert(status == EFI_SUCCESS); | |
804 | free_mock_sbat(test_sbat); | |
805 | free_mock_sbat_entries(test_sbat_entries); | |
806 | return 0; | |
807 | } | |
808 | ||
809 | int | |
810 | test_verify_sbat_match_diff_name_mixed(void) | |
811 | { | |
812 | struct sbat *test_sbat; | |
813 | unsigned int sbat_entry_array_size = 2; | |
814 | struct sbat_entry sbat_entry_array[sbat_entry_array_size]; | |
815 | sbat_entry_array[0].component_name = "test1"; | |
816 | sbat_entry_array[0].component_generation = "1"; | |
817 | sbat_entry_array[0].vendor_name = "SBAT test1"; | |
818 | sbat_entry_array[0].vendor_package_name = "acme"; | |
819 | sbat_entry_array[0].vendor_version = "1"; | |
820 | sbat_entry_array[0].vendor_url = "testURL"; | |
821 | sbat_entry_array[1].component_name = "test2"; | |
822 | sbat_entry_array[1].component_generation = "2"; | |
823 | sbat_entry_array[1].vendor_name = "SBAT test2"; | |
824 | sbat_entry_array[1].vendor_package_name = "acme2"; | |
825 | sbat_entry_array[1].vendor_version = "2"; | |
826 | sbat_entry_array[1].vendor_url = "testURL2"; | |
827 | test_sbat = create_mock_sbat_multiple_entries(sbat_entry_array, | |
828 | sbat_entry_array_size); | |
829 | if (!test_sbat) | |
830 | return -1; | |
831 | ||
832 | list_t *test_sbat_entries; | |
833 | unsigned int sbat_var_array_size = 2; | |
834 | struct sbat_var sbat_var_array[sbat_var_array_size]; | |
835 | sbat_var_array[0].component_name = "test1"; | |
836 | sbat_var_array[0].component_generation = "1"; | |
837 | sbat_var_array[1].component_name = "bar"; | |
838 | sbat_var_array[1].component_generation = "2"; | |
839 | test_sbat_entries = create_mock_sbat_entries_multiple_entries(sbat_var_array, | |
840 | sbat_var_array_size); | |
841 | if (!test_sbat_entries) | |
842 | return -1; | |
843 | EFI_STATUS status; | |
844 | ||
845 | status = verify_sbat(test_sbat, test_sbat_entries); | |
846 | ||
847 | assert(status == EFI_SUCCESS); | |
848 | free_mock_sbat(test_sbat); | |
849 | free_mock_sbat_entries(test_sbat_entries); | |
850 | return 0; | |
851 | } | |
852 | ||
853 | int | |
854 | test_verify_sbat_reject_diff_name_mixed(void) | |
855 | { | |
856 | struct sbat *test_sbat; | |
857 | unsigned int sbat_entry_array_size = 2; | |
858 | struct sbat_entry sbat_entry_array[sbat_entry_array_size]; | |
859 | sbat_entry_array[0].component_name = "test1"; | |
860 | sbat_entry_array[0].component_generation = "1"; | |
861 | sbat_entry_array[0].vendor_name = "SBAT test1"; | |
862 | sbat_entry_array[0].vendor_package_name = "acme"; | |
863 | sbat_entry_array[0].vendor_version = "1"; | |
864 | sbat_entry_array[0].vendor_url = "testURL"; | |
865 | sbat_entry_array[1].component_name = "test2"; | |
866 | sbat_entry_array[1].component_generation = "2"; | |
867 | sbat_entry_array[1].vendor_name = "SBAT test2"; | |
868 | sbat_entry_array[1].vendor_package_name = "acme2"; | |
869 | sbat_entry_array[1].vendor_version = "2"; | |
870 | sbat_entry_array[1].vendor_url = "testURL2"; | |
871 | test_sbat = create_mock_sbat_multiple_entries(sbat_entry_array, | |
872 | sbat_entry_array_size); | |
873 | if (!test_sbat) | |
874 | return -1; | |
875 | ||
876 | list_t *test_sbat_entries; | |
877 | unsigned int sbat_var_array_size = 2; | |
878 | struct sbat_var sbat_var_array[sbat_var_array_size]; | |
879 | sbat_var_array[0].component_name = "test1"; | |
880 | sbat_var_array[0].component_generation = "5"; | |
881 | sbat_var_array[1].component_name = "bar"; | |
882 | sbat_var_array[1].component_generation = "2"; | |
883 | test_sbat_entries = create_mock_sbat_entries_multiple_entries(sbat_var_array, | |
884 | sbat_var_array_size); | |
885 | if (!test_sbat_entries) | |
886 | return -1; | |
887 | EFI_STATUS status; | |
888 | ||
889 | status = verify_sbat(test_sbat, test_sbat_entries); | |
890 | ||
891 | assert(status == EFI_SECURITY_VIOLATION); | |
892 | free_mock_sbat(test_sbat); | |
893 | free_mock_sbat_entries(test_sbat_entries); | |
894 | return 0; | |
895 | } | |
896 | #endif | |
897 | ||
898 | int | |
899 | test_parse_and_verify(void) | |
900 | { | |
901 | EFI_STATUS status; | |
902 | char sbat_section[] = | |
903 | "test1,1,SBAT test1,acme1,1,testURL1\n" | |
904 | "test2,2,SBAT test2,acme2,2,testURL2\n"; | |
905 | struct sbat_section_entry **section_entries = NULL; | |
906 | size_t n_section_entries = 0, i; | |
907 | struct sbat_section_entry test_section_entry1 = { | |
908 | "test1", "1", "SBAT test1", "acme1", "1", "testURL1" | |
909 | }; | |
910 | struct sbat_section_entry test_section_entry2 = { | |
911 | "test2", "2", "SBAT test2", "acme2", "2", "testURL2" | |
912 | }; | |
913 | struct sbat_section_entry *test_entries[] = { | |
914 | &test_section_entry1, &test_section_entry2, | |
915 | }; | |
8119f718 | 916 | int rc = -1; |
031e5cce SM |
917 | |
918 | status = parse_sbat_section(sbat_section, sizeof(sbat_section)-1, | |
919 | &n_section_entries, §ion_entries); | |
920 | eassert(status == EFI_SUCCESS, "expected %d got %d\n", | |
921 | EFI_SUCCESS, status); | |
922 | eassert(section_entries != NULL, "expected non-NULL got NULL\n"); | |
923 | ||
924 | for (i = 0; i < n_section_entries; i++) { | |
925 | struct sbat_section_entry *entry = section_entries[i]; | |
926 | struct sbat_section_entry *test_entry = test_entries[i]; | |
927 | ||
928 | #define mkassert(a) \ | |
929 | eassert(strcmp(entry-> a, test_entry-> a) == 0, \ | |
930 | "expected \"%s\" got \"%s\"\n", \ | |
931 | test_entry-> a, entry-> a ) | |
932 | ||
933 | mkassert(component_name); | |
934 | mkassert(component_generation); | |
935 | mkassert(vendor_name); | |
936 | mkassert(vendor_package_name); | |
937 | mkassert(vendor_version); | |
938 | mkassert(vendor_url); | |
939 | ||
940 | #undef mkassert | |
941 | } | |
942 | ||
943 | eassert(n_section_entries == 2, "expected %d got %d\n", | |
944 | 2, n_section_entries); | |
945 | ||
946 | char sbat_var_data[] = "test1,5\nbar,2\n"; | |
947 | size_t sbat_var_data_size = sizeof(sbat_var_data); | |
948 | char *sbat_var_alloced = calloc(1, sbat_var_data_size); | |
949 | if (!sbat_var_alloced) | |
950 | return -1; | |
951 | memcpy(sbat_var_alloced, sbat_var_data, sbat_var_data_size); | |
952 | ||
953 | INIT_LIST_HEAD(&sbat_var); | |
954 | status = parse_sbat_var_data(&sbat_var, sbat_var_alloced, sbat_var_data_size); | |
8119f718 | 955 | free(sbat_var_alloced); |
031e5cce SM |
956 | if (status != EFI_SUCCESS || list_empty(&sbat_var)) |
957 | return -1; | |
958 | ||
959 | status = verify_sbat(n_section_entries, section_entries); | |
8119f718 | 960 | assert_equal_goto(status, EFI_SECURITY_VIOLATION, err, "expected %#x got %#x\n"); |
031e5cce | 961 | |
8119f718 SM |
962 | rc = 0; |
963 | err: | |
031e5cce | 964 | cleanup_sbat_section_entries(n_section_entries, section_entries); |
8119f718 | 965 | cleanup_sbat_var(&sbat_var); |
031e5cce | 966 | |
8119f718 SM |
967 | return rc; |
968 | } | |
969 | ||
970 | int | |
971 | test_preserve_sbat_uefi_variable_good(void) | |
972 | { | |
e6ace38a SM |
973 | char sbat[] = "sbat,1,2021030218\ncomponent,2,\n"; |
974 | char sbatvar[] = "sbat,1,2021030218\ncomponent,2,\n"; | |
975 | size_t sbat_size = sizeof(sbat); | |
976 | UINT32 attributes = SBAT_VAR_ATTRS; | |
977 | ||
978 | if (preserve_sbat_uefi_variable(sbat, sbat_size, attributes, sbatvar)) | |
979 | return 0; | |
980 | else | |
981 | return -1; | |
982 | } | |
983 | ||
984 | int | |
985 | test_preserve_sbat_uefi_variable_version_newer(void) | |
986 | { | |
987 | char sbat[] = "sbat,2,2022030218\ncomponent,2,\n"; | |
988 | char sbatvar[] = "sbat,1,2021030218\ncomponent,2,\n"; | |
989 | size_t sbat_size = sizeof(sbat); | |
990 | UINT32 attributes = SBAT_VAR_ATTRS; | |
991 | ||
992 | if (preserve_sbat_uefi_variable(sbat, sbat_size, attributes, sbatvar)) | |
993 | return 0; | |
994 | else | |
995 | return -1; | |
996 | } | |
997 | ||
998 | int | |
999 | test_preserve_sbat_uefi_variable_version_newerlonger(void) | |
1000 | { | |
1001 | char sbat[] = "sbat,10,2022030218\ncomponent,2,\n"; | |
1002 | char sbatvar[] = "sbat,2,2021030218\ncomponent,2,\n"; | |
1003 | size_t sbat_size = sizeof(sbat); | |
1004 | UINT32 attributes = SBAT_VAR_ATTRS; | |
1005 | ||
1006 | if (preserve_sbat_uefi_variable(sbat, sbat_size, attributes, sbatvar)) | |
1007 | return 0; | |
1008 | else | |
1009 | return -1; | |
1010 | } | |
1011 | ||
1012 | int | |
1013 | test_preserve_sbat_uefi_variable_version_older(void) | |
1014 | { | |
1015 | char sbat[] = "sbat,1,2021030218\ncomponent,2,\n"; | |
1016 | char sbatvar[] = "sbat,2,2022030218\ncomponent,2,\n"; | |
1017 | size_t sbat_size = sizeof(sbat); | |
1018 | UINT32 attributes = SBAT_VAR_ATTRS; | |
1019 | ||
1020 | if (preserve_sbat_uefi_variable(sbat, sbat_size, attributes, sbatvar)) | |
1021 | return -1; | |
1022 | else | |
1023 | return 0; | |
1024 | } | |
1025 | ||
1026 | int | |
1027 | test_preserve_sbat_uefi_variable_version_olderlonger(void) | |
1028 | { | |
1029 | char sbat[] = "sbat,2,2021030218\ncomponent,2,\n"; | |
1030 | char sbatvar[] = "sbat,10,2022030218\ncomponent,2,\n"; | |
1031 | size_t sbat_size = sizeof(sbat); | |
1032 | UINT32 attributes = SBAT_VAR_ATTRS; | |
1033 | ||
1034 | if (preserve_sbat_uefi_variable(sbat, sbat_size, attributes, sbatvar)) | |
1035 | return -1; | |
1036 | else | |
1037 | return 0; | |
1038 | } | |
1039 | ||
1040 | ||
1041 | int | |
1042 | test_preserve_sbat_uefi_variable_newer(void) | |
1043 | { | |
1044 | char sbat[] = "sbat,1,2021030218\ncomponent,2,\n"; | |
1045 | char sbatvar[] = "sbat,1,2025030218\ncomponent,5,\ncomponent,3"; | |
1046 | size_t sbat_size = sizeof(sbat); | |
1047 | UINT32 attributes = SBAT_VAR_ATTRS; | |
1048 | ||
1049 | if (preserve_sbat_uefi_variable(sbat, sbat_size, attributes, sbatvar)) | |
1050 | return -1; | |
1051 | else | |
1052 | return 0; | |
1053 | } | |
1054 | int | |
1055 | test_preserve_sbat_uefi_variable_older(void) | |
1056 | { | |
1057 | char sbat[] = "sbat,1,2025030218\ncomponent,2,\ncomponent,3"; | |
1058 | char sbatvar[] = "sbat,1,2020030218\ncomponent,1,\n"; | |
8119f718 SM |
1059 | size_t sbat_size = sizeof(sbat); |
1060 | UINT32 attributes = SBAT_VAR_ATTRS; | |
1061 | ||
e6ace38a | 1062 | if (preserve_sbat_uefi_variable(sbat, sbat_size, attributes, sbatvar)) |
8119f718 SM |
1063 | return 0; |
1064 | else | |
1065 | return -1; | |
1066 | } | |
1067 | ||
1068 | int | |
1069 | test_preserve_sbat_uefi_variable_bad_sig(void) | |
1070 | { | |
e6ace38a SM |
1071 | char sbat[] = "bad_sig,1,2021030218\ncomponent,2,\n"; |
1072 | char sbatvar[] = "sbat,1,2021030218\n"; | |
8119f718 SM |
1073 | size_t sbat_size = sizeof(sbat); |
1074 | UINT32 attributes = SBAT_VAR_ATTRS; | |
1075 | ||
e6ace38a | 1076 | if (preserve_sbat_uefi_variable(sbat, sbat_size, attributes, sbatvar)) |
8119f718 SM |
1077 | return -1; |
1078 | else | |
1079 | return 0; | |
1080 | } | |
1081 | ||
1082 | int | |
1083 | test_preserve_sbat_uefi_variable_bad_attr(void) | |
1084 | { | |
e6ace38a SM |
1085 | char sbat[] = "sbat,1,2021030218\ncomponent,2,\n"; |
1086 | char sbatvar[] = "sbat,1,2021030218\n"; | |
8119f718 SM |
1087 | size_t sbat_size = sizeof(sbat); |
1088 | UINT32 attributes = 0; | |
1089 | ||
e6ace38a | 1090 | if (preserve_sbat_uefi_variable(sbat, sbat_size, attributes, sbatvar)) |
8119f718 SM |
1091 | return -1; |
1092 | else | |
1093 | return 0; | |
1094 | } | |
1095 | ||
1096 | int | |
1097 | test_preserve_sbat_uefi_variable_bad_short(void) | |
1098 | { | |
1099 | char sbat[] = "sba"; | |
e6ace38a | 1100 | char sbatvar[] = "sbat,1,2021030218\n"; |
8119f718 SM |
1101 | size_t sbat_size = sizeof(sbat); |
1102 | UINT32 attributes = SBAT_VAR_ATTRS; | |
1103 | ||
e6ace38a | 1104 | if (preserve_sbat_uefi_variable(sbat, sbat_size, attributes, sbatvar)) |
8119f718 SM |
1105 | return -1; |
1106 | else | |
1107 | return 0; | |
031e5cce SM |
1108 | } |
1109 | ||
1110 | int | |
1111 | main(void) | |
1112 | { | |
1113 | int status = 0; | |
1114 | // parse_sbat section tests | |
1115 | test(test_parse_sbat_section_null_sbat_base); | |
1116 | test(test_parse_sbat_section_zero_sbat_size); | |
1117 | test(test_parse_sbat_section_null_entries); | |
1118 | test(test_parse_sbat_section_null_count); | |
1119 | test(test_parse_sbat_section_no_newline); | |
1120 | test(test_parse_sbat_section_no_commas); | |
1121 | test(test_parse_sbat_section_too_few_elem); | |
1122 | test(test_parse_sbat_section_too_many_elem); | |
1123 | ||
1124 | // parse_sbat_var tests | |
1125 | test(test_parse_sbat_var_null_list); | |
1126 | test(test_parse_sbat_var_data_null_list); | |
1127 | test(test_parse_sbat_var_data_null_data); | |
1128 | test(test_parse_sbat_var_data_zero_size); | |
1129 | ||
1130 | // verify_sbat tests | |
1131 | test(test_verify_sbat_null_sbat_section); | |
1132 | #if 0 | |
1133 | test(test_verify_sbat_null_sbat_entries); | |
1134 | test(test_verify_sbat_match_one_exact); | |
1135 | test(test_verify_sbat_match_one_higher); | |
1136 | test(test_verify_sbat_reject_one); | |
1137 | test(test_verify_sbat_reject_many); | |
1138 | test(test_verify_sbat_match_many_higher); | |
1139 | test(test_verify_sbat_match_many_exact); | |
1140 | test(test_verify_sbat_reject_many_all); | |
1141 | test(test_verify_sbat_match_diff_name); | |
1142 | test(test_verify_sbat_match_diff_name_mixed); | |
1143 | test(test_verify_sbat_reject_diff_name_mixed); | |
1144 | #endif | |
1145 | test(test_parse_and_verify); | |
1146 | ||
8119f718 | 1147 | test(test_preserve_sbat_uefi_variable_good); |
e6ace38a SM |
1148 | test(test_preserve_sbat_uefi_variable_newer); |
1149 | test(test_preserve_sbat_uefi_variable_older); | |
8119f718 SM |
1150 | test(test_preserve_sbat_uefi_variable_bad_sig); |
1151 | test(test_preserve_sbat_uefi_variable_bad_attr); | |
1152 | test(test_preserve_sbat_uefi_variable_bad_short); | |
e6ace38a SM |
1153 | test(test_preserve_sbat_uefi_variable_version_newer); |
1154 | test(test_preserve_sbat_uefi_variable_version_newerlonger); | |
1155 | test(test_preserve_sbat_uefi_variable_version_older); | |
1156 | test(test_preserve_sbat_uefi_variable_version_olderlonger); | |
8119f718 | 1157 | |
031e5cce SM |
1158 | return 0; |
1159 | } | |
1160 | ||
1161 | // vim:fenc=utf-8:tw=75:noet |