Debian Codegraph @

lib/variables.c

raw
1 // SPDX-License-Identifier: BSD-2-Clause-Patent
2 /*
3 * Copyright 2012 <[email protected]>
4 *
5 * Portions of this file are a direct cut and paste from Tianocore
6 * (http://tianocore.sf.net)
7 *
8 * SecurityPkg/VariableAuthenticated/SecureBootConfigDxe/SecureBootConfigImpl.c
9 *
10 * Copyright (c) 2011 - 2012, Intel Corporation. All rights reserved.<BR>
11 *
12 */
13 #include "shim.h"
14
15 extern EFI_SYSTEM_TABLE *ST;
16 extern EFI_BOOT_SERVICES *BS;
17 extern EFI_RUNTIME_SERVICES *RT;
18
19 EFI_STATUS
20 fill_esl(const EFI_SIGNATURE_DATA *first_sig, const size_t howmany,
21 const EFI_GUID *type, const UINT32 sig_size,
22 uint8_t *out, size_t *outlen)
23 {
24 EFI_SIGNATURE_LIST *sl;
25 EFI_SIGNATURE_DATA *sd;
26 size_t needed = 0;
27 size_t data_len = howmany * sig_size;
28
29 dprint(L"fill_esl: first_sig=0x%llx, data_len=%lu\n", first_sig, data_len);
30
31 if ((out && !first_sig) || !howmany || !type || !sig_size || !outlen)
32 return EFI_INVALID_PARAMETER;
33
34 if (howmany > (UINT32_MAX - sizeof(EFI_SIGNATURE_LIST)) / sig_size)
35 return EFI_INVALID_PARAMETER;
36
37 needed = sizeof(EFI_SIGNATURE_LIST) + data_len;
38 if (!out || *outlen < needed) {
39 *outlen = needed;
40 return EFI_BUFFER_TOO_SMALL;
41 }
42
43 *outlen = needed;
44 sl = (EFI_SIGNATURE_LIST *)out;
45
46 sl->SignatureHeaderSize = 0;
47 sl->SignatureType = *type;
48 sl->SignatureSize = sig_size;
49 sl->SignatureListSize = needed;
50
51 sd = (EFI_SIGNATURE_DATA *)(out + sizeof(EFI_SIGNATURE_LIST));
52 CopyMem(sd, (void *)first_sig, data_len);
53
54 return EFI_SUCCESS;
55 }
56
57 EFI_STATUS
58 fill_esl_with_one_signature(const uint8_t *data, const uint32_t data_len,
59 const EFI_GUID *type, const EFI_GUID *owner,
60 uint8_t *out, size_t *outlen)
61 {
62 EFI_STATUS efi_status;
63 EFI_SIGNATURE_DATA *sd = NULL;
64 UINT32 sig_size = sizeof(EFI_SIGNATURE_DATA) - 1 + data_len;
65
66 if (data_len > UINT32_MAX - sizeof(EFI_SIGNATURE_DATA) + 1)
67 return EFI_INVALID_PARAMETER;
68
69 if (out) {
70 sd = AllocateZeroPool(sig_size);
71 if (!sd)
72 return EFI_OUT_OF_RESOURCES;
73 if (owner)
74 CopyMem(sd, (void *)owner, sizeof(EFI_GUID));
75 CopyMem(sd->SignatureData, (void *)data, data_len);
76 }
77
78 efi_status = fill_esl(sd, 1, type, sig_size, out, outlen);
79
80 if (out)
81 FreePool(sd);
82 return efi_status;
83 }
84
85 EFI_STATUS
86 variable_create_esl(const EFI_SIGNATURE_DATA *first_sig, const size_t howmany,
87 const EFI_GUID *type, const UINT32 sig_size,
88 uint8_t **out, size_t *outlen)
89 {
90 EFI_STATUS efi_status;
91
92 *outlen = 0;
93 efi_status = fill_esl(first_sig, howmany, type, sig_size, NULL, outlen);
94 if (efi_status != EFI_BUFFER_TOO_SMALL)
95 return efi_status;
96
97 *out = AllocateZeroPool(*outlen);
98 if (!*out)
99 return EFI_OUT_OF_RESOURCES;
100
101 return fill_esl(first_sig, howmany, type, sig_size, *out, outlen);
102 }
103
104 EFI_STATUS
105 variable_create_esl_with_one_signature(const uint8_t* data, const size_t data_len,
106 const EFI_GUID *type, const EFI_GUID *owner,
107 uint8_t **out, size_t *outlen)
108 {
109 EFI_STATUS efi_status;
110
111 *outlen = 0;
112 efi_status = fill_esl_with_one_signature(data, data_len, type, owner,
113 NULL, outlen);
114 if (efi_status != EFI_BUFFER_TOO_SMALL)
115 return efi_status;
116
117 *out = AllocateZeroPool(*outlen);
118 if (!*out)
119 return EFI_OUT_OF_RESOURCES;
120
121 return fill_esl_with_one_signature(data, data_len, type, owner, *out,
122 outlen);
123 }
124
125 EFI_STATUS
126 CreateTimeBasedPayload(IN OUT UINTN * DataSize, IN OUT UINT8 ** Data)
127 {
128 EFI_STATUS efi_status;
129 UINT8 *NewData;
130 UINT8 *Payload;
131 UINTN PayloadSize;
132 EFI_VARIABLE_AUTHENTICATION_2 *DescriptorData;
133 UINTN DescriptorSize;
134 EFI_TIME Time;
135
136 if (Data == NULL || DataSize == NULL) {
137 return EFI_INVALID_PARAMETER;
138 }
139 /*
140 * In Setup mode or Custom mode, the variable does not need to be
141 * signed but the
142 * parameters to the SetVariable() call still need to be prepared as
143 * authenticated variable. So we create EFI_VARIABLE_AUTHENTICATED_2
144 * descriptor without certificate data in it.
145 */
146 Payload = *Data;
147 PayloadSize = *DataSize;
148
149 DescriptorSize = offsetof(EFI_VARIABLE_AUTHENTICATION_2, AuthInfo)
150 + offsetof(WIN_CERTIFICATE_UEFI_GUID, CertData);
151 NewData = (UINT8 *) AllocateZeroPool(DescriptorSize + PayloadSize);
152 if (NewData == NULL) {
153 return EFI_OUT_OF_RESOURCES;
154 }
155
156 if ((Payload != NULL) && (PayloadSize != 0)) {
157 CopyMem(NewData + DescriptorSize, Payload, PayloadSize);
158 }
159
160 DescriptorData = (EFI_VARIABLE_AUTHENTICATION_2 *) (NewData);
161
162 ZeroMem(&Time, sizeof(EFI_TIME));
163 efi_status = RT->GetTime(&Time, NULL);
164 if (EFI_ERROR(efi_status)) {
165 FreePool(NewData);
166 return efi_status;
167 }
168 Time.Pad1 = 0;
169 Time.Nanosecond = 0;
170 Time.TimeZone = 0;
171 Time.Daylight = 0;
172 Time.Pad2 = 0;
173 CopyMem(&DescriptorData->TimeStamp, &Time, sizeof(EFI_TIME));
174
175 DescriptorData->AuthInfo.Hdr.dwLength =
176 offsetof(WIN_CERTIFICATE_UEFI_GUID, CertData);
177 DescriptorData->AuthInfo.Hdr.wRevision = 0x0200;
178 DescriptorData->AuthInfo.Hdr.wCertificateType = WIN_CERT_TYPE_EFI_GUID;
179 DescriptorData->AuthInfo.CertType = EFI_CERT_TYPE_PKCS7_GUID;
180
181 /*
182 * we're expecting an EFI signature list, so don't free the input
183 * since it might not be in a pool
184 */
185 #if 0
186 if (Payload != NULL) {
187 FreePool(Payload);
188 }
189 #endif
190
191 *DataSize = DescriptorSize + PayloadSize;
192 *Data = NewData;
193 return EFI_SUCCESS;
194 }
195
196 EFI_STATUS
197 SetSecureVariable(const CHAR16 * const var, UINT8 *Data, UINTN len,
198 EFI_GUID owner, UINT32 options, int createtimebased)
199 {
200 EFI_SIGNATURE_LIST *Cert;
201 UINTN DataSize;
202 EFI_STATUS efi_status;
203
204 /* Microsoft request: Bugs in some UEFI platforms mean that PK or any
205 * other secure variable can be updated or deleted programmatically,
206 * so prevent */
207 if (!variable_is_setupmode(1))
208 return EFI_SECURITY_VIOLATION;
209
210 if (createtimebased) {
211 size_t ds;
212 efi_status = variable_create_esl_with_one_signature(
213 Data, len, &X509_GUID, NULL,
214 (uint8_t **)&Cert, &ds);
215 if (EFI_ERROR(efi_status)) {
216 console_print(L"Failed to create %s certificate %d\n",
217 var, efi_status);
218 return efi_status;
219 }
220
221 DataSize = ds;
222 } else {
223 /* we expect an efi signature list rather than creating it */
224 Cert = (EFI_SIGNATURE_LIST *)Data;
225 DataSize = len;
226 }
227 efi_status = CreateTimeBasedPayload(&DataSize, (UINT8 **)&Cert);
228 if (EFI_ERROR(efi_status)) {
229 if (Cert && Cert != (EFI_SIGNATURE_LIST *)Data)
230 FreePool(Cert);
231 console_print(L"Failed to create time based payload %d\n",
232 efi_status);
233 return efi_status;
234 }
235
236 efi_status = RT->SetVariable((CHAR16 *)var, &owner,
237 EFI_VARIABLE_NON_VOLATILE |
238 EFI_VARIABLE_RUNTIME_ACCESS |
239 EFI_VARIABLE_BOOTSERVICE_ACCESS |
240 EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS |
241 options, DataSize, Cert);
242 return efi_status;
243 }
244
245 UINT64
246 GetOSIndications(void)
247 {
248 UINT64 indications;
249 UINTN DataSize = sizeof(indications);
250 EFI_STATUS efi_status;
251
252 efi_status = RT->GetVariable(L"OsIndicationsSupported", &GV_GUID,
253 NULL, &DataSize, &indications);
254 if (EFI_ERROR(efi_status))
255 return 0;
256
257 return indications;
258 }
259
260 EFI_STATUS
261 SETOSIndicationsAndReboot(UINT64 indications)
262 {
263 UINTN DataSize = sizeof(indications);
264 EFI_STATUS efi_status;
265
266 efi_status = RT->SetVariable(L"OsIndications", &GV_GUID,
267 EFI_VARIABLE_NON_VOLATILE |
268 EFI_VARIABLE_RUNTIME_ACCESS |
269 EFI_VARIABLE_BOOTSERVICE_ACCESS,
270 DataSize, &indications);
271 if (EFI_ERROR(efi_status))
272 return efi_status;
273
274 RT->ResetSystem(EfiResetWarm, EFI_SUCCESS, 0, NULL);
275 /* does not return */
276
277 return EFI_SUCCESS;
278 }
279
280 EFI_STATUS
281 get_variable_attr(const CHAR16 * const var, UINT8 **data, UINTN *len,
282 EFI_GUID owner, UINT32 *attributes)
283 {
284 EFI_STATUS efi_status;
285
286 if (!len)
287 return EFI_INVALID_PARAMETER;
288
289 *len = 0;
290
291 efi_status = RT->GetVariable((CHAR16 *)var, &owner, NULL, len, NULL);
292 if (efi_status != EFI_BUFFER_TOO_SMALL) {
293 if (!EFI_ERROR(efi_status)) /* this should never happen */
294 return EFI_PROTOCOL_ERROR;
295 return efi_status;
296 }
297
298 if (!data)
299 return EFI_INVALID_PARAMETER;
300
301 /*
302 * Add three zero pad bytes; at least one correctly aligned UCS-2
303 * character.
304 */
305 *data = AllocateZeroPool(*len + 3);
306 if (!*data)
307 return EFI_OUT_OF_RESOURCES;
308
309 efi_status = RT->GetVariable((CHAR16 *)var, &owner, attributes, len, *data);
310 if (EFI_ERROR(efi_status)) {
311 FreePool(*data);
312 *data = NULL;
313 }
314
315 return efi_status;
316 }
317
318 EFI_STATUS
319 get_variable(const CHAR16 * const var, UINT8 **data, UINTN *len, EFI_GUID owner)
320 {
321 return get_variable_attr(var, data, len, owner, NULL);
322 }
323
324 EFI_STATUS
325 get_variable_size(const CHAR16 * const var, EFI_GUID owner, UINTN *lenp)
326 {
327 UINTN len = 0;
328 EFI_STATUS efi_status;
329
330 efi_status = get_variable_attr(var, NULL, &len, owner, NULL);
331 if (EFI_ERROR(efi_status)) {
332 if (efi_status == EFI_BUFFER_TOO_SMALL) {
333 *lenp = len;
334 return EFI_SUCCESS;
335 } else if (efi_status == EFI_NOT_FOUND) {
336 *lenp = 0;
337 return EFI_SUCCESS;
338 }
339 return efi_status;
340 }
341 /*
342 * who knows what this means, but...
343 */
344 *lenp = len;
345 return efi_status;
346 }
347
348 EFI_STATUS
349 set_variable(CHAR16 *var, EFI_GUID owner, UINT32 attributes,
350 UINTN datasize, void *data)
351 {
352 return RT->SetVariable(var, &owner, attributes, datasize, data);
353 }
354
355 EFI_STATUS
356 del_variable(CHAR16 *var, EFI_GUID owner)
357 {
358 return set_variable(var, owner, 0, 0, "");
359 }
360
361 EFI_STATUS
362 find_in_esl(UINT8 *Data, UINTN DataSize, UINT8 *key, UINTN keylen)
363 {
364 EFI_SIGNATURE_LIST *CertList;
365
366 certlist_for_each_certentry(CertList, Data, DataSize, DataSize) {
367 if (CertList->SignatureSize != keylen + sizeof(EFI_GUID))
368 continue;
369 EFI_SIGNATURE_DATA *Cert;
370
371 certentry_for_each_cert(Cert, CertList)
372 if (CompareMem (Cert->SignatureData, key, keylen) == 0)
373 return EFI_SUCCESS;
374 }
375 return EFI_NOT_FOUND;
376 }
377
378 EFI_STATUS
379 find_in_variable_esl(const CHAR16 * const var, EFI_GUID owner, UINT8 *key,
380 UINTN keylen)
381 {
382 UINTN DataSize = 0;
383 UINT8 *Data = NULL;
384 EFI_STATUS efi_status;
385
386 efi_status = get_variable(var, &Data, &DataSize, owner);
387 if (EFI_ERROR(efi_status))
388 return efi_status;
389
390 efi_status = find_in_esl(Data, DataSize, key, keylen);
391
392 FreePool(Data);
393
394 return efi_status;
395 }
396
397 int
398 variable_is_setupmode(int default_return)
399 {
400 /* set to 1 because we return true if SetupMode doesn't exist */
401 UINT8 SetupMode = default_return;
402 UINTN DataSize = sizeof(SetupMode);
403 EFI_STATUS efi_status;
404
405 efi_status = RT->GetVariable(L"SetupMode", &GV_GUID, NULL,
406 &DataSize, &SetupMode);
407 if (EFI_ERROR(efi_status))
408 return default_return;
409
410 return SetupMode;
411 }
412
413 int
414 variable_is_secureboot(void)
415 {
416 /* return false if variable doesn't exist */
417 UINT8 SecureBoot = 0;
418 UINTN DataSize;
419 EFI_STATUS efi_status;
420
421 DataSize = sizeof(SecureBoot);
422 efi_status = RT->GetVariable(L"SecureBoot", &GV_GUID, NULL,
423 &DataSize, &SecureBoot);
424 if (EFI_ERROR(efi_status))
425 return 0;
426
427 return SecureBoot;
428 }
429
430 EFI_STATUS
431 variable_enroll_hash(const CHAR16 * const var, EFI_GUID owner,
432 UINT8 hash[SHA256_DIGEST_SIZE])
433 {
434 EFI_STATUS efi_status;
435
436 efi_status = find_in_variable_esl(var, owner, hash, SHA256_DIGEST_SIZE);
437 if (!EFI_ERROR(efi_status))
438 /* hash already present */
439 return EFI_ALREADY_STARTED;
440
441 UINT8 sig[sizeof(EFI_SIGNATURE_LIST)
442 + sizeof(EFI_SIGNATURE_DATA) - 1 + SHA256_DIGEST_SIZE];
443 EFI_SIGNATURE_LIST *l = (void *)sig;
444 EFI_SIGNATURE_DATA *d = (void *)sig + sizeof(EFI_SIGNATURE_LIST);
445 SetMem(sig, 0, sizeof(sig));
446 l->SignatureType = EFI_CERT_SHA256_GUID;
447 l->SignatureListSize = sizeof(sig);
448 l->SignatureSize = 16 +32; /* UEFI defined */
449 CopyMem(&d->SignatureData, hash, SHA256_DIGEST_SIZE);
450 d->SignatureOwner = SHIM_LOCK_GUID;
451
452 if (CompareGuid(&owner, &SIG_DB) == 0)
453 efi_status = SetSecureVariable(var, sig, sizeof(sig), owner,
454 EFI_VARIABLE_APPEND_WRITE, 0);
455 else
456 efi_status = RT->SetVariable((CHAR16 *)var, &owner,
457 EFI_VARIABLE_NON_VOLATILE |
458 EFI_VARIABLE_BOOTSERVICE_ACCESS |
459 EFI_VARIABLE_APPEND_WRITE,
460 sizeof(sig), sig);
461 return efi_status;
462 }