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 "vb2_common.h"
10 #include "vboot_struct.h" /* For old struct sizes */
11 #include "test_common.h"
12
13 /*
14 * Test struct packing for vboot_struct.h structs which are passed between
15 * firmware and OS, or passed between different phases of firmware.
16 */
test_struct_packing(void)17 static void test_struct_packing(void)
18 {
19 /* Test vboot2 versions of vboot1 structs */
20 TEST_EQ(EXPECTED_VB2_PACKED_KEY_SIZE,
21 sizeof(struct vb2_packed_key),
22 "sizeof(vb2_packed_key)");
23 TEST_EQ(EXPECTED_VB2_SIGNATURE_SIZE,
24 sizeof(struct vb2_signature),
25 "sizeof(vb2_signature)");
26 TEST_EQ(EXPECTED_VB2_KEYBLOCK_SIZE,
27 sizeof(struct vb2_keyblock),
28 "sizeof(vb2_keyblock)");
29 TEST_EQ(EXPECTED_VB2_FW_PREAMBLE_SIZE,
30 sizeof(struct vb2_fw_preamble),
31 "sizeof(vb2_fw_preamble)");
32 TEST_EQ(EXPECTED_VB2_GBB_HEADER_SIZE,
33 sizeof(struct vb2_gbb_header),
34 "sizeof(vb2_gbb_header)");
35
36 /* And make sure they're the same as their vboot1 equivalents */
37 TEST_EQ(EXPECTED_VB2_PACKED_KEY_SIZE,
38 EXPECTED_VBPUBLICKEY_SIZE,
39 "vboot1->2 packed key sizes same");
40 TEST_EQ(EXPECTED_VB2_SIGNATURE_SIZE,
41 EXPECTED_VBSIGNATURE_SIZE,
42 "vboot1->2 signature sizes same");
43 TEST_EQ(EXPECTED_VB2_KEYBLOCK_SIZE,
44 EXPECTED_VBKEYBLOCKHEADER_SIZE,
45 "vboot1->2 keyblock sizes same");
46 TEST_EQ(EXPECTED_VB2_FW_PREAMBLE_SIZE,
47 EXPECTED_VBFIRMWAREPREAMBLEHEADER2_1_SIZE,
48 "vboot1->2 firmware preamble sizes same");
49 }
50
51 /**
52 * Helper functions not dependent on specific key sizes
53 */
test_helper_functions(void)54 static void test_helper_functions(void)
55 {
56 {
57 uint8_t *p = (uint8_t *)test_helper_functions;
58 TEST_EQ((int)vb2_offset_of(p, p), 0, "vb2_offset_of() equal");
59 TEST_EQ((int)vb2_offset_of(p, p+10), 10,
60 "vb2_offset_of() positive");
61 }
62
63 {
64 struct vb2_packed_key k = {.key_offset = sizeof(k)};
65 TEST_EQ((int)vb2_offset_of(&k, vb2_packed_key_data(&k)),
66 sizeof(k), "vb2_packed_key_data() adjacent");
67 }
68
69 {
70 struct vb2_packed_key k = {.key_offset = 123};
71 TEST_EQ((int)vb2_offset_of(&k, vb2_packed_key_data(&k)), 123,
72 "vb2_packed_key_data() spaced");
73 }
74
75 {
76 struct vb2_signature s = {.sig_offset = sizeof(s)};
77 TEST_EQ((int)vb2_offset_of(&s, vb2_signature_data(&s)),
78 sizeof(s), "vb2_signature_data() adjacent");
79 }
80
81 {
82 struct vb2_signature s = {.sig_offset = 123};
83 TEST_EQ((int)vb2_offset_of(&s, vb2_signature_data(&s)), 123,
84 "vb2_signature_data() spaced");
85 }
86
87 {
88 uint8_t *p = (uint8_t *)test_helper_functions;
89 TEST_SUCC(vb2_verify_member_inside(p, 20, p, 6, 11, 3),
90 "MemberInside ok 1");
91 TEST_SUCC(vb2_verify_member_inside(p, 20, p+4, 4, 8, 4),
92 "MemberInside ok 2");
93 TEST_EQ(vb2_verify_member_inside(p, 20, p-4, 4, 8, 4),
94 VB2_ERROR_INSIDE_MEMBER_OUTSIDE,
95 "MemberInside member before parent");
96 TEST_EQ(vb2_verify_member_inside(p, 20, p+20, 4, 8, 4),
97 VB2_ERROR_INSIDE_MEMBER_OUTSIDE,
98 "MemberInside member after parent");
99 TEST_EQ(vb2_verify_member_inside(p, 20, p, 21, 0, 0),
100 VB2_ERROR_INSIDE_MEMBER_OUTSIDE,
101 "MemberInside member too big");
102 TEST_EQ(vb2_verify_member_inside(p, 20, p, 4, 21, 0),
103 VB2_ERROR_INSIDE_DATA_OUTSIDE,
104 "MemberInside data after parent");
105 TEST_EQ(vb2_verify_member_inside(p, 20, p, 4, SIZE_MAX, 0),
106 VB2_ERROR_INSIDE_DATA_OUTSIDE,
107 "MemberInside data before parent");
108 TEST_EQ(vb2_verify_member_inside(p, 20, p, 4, 4, 17),
109 VB2_ERROR_INSIDE_DATA_OUTSIDE,
110 "MemberInside data too big");
111 TEST_EQ(vb2_verify_member_inside(p, 20, p, 8, 4, 8),
112 VB2_ERROR_INSIDE_DATA_OVERLAP,
113 "MemberInside data overlaps member");
114 TEST_EQ(vb2_verify_member_inside(p, -8, p, 12, 0, 0),
115 VB2_ERROR_INSIDE_PARENT_WRAPS,
116 "MemberInside wraparound 1");
117 TEST_EQ(vb2_verify_member_inside(p, 20, p, -8, 0, 0),
118 VB2_ERROR_INSIDE_MEMBER_WRAPS,
119 "MemberInside wraparound 2");
120 TEST_EQ(vb2_verify_member_inside(p, 20, p, 4, 4, -12),
121 VB2_ERROR_INSIDE_DATA_WRAPS,
122 "MemberInside wraparound 3");
123 }
124
125 {
126 struct vb2_packed_key k = {.key_offset = sizeof(k),
127 .key_size = 128};
128 TEST_SUCC(vb2_verify_packed_key_inside(&k, sizeof(k)+128, &k),
129 "PublicKeyInside ok 1");
130 TEST_SUCC(vb2_verify_packed_key_inside(&k - 1,
131 2*sizeof(k)+128, &k),
132 "PublicKeyInside ok 2");
133 TEST_EQ(vb2_verify_packed_key_inside(&k, 128, &k),
134 VB2_ERROR_INSIDE_DATA_OUTSIDE,
135 "PublicKeyInside key too big");
136 }
137
138 {
139 struct vb2_packed_key k = {.key_offset = 100,
140 .key_size = 4};
141 TEST_EQ(vb2_verify_packed_key_inside(&k, 99, &k),
142 VB2_ERROR_INSIDE_DATA_OUTSIDE,
143 "PublicKeyInside offset too big");
144 }
145
146 {
147 struct vb2_signature s = {.sig_offset = sizeof(s),
148 .sig_size = 128};
149 TEST_SUCC(vb2_verify_signature_inside(&s, sizeof(s)+128, &s),
150 "SignatureInside ok 1");
151 TEST_SUCC(vb2_verify_signature_inside(&s - 1,
152 2*sizeof(s)+128, &s),
153 "SignatureInside ok 2");
154 TEST_EQ(vb2_verify_signature_inside(&s, 128, &s),
155 VB2_ERROR_INSIDE_DATA_OUTSIDE,
156 "SignatureInside sig too big");
157 }
158
159 {
160 struct vb2_signature s = {.sig_offset = 100,
161 .sig_size = 4};
162 TEST_EQ(vb2_verify_signature_inside(&s, 99, &s),
163 VB2_ERROR_INSIDE_DATA_OUTSIDE,
164 "SignatureInside offset too big");
165 }
166 }
167
main(int argc,char * argv[])168 int main(int argc, char* argv[])
169 {
170 test_struct_packing();
171 test_helper_functions();
172
173 return gTestSuccess ? 0 : 255;
174 }
175