1 /* Copyright (c) 2014 The Chromium OS Authors. All rights reserved.
2 * Use of this source code is governed by a BSD-style license that can be
3 * found in the LICENSE file.
4 *
5 * Tests for firmware 2common.c
6 */
7
8 #include "2sysincludes.h"
9 #include "2common.h"
10 #include "2rsa.h"
11 #include "vb2_common.h"
12 #include "host_fw_preamble2.h"
13 #include "host_key2.h"
14 #include "host_keyblock2.h"
15 #include "host_signature2.h"
16
17 #include "test_common.h"
18
19 static const uint8_t test_data[] = "This is some test data to sign.";
20 static const uint8_t test_data2[] = "Some more test data";
21 static const uint8_t test_data3[] = "Even more test data";
22
23 /*
24 * Test struct packing for vboot_struct.h structs which are passed between
25 * firmware and OS, or passed between different phases of firmware.
26 */
test_struct_packing(void)27 static void test_struct_packing(void)
28 {
29 /* Test new struct sizes */
30 TEST_EQ(EXPECTED_GUID_SIZE,
31 sizeof(struct vb2_guid),
32 "sizeof(vb2_guid)");
33 TEST_EQ(EXPECTED_VB2_STRUCT_COMMON_SIZE,
34 sizeof(struct vb2_struct_common),
35 "sizeof(vb2_struct_common)");
36 TEST_EQ(EXPECTED_VB2_PACKED_KEY_SIZE,
37 sizeof(struct vb2_packed_key),
38 "sizeof(vb2_packed_key)");
39 TEST_EQ(EXPECTED_VB2_SIGNATURE_SIZE,
40 sizeof(struct vb2_signature),
41 "sizeof(vb2_signature)");
42 TEST_EQ(EXPECTED_VB2_KEYBLOCK_SIZE,
43 sizeof(struct vb2_keyblock),
44 "sizeof(vb2_keyblock)");
45 TEST_EQ(EXPECTED_VB2_FW_PREAMBLE_SIZE,
46 sizeof(struct vb2_fw_preamble),
47 "sizeof(vb2_fw_preamble)");
48 }
49
50 /**
51 * Common header functions
52 */
test_common_header_functions(void)53 static void test_common_header_functions(void)
54 {
55 uint8_t cbuf[sizeof(struct vb2_struct_common) + 128];
56 uint8_t cbufgood[sizeof(cbuf)];
57 struct vb2_struct_common *c = (struct vb2_struct_common *)cbuf;
58 struct vb2_struct_common *c2;
59 const char test_desc[32] = "test desc";
60 uint32_t desc_end, m;
61
62 c->total_size = sizeof(cbuf);
63 c->fixed_size = sizeof(*c);
64 c->desc_size = sizeof(test_desc);
65 memcpy(cbuf + c->fixed_size, test_desc, sizeof(test_desc));
66 desc_end = c->fixed_size + c->desc_size;
67
68 c2 = (struct vb2_struct_common *)(cbuf + desc_end);
69 c2->total_size = c->total_size - desc_end;
70 c2->fixed_size = sizeof(*c2);
71 c2->desc_size = 0;
72
73 /* Description helper */
74 TEST_EQ(0, strcmp(vb2_common_desc(c), test_desc), "vb2_common_desc()");
75 TEST_EQ(0, strcmp(vb2_common_desc(c2), ""), "vb2_common_desc() empty");
76
77 TEST_SUCC(vb2_verify_common_header(cbuf, sizeof(cbuf)),
78 "vb2_verify_common_header() good");
79 memcpy(cbufgood, cbuf, sizeof(cbufgood));
80
81 memcpy(cbuf, cbufgood, sizeof(cbuf));
82 c->total_size += 4;
83 TEST_EQ(vb2_verify_common_header(cbuf, sizeof(cbuf)),
84 VB2_ERROR_COMMON_TOTAL_SIZE,
85 "vb2_verify_common_header() total size");
86
87 memcpy(cbuf, cbufgood, sizeof(cbuf));
88 c->fixed_size = c->total_size + 4;
89 TEST_EQ(vb2_verify_common_header(cbuf, sizeof(cbuf)),
90 VB2_ERROR_COMMON_FIXED_SIZE,
91 "vb2_verify_common_header() fixed size");
92
93 memcpy(cbuf, cbufgood, sizeof(cbuf));
94 c->desc_size = c->total_size - c->fixed_size + 4;
95 TEST_EQ(vb2_verify_common_header(cbuf, sizeof(cbuf)),
96 VB2_ERROR_COMMON_DESC_SIZE,
97 "vb2_verify_common_header() desc size");
98
99 memcpy(cbuf, cbufgood, sizeof(cbuf));
100 c->total_size--;
101 TEST_EQ(vb2_verify_common_header(cbuf, sizeof(cbuf)),
102 VB2_ERROR_COMMON_TOTAL_UNALIGNED,
103 "vb2_verify_common_header() total unaligned");
104
105 memcpy(cbuf, cbufgood, sizeof(cbuf));
106 c->fixed_size++;
107 TEST_EQ(vb2_verify_common_header(cbuf, sizeof(cbuf)),
108 VB2_ERROR_COMMON_FIXED_UNALIGNED,
109 "vb2_verify_common_header() fixed unaligned");
110
111 memcpy(cbuf, cbufgood, sizeof(cbuf));
112 c->desc_size--;
113 TEST_EQ(vb2_verify_common_header(cbuf, sizeof(cbuf)),
114 VB2_ERROR_COMMON_DESC_UNALIGNED,
115 "vb2_verify_common_header() desc unaligned");
116
117 memcpy(cbuf, cbufgood, sizeof(cbuf));
118 c->desc_size = -4;
119 TEST_EQ(vb2_verify_common_header(cbuf, sizeof(cbuf)),
120 VB2_ERROR_COMMON_DESC_WRAPS,
121 "vb2_verify_common_header() desc wraps");
122
123 memcpy(cbuf, cbufgood, sizeof(cbuf));
124 cbuf[desc_end - 1] = 1;
125 TEST_EQ(vb2_verify_common_header(cbuf, sizeof(cbuf)),
126 VB2_ERROR_COMMON_DESC_TERMINATOR,
127 "vb2_verify_common_header() desc not terminated");
128
129 /* Member checking function */
130 memcpy(cbuf, cbufgood, sizeof(cbuf));
131 m = 0;
132 TEST_SUCC(vb2_verify_common_member(cbuf, &m, c->total_size - 8, 4),
133 "vb2_verify_common_member()");
134 TEST_EQ(m, c->total_size - 4, " new minimum");
135
136 m = desc_end;
137 TEST_SUCC(vb2_verify_common_member(cbuf, &m, desc_end, 4),
138 "vb2_verify_common_member() good offset");
139 TEST_EQ(m, desc_end + 4, " new minimum");
140
141 m = 0;
142 TEST_EQ(vb2_verify_common_member(cbuf, &m, c->total_size - 8, -4),
143 VB2_ERROR_COMMON_MEMBER_WRAPS,
144 "vb2_verify_common_member() wraps");
145
146 m = 0;
147 TEST_EQ(vb2_verify_common_member(cbuf, &m, c->total_size - 7, 4),
148 VB2_ERROR_COMMON_MEMBER_UNALIGNED,
149 "vb2_verify_common_member() offset unaligned");
150
151 m = 0;
152 TEST_EQ(vb2_verify_common_member(cbuf, &m, c->total_size - 8, 5),
153 VB2_ERROR_COMMON_MEMBER_UNALIGNED,
154 "vb2_verify_common_member() size unaligned");
155
156 m = 0;
157 TEST_EQ(vb2_verify_common_member(cbuf, &m, desc_end - 4, 4),
158 VB2_ERROR_COMMON_MEMBER_OVERLAP,
159 "vb2_verify_common_member() overlap");
160
161 m = desc_end + 4;
162 TEST_EQ(vb2_verify_common_member(cbuf, &m, desc_end, 4),
163 VB2_ERROR_COMMON_MEMBER_OVERLAP,
164 "vb2_verify_common_member() overlap 2");
165
166 m = 0;
167 TEST_EQ(vb2_verify_common_member(cbuf, &m, c->total_size - 4, 8),
168 VB2_ERROR_COMMON_MEMBER_SIZE,
169 "vb2_verify_common_member() size");
170
171 /* Subobject checking */
172 m = 0;
173 TEST_SUCC(vb2_verify_common_subobject(cbuf, &m, desc_end),
174 "vb2_verify_common_subobject() good offset");
175 TEST_EQ(m, sizeof(cbuf), " new minimum");
176
177 m = desc_end + 4;
178 TEST_EQ(vb2_verify_common_subobject(cbuf, &m, desc_end),
179 VB2_ERROR_COMMON_MEMBER_OVERLAP,
180 "vb2_verify_common_subobject() overlap");
181
182 m = 0;
183 c2->total_size += 4;
184 TEST_EQ(vb2_verify_common_subobject(cbuf, &m, desc_end),
185 VB2_ERROR_COMMON_TOTAL_SIZE,
186 "vb2_verify_common_subobject() size");
187 }
188
189 /**
190 * Signature size
191 */
test_sig_size(void)192 static void test_sig_size(void)
193 {
194 TEST_EQ(vb2_sig_size(VB2_SIG_INVALID, VB2_HASH_SHA256), 0,
195 "vb2_sig_size() sig invalid");
196
197 TEST_EQ(vb2_sig_size(VB2_SIG_RSA2048, VB2_HASH_INVALID), 0,
198 "vb2_sig_size() hash invalid");
199
200 TEST_EQ(vb2_sig_size(VB2_SIG_RSA2048, VB2_HASH_SHA256), 2048 / 8,
201 "vb2_sig_size() RSA2048");
202 TEST_EQ(vb2_sig_size(VB2_SIG_RSA4096, VB2_HASH_SHA256), 4096 / 8,
203 "vb2_sig_size() RSA4096");
204 TEST_EQ(vb2_sig_size(VB2_SIG_RSA8192, VB2_HASH_SHA512), 8192 / 8,
205 "vb2_sig_size() RSA8192");
206
207 TEST_EQ(vb2_sig_size(VB2_SIG_NONE, VB2_HASH_SHA1),
208 VB2_SHA1_DIGEST_SIZE, "vb2_sig_size() SHA1");
209 TEST_EQ(vb2_sig_size(VB2_SIG_NONE, VB2_HASH_SHA256),
210 VB2_SHA256_DIGEST_SIZE, "vb2_sig_size() SHA256");
211 TEST_EQ(vb2_sig_size(VB2_SIG_NONE, VB2_HASH_SHA512),
212 VB2_SHA512_DIGEST_SIZE, "vb2_sig_size() SHA512");
213 }
214
215 /**
216 * Verify data on bare hash
217 */
test_verify_hash(void)218 static void test_verify_hash(void)
219 {
220 struct vb2_signature *sig;
221 const struct vb2_private_key *prik;
222 struct vb2_public_key pubk;
223 uint8_t workbuf[VB2_VERIFY_DATA_WORKBUF_BYTES]
224 __attribute__ ((aligned (VB2_WORKBUF_ALIGN)));
225 struct vb2_workbuf wb;
226
227 vb2_workbuf_init(&wb, workbuf, sizeof(workbuf));
228
229 TEST_SUCC(vb2_private_key_hash(&prik, VB2_HASH_SHA256),
230 "create private hash key");
231 TEST_SUCC(vb2_public_key_hash(&pubk, VB2_HASH_SHA256),
232 "create hash key");
233
234 /* Create the signature */
235 TEST_SUCC(vb2_sign_data(&sig, test_data, sizeof(test_data), prik, NULL),
236 "create hash sig");
237
238 TEST_SUCC(vb2_verify_data(test_data, sizeof(test_data),
239 sig, &pubk, &wb),
240 "vb2_verify_data() hash ok");
241
242 *((uint8_t *)sig + sig->sig_offset) ^= 0xab;
243 TEST_EQ(vb2_verify_data(test_data, sizeof(test_data), sig, &pubk, &wb),
244 VB2_ERROR_VDATA_VERIFY_DIGEST, "vb2_verify_data() hash bad");
245
246 free(sig);
247 }
248
249 /**
250 * Verify keyblock
251 */
test_verify_keyblock(void)252 static void test_verify_keyblock(void)
253 {
254 const char desc[16] = "test keyblock";
255 const struct vb2_private_key *prik[2];
256 struct vb2_public_key pubk, pubk2, pubk3;
257 struct vb2_signature *sig;
258 struct vb2_keyblock *kbuf;
259 uint32_t buf_size;
260 uint8_t *buf, *buf2;
261
262 uint8_t workbuf[VB2_KEY_BLOCK_VERIFY_WORKBUF_BYTES]
263 __attribute__ ((aligned (VB2_WORKBUF_ALIGN)));
264 struct vb2_workbuf wb;
265
266 TEST_SUCC(vb2_public_key_hash(&pubk, VB2_HASH_SHA256),
267 "create hash key 1");
268 TEST_SUCC(vb2_public_key_hash(&pubk2, VB2_HASH_SHA512),
269 "create hash key 2");
270 TEST_SUCC(vb2_public_key_hash(&pubk3, VB2_HASH_SHA1),
271 "create hash key 3");
272
273 TEST_SUCC(vb2_private_key_hash(prik + 0, VB2_HASH_SHA256),
274 "create private key 1");
275 TEST_SUCC(vb2_private_key_hash(prik + 1, VB2_HASH_SHA512),
276 "create private key 2");
277
278 /* Create the test keyblock */
279 TEST_SUCC(vb2_keyblock_create(&kbuf, &pubk3, prik, 2, 0x4321, desc),
280 "create keyblock");
281
282 buf = (uint8_t *)kbuf;
283 buf_size = kbuf->c.total_size;
284
285 /* Make a copy of the buffer, so we can mangle it for tests */
286 buf2 = malloc(buf_size);
287 memcpy(buf2, buf, buf_size);
288
289 vb2_workbuf_init(&wb, workbuf, sizeof(workbuf));
290 kbuf = (struct vb2_keyblock *)buf;
291
292 TEST_SUCC(vb2_verify_keyblock(kbuf, buf_size, &pubk, &wb),
293 "vb2_verify_keyblock()");
294
295 memcpy(buf, buf2, buf_size);
296 TEST_SUCC(vb2_verify_keyblock(kbuf, buf_size, &pubk2, &wb),
297 "vb2_verify_keyblock() key 2");
298
299 memcpy(buf, buf2, buf_size);
300 TEST_EQ(vb2_verify_keyblock(kbuf, buf_size, &pubk3, &wb),
301 VB2_ERROR_KEYBLOCK_SIG_GUID,
302 "vb2_verify_keyblock() key not present");
303
304 memcpy(buf, buf2, buf_size);
305 kbuf->c.magic = VB2_MAGIC_PACKED_KEY;
306 TEST_EQ(vb2_verify_keyblock(kbuf, buf_size, &pubk, &wb),
307 VB2_ERROR_KEYBLOCK_MAGIC,
308 "vb2_verify_keyblock() magic");
309
310 memcpy(buf, buf2, buf_size);
311 kbuf->c.fixed_size++;
312 TEST_EQ(vb2_verify_keyblock(kbuf, buf_size, &pubk, &wb),
313 VB2_ERROR_COMMON_FIXED_UNALIGNED,
314 "vb2_verify_keyblock() header");
315
316 memcpy(buf, buf2, buf_size);
317 kbuf->c.struct_version_major++;
318 TEST_EQ(vb2_verify_keyblock(kbuf, buf_size, &pubk, &wb),
319 VB2_ERROR_KEYBLOCK_HEADER_VERSION,
320 "vb2_verify_keyblock() major version");
321
322 memcpy(buf, buf2, buf_size);
323 kbuf->c.struct_version_minor++;
324 /* That changes the signature, so resign the keyblock */
325 vb2_sign_data(&sig, buf, kbuf->sig_offset, prik[0], NULL);
326 memcpy(buf + kbuf->sig_offset, sig, sig->c.total_size);
327 free(sig);
328 TEST_SUCC(vb2_verify_keyblock(kbuf, buf_size, &pubk, &wb),
329 "vb2_verify_keyblock() minor version");
330
331 memcpy(buf, buf2, buf_size);
332 kbuf->c.fixed_size -= 4;
333 kbuf->c.desc_size += 4;
334 TEST_EQ(vb2_verify_keyblock(kbuf, buf_size, &pubk, &wb),
335 VB2_ERROR_KEYBLOCK_SIZE,
336 "vb2_verify_keyblock() header size");
337
338 memcpy(buf, buf2, buf_size);
339 kbuf->key_offset = kbuf->c.total_size - 4;
340 TEST_EQ(vb2_verify_keyblock(kbuf, buf_size, &pubk, &wb),
341 VB2_ERROR_COMMON_MEMBER_SIZE,
342 "vb2_verify_keyblock() data key outside");
343
344 memcpy(buf, buf2, buf_size);
345 sig = (struct vb2_signature *)(buf + kbuf->sig_offset);
346 sig->data_size--;
347 TEST_EQ(vb2_verify_keyblock(kbuf, buf_size, &pubk, &wb),
348 VB2_ERROR_KEYBLOCK_SIGNED_SIZE,
349 "vb2_verify_keyblock() signed wrong size");
350
351 memcpy(buf, buf2, buf_size);
352 sig = (struct vb2_signature *)(buf + kbuf->sig_offset);
353 sig->c.total_size = kbuf->c.total_size - 4;
354 TEST_EQ(vb2_verify_keyblock(kbuf, buf_size, &pubk, &wb),
355 VB2_ERROR_COMMON_TOTAL_SIZE,
356 "vb2_verify_keyblock() key outside keyblock");
357
358 memcpy(buf, buf2, buf_size);
359 sig = (struct vb2_signature *)(buf + kbuf->sig_offset);
360 sig->c.struct_version_major++;
361 TEST_EQ(vb2_verify_keyblock(kbuf, buf_size, &pubk, &wb),
362 VB2_ERROR_SIG_VERSION,
363 "vb2_verify_keyblock() corrupt key");
364
365 memcpy(buf, buf2, buf_size);
366 kbuf->c.struct_version_minor++;
367 TEST_EQ(vb2_verify_keyblock(kbuf, buf_size, &pubk, &wb),
368 VB2_ERROR_VDATA_VERIFY_DIGEST,
369 "vb2_verify_keyblock() corrupt");
370
371 free(buf);
372 free(buf2);
373 }
374
375 /**
376 * Verify firmware preamble
377 */
test_verify_fw_preamble(void)378 static void test_verify_fw_preamble(void)
379 {
380 const char desc[16] = "test preamble";
381 const struct vb2_private_key *prikhash;
382 struct vb2_signature *hashes[3];
383 struct vb2_public_key pubk;
384 struct vb2_signature *sig;
385 struct vb2_fw_preamble *pre;
386 uint32_t buf_size;
387 uint8_t *buf, *buf2;
388
389 uint8_t workbuf[VB2_VERIFY_FIRMWARE_PREAMBLE_WORKBUF_BYTES]
390 __attribute__ ((aligned (VB2_WORKBUF_ALIGN)));
391 struct vb2_workbuf wb;
392
393 /*
394 * Preambles will usually be signed with a real key not a bare hash,
395 * but the call to vb2_verify_data() inside the preamble check is the
396 * same (and its functionality is verified separately), and using a
397 * bare hash here saves us from needing to have a private key to do
398 * this test.
399 */
400 TEST_SUCC(vb2_public_key_hash(&pubk, VB2_HASH_SHA256),
401 "create hash key");
402 TEST_SUCC(vb2_private_key_hash(&prikhash, VB2_HASH_SHA256),
403 "Create private hash key");
404
405 /* Create some signatures */
406 TEST_SUCC(vb2_sign_data(hashes + 0, test_data, sizeof(test_data),
407 prikhash, "Hash 1"),
408 "Hash 1");
409 TEST_SUCC(vb2_sign_data(hashes + 1, test_data2, sizeof(test_data2),
410 prikhash, "Hash 2"),
411 "Hash 2");
412 TEST_SUCC(vb2_sign_data(hashes + 2, test_data3, sizeof(test_data3),
413 prikhash, "Hash 3"),
414 "Hash 3");
415
416 /* Test good preamble */
417 TEST_SUCC(vb2_fw_preamble_create(&pre, prikhash,
418 (const struct vb2_signature **)hashes,
419 3, 0x1234, 0x5678, desc),
420 "Create preamble good");
421
422 buf = (uint8_t *)pre;
423 buf_size = pre->c.total_size;
424
425 /* Make a copy of the buffer, so we can mangle it for tests */
426 buf2 = malloc(buf_size);
427 memcpy(buf2, buf, buf_size);
428
429 vb2_workbuf_init(&wb, workbuf, sizeof(workbuf));
430 pre = (struct vb2_fw_preamble *)buf;
431
432 TEST_SUCC(vb2_verify_fw_preamble(pre, buf_size, &pubk, &wb),
433 "vb2_verify_fw_preamble()");
434
435 memcpy(buf, buf2, buf_size);
436 pre->c.magic = VB2_MAGIC_PACKED_KEY;
437 TEST_EQ(vb2_verify_fw_preamble(pre, buf_size, &pubk, &wb),
438 VB2_ERROR_PREAMBLE_MAGIC,
439 "vb2_verify_fw_preamble() magic");
440
441 memcpy(buf, buf2, buf_size);
442 pre->c.fixed_size++;
443 TEST_EQ(vb2_verify_fw_preamble(pre, buf_size, &pubk, &wb),
444 VB2_ERROR_COMMON_FIXED_UNALIGNED,
445 "vb2_verify_fw_preamble() header");
446
447 memcpy(buf, buf2, buf_size);
448 pre->c.struct_version_major++;
449 TEST_EQ(vb2_verify_fw_preamble(pre, buf_size, &pubk, &wb),
450 VB2_ERROR_PREAMBLE_HEADER_VERSION,
451 "vb2_verify_fw_preamble() major version");
452
453 memcpy(buf, buf2, buf_size);
454 pre->c.struct_version_minor++;
455 /* That changes the signature, so resign the fw_preamble */
456 vb2_sign_data(&sig, buf, pre->sig_offset, prikhash, NULL);
457 memcpy(buf + pre->sig_offset, sig, sig->c.total_size);
458 free(sig);
459 TEST_SUCC(vb2_verify_fw_preamble(pre, buf_size, &pubk, &wb),
460 "vb2_verify_fw_preamble() minor version");
461
462 memcpy(buf, buf2, buf_size);
463 pre->c.fixed_size -= 4;
464 pre->c.desc_size += 4;
465 TEST_EQ(vb2_verify_fw_preamble(pre, buf_size, &pubk, &wb),
466 VB2_ERROR_PREAMBLE_SIZE,
467 "vb2_verify_fw_preamble() header size");
468
469 memcpy(buf, buf2, buf_size);
470 sig = (struct vb2_signature *)(buf + pre->hash_offset);
471 sig->c.total_size += pre->c.total_size;
472 TEST_EQ(vb2_verify_fw_preamble(pre, buf_size, &pubk, &wb),
473 VB2_ERROR_COMMON_TOTAL_SIZE,
474 "vb2_verify_fw_preamble() hash size");
475
476 memcpy(buf, buf2, buf_size);
477 sig = (struct vb2_signature *)(buf + pre->hash_offset);
478 sig->sig_size /= 2;
479 TEST_EQ(vb2_verify_fw_preamble(pre, buf_size, &pubk, &wb),
480 VB2_ERROR_SIG_SIZE,
481 "vb2_verify_fw_preamble() hash integrity");
482
483 memcpy(buf, buf2, buf_size);
484 pre->hash_count++;
485 TEST_EQ(vb2_verify_fw_preamble(pre, buf_size, &pubk, &wb),
486 VB2_ERROR_COMMON_MEMBER_OVERLAP,
487 "vb2_verify_fw_preamble() hash count");
488
489 memcpy(buf, buf2, buf_size);
490 sig = (struct vb2_signature *)(buf + pre->sig_offset);
491 sig->c.total_size += 4;
492 TEST_EQ(vb2_verify_fw_preamble(pre, buf_size, &pubk, &wb),
493 VB2_ERROR_COMMON_TOTAL_SIZE,
494 "vb2_verify_fw_preamble() sig inside");
495
496 memcpy(buf, buf2, buf_size);
497 sig = (struct vb2_signature *)(buf + pre->sig_offset);
498 buf[pre->sig_offset + sig->sig_offset]++;
499 TEST_EQ(vb2_verify_fw_preamble(pre, buf_size, &pubk, &wb),
500 VB2_ERROR_VDATA_VERIFY_DIGEST,
501 "vb2_verify_fw_preamble() sig corrupt");
502
503 memcpy(buf, buf2, buf_size);
504 pre->flags++;
505 TEST_EQ(vb2_verify_fw_preamble(pre, buf_size, &pubk, &wb),
506 VB2_ERROR_VDATA_VERIFY_DIGEST,
507 "vb2_verify_fw_preamble() preamble corrupt");
508
509 free(buf);
510 free(buf2);
511 }
512
main(int argc,char * argv[])513 int main(int argc, char* argv[])
514 {
515 test_struct_packing();
516 test_common_header_functions();
517 test_sig_size();
518 test_verify_hash();
519 test_verify_keyblock();
520 test_verify_fw_preamble();
521
522 return gTestSuccess ? 0 : 255;
523 }
524