Branch data Line data Source code
1 : : // SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
2 : : /* Copyright 2020 IBM Corp. */
3 : :
4 : : #define MBEDTLS_PKCS7_C
5 : : #include "secvar_common_test.c"
6 : : #include "../backend/edk2-compat.c"
7 : : #include "../backend/edk2-compat-process.c"
8 : : #include "../secvar_util.c"
9 : : #include "../../crypto/pkcs7/pkcs7.c"
10 : : #include "./data/PK.h"
11 : : #include "./data/noPK.h"
12 : : #include "./data/KEK.h"
13 : : #include "./data/invalidkek.h"
14 : : #include "./data/malformedkek.h"
15 : : #include "./data/trimmedKEK.h"
16 : : #include "./data/KEKeslcorrupt.h"
17 : : #include "./data/KEKpkcs7corrupt.h"
18 : : #include "./data/db.h"
19 : : #include "./data/dbsigneddata.h"
20 : : #include "./data/OldTSKEK.h"
21 : : #include "./data/multipleKEK.h"
22 : : #include "./data/multipletrimmedKEK.h"
23 : : #include "./data/multipleDB.h"
24 : : #include "./data/multiplePK.h"
25 : : #include "./data/dbx.h"
26 : : #include "./data/dbxcert.h"
27 : : #include "./data/dbxsha512.h"
28 : : #include "./data/dbxmalformed.h"
29 : : #include "./data/pkcs7_sha512.h"
30 : :
31 : : bool test_hw_key_hash = false;
32 : :
33 : : /* Hardcoding HW KEY HASH to avoid emulating device-tree in unit-tests. */
34 : : const unsigned char hw_key_hash[64] = {
35 : : 0xb6, 0xdf, 0xfe, 0x75, 0x53, 0xf9, 0x2e, 0xcb, 0x2b, 0x05, 0x55, 0x35, 0xd7, 0xda, 0xfe, 0x32, \
36 : : 0x98, 0x93, 0x35, 0x1e, 0xd7, 0x4b, 0xbb, 0x21, 0x6b, 0xa0, 0x56, 0xa7, 0x1e, 0x3c, 0x0b, 0x56, \
37 : : 0x6f, 0x0c, 0x4d, 0xbe, 0x31, 0x42, 0x13, 0x68, 0xcb, 0x32, 0x11, 0x6f, 0x13, 0xbb, 0xdd, 0x9e, \
38 : : 0x4f, 0xe3, 0x83, 0x8b, 0x1c, 0x6a, 0x2e, 0x07, 0xdb, 0x95, 0x16, 0xc9, 0x33, 0xaa, 0x20, 0xef
39 : : };
40 : :
41 : : const unsigned char new_hw_key_hash[64] = {
42 : : 0xa6, 0xdf, 0xfe, 0x75, 0x53, 0xf9, 0x2e, 0xcb, 0x2b, 0x05, 0x55, 0x35, 0xd7, 0xda, 0xfe, 0x32, \
43 : : 0x98, 0x93, 0x35, 0x1e, 0xd7, 0x4b, 0xbb, 0x21, 0x6b, 0xa0, 0x56, 0xa7, 0x1e, 0x3c, 0x0b, 0x56, \
44 : : 0x6f, 0x0c, 0x4d, 0xbe, 0x31, 0x42, 0x13, 0x68, 0xcb, 0x32, 0x11, 0x6f, 0x13, 0xbb, 0xdd, 0x9e, \
45 : : 0x4f, 0xe3, 0x83, 0x8b, 0x1c, 0x6a, 0x2e, 0x07, 0xdb, 0x95, 0x16, 0xc9, 0x33, 0xaa, 0x20, 0xef
46 : : };
47 : :
48 : 1 : int reset_keystore(struct list_head *bank __unused) { return 0; }
49 : 21 : int verify_hw_key_hash(void)
50 : : {
51 : :
52 : : /* This check is added just to simulate mismatch of hashes. */
53 : 21 : if (test_hw_key_hash)
54 : : if (memcmp(new_hw_key_hash, hw_key_hash, 64) != 0)
55 : 1 : return OPAL_PERMISSION;
56 : :
57 : 20 : return OPAL_SUCCESS;
58 : : }
59 : :
60 : :
61 : 5 : int add_hw_key_hash(struct list_head *bank)
62 : : {
63 : : struct secvar *var;
64 : 5 : uint32_t hw_key_hash_size = 64;
65 : :
66 : 5 : var = new_secvar("HWKH", 5, hw_key_hash,
67 : : hw_key_hash_size, SECVAR_FLAG_PROTECTED);
68 : 5 : list_add_tail(bank, &var->link);
69 : :
70 : 5 : return OPAL_SUCCESS;
71 : : }
72 : :
73 : 2 : int delete_hw_key_hash(struct list_head *bank)
74 : : {
75 : : struct secvar *var;
76 : :
77 : 2 : var = find_secvar("HWKH", 5, bank);
78 : 2 : if (!var)
79 : 0 : return OPAL_SUCCESS;
80 : :
81 : 2 : list_del(&var->link);
82 : 2 : dealloc_secvar(var);
83 : :
84 : 2 : return OPAL_SUCCESS;
85 : : }
86 : :
87 : : const char *secvar_test_name = "edk2-compat";
88 : :
89 : 2 : int secvar_set_secure_mode(void) { return 0; };
90 : :
91 : 1 : int run_test()
92 : : {
93 : 1 : int rc = -1;
94 : : struct secvar *tmp;
95 : : size_t tmp_size;
96 : 1 : char empty[64] = {0};
97 : : void *data;
98 : :
99 : : /* The sequence of test cases here is important to ensure that
100 : : * timestamp checks work as expected. */
101 : :
102 : : /* Check pre-process creates the empty variables. */
103 : 1 : ASSERT(0 == list_length(&variable_bank));
104 : 1 : rc = edk2_compat_pre_process(&variable_bank, &update_bank);
105 : 1 : ASSERT(OPAL_SUCCESS == rc);
106 : 1 : ASSERT(5 == list_length(&variable_bank));
107 : 1 : tmp = find_secvar("TS", 3, &variable_bank);
108 : 1 : ASSERT(NULL != tmp);
109 : 1 : ASSERT(64 == tmp->data_size);
110 : 1 : ASSERT(!(memcmp(tmp->data, empty, 64)));
111 : :
112 : : /* Add test to verify hw_key_hash.
113 : : * This is to ensure that mismatch of test happens.
114 : : * The test uses test_hw_key_hash variable to ensure that
115 : : * mismatch happens. For all next tests, test_hw_key_hash variable
116 : : * should be zero to avoid hard-coded mismatch.
117 : : */
118 : 1 : test_hw_key_hash = 1;
119 : 1 : setup_mode = false;
120 : 1 : printf("Add PK");
121 : 1 : tmp = new_secvar("PK", 3, PK_auth, PK_auth_len, 0);
122 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
123 : 1 : list_add_tail(&update_bank, &tmp->link);
124 : 1 : ASSERT(1 == list_length(&update_bank));
125 : 1 : rc = edk2_compat_process(&variable_bank, &update_bank);
126 : 1 : printf("rc is %04x %d\n", rc, rc);
127 : 1 : ASSERT(OPAL_SUCCESS == rc);
128 : 1 : ASSERT(0 == list_length(&update_bank));
129 : 1 : ASSERT(setup_mode);
130 : :
131 : : /* Set test_hw_key_hash to zero to avoid hardcoded mismatch. */
132 : 1 : test_hw_key_hash = 0;
133 : :
134 : : /* Add PK and a failed update. */
135 : 1 : printf("Add PK and failed dbx");
136 : 1 : tmp = new_secvar("PK", 3, PK_auth, PK_auth_len, 0);
137 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
138 : 1 : list_add_tail(&update_bank, &tmp->link);
139 : 1 : ASSERT(1 == list_length(&update_bank));
140 : :
141 : 1 : tmp = new_secvar("dbx", 4, wrongdbxauth, wrong_dbx_auth_len, 0);
142 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
143 : 1 : list_add_tail(&update_bank, &tmp->link);
144 : 1 : ASSERT(2 == list_length(&update_bank));
145 : :
146 : 1 : rc = edk2_compat_process(&variable_bank, &update_bank);
147 : 1 : ASSERT(OPAL_PARAMETER == rc);
148 : 1 : ASSERT(5 == list_length(&variable_bank));
149 : 1 : ASSERT(0 == list_length(&update_bank));
150 : 1 : rc = edk2_compat_post_process(&variable_bank, &update_bank);
151 : 1 : ASSERT(5 == list_length(&variable_bank));
152 : 1 : ASSERT(setup_mode);
153 : :
154 : : /* Add PK and db, db update should fail, so all updates fail. */
155 : 1 : printf("Add PK");
156 : 1 : tmp = new_secvar("PK", 3, PK_auth, PK_auth_len, 0);
157 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
158 : 1 : list_add_tail(&update_bank, &tmp->link);
159 : 1 : ASSERT(1 == list_length(&update_bank));
160 : 1 : printf("Add db");
161 : 1 : tmp = new_secvar("db", 3, DB_auth, sizeof(DB_auth), 0);
162 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
163 : 1 : list_add_tail(&update_bank, &tmp->link);
164 : 1 : ASSERT(2 == list_length(&update_bank));
165 : 1 : rc = edk2_compat_process(&variable_bank, &update_bank);
166 : 1 : ASSERT(OPAL_PERMISSION == rc);
167 : 1 : ASSERT(5 == list_length(&variable_bank));
168 : 1 : ASSERT(0 == list_length(&update_bank));
169 : 1 : rc = edk2_compat_post_process(&variable_bank, &update_bank);
170 : 1 : ASSERT(5 == list_length(&variable_bank));
171 : 1 : ASSERT(setup_mode);
172 : :
173 : : /* Add PK with bad ESL. should fail since data is not big enough to be ESL*/
174 : 1 : printf("Add PK with invalid appended ESL");
175 : : /* 1014 is length of appended ESL Header and its data */
176 : 1 : tmp = new_secvar("PK", 3, PK_auth, PK_auth_len - 1014 + sizeof(EFI_SIGNATURE_LIST) - 1, 0);
177 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
178 : 1 : list_add_tail(&update_bank, &tmp->link);
179 : 1 : ASSERT(1 == list_length(&update_bank));
180 : 1 : rc = edk2_compat_process(&variable_bank, &update_bank);
181 : 1 : ASSERT(5 == list_length(&variable_bank));
182 : 1 : ASSERT(0 == list_length(&update_bank));
183 : 1 : rc = edk2_compat_post_process(&variable_bank, &update_bank);
184 : 1 : ASSERT(5 == list_length(&variable_bank));
185 : 1 : ASSERT(setup_mode);
186 : :
187 : :
188 : : /* Add PK to update and .process(). */
189 : 1 : printf("Add PK");
190 : 1 : tmp = new_secvar("PK", 3, PK_auth, PK_auth_len, 0);
191 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
192 : 1 : list_add_tail(&update_bank, &tmp->link);
193 : 1 : ASSERT(1 == list_length(&update_bank));
194 : :
195 : 1 : rc = edk2_compat_process(&variable_bank, &update_bank);
196 : 1 : ASSERT(OPAL_SUCCESS == rc);
197 : 1 : ASSERT(6 == list_length(&variable_bank));
198 : 1 : ASSERT(0 == list_length(&update_bank));
199 : 1 : rc = edk2_compat_post_process(&variable_bank, &update_bank);
200 : 1 : ASSERT(5 == list_length(&variable_bank));
201 : 1 : tmp = find_secvar("PK", 3, &variable_bank);
202 : 1 : ASSERT(NULL != tmp);
203 : 1 : ASSERT(0 != tmp->data_size);
204 : 1 : ASSERT(PK_auth_len > tmp->data_size); /* esl should be smaller without auth. */
205 : 1 : ASSERT(!setup_mode);
206 : :
207 : : /* Add db, should fail with no KEK. */
208 : 1 : printf("Add db");
209 : 1 : tmp = new_secvar("db", 3, DB_auth, DB_auth_len, 0);
210 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
211 : 1 : list_add_tail(&update_bank, &tmp->link);
212 : 1 : ASSERT(1 == list_length(&update_bank));
213 : :
214 : 1 : rc = edk2_compat_process(&variable_bank, &update_bank);
215 : 1 : ASSERT(OPAL_PERMISSION == rc);
216 : 1 : ASSERT(5 == list_length(&variable_bank));
217 : 1 : ASSERT(0 == list_length(&update_bank));
218 : 1 : tmp = find_secvar("db", 3, &variable_bank);
219 : 1 : ASSERT(NULL != tmp);
220 : :
221 : : /* Add db, should fail with no KEK and invalid PK size */
222 : 1 : printf("Add db, corrupt PK");
223 : : /* Somehow PK gets assigned wrong size */
224 : 1 : tmp = find_secvar("PK", 3, &variable_bank);
225 : 1 : ASSERT(NULL != tmp);
226 : 1 : tmp_size = tmp->data_size;
227 : 1 : tmp->data_size = sizeof(EFI_SIGNATURE_LIST) - 1;
228 : 1 : tmp = new_secvar("db", 3, DB_auth, DB_auth_len, 0);
229 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
230 : 1 : list_add_tail(&update_bank, &tmp->link);
231 : 1 : ASSERT(1 == list_length(&update_bank));
232 : :
233 : 1 : rc = edk2_compat_process(&variable_bank, &update_bank);
234 : 1 : ASSERT(OPAL_INTERNAL_ERROR == rc);
235 : 1 : ASSERT(5 == list_length(&variable_bank));
236 : 1 : ASSERT(0 == list_length(&update_bank));
237 : 1 : tmp = find_secvar("db", 3, &variable_bank);
238 : 1 : ASSERT(NULL != tmp);
239 : 1 : ASSERT(0 == tmp->data_size);
240 : : /* Restore PK data size */
241 : 1 : tmp = find_secvar("PK", 3, &variable_bank);
242 : 1 : ASSERT(NULL != tmp);
243 : 1 : tmp->data_size = tmp_size;
244 : :
245 : : /* Add trimmed KEK, .process(), should fail. */
246 : 1 : printf("Add trimmed KEK\n");
247 : 1 : tmp = new_secvar("KEK", 4, trimmedKEK_auth, trimmedKEK_auth_len, 0);
248 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
249 : 1 : list_add_tail(&update_bank, &tmp->link);
250 : 1 : ASSERT(1 == list_length(&update_bank));
251 : :
252 : 1 : rc = edk2_compat_process(&variable_bank, &update_bank);
253 : 1 : ASSERT(OPAL_PARAMETER == rc);
254 : 1 : ASSERT(5 == list_length(&variable_bank));
255 : 1 : ASSERT(0 == list_length(&update_bank));
256 : 1 : tmp = find_secvar("KEK", 4, &variable_bank);
257 : 1 : ASSERT(NULL != tmp);
258 : 1 : ASSERT(0 == tmp->data_size);
259 : :
260 : 1 : printf("Try truncated KEK < size of auth structure:\n");
261 : 1 : data = malloc(1467);
262 : 1 : memcpy(data, KEK_auth, 1467);
263 : 1 : tmp = new_secvar("KEK", 4, data, 1467, 0);
264 : 1 : rc = edk2_compat_validate(tmp);
265 : 1 : ASSERT(0 == rc);
266 : 1 : list_add_tail(&update_bank, &tmp->link);
267 : 1 : ASSERT(1 == list_length(&update_bank));
268 : :
269 : 1 : rc = edk2_compat_process(&variable_bank, &update_bank);
270 : 1 : ASSERT(0 != rc);
271 : 1 : ASSERT(5 == list_length(&variable_bank));
272 : 1 : ASSERT(0 == list_length(&update_bank));
273 : 1 : tmp = find_secvar("KEK", 4, &variable_bank);
274 : 1 : ASSERT(NULL != tmp);
275 : 1 : ASSERT(0 == tmp->data_size);
276 : 1 : free(data);
277 : :
278 : : /* KEK with corrupted ESL SignatureSize */
279 : 1 : printf("KEK with corrupt ESL SignatureSize\n");
280 : 1 : tmp = new_secvar("KEK", 4, KEKeslcorrupt_auth, KEKeslcorrupt_auth_len, 0);
281 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
282 : 1 : list_add_tail(&update_bank, &tmp->link);
283 : 1 : ASSERT(1 == list_length(&update_bank));
284 : :
285 : 1 : rc = edk2_compat_process(&variable_bank, &update_bank);
286 : : /* If we don't catch the error, we get OPAL_NO_MEM instead */
287 : 1 : ASSERT(OPAL_PARAMETER == rc);
288 : 1 : ASSERT(5 == list_length(&variable_bank));
289 : 1 : ASSERT(0 == list_length(&update_bank));
290 : 1 : tmp = find_secvar("KEK", 4, &variable_bank);
291 : 1 : ASSERT(NULL != tmp);
292 : 1 : ASSERT(0 == tmp->data_size);
293 : :
294 : : /* KEK with corrupted pkcs7, used to leak memory */
295 : 1 : printf("KEK with corrupt PKCS#7 message\n");
296 : 1 : tmp = new_secvar("KEK", 4, KEKpkcs7corrupt_auth, KEKpkcs7corrupt_auth_len, 0);
297 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
298 : 1 : list_add_tail(&update_bank, &tmp->link);
299 : 1 : ASSERT(1 == list_length(&update_bank));
300 : :
301 : 1 : rc = edk2_compat_process(&variable_bank, &update_bank);
302 : 1 : ASSERT(OPAL_PARAMETER == rc);
303 : 1 : ASSERT(5 == list_length(&variable_bank));
304 : 1 : ASSERT(0 == list_length(&update_bank));
305 : 1 : tmp = find_secvar("KEK", 4, &variable_bank);
306 : 1 : ASSERT(NULL != tmp);
307 : 1 : ASSERT(0 == tmp->data_size);
308 : :
309 : : /* Add valid KEK, .process(), succeeds. */
310 : 1 : printf("Add KEK");
311 : 1 : tmp = new_secvar("KEK", 4, KEK_auth, KEK_auth_len, 0);
312 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
313 : 1 : list_add_tail(&update_bank, &tmp->link);
314 : 1 : ASSERT(1 == list_length(&update_bank));
315 : :
316 : 1 : rc = edk2_compat_process(&variable_bank, &update_bank);
317 : 1 : ASSERT(OPAL_SUCCESS == rc);
318 : 1 : ASSERT(5 == list_length(&variable_bank));
319 : 1 : ASSERT(0 == list_length(&update_bank));
320 : 1 : tmp = find_secvar("KEK", 4, &variable_bank);
321 : 1 : ASSERT(NULL != tmp);
322 : 1 : ASSERT(0 != tmp->data_size);
323 : :
324 : : /* Add valid KEK, .process(), timestamp check fails. */
325 : 1 : tmp = new_secvar("KEK", 4, OldTS_KEK_auth, OldTS_KEK_auth_len, 0);
326 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
327 : 1 : list_add_tail(&update_bank, &tmp->link);
328 : 1 : ASSERT(1 == list_length(&update_bank));
329 : :
330 : 1 : rc = edk2_compat_process(&variable_bank, &update_bank);
331 : 1 : ASSERT(OPAL_PERMISSION == rc);
332 : 1 : ASSERT(5 == list_length(&variable_bank));
333 : 1 : ASSERT(0 == list_length(&update_bank));
334 : 1 : tmp = find_secvar("KEK", 4, &variable_bank);
335 : 1 : ASSERT(NULL != tmp);
336 : 1 : ASSERT(0 != tmp->data_size);
337 : :
338 : : /* Add db, .process(), should succeed. */
339 : 1 : printf("Add db again\n");
340 : 1 : tmp = new_secvar("db", 3, DB_auth, DB_auth_len, 0);
341 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
342 : 1 : list_add_tail(&update_bank, &tmp->link);
343 : 1 : ASSERT(1 == list_length(&update_bank));
344 : :
345 : 1 : rc = edk2_compat_process(&variable_bank, &update_bank);
346 : 1 : ASSERT(OPAL_SUCCESS == rc);
347 : 1 : ASSERT(5 == list_length(&variable_bank));
348 : 1 : ASSERT(0 == list_length(&update_bank));
349 : 1 : tmp = find_secvar("db", 3, &variable_bank);
350 : 1 : printf("tmp is %s\n", tmp->key);
351 : 1 : ASSERT(NULL != tmp);
352 : 1 : ASSERT(0 != tmp->data_size);
353 : :
354 : : /* Add db, .process(), should fail because of timestamp. */
355 : 1 : printf("Add db again\n");
356 : 1 : tmp = new_secvar("db", 3, DB_auth, DB_auth_len, 0);
357 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
358 : 1 : list_add_tail(&update_bank, &tmp->link);
359 : 1 : ASSERT(1 == list_length(&update_bank));
360 : :
361 : 1 : rc = edk2_compat_process(&variable_bank, &update_bank);
362 : 1 : ASSERT(OPAL_PERMISSION == rc);
363 : 1 : ASSERT(5 == list_length(&variable_bank));
364 : 1 : ASSERT(0 == list_length(&update_bank));
365 : 1 : tmp = find_secvar("db", 3, &variable_bank);
366 : 1 : ASSERT(NULL != tmp);
367 : 1 : ASSERT(0 != tmp->data_size);
368 : :
369 : : /* Add valid sha256 dbx. */
370 : 1 : printf("Add sha256 dbx\n");
371 : 1 : tmp = new_secvar("dbx", 4, dbxauth, dbx_auth_len, 0);
372 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
373 : 1 : list_add_tail(&update_bank, &tmp->link);
374 : 1 : ASSERT(1 == list_length(&update_bank));
375 : :
376 : 1 : rc = edk2_compat_process(&variable_bank, &update_bank);
377 : 1 : ASSERT(OPAL_SUCCESS == rc);
378 : 1 : ASSERT(5 == list_length(&variable_bank));
379 : 1 : ASSERT(0 == list_length(&update_bank));
380 : 1 : tmp = find_secvar("db", 3, &variable_bank);
381 : 1 : ASSERT(NULL != tmp);
382 : 1 : ASSERT(0 != tmp->data_size);
383 : :
384 : : /* Add invalid KEK, .process(), should fail. Timestamp check failure. */
385 : 1 : printf("Add invalid KEK\n");
386 : 1 : tmp = new_secvar("KEK", 4, InvalidKEK_auth, InvalidKEK_auth_len, 0);
387 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
388 : 1 : list_add_tail(&update_bank, &tmp->link);
389 : 1 : ASSERT(1 == list_length(&update_bank));
390 : :
391 : 1 : rc = edk2_compat_process(&variable_bank, &update_bank);
392 : 1 : ASSERT(OPAL_PERMISSION == rc);
393 : 1 : ASSERT(5 == list_length(&variable_bank));
394 : 1 : ASSERT(0 == list_length(&update_bank));
395 : 1 : tmp = find_secvar("KEK", 4, &variable_bank);
396 : 1 : ASSERT(NULL != tmp);
397 : 1 : ASSERT(0 != tmp->data_size);
398 : :
399 : : /* Add ill formatted KEK, .process(), should fail. */
400 : 1 : printf("Add invalid KEK\n");
401 : 1 : tmp = new_secvar("KEK", 4, MalformedKEK_auth, MalformedKEK_auth_len, 0);
402 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
403 : 1 : list_add_tail(&update_bank, &tmp->link);
404 : 1 : ASSERT(1 == list_length(&update_bank));
405 : :
406 : 1 : rc = edk2_compat_process(&variable_bank, &update_bank);
407 : 1 : ASSERT(OPAL_PARAMETER == rc);
408 : 1 : ASSERT(5 == list_length(&variable_bank));
409 : 1 : ASSERT(0 == list_length(&update_bank));
410 : 1 : tmp = find_secvar("KEK", 4, &variable_bank);
411 : 1 : ASSERT(NULL != tmp);
412 : 1 : ASSERT(0 != tmp->data_size);
413 : :
414 : : /* Add multiple db and then multiple KEKs.
415 : : * The db should be signed with a KEK yet to be added.
416 : : */
417 : 1 : printf("Add multiple db\n");
418 : 1 : tmp = new_secvar("db", 3, multipleDB_auth, multipleDB_auth_len, 0);
419 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
420 : 1 : list_add_tail(&update_bank, &tmp->link);
421 : 1 : ASSERT(1 == list_length(&update_bank));
422 : 1 : printf("Add multiple KEK\n");
423 : 1 : tmp = new_secvar("KEK", 4, multipleKEK_auth, multipleKEK_auth_len, 0);
424 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
425 : 1 : list_add_tail(&update_bank, &tmp->link);
426 : 1 : ASSERT(2 == list_length(&update_bank));
427 : :
428 : 1 : rc = edk2_compat_process(&variable_bank, &update_bank);
429 : 1 : ASSERT(OPAL_PERMISSION == rc);
430 : 1 : ASSERT(5 == list_length(&variable_bank));
431 : 1 : ASSERT(0 == list_length(&update_bank));
432 : :
433 : : /* Add multiple KEK ESLs with w one missing 5 bytes */
434 : 1 : printf("Add multiple KEK with one trimmed\n");
435 : 1 : tmp = new_secvar("KEK", 4, multipletrimmedKEK_auth, multipletrimmedKEK_auth_len, 0);
436 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
437 : 1 : list_add_tail(&update_bank, &tmp->link);
438 : 1 : ASSERT(1 == list_length(&update_bank));
439 : :
440 : 1 : rc = edk2_compat_process(&variable_bank, &update_bank);
441 : 1 : ASSERT(OPAL_PARAMETER == rc);
442 : 1 : ASSERT(5 == list_length(&variable_bank));
443 : 1 : ASSERT(0 == list_length(&update_bank));
444 : 1 : tmp = find_secvar("KEK", 4, &variable_bank);
445 : 1 : ASSERT(NULL != tmp);
446 : 1 : ASSERT(0 != tmp->data_size);
447 : :
448 : : /* Add multiple KEK ESLs, one of them should sign the db. */
449 : 1 : printf("Add multiple KEK\n");
450 : 1 : tmp = new_secvar("KEK", 4, multipleKEK_auth, multipleKEK_auth_len, 0);
451 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
452 : 1 : list_add_tail(&update_bank, &tmp->link);
453 : 1 : ASSERT(1 == list_length(&update_bank));
454 : 1 : printf("Add multiple db\n");
455 : 1 : tmp = new_secvar("db", 3, multipleDB_auth, multipleDB_auth_len, 0);
456 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
457 : 1 : list_add_tail(&update_bank, &tmp->link);
458 : 1 : ASSERT(2 == list_length(&update_bank));
459 : :
460 : 1 : rc = edk2_compat_process(&variable_bank, &update_bank);
461 : 1 : ASSERT(OPAL_SUCCESS == rc);
462 : 1 : ASSERT(5 == list_length(&variable_bank));
463 : 1 : ASSERT(0 == list_length(&update_bank));
464 : 1 : tmp = find_secvar("KEK", 4, &variable_bank);
465 : 1 : ASSERT(NULL != tmp);
466 : 1 : ASSERT(0 != tmp->data_size);
467 : 1 : tmp = find_secvar("db", 3, &variable_bank);
468 : 1 : ASSERT(NULL != tmp);
469 : 1 : ASSERT(0 != tmp->data_size);
470 : :
471 : : /* Add db with signeddata PKCS7 format. */
472 : 1 : printf("DB with signed data\n");
473 : 1 : tmp = new_secvar("db", 3, dbsigneddata_auth, dbsigneddata_auth_len, 0);
474 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
475 : 1 : list_add_tail(&update_bank, &tmp->link);
476 : 1 : ASSERT(1 == list_length(&update_bank));
477 : :
478 : 1 : rc = edk2_compat_process(&variable_bank, &update_bank);
479 : 1 : ASSERT(OPAL_SUCCESS == rc);
480 : 1 : ASSERT(5 == list_length(&variable_bank));
481 : 1 : ASSERT(0 == list_length(&update_bank));
482 : 1 : tmp = find_secvar("db", 3, &variable_bank);
483 : 1 : ASSERT(NULL != tmp);
484 : 1 : ASSERT(0 != tmp->data_size);
485 : :
486 : : /* Delete PK and invalid dbx - to test queued updates for deleting PK. */
487 : 1 : printf("Delete PK\n");
488 : : /* Add hw_key_hash explicitly to ensure it is deleted as part of PK deletion. */
489 : 1 : add_hw_key_hash(&variable_bank);
490 : 1 : ASSERT(6 == list_length(&variable_bank));
491 : 1 : tmp = new_secvar("PK", 3, noPK_auth, noPK_auth_len, 0);
492 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
493 : 1 : list_add_tail(&update_bank, &tmp->link);
494 : 1 : ASSERT(1 == list_length(&update_bank));
495 : 1 : printf("Add invalid dbx\n");
496 : 1 : tmp = new_secvar("dbx", 4, wrongdbxauth, wrong_dbx_auth_len, 0);
497 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
498 : 1 : list_add_tail(&update_bank, &tmp->link);
499 : 1 : ASSERT(2 == list_length(&update_bank));
500 : 1 : rc = edk2_compat_process(&variable_bank, &update_bank);
501 : 1 : ASSERT(OPAL_PARAMETER == rc);
502 : 1 : ASSERT(6 == list_length(&variable_bank));
503 : 1 : ASSERT(0 == list_length(&update_bank));
504 : 1 : rc = edk2_compat_post_process(&variable_bank, &update_bank);
505 : 1 : ASSERT(5 == list_length(&variable_bank));
506 : 1 : tmp = find_secvar("PK", 3, &variable_bank);
507 : 1 : ASSERT(NULL != tmp);
508 : 1 : ASSERT(0 != tmp->data_size);
509 : 1 : ASSERT(!setup_mode);
510 : :
511 : : /* updates with pkcs#7 messages with sha512 hashes should be rejected */
512 : 1 : printf("Add db where auth has sha512 in PKCS#7\n");
513 : 1 : tmp = new_secvar("db", 3, pkcs7_sha512, pkcs7_sha512_len, 0);
514 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
515 : 1 : list_add_tail(&update_bank, &tmp->link);
516 : 1 : ASSERT(1 == list_length(&update_bank));
517 : :
518 : 1 : rc = edk2_compat_process(&variable_bank, &update_bank);
519 : 1 : ASSERT(OPAL_PARAMETER == rc);
520 : 1 : ASSERT(5 == list_length(&variable_bank));
521 : 1 : ASSERT(0 == list_length(&update_bank));
522 : :
523 : : /* Delete PK. */
524 : 1 : printf("Delete PK\n");
525 : : /* Add hw_key_hash explicitly to ensure it is deleted as part of PK deletion. */
526 : 1 : add_hw_key_hash(&variable_bank);
527 : 1 : ASSERT(6 == list_length(&variable_bank));
528 : 1 : tmp = new_secvar("PK", 3, noPK_auth, noPK_auth_len, 0);
529 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
530 : 1 : list_add_tail(&update_bank, &tmp->link);
531 : 1 : ASSERT(1 == list_length(&update_bank));
532 : :
533 : 1 : rc = edk2_compat_process(&variable_bank, &update_bank);
534 : 1 : ASSERT(OPAL_SUCCESS == rc);
535 : 1 : ASSERT(5 == list_length(&variable_bank));
536 : 1 : ASSERT(0 == list_length(&update_bank));
537 : 1 : rc = edk2_compat_post_process(&variable_bank, &update_bank);
538 : 1 : ASSERT(5 == list_length(&variable_bank));
539 : 1 : tmp = find_secvar("PK", 3, &variable_bank);
540 : 1 : ASSERT(NULL != tmp);
541 : 1 : ASSERT(0 == tmp->data_size);
542 : 1 : ASSERT(setup_mode);
543 : :
544 : : /* Add multiple PK. */
545 : 1 : printf("Multiple PK\n");
546 : 1 : tmp = new_secvar("PK", 3, multiplePK_auth, multiplePK_auth_len, 0);
547 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
548 : 1 : list_add_tail(&update_bank, &tmp->link);
549 : 1 : ASSERT(1 == list_length(&update_bank));
550 : :
551 : 1 : rc = edk2_compat_process(&variable_bank, &update_bank);
552 : 1 : ASSERT(OPAL_PARAMETER == rc);
553 : 1 : ASSERT(5 == list_length(&variable_bank));
554 : 1 : ASSERT(0 == list_length(&update_bank));
555 : 1 : tmp = find_secvar("PK", 3, &variable_bank);
556 : 1 : ASSERT(NULL != tmp);
557 : 1 : ASSERT(0 == tmp->data_size);
558 : 1 : ASSERT(setup_mode);
559 : :
560 : : /* Add invalid dbx like with wrong GUID. */
561 : 1 : printf("Add invalid dbx\n");
562 : 1 : tmp = new_secvar("dbx", 4, wrongdbxauth, wrong_dbx_auth_len, 0);
563 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
564 : 1 : list_add_tail(&update_bank, &tmp->link);
565 : 1 : ASSERT(1 == list_length(&update_bank));
566 : :
567 : 1 : rc = edk2_compat_process(&variable_bank, &update_bank);
568 : 1 : ASSERT(OPAL_PARAMETER == rc);
569 : 1 : ASSERT(5 == list_length(&variable_bank));
570 : 1 : ASSERT(0 == list_length(&update_bank));
571 : :
572 : : /* Ensure sha512 dbx is considered as valid. */
573 : 1 : printf("Add sha512 dbx\n");
574 : 1 : tmp = new_secvar("dbx", 4, dbx512, dbx512_auth_len, 0);
575 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
576 : 1 : list_add_tail(&update_bank, &tmp->link);
577 : 1 : ASSERT(1 == list_length(&update_bank));
578 : :
579 : 1 : rc = edk2_compat_process(&variable_bank, &update_bank);
580 : 1 : ASSERT(OPAL_SUCCESS == rc);
581 : 1 : ASSERT(5 == list_length(&variable_bank));
582 : 1 : ASSERT(0 == list_length(&update_bank));
583 : 1 : tmp = find_secvar("dbx", 4, &variable_bank);
584 : 1 : ASSERT(NULL != tmp);
585 : 1 : ASSERT(0 != tmp->data_size);
586 : :
587 : : /* We do not support cert as dbx. */
588 : 1 : printf("Add db(cert) as dbx\n");
589 : 1 : tmp = new_secvar("dbx", 4, dbx_cert_auth, sizeof(dbx_cert_auth), 0);
590 : 1 : ASSERT(0 == edk2_compat_validate(tmp));
591 : 1 : list_add_tail(&update_bank, &tmp->link);
592 : 1 : ASSERT(1 == list_length(&update_bank));
593 : :
594 : 1 : rc = edk2_compat_process(&variable_bank, &update_bank);
595 : 1 : ASSERT(OPAL_PARAMETER == rc);
596 : 1 : ASSERT(5 == list_length(&variable_bank));
597 : 1 : ASSERT(0 == list_length(&update_bank));
598 : :
599 : 1 : return 0;
600 : : }
601 : :
602 : 1 : int main(void)
603 : : {
604 : : int rc;
605 : :
606 : 1 : list_head_init(&variable_bank);
607 : 1 : list_head_init(&update_bank);
608 : :
609 : 1 : secvar_storage.max_var_size = 4096;
610 : :
611 : 1 : rc = run_test();
612 : :
613 : 1 : clear_bank_list(&variable_bank);
614 : 1 : clear_bank_list(&update_bank);
615 : :
616 : 1 : return rc;
617 : : }
|
