1 /* Copyright 2014 The ChromiumOS Authors
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 api.c
6 */
7
8 #include <stdio.h>
9
10 #include "2api.h"
11 #include "2common.h"
12 #include "2misc.h"
13 #include "2nvstorage.h"
14 #include "2rsa.h"
15 #include "2secdata.h"
16 #include "2sysincludes.h"
17 #include "common/tests.h"
18
19 /* Common context for tests */
20
21 static uint8_t workbuf[VB2_FIRMWARE_WORKBUF_RECOMMENDED_SIZE]
22 __attribute__((aligned(VB2_WORKBUF_ALIGN)));
23 static struct vb2_context *ctx;
24 static struct vb2_shared_data *sd;
25 static struct vb2_gbb_header gbb;
26
27 const char mock_body[320] = "Mock body";
28 const int mock_body_size = sizeof(mock_body);
29 const int mock_algorithm = VB2_ALG_RSA2048_SHA256;
30 const int mock_hash_alg = VB2_HASH_SHA256;
31 static const uint8_t mock_hwid_digest[VB2_GBB_HWID_DIGEST_SIZE] = {
32 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
33 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
34 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
35 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
36 };
37 const int mock_sig_size = 64;
38 static uint8_t digest_result[VB2_SHA256_DIGEST_SIZE];
39 static const uint32_t digest_result_size = sizeof(digest_result);
40
41 static const struct vb2_hash mock_mhash = {
42 .algo = VB2_HASH_SHA256,
43 .sha256 = {
44 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
45 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
46 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
47 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
48 },
49 };
50
51 /* Mocked function data */
52
53 static int force_dev_mode;
54 static vb2_error_t retval_vb2_fw_init_gbb;
55 static vb2_error_t retval_vb2_check_dev_switch;
56 static vb2_error_t retval_vb2_check_tpm_clear;
57 static vb2_error_t retval_vb2_select_fw_slot;
58 static vb2_error_t retval_vb2_load_fw_keyblock;
59 static vb2_error_t retval_vb2_load_fw_preamble;
60 static vb2_error_t retval_vb2_digest_finalize;
61 static vb2_error_t retval_vb2_verify_digest;
62
63 /* Type of test to reset for */
64
65 enum reset_type {
66 FOR_MISC,
67 FOR_EXTEND_HASH,
68 FOR_CHECK_HASH,
69 FOR_METADATA_HASH,
70 };
71
reset_common_data(enum reset_type t)72 static void reset_common_data(enum reset_type t)
73 {
74 struct vb2_fw_preamble *pre;
75 struct vb2_packed_key *k;
76
77 memset(workbuf, 0xaa, sizeof(workbuf));
78
79 TEST_SUCC(vb2api_init(workbuf, sizeof(workbuf), &ctx),
80 "vb2api_init failed");
81 sd = vb2_get_sd(ctx);
82
83 vb2_nv_init(ctx);
84
85 vb2api_secdata_firmware_create(ctx);
86
87 vb2api_secdata_kernel_create(ctx);
88 vb2_secdata_kernel_init(ctx);
89
90 force_dev_mode = 0;
91 retval_vb2_fw_init_gbb = VB2_SUCCESS;
92 retval_vb2_check_dev_switch = VB2_SUCCESS;
93 retval_vb2_check_tpm_clear = VB2_SUCCESS;
94 retval_vb2_select_fw_slot = VB2_SUCCESS;
95 retval_vb2_load_fw_keyblock = VB2_SUCCESS;
96 retval_vb2_load_fw_preamble = VB2_SUCCESS;
97 retval_vb2_digest_finalize = VB2_SUCCESS;
98 retval_vb2_verify_digest = VB2_SUCCESS;
99
100 memcpy(&gbb.hwid_digest, mock_hwid_digest,
101 sizeof(gbb.hwid_digest));
102
103 sd->preamble_offset = sd->workbuf_used;
104 sd->preamble_size = sizeof(*pre);
105 vb2_set_workbuf_used(ctx, sd->preamble_offset + sd->preamble_size);
106 pre = vb2_member_of(sd, sd->preamble_offset);
107 sd->fw_version = 0x00030004U;
108 sd->kernel_version = 0x00010002U;
109
110 if (t == FOR_METADATA_HASH) {
111 struct vb2_hash *mhash;
112 pre->body_signature.data_size = 0;
113 pre->body_signature.sig_size = offsetof(struct vb2_hash, raw) +
114 vb2_digest_size(mock_mhash.algo);
115 pre->body_signature.sig_offset =
116 vb2_offset_of(&pre->body_signature,
117 vb2_member_of(sd, sd->workbuf_used));
118 pre->flags = 0;
119 mhash = vb2_member_of(sd, sd->workbuf_used);
120 vb2_set_workbuf_used(ctx, pre->body_signature.sig_size);
121 memcpy(mhash, &mock_mhash, pre->body_signature.sig_size);
122 } else {
123 pre->body_signature.data_size = mock_body_size;
124 pre->body_signature.sig_size = mock_sig_size;
125 pre->flags = 0;
126
127 sd->data_key_offset = sd->workbuf_used;
128 sd->data_key_size = sizeof(*k) + 8;
129 vb2_set_workbuf_used(ctx,
130 sd->data_key_offset + sd->data_key_size);
131 k = vb2_member_of(sd, sd->data_key_offset);
132 k->algorithm = mock_algorithm;
133 }
134
135 if (t == FOR_EXTEND_HASH || t == FOR_CHECK_HASH)
136 vb2api_init_hash(ctx, VB2_HASH_TAG_FW_BODY);
137
138 if (t == FOR_CHECK_HASH)
139 vb2api_extend_hash(ctx, mock_body, mock_body_size);
140
141 /* Always clear out the digest result. */
142 memset(digest_result, 0, digest_result_size);
143 };
144
145 /* Mocked functions */
vb2_get_gbb(struct vb2_context * c)146 struct vb2_gbb_header *vb2_get_gbb(struct vb2_context *c)
147 {
148 return &gbb;
149 }
150
vb2_fw_init_gbb(struct vb2_context * c)151 vb2_error_t vb2_fw_init_gbb(struct vb2_context *c)
152 {
153 return retval_vb2_fw_init_gbb;
154 }
155
vb2_check_dev_switch(struct vb2_context * c)156 vb2_error_t vb2_check_dev_switch(struct vb2_context *c)
157 {
158 if (force_dev_mode) {
159 c->flags |= VB2_CONTEXT_DEVELOPER_MODE;
160 sd->flags |= VB2_SD_FLAG_DEV_MODE_ENABLED;
161 }
162 return retval_vb2_check_dev_switch;
163 }
164
vb2_check_tpm_clear(struct vb2_context * c)165 vb2_error_t vb2_check_tpm_clear(struct vb2_context *c)
166 {
167 return retval_vb2_check_tpm_clear;
168 }
169
vb2_select_fw_slot(struct vb2_context * c)170 vb2_error_t vb2_select_fw_slot(struct vb2_context *c)
171 {
172 return retval_vb2_select_fw_slot;
173 }
174
vb2_load_fw_keyblock(struct vb2_context * c)175 vb2_error_t vb2_load_fw_keyblock(struct vb2_context *c)
176 {
177 return retval_vb2_load_fw_keyblock;
178 }
179
vb2_load_fw_preamble(struct vb2_context * c)180 vb2_error_t vb2_load_fw_preamble(struct vb2_context *c)
181 {
182 return retval_vb2_load_fw_preamble;
183 }
184
vb2_unpack_key_buffer(struct vb2_public_key * key,const uint8_t * buf,uint32_t size)185 vb2_error_t vb2_unpack_key_buffer(struct vb2_public_key *key,
186 const uint8_t *buf, uint32_t size)
187 {
188 struct vb2_packed_key *k = (struct vb2_packed_key *)buf;
189
190 if (size != sizeof(*k) + 8)
191 return VB2_ERROR_UNPACK_KEY_SIZE;
192
193 key->sig_alg = vb2_crypto_to_signature(k->algorithm);
194 key->hash_alg = vb2_crypto_to_hash(k->algorithm);
195
196 return VB2_SUCCESS;
197 }
198
fill_digest(uint8_t * digest,uint32_t digest_size)199 static void fill_digest(uint8_t *digest, uint32_t digest_size)
200 {
201 /* Set the result to a known value. */
202 memset(digest, 0x0a, digest_size);
203 }
204
vb2_digest_init(struct vb2_digest_context * dc,bool allow_hwcrypto,enum vb2_hash_algorithm algo,uint32_t data_size)205 vb2_error_t vb2_digest_init(struct vb2_digest_context *dc, bool allow_hwcrypto,
206 enum vb2_hash_algorithm algo, uint32_t data_size)
207 {
208 if (algo != mock_hash_alg)
209 return VB2_ERROR_SHA_INIT_ALGORITHM;
210
211 dc->hash_alg = algo;
212 dc->using_hwcrypto = 0;
213
214 return VB2_SUCCESS;
215 }
216
vb2_digest_extend(struct vb2_digest_context * dc,const uint8_t * buf,uint32_t size)217 vb2_error_t vb2_digest_extend(struct vb2_digest_context *dc, const uint8_t *buf,
218 uint32_t size)
219 {
220 if (dc->hash_alg != mock_hash_alg)
221 return VB2_ERROR_SHA_EXTEND_ALGORITHM;
222
223 return VB2_SUCCESS;
224 }
225
vb2_digest_finalize(struct vb2_digest_context * dc,uint8_t * digest,uint32_t digest_size)226 vb2_error_t vb2_digest_finalize(struct vb2_digest_context *dc, uint8_t *digest,
227 uint32_t digest_size)
228 {
229 if (retval_vb2_digest_finalize == VB2_SUCCESS)
230 fill_digest(digest, digest_size);
231
232 return retval_vb2_digest_finalize;
233 }
234
vb2_rsa_sig_size(enum vb2_signature_algorithm sig_alg)235 uint32_t vb2_rsa_sig_size(enum vb2_signature_algorithm sig_alg)
236 {
237 return mock_sig_size;
238 }
239
240 static struct vb2_public_key last_used_key;
241
vb2_rsa_verify_digest(const struct vb2_public_key * key,uint8_t * sig,const uint8_t * digest,const struct vb2_workbuf * wb)242 vb2_error_t vb2_rsa_verify_digest(const struct vb2_public_key *key,
243 uint8_t *sig, const uint8_t *digest,
244 const struct vb2_workbuf *wb)
245 {
246 memcpy(&last_used_key, key, sizeof(struct vb2_public_key));
247 return retval_vb2_verify_digest;
248 }
249
250 /* Tests */
251 static int vb2_try_returned;
252
call_vb2_try(vb2_error_t expr,uint8_t recovery_reason,int one_arg)253 static vb2_error_t call_vb2_try(vb2_error_t expr, uint8_t recovery_reason,
254 int one_arg)
255 {
256 vb2_try_returned = 1;
257 if (one_arg)
258 VB2_TRY(expr);
259 else
260 VB2_TRY(expr, ctx, recovery_reason);
261 vb2_try_returned = 0;
262 return VB2_SUCCESS;
263 }
264
misc_tests(void)265 static void misc_tests(void)
266 {
267 /* Test secdata_firmware passthru functions */
268 reset_common_data(FOR_MISC);
269 /* Corrupt secdata_firmware so initial check will fail */
270 ctx->secdata_firmware[0] ^= 0x42;
271 TEST_EQ(vb2api_secdata_firmware_check(ctx),
272 VB2_ERROR_SECDATA_FIRMWARE_CRC,
273 "secdata_firmware check");
274 TEST_EQ(vb2api_secdata_firmware_create(ctx), VB2_SECDATA_FIRMWARE_SIZE,
275 "secdata_firmware create");
276 TEST_SUCC(vb2api_secdata_firmware_check(ctx),
277 "secdata_firmware check 2");
278
279 /* Test get_firmware_size() */
280 reset_common_data(FOR_MISC);
281 TEST_EQ(vb2api_get_firmware_size(ctx), mock_body_size, "firmware_size");
282
283 reset_common_data(FOR_MISC);
284 sd->preamble_size = 0;
285 TEST_ABORT(vb2api_get_firmware_size(ctx), "firmware_size too early");
286
287 /* Test VB2_TRY() */
288 reset_common_data(FOR_MISC);
289 call_vb2_try(VB2_SUCCESS, VB2_RECOVERY_NOT_REQUESTED, 1);
290 TEST_EQ(vb2_try_returned, 0, "VB2_TRY(expr) success");
291 TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
292 VB2_RECOVERY_NOT_REQUESTED, " vb2api_fail no request");
293
294 reset_common_data(FOR_MISC);
295 call_vb2_try(VB2_REQUEST, VB2_RECOVERY_NOT_REQUESTED, 1);
296 TEST_EQ(vb2_try_returned, 1, "VB2_TRY(expr) request");
297 TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
298 VB2_RECOVERY_NOT_REQUESTED, " vb2api_fail no request");
299
300 reset_common_data(FOR_MISC);
301 call_vb2_try(VB2_ERROR_MOCK, VB2_RECOVERY_NOT_REQUESTED, 1);
302 TEST_EQ(vb2_try_returned, 1, "VB2_TRY(expr) error");
303 TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
304 VB2_RECOVERY_NOT_REQUESTED, " vb2api_fail no request");
305
306 reset_common_data(FOR_MISC);
307 call_vb2_try(VB2_SUCCESS, 123, 0);
308 TEST_EQ(vb2_try_returned, 0, "VB2_TRY(expr, ...) success");
309 TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
310 VB2_RECOVERY_NOT_REQUESTED, " vb2api_fail no request");
311 TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_SUBCODE),
312 0, " vb2api_fail no subcode");
313
314 reset_common_data(FOR_MISC);
315 call_vb2_try(VB2_REQUEST, 123, 0);
316 TEST_EQ(vb2_try_returned, 1, "VB2_TRY(expr, ...) request");
317 TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
318 VB2_RECOVERY_NOT_REQUESTED, " vb2api_fail no request");
319 TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_SUBCODE),
320 0, " vb2api_fail no subcode");
321
322 reset_common_data(FOR_MISC);
323 call_vb2_try(VB2_ERROR_MOCK, 123, 0);
324 TEST_EQ(vb2_try_returned, 1, "VB2_TRY(expr, ...) error");
325 TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
326 123, " vb2api_fail request");
327 TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_SUBCODE),
328 VB2_ERROR_MOCK & 0xff, " vb2api_fail subcode");
329 }
330
phase1_tests(void)331 static void phase1_tests(void)
332 {
333 reset_common_data(FOR_MISC);
334 TEST_SUCC(vb2api_fw_phase1(ctx), "phase1 good");
335 TEST_EQ(sd->recovery_reason, 0, " not recovery");
336 TEST_EQ(ctx->flags & VB2_CONTEXT_RECOVERY_MODE, 0, " recovery flag");
337 TEST_EQ(ctx->flags & VB2_CONTEXT_CLEAR_RAM, 0, " clear ram flag");
338 TEST_EQ(ctx->flags & VB2_CONTEXT_DISPLAY_INIT,
339 0, " display init context flag");
340 TEST_EQ(sd->flags & VB2_SD_FLAG_DISPLAY_AVAILABLE,
341 0, " display available SD flag");
342 TEST_NEQ(sd->status & VB2_SD_STATUS_SECDATA_FIRMWARE_INIT,
343 0, " secdata firmware initialized");
344 TEST_NEQ(sd->status & VB2_SD_STATUS_SECDATA_KERNEL_INIT,
345 0, " secdata kernel initialized");
346 TEST_NEQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
347 0, " recovery decided");
348
349 reset_common_data(FOR_MISC);
350 retval_vb2_fw_init_gbb = VB2_ERROR_GBB_MAGIC;
351 TEST_EQ(vb2api_fw_phase1(ctx), VB2_ERROR_API_PHASE1_RECOVERY,
352 "phase1 gbb");
353 TEST_EQ(sd->recovery_reason, VB2_RECOVERY_GBB_HEADER,
354 " recovery reason");
355 TEST_NEQ(ctx->flags & VB2_CONTEXT_RECOVERY_MODE, 0, " recovery flag");
356 TEST_NEQ(ctx->flags & VB2_CONTEXT_CLEAR_RAM, 0, " clear ram flag");
357 TEST_NEQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
358 0, " recovery decided");
359
360 /* Dev switch error proceeds to a recovery boot */
361 reset_common_data(FOR_MISC);
362 retval_vb2_check_dev_switch = VB2_ERROR_MOCK;
363 TEST_EQ(vb2api_fw_phase1(ctx), VB2_ERROR_API_PHASE1_RECOVERY,
364 "phase1 dev switch error proceeds to recovery");
365 TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
366 VB2_RECOVERY_DEV_SWITCH, " recovery request");
367 TEST_EQ(sd->recovery_reason, VB2_RECOVERY_DEV_SWITCH,
368 " recovery reason");
369 /* Check that DISPLAY_AVAILABLE gets set on recovery mode. */
370 TEST_NEQ(ctx->flags & VB2_CONTEXT_DISPLAY_INIT,
371 0, " display init context flag");
372 TEST_NEQ(sd->flags & VB2_SD_FLAG_DISPLAY_AVAILABLE,
373 0, " display available SD flag");
374 TEST_NEQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
375 0, " recovery decided");
376
377 reset_common_data(FOR_MISC);
378 ctx->secdata_firmware[0] ^= 0x42;
379 TEST_EQ(vb2api_fw_phase1(ctx), VB2_ERROR_API_PHASE1_RECOVERY,
380 "phase1 secdata_firmware");
381 TEST_EQ(sd->recovery_reason, VB2_RECOVERY_SECDATA_FIRMWARE_INIT,
382 " recovery reason");
383 TEST_NEQ(ctx->flags & VB2_CONTEXT_RECOVERY_MODE, 0, " recovery flag");
384 TEST_NEQ(ctx->flags & VB2_CONTEXT_CLEAR_RAM, 0, " clear ram flag");
385 TEST_NEQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
386 0, " recovery decided");
387
388 /* Bad secdata_kernel causes recovery mode */
389 reset_common_data(FOR_MISC);
390 ctx->secdata_kernel[2] ^= 0x42; /* 3rd byte is CRC */
391 TEST_EQ(vb2api_fw_phase1(ctx), VB2_ERROR_API_PHASE1_RECOVERY,
392 "phase1 bad secdata_kernel");
393 TEST_EQ(sd->recovery_reason, VB2_RECOVERY_SECDATA_KERNEL_INIT,
394 " recovery reason");
395 TEST_NEQ(ctx->flags & VB2_CONTEXT_RECOVERY_MODE, 0, " recovery flag");
396 TEST_NEQ(ctx->flags & VB2_CONTEXT_CLEAR_RAM, 0, " clear ram flag");
397 TEST_NEQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
398 0, " recovery decided");
399
400 /* Test secdata_firmware-requested reboot */
401 reset_common_data(FOR_MISC);
402 ctx->flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT;
403 TEST_EQ(vb2api_fw_phase1(ctx), VB2_ERROR_API_PHASE1_SECDATA_REBOOT,
404 "phase1 secdata_firmware reboot normal");
405 TEST_EQ(sd->recovery_reason, 0, " recovery reason");
406 TEST_EQ(vb2_nv_get(ctx, VB2_NV_TPM_REQUESTED_REBOOT),
407 1, " tpm reboot request");
408 TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
409 0, " recovery request");
410 TEST_EQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
411 0, " recovery decided");
412
413 reset_common_data(FOR_MISC);
414 vb2_nv_set(ctx, VB2_NV_TPM_REQUESTED_REBOOT, 1);
415 TEST_SUCC(vb2api_fw_phase1(ctx),
416 "phase1 secdata_firmware reboot back normal");
417 TEST_EQ(sd->recovery_reason, 0, " recovery reason");
418 TEST_EQ(vb2_nv_get(ctx, VB2_NV_TPM_REQUESTED_REBOOT),
419 0, " tpm reboot request");
420 TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
421 0, " recovery request");
422 TEST_NEQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
423 0, " recovery decided");
424
425 reset_common_data(FOR_MISC);
426 ctx->flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT;
427 memset(ctx->secdata_firmware, 0, sizeof(ctx->secdata_firmware));
428 TEST_EQ(vb2api_fw_phase1(ctx), VB2_ERROR_API_PHASE1_SECDATA_REBOOT,
429 "phase1 secdata_firmware reboot normal, "
430 "secdata_firmware blank");
431 TEST_EQ(sd->recovery_reason, 0, " recovery reason");
432 TEST_EQ(vb2_nv_get(ctx, VB2_NV_TPM_REQUESTED_REBOOT),
433 1, " tpm reboot request");
434 TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
435 0, " recovery request");
436 TEST_EQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
437 0, " recovery decided");
438
439 reset_common_data(FOR_MISC);
440 ctx->flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT;
441 vb2_nv_set(ctx, VB2_NV_TPM_REQUESTED_REBOOT, 1);
442 TEST_EQ(vb2api_fw_phase1(ctx), VB2_ERROR_API_PHASE1_RECOVERY,
443 "phase1 secdata_firmware reboot normal again");
444 TEST_EQ(sd->recovery_reason, VB2_RECOVERY_RO_TPM_REBOOT,
445 " recovery reason");
446 TEST_EQ(vb2_nv_get(ctx, VB2_NV_TPM_REQUESTED_REBOOT),
447 1, " tpm reboot request");
448 TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
449 VB2_RECOVERY_RO_TPM_REBOOT, " recovery request");
450 TEST_NEQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
451 0, " recovery decided");
452
453 reset_common_data(FOR_MISC);
454 ctx->flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT;
455 vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST, VB2_RECOVERY_RO_UNSPECIFIED);
456 TEST_EQ(vb2api_fw_phase1(ctx), VB2_ERROR_API_PHASE1_SECDATA_REBOOT,
457 "phase1 secdata_firmware reboot recovery");
458 /* Recovery reason isn't set this boot because we're rebooting first */
459 TEST_EQ(sd->recovery_reason, 0, " recovery reason not set THIS boot");
460 TEST_EQ(vb2_nv_get(ctx, VB2_NV_TPM_REQUESTED_REBOOT),
461 1, " tpm reboot request");
462 TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
463 VB2_RECOVERY_RO_UNSPECIFIED, " recovery request");
464 TEST_EQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
465 0, " recovery decided");
466
467 reset_common_data(FOR_MISC);
468 vb2_nv_set(ctx, VB2_NV_TPM_REQUESTED_REBOOT, 1);
469 vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST, VB2_RECOVERY_RO_UNSPECIFIED);
470 TEST_EQ(vb2api_fw_phase1(ctx), VB2_ERROR_API_PHASE1_RECOVERY,
471 "phase1 secdata_firmware reboot back recovery");
472 TEST_EQ(sd->recovery_reason, VB2_RECOVERY_RO_UNSPECIFIED,
473 " recovery reason");
474 TEST_EQ(vb2_nv_get(ctx, VB2_NV_TPM_REQUESTED_REBOOT),
475 0, " tpm reboot request");
476 TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
477 VB2_RECOVERY_RO_UNSPECIFIED, " recovery request");
478 TEST_NEQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
479 0, " recovery decided");
480
481 reset_common_data(FOR_MISC);
482 ctx->flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT;
483 vb2_nv_set(ctx, VB2_NV_TPM_REQUESTED_REBOOT, 1);
484 vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST, VB2_RECOVERY_RO_UNSPECIFIED);
485 TEST_EQ(vb2api_fw_phase1(ctx), VB2_ERROR_API_PHASE1_RECOVERY,
486 "phase1 secdata_firmware reboot recovery again");
487 TEST_EQ(sd->recovery_reason, VB2_RECOVERY_RO_UNSPECIFIED,
488 " recovery reason");
489 TEST_EQ(vb2_nv_get(ctx, VB2_NV_TPM_REQUESTED_REBOOT),
490 1, " tpm reboot request");
491 TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
492 VB2_RECOVERY_RO_UNSPECIFIED, " recovery request");
493 TEST_NEQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
494 0, " recovery decided");
495
496 /* Cases for checking DISPLAY_INIT and DISPLAY_AVAILABLE. */
497 reset_common_data(FOR_MISC);
498 ctx->flags |= VB2_CONTEXT_DISPLAY_INIT;
499 TEST_SUCC(vb2api_fw_phase1(ctx), "phase1 with DISPLAY_INIT");
500 TEST_NEQ(ctx->flags & VB2_CONTEXT_DISPLAY_INIT,
501 0, " display init context flag");
502 TEST_NEQ(sd->flags & VB2_SD_FLAG_DISPLAY_AVAILABLE,
503 0, " display available SD flag");
504 TEST_NEQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
505 0, " recovery decided");
506
507 reset_common_data(FOR_MISC);
508 vb2_nv_set(ctx, VB2_NV_DISPLAY_REQUEST, 1);
509 TEST_SUCC(vb2api_fw_phase1(ctx), "phase1 with DISPLAY_REQUEST");
510 TEST_NEQ(ctx->flags & VB2_CONTEXT_DISPLAY_INIT,
511 0, " display init context flag");
512 TEST_NEQ(sd->flags & VB2_SD_FLAG_DISPLAY_AVAILABLE,
513 0, " display available SD flag");
514 TEST_NEQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
515 0, " recovery decided");
516
517 reset_common_data(FOR_MISC);
518 force_dev_mode = 1;
519 TEST_SUCC(vb2api_fw_phase1(ctx), "phase1 in dev mode");
520 TEST_NEQ(ctx->flags & VB2_CONTEXT_DISPLAY_INIT,
521 0, " display init context flag");
522 TEST_NEQ(sd->flags & VB2_SD_FLAG_DISPLAY_AVAILABLE,
523 0, " display available SD flag");
524 TEST_NEQ(sd->status & VB2_SD_STATUS_RECOVERY_DECIDED,
525 0, " recovery decided");
526 }
527
phase2_tests(void)528 static void phase2_tests(void)
529 {
530 reset_common_data(FOR_MISC);
531 TEST_SUCC(vb2api_fw_phase2(ctx), "phase2 good");
532 TEST_EQ(ctx->flags & VB2_CONTEXT_CLEAR_RAM, 0, " clear ram flag");
533 TEST_EQ(ctx->flags & VB2_CONTEXT_FW_SLOT_B, 0, " slot b flag");
534
535 reset_common_data(FOR_MISC);
536 ctx->flags |= VB2_CONTEXT_DEVELOPER_MODE;
537 TEST_SUCC(vb2api_fw_phase2(ctx), "phase2 dev");
538 TEST_NEQ(ctx->flags & VB2_CONTEXT_CLEAR_RAM, 0, " clear ram flag");
539
540 reset_common_data(FOR_MISC);
541 retval_vb2_check_tpm_clear = VB2_ERROR_MOCK;
542 TEST_EQ(vb2api_fw_phase2(ctx), VB2_ERROR_MOCK, "phase2 tpm clear");
543 TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
544 VB2_RECOVERY_TPM_CLEAR_OWNER, " recovery reason");
545
546 reset_common_data(FOR_MISC);
547 retval_vb2_select_fw_slot = VB2_ERROR_MOCK;
548 TEST_EQ(vb2api_fw_phase2(ctx), VB2_ERROR_MOCK, "phase2 slot");
549 TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
550 VB2_RECOVERY_FW_SLOT, " recovery reason");
551
552 /* S3 resume exits before clearing RAM */
553 reset_common_data(FOR_MISC);
554 ctx->flags |= VB2_CONTEXT_S3_RESUME;
555 ctx->flags |= VB2_CONTEXT_DEVELOPER_MODE;
556 TEST_SUCC(vb2api_fw_phase2(ctx), "phase2 s3 dev");
557 TEST_EQ(ctx->flags & VB2_CONTEXT_CLEAR_RAM, 0, " clear ram flag");
558 TEST_EQ(ctx->flags & VB2_CONTEXT_FW_SLOT_B, 0, " slot b flag");
559
560 reset_common_data(FOR_MISC);
561 ctx->flags |= VB2_CONTEXT_S3_RESUME;
562 vb2_nv_set(ctx, VB2_NV_FW_TRIED, 1);
563 TEST_SUCC(vb2api_fw_phase2(ctx), "phase2 s3");
564 TEST_NEQ(ctx->flags & VB2_CONTEXT_FW_SLOT_B, 0, " slot b flag");
565 }
566
get_pcr_digest_tests(void)567 static void get_pcr_digest_tests(void)
568 {
569 uint8_t digest[VB2_PCR_DIGEST_RECOMMENDED_SIZE];
570 uint8_t digest_org[VB2_PCR_DIGEST_RECOMMENDED_SIZE];
571 uint8_t fw_ver_digest[VB2_PCR_DIGEST_RECOMMENDED_SIZE] = {0x04, 0x00,
572 0x03, 0x00};
573 uint8_t ker_ver_digest[VB2_PCR_DIGEST_RECOMMENDED_SIZE] = {0x02, 0x00,
574 0x01, 0x00};
575 uint32_t digest_size;
576
577 reset_common_data(FOR_MISC);
578 memset(digest_org, 0, sizeof(digest_org));
579
580 digest_size = sizeof(digest);
581 memset(digest, 0, sizeof(digest));
582 TEST_SUCC(vb2api_get_pcr_digest(
583 ctx, BOOT_MODE_PCR, digest, &digest_size),
584 "BOOT_MODE_PCR");
585 TEST_EQ(digest_size, VB2_SHA1_DIGEST_SIZE, "BOOT_MODE_PCR digest size");
586 TEST_TRUE(memcmp(digest, digest_org, digest_size),
587 "BOOT_MODE_PCR digest");
588
589 digest_size = sizeof(digest);
590 memset(digest, 0, sizeof(digest));
591 TEST_SUCC(vb2api_get_pcr_digest(
592 ctx, HWID_DIGEST_PCR, digest, &digest_size),
593 "HWID_DIGEST_PCR");
594 TEST_EQ(digest_size, VB2_GBB_HWID_DIGEST_SIZE,
595 "HWID_DIGEST_PCR digest size");
596 TEST_FALSE(memcmp(digest, mock_hwid_digest, digest_size),
597 "HWID_DIGEST_PCR digest");
598
599 digest_size = sizeof(digest);
600 memset(digest, 0, sizeof(digest));
601 TEST_SUCC(vb2api_get_pcr_digest(ctx, FIRMWARE_VERSION_PCR, digest,
602 &digest_size),
603 "FIRMWARE_DIGEST_PCR");
604 TEST_EQ(digest_size, sizeof(uint32_t),
605 "FIRMWARE_DIGEST_PCR digest size");
606 TEST_FALSE(memcmp(digest, fw_ver_digest, digest_size),
607 "FIRMWARE_DIGEST_PCR digest");
608
609 digest_size = sizeof(digest);
610 memset(digest, 0, sizeof(digest));
611 TEST_SUCC(vb2api_get_pcr_digest(ctx, KERNEL_VERSION_PCR, digest,
612 &digest_size),
613 "KERNEL_DIGEST_PCR");
614 TEST_EQ(digest_size, sizeof(uint32_t), "KERNEL_DIGEST_PCR digest size");
615 TEST_FALSE(memcmp(digest, ker_ver_digest, digest_size),
616 "KERNEL_DIGEST_PCR digest");
617
618 digest_size = 1;
619 TEST_EQ(vb2api_get_pcr_digest(ctx, BOOT_MODE_PCR, digest, &digest_size),
620 VB2_ERROR_API_PCR_DIGEST_BUF,
621 "BOOT_MODE_PCR buffer too small");
622
623 TEST_EQ(vb2api_get_pcr_digest(ctx, 255, digest, &digest_size),
624 VB2_ERROR_API_PCR_DIGEST, "invalid enum vb2_pcr_digest");
625 }
626
phase3_tests(void)627 static void phase3_tests(void)
628 {
629 reset_common_data(FOR_MISC);
630 TEST_SUCC(vb2api_fw_phase3(ctx), "phase3 good");
631
632 reset_common_data(FOR_MISC);
633 retval_vb2_load_fw_keyblock = VB2_ERROR_MOCK;
634 TEST_EQ(vb2api_fw_phase3(ctx), VB2_ERROR_MOCK, "phase3 keyblock");
635 TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
636 VB2_RECOVERY_RO_INVALID_RW, " recovery reason");
637
638 reset_common_data(FOR_MISC);
639 retval_vb2_load_fw_preamble = VB2_ERROR_MOCK;
640 TEST_EQ(vb2api_fw_phase3(ctx), VB2_ERROR_MOCK, "phase3 keyblock");
641 TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
642 VB2_RECOVERY_RO_INVALID_RW, " recovery reason");
643 }
644
init_hash_tests(void)645 static void init_hash_tests(void)
646 {
647 struct vb2_packed_key *k;
648 int wb_used_before;
649 struct vb2_fw_preamble *pre;
650
651 /* For now, all we support is body signature hash */
652 reset_common_data(FOR_MISC);
653 wb_used_before = sd->workbuf_used;
654 TEST_SUCC(vb2api_init_hash(ctx, VB2_HASH_TAG_FW_BODY),
655 "init hash good");
656 TEST_EQ(sd->hash_offset, wb_used_before, "hash context offset");
657 TEST_EQ(sd->hash_size, sizeof(struct vb2_digest_context),
658 "hash context size");
659 TEST_EQ(sd->workbuf_used,
660 vb2_wb_round_up(sd->hash_offset + sd->hash_size),
661 "hash uses workbuf");
662 TEST_EQ(sd->hash_tag, VB2_HASH_TAG_FW_BODY, "hash tag");
663 TEST_EQ(sd->hash_remaining_size, mock_body_size, "hash remaining");
664
665 wb_used_before = sd->workbuf_used;
666 TEST_SUCC(vb2api_init_hash(ctx, VB2_HASH_TAG_FW_BODY),
667 "init hash again");
668 TEST_EQ(sd->workbuf_used, wb_used_before, "init hash reuses context");
669
670 reset_common_data(FOR_MISC);
671 TEST_EQ(vb2api_init_hash(ctx, VB2_HASH_TAG_INVALID),
672 VB2_ERROR_API_INIT_HASH_TAG, "init hash invalid tag");
673
674 reset_common_data(FOR_MISC);
675 sd->preamble_size = 0;
676 TEST_EQ(vb2api_init_hash(ctx, VB2_HASH_TAG_FW_BODY),
677 VB2_ERROR_API_INIT_HASH_PREAMBLE, "init hash preamble");
678
679 reset_common_data(FOR_MISC);
680 TEST_EQ(vb2api_init_hash(ctx, VB2_HASH_TAG_FW_BODY + 1),
681 VB2_ERROR_API_INIT_HASH_TAG, "init hash unknown tag");
682
683 reset_common_data(FOR_MISC);
684 sd->workbuf_used = sd->workbuf_size + VB2_WORKBUF_ALIGN -
685 vb2_wb_round_up(sizeof(struct vb2_digest_context));
686 TEST_EQ(vb2api_init_hash(ctx, VB2_HASH_TAG_FW_BODY),
687 VB2_ERROR_API_INIT_HASH_WORKBUF, "init hash workbuf");
688
689 reset_common_data(FOR_MISC);
690 sd->data_key_size = 0;
691 TEST_EQ(vb2api_init_hash(ctx, VB2_HASH_TAG_FW_BODY),
692 VB2_ERROR_API_INIT_HASH_DATA_KEY, "init hash data key");
693
694 reset_common_data(FOR_MISC);
695 pre = vb2_member_of(sd, sd->preamble_offset);
696 pre->body_signature.data_size = 0;
697 TEST_EQ(vb2api_init_hash(ctx, VB2_HASH_TAG_FW_BODY),
698 VB2_ERROR_API_INIT_HASH_DATA_KEY, "init hash data size");
699
700 reset_common_data(FOR_MISC);
701 sd->data_key_size--;
702 TEST_EQ(vb2api_init_hash(ctx, VB2_HASH_TAG_FW_BODY),
703 VB2_ERROR_UNPACK_KEY_SIZE, "init hash data key size");
704
705 reset_common_data(FOR_MISC);
706 k = vb2_member_of(sd, sd->data_key_offset);
707 k->algorithm--;
708 TEST_EQ(vb2api_init_hash(ctx, VB2_HASH_TAG_FW_BODY),
709 VB2_ERROR_SHA_INIT_ALGORITHM, "init hash algorithm");
710 }
711
extend_hash_tests(void)712 static void extend_hash_tests(void)
713 {
714 struct vb2_digest_context *dc;
715
716 reset_common_data(FOR_EXTEND_HASH);
717 TEST_SUCC(vb2api_extend_hash(ctx, mock_body, 32),
718 "hash extend good");
719 TEST_EQ(sd->hash_remaining_size, mock_body_size - 32,
720 "hash extend remaining");
721 TEST_SUCC(vb2api_extend_hash(ctx, mock_body, mock_body_size - 32),
722 "hash extend again");
723 TEST_EQ(sd->hash_remaining_size, 0, "hash extend remaining 2");
724
725 reset_common_data(FOR_EXTEND_HASH);
726 sd->hash_size = 0;
727 TEST_EQ(vb2api_extend_hash(ctx, mock_body, mock_body_size),
728 VB2_ERROR_API_EXTEND_HASH_WORKBUF, "hash extend no workbuf");
729
730 reset_common_data(FOR_EXTEND_HASH);
731 TEST_EQ(vb2api_extend_hash(ctx, mock_body, mock_body_size + 1),
732 VB2_ERROR_API_EXTEND_HASH_SIZE, "hash extend too much");
733
734 reset_common_data(FOR_EXTEND_HASH);
735 TEST_EQ(vb2api_extend_hash(ctx, mock_body, 0),
736 VB2_ERROR_API_EXTEND_HASH_SIZE, "hash extend empty");
737
738 reset_common_data(FOR_EXTEND_HASH);
739 dc = (struct vb2_digest_context *)vb2_member_of(sd, sd->hash_offset);
740 dc->hash_alg = mock_hash_alg + 1;
741 TEST_EQ(vb2api_extend_hash(ctx, mock_body, mock_body_size),
742 VB2_ERROR_SHA_EXTEND_ALGORITHM, "hash extend fail");
743 }
744
check_hash_tests(void)745 static void check_hash_tests(void)
746 {
747 struct vb2_fw_preamble *pre;
748 const uint32_t digest_value = 0x0a0a0a0a;
749
750 reset_common_data(FOR_CHECK_HASH);
751 TEST_SUCC(vb2api_check_hash(ctx), "check hash good");
752
753 reset_common_data(FOR_CHECK_HASH);
754 TEST_SUCC(vb2api_check_hash_get_digest(ctx, digest_result,
755 digest_result_size), "check hash good with result");
756 /* Check the first 4 bytes to ensure it was copied over. */
757 TEST_SUCC(memcmp(digest_result, &digest_value, sizeof(digest_value)),
758 "check digest value");
759
760 /* Test hwcrypto conditions */
761 reset_common_data(FOR_CHECK_HASH);
762 TEST_SUCC(vb2api_check_hash(ctx), "check hash good");
763 TEST_EQ(last_used_key.allow_hwcrypto, 0,
764 "hwcrypto is forbidden by TPM flag");
765
766 reset_common_data(FOR_CHECK_HASH);
767 ctx->flags |= VB2_CONTEXT_RECOVERY_MODE;
768 TEST_SUCC(vb2api_check_hash(ctx), "check hash good");
769 TEST_EQ(last_used_key.allow_hwcrypto, 0,
770 "hwcrypto is forbidden by TPM flag on recovery mode");
771
772 reset_common_data(FOR_CHECK_HASH);
773 vb2_secdata_kernel_set(ctx, VB2_SECDATA_KERNEL_FLAGS,
774 VB2_SECDATA_KERNEL_FLAG_HWCRYPTO_ALLOWED);
775 TEST_SUCC(vb2api_check_hash(ctx), "check hash good");
776 TEST_EQ(last_used_key.allow_hwcrypto, 1, "hwcrypto is allowed");
777
778 reset_common_data(FOR_CHECK_HASH);
779 ctx->flags |= VB2_CONTEXT_RECOVERY_MODE;
780 vb2_secdata_kernel_set(ctx, VB2_SECDATA_KERNEL_FLAGS,
781 VB2_SECDATA_KERNEL_FLAG_HWCRYPTO_ALLOWED);
782 TEST_SUCC(vb2api_check_hash(ctx), "check hash good");
783 TEST_EQ(last_used_key.allow_hwcrypto, 0,
784 "hwcrypto is forbidden on recovery mode");
785
786 reset_common_data(FOR_CHECK_HASH);
787 TEST_EQ(vb2api_check_hash_get_digest(ctx, digest_result,
788 digest_result_size - 1),
789 VB2_ERROR_API_CHECK_DIGEST_SIZE, "check digest size");
790 TEST_NEQ(memcmp(digest_result, &digest_value, sizeof(digest_value)), 0,
791 "check digest wrong size");
792
793 reset_common_data(FOR_CHECK_HASH);
794 sd->preamble_size = 0;
795 TEST_EQ(vb2api_check_hash(ctx),
796 VB2_ERROR_API_CHECK_HASH_PREAMBLE, "check hash preamble");
797
798 reset_common_data(FOR_CHECK_HASH);
799 sd->hash_size = 0;
800 TEST_EQ(vb2api_check_hash(ctx),
801 VB2_ERROR_API_CHECK_HASH_WORKBUF, "check hash no workbuf");
802
803 reset_common_data(FOR_CHECK_HASH);
804 sd->hash_remaining_size = 1;
805 TEST_EQ(vb2api_check_hash(ctx),
806 VB2_ERROR_API_CHECK_HASH_SIZE, "check hash size");
807
808 reset_common_data(FOR_CHECK_HASH);
809 sd->workbuf_used = sd->workbuf_size;
810 TEST_EQ(vb2api_check_hash(ctx),
811 VB2_ERROR_API_CHECK_HASH_WORKBUF_DIGEST, "check hash workbuf");
812
813 reset_common_data(FOR_CHECK_HASH);
814 retval_vb2_digest_finalize = VB2_ERROR_MOCK;
815 TEST_EQ(vb2api_check_hash(ctx), VB2_ERROR_MOCK, "check hash finalize");
816
817 reset_common_data(FOR_CHECK_HASH);
818 sd->hash_tag = VB2_HASH_TAG_INVALID;
819 TEST_EQ(vb2api_check_hash(ctx),
820 VB2_ERROR_API_CHECK_HASH_TAG, "check hash tag");
821
822 reset_common_data(FOR_CHECK_HASH);
823 sd->data_key_size = 0;
824 TEST_EQ(vb2api_check_hash(ctx),
825 VB2_ERROR_API_CHECK_HASH_DATA_KEY, "check hash data key");
826
827 reset_common_data(FOR_CHECK_HASH);
828 sd->data_key_size--;
829 TEST_EQ(vb2api_check_hash(ctx),
830 VB2_ERROR_UNPACK_KEY_SIZE, "check hash data key size");
831
832 reset_common_data(FOR_CHECK_HASH);
833 pre = vb2_member_of(sd, sd->preamble_offset);
834 pre->body_signature.sig_size++;
835 TEST_EQ(vb2api_check_hash(ctx),
836 VB2_ERROR_VDATA_SIG_SIZE, "check hash sig size");
837
838 reset_common_data(FOR_CHECK_HASH);
839 retval_vb2_digest_finalize = VB2_ERROR_RSA_VERIFY_DIGEST;
840 TEST_EQ(vb2api_check_hash(ctx),
841 VB2_ERROR_RSA_VERIFY_DIGEST, "check hash finalize");
842 }
843
get_metadata_hash_test(void)844 static void get_metadata_hash_test(void)
845 {
846 struct vb2_hash *hash;
847 struct vb2_fw_preamble *pre;
848
849 reset_common_data(FOR_MISC);
850 TEST_EQ(vb2api_get_metadata_hash(ctx, &hash),
851 VB2_ERROR_API_INIT_HASH_DATA_KEY, "check body sig data size");
852
853 reset_common_data(FOR_MISC);
854 sd->preamble_size = 0;
855 TEST_EQ(vb2api_get_metadata_hash(ctx, &hash),
856 VB2_ERROR_API_CHECK_HASH_PREAMBLE, "check preamble size");
857
858 reset_common_data(FOR_METADATA_HASH);
859 pre = vb2_member_of(sd, sd->preamble_offset);
860 pre->body_signature.sig_size = 8;
861 TEST_EQ(vb2api_get_metadata_hash(ctx, &hash),
862 VB2_ERROR_API_CHECK_HASH_SIG_SIZE, "check too small sig size");
863
864 reset_common_data(FOR_METADATA_HASH);
865 pre = vb2_member_of(sd, sd->preamble_offset);
866 pre->body_signature.data_size = mock_body_size;
867 TEST_EQ(vb2api_get_metadata_hash(ctx, &hash),
868 VB2_ERROR_API_INIT_HASH_DATA_KEY, "check incorrect data size");
869
870 reset_common_data(FOR_METADATA_HASH);
871 pre = vb2_member_of(sd, sd->preamble_offset);
872 hash = (struct vb2_hash *)vb2_signature_data_mutable(
873 &pre->body_signature);
874 hash->algo = VB2_HASH_INVALID;
875 TEST_EQ(vb2api_get_metadata_hash(ctx, &hash),
876 VB2_ERROR_API_CHECK_HASH_SIG_SIZE, "check unsupported algo");
877
878 reset_common_data(FOR_METADATA_HASH);
879 TEST_EQ(vb2api_get_metadata_hash(ctx, &hash), VB2_SUCCESS,
880 "check metadata hash get");
881 TEST_PTR_NEQ(hash, NULL, "check metadata hash not null");
882 TEST_EQ(hash->algo, mock_mhash.algo, "check metadata hash algo");
883 TEST_EQ(memcmp(hash->raw, mock_mhash.raw,
884 vb2_digest_size(mock_mhash.algo)),
885 0, "check metadata hash digest");
886 }
887
main(int argc,char * argv[])888 int main(int argc, char* argv[])
889 {
890 misc_tests();
891 phase1_tests();
892 phase2_tests();
893 phase3_tests();
894
895 init_hash_tests();
896 extend_hash_tests();
897 check_hash_tests();
898
899 get_metadata_hash_test();
900
901 get_pcr_digest_tests();
902
903 return gTestSuccess ? 0 : 255;
904 }
905