]> git.proxmox.com Git - mirror_edk2.git/blame_incremental - SecurityPkg/VariableAuthenticated/SecureBootConfigDxe/SecureBootConfigImpl.c
projects / mirror_edk2.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
SecurityPkg: AuthVariableLib & SecureBootConfigDxe: Fix SecureBootEnable & PK inconsi...
[mirror_edk2.git] / SecurityPkg / VariableAuthenticated / SecureBootConfigDxe / SecureBootConfigImpl.c
... / ...
CommitLineData
1/** @file\r
2 HII Config Access protocol implementation of SecureBoot configuration module.\r
3\r
4Copyright (c) 2011 - 2016, Intel Corporation. All rights reserved.<BR>\r
5This program and the accompanying materials\r
6are licensed and made available under the terms and conditions of the BSD License\r
7which accompanies this distribution. The full text of the license may be found at\r
8http://opensource.org/licenses/bsd-license.php\r
9\r
10THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
11WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
12\r
13**/\r
14\r
15#include "SecureBootConfigImpl.h"\r
16\r
17CHAR16 mSecureBootStorageName[] = L"SECUREBOOT_CONFIGURATION";\r
18\r
19SECUREBOOT_CONFIG_PRIVATE_DATA mSecureBootConfigPrivateDateTemplate = {\r
20 SECUREBOOT_CONFIG_PRIVATE_DATA_SIGNATURE,\r
21 {\r
22 SecureBootExtractConfig,\r
23 SecureBootRouteConfig,\r
24 SecureBootCallback\r
25 }\r
26};\r
27\r
28HII_VENDOR_DEVICE_PATH mSecureBootHiiVendorDevicePath = {\r
29 {\r
30 {\r
31 HARDWARE_DEVICE_PATH,\r
32 HW_VENDOR_DP,\r
33 {\r
34 (UINT8) (sizeof (VENDOR_DEVICE_PATH)),\r
35 (UINT8) ((sizeof (VENDOR_DEVICE_PATH)) >> 8)\r
36 }\r
37 },\r
38 SECUREBOOT_CONFIG_FORM_SET_GUID\r
39 },\r
40 {\r
41 END_DEVICE_PATH_TYPE,\r
42 END_ENTIRE_DEVICE_PATH_SUBTYPE,\r
43 {\r
44 (UINT8) (END_DEVICE_PATH_LENGTH),\r
45 (UINT8) ((END_DEVICE_PATH_LENGTH) >> 8)\r
46 }\r
47 }\r
48};\r
49\r
50\r
51BOOLEAN mIsEnterSecureBootForm = FALSE;\r
52BOOLEAN mIsSelectedSecureBootModeForm = FALSE;\r
53BOOLEAN mIsSecureBootModeChanged = FALSE;\r
54\r
55//\r
56// OID ASN.1 Value for Hash Algorithms\r
57//\r
58UINT8 mHashOidValue[] = {\r
59 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x02, 0x05, // OBJ_md5\r
60 0x2B, 0x0E, 0x03, 0x02, 0x1A, // OBJ_sha1\r
61 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x04, // OBJ_sha224\r
62 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, // OBJ_sha256\r
63 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, // OBJ_sha384\r
64 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, // OBJ_sha512\r
65 };\r
66\r
67HASH_TABLE mHash[] = {\r
68 { L"SHA1", 20, &mHashOidValue[8], 5, Sha1GetContextSize, Sha1Init, Sha1Update, Sha1Final },\r
69 { L"SHA224", 28, &mHashOidValue[13], 9, NULL, NULL, NULL, NULL },\r
70 { L"SHA256", 32, &mHashOidValue[22], 9, Sha256GetContextSize, Sha256Init, Sha256Update, Sha256Final},\r
71 { L"SHA384", 48, &mHashOidValue[31], 9, Sha384GetContextSize, Sha384Init, Sha384Update, Sha384Final},\r
72 { L"SHA512", 64, &mHashOidValue[40], 9, Sha512GetContextSize, Sha512Init, Sha512Update, Sha512Final}\r
73};\r
74\r
75//\r
76// Variable Definitions\r
77//\r
78UINT32 mPeCoffHeaderOffset = 0;\r
79WIN_CERTIFICATE *mCertificate = NULL;\r
80IMAGE_TYPE mImageType;\r
81UINT8 *mImageBase = NULL;\r
82UINTN mImageSize = 0;\r
83UINT8 mImageDigest[MAX_DIGEST_SIZE];\r
84UINTN mImageDigestSize;\r
85EFI_GUID mCertType;\r
86EFI_IMAGE_SECURITY_DATA_DIRECTORY *mSecDataDir = NULL;\r
87EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION mNtHeader;\r
88\r
89//\r
90// Possible DER-encoded certificate file suffixes, end with NULL pointer.\r
91//\r
92CHAR16* mDerEncodedSuffix[] = {\r
93 L".cer",\r
94 L".der",\r
95 L".crt",\r
96 NULL\r
97};\r
98CHAR16* mSupportX509Suffix = L"*.cer/der/crt";\r
99\r
100SECUREBOOT_CONFIG_PRIVATE_DATA *gSecureBootPrivateData = NULL;\r
101\r
102/**\r
103 This code checks if the FileSuffix is one of the possible DER-encoded certificate suffix.\r
104\r
105 @param[in] FileSuffix The suffix of the input certificate file\r
106\r
107 @retval TRUE It's a DER-encoded certificate.\r
108 @retval FALSE It's NOT a DER-encoded certificate.\r
109\r
110**/\r
111BOOLEAN\r
112IsDerEncodeCertificate (\r
113 IN CONST CHAR16 *FileSuffix\r
114)\r
115{\r
116 UINTN Index;\r
117 for (Index = 0; mDerEncodedSuffix[Index] != NULL; Index++) {\r
118 if (StrCmp (FileSuffix, mDerEncodedSuffix[Index]) == 0) {\r
119 return TRUE;\r
120 }\r
121 }\r
122 return FALSE;\r
123}\r
124\r
125/**\r
126 Set Secure Boot option into variable space.\r
127\r
128 @param[in] VarValue The option of Secure Boot.\r
129\r
130 @retval EFI_SUCCESS The operation is finished successfully.\r
131 @retval Others Other errors as indicated.\r
132\r
133**/\r
134EFI_STATUS\r
135SaveSecureBootVariable (\r
136 IN UINT8 VarValue\r
137 )\r
138{\r
139 EFI_STATUS Status;\r
140\r
141 Status = gRT->SetVariable (\r
142 EFI_SECURE_BOOT_ENABLE_NAME,\r
143 &gEfiSecureBootEnableDisableGuid,\r
144 EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,\r
145 sizeof (UINT8),\r
146 &VarValue\r
147 );\r
148 return Status;\r
149}\r
150\r
151/**\r
152 Create a time based data payload by concatenating the EFI_VARIABLE_AUTHENTICATION_2\r
153 descriptor with the input data. NO authentication is required in this function.\r
154\r
155 @param[in, out] DataSize On input, the size of Data buffer in bytes.\r
156 On output, the size of data returned in Data\r
157 buffer in bytes.\r
158 @param[in, out] Data On input, Pointer to data buffer to be wrapped or\r
159 pointer to NULL to wrap an empty payload.\r
160 On output, Pointer to the new payload date buffer allocated from pool,\r
161 it's caller's responsibility to free the memory when finish using it.\r
162\r
163 @retval EFI_SUCCESS Create time based payload successfully.\r
164 @retval EFI_OUT_OF_RESOURCES There are not enough memory resourses to create time based payload.\r
165 @retval EFI_INVALID_PARAMETER The parameter is invalid.\r
166 @retval Others Unexpected error happens.\r
167\r
168**/\r
169EFI_STATUS\r
170CreateTimeBasedPayload (\r
171 IN OUT UINTN *DataSize,\r
172 IN OUT UINT8 **Data\r
173 )\r
174{\r
175 EFI_STATUS Status;\r
176 UINT8 *NewData;\r
177 UINT8 *Payload;\r
178 UINTN PayloadSize;\r
179 EFI_VARIABLE_AUTHENTICATION_2 *DescriptorData;\r
180 UINTN DescriptorSize;\r
181 EFI_TIME Time;\r
182\r
183 if (Data == NULL || DataSize == NULL) {\r
184 return EFI_INVALID_PARAMETER;\r
185 }\r
186\r
187 //\r
188 // In Setup mode or Custom mode, the variable does not need to be signed but the\r
189 // parameters to the SetVariable() call still need to be prepared as authenticated\r
190 // variable. So we create EFI_VARIABLE_AUTHENTICATED_2 descriptor without certificate\r
191 // data in it.\r
192 //\r
193 Payload = *Data;\r
194 PayloadSize = *DataSize;\r
195\r
196 DescriptorSize = OFFSET_OF (EFI_VARIABLE_AUTHENTICATION_2, AuthInfo) + OFFSET_OF (WIN_CERTIFICATE_UEFI_GUID, CertData);\r
197 NewData = (UINT8*) AllocateZeroPool (DescriptorSize + PayloadSize);\r
198 if (NewData == NULL) {\r
199 return EFI_OUT_OF_RESOURCES;\r
200 }\r
201\r
202 if ((Payload != NULL) && (PayloadSize != 0)) {\r
203 CopyMem (NewData + DescriptorSize, Payload, PayloadSize);\r
204 }\r
205\r
206 DescriptorData = (EFI_VARIABLE_AUTHENTICATION_2 *) (NewData);\r
207\r
208 ZeroMem (&Time, sizeof (EFI_TIME));\r
209 Status = gRT->GetTime (&Time, NULL);\r
210 if (EFI_ERROR (Status)) {\r
211 FreePool(NewData);\r
212 return Status;\r
213 }\r
214 Time.Pad1 = 0;\r
215 Time.Nanosecond = 0;\r
216 Time.TimeZone = 0;\r
217 Time.Daylight = 0;\r
218 Time.Pad2 = 0;\r
219 CopyMem (&DescriptorData->TimeStamp, &Time, sizeof (EFI_TIME));\r
220\r
221 DescriptorData->AuthInfo.Hdr.dwLength = OFFSET_OF (WIN_CERTIFICATE_UEFI_GUID, CertData);\r
222 DescriptorData->AuthInfo.Hdr.wRevision = 0x0200;\r
223 DescriptorData->AuthInfo.Hdr.wCertificateType = WIN_CERT_TYPE_EFI_GUID;\r
224 CopyGuid (&DescriptorData->AuthInfo.CertType, &gEfiCertPkcs7Guid);\r
225\r
226 if (Payload != NULL) {\r
227 FreePool(Payload);\r
228 }\r
229\r
230 *DataSize = DescriptorSize + PayloadSize;\r
231 *Data = NewData;\r
232 return EFI_SUCCESS;\r
233}\r
234\r
235/**\r
236 Internal helper function to delete a Variable given its name and GUID, NO authentication\r
237 required.\r
238\r
239 @param[in] VariableName Name of the Variable.\r
240 @param[in] VendorGuid GUID of the Variable.\r
241\r
242 @retval EFI_SUCCESS Variable deleted successfully.\r
243 @retval Others The driver failed to start the device.\r
244\r
245**/\r
246EFI_STATUS\r
247DeleteVariable (\r
248 IN CHAR16 *VariableName,\r
249 IN EFI_GUID *VendorGuid\r
250 )\r
251{\r
252 EFI_STATUS Status;\r
253 VOID* Variable;\r
254 UINT8 *Data;\r
255 UINTN DataSize;\r
256 UINT32 Attr;\r
257\r
258 GetVariable2 (VariableName, VendorGuid, &Variable, NULL);\r
259 if (Variable == NULL) {\r
260 return EFI_SUCCESS;\r
261 }\r
262 FreePool (Variable);\r
263\r
264 Data = NULL;\r
265 DataSize = 0;\r
266 Attr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS\r
267 | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS;\r
268\r
269 Status = CreateTimeBasedPayload (&DataSize, &Data);\r
270 if (EFI_ERROR (Status)) {\r
271 DEBUG ((EFI_D_ERROR, "Fail to create time-based data payload: %r", Status));\r
272 return Status;\r
273 }\r
274\r
275 Status = gRT->SetVariable (\r
276 VariableName,\r
277 VendorGuid,\r
278 Attr,\r
279 DataSize,\r
280 Data\r
281 );\r
282 if (Data != NULL) {\r
283 FreePool (Data);\r
284 }\r
285 return Status;\r
286}\r
287\r
288/**\r
289\r
290 Set the platform secure boot mode into "Custom" or "Standard" mode.\r
291\r
292 @param[in] SecureBootMode New secure boot mode: STANDARD_SECURE_BOOT_MODE or\r
293 CUSTOM_SECURE_BOOT_MODE.\r
294\r
295 @return EFI_SUCCESS The platform has switched to the special mode successfully.\r
296 @return other Fail to operate the secure boot mode.\r
297\r
298**/\r
299EFI_STATUS\r
300SetSecureBootMode (\r
301 IN UINT8 SecureBootMode\r
302 )\r
303{\r
304 return gRT->SetVariable (\r
305 EFI_CUSTOM_MODE_NAME,\r
306 &gEfiCustomModeEnableGuid,\r
307 EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,\r
308 sizeof (UINT8),\r
309 &SecureBootMode\r
310 );\r
311}\r
312\r
313/**\r
314 Generate the PK signature list from the X509 Certificate storing file (.cer)\r
315\r
316 @param[in] X509File FileHandle of X509 Certificate storing file.\r
317 @param[out] PkCert Point to the data buffer to store the signature list.\r
318\r
319 @return EFI_UNSUPPORTED Unsupported Key Length.\r
320 @return EFI_OUT_OF_RESOURCES There are not enough memory resourses to form the signature list.\r
321\r
322**/\r
323EFI_STATUS\r
324CreatePkX509SignatureList (\r
325 IN EFI_FILE_HANDLE X509File,\r
326 OUT EFI_SIGNATURE_LIST **PkCert\r
327 )\r
328{\r
329 EFI_STATUS Status;\r
330 UINT8 *X509Data;\r
331 UINTN X509DataSize;\r
332 EFI_SIGNATURE_DATA *PkCertData;\r
333\r
334 X509Data = NULL;\r
335 PkCertData = NULL;\r
336 X509DataSize = 0;\r
337\r
338 Status = ReadFileContent (X509File, (VOID**) &X509Data, &X509DataSize, 0);\r
339 if (EFI_ERROR (Status)) {\r
340 goto ON_EXIT;\r
341 }\r
342 ASSERT (X509Data != NULL);\r
343\r
344 //\r
345 // Allocate space for PK certificate list and initialize it.\r
346 // Create PK database entry with SignatureHeaderSize equals 0.\r
347 //\r
348 *PkCert = (EFI_SIGNATURE_LIST*) AllocateZeroPool (\r
349 sizeof(EFI_SIGNATURE_LIST) + sizeof(EFI_SIGNATURE_DATA) - 1\r
350 + X509DataSize\r
351 );\r
352 if (*PkCert == NULL) {\r
353 Status = EFI_OUT_OF_RESOURCES;\r
354 goto ON_EXIT;\r
355 }\r
356\r
357 (*PkCert)->SignatureListSize = (UINT32) (sizeof(EFI_SIGNATURE_LIST)\r
358 + sizeof(EFI_SIGNATURE_DATA) - 1\r
359 + X509DataSize);\r
360 (*PkCert)->SignatureSize = (UINT32) (sizeof(EFI_SIGNATURE_DATA) - 1 + X509DataSize);\r
361 (*PkCert)->SignatureHeaderSize = 0;\r
362 CopyGuid (&(*PkCert)->SignatureType, &gEfiCertX509Guid);\r
363 PkCertData = (EFI_SIGNATURE_DATA*) ((UINTN)(*PkCert)\r
364 + sizeof(EFI_SIGNATURE_LIST)\r
365 + (*PkCert)->SignatureHeaderSize);\r
366 CopyGuid (&PkCertData->SignatureOwner, &gEfiGlobalVariableGuid);\r
367 //\r
368 // Fill the PK database with PKpub data from X509 certificate file.\r
369 //\r
370 CopyMem (&(PkCertData->SignatureData[0]), X509Data, X509DataSize);\r
371\r
372ON_EXIT:\r
373\r
374 if (X509Data != NULL) {\r
375 FreePool (X509Data);\r
376 }\r
377\r
378 if (EFI_ERROR(Status) && *PkCert != NULL) {\r
379 FreePool (*PkCert);\r
380 *PkCert = NULL;\r
381 }\r
382\r
383 return Status;\r
384}\r
385\r
386/**\r
387 Enroll new PK into the System without original PK's authentication.\r
388\r
389 The SignatureOwner GUID will be the same with PK's vendorguid.\r
390\r
391 @param[in] PrivateData The module's private data.\r
392\r
393 @retval EFI_SUCCESS New PK enrolled successfully.\r
394 @retval EFI_INVALID_PARAMETER The parameter is invalid.\r
395 @retval EFI_OUT_OF_RESOURCES Could not allocate needed resources.\r
396\r
397**/\r
398EFI_STATUS\r
399EnrollPlatformKey (\r
400 IN SECUREBOOT_CONFIG_PRIVATE_DATA* Private\r
401 )\r
402{\r
403 EFI_STATUS Status;\r
404 UINT32 Attr;\r
405 UINTN DataSize;\r
406 EFI_SIGNATURE_LIST *PkCert;\r
407 UINT16* FilePostFix;\r
408 UINTN NameLength;\r
409\r
410 if (Private->FileContext->FileName == NULL) {\r
411 return EFI_INVALID_PARAMETER;\r
412 }\r
413\r
414 PkCert = NULL;\r
415\r
416 Status = SetSecureBootMode(CUSTOM_SECURE_BOOT_MODE);\r
417 if (EFI_ERROR (Status)) {\r
418 return Status;\r
419 }\r
420\r
421 //\r
422 // Parse the file's postfix. Only support DER encoded X.509 certificate files.\r
423 //\r
424 NameLength = StrLen (Private->FileContext->FileName);\r
425 if (NameLength <= 4) {\r
426 return EFI_INVALID_PARAMETER;\r
427 }\r
428 FilePostFix = Private->FileContext->FileName + NameLength - 4;\r
429 if (!IsDerEncodeCertificate(FilePostFix)) {\r
430 DEBUG ((EFI_D_ERROR, "Unsupported file type, only DER encoded certificate (%s) is supported.", mSupportX509Suffix));\r
431 return EFI_INVALID_PARAMETER;\r
432 }\r
433 DEBUG ((EFI_D_INFO, "FileName= %s\n", Private->FileContext->FileName));\r
434 DEBUG ((EFI_D_INFO, "FilePostFix = %s\n", FilePostFix));\r
435\r
436 //\r
437 // Prase the selected PK file and generature PK certificate list.\r
438 //\r
439 Status = CreatePkX509SignatureList (\r
440 Private->FileContext->FHandle,\r
441 &PkCert\r
442 );\r
443 if (EFI_ERROR (Status)) {\r
444 goto ON_EXIT;\r
445 }\r
446 ASSERT (PkCert != NULL);\r
447\r
448 //\r
449 // Set Platform Key variable.\r
450 //\r
451 Attr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS\r
452 | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS;\r
453 DataSize = PkCert->SignatureListSize;\r
454 Status = CreateTimeBasedPayload (&DataSize, (UINT8**) &PkCert);\r
455 if (EFI_ERROR (Status)) {\r
456 DEBUG ((EFI_D_ERROR, "Fail to create time-based data payload: %r", Status));\r
457 goto ON_EXIT;\r
458 }\r
459\r
460 Status = gRT->SetVariable(\r
461 EFI_PLATFORM_KEY_NAME,\r
462 &gEfiGlobalVariableGuid,\r
463 Attr,\r
464 DataSize,\r
465 PkCert\r
466 );\r
467 if (EFI_ERROR (Status)) {\r
468 if (Status == EFI_OUT_OF_RESOURCES) {\r
469 DEBUG ((EFI_D_ERROR, "Enroll PK failed with out of resource.\n"));\r
470 }\r
471 goto ON_EXIT;\r
472 }\r
473\r
474ON_EXIT:\r
475\r
476 if (PkCert != NULL) {\r
477 FreePool(PkCert);\r
478 }\r
479\r
480 if (Private->FileContext->FHandle != NULL) {\r
481 CloseFile (Private->FileContext->FHandle);\r
482 Private->FileContext->FHandle = NULL;\r
483 }\r
484\r
485 return Status;\r
486}\r
487\r
488/**\r
489 Remove the PK variable.\r
490\r
491 @retval EFI_SUCCESS Delete PK successfully.\r
492 @retval Others Could not allow to delete PK.\r
493\r
494**/\r
495EFI_STATUS\r
496DeletePlatformKey (\r
497 VOID\r
498)\r
499{\r
500 EFI_STATUS Status;\r
501\r
502 Status = SetSecureBootMode(CUSTOM_SECURE_BOOT_MODE);\r
503 if (EFI_ERROR (Status)) {\r
504 return Status;\r
505 }\r
506\r
507 Status = DeleteVariable (\r
508 EFI_PLATFORM_KEY_NAME,\r
509 &gEfiGlobalVariableGuid\r
510 );\r
511 return Status;\r
512}\r
513\r
514/**\r
515 Enroll a new KEK item from public key storing file (*.pbk).\r
516\r
517 @param[in] PrivateData The module's private data.\r
518\r
519 @retval EFI_SUCCESS New KEK enrolled successfully.\r
520 @retval EFI_INVALID_PARAMETER The parameter is invalid.\r
521 @retval EFI_UNSUPPORTED Unsupported command.\r
522 @retval EFI_OUT_OF_RESOURCES Could not allocate needed resources.\r
523\r
524**/\r
525EFI_STATUS\r
526EnrollRsa2048ToKek (\r
527 IN SECUREBOOT_CONFIG_PRIVATE_DATA *Private\r
528 )\r
529{\r
530 EFI_STATUS Status;\r
531 UINT32 Attr;\r
532 UINTN DataSize;\r
533 EFI_SIGNATURE_LIST *KekSigList;\r
534 UINTN KeyBlobSize;\r
535 UINT8 *KeyBlob;\r
536 CPL_KEY_INFO *KeyInfo;\r
537 EFI_SIGNATURE_DATA *KEKSigData;\r
538 UINTN KekSigListSize;\r
539 UINT8 *KeyBuffer;\r
540 UINTN KeyLenInBytes;\r
541\r
542 Attr = 0;\r
543 DataSize = 0;\r
544 KeyBuffer = NULL;\r
545 KeyBlobSize = 0;\r
546 KeyBlob = NULL;\r
547 KeyInfo = NULL;\r
548 KEKSigData = NULL;\r
549 KekSigList = NULL;\r
550 KekSigListSize = 0;\r
551\r
552 //\r
553 // Form the KeKpub certificate list into EFI_SIGNATURE_LIST type.\r
554 // First, We have to parse out public key data from the pbk key file.\r
555 //\r
556 Status = ReadFileContent (\r
557 Private->FileContext->FHandle,\r
558 (VOID**) &KeyBlob,\r
559 &KeyBlobSize,\r
560 0\r
561 );\r
562 if (EFI_ERROR (Status)) {\r
563 goto ON_EXIT;\r
564 }\r
565 ASSERT (KeyBlob != NULL);\r
566 KeyInfo = (CPL_KEY_INFO *) KeyBlob;\r
567 if (KeyInfo->KeyLengthInBits / 8 != WIN_CERT_UEFI_RSA2048_SIZE) {\r
568 DEBUG ((DEBUG_ERROR, "Unsupported key length, Only RSA2048 is supported.\n"));\r
569 Status = EFI_UNSUPPORTED;\r
570 goto ON_EXIT;\r
571 }\r
572\r
573 //\r
574 // Convert the Public key to fix octet string format represented in RSA PKCS#1.\r
575 //\r
576 KeyLenInBytes = KeyInfo->KeyLengthInBits / 8;\r
577 KeyBuffer = AllocateZeroPool (KeyLenInBytes);\r
578 if (KeyBuffer == NULL) {\r
579 Status = EFI_OUT_OF_RESOURCES;\r
580 goto ON_EXIT;\r
581 }\r
582 Int2OctStr (\r
583 (UINTN*) (KeyBlob + sizeof (CPL_KEY_INFO)),\r
584 KeyLenInBytes / sizeof (UINTN),\r
585 KeyBuffer,\r
586 KeyLenInBytes\r
587 );\r
588 CopyMem(KeyBlob + sizeof(CPL_KEY_INFO), KeyBuffer, KeyLenInBytes);\r
589\r
590 //\r
591 // Form an new EFI_SIGNATURE_LIST.\r
592 //\r
593 KekSigListSize = sizeof(EFI_SIGNATURE_LIST)\r
594 + sizeof(EFI_SIGNATURE_DATA) - 1\r
595 + WIN_CERT_UEFI_RSA2048_SIZE;\r
596\r
597 KekSigList = (EFI_SIGNATURE_LIST*) AllocateZeroPool (KekSigListSize);\r
598 if (KekSigList == NULL) {\r
599 Status = EFI_OUT_OF_RESOURCES;\r
600 goto ON_EXIT;\r
601 }\r
602\r
603 KekSigList->SignatureListSize = sizeof(EFI_SIGNATURE_LIST)\r
604 + sizeof(EFI_SIGNATURE_DATA) - 1\r
605 + WIN_CERT_UEFI_RSA2048_SIZE;\r
606 KekSigList->SignatureHeaderSize = 0;\r
607 KekSigList->SignatureSize = sizeof(EFI_SIGNATURE_DATA) - 1 + WIN_CERT_UEFI_RSA2048_SIZE;\r
608 CopyGuid (&KekSigList->SignatureType, &gEfiCertRsa2048Guid);\r
609\r
610 KEKSigData = (EFI_SIGNATURE_DATA*)((UINT8*)KekSigList + sizeof(EFI_SIGNATURE_LIST));\r
611 CopyGuid (&KEKSigData->SignatureOwner, Private->SignatureGUID);\r
612 CopyMem (\r
613 KEKSigData->SignatureData,\r
614 KeyBlob + sizeof(CPL_KEY_INFO),\r
615 WIN_CERT_UEFI_RSA2048_SIZE\r
616 );\r
617\r
618 //\r
619 // Check if KEK entry has been already existed.\r
620 // If true, use EFI_VARIABLE_APPEND_WRITE attribute to append the\r
621 // new KEK to original variable.\r
622 //\r
623 Attr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS\r
624 | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS;\r
625 Status = CreateTimeBasedPayload (&KekSigListSize, (UINT8**) &KekSigList);\r
626 if (EFI_ERROR (Status)) {\r
627 DEBUG ((EFI_D_ERROR, "Fail to create time-based data payload: %r", Status));\r
628 goto ON_EXIT;\r
629 }\r
630\r
631 Status = gRT->GetVariable(\r
632 EFI_KEY_EXCHANGE_KEY_NAME,\r
633 &gEfiGlobalVariableGuid,\r
634 NULL,\r
635 &DataSize,\r
636 NULL\r
637 );\r
638 if (Status == EFI_BUFFER_TOO_SMALL) {\r
639 Attr |= EFI_VARIABLE_APPEND_WRITE;\r
640 } else if (Status != EFI_NOT_FOUND) {\r
641 goto ON_EXIT;\r
642 }\r
643\r
644 //\r
645 // Done. Now we have formed the correct KEKpub database item, just set it into variable storage,\r
646 //\r
647 Status = gRT->SetVariable(\r
648 EFI_KEY_EXCHANGE_KEY_NAME,\r
649 &gEfiGlobalVariableGuid,\r
650 Attr,\r
651 KekSigListSize,\r
652 KekSigList\r
653 );\r
654 if (EFI_ERROR (Status)) {\r
655 goto ON_EXIT;\r
656 }\r
657\r
658ON_EXIT:\r
659\r
660 CloseFile (Private->FileContext->FHandle);\r
661 Private->FileContext->FHandle = NULL;\r
662\r
663 if (Private->FileContext->FileName != NULL){\r
664 FreePool(Private->FileContext->FileName);\r
665 Private->FileContext->FileName = NULL;\r
666 }\r
667\r
668 if (Private->SignatureGUID != NULL) {\r
669 FreePool (Private->SignatureGUID);\r
670 Private->SignatureGUID = NULL;\r
671 }\r
672\r
673 if (KeyBlob != NULL) {\r
674 FreePool (KeyBlob);\r
675 }\r
676 if (KeyBuffer != NULL) {\r
677 FreePool (KeyBuffer);\r
678 }\r
679 if (KekSigList != NULL) {\r
680 FreePool (KekSigList);\r
681 }\r
682\r
683 return Status;\r
684}\r
685\r
686/**\r
687 Enroll a new KEK item from X509 certificate file.\r
688\r
689 @param[in] PrivateData The module's private data.\r
690\r
691 @retval EFI_SUCCESS New X509 is enrolled successfully.\r
692 @retval EFI_INVALID_PARAMETER The parameter is invalid.\r
693 @retval EFI_UNSUPPORTED Unsupported command.\r
694 @retval EFI_OUT_OF_RESOURCES Could not allocate needed resources.\r
695\r
696**/\r
697EFI_STATUS\r
698EnrollX509ToKek (\r
699 IN SECUREBOOT_CONFIG_PRIVATE_DATA *Private\r
700 )\r
701{\r
702 EFI_STATUS Status;\r
703 UINTN X509DataSize;\r
704 VOID *X509Data;\r
705 EFI_SIGNATURE_DATA *KEKSigData;\r
706 EFI_SIGNATURE_LIST *KekSigList;\r
707 UINTN DataSize;\r
708 UINTN KekSigListSize;\r
709 UINT32 Attr;\r
710\r
711 X509Data = NULL;\r
712 X509DataSize = 0;\r
713 KekSigList = NULL;\r
714 KekSigListSize = 0;\r
715 DataSize = 0;\r
716 KEKSigData = NULL;\r
717\r
718 Status = ReadFileContent (\r
719 Private->FileContext->FHandle,\r
720 &X509Data,\r
721 &X509DataSize,\r
722 0\r
723 );\r
724 if (EFI_ERROR (Status)) {\r
725 goto ON_EXIT;\r
726 }\r
727 ASSERT (X509Data != NULL);\r
728\r
729 KekSigListSize = sizeof(EFI_SIGNATURE_LIST) + sizeof(EFI_SIGNATURE_DATA) - 1 + X509DataSize;\r
730 KekSigList = (EFI_SIGNATURE_LIST*) AllocateZeroPool (KekSigListSize);\r
731 if (KekSigList == NULL) {\r
732 Status = EFI_OUT_OF_RESOURCES;\r
733 goto ON_EXIT;\r
734 }\r
735\r
736 //\r
737 // Fill Certificate Database parameters.\r
738 //\r
739 KekSigList->SignatureListSize = (UINT32) KekSigListSize;\r
740 KekSigList->SignatureHeaderSize = 0;\r
741 KekSigList->SignatureSize = (UINT32) (sizeof(EFI_SIGNATURE_DATA) - 1 + X509DataSize);\r
742 CopyGuid (&KekSigList->SignatureType, &gEfiCertX509Guid);\r
743\r
744 KEKSigData = (EFI_SIGNATURE_DATA*) ((UINT8*) KekSigList + sizeof (EFI_SIGNATURE_LIST));\r
745 CopyGuid (&KEKSigData->SignatureOwner, Private->SignatureGUID);\r
746 CopyMem (KEKSigData->SignatureData, X509Data, X509DataSize);\r
747\r
748 //\r
749 // Check if KEK been already existed.\r
750 // If true, use EFI_VARIABLE_APPEND_WRITE attribute to append the\r
751 // new kek to original variable\r
752 //\r
753 Attr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS\r
754 | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS;\r
755 Status = CreateTimeBasedPayload (&KekSigListSize, (UINT8**) &KekSigList);\r
756 if (EFI_ERROR (Status)) {\r
757 DEBUG ((EFI_D_ERROR, "Fail to create time-based data payload: %r", Status));\r
758 goto ON_EXIT;\r
759 }\r
760\r
761 Status = gRT->GetVariable(\r
762 EFI_KEY_EXCHANGE_KEY_NAME,\r
763 &gEfiGlobalVariableGuid,\r
764 NULL,\r
765 &DataSize,\r
766 NULL\r
767 );\r
768 if (Status == EFI_BUFFER_TOO_SMALL) {\r
769 Attr |= EFI_VARIABLE_APPEND_WRITE;\r
770 } else if (Status != EFI_NOT_FOUND) {\r
771 goto ON_EXIT;\r
772 }\r
773\r
774 Status = gRT->SetVariable(\r
775 EFI_KEY_EXCHANGE_KEY_NAME,\r
776 &gEfiGlobalVariableGuid,\r
777 Attr,\r
778 KekSigListSize,\r
779 KekSigList\r
780 );\r
781 if (EFI_ERROR (Status)) {\r
782 goto ON_EXIT;\r
783 }\r
784\r
785ON_EXIT:\r
786\r
787 CloseFile (Private->FileContext->FHandle);\r
788 if (Private->FileContext->FileName != NULL){\r
789 FreePool(Private->FileContext->FileName);\r
790 Private->FileContext->FileName = NULL;\r
791 }\r
792\r
793 Private->FileContext->FHandle = NULL;\r
794\r
795 if (Private->SignatureGUID != NULL) {\r
796 FreePool (Private->SignatureGUID);\r
797 Private->SignatureGUID = NULL;\r
798 }\r
799\r
800 if (KekSigList != NULL) {\r
801 FreePool (KekSigList);\r
802 }\r
803\r
804 return Status;\r
805}\r
806\r
807/**\r
808 Enroll new KEK into the System without PK's authentication.\r
809 The SignatureOwner GUID will be Private->SignatureGUID.\r
810\r
811 @param[in] PrivateData The module's private data.\r
812\r
813 @retval EFI_SUCCESS New KEK enrolled successful.\r
814 @retval EFI_INVALID_PARAMETER The parameter is invalid.\r
815 @retval others Fail to enroll KEK data.\r
816\r
817**/\r
818EFI_STATUS\r
819EnrollKeyExchangeKey (\r
820 IN SECUREBOOT_CONFIG_PRIVATE_DATA *Private\r
821 )\r
822{\r
823 UINT16* FilePostFix;\r
824 EFI_STATUS Status;\r
825 UINTN NameLength;\r
826\r
827 if ((Private->FileContext->FileName == NULL) || (Private->SignatureGUID == NULL)) {\r
828 return EFI_INVALID_PARAMETER;\r
829 }\r
830\r
831 Status = SetSecureBootMode(CUSTOM_SECURE_BOOT_MODE);\r
832 if (EFI_ERROR (Status)) {\r
833 return Status;\r
834 }\r
835\r
836 //\r
837 // Parse the file's postfix. Supports DER-encoded X509 certificate,\r
838 // and .pbk as RSA public key file.\r
839 //\r
840 NameLength = StrLen (Private->FileContext->FileName);\r
841 if (NameLength <= 4) {\r
842 return EFI_INVALID_PARAMETER;\r
843 }\r
844 FilePostFix = Private->FileContext->FileName + NameLength - 4;\r
845 if (IsDerEncodeCertificate(FilePostFix)) {\r
846 return EnrollX509ToKek (Private);\r
847 } else if (CompareMem (FilePostFix, L".pbk",4) == 0) {\r
848 return EnrollRsa2048ToKek (Private);\r
849 } else {\r
850 return EFI_INVALID_PARAMETER;\r
851 }\r
852}\r
853\r
854/**\r
855 Enroll a new X509 certificate into Signature Database (DB or DBX or DBT) without\r
856 KEK's authentication.\r
857\r
858 @param[in] PrivateData The module's private data.\r
859 @param[in] VariableName Variable name of signature database, must be\r
860 EFI_IMAGE_SECURITY_DATABASE or EFI_IMAGE_SECURITY_DATABASE1.\r
861\r
862 @retval EFI_SUCCESS New X509 is enrolled successfully.\r
863 @retval EFI_OUT_OF_RESOURCES Could not allocate needed resources.\r
864\r
865**/\r
866EFI_STATUS\r
867EnrollX509toSigDB (\r
868 IN SECUREBOOT_CONFIG_PRIVATE_DATA *Private,\r
869 IN CHAR16 *VariableName\r
870 )\r
871{\r
872 EFI_STATUS Status;\r
873 UINTN X509DataSize;\r
874 VOID *X509Data;\r
875 EFI_SIGNATURE_LIST *SigDBCert;\r
876 EFI_SIGNATURE_DATA *SigDBCertData;\r
877 VOID *Data;\r
878 UINTN DataSize;\r
879 UINTN SigDBSize;\r
880 UINT32 Attr;\r
881\r
882 X509DataSize = 0;\r
883 SigDBSize = 0;\r
884 DataSize = 0;\r
885 X509Data = NULL;\r
886 SigDBCert = NULL;\r
887 SigDBCertData = NULL;\r
888 Data = NULL;\r
889\r
890 Status = ReadFileContent (\r
891 Private->FileContext->FHandle,\r
892 &X509Data,\r
893 &X509DataSize,\r
894 0\r
895 );\r
896 if (EFI_ERROR (Status)) {\r
897 goto ON_EXIT;\r
898 }\r
899 ASSERT (X509Data != NULL);\r
900\r
901 SigDBSize = sizeof(EFI_SIGNATURE_LIST) + sizeof(EFI_SIGNATURE_DATA) - 1 + X509DataSize;\r
902\r
903 Data = AllocateZeroPool (SigDBSize);\r
904 if (Data == NULL) {\r
905 Status = EFI_OUT_OF_RESOURCES;\r
906 goto ON_EXIT;\r
907 }\r
908\r
909 //\r
910 // Fill Certificate Database parameters.\r
911 //\r
912 SigDBCert = (EFI_SIGNATURE_LIST*) Data;\r
913 SigDBCert->SignatureListSize = (UINT32) SigDBSize;\r
914 SigDBCert->SignatureHeaderSize = 0;\r
915 SigDBCert->SignatureSize = (UINT32) (sizeof(EFI_SIGNATURE_DATA) - 1 + X509DataSize);\r
916 CopyGuid (&SigDBCert->SignatureType, &gEfiCertX509Guid);\r
917\r
918 SigDBCertData = (EFI_SIGNATURE_DATA*) ((UINT8* ) SigDBCert + sizeof (EFI_SIGNATURE_LIST));\r
919 CopyGuid (&SigDBCertData->SignatureOwner, Private->SignatureGUID);\r
920 CopyMem ((UINT8* ) (SigDBCertData->SignatureData), X509Data, X509DataSize);\r
921\r
922 //\r
923 // Check if signature database entry has been already existed.\r
924 // If true, use EFI_VARIABLE_APPEND_WRITE attribute to append the\r
925 // new signature data to original variable\r
926 //\r
927 Attr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS\r
928 | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS;\r
929 Status = CreateTimeBasedPayload (&SigDBSize, (UINT8**) &Data);\r
930 if (EFI_ERROR (Status)) {\r
931 DEBUG ((EFI_D_ERROR, "Fail to create time-based data payload: %r", Status));\r
932 goto ON_EXIT;\r
933 }\r
934\r
935 Status = gRT->GetVariable(\r
936 VariableName,\r
937 &gEfiImageSecurityDatabaseGuid,\r
938 NULL,\r
939 &DataSize,\r
940 NULL\r
941 );\r
942 if (Status == EFI_BUFFER_TOO_SMALL) {\r
943 Attr |= EFI_VARIABLE_APPEND_WRITE;\r
944 } else if (Status != EFI_NOT_FOUND) {\r
945 goto ON_EXIT;\r
946 }\r
947\r
948 Status = gRT->SetVariable(\r
949 VariableName,\r
950 &gEfiImageSecurityDatabaseGuid,\r
951 Attr,\r
952 SigDBSize,\r
953 Data\r
954 );\r
955 if (EFI_ERROR (Status)) {\r
956 goto ON_EXIT;\r
957 }\r
958\r
959ON_EXIT:\r
960\r
961 CloseFile (Private->FileContext->FHandle);\r
962 if (Private->FileContext->FileName != NULL){\r
963 FreePool(Private->FileContext->FileName);\r
964 Private->FileContext->FileName = NULL;\r
965 }\r
966\r
967 Private->FileContext->FHandle = NULL;\r
968\r
969 if (Private->SignatureGUID != NULL) {\r
970 FreePool (Private->SignatureGUID);\r
971 Private->SignatureGUID = NULL;\r
972 }\r
973\r
974 if (Data != NULL) {\r
975 FreePool (Data);\r
976 }\r
977\r
978 if (X509Data != NULL) {\r
979 FreePool (X509Data);\r
980 }\r
981\r
982 return Status;\r
983}\r
984\r
985/**\r
986 Check whether signature is in specified database.\r
987\r
988 @param[in] VariableName Name of database variable that is searched in.\r
989 @param[in] Signature Pointer to signature that is searched for.\r
990 @param[in] SignatureSize Size of Signature.\r
991\r
992 @return TRUE Found the signature in the variable database.\r
993 @return FALSE Not found the signature in the variable database.\r
994\r
995**/\r
996BOOLEAN\r
997IsSignatureFoundInDatabase (\r
998 IN CHAR16 *VariableName,\r
999 IN UINT8 *Signature,\r
1000 IN UINTN SignatureSize\r
1001 )\r
1002{\r
1003 EFI_STATUS Status;\r
1004 EFI_SIGNATURE_LIST *CertList;\r
1005 EFI_SIGNATURE_DATA *Cert;\r
1006 UINTN DataSize;\r
1007 UINT8 *Data;\r
1008 UINTN Index;\r
1009 UINTN CertCount;\r
1010 BOOLEAN IsFound;\r
1011\r
1012 //\r
1013 // Read signature database variable.\r
1014 //\r
1015 IsFound = FALSE;\r
1016 Data = NULL;\r
1017 DataSize = 0;\r
1018 Status = gRT->GetVariable (VariableName, &gEfiImageSecurityDatabaseGuid, NULL, &DataSize, NULL);\r
1019 if (Status != EFI_BUFFER_TOO_SMALL) {\r
1020 return FALSE;\r
1021 }\r
1022\r
1023 Data = (UINT8 *) AllocateZeroPool (DataSize);\r
1024 if (Data == NULL) {\r
1025 return FALSE;\r
1026 }\r
1027\r
1028 Status = gRT->GetVariable (VariableName, &gEfiImageSecurityDatabaseGuid, NULL, &DataSize, Data);\r
1029 if (EFI_ERROR (Status)) {\r
1030 goto Done;\r
1031 }\r
1032\r
1033 //\r
1034 // Enumerate all signature data in SigDB to check if executable's signature exists.\r
1035 //\r
1036 CertList = (EFI_SIGNATURE_LIST *) Data;\r
1037 while ((DataSize > 0) && (DataSize >= CertList->SignatureListSize)) {\r
1038 CertCount = (CertList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - CertList->SignatureHeaderSize) / CertList->SignatureSize;\r
1039 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertList + sizeof (EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);\r
1040 if ((CertList->SignatureSize == sizeof(EFI_SIGNATURE_DATA) - 1 + SignatureSize) && (CompareGuid(&CertList->SignatureType, &gEfiCertX509Guid))) {\r
1041 for (Index = 0; Index < CertCount; Index++) {\r
1042 if (CompareMem (Cert->SignatureData, Signature, SignatureSize) == 0) {\r
1043 //\r
1044 // Find the signature in database.\r
1045 //\r
1046 IsFound = TRUE;\r
1047 break;\r
1048 }\r
1049 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) Cert + CertList->SignatureSize);\r
1050 }\r
1051\r
1052 if (IsFound) {\r
1053 break;\r
1054 }\r
1055 }\r
1056\r
1057 DataSize -= CertList->SignatureListSize;\r
1058 CertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) CertList + CertList->SignatureListSize);\r
1059 }\r
1060\r
1061Done:\r
1062 if (Data != NULL) {\r
1063 FreePool (Data);\r
1064 }\r
1065\r
1066 return IsFound;\r
1067}\r
1068\r
1069/**\r
1070 Calculate the hash of a certificate data with the specified hash algorithm.\r
1071\r
1072 @param[in] CertData The certificate data to be hashed.\r
1073 @param[in] CertSize The certificate size in bytes.\r
1074 @param[in] HashAlg The specified hash algorithm.\r
1075 @param[out] CertHash The output digest of the certificate\r
1076\r
1077 @retval TRUE Successfully got the hash of the CertData.\r
1078 @retval FALSE Failed to get the hash of CertData.\r
1079\r
1080**/\r
1081BOOLEAN\r
1082CalculateCertHash (\r
1083 IN UINT8 *CertData,\r
1084 IN UINTN CertSize,\r
1085 IN UINT32 HashAlg,\r
1086 OUT UINT8 *CertHash\r
1087 )\r
1088{\r
1089 BOOLEAN Status;\r
1090 VOID *HashCtx;\r
1091 UINTN CtxSize;\r
1092 UINT8 *TBSCert;\r
1093 UINTN TBSCertSize;\r
1094\r
1095 HashCtx = NULL;\r
1096 Status = FALSE;\r
1097\r
1098 if (HashAlg >= HASHALG_MAX) {\r
1099 return FALSE;\r
1100 }\r
1101\r
1102 //\r
1103 // Retrieve the TBSCertificate for Hash Calculation.\r
1104 //\r
1105 if (!X509GetTBSCert (CertData, CertSize, &TBSCert, &TBSCertSize)) {\r
1106 return FALSE;\r
1107 }\r
1108\r
1109 //\r
1110 // 1. Initialize context of hash.\r
1111 //\r
1112 CtxSize = mHash[HashAlg].GetContextSize ();\r
1113 HashCtx = AllocatePool (CtxSize);\r
1114 ASSERT (HashCtx != NULL);\r
1115\r
1116 //\r
1117 // 2. Initialize a hash context.\r
1118 //\r
1119 Status = mHash[HashAlg].HashInit (HashCtx);\r
1120 if (!Status) {\r
1121 goto Done;\r
1122 }\r
1123\r
1124 //\r
1125 // 3. Calculate the hash.\r
1126 //\r
1127 Status = mHash[HashAlg].HashUpdate (HashCtx, TBSCert, TBSCertSize);\r
1128 if (!Status) {\r
1129 goto Done;\r
1130 }\r
1131\r
1132 //\r
1133 // 4. Get the hash result.\r
1134 //\r
1135 ZeroMem (CertHash, mHash[HashAlg].DigestLength);\r
1136 Status = mHash[HashAlg].HashFinal (HashCtx, CertHash);\r
1137\r
1138Done:\r
1139 if (HashCtx != NULL) {\r
1140 FreePool (HashCtx);\r
1141 }\r
1142\r
1143 return Status;\r
1144}\r
1145\r
1146/**\r
1147 Check whether the hash of an X.509 certificate is in forbidden database (DBX).\r
1148\r
1149 @param[in] Certificate Pointer to X.509 Certificate that is searched for.\r
1150 @param[in] CertSize Size of X.509 Certificate.\r
1151\r
1152 @return TRUE Found the certificate hash in the forbidden database.\r
1153 @return FALSE Certificate hash is Not found in the forbidden database.\r
1154\r
1155**/\r
1156BOOLEAN\r
1157IsCertHashFoundInDbx (\r
1158 IN UINT8 *Certificate,\r
1159 IN UINTN CertSize\r
1160 )\r
1161{\r
1162 BOOLEAN IsFound;\r
1163 EFI_STATUS Status;\r
1164 EFI_SIGNATURE_LIST *DbxList;\r
1165 EFI_SIGNATURE_DATA *CertHash;\r
1166 UINTN CertHashCount;\r
1167 UINTN Index;\r
1168 UINT32 HashAlg;\r
1169 UINT8 CertDigest[MAX_DIGEST_SIZE];\r
1170 UINT8 *DbxCertHash;\r
1171 UINTN SiglistHeaderSize;\r
1172 UINT8 *Data;\r
1173 UINTN DataSize;\r
1174\r
1175 IsFound = FALSE;\r
1176 HashAlg = HASHALG_MAX;\r
1177 Data = NULL;\r
1178\r
1179 //\r
1180 // Read signature database variable.\r
1181 //\r
1182 DataSize = 0;\r
1183 Status = gRT->GetVariable (EFI_IMAGE_SECURITY_DATABASE1, &gEfiImageSecurityDatabaseGuid, NULL, &DataSize, NULL);\r
1184 if (Status != EFI_BUFFER_TOO_SMALL) {\r
1185 return FALSE;\r
1186 }\r
1187\r
1188 Data = (UINT8 *) AllocateZeroPool (DataSize);\r
1189 if (Data == NULL) {\r
1190 return FALSE;\r
1191 }\r
1192\r
1193 Status = gRT->GetVariable (EFI_IMAGE_SECURITY_DATABASE1, &gEfiImageSecurityDatabaseGuid, NULL, &DataSize, Data);\r
1194 if (EFI_ERROR (Status)) {\r
1195 goto Done;\r
1196 }\r
1197\r
1198 //\r
1199 // Check whether the certificate hash exists in the forbidden database.\r
1200 //\r
1201 DbxList = (EFI_SIGNATURE_LIST *) Data;\r
1202 while ((DataSize > 0) && (DataSize >= DbxList->SignatureListSize)) {\r
1203 //\r
1204 // Determine Hash Algorithm of Certificate in the forbidden database.\r
1205 //\r
1206 if (CompareGuid (&DbxList->SignatureType, &gEfiCertX509Sha256Guid)) {\r
1207 HashAlg = HASHALG_SHA256;\r
1208 } else if (CompareGuid (&DbxList->SignatureType, &gEfiCertX509Sha384Guid)) {\r
1209 HashAlg = HASHALG_SHA384;\r
1210 } else if (CompareGuid (&DbxList->SignatureType, &gEfiCertX509Sha512Guid)) {\r
1211 HashAlg = HASHALG_SHA512;\r
1212 } else {\r
1213 DataSize -= DbxList->SignatureListSize;\r
1214 DbxList = (EFI_SIGNATURE_LIST *) ((UINT8 *) DbxList + DbxList->SignatureListSize);\r
1215 continue;\r
1216 }\r
1217\r
1218 //\r
1219 // Calculate the hash value of current db certificate for comparision.\r
1220 //\r
1221 if (!CalculateCertHash (Certificate, CertSize, HashAlg, CertDigest)) {\r
1222 goto Done;\r
1223 }\r
1224\r
1225 SiglistHeaderSize = sizeof (EFI_SIGNATURE_LIST) + DbxList->SignatureHeaderSize;\r
1226 CertHash = (EFI_SIGNATURE_DATA *) ((UINT8 *) DbxList + SiglistHeaderSize);\r
1227 CertHashCount = (DbxList->SignatureListSize - SiglistHeaderSize) / DbxList->SignatureSize;\r
1228 for (Index = 0; Index < CertHashCount; Index++) {\r
1229 //\r
1230 // Iterate each Signature Data Node within this CertList for verify.\r
1231 //\r
1232 DbxCertHash = CertHash->SignatureData;\r
1233 if (CompareMem (DbxCertHash, CertDigest, mHash[HashAlg].DigestLength) == 0) {\r
1234 //\r
1235 // Hash of Certificate is found in forbidden database.\r
1236 //\r
1237 IsFound = TRUE;\r
1238 goto Done;\r
1239 }\r
1240 CertHash = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertHash + DbxList->SignatureSize);\r
1241 }\r
1242\r
1243 DataSize -= DbxList->SignatureListSize;\r
1244 DbxList = (EFI_SIGNATURE_LIST *) ((UINT8 *) DbxList + DbxList->SignatureListSize);\r
1245 }\r
1246\r
1247Done:\r
1248 if (Data != NULL) {\r
1249 FreePool (Data);\r
1250 }\r
1251\r
1252 return IsFound;\r
1253}\r
1254\r
1255/**\r
1256 Check whether the signature list exists in given variable data.\r
1257\r
1258 It searches the signature list for the ceritificate hash by CertType.\r
1259 If the signature list is found, get the offset of Database for the\r
1260 next hash of a certificate.\r
1261\r
1262 @param[in] Database Variable data to save signature list.\r
1263 @param[in] DatabaseSize Variable size.\r
1264 @param[in] SignatureType The type of the signature.\r
1265 @param[out] Offset The offset to save a new hash of certificate.\r
1266\r
1267 @return TRUE The signature list is found in the forbidden database.\r
1268 @return FALSE The signature list is not found in the forbidden database.\r
1269**/\r
1270BOOLEAN\r
1271GetSignaturelistOffset (\r
1272 IN EFI_SIGNATURE_LIST *Database,\r
1273 IN UINTN DatabaseSize,\r
1274 IN EFI_GUID *SignatureType,\r
1275 OUT UINTN *Offset\r
1276 )\r
1277{\r
1278 EFI_SIGNATURE_LIST *SigList;\r
1279 UINTN SiglistSize;\r
1280\r
1281 if ((Database == NULL) || (DatabaseSize == 0)) {\r
1282 *Offset = 0;\r
1283 return FALSE;\r
1284 }\r
1285\r
1286 SigList = Database;\r
1287 SiglistSize = DatabaseSize;\r
1288 while ((SiglistSize > 0) && (SiglistSize >= SigList->SignatureListSize)) {\r
1289 if (CompareGuid (&SigList->SignatureType, SignatureType)) {\r
1290 *Offset = DatabaseSize - SiglistSize;\r
1291 return TRUE;\r
1292 }\r
1293 SiglistSize -= SigList->SignatureListSize;\r
1294 SigList = (EFI_SIGNATURE_LIST *) ((UINT8 *) SigList + SigList->SignatureListSize);\r
1295 }\r
1296 *Offset = 0;\r
1297 return FALSE;\r
1298}\r
1299\r
1300/**\r
1301 Enroll a new X509 certificate hash into Signature Database (dbx) without\r
1302 KEK's authentication.\r
1303\r
1304 @param[in] PrivateData The module's private data.\r
1305 @param[in] HashAlg The hash algorithm to enroll the certificate.\r
1306 @param[in] RevocationDate The revocation date of the certificate.\r
1307 @param[in] RevocationTime The revocation time of the certificate.\r
1308 @param[in] AlwaysRevocation Indicate whether the certificate is always revoked.\r
1309\r
1310 @retval EFI_SUCCESS New X509 is enrolled successfully.\r
1311 @retval EFI_INVALID_PARAMETER The parameter is invalid.\r
1312 @retval EFI_OUT_OF_RESOURCES Could not allocate needed resources.\r
1313\r
1314**/\r
1315EFI_STATUS\r
1316EnrollX509HashtoSigDB (\r
1317 IN SECUREBOOT_CONFIG_PRIVATE_DATA *Private,\r
1318 IN UINT32 HashAlg,\r
1319 IN EFI_HII_DATE *RevocationDate,\r
1320 IN EFI_HII_TIME *RevocationTime,\r
1321 IN BOOLEAN AlwaysRevocation\r
1322 )\r
1323{\r
1324 EFI_STATUS Status;\r
1325 UINTN X509DataSize;\r
1326 VOID *X509Data;\r
1327 EFI_SIGNATURE_LIST *SignatureList;\r
1328 UINTN SignatureListSize;\r
1329 UINT8 *Data;\r
1330 UINT8 *NewData;\r
1331 UINTN DataSize;\r
1332 UINTN DbSize;\r
1333 UINT32 Attr;\r
1334 EFI_SIGNATURE_DATA *SignatureData;\r
1335 UINTN SignatureSize;\r
1336 EFI_GUID SignatureType;\r
1337 UINTN Offset;\r
1338 UINT8 CertHash[MAX_DIGEST_SIZE];\r
1339 UINT16* FilePostFix;\r
1340 UINTN NameLength;\r
1341 EFI_TIME *Time;\r
1342\r
1343 X509DataSize = 0;\r
1344 DbSize = 0;\r
1345 X509Data = NULL;\r
1346 SignatureData = NULL;\r
1347 SignatureList = NULL;\r
1348 Data = NULL;\r
1349 NewData = NULL;\r
1350\r
1351 if ((Private->FileContext->FileName == NULL) || (Private->FileContext->FHandle == NULL) || (Private->SignatureGUID == NULL)) {\r
1352 return EFI_INVALID_PARAMETER;\r
1353 }\r
1354\r
1355 Status = SetSecureBootMode (CUSTOM_SECURE_BOOT_MODE);\r
1356 if (EFI_ERROR (Status)) {\r
1357 return Status;\r
1358 }\r
1359\r
1360 //\r
1361 // Parse the file's postfix.\r
1362 //\r
1363 NameLength = StrLen (Private->FileContext->FileName);\r
1364 if (NameLength <= 4) {\r
1365 return EFI_INVALID_PARAMETER;\r
1366 }\r
1367 FilePostFix = Private->FileContext->FileName + NameLength - 4;\r
1368 if (!IsDerEncodeCertificate(FilePostFix)) {\r
1369 //\r
1370 // Only supports DER-encoded X509 certificate.\r
1371 //\r
1372 return EFI_INVALID_PARAMETER;\r
1373 }\r
1374\r
1375 //\r
1376 // Get the certificate from file and calculate its hash.\r
1377 //\r
1378 Status = ReadFileContent (\r
1379 Private->FileContext->FHandle,\r
1380 &X509Data,\r
1381 &X509DataSize,\r
1382 0\r
1383 );\r
1384 if (EFI_ERROR (Status)) {\r
1385 goto ON_EXIT;\r
1386 }\r
1387 ASSERT (X509Data != NULL);\r
1388\r
1389 if (!CalculateCertHash (X509Data, X509DataSize, HashAlg, CertHash)) {\r
1390 goto ON_EXIT;\r
1391 }\r
1392\r
1393 //\r
1394 // Get the variable for enrollment.\r
1395 //\r
1396 DataSize = 0;\r
1397 Status = gRT->GetVariable (EFI_IMAGE_SECURITY_DATABASE1, &gEfiImageSecurityDatabaseGuid, NULL, &DataSize, NULL);\r
1398 if (Status == EFI_BUFFER_TOO_SMALL) {\r
1399 Data = (UINT8 *) AllocateZeroPool (DataSize);\r
1400 if (Data == NULL) {\r
1401 return EFI_OUT_OF_RESOURCES;\r
1402 }\r
1403\r
1404 Status = gRT->GetVariable (EFI_IMAGE_SECURITY_DATABASE1, &gEfiImageSecurityDatabaseGuid, NULL, &DataSize, Data);\r
1405 if (EFI_ERROR (Status)) {\r
1406 goto ON_EXIT;\r
1407 }\r
1408 }\r
1409\r
1410 //\r
1411 // Allocate memory for Signature and fill the Signature\r
1412 //\r
1413 SignatureSize = sizeof(EFI_SIGNATURE_DATA) - 1 + sizeof (EFI_TIME) + mHash[HashAlg].DigestLength;\r
1414 SignatureData = (EFI_SIGNATURE_DATA *) AllocateZeroPool (SignatureSize);\r
1415 if (SignatureData == NULL) {\r
1416 return EFI_OUT_OF_RESOURCES;\r
1417 }\r
1418 CopyGuid (&SignatureData->SignatureOwner, Private->SignatureGUID);\r
1419 CopyMem (SignatureData->SignatureData, CertHash, mHash[HashAlg].DigestLength);\r
1420\r
1421 //\r
1422 // Fill the time.\r
1423 //\r
1424 if (!AlwaysRevocation) {\r
1425 Time = (EFI_TIME *)(&SignatureData->SignatureData + mHash[HashAlg].DigestLength);\r
1426 Time->Year = RevocationDate->Year;\r
1427 Time->Month = RevocationDate->Month;\r
1428 Time->Day = RevocationDate->Day;\r
1429 Time->Hour = RevocationTime->Hour;\r
1430 Time->Minute = RevocationTime->Minute;\r
1431 Time->Second = RevocationTime->Second;\r
1432 }\r
1433\r
1434 //\r
1435 // Determine the GUID for certificate hash.\r
1436 //\r
1437 switch (HashAlg) {\r
1438 case HASHALG_SHA256:\r
1439 SignatureType = gEfiCertX509Sha256Guid;\r
1440 break;\r
1441 case HASHALG_SHA384:\r
1442 SignatureType = gEfiCertX509Sha384Guid;\r
1443 break;\r
1444 case HASHALG_SHA512:\r
1445 SignatureType = gEfiCertX509Sha512Guid;\r
1446 break;\r
1447 default:\r
1448 return FALSE;\r
1449 }\r
1450\r
1451 //\r
1452 // Add signature into the new variable data buffer\r
1453 //\r
1454 if (GetSignaturelistOffset((EFI_SIGNATURE_LIST *)Data, DataSize, &SignatureType, &Offset)) {\r
1455 //\r
1456 // Add the signature to the found signaturelist.\r
1457 //\r
1458 DbSize = DataSize + SignatureSize;\r
1459 NewData = AllocateZeroPool (DbSize);\r
1460 if (NewData == NULL) {\r
1461 Status = EFI_OUT_OF_RESOURCES;\r
1462 goto ON_EXIT;\r
1463 }\r
1464\r
1465 SignatureList = (EFI_SIGNATURE_LIST *)(Data + Offset);\r
1466 SignatureListSize = (UINTN) ReadUnaligned32 ((UINT32 *)&SignatureList->SignatureListSize);\r
1467 CopyMem (NewData, Data, Offset + SignatureListSize);\r
1468\r
1469 SignatureList = (EFI_SIGNATURE_LIST *)(NewData + Offset);\r
1470 WriteUnaligned32 ((UINT32 *) &SignatureList->SignatureListSize, (UINT32)(SignatureListSize + SignatureSize));\r
1471\r
1472 Offset += SignatureListSize;\r
1473 CopyMem (NewData + Offset, SignatureData, SignatureSize);\r
1474 CopyMem (NewData + Offset + SignatureSize, Data + Offset, DataSize - Offset);\r
1475\r
1476 FreePool (Data);\r
1477 Data = NewData;\r
1478 DataSize = DbSize;\r
1479 } else {\r
1480 //\r
1481 // Create a new signaturelist, and add the signature into the signaturelist.\r
1482 //\r
1483 DbSize = DataSize + sizeof(EFI_SIGNATURE_LIST) + SignatureSize;\r
1484 NewData = AllocateZeroPool (DbSize);\r
1485 if (NewData == NULL) {\r
1486 Status = EFI_OUT_OF_RESOURCES;\r
1487 goto ON_EXIT;\r
1488 }\r
1489 //\r
1490 // Fill Certificate Database parameters.\r
1491 //\r
1492 SignatureList = (EFI_SIGNATURE_LIST*) (NewData + DataSize);\r
1493 SignatureListSize = sizeof(EFI_SIGNATURE_LIST) + SignatureSize;\r
1494 WriteUnaligned32 ((UINT32 *) &SignatureList->SignatureListSize, (UINT32) SignatureListSize);\r
1495 WriteUnaligned32 ((UINT32 *) &SignatureList->SignatureSize, (UINT32) SignatureSize);\r
1496 CopyGuid (&SignatureList->SignatureType, &SignatureType);\r
1497 CopyMem ((UINT8* ) SignatureList + sizeof (EFI_SIGNATURE_LIST), SignatureData, SignatureSize);\r
1498 if ((DataSize != 0) && (Data != NULL)) {\r
1499 CopyMem (NewData, Data, DataSize);\r
1500 FreePool (Data);\r
1501 }\r
1502 Data = NewData;\r
1503 DataSize = DbSize;\r
1504 }\r
1505\r
1506 Status = CreateTimeBasedPayload (&DataSize, (UINT8**) &Data);\r
1507 if (EFI_ERROR (Status)) {\r
1508 goto ON_EXIT;\r
1509 }\r
1510\r
1511 Attr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS\r
1512 | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS;\r
1513 Status = gRT->SetVariable(\r
1514 EFI_IMAGE_SECURITY_DATABASE1,\r
1515 &gEfiImageSecurityDatabaseGuid,\r
1516 Attr,\r
1517 DataSize,\r
1518 Data\r
1519 );\r
1520 if (EFI_ERROR (Status)) {\r
1521 goto ON_EXIT;\r
1522 }\r
1523\r
1524ON_EXIT:\r
1525 CloseFile (Private->FileContext->FHandle);\r
1526 if (Private->FileContext->FileName != NULL){\r
1527 FreePool(Private->FileContext->FileName);\r
1528 Private->FileContext->FileName = NULL;\r
1529 }\r
1530\r
1531 Private->FileContext->FHandle = NULL;\r
1532\r
1533 if (Private->SignatureGUID != NULL) {\r
1534 FreePool (Private->SignatureGUID);\r
1535 Private->SignatureGUID = NULL;\r
1536 }\r
1537\r
1538 if (Data != NULL) {\r
1539 FreePool (Data);\r
1540 }\r
1541\r
1542 if (SignatureData != NULL) {\r
1543 FreePool (SignatureData);\r
1544 }\r
1545\r
1546 if (X509Data != NULL) {\r
1547 FreePool (X509Data);\r
1548 }\r
1549\r
1550 return Status;\r
1551}\r
1552\r
1553/**\r
1554 Check whether a certificate from a file exists in dbx.\r
1555\r
1556 @param[in] PrivateData The module's private data.\r
1557 @param[in] VariableName Variable name of signature database, must be\r
1558 EFI_IMAGE_SECURITY_DATABASE1.\r
1559\r
1560 @retval TRUE The X509 certificate is found in dbx successfully.\r
1561 @retval FALSE The X509 certificate is not found in dbx.\r
1562**/\r
1563BOOLEAN\r
1564IsX509CertInDbx (\r
1565 IN SECUREBOOT_CONFIG_PRIVATE_DATA *Private,\r
1566 IN CHAR16 *VariableName\r
1567 )\r
1568{\r
1569 EFI_STATUS Status;\r
1570 UINTN X509DataSize;\r
1571 VOID *X509Data;\r
1572 BOOLEAN IsFound;\r
1573\r
1574 //\r
1575 // Read the certificate from file\r
1576 //\r
1577 X509DataSize = 0;\r
1578 X509Data = NULL;\r
1579 Status = ReadFileContent (\r
1580 Private->FileContext->FHandle,\r
1581 &X509Data,\r
1582 &X509DataSize,\r
1583 0\r
1584 );\r
1585 if (EFI_ERROR (Status)) {\r
1586 return FALSE;\r
1587 }\r
1588\r
1589 //\r
1590 // Check the raw certificate.\r
1591 //\r
1592 IsFound = FALSE;\r
1593 if (IsSignatureFoundInDatabase (EFI_IMAGE_SECURITY_DATABASE1, X509Data, X509DataSize)) {\r
1594 IsFound = TRUE;\r
1595 goto ON_EXIT;\r
1596 }\r
1597\r
1598 //\r
1599 // Check the hash of certificate.\r
1600 //\r
1601 if (IsCertHashFoundInDbx (X509Data, X509DataSize)) {\r
1602 IsFound = TRUE;\r
1603 goto ON_EXIT;\r
1604 }\r
1605\r
1606ON_EXIT:\r
1607 if (X509Data != NULL) {\r
1608 FreePool (X509Data);\r
1609 }\r
1610\r
1611 return IsFound;\r
1612}\r
1613\r
1614/**\r
1615 Load PE/COFF image information into internal buffer and check its validity.\r
1616\r
1617 @retval EFI_SUCCESS Successful\r
1618 @retval EFI_UNSUPPORTED Invalid PE/COFF file\r
1619 @retval EFI_ABORTED Serious error occurs, like file I/O error etc.\r
1620\r
1621**/\r
1622EFI_STATUS\r
1623LoadPeImage (\r
1624 VOID\r
1625 )\r
1626{\r
1627 EFI_IMAGE_DOS_HEADER *DosHdr;\r
1628 EFI_IMAGE_NT_HEADERS32 *NtHeader32;\r
1629 EFI_IMAGE_NT_HEADERS64 *NtHeader64;\r
1630\r
1631 NtHeader32 = NULL;\r
1632 NtHeader64 = NULL;\r
1633 //\r
1634 // Read the Dos header\r
1635 //\r
1636 DosHdr = (EFI_IMAGE_DOS_HEADER*)(mImageBase);\r
1637 if (DosHdr->e_magic == EFI_IMAGE_DOS_SIGNATURE)\r
1638 {\r
1639 //\r
1640 // DOS image header is present,\r
1641 // So read the PE header after the DOS image header\r
1642 //\r
1643 mPeCoffHeaderOffset = DosHdr->e_lfanew;\r
1644 }\r
1645 else\r
1646 {\r
1647 mPeCoffHeaderOffset = 0;\r
1648 }\r
1649\r
1650 //\r
1651 // Read PE header and check the signature validity and machine compatibility\r
1652 //\r
1653 NtHeader32 = (EFI_IMAGE_NT_HEADERS32*) (mImageBase + mPeCoffHeaderOffset);\r
1654 if (NtHeader32->Signature != EFI_IMAGE_NT_SIGNATURE)\r
1655 {\r
1656 return EFI_UNSUPPORTED;\r
1657 }\r
1658\r
1659 mNtHeader.Pe32 = NtHeader32;\r
1660\r
1661 //\r
1662 // Check the architecture field of PE header and get the Certificate Data Directory data\r
1663 // Note the size of FileHeader field is constant for both IA32 and X64 arch\r
1664 //\r
1665 if ((NtHeader32->FileHeader.Machine == EFI_IMAGE_MACHINE_IA32)\r
1666 || (NtHeader32->FileHeader.Machine == EFI_IMAGE_MACHINE_EBC)\r
1667 || (NtHeader32->FileHeader.Machine == EFI_IMAGE_MACHINE_ARMTHUMB_MIXED)) {\r
1668 //\r
1669 // 32-bits Architecture\r
1670 //\r
1671 mImageType = ImageType_IA32;\r
1672 mSecDataDir = (EFI_IMAGE_SECURITY_DATA_DIRECTORY*) &(NtHeader32->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_SECURITY]);\r
1673 }\r
1674 else if ((NtHeader32->FileHeader.Machine == EFI_IMAGE_MACHINE_IA64)\r
1675 || (NtHeader32->FileHeader.Machine == EFI_IMAGE_MACHINE_X64)\r
1676 || (NtHeader32->FileHeader.Machine == EFI_IMAGE_MACHINE_AARCH64)) {\r
1677 //\r
1678 // 64-bits Architecture\r
1679 //\r
1680 mImageType = ImageType_X64;\r
1681 NtHeader64 = (EFI_IMAGE_NT_HEADERS64 *) (mImageBase + mPeCoffHeaderOffset);\r
1682 mSecDataDir = (EFI_IMAGE_SECURITY_DATA_DIRECTORY*) &(NtHeader64->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_SECURITY]);\r
1683 } else {\r
1684 return EFI_UNSUPPORTED;\r
1685 }\r
1686\r
1687 return EFI_SUCCESS;\r
1688}\r
1689\r
1690/**\r
1691 Calculate hash of Pe/Coff image based on the authenticode image hashing in\r
1692 PE/COFF Specification 8.0 Appendix A\r
1693\r
1694 @param[in] HashAlg Hash algorithm type.\r
1695\r
1696 @retval TRUE Successfully hash image.\r
1697 @retval FALSE Fail in hash image.\r
1698\r
1699**/\r
1700BOOLEAN\r
1701HashPeImage (\r
1702 IN UINT32 HashAlg\r
1703 )\r
1704{\r
1705 BOOLEAN Status;\r
1706 UINT16 Magic;\r
1707 EFI_IMAGE_SECTION_HEADER *Section;\r
1708 VOID *HashCtx;\r
1709 UINTN CtxSize;\r
1710 UINT8 *HashBase;\r
1711 UINTN HashSize;\r
1712 UINTN SumOfBytesHashed;\r
1713 EFI_IMAGE_SECTION_HEADER *SectionHeader;\r
1714 UINTN Index;\r
1715 UINTN Pos;\r
1716\r
1717 HashCtx = NULL;\r
1718 SectionHeader = NULL;\r
1719 Status = FALSE;\r
1720\r
1721 if ((HashAlg != HASHALG_SHA1) && (HashAlg != HASHALG_SHA256)) {\r
1722 return FALSE;\r
1723 }\r
1724\r
1725 //\r
1726 // Initialize context of hash.\r
1727 //\r
1728 ZeroMem (mImageDigest, MAX_DIGEST_SIZE);\r
1729\r
1730 if (HashAlg == HASHALG_SHA1) {\r
1731 mImageDigestSize = SHA1_DIGEST_SIZE;\r
1732 mCertType = gEfiCertSha1Guid;\r
1733 } else if (HashAlg == HASHALG_SHA256) {\r
1734 mImageDigestSize = SHA256_DIGEST_SIZE;\r
1735 mCertType = gEfiCertSha256Guid;\r
1736 }\r
1737\r
1738 CtxSize = mHash[HashAlg].GetContextSize();\r
1739\r
1740 HashCtx = AllocatePool (CtxSize);\r
1741 ASSERT (HashCtx != NULL);\r
1742\r
1743 // 1. Load the image header into memory.\r
1744\r
1745 // 2. Initialize a SHA hash context.\r
1746 Status = mHash[HashAlg].HashInit(HashCtx);\r
1747 if (!Status) {\r
1748 goto Done;\r
1749 }\r
1750 //\r
1751 // Measuring PE/COFF Image Header;\r
1752 // But CheckSum field and SECURITY data directory (certificate) are excluded\r
1753 //\r
1754 if (mNtHeader.Pe32->FileHeader.Machine == IMAGE_FILE_MACHINE_IA64 && mNtHeader.Pe32->OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {\r
1755 //\r
1756 // NOTE: Some versions of Linux ELILO for Itanium have an incorrect magic value\r
1757 // in the PE/COFF Header. If the MachineType is Itanium(IA64) and the\r
1758 // Magic value in the OptionalHeader is EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC\r
1759 // then override the magic value to EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC\r
1760 //\r
1761 Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC;\r
1762 } else {\r
1763 //\r
1764 // Get the magic value from the PE/COFF Optional Header\r
1765 //\r
1766 Magic = mNtHeader.Pe32->OptionalHeader.Magic;\r
1767 }\r
1768\r
1769 //\r
1770 // 3. Calculate the distance from the base of the image header to the image checksum address.\r
1771 // 4. Hash the image header from its base to beginning of the image checksum.\r
1772 //\r
1773 HashBase = mImageBase;\r
1774 if (Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {\r
1775 //\r
1776 // Use PE32 offset.\r
1777 //\r
1778 HashSize = (UINTN) ((UINT8 *) (&mNtHeader.Pe32->OptionalHeader.CheckSum) - HashBase);\r
1779 } else {\r
1780 //\r
1781 // Use PE32+ offset.\r
1782 //\r
1783 HashSize = (UINTN) ((UINT8 *) (&mNtHeader.Pe32Plus->OptionalHeader.CheckSum) - HashBase);\r
1784 }\r
1785\r
1786 Status = mHash[HashAlg].HashUpdate(HashCtx, HashBase, HashSize);\r
1787 if (!Status) {\r
1788 goto Done;\r
1789 }\r
1790 //\r
1791 // 5. Skip over the image checksum (it occupies a single ULONG).\r
1792 // 6. Get the address of the beginning of the Cert Directory.\r
1793 // 7. Hash everything from the end of the checksum to the start of the Cert Directory.\r
1794 //\r
1795 if (Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {\r
1796 //\r
1797 // Use PE32 offset.\r
1798 //\r
1799 HashBase = (UINT8 *) &mNtHeader.Pe32->OptionalHeader.CheckSum + sizeof (UINT32);\r
1800 HashSize = (UINTN) ((UINT8 *) (&mNtHeader.Pe32->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_SECURITY]) - HashBase);\r
1801 } else {\r
1802 //\r
1803 // Use PE32+ offset.\r
1804 //\r
1805 HashBase = (UINT8 *) &mNtHeader.Pe32Plus->OptionalHeader.CheckSum + sizeof (UINT32);\r
1806 HashSize = (UINTN) ((UINT8 *) (&mNtHeader.Pe32Plus->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_SECURITY]) - HashBase);\r
1807 }\r
1808\r
1809 Status = mHash[HashAlg].HashUpdate(HashCtx, HashBase, HashSize);\r
1810 if (!Status) {\r
1811 goto Done;\r
1812 }\r
1813 //\r
1814 // 8. Skip over the Cert Directory. (It is sizeof(IMAGE_DATA_DIRECTORY) bytes.)\r
1815 // 9. Hash everything from the end of the Cert Directory to the end of image header.\r
1816 //\r
1817 if (Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {\r
1818 //\r
1819 // Use PE32 offset\r
1820 //\r
1821 HashBase = (UINT8 *) &mNtHeader.Pe32->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_SECURITY + 1];\r
1822 HashSize = mNtHeader.Pe32->OptionalHeader.SizeOfHeaders - (UINTN) ((UINT8 *) (&mNtHeader.Pe32->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_SECURITY + 1]) - mImageBase);\r
1823 } else {\r
1824 //\r
1825 // Use PE32+ offset.\r
1826 //\r
1827 HashBase = (UINT8 *) &mNtHeader.Pe32Plus->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_SECURITY + 1];\r
1828 HashSize = mNtHeader.Pe32Plus->OptionalHeader.SizeOfHeaders - (UINTN) ((UINT8 *) (&mNtHeader.Pe32Plus->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_SECURITY + 1]) - mImageBase);\r
1829 }\r
1830\r
1831 Status = mHash[HashAlg].HashUpdate(HashCtx, HashBase, HashSize);\r
1832 if (!Status) {\r
1833 goto Done;\r
1834 }\r
1835 //\r
1836 // 10. Set the SUM_OF_BYTES_HASHED to the size of the header.\r
1837 //\r
1838 if (Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {\r
1839 //\r
1840 // Use PE32 offset.\r
1841 //\r
1842 SumOfBytesHashed = mNtHeader.Pe32->OptionalHeader.SizeOfHeaders;\r
1843 } else {\r
1844 //\r
1845 // Use PE32+ offset\r
1846 //\r
1847 SumOfBytesHashed = mNtHeader.Pe32Plus->OptionalHeader.SizeOfHeaders;\r
1848 }\r
1849\r
1850 //\r
1851 // 11. Build a temporary table of pointers to all the IMAGE_SECTION_HEADER\r
1852 // structures in the image. The 'NumberOfSections' field of the image\r
1853 // header indicates how big the table should be. Do not include any\r
1854 // IMAGE_SECTION_HEADERs in the table whose 'SizeOfRawData' field is zero.\r
1855 //\r
1856 SectionHeader = (EFI_IMAGE_SECTION_HEADER *) AllocateZeroPool (sizeof (EFI_IMAGE_SECTION_HEADER) * mNtHeader.Pe32->FileHeader.NumberOfSections);\r
1857 ASSERT (SectionHeader != NULL);\r
1858 //\r
1859 // 12. Using the 'PointerToRawData' in the referenced section headers as\r
1860 // a key, arrange the elements in the table in ascending order. In other\r
1861 // words, sort the section headers according to the disk-file offset of\r
1862 // the section.\r
1863 //\r
1864 Section = (EFI_IMAGE_SECTION_HEADER *) (\r
1865 mImageBase +\r
1866 mPeCoffHeaderOffset +\r
1867 sizeof (UINT32) +\r
1868 sizeof (EFI_IMAGE_FILE_HEADER) +\r
1869 mNtHeader.Pe32->FileHeader.SizeOfOptionalHeader\r
1870 );\r
1871 for (Index = 0; Index < mNtHeader.Pe32->FileHeader.NumberOfSections; Index++) {\r
1872 Pos = Index;\r
1873 while ((Pos > 0) && (Section->PointerToRawData < SectionHeader[Pos - 1].PointerToRawData)) {\r
1874 CopyMem (&SectionHeader[Pos], &SectionHeader[Pos - 1], sizeof (EFI_IMAGE_SECTION_HEADER));\r
1875 Pos--;\r
1876 }\r
1877 CopyMem (&SectionHeader[Pos], Section, sizeof (EFI_IMAGE_SECTION_HEADER));\r
1878 Section += 1;\r
1879 }\r
1880\r
1881 //\r
1882 // 13. Walk through the sorted table, bring the corresponding section\r
1883 // into memory, and hash the entire section (using the 'SizeOfRawData'\r
1884 // field in the section header to determine the amount of data to hash).\r
1885 // 14. Add the section's 'SizeOfRawData' to SUM_OF_BYTES_HASHED .\r
1886 // 15. Repeat steps 13 and 14 for all the sections in the sorted table.\r
1887 //\r
1888 for (Index = 0; Index < mNtHeader.Pe32->FileHeader.NumberOfSections; Index++) {\r
1889 Section = &SectionHeader[Index];\r
1890 if (Section->SizeOfRawData == 0) {\r
1891 continue;\r
1892 }\r
1893 HashBase = mImageBase + Section->PointerToRawData;\r
1894 HashSize = (UINTN) Section->SizeOfRawData;\r
1895\r
1896 Status = mHash[HashAlg].HashUpdate(HashCtx, HashBase, HashSize);\r
1897 if (!Status) {\r
1898 goto Done;\r
1899 }\r
1900\r
1901 SumOfBytesHashed += HashSize;\r
1902 }\r
1903\r
1904 //\r
1905 // 16. If the file size is greater than SUM_OF_BYTES_HASHED, there is extra\r
1906 // data in the file that needs to be added to the hash. This data begins\r
1907 // at file offset SUM_OF_BYTES_HASHED and its length is:\r
1908 // FileSize - (CertDirectory->Size)\r
1909 //\r
1910 if (mImageSize > SumOfBytesHashed) {\r
1911 HashBase = mImageBase + SumOfBytesHashed;\r
1912 if (Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {\r
1913 //\r
1914 // Use PE32 offset.\r
1915 //\r
1916 HashSize = (UINTN)(\r
1917 mImageSize -\r
1918 mNtHeader.Pe32->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_SECURITY].Size -\r
1919 SumOfBytesHashed);\r
1920 } else {\r
1921 //\r
1922 // Use PE32+ offset.\r
1923 //\r
1924 HashSize = (UINTN)(\r
1925 mImageSize -\r
1926 mNtHeader.Pe32Plus->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_SECURITY].Size -\r
1927 SumOfBytesHashed);\r
1928 }\r
1929\r
1930 Status = mHash[HashAlg].HashUpdate(HashCtx, HashBase, HashSize);\r
1931 if (!Status) {\r
1932 goto Done;\r
1933 }\r
1934 }\r
1935\r
1936 Status = mHash[HashAlg].HashFinal(HashCtx, mImageDigest);\r
1937\r
1938Done:\r
1939 if (HashCtx != NULL) {\r
1940 FreePool (HashCtx);\r
1941 }\r
1942 if (SectionHeader != NULL) {\r
1943 FreePool (SectionHeader);\r
1944 }\r
1945 return Status;\r
1946}\r
1947\r
1948/**\r
1949 Recognize the Hash algorithm in PE/COFF Authenticode and calculate hash of\r
1950 Pe/Coff image based on the authenticated image hashing in PE/COFF Specification\r
1951 8.0 Appendix A\r
1952\r
1953 @retval EFI_UNSUPPORTED Hash algorithm is not supported.\r
1954 @retval EFI_SUCCESS Hash successfully.\r
1955\r
1956**/\r
1957EFI_STATUS\r
1958HashPeImageByType (\r
1959 VOID\r
1960 )\r
1961{\r
1962 UINT8 Index;\r
1963 WIN_CERTIFICATE_EFI_PKCS *PkcsCertData;\r
1964\r
1965 PkcsCertData = (WIN_CERTIFICATE_EFI_PKCS *) (mImageBase + mSecDataDir->Offset);\r
1966\r
1967 for (Index = 0; Index < HASHALG_MAX; Index++) {\r
1968 //\r
1969 // Check the Hash algorithm in PE/COFF Authenticode.\r
1970 // According to PKCS#7 Definition:\r
1971 // SignedData ::= SEQUENCE {\r
1972 // version Version,\r
1973 // digestAlgorithms DigestAlgorithmIdentifiers,\r
1974 // contentInfo ContentInfo,\r
1975 // .... }\r
1976 // The DigestAlgorithmIdentifiers can be used to determine the hash algorithm in PE/COFF hashing\r
1977 // This field has the fixed offset (+32) in final Authenticode ASN.1 data.\r
1978 // Fixed offset (+32) is calculated based on two bytes of length encoding.\r
1979 //\r
1980 if ((*(PkcsCertData->CertData + 1) & TWO_BYTE_ENCODE) != TWO_BYTE_ENCODE) {\r
1981 //\r
1982 // Only support two bytes of Long Form of Length Encoding.\r
1983 //\r
1984 continue;\r
1985 }\r
1986\r
1987 //\r
1988 if (CompareMem (PkcsCertData->CertData + 32, mHash[Index].OidValue, mHash[Index].OidLength) == 0) {\r
1989 break;\r
1990 }\r
1991 }\r
1992\r
1993 if (Index == HASHALG_MAX) {\r
1994 return EFI_UNSUPPORTED;\r
1995 }\r
1996\r
1997 //\r
1998 // HASH PE Image based on Hash algorithm in PE/COFF Authenticode.\r
1999 //\r
2000 if (!HashPeImage(Index)) {\r
2001 return EFI_UNSUPPORTED;\r
2002 }\r
2003\r
2004 return EFI_SUCCESS;\r
2005}\r
2006\r
2007/**\r
2008 Enroll a new executable's signature into Signature Database.\r
2009\r
2010 @param[in] PrivateData The module's private data.\r
2011 @param[in] VariableName Variable name of signature database, must be\r
2012 EFI_IMAGE_SECURITY_DATABASE, EFI_IMAGE_SECURITY_DATABASE1\r
2013 or EFI_IMAGE_SECURITY_DATABASE2.\r
2014\r
2015 @retval EFI_SUCCESS New signature is enrolled successfully.\r
2016 @retval EFI_INVALID_PARAMETER The parameter is invalid.\r
2017 @retval EFI_UNSUPPORTED Unsupported command.\r
2018 @retval EFI_OUT_OF_RESOURCES Could not allocate needed resources.\r
2019\r
2020**/\r
2021EFI_STATUS\r
2022EnrollImageSignatureToSigDB (\r
2023 IN SECUREBOOT_CONFIG_PRIVATE_DATA *Private,\r
2024 IN CHAR16 *VariableName\r
2025 )\r
2026{\r
2027 EFI_STATUS Status;\r
2028 EFI_SIGNATURE_LIST *SigDBCert;\r
2029 EFI_SIGNATURE_DATA *SigDBCertData;\r
2030 VOID *Data;\r
2031 UINTN DataSize;\r
2032 UINTN SigDBSize;\r
2033 UINT32 Attr;\r
2034 WIN_CERTIFICATE_UEFI_GUID *GuidCertData;\r
2035\r
2036 Data = NULL;\r
2037 GuidCertData = NULL;\r
2038\r
2039 if (StrCmp (VariableName, EFI_IMAGE_SECURITY_DATABASE2) == 0) {\r
2040 return EFI_UNSUPPORTED;\r
2041 }\r
2042\r
2043 //\r
2044 // Form the SigDB certificate list.\r
2045 // Format the data item into EFI_SIGNATURE_LIST type.\r
2046 //\r
2047 // We need to parse executable's signature data from specified signed executable file.\r
2048 // In current implementation, we simply trust the pass-in signed executable file.\r
2049 // In reality, it's OS's responsibility to verify the signed executable file.\r
2050 //\r
2051\r
2052 //\r
2053 // Read the whole file content\r
2054 //\r
2055 Status = ReadFileContent(\r
2056 Private->FileContext->FHandle,\r
2057 (VOID **) &mImageBase,\r
2058 &mImageSize,\r
2059 0\r
2060 );\r
2061 if (EFI_ERROR (Status)) {\r
2062 goto ON_EXIT;\r
2063 }\r
2064 ASSERT (mImageBase != NULL);\r
2065\r
2066 Status = LoadPeImage ();\r
2067 if (EFI_ERROR (Status)) {\r
2068 goto ON_EXIT;\r
2069 }\r
2070\r
2071 if (mSecDataDir->SizeOfCert == 0) {\r
2072 if (!HashPeImage (HASHALG_SHA256)) {\r
2073 Status = EFI_SECURITY_VIOLATION;\r
2074 goto ON_EXIT;\r
2075 }\r
2076 } else {\r
2077\r
2078 //\r
2079 // Read the certificate data\r
2080 //\r
2081 mCertificate = (WIN_CERTIFICATE *)(mImageBase + mSecDataDir->Offset);\r
2082\r
2083 if (mCertificate->wCertificateType == WIN_CERT_TYPE_EFI_GUID) {\r
2084 GuidCertData = (WIN_CERTIFICATE_UEFI_GUID*) mCertificate;\r
2085 if (CompareMem (&GuidCertData->CertType, &gEfiCertTypeRsa2048Sha256Guid, sizeof(EFI_GUID)) != 0) {\r
2086 Status = EFI_ABORTED;\r
2087 goto ON_EXIT;\r
2088 }\r
2089\r
2090 if (!HashPeImage (HASHALG_SHA256)) {\r
2091 Status = EFI_ABORTED;\r
2092 goto ON_EXIT;;\r
2093 }\r
2094\r
2095 } else if (mCertificate->wCertificateType == WIN_CERT_TYPE_PKCS_SIGNED_DATA) {\r
2096\r
2097 Status = HashPeImageByType ();\r
2098 if (EFI_ERROR (Status)) {\r
2099 goto ON_EXIT;;\r
2100 }\r
2101 } else {\r
2102 Status = EFI_ABORTED;\r
2103 goto ON_EXIT;\r
2104 }\r
2105 }\r
2106\r
2107 //\r
2108 // Create a new SigDB entry.\r
2109 //\r
2110 SigDBSize = sizeof(EFI_SIGNATURE_LIST)\r
2111 + sizeof(EFI_SIGNATURE_DATA) - 1\r
2112 + (UINT32) mImageDigestSize;\r
2113\r
2114 Data = (UINT8*) AllocateZeroPool (SigDBSize);\r
2115 if (Data == NULL) {\r
2116 Status = EFI_OUT_OF_RESOURCES;\r
2117 goto ON_EXIT;\r
2118 }\r
2119\r
2120 //\r
2121 // Adjust the Certificate Database parameters.\r
2122 //\r
2123 SigDBCert = (EFI_SIGNATURE_LIST*) Data;\r
2124 SigDBCert->SignatureListSize = (UINT32) SigDBSize;\r
2125 SigDBCert->SignatureHeaderSize = 0;\r
2126 SigDBCert->SignatureSize = sizeof(EFI_SIGNATURE_DATA) - 1 + (UINT32) mImageDigestSize;\r
2127 CopyGuid (&SigDBCert->SignatureType, &mCertType);\r
2128\r
2129 SigDBCertData = (EFI_SIGNATURE_DATA*)((UINT8*)SigDBCert + sizeof(EFI_SIGNATURE_LIST));\r
2130 CopyGuid (&SigDBCertData->SignatureOwner, Private->SignatureGUID);\r
2131 CopyMem (SigDBCertData->SignatureData, mImageDigest, mImageDigestSize);\r
2132\r
2133 Attr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS\r
2134 | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS;\r
2135 Status = CreateTimeBasedPayload (&SigDBSize, (UINT8**) &Data);\r
2136 if (EFI_ERROR (Status)) {\r
2137 DEBUG ((EFI_D_ERROR, "Fail to create time-based data payload: %r", Status));\r
2138 goto ON_EXIT;\r
2139 }\r
2140\r
2141 //\r
2142 // Check if SigDB variable has been already existed.\r
2143 // If true, use EFI_VARIABLE_APPEND_WRITE attribute to append the\r
2144 // new signature data to original variable\r
2145 //\r
2146 DataSize = 0;\r
2147 Status = gRT->GetVariable(\r
2148 VariableName,\r
2149 &gEfiImageSecurityDatabaseGuid,\r
2150 NULL,\r
2151 &DataSize,\r
2152 NULL\r
2153 );\r
2154 if (Status == EFI_BUFFER_TOO_SMALL) {\r
2155 Attr |= EFI_VARIABLE_APPEND_WRITE;\r
2156 } else if (Status != EFI_NOT_FOUND) {\r
2157 goto ON_EXIT;\r
2158 }\r
2159\r
2160 //\r
2161 // Enroll the variable.\r
2162 //\r
2163 Status = gRT->SetVariable(\r
2164 VariableName,\r
2165 &gEfiImageSecurityDatabaseGuid,\r
2166 Attr,\r
2167 SigDBSize,\r
2168 Data\r
2169 );\r
2170 if (EFI_ERROR (Status)) {\r
2171 goto ON_EXIT;\r
2172 }\r
2173\r
2174ON_EXIT:\r
2175\r
2176 CloseFile (Private->FileContext->FHandle);\r
2177 Private->FileContext->FHandle = NULL;\r
2178\r
2179 if (Private->FileContext->FileName != NULL){\r
2180 FreePool(Private->FileContext->FileName);\r
2181 Private->FileContext->FileName = NULL;\r
2182 }\r
2183\r
2184 if (Private->SignatureGUID != NULL) {\r
2185 FreePool (Private->SignatureGUID);\r
2186 Private->SignatureGUID = NULL;\r
2187 }\r
2188\r
2189 if (Data != NULL) {\r
2190 FreePool (Data);\r
2191 }\r
2192\r
2193 if (mImageBase != NULL) {\r
2194 FreePool (mImageBase);\r
2195 mImageBase = NULL;\r
2196 }\r
2197\r
2198 return Status;\r
2199}\r
2200\r
2201/**\r
2202 Enroll signature into DB/DBX/DBT without KEK's authentication.\r
2203 The SignatureOwner GUID will be Private->SignatureGUID.\r
2204\r
2205 @param[in] PrivateData The module's private data.\r
2206 @param[in] VariableName Variable name of signature database, must be\r
2207 EFI_IMAGE_SECURITY_DATABASE or EFI_IMAGE_SECURITY_DATABASE1.\r
2208\r
2209 @retval EFI_SUCCESS New signature enrolled successfully.\r
2210 @retval EFI_INVALID_PARAMETER The parameter is invalid.\r
2211 @retval others Fail to enroll signature data.\r
2212\r
2213**/\r
2214EFI_STATUS\r
2215EnrollSignatureDatabase (\r
2216 IN SECUREBOOT_CONFIG_PRIVATE_DATA *Private,\r
2217 IN CHAR16 *VariableName\r
2218 )\r
2219{\r
2220 UINT16* FilePostFix;\r
2221 EFI_STATUS Status;\r
2222 UINTN NameLength;\r
2223\r
2224 if ((Private->FileContext->FileName == NULL) || (Private->FileContext->FHandle == NULL) || (Private->SignatureGUID == NULL)) {\r
2225 return EFI_INVALID_PARAMETER;\r
2226 }\r
2227\r
2228 Status = SetSecureBootMode (CUSTOM_SECURE_BOOT_MODE);\r
2229 if (EFI_ERROR (Status)) {\r
2230 return Status;\r
2231 }\r
2232\r
2233 //\r
2234 // Parse the file's postfix.\r
2235 //\r
2236 NameLength = StrLen (Private->FileContext->FileName);\r
2237 if (NameLength <= 4) {\r
2238 return EFI_INVALID_PARAMETER;\r
2239 }\r
2240 FilePostFix = Private->FileContext->FileName + NameLength - 4;\r
2241 if (IsDerEncodeCertificate (FilePostFix)) {\r
2242 //\r
2243 // Supports DER-encoded X509 certificate.\r
2244 //\r
2245 return EnrollX509toSigDB (Private, VariableName);\r
2246 }\r
2247\r
2248 return EnrollImageSignatureToSigDB (Private, VariableName);\r
2249}\r
2250\r
2251/**\r
2252 List all signatures in specified signature database (e.g. KEK/DB/DBX/DBT)\r
2253 by GUID in the page for user to select and delete as needed.\r
2254\r
2255 @param[in] PrivateData Module's private data.\r
2256 @param[in] VariableName The variable name of the vendor's signature database.\r
2257 @param[in] VendorGuid A unique identifier for the vendor.\r
2258 @param[in] LabelNumber Label number to insert opcodes.\r
2259 @param[in] FormId Form ID of current page.\r
2260 @param[in] QuestionIdBase Base question id of the signature list.\r
2261\r
2262 @retval EFI_SUCCESS Success to update the signature list page\r
2263 @retval EFI_OUT_OF_RESOURCES Unable to allocate required resources.\r
2264\r
2265**/\r
2266EFI_STATUS\r
2267UpdateDeletePage (\r
2268 IN SECUREBOOT_CONFIG_PRIVATE_DATA *PrivateData,\r
2269 IN CHAR16 *VariableName,\r
2270 IN EFI_GUID *VendorGuid,\r
2271 IN UINT16 LabelNumber,\r
2272 IN EFI_FORM_ID FormId,\r
2273 IN EFI_QUESTION_ID QuestionIdBase\r
2274 )\r
2275{\r
2276 EFI_STATUS Status;\r
2277 UINT32 Index;\r
2278 UINTN CertCount;\r
2279 UINTN GuidIndex;\r
2280 VOID *StartOpCodeHandle;\r
2281 VOID *EndOpCodeHandle;\r
2282 EFI_IFR_GUID_LABEL *StartLabel;\r
2283 EFI_IFR_GUID_LABEL *EndLabel;\r
2284 UINTN DataSize;\r
2285 UINT8 *Data;\r
2286 EFI_SIGNATURE_LIST *CertList;\r
2287 EFI_SIGNATURE_DATA *Cert;\r
2288 UINT32 ItemDataSize;\r
2289 CHAR16 *GuidStr;\r
2290 EFI_STRING_ID GuidID;\r
2291 EFI_STRING_ID Help;\r
2292\r
2293 Data = NULL;\r
2294 CertList = NULL;\r
2295 Cert = NULL;\r
2296 GuidStr = NULL;\r
2297 StartOpCodeHandle = NULL;\r
2298 EndOpCodeHandle = NULL;\r
2299\r
2300 //\r
2301 // Initialize the container for dynamic opcodes.\r
2302 //\r
2303 StartOpCodeHandle = HiiAllocateOpCodeHandle ();\r
2304 if (StartOpCodeHandle == NULL) {\r
2305 Status = EFI_OUT_OF_RESOURCES;\r
2306 goto ON_EXIT;\r
2307 }\r
2308\r
2309 EndOpCodeHandle = HiiAllocateOpCodeHandle ();\r
2310 if (EndOpCodeHandle == NULL) {\r
2311 Status = EFI_OUT_OF_RESOURCES;\r
2312 goto ON_EXIT;\r
2313 }\r
2314\r
2315 //\r
2316 // Create Hii Extend Label OpCode.\r
2317 //\r
2318 StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (\r
2319 StartOpCodeHandle,\r
2320 &gEfiIfrTianoGuid,\r
2321 NULL,\r
2322 sizeof (EFI_IFR_GUID_LABEL)\r
2323 );\r
2324 StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;\r
2325 StartLabel->Number = LabelNumber;\r
2326\r
2327 EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (\r
2328 EndOpCodeHandle,\r
2329 &gEfiIfrTianoGuid,\r
2330 NULL,\r
2331 sizeof (EFI_IFR_GUID_LABEL)\r
2332 );\r
2333 EndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;\r
2334 EndLabel->Number = LABEL_END;\r
2335\r
2336 //\r
2337 // Read Variable.\r
2338 //\r
2339 DataSize = 0;\r
2340 Status = gRT->GetVariable (VariableName, VendorGuid, NULL, &DataSize, Data);\r
2341 if (EFI_ERROR (Status) && Status != EFI_BUFFER_TOO_SMALL) {\r
2342 goto ON_EXIT;\r
2343 }\r
2344\r
2345 Data = (UINT8 *) AllocateZeroPool (DataSize);\r
2346 if (Data == NULL) {\r
2347 Status = EFI_OUT_OF_RESOURCES;\r
2348 goto ON_EXIT;\r
2349 }\r
2350\r
2351 Status = gRT->GetVariable (VariableName, VendorGuid, NULL, &DataSize, Data);\r
2352 if (EFI_ERROR (Status)) {\r
2353 goto ON_EXIT;\r
2354 }\r
2355\r
2356 GuidStr = AllocateZeroPool (100);\r
2357 if (GuidStr == NULL) {\r
2358 Status = EFI_OUT_OF_RESOURCES;\r
2359 goto ON_EXIT;\r
2360 }\r
2361\r
2362 //\r
2363 // Enumerate all KEK pub data.\r
2364 //\r
2365 ItemDataSize = (UINT32) DataSize;\r
2366 CertList = (EFI_SIGNATURE_LIST *) Data;\r
2367 GuidIndex = 0;\r
2368\r
2369 while ((ItemDataSize > 0) && (ItemDataSize >= CertList->SignatureListSize)) {\r
2370\r
2371 if (CompareGuid (&CertList->SignatureType, &gEfiCertRsa2048Guid)) {\r
2372 Help = STRING_TOKEN (STR_CERT_TYPE_RSA2048_SHA256_GUID);\r
2373 } else if (CompareGuid (&CertList->SignatureType, &gEfiCertX509Guid)) {\r
2374 Help = STRING_TOKEN (STR_CERT_TYPE_PCKS7_GUID);\r
2375 } else if (CompareGuid (&CertList->SignatureType, &gEfiCertSha1Guid)) {\r
2376 Help = STRING_TOKEN (STR_CERT_TYPE_SHA1_GUID);\r
2377 } else if (CompareGuid (&CertList->SignatureType, &gEfiCertSha256Guid)) {\r
2378 Help = STRING_TOKEN (STR_CERT_TYPE_SHA256_GUID);\r
2379 } else if (CompareGuid (&CertList->SignatureType, &gEfiCertX509Sha256Guid)) {\r
2380 Help = STRING_TOKEN (STR_CERT_TYPE_X509_SHA256_GUID);\r
2381 } else if (CompareGuid (&CertList->SignatureType, &gEfiCertX509Sha384Guid)) {\r
2382 Help = STRING_TOKEN (STR_CERT_TYPE_X509_SHA384_GUID);\r
2383 } else if (CompareGuid (&CertList->SignatureType, &gEfiCertX509Sha512Guid)) {\r
2384 Help = STRING_TOKEN (STR_CERT_TYPE_X509_SHA512_GUID);\r
2385 } else {\r
2386 //\r
2387 // The signature type is not supported in current implementation.\r
2388 //\r
2389 ItemDataSize -= CertList->SignatureListSize;\r
2390 CertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) CertList + CertList->SignatureListSize);\r
2391 continue;\r
2392 }\r
2393\r
2394 CertCount = (CertList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - CertList->SignatureHeaderSize) / CertList->SignatureSize;\r
2395 for (Index = 0; Index < CertCount; Index++) {\r
2396 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertList\r
2397 + sizeof (EFI_SIGNATURE_LIST)\r
2398 + CertList->SignatureHeaderSize\r
2399 + Index * CertList->SignatureSize);\r
2400 //\r
2401 // Display GUID and help\r
2402 //\r
2403 GuidToString (&Cert->SignatureOwner, GuidStr, 100);\r
2404 GuidID = HiiSetString (PrivateData->HiiHandle, 0, GuidStr, NULL);\r
2405 HiiCreateCheckBoxOpCode (\r
2406 StartOpCodeHandle,\r
2407 (EFI_QUESTION_ID) (QuestionIdBase + GuidIndex++),\r
2408 0,\r
2409 0,\r
2410 GuidID,\r
2411 Help,\r
2412 EFI_IFR_FLAG_CALLBACK,\r
2413 0,\r
2414 NULL\r
2415 );\r
2416 }\r
2417\r
2418 ItemDataSize -= CertList->SignatureListSize;\r
2419 CertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) CertList + CertList->SignatureListSize);\r
2420 }\r
2421\r
2422ON_EXIT:\r
2423 HiiUpdateForm (\r
2424 PrivateData->HiiHandle,\r
2425 &gSecureBootConfigFormSetGuid,\r
2426 FormId,\r
2427 StartOpCodeHandle,\r
2428 EndOpCodeHandle\r
2429 );\r
2430\r
2431 if (StartOpCodeHandle != NULL) {\r
2432 HiiFreeOpCodeHandle (StartOpCodeHandle);\r
2433 }\r
2434\r
2435 if (EndOpCodeHandle != NULL) {\r
2436 HiiFreeOpCodeHandle (EndOpCodeHandle);\r
2437 }\r
2438\r
2439 if (Data != NULL) {\r
2440 FreePool (Data);\r
2441 }\r
2442\r
2443 if (GuidStr != NULL) {\r
2444 FreePool (GuidStr);\r
2445 }\r
2446\r
2447 return EFI_SUCCESS;\r
2448}\r
2449\r
2450/**\r
2451 Delete a KEK entry from KEK database.\r
2452\r
2453 @param[in] PrivateData Module's private data.\r
2454 @param[in] QuestionId Question id of the KEK item to delete.\r
2455\r
2456 @retval EFI_SUCCESS Delete kek item successfully.\r
2457 @retval EFI_OUT_OF_RESOURCES Could not allocate needed resources.\r
2458\r
2459**/\r
2460EFI_STATUS\r
2461DeleteKeyExchangeKey (\r
2462 IN SECUREBOOT_CONFIG_PRIVATE_DATA *PrivateData,\r
2463 IN EFI_QUESTION_ID QuestionId\r
2464 )\r
2465{\r
2466 EFI_STATUS Status;\r
2467 UINTN DataSize;\r
2468 UINT8 *Data;\r
2469 UINT8 *OldData;\r
2470 UINT32 Attr;\r
2471 UINT32 Index;\r
2472 EFI_SIGNATURE_LIST *CertList;\r
2473 EFI_SIGNATURE_LIST *NewCertList;\r
2474 EFI_SIGNATURE_DATA *Cert;\r
2475 UINTN CertCount;\r
2476 UINT32 Offset;\r
2477 BOOLEAN IsKEKItemFound;\r
2478 UINT32 KekDataSize;\r
2479 UINTN DeleteKekIndex;\r
2480 UINTN GuidIndex;\r
2481\r
2482 Data = NULL;\r
2483 OldData = NULL;\r
2484 CertList = NULL;\r
2485 Cert = NULL;\r
2486 Attr = 0;\r
2487 DeleteKekIndex = QuestionId - OPTION_DEL_KEK_QUESTION_ID;\r
2488\r
2489 Status = SetSecureBootMode(CUSTOM_SECURE_BOOT_MODE);\r
2490 if (EFI_ERROR (Status)) {\r
2491 return Status;\r
2492 }\r
2493\r
2494 //\r
2495 // Get original KEK variable.\r
2496 //\r
2497 DataSize = 0;\r
2498 Status = gRT->GetVariable (EFI_KEY_EXCHANGE_KEY_NAME, &gEfiGlobalVariableGuid, NULL, &DataSize, NULL);\r
2499 if (EFI_ERROR(Status) && Status != EFI_BUFFER_TOO_SMALL) {\r
2500 goto ON_EXIT;\r
2501 }\r
2502\r
2503 OldData = (UINT8*)AllocateZeroPool(DataSize);\r
2504 if (OldData == NULL) {\r
2505 Status = EFI_OUT_OF_RESOURCES;\r
2506 goto ON_EXIT;\r
2507 }\r
2508\r
2509 Status = gRT->GetVariable (EFI_KEY_EXCHANGE_KEY_NAME, &gEfiGlobalVariableGuid, &Attr, &DataSize, OldData);\r
2510 if (EFI_ERROR(Status)) {\r
2511 goto ON_EXIT;\r
2512 }\r
2513\r
2514 //\r
2515 // Allocate space for new variable.\r
2516 //\r
2517 Data = (UINT8*) AllocateZeroPool (DataSize);\r
2518 if (Data == NULL) {\r
2519 Status = EFI_OUT_OF_RESOURCES;\r
2520 goto ON_EXIT;\r
2521 }\r
2522\r
2523 //\r
2524 // Enumerate all KEK pub data and erasing the target item.\r
2525 //\r
2526 IsKEKItemFound = FALSE;\r
2527 KekDataSize = (UINT32) DataSize;\r
2528 CertList = (EFI_SIGNATURE_LIST *) OldData;\r
2529 Offset = 0;\r
2530 GuidIndex = 0;\r
2531 while ((KekDataSize > 0) && (KekDataSize >= CertList->SignatureListSize)) {\r
2532 if (CompareGuid (&CertList->SignatureType, &gEfiCertRsa2048Guid) ||\r
2533 CompareGuid (&CertList->SignatureType, &gEfiCertX509Guid)) {\r
2534 CopyMem (Data + Offset, CertList, (sizeof(EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize));\r
2535 NewCertList = (EFI_SIGNATURE_LIST *)(Data + Offset);\r
2536 Offset += (sizeof(EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);\r
2537 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertList + sizeof (EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);\r
2538 CertCount = (CertList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - CertList->SignatureHeaderSize) / CertList->SignatureSize;\r
2539 for (Index = 0; Index < CertCount; Index++) {\r
2540 if (GuidIndex == DeleteKekIndex ) {\r
2541 //\r
2542 // Find it! Skip it!\r
2543 //\r
2544 NewCertList->SignatureListSize -= CertList->SignatureSize;\r
2545 IsKEKItemFound = TRUE;\r
2546 } else {\r
2547 //\r
2548 // This item doesn't match. Copy it to the Data buffer.\r
2549 //\r
2550 CopyMem (Data + Offset, Cert, CertList->SignatureSize);\r
2551 Offset += CertList->SignatureSize;\r
2552 }\r
2553 GuidIndex++;\r
2554 Cert = (EFI_SIGNATURE_DATA *) ((UINT8*) Cert + CertList->SignatureSize);\r
2555 }\r
2556 } else {\r
2557 //\r
2558 // This List doesn't match. Copy it to the Data buffer.\r
2559 //\r
2560 CopyMem (Data + Offset, CertList, CertList->SignatureListSize);\r
2561 Offset += CertList->SignatureListSize;\r
2562 }\r
2563\r
2564 KekDataSize -= CertList->SignatureListSize;\r
2565 CertList = (EFI_SIGNATURE_LIST*) ((UINT8*) CertList + CertList->SignatureListSize);\r
2566 }\r
2567\r
2568 if (!IsKEKItemFound) {\r
2569 //\r
2570 // Doesn't find the Kek Item!\r
2571 //\r
2572 Status = EFI_NOT_FOUND;\r
2573 goto ON_EXIT;\r
2574 }\r
2575\r
2576 //\r
2577 // Delete the Signature header if there is no signature in the list.\r
2578 //\r
2579 KekDataSize = Offset;\r
2580 CertList = (EFI_SIGNATURE_LIST*) Data;\r
2581 Offset = 0;\r
2582 ZeroMem (OldData, KekDataSize);\r
2583 while ((KekDataSize > 0) && (KekDataSize >= CertList->SignatureListSize)) {\r
2584 CertCount = (CertList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - CertList->SignatureHeaderSize) / CertList->SignatureSize;\r
2585 DEBUG ((DEBUG_INFO, " CertCount = %x\n", CertCount));\r
2586 if (CertCount != 0) {\r
2587 CopyMem (OldData + Offset, CertList, CertList->SignatureListSize);\r
2588 Offset += CertList->SignatureListSize;\r
2589 }\r
2590 KekDataSize -= CertList->SignatureListSize;\r
2591 CertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) CertList + CertList->SignatureListSize);\r
2592 }\r
2593\r
2594 DataSize = Offset;\r
2595 if ((Attr & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) != 0) {\r
2596 Status = CreateTimeBasedPayload (&DataSize, &OldData);\r
2597 if (EFI_ERROR (Status)) {\r
2598 DEBUG ((EFI_D_ERROR, "Fail to create time-based data payload: %r", Status));\r
2599 goto ON_EXIT;\r
2600 }\r
2601 }\r
2602\r
2603 Status = gRT->SetVariable(\r
2604 EFI_KEY_EXCHANGE_KEY_NAME,\r
2605 &gEfiGlobalVariableGuid,\r
2606 Attr,\r
2607 DataSize,\r
2608 OldData\r
2609 );\r
2610 if (EFI_ERROR (Status)) {\r
2611 DEBUG ((DEBUG_ERROR, "Failed to set variable, Status = %r\n", Status));\r
2612 goto ON_EXIT;\r
2613 }\r
2614\r
2615ON_EXIT:\r
2616 if (Data != NULL) {\r
2617 FreePool(Data);\r
2618 }\r
2619\r
2620 if (OldData != NULL) {\r
2621 FreePool(OldData);\r
2622 }\r
2623\r
2624 return UpdateDeletePage (\r
2625 PrivateData,\r
2626 EFI_KEY_EXCHANGE_KEY_NAME,\r
2627 &gEfiGlobalVariableGuid,\r
2628 LABEL_KEK_DELETE,\r
2629 FORMID_DELETE_KEK_FORM,\r
2630 OPTION_DEL_KEK_QUESTION_ID\r
2631 );\r
2632}\r
2633\r
2634/**\r
2635 Delete a signature entry from siganture database.\r
2636\r
2637 @param[in] PrivateData Module's private data.\r
2638 @param[in] VariableName The variable name of the vendor's signature database.\r
2639 @param[in] VendorGuid A unique identifier for the vendor.\r
2640 @param[in] LabelNumber Label number to insert opcodes.\r
2641 @param[in] FormId Form ID of current page.\r
2642 @param[in] QuestionIdBase Base question id of the signature list.\r
2643 @param[in] DeleteIndex Signature index to delete.\r
2644\r
2645 @retval EFI_SUCCESS Delete siganture successfully.\r
2646 @retval EFI_NOT_FOUND Can't find the signature item,\r
2647 @retval EFI_OUT_OF_RESOURCES Could not allocate needed resources.\r
2648**/\r
2649EFI_STATUS\r
2650DeleteSignature (\r
2651 IN SECUREBOOT_CONFIG_PRIVATE_DATA *PrivateData,\r
2652 IN CHAR16 *VariableName,\r
2653 IN EFI_GUID *VendorGuid,\r
2654 IN UINT16 LabelNumber,\r
2655 IN EFI_FORM_ID FormId,\r
2656 IN EFI_QUESTION_ID QuestionIdBase,\r
2657 IN UINTN DeleteIndex\r
2658 )\r
2659{\r
2660 EFI_STATUS Status;\r
2661 UINTN DataSize;\r
2662 UINT8 *Data;\r
2663 UINT8 *OldData;\r
2664 UINT32 Attr;\r
2665 UINT32 Index;\r
2666 EFI_SIGNATURE_LIST *CertList;\r
2667 EFI_SIGNATURE_LIST *NewCertList;\r
2668 EFI_SIGNATURE_DATA *Cert;\r
2669 UINTN CertCount;\r
2670 UINT32 Offset;\r
2671 BOOLEAN IsItemFound;\r
2672 UINT32 ItemDataSize;\r
2673 UINTN GuidIndex;\r
2674\r
2675 Data = NULL;\r
2676 OldData = NULL;\r
2677 CertList = NULL;\r
2678 Cert = NULL;\r
2679 Attr = 0;\r
2680\r
2681 Status = SetSecureBootMode(CUSTOM_SECURE_BOOT_MODE);\r
2682 if (EFI_ERROR (Status)) {\r
2683 return Status;\r
2684 }\r
2685\r
2686 //\r
2687 // Get original signature list data.\r
2688 //\r
2689 DataSize = 0;\r
2690 Status = gRT->GetVariable (VariableName, VendorGuid, NULL, &DataSize, NULL);\r
2691 if (EFI_ERROR (Status) && Status != EFI_BUFFER_TOO_SMALL) {\r
2692 goto ON_EXIT;\r
2693 }\r
2694\r
2695 OldData = (UINT8 *) AllocateZeroPool (DataSize);\r
2696 if (OldData == NULL) {\r
2697 Status = EFI_OUT_OF_RESOURCES;\r
2698 goto ON_EXIT;\r
2699 }\r
2700\r
2701 Status = gRT->GetVariable (VariableName, VendorGuid, &Attr, &DataSize, OldData);\r
2702 if (EFI_ERROR(Status)) {\r
2703 goto ON_EXIT;\r
2704 }\r
2705\r
2706 //\r
2707 // Allocate space for new variable.\r
2708 //\r
2709 Data = (UINT8*) AllocateZeroPool (DataSize);\r
2710 if (Data == NULL) {\r
2711 Status = EFI_OUT_OF_RESOURCES;\r
2712 goto ON_EXIT;\r
2713 }\r
2714\r
2715 //\r
2716 // Enumerate all signature data and erasing the target item.\r
2717 //\r
2718 IsItemFound = FALSE;\r
2719 ItemDataSize = (UINT32) DataSize;\r
2720 CertList = (EFI_SIGNATURE_LIST *) OldData;\r
2721 Offset = 0;\r
2722 GuidIndex = 0;\r
2723 while ((ItemDataSize > 0) && (ItemDataSize >= CertList->SignatureListSize)) {\r
2724 if (CompareGuid (&CertList->SignatureType, &gEfiCertRsa2048Guid) ||\r
2725 CompareGuid (&CertList->SignatureType, &gEfiCertX509Guid) ||\r
2726 CompareGuid (&CertList->SignatureType, &gEfiCertSha1Guid) ||\r
2727 CompareGuid (&CertList->SignatureType, &gEfiCertSha256Guid) ||\r
2728 CompareGuid (&CertList->SignatureType, &gEfiCertX509Sha256Guid) ||\r
2729 CompareGuid (&CertList->SignatureType, &gEfiCertX509Sha384Guid) ||\r
2730 CompareGuid (&CertList->SignatureType, &gEfiCertX509Sha512Guid)\r
2731 ) {\r
2732 //\r
2733 // Copy EFI_SIGNATURE_LIST header then calculate the signature count in this list.\r
2734 //\r
2735 CopyMem (Data + Offset, CertList, (sizeof(EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize));\r
2736 NewCertList = (EFI_SIGNATURE_LIST*) (Data + Offset);\r
2737 Offset += (sizeof(EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);\r
2738 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertList + sizeof (EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);\r
2739 CertCount = (CertList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - CertList->SignatureHeaderSize) / CertList->SignatureSize;\r
2740 for (Index = 0; Index < CertCount; Index++) {\r
2741 if (GuidIndex == DeleteIndex) {\r
2742 //\r
2743 // Find it! Skip it!\r
2744 //\r
2745 NewCertList->SignatureListSize -= CertList->SignatureSize;\r
2746 IsItemFound = TRUE;\r
2747 } else {\r
2748 //\r
2749 // This item doesn't match. Copy it to the Data buffer.\r
2750 //\r
2751 CopyMem (Data + Offset, (UINT8*)(Cert), CertList->SignatureSize);\r
2752 Offset += CertList->SignatureSize;\r
2753 }\r
2754 GuidIndex++;\r
2755 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) Cert + CertList->SignatureSize);\r
2756 }\r
2757 } else {\r
2758 //\r
2759 // This List doesn't match. Just copy it to the Data buffer.\r
2760 //\r
2761 CopyMem (Data + Offset, (UINT8*)(CertList), CertList->SignatureListSize);\r
2762 Offset += CertList->SignatureListSize;\r
2763 }\r
2764\r
2765 ItemDataSize -= CertList->SignatureListSize;\r
2766 CertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) CertList + CertList->SignatureListSize);\r
2767 }\r
2768\r
2769 if (!IsItemFound) {\r
2770 //\r
2771 // Doesn't find the signature Item!\r
2772 //\r
2773 Status = EFI_NOT_FOUND;\r
2774 goto ON_EXIT;\r
2775 }\r
2776\r
2777 //\r
2778 // Delete the EFI_SIGNATURE_LIST header if there is no signature in the list.\r
2779 //\r
2780 ItemDataSize = Offset;\r
2781 CertList = (EFI_SIGNATURE_LIST *) Data;\r
2782 Offset = 0;\r
2783 ZeroMem (OldData, ItemDataSize);\r
2784 while ((ItemDataSize > 0) && (ItemDataSize >= CertList->SignatureListSize)) {\r
2785 CertCount = (CertList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - CertList->SignatureHeaderSize) / CertList->SignatureSize;\r
2786 DEBUG ((DEBUG_INFO, " CertCount = %x\n", CertCount));\r
2787 if (CertCount != 0) {\r
2788 CopyMem (OldData + Offset, (UINT8*)(CertList), CertList->SignatureListSize);\r
2789 Offset += CertList->SignatureListSize;\r
2790 }\r
2791 ItemDataSize -= CertList->SignatureListSize;\r
2792 CertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) CertList + CertList->SignatureListSize);\r
2793 }\r
2794\r
2795 DataSize = Offset;\r
2796 if ((Attr & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) != 0) {\r
2797 Status = CreateTimeBasedPayload (&DataSize, &OldData);\r
2798 if (EFI_ERROR (Status)) {\r
2799 DEBUG ((EFI_D_ERROR, "Fail to create time-based data payload: %r", Status));\r
2800 goto ON_EXIT;\r
2801 }\r
2802 }\r
2803\r
2804 Status = gRT->SetVariable(\r
2805 VariableName,\r
2806 VendorGuid,\r
2807 Attr,\r
2808 DataSize,\r
2809 OldData\r
2810 );\r
2811 if (EFI_ERROR (Status)) {\r
2812 DEBUG ((DEBUG_ERROR, "Failed to set variable, Status = %r\n", Status));\r
2813 goto ON_EXIT;\r
2814 }\r
2815\r
2816ON_EXIT:\r
2817 if (Data != NULL) {\r
2818 FreePool(Data);\r
2819 }\r
2820\r
2821 if (OldData != NULL) {\r
2822 FreePool(OldData);\r
2823 }\r
2824\r
2825 return UpdateDeletePage (\r
2826 PrivateData,\r
2827 VariableName,\r
2828 VendorGuid,\r
2829 LabelNumber,\r
2830 FormId,\r
2831 QuestionIdBase\r
2832 );\r
2833}\r
2834\r
2835/**\r
2836 Perform secure boot mode transition from User Mode by setting AuditMode \r
2837 or DeployedMode variable.\r
2838\r
2839 @param[in] NewMode New secure boot mode.\r
2840\r
2841 @retval EFI_SUCCESS Secure Boot mode transition is successful.\r
2842**/\r
2843EFI_STATUS\r
2844TransitionFromUserMode(\r
2845 IN UINT8 NewMode\r
2846 )\r
2847{\r
2848 UINT8 Data;\r
2849 EFI_STATUS Status;\r
2850\r
2851 if (NewMode == SECURE_BOOT_MODE_AUDIT_MODE) {\r
2852 Data = 1;\r
2853 Status = gRT->SetVariable(\r
2854 EFI_AUDIT_MODE_NAME,\r
2855 &gEfiGlobalVariableGuid,\r
2856 EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,\r
2857 sizeof(UINT8),\r
2858 &Data\r
2859 );\r
2860 return Status;\r
2861 } else if (NewMode == SECURE_BOOT_MODE_DEPLOYED_MODE) {\r
2862 Data = 1;\r
2863 Status = gRT->SetVariable(\r
2864 EFI_DEPLOYED_MODE_NAME,\r
2865 &gEfiGlobalVariableGuid,\r
2866 EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,\r
2867 sizeof(UINT8),\r
2868 &Data\r
2869 );\r
2870 return Status;\r
2871 }\r
2872\r
2873 //\r
2874 // Other case do nothing here. May Goto enroll PK page.\r
2875 //\r
2876 return EFI_SUCCESS;\r
2877}\r
2878\r
2879/**\r
2880 Perform secure boot mode transition from Setup Mode by setting AuditMode \r
2881 variable.\r
2882\r
2883 @param[in] NewMode New secure boot mode.\r
2884\r
2885 @retval EFI_SUCCESS Secure Boot mode transition is successful.\r
2886**/\r
2887EFI_STATUS\r
2888TransitionFromSetupMode(\r
2889 IN UINT8 NewMode\r
2890 )\r
2891{\r
2892 UINT8 Data;\r
2893 EFI_STATUS Status;\r
2894\r
2895 Status = EFI_INVALID_PARAMETER;\r
2896\r
2897 if (NewMode == SECURE_BOOT_MODE_AUDIT_MODE) {\r
2898 Data = 1;\r
2899 Status = gRT->SetVariable(\r
2900 EFI_AUDIT_MODE_NAME,\r
2901 &gEfiGlobalVariableGuid,\r
2902 EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,\r
2903 sizeof(UINT8),\r
2904 &Data\r
2905 );\r
2906 return Status;\r
2907 }\r
2908\r
2909 //\r
2910 // Other case do nothing here. May Goto enroll PK page.\r
2911 //\r
2912 return EFI_SUCCESS;\r
2913}\r
2914\r
2915/**\r
2916 Perform secure boot mode transition from Audit Mode. Nothing is done here,\r
2917 should goto enroll PK page.\r
2918\r
2919 @param[in] NewMode New secure boot mode.\r
2920\r
2921 @retval EFI_SUCCESS Secure Boot mode transition is successful.\r
2922**/\r
2923EFI_STATUS\r
2924TransitionFromAuditMode(\r
2925 IN UINT8 NewMode\r
2926 )\r
2927{\r
2928 //\r
2929 // Other case do nothing here. Should Goto enroll PK page.\r
2930 //\r
2931 return EFI_SUCCESS;\r
2932}\r
2933\r
2934/**\r
2935 Perform secure boot mode transition from Deployed Mode by setting Deployed Mode\r
2936 variable to 0.\r
2937\r
2938 @param[in] NewMode New secure boot mode.\r
2939\r
2940 @retval EFI_SUCCESS Secure Boot mode transition is successful.\r
2941**/\r
2942EFI_STATUS\r
2943TransitionFromDeployedMode(\r
2944 IN UINT8 NewMode\r
2945 )\r
2946{\r
2947 UINT8 Data;\r
2948 EFI_STATUS Status;\r
2949\r
2950 //\r
2951 // Platform specific logic. when physical presence, Allow to set DeployedMode =:0\r
2952 // to switch back to UserMode\r
2953 //\r
2954 if (NewMode == SECURE_BOOT_MODE_USER_MODE) {\r
2955 Data = 0;\r
2956 Status = gRT->SetVariable(\r
2957 EFI_DEPLOYED_MODE_NAME,\r
2958 &gEfiGlobalVariableGuid,\r
2959 EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,\r
2960 sizeof(UINT8),\r
2961 &Data\r
2962 );\r
2963 DEBUG((EFI_D_INFO, "DeployedMode Status %x\n", Status));\r
2964 return Status;\r
2965 }\r
2966 return EFI_SUCCESS;\r
2967}\r
2968\r
2969/**\r
2970 Perform main secure boot mode transition.\r
2971\r
2972 @param[in] CurMode New secure boot mode.\r
2973 @param[in] NewMode New secure boot mode.\r
2974\r
2975 @retval EFI_SUCCESS Secure Boot mode transition is successful.\r
2976**/\r
2977EFI_STATUS\r
2978SecureBootModeTransition(\r
2979 IN UINT8 CurMode,\r
2980 IN UINT8 NewMode\r
2981 )\r
2982{\r
2983 EFI_STATUS Status;\r
2984\r
2985 //\r
2986 // Set platform to be customized mode to ensure platform specific mode switch sucess\r
2987 //\r
2988 Status = SetSecureBootMode(CUSTOM_SECURE_BOOT_MODE);\r
2989 if (EFI_ERROR (Status)) {\r
2990 return Status;\r
2991 }\r
2992\r
2993 //\r
2994 // SecureBootMode transition\r
2995 //\r
2996 switch (CurMode) {\r
2997 case SECURE_BOOT_MODE_USER_MODE:\r
2998 Status = TransitionFromUserMode(NewMode);\r
2999 break;\r
3000\r
3001 case SECURE_BOOT_MODE_SETUP_MODE:\r
3002 Status = TransitionFromSetupMode(NewMode);\r
3003 break;\r
3004\r
3005 case SECURE_BOOT_MODE_AUDIT_MODE:\r
3006 Status = TransitionFromAuditMode(NewMode);\r
3007 break;\r
3008\r
3009 case SECURE_BOOT_MODE_DEPLOYED_MODE:\r
3010 Status = TransitionFromDeployedMode(NewMode);\r
3011 break;\r
3012\r
3013 default:\r
3014 Status = EFI_INVALID_PARAMETER;\r
3015 ASSERT(FALSE);\r
3016 }\r
3017\r
3018 return Status;\r
3019}\r
3020\r
3021/**\r
3022 Get current secure boot mode by retrieve data from SetupMode/AuditMode/DeployedMode.\r
3023\r
3024 @param[out] SecureBootMode Current secure boot mode.\r
3025\r
3026**/\r
3027VOID\r
3028ExtractSecureBootModeFromVariable(\r
3029 OUT UINT8 *SecureBootMode\r
3030 )\r
3031{\r
3032 UINT8 *SetupMode;\r
3033 UINT8 *AuditMode;\r
3034 UINT8 *DeployedMode;\r
3035\r
3036 SetupMode = NULL;\r
3037 AuditMode = NULL;\r
3038 DeployedMode = NULL;\r
3039\r
3040 //\r
3041 // Get AuditMode/DeployedMode from variable\r
3042 //\r
3043 GetVariable2 (EFI_SETUP_MODE_NAME, &gEfiGlobalVariableGuid, (VOID**)&SetupMode, NULL);\r
3044 GetVariable2 (EFI_AUDIT_MODE_NAME, &gEfiGlobalVariableGuid, (VOID**)&AuditMode, NULL);\r
3045 GetVariable2 (EFI_DEPLOYED_MODE_NAME, &gEfiGlobalVariableGuid, (VOID**)&DeployedMode, NULL);\r
3046 if (SetupMode != NULL && AuditMode != NULL && DeployedMode != NULL) {\r
3047 if (*SetupMode == 0 && *AuditMode == 0 && *DeployedMode == 0) {\r
3048 //\r
3049 // User Mode\r
3050 //\r
3051 *SecureBootMode = SECURE_BOOT_MODE_USER_MODE;\r
3052 } else if (*SetupMode == 1 && *AuditMode == 0 && *DeployedMode == 0) {\r
3053 //\r
3054 // Setup Mode\r
3055 //\r
3056 *SecureBootMode = SECURE_BOOT_MODE_SETUP_MODE;\r
3057 } else if (*SetupMode == 1 && *AuditMode == 1 && *DeployedMode == 0) {\r
3058 //\r
3059 // Audit Mode\r
3060 //\r
3061 *SecureBootMode = SECURE_BOOT_MODE_AUDIT_MODE;\r
3062 } else if (*SetupMode == 0 && *AuditMode == 0 && *DeployedMode == 1) {\r
3063 //\r
3064 // Deployed Mode\r
3065 //\r
3066 *SecureBootMode = SECURE_BOOT_MODE_DEPLOYED_MODE;\r
3067 } else {\r
3068 ASSERT(FALSE);\r
3069 }\r
3070 }else {\r
3071 ASSERT(FALSE);\r
3072 }\r
3073\r
3074 if (SetupMode != NULL) {\r
3075 FreePool (SetupMode);\r
3076 }\r
3077 if (DeployedMode != NULL) {\r
3078 FreePool (DeployedMode);\r
3079 }\r
3080 if (AuditMode != NULL) {\r
3081 FreePool (AuditMode);\r
3082 }\r
3083}\r
3084\r
3085/**\r
3086\r
3087 Update SecureBoot strings based on new Secure Boot Mode State. String includes STR_SECURE_BOOT_STATE_CONTENT\r
3088 and STR_CUR_SECURE_BOOT_MODE_CONTENT.\r
3089\r
3090 @param[in] PrivateData Module's private data.\r
3091\r
3092 @return EFI_SUCCESS Update secure boot strings successfully.\r
3093 @return other Fail to update secure boot strings.\r
3094\r
3095**/\r
3096EFI_STATUS\r
3097UpdateSecureBootString(\r
3098 IN SECUREBOOT_CONFIG_PRIVATE_DATA *Private\r
3099 )\r
3100{\r
3101 UINT8 CurSecureBootMode;\r
3102 UINT8 *SecureBoot;\r
3103\r
3104 SecureBoot = NULL;\r
3105\r
3106 //\r
3107 // Get current secure boot state.\r
3108 //\r
3109 GetVariable2 (EFI_SECURE_BOOT_MODE_NAME, &gEfiGlobalVariableGuid, (VOID**)&SecureBoot, NULL);\r
3110 if (SecureBoot == NULL) {\r
3111 return EFI_NOT_FOUND;\r
3112 }\r
3113\r
3114 if (*SecureBoot == SECURE_BOOT_MODE_ENABLE) {\r
3115 HiiSetString (Private->HiiHandle, STRING_TOKEN (STR_SECURE_BOOT_STATE_CONTENT), L"Enabled", NULL);\r
3116 } else {\r
3117 HiiSetString (Private->HiiHandle, STRING_TOKEN (STR_SECURE_BOOT_STATE_CONTENT), L"Disabled", NULL);\r
3118 }\r
3119 //\r
3120 // Get current secure boot mode.\r
3121 //\r
3122 ExtractSecureBootModeFromVariable(&CurSecureBootMode);\r
3123 \r
3124 if (CurSecureBootMode == SECURE_BOOT_MODE_USER_MODE) {\r
3125 HiiSetString (Private->HiiHandle, STRING_TOKEN (STR_CUR_SECURE_BOOT_MODE_CONTENT), L"UserMode", NULL);\r
3126 } else if (CurSecureBootMode == SECURE_BOOT_MODE_SETUP_MODE) {\r
3127 HiiSetString (Private->HiiHandle, STRING_TOKEN (STR_CUR_SECURE_BOOT_MODE_CONTENT), L"SetupMode", NULL);\r
3128 } else if (CurSecureBootMode == SECURE_BOOT_MODE_AUDIT_MODE) {\r
3129 HiiSetString (Private->HiiHandle, STRING_TOKEN (STR_CUR_SECURE_BOOT_MODE_CONTENT), L"AuditMode", NULL);\r
3130 } else if (CurSecureBootMode == SECURE_BOOT_MODE_DEPLOYED_MODE) {\r
3131 HiiSetString (Private->HiiHandle, STRING_TOKEN (STR_CUR_SECURE_BOOT_MODE_CONTENT), L"DeployedMode", NULL);\r
3132 }\r
3133\r
3134 FreePool(SecureBoot);\r
3135\r
3136 return EFI_SUCCESS;\r
3137}\r
3138\r
3139/**\r
3140 This function extracts configuration from variable.\r
3141\r
3142 @param[in, out] ConfigData Point to SecureBoot configuration private data.\r
3143\r
3144**/\r
3145VOID\r
3146SecureBootExtractConfigFromVariable (\r
3147 IN OUT SECUREBOOT_CONFIGURATION *ConfigData\r
3148 )\r
3149{\r
3150 UINT8 *SecureBootEnable;\r
3151 UINT8 *SecureBootMode;\r
3152 EFI_TIME CurrTime;\r
3153\r
3154 SecureBootEnable = NULL;\r
3155 SecureBootMode = NULL;\r
3156\r
3157 //\r
3158 // Initilize the Date and Time using system time.\r
3159 //\r
3160 ConfigData->CertificateFormat = HASHALG_RAW;\r
3161 ConfigData->AlwaysRevocation = TRUE;\r
3162 gRT->GetTime (&CurrTime, NULL);\r
3163 ConfigData->RevocationDate.Year = CurrTime.Year;\r
3164 ConfigData->RevocationDate.Month = CurrTime.Month;\r
3165 ConfigData->RevocationDate.Day = CurrTime.Day;\r
3166 ConfigData->RevocationTime.Hour = CurrTime.Hour;\r
3167 ConfigData->RevocationTime.Minute = CurrTime.Minute;\r
3168 ConfigData->RevocationTime.Second = 0;\r
3169\r
3170\r
3171 //\r
3172 // If it is Physical Presence User, set the PhysicalPresent to true.\r
3173 //\r
3174 if (UserPhysicalPresent()) {\r
3175 ConfigData->PhysicalPresent = TRUE;\r
3176 } else {\r
3177 ConfigData->PhysicalPresent = FALSE;\r
3178 }\r
3179\r
3180 //\r
3181 // Get the SecureBootMode from CustomMode variable.\r
3182 //\r
3183 GetVariable2 (EFI_CUSTOM_MODE_NAME, &gEfiCustomModeEnableGuid, (VOID**)&SecureBootMode, NULL);\r
3184 if (SecureBootMode == NULL) {\r
3185 ConfigData->SecureBootMode = STANDARD_SECURE_BOOT_MODE;\r
3186 } else {\r
3187 ConfigData->SecureBootMode = *(SecureBootMode);\r
3188 }\r
3189\r
3190 //\r
3191 // Extact current Secure Boot Mode\r
3192 //\r
3193 ExtractSecureBootModeFromVariable(&ConfigData->CurSecureBootMode);\r
3194\r
3195 //\r
3196 // If there is no PK then the Delete Pk button will be gray.\r
3197 //\r
3198 if (ConfigData->CurSecureBootMode == SECURE_BOOT_MODE_SETUP_MODE || ConfigData->CurSecureBootMode == SECURE_BOOT_MODE_AUDIT_MODE) {\r
3199 ConfigData->HasPk = FALSE;\r
3200 } else {\r
3201 ConfigData->HasPk = TRUE;\r
3202 }\r
3203\r
3204 //\r
3205 // Check SecureBootEnable & Pk status, fix the inconsistence. \r
3206 // If the SecureBootEnable Variable doesn't exist, hide the SecureBoot Enable/Disable\r
3207 // Checkbox.\r
3208 //\r
3209 ConfigData->AttemptSecureBoot = FALSE;\r
3210 GetVariable2 (EFI_SECURE_BOOT_ENABLE_NAME, &gEfiSecureBootEnableDisableGuid, (VOID**)&SecureBootEnable, NULL); \r
3211\r
3212 //\r
3213 // Fix Pk, SecureBootEnable inconsistence\r
3214 //\r
3215 if (ConfigData->CurSecureBootMode == SECURE_BOOT_MODE_USER_MODE || ConfigData->CurSecureBootMode == SECURE_BOOT_MODE_DEPLOYED_MODE) {\r
3216 ConfigData->HideSecureBoot = FALSE;\r
3217 if ((SecureBootEnable != NULL) && (*SecureBootEnable == SECURE_BOOT_ENABLE)) {\r
3218 ConfigData->AttemptSecureBoot = TRUE;\r
3219 }\r
3220 } else {\r
3221 ConfigData->HideSecureBoot = TRUE;\r
3222 }\r
3223\r
3224 if (SecureBootEnable != NULL) {\r
3225 FreePool (SecureBootEnable);\r
3226 }\r
3227\r
3228 if (SecureBootMode != NULL) {\r
3229 FreePool (SecureBootMode);\r
3230 }\r
3231}\r
3232\r
3233/**\r
3234 This function allows a caller to extract the current configuration for one\r
3235 or more named elements from the target driver.\r
3236\r
3237 @param[in] This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.\r
3238 @param[in] Request A null-terminated Unicode string in\r
3239 <ConfigRequest> format.\r
3240 @param[out] Progress On return, points to a character in the Request\r
3241 string. Points to the string's null terminator if\r
3242 request was successful. Points to the most recent\r
3243 '&' before the first failing name/value pair (or\r
3244 the beginning of the string if the failure is in\r
3245 the first name/value pair) if the request was not\r
3246 successful.\r
3247 @param[out] Results A null-terminated Unicode string in\r
3248 <ConfigAltResp> format which has all values filled\r
3249 in for the names in the Request string. String to\r
3250 be allocated by the called function.\r
3251\r
3252 @retval EFI_SUCCESS The Results is filled with the requested values.\r
3253 @retval EFI_OUT_OF_RESOURCES Not enough memory to store the results.\r
3254 @retval EFI_INVALID_PARAMETER Request is illegal syntax, or unknown name.\r
3255 @retval EFI_NOT_FOUND Routing data doesn't match any storage in this\r
3256 driver.\r
3257\r
3258**/\r
3259EFI_STATUS\r
3260EFIAPI\r
3261SecureBootExtractConfig (\r
3262 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,\r
3263 IN CONST EFI_STRING Request,\r
3264 OUT EFI_STRING *Progress,\r
3265 OUT EFI_STRING *Results\r
3266 )\r
3267{\r
3268 EFI_STATUS Status;\r
3269 UINTN BufferSize;\r
3270 UINTN Size;\r
3271 SECUREBOOT_CONFIGURATION Configuration;\r
3272 EFI_STRING ConfigRequest;\r
3273 EFI_STRING ConfigRequestHdr;\r
3274 SECUREBOOT_CONFIG_PRIVATE_DATA *PrivateData;\r
3275 BOOLEAN AllocatedRequest;\r
3276\r
3277 if (Progress == NULL || Results == NULL) {\r
3278 return EFI_INVALID_PARAMETER;\r
3279 }\r
3280\r
3281 AllocatedRequest = FALSE;\r
3282 ConfigRequestHdr = NULL;\r
3283 ConfigRequest = NULL;\r
3284 Size = 0;\r
3285\r
3286 ZeroMem (&Configuration, sizeof (Configuration));\r
3287 PrivateData = SECUREBOOT_CONFIG_PRIVATE_FROM_THIS (This);\r
3288 *Progress = Request;\r
3289\r
3290 if ((Request != NULL) && !HiiIsConfigHdrMatch (Request, &gSecureBootConfigFormSetGuid, mSecureBootStorageName)) {\r
3291 return EFI_NOT_FOUND;\r
3292 }\r
3293\r
3294 //\r
3295 // Get Configuration from Variable.\r
3296 //\r
3297 SecureBootExtractConfigFromVariable (&Configuration);\r
3298\r
3299 BufferSize = sizeof (SECUREBOOT_CONFIGURATION);\r
3300 ConfigRequest = Request;\r
3301 if ((Request == NULL) || (StrStr (Request, L"OFFSET") == NULL)) {\r
3302 //\r
3303 // Request is set to NULL or OFFSET is NULL, construct full request string.\r
3304 //\r
3305 // Allocate and fill a buffer large enough to hold the <ConfigHdr> template\r
3306 // followed by "&OFFSET=0&WIDTH=WWWWWWWWWWWWWWWW" followed by a Null-terminator\r
3307 //\r
3308 ConfigRequestHdr = HiiConstructConfigHdr (&gSecureBootConfigFormSetGuid, mSecureBootStorageName, PrivateData->DriverHandle);\r
3309 Size = (StrLen (ConfigRequestHdr) + 32 + 1) * sizeof (CHAR16);\r
3310 ConfigRequest = AllocateZeroPool (Size);\r
3311 ASSERT (ConfigRequest != NULL);\r
3312 AllocatedRequest = TRUE;\r
3313 UnicodeSPrint (ConfigRequest, Size, L"%s&OFFSET=0&WIDTH=%016LX", ConfigRequestHdr, (UINT64)BufferSize);\r
3314 FreePool (ConfigRequestHdr);\r
3315 ConfigRequestHdr = NULL;\r
3316 }\r
3317\r
3318 Status = gHiiConfigRouting->BlockToConfig (\r
3319 gHiiConfigRouting,\r
3320 ConfigRequest,\r
3321 (UINT8 *) &Configuration,\r
3322 BufferSize,\r
3323 Results,\r
3324 Progress\r
3325 );\r
3326\r
3327 //\r
3328 // Free the allocated config request string.\r
3329 //\r
3330 if (AllocatedRequest) {\r
3331 FreePool (ConfigRequest);\r
3332 }\r
3333\r
3334 //\r
3335 // Set Progress string to the original request string.\r
3336 //\r
3337 if (Request == NULL) {\r
3338 *Progress = NULL;\r
3339 } else if (StrStr (Request, L"OFFSET") == NULL) {\r
3340 *Progress = Request + StrLen (Request);\r
3341 }\r
3342\r
3343 return Status;\r
3344}\r
3345\r
3346/**\r
3347 This function processes the results of changes in configuration.\r
3348\r
3349 @param[in] This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.\r
3350 @param[in] Configuration A null-terminated Unicode string in <ConfigResp>\r
3351 format.\r
3352 @param[out] Progress A pointer to a string filled in with the offset of\r
3353 the most recent '&' before the first failing\r
3354 name/value pair (or the beginning of the string if\r
3355 the failure is in the first name/value pair) or\r
3356 the terminating NULL if all was successful.\r
3357\r
3358 @retval EFI_SUCCESS The Results is processed successfully.\r
3359 @retval EFI_INVALID_PARAMETER Configuration is NULL.\r
3360 @retval EFI_NOT_FOUND Routing data doesn't match any storage in this\r
3361 driver.\r
3362\r
3363**/\r
3364EFI_STATUS\r
3365EFIAPI\r
3366SecureBootRouteConfig (\r
3367 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,\r
3368 IN CONST EFI_STRING Configuration,\r
3369 OUT EFI_STRING *Progress\r
3370 )\r
3371{\r
3372 SECUREBOOT_CONFIGURATION IfrNvData;\r
3373 UINTN BufferSize;\r
3374 EFI_STATUS Status;\r
3375\r
3376 if (Configuration == NULL || Progress == NULL) {\r
3377 return EFI_INVALID_PARAMETER;\r
3378 }\r
3379\r
3380 *Progress = Configuration;\r
3381 if (!HiiIsConfigHdrMatch (Configuration, &gSecureBootConfigFormSetGuid, mSecureBootStorageName)) {\r
3382 return EFI_NOT_FOUND;\r
3383 }\r
3384\r
3385 //\r
3386 // Get Configuration from Variable.\r
3387 //\r
3388 SecureBootExtractConfigFromVariable (&IfrNvData);\r
3389\r
3390 //\r
3391 // Map the Configuration to the configuration block.\r
3392 //\r
3393 BufferSize = sizeof (SECUREBOOT_CONFIGURATION);\r
3394 Status = gHiiConfigRouting->ConfigToBlock (\r
3395 gHiiConfigRouting,\r
3396 Configuration,\r
3397 (UINT8 *)&IfrNvData,\r
3398 &BufferSize,\r
3399 Progress\r
3400 );\r
3401 if (EFI_ERROR (Status)) {\r
3402 return Status;\r
3403 }\r
3404\r
3405 //\r
3406 // Store Buffer Storage back to EFI variable if needed\r
3407 //\r
3408 if (!IfrNvData.HideSecureBoot) {\r
3409 Status = SaveSecureBootVariable (IfrNvData.AttemptSecureBoot);\r
3410 if (EFI_ERROR (Status)) {\r
3411 return Status;\r
3412 }\r
3413 }\r
3414\r
3415 *Progress = Configuration + StrLen (Configuration);\r
3416 return EFI_SUCCESS;\r
3417}\r
3418\r
3419/**\r
3420 This function is called to provide results data to the driver.\r
3421\r
3422 @param[in] This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.\r
3423 @param[in] Action Specifies the type of action taken by the browser.\r
3424 @param[in] QuestionId A unique value which is sent to the original\r
3425 exporting driver so that it can identify the type\r
3426 of data to expect.\r
3427 @param[in] Type The type of value for the question.\r
3428 @param[in] Value A pointer to the data being sent to the original\r
3429 exporting driver.\r
3430 @param[out] ActionRequest On return, points to the action requested by the\r
3431 callback function.\r
3432\r
3433 @retval EFI_SUCCESS The callback successfully handled the action.\r
3434 @retval EFI_OUT_OF_RESOURCES Not enough storage is available to hold the\r
3435 variable and its data.\r
3436 @retval EFI_DEVICE_ERROR The variable could not be saved.\r
3437 @retval EFI_UNSUPPORTED The specified Action is not supported by the\r
3438 callback.\r
3439\r
3440**/\r
3441EFI_STATUS\r
3442EFIAPI\r
3443SecureBootCallback (\r
3444 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,\r
3445 IN EFI_BROWSER_ACTION Action,\r
3446 IN EFI_QUESTION_ID QuestionId,\r
3447 IN UINT8 Type,\r
3448 IN EFI_IFR_TYPE_VALUE *Value,\r
3449 OUT EFI_BROWSER_ACTION_REQUEST *ActionRequest\r
3450 )\r
3451{\r
3452 EFI_INPUT_KEY Key;\r
3453 EFI_STATUS Status;\r
3454 SECUREBOOT_CONFIG_PRIVATE_DATA *Private;\r
3455 UINTN BufferSize;\r
3456 SECUREBOOT_CONFIGURATION *IfrNvData;\r
3457 UINT16 LabelId;\r
3458 UINT8 *SecureBootEnable;\r
3459 UINT8 *Pk;\r
3460 UINT8 *SecureBootMode;\r
3461 CHAR16 PromptString[100];\r
3462 UINT8 CurSecureBootMode;\r
3463 EFI_DEVICE_PATH_PROTOCOL *File;\r
3464\r
3465 Status = EFI_SUCCESS;\r
3466 SecureBootEnable = NULL;\r
3467 SecureBootMode = NULL;\r
3468 File = NULL;\r
3469\r
3470 if ((This == NULL) || (Value == NULL) || (ActionRequest == NULL)) {\r
3471 return EFI_INVALID_PARAMETER;\r
3472 }\r
3473 Private = SECUREBOOT_CONFIG_PRIVATE_FROM_THIS (This);\r
3474\r
3475 gSecureBootPrivateData = Private;\r
3476\r
3477 //\r
3478 // Retrieve uncommitted data from Browser\r
3479 //\r
3480 BufferSize = sizeof (SECUREBOOT_CONFIGURATION);\r
3481 IfrNvData = AllocateZeroPool (BufferSize);\r
3482 if (IfrNvData == NULL) {\r
3483 return EFI_OUT_OF_RESOURCES;\r
3484 }\r
3485\r
3486 HiiGetBrowserData (&gSecureBootConfigFormSetGuid, mSecureBootStorageName, BufferSize, (UINT8 *) IfrNvData);\r
3487\r
3488 if (Action == EFI_BROWSER_ACTION_FORM_OPEN) {\r
3489 if (QuestionId == KEY_SECURE_BOOT_MODE) {\r
3490 //\r
3491 // Update secure boot strings when opening this form\r
3492 //\r
3493 Status = UpdateSecureBootString(Private);\r
3494 SecureBootExtractConfigFromVariable (IfrNvData);\r
3495 mIsEnterSecureBootForm = TRUE;\r
3496 } else if (QuestionId == KEY_TRANS_SECURE_BOOT_MODE){\r
3497 //\r
3498 // Secure Boot Policy variable changes after transition. Re-sync CurSecureBootMode\r
3499 //\r
3500 ExtractSecureBootModeFromVariable(&IfrNvData->CurSecureBootMode);\r
3501 mIsSelectedSecureBootModeForm = TRUE;\r
3502 mIsSecureBootModeChanged = FALSE;\r
3503 }\r
3504 goto EXIT;\r
3505 }\r
3506\r
3507 if (Action == EFI_BROWSER_ACTION_RETRIEVE) {\r
3508 Status = EFI_UNSUPPORTED;\r
3509 if (QuestionId == KEY_SECURE_BOOT_MODE) {\r
3510 if (mIsEnterSecureBootForm) {\r
3511 Value->u8 = SECURE_BOOT_MODE_STANDARD;\r
3512 Status = EFI_SUCCESS;\r
3513 }\r
3514 } else if (QuestionId == KEY_TRANS_SECURE_BOOT_MODE) {\r
3515 if (mIsSelectedSecureBootModeForm) {\r
3516 Value->u8 = IfrNvData->CurSecureBootMode;\r
3517 Status = EFI_SUCCESS;\r
3518 }\r
3519 }\r
3520 goto EXIT;\r
3521 }\r
3522\r
3523 if ((Action != EFI_BROWSER_ACTION_CHANGED) &&\r
3524 (Action != EFI_BROWSER_ACTION_CHANGING) &&\r
3525 (Action != EFI_BROWSER_ACTION_FORM_CLOSE) &&\r
3526 (Action != EFI_BROWSER_ACTION_DEFAULT_STANDARD)) {\r
3527 Status = EFI_UNSUPPORTED;\r
3528 goto EXIT;\r
3529 }\r
3530\r
3531 if (Action == EFI_BROWSER_ACTION_CHANGING) {\r
3532\r
3533 switch (QuestionId) {\r
3534 case KEY_SECURE_BOOT_ENABLE:\r
3535 GetVariable2 (EFI_SECURE_BOOT_ENABLE_NAME, &gEfiSecureBootEnableDisableGuid, (VOID**)&SecureBootEnable, NULL);\r
3536 if (NULL != SecureBootEnable) {\r
3537 FreePool (SecureBootEnable);\r
3538 if (EFI_ERROR (SaveSecureBootVariable (Value->u8))) {\r
3539 CreatePopUp (\r
3540 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
3541 &Key,\r
3542 L"Only Physical Presence User could disable secure boot!",\r
3543 NULL\r
3544 );\r
3545 Status = EFI_UNSUPPORTED;\r
3546 } else {\r
3547 CreatePopUp (\r
3548 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
3549 &Key,\r
3550 L"Configuration changed, please reset the platform to take effect!",\r
3551 NULL\r
3552 );\r
3553 }\r
3554 }\r
3555 break;\r
3556\r
3557 case KEY_SECURE_BOOT_KEK_OPTION:\r
3558 case KEY_SECURE_BOOT_DB_OPTION:\r
3559 case KEY_SECURE_BOOT_DBX_OPTION:\r
3560 case KEY_SECURE_BOOT_DBT_OPTION:\r
3561 //\r
3562 // Clear Signature GUID.\r
3563 //\r
3564 ZeroMem (IfrNvData->SignatureGuid, sizeof (IfrNvData->SignatureGuid));\r
3565 if (Private->SignatureGUID == NULL) {\r
3566 Private->SignatureGUID = (EFI_GUID *) AllocateZeroPool (sizeof (EFI_GUID));\r
3567 if (Private->SignatureGUID == NULL) {\r
3568 return EFI_OUT_OF_RESOURCES;\r
3569 }\r
3570 }\r
3571\r
3572 if (QuestionId == KEY_SECURE_BOOT_DB_OPTION) {\r
3573 LabelId = SECUREBOOT_ENROLL_SIGNATURE_TO_DB;\r
3574 } else if (QuestionId == KEY_SECURE_BOOT_DBX_OPTION) {\r
3575 LabelId = SECUREBOOT_ENROLL_SIGNATURE_TO_DBX;\r
3576 } else if (QuestionId == KEY_SECURE_BOOT_DBT_OPTION) {\r
3577 LabelId = SECUREBOOT_ENROLL_SIGNATURE_TO_DBT;\r
3578 } else {\r
3579 LabelId = FORMID_ENROLL_KEK_FORM;\r
3580 }\r
3581\r
3582 //\r
3583 // Refresh selected file.\r
3584 //\r
3585 CleanUpPage (LabelId, Private);\r
3586 break;\r
3587 case KEY_SECURE_BOOT_PK_OPTION:\r
3588 LabelId = FORMID_ENROLL_PK_FORM;\r
3589 //\r
3590 // Refresh selected file.\r
3591 //\r
3592 CleanUpPage (LabelId, Private);\r
3593 break;\r
3594\r
3595 case FORMID_ENROLL_PK_FORM:\r
3596 ChooseFile (NULL, NULL, UpdatePKFromFile, &File);\r
3597 break;\r
3598\r
3599 case FORMID_ENROLL_KEK_FORM:\r
3600 ChooseFile (NULL, NULL, UpdateKEKFromFile, &File);\r
3601 break;\r
3602\r
3603 case SECUREBOOT_ENROLL_SIGNATURE_TO_DB:\r
3604 ChooseFile (NULL, NULL, UpdateDBFromFile, &File);\r
3605 break;\r
3606\r
3607 case SECUREBOOT_ENROLL_SIGNATURE_TO_DBX:\r
3608 ChooseFile (NULL, NULL, UpdateDBXFromFile, &File);\r
3609 break;\r
3610\r
3611 case SECUREBOOT_ENROLL_SIGNATURE_TO_DBT:\r
3612 ChooseFile (NULL, NULL, UpdateDBTFromFile, &File);\r
3613 break;\r
3614\r
3615 case KEY_SECURE_BOOT_DELETE_PK:\r
3616 if (Value->u8) {\r
3617 CreatePopUp (\r
3618 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
3619 &Key,\r
3620 L"Are you sure you want to delete PK? Secure boot will be disabled!",\r
3621 L"Press 'Y' to delete PK and exit, 'N' to discard change and return",\r
3622 NULL\r
3623 );\r
3624 if (Key.UnicodeChar == 'y' || Key.UnicodeChar == 'Y') {\r
3625 Status = DeletePlatformKey ();\r
3626 if (EFI_ERROR (Status)) {\r
3627 CreatePopUp (\r
3628 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
3629 &Key,\r
3630 L"Only Physical Presence User could delete PK in custom mode!",\r
3631 NULL\r
3632 );\r
3633 }\r
3634 }\r
3635 }\r
3636 break;\r
3637\r
3638 case KEY_DELETE_KEK:\r
3639 UpdateDeletePage (\r
3640 Private,\r
3641 EFI_KEY_EXCHANGE_KEY_NAME,\r
3642 &gEfiGlobalVariableGuid,\r
3643 LABEL_KEK_DELETE,\r
3644 FORMID_DELETE_KEK_FORM,\r
3645 OPTION_DEL_KEK_QUESTION_ID\r
3646 );\r
3647 break;\r
3648\r
3649 case SECUREBOOT_DELETE_SIGNATURE_FROM_DB:\r
3650 UpdateDeletePage (\r
3651 Private,\r
3652 EFI_IMAGE_SECURITY_DATABASE,\r
3653 &gEfiImageSecurityDatabaseGuid,\r
3654 LABEL_DB_DELETE,\r
3655 SECUREBOOT_DELETE_SIGNATURE_FROM_DB,\r
3656 OPTION_DEL_DB_QUESTION_ID\r
3657 );\r
3658 break;\r
3659\r
3660 case SECUREBOOT_DELETE_SIGNATURE_FROM_DBX:\r
3661 UpdateDeletePage (\r
3662 Private,\r
3663 EFI_IMAGE_SECURITY_DATABASE1,\r
3664 &gEfiImageSecurityDatabaseGuid,\r
3665 LABEL_DBX_DELETE,\r
3666 SECUREBOOT_DELETE_SIGNATURE_FROM_DBX,\r
3667 OPTION_DEL_DBX_QUESTION_ID\r
3668 );\r
3669\r
3670 break;\r
3671\r
3672 case SECUREBOOT_DELETE_SIGNATURE_FROM_DBT:\r
3673 UpdateDeletePage (\r
3674 Private,\r
3675 EFI_IMAGE_SECURITY_DATABASE2,\r
3676 &gEfiImageSecurityDatabaseGuid,\r
3677 LABEL_DBT_DELETE,\r
3678 SECUREBOOT_DELETE_SIGNATURE_FROM_DBT,\r
3679 OPTION_DEL_DBT_QUESTION_ID\r
3680 );\r
3681\r
3682 break;\r
3683\r
3684 case KEY_VALUE_SAVE_AND_EXIT_KEK:\r
3685 Status = EnrollKeyExchangeKey (Private);\r
3686 if (EFI_ERROR (Status)) {\r
3687 CreatePopUp (\r
3688 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
3689 &Key,\r
3690 L"ERROR: Unsupported file type!",\r
3691 L"Only supports DER-encoded X509 certificate",\r
3692 NULL\r
3693 );\r
3694 }\r
3695 break;\r
3696\r
3697 case KEY_VALUE_SAVE_AND_EXIT_DB:\r
3698 Status = EnrollSignatureDatabase (Private, EFI_IMAGE_SECURITY_DATABASE);\r
3699 if (EFI_ERROR (Status)) {\r
3700 CreatePopUp (\r
3701 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
3702 &Key,\r
3703 L"ERROR: Unsupported file type!",\r
3704 L"Only supports DER-encoded X509 certificate and executable EFI image",\r
3705 NULL\r
3706 );\r
3707 }\r
3708 break;\r
3709\r
3710 case KEY_VALUE_SAVE_AND_EXIT_DBX:\r
3711 if (IsX509CertInDbx (Private, EFI_IMAGE_SECURITY_DATABASE1)) {\r
3712 CreatePopUp (\r
3713 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
3714 &Key,\r
3715 L"Enrollment failed! Same certificate had already been in the dbx!",\r
3716 NULL\r
3717 );\r
3718 break;\r
3719 }\r
3720\r
3721 if ((IfrNvData != NULL) && (IfrNvData->CertificateFormat < HASHALG_MAX)) {\r
3722 Status = EnrollX509HashtoSigDB (\r
3723 Private,\r
3724 IfrNvData->CertificateFormat,\r
3725 &IfrNvData->RevocationDate,\r
3726 &IfrNvData->RevocationTime,\r
3727 IfrNvData->AlwaysRevocation\r
3728 );\r
3729 } else {\r
3730 Status = EnrollSignatureDatabase (Private, EFI_IMAGE_SECURITY_DATABASE1);\r
3731 }\r
3732 if (EFI_ERROR (Status)) {\r
3733 CreatePopUp (\r
3734 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
3735 &Key,\r
3736 L"ERROR: Unsupported file type!",\r
3737 L"Only supports DER-encoded X509 certificate and executable EFI image",\r
3738 NULL\r
3739 );\r
3740 }\r
3741 break;\r
3742\r
3743 case KEY_VALUE_SAVE_AND_EXIT_DBT:\r
3744 Status = EnrollSignatureDatabase (Private, EFI_IMAGE_SECURITY_DATABASE2);\r
3745 if (EFI_ERROR (Status)) {\r
3746 CreatePopUp (\r
3747 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
3748 &Key,\r
3749 L"ERROR: Unsupported file type!",\r
3750 L"Only supports DER-encoded X509 certificate.",\r
3751 NULL\r
3752 );\r
3753 }\r
3754 break;\r
3755 case KEY_VALUE_SAVE_AND_EXIT_PK:\r
3756 Status = EnrollPlatformKey (Private);\r
3757 if (EFI_ERROR (Status)) {\r
3758 UnicodeSPrint (\r
3759 PromptString,\r
3760 sizeof (PromptString),\r
3761 L"Only DER encoded certificate file (%s) is supported.",\r
3762 mSupportX509Suffix\r
3763 );\r
3764 CreatePopUp (\r
3765 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
3766 &Key,\r
3767 L"ERROR: Unsupported file type!",\r
3768 PromptString,\r
3769 NULL\r
3770 );\r
3771 }\r
3772 break;\r
3773 case KEY_TRANS_SECURE_BOOT_MODE:\r
3774 //\r
3775 // Pop up to alert user want to change secure boot mode \r
3776 //\r
3777 if ((IfrNvData->CurSecureBootMode == SECURE_BOOT_MODE_USER_MODE && \r
3778 (Value->u8 == SECURE_BOOT_MODE_AUDIT_MODE || Value->u8 == SECURE_BOOT_MODE_DEPLOYED_MODE))\r
3779 ||(IfrNvData->CurSecureBootMode == SECURE_BOOT_MODE_SETUP_MODE && \r
3780 Value->u8 == SECURE_BOOT_MODE_AUDIT_MODE)\r
3781 ||(IfrNvData->CurSecureBootMode == SECURE_BOOT_MODE_DEPLOYED_MODE && \r
3782 Value->u8 == SECURE_BOOT_MODE_USER_MODE && IfrNvData->PhysicalPresent == 1)){\r
3783 CreatePopUp (\r
3784 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
3785 &Key,\r
3786 L"Are you sure you want to switch secure boot mode?",\r
3787 L"Press 'Y' to switch secure boot mode, 'N' to discard change and return",\r
3788 NULL\r
3789 );\r
3790 if (Key.UnicodeChar != 'y' && Key.UnicodeChar != 'Y') {\r
3791 //\r
3792 // If not 'Y'/''y' restore to defualt secure boot mode\r
3793 //\r
3794 Value->u8 = IfrNvData->CurSecureBootMode;\r
3795 goto EXIT;\r
3796 }\r
3797 } else if ((IfrNvData->CurSecureBootMode == SECURE_BOOT_MODE_SETUP_MODE && Value->u8 == SECURE_BOOT_MODE_USER_MODE)\r
3798 ||(IfrNvData->CurSecureBootMode == SECURE_BOOT_MODE_USER_MODE && Value->u8 == SECURE_BOOT_MODE_SETUP_MODE)\r
3799 ||(IfrNvData->CurSecureBootMode == SECURE_BOOT_MODE_AUDIT_MODE && Value->u8 == SECURE_BOOT_MODE_DEPLOYED_MODE)\r
3800 ||(IfrNvData->CurSecureBootMode == SECURE_BOOT_MODE_DEPLOYED_MODE && Value->u8 == SECURE_BOOT_MODE_SETUP_MODE)) {\r
3801 CreatePopUp (\r
3802 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,\r
3803 &Key,\r
3804 L"Secure boot mode transition requires PK change",\r
3805 L"Please go to link below to update PK",\r
3806 NULL\r
3807 );\r
3808 } else {\r
3809 Status = EFI_INVALID_PARAMETER;\r
3810 goto EXIT;\r
3811 }\r
3812\r
3813 Status = SecureBootModeTransition(IfrNvData->CurSecureBootMode, Value->u8);\r
3814 //\r
3815 // Secure Boot Policy variable may change after transition. Re-sync CurSecureBootMode\r
3816 //\r
3817 ExtractSecureBootModeFromVariable(&CurSecureBootMode);\r
3818 if (IfrNvData->CurSecureBootMode != CurSecureBootMode) {\r
3819 IfrNvData->CurSecureBootMode = CurSecureBootMode;\r
3820 mIsSecureBootModeChanged = TRUE;\r
3821 }\r
3822 break;\r
3823\r
3824 default:\r
3825 if ((QuestionId >= OPTION_DEL_KEK_QUESTION_ID) &&\r
3826 (QuestionId < (OPTION_DEL_KEK_QUESTION_ID + OPTION_CONFIG_RANGE))) {\r
3827 DeleteKeyExchangeKey (Private, QuestionId);\r
3828 } else if ((QuestionId >= OPTION_DEL_DB_QUESTION_ID) &&\r
3829 (QuestionId < (OPTION_DEL_DB_QUESTION_ID + OPTION_CONFIG_RANGE))) {\r
3830 DeleteSignature (\r
3831 Private,\r
3832 EFI_IMAGE_SECURITY_DATABASE,\r
3833 &gEfiImageSecurityDatabaseGuid,\r
3834 LABEL_DB_DELETE,\r
3835 SECUREBOOT_DELETE_SIGNATURE_FROM_DB,\r
3836 OPTION_DEL_DB_QUESTION_ID,\r
3837 QuestionId - OPTION_DEL_DB_QUESTION_ID\r
3838 );\r
3839 } else if ((QuestionId >= OPTION_DEL_DBX_QUESTION_ID) &&\r
3840 (QuestionId < (OPTION_DEL_DBX_QUESTION_ID + OPTION_CONFIG_RANGE))) {\r
3841 DeleteSignature (\r
3842 Private,\r
3843 EFI_IMAGE_SECURITY_DATABASE1,\r
3844 &gEfiImageSecurityDatabaseGuid,\r
3845 LABEL_DBX_DELETE,\r
3846 SECUREBOOT_DELETE_SIGNATURE_FROM_DBX,\r
3847 OPTION_DEL_DBX_QUESTION_ID,\r
3848 QuestionId - OPTION_DEL_DBX_QUESTION_ID\r
3849 );\r
3850 } else if ((QuestionId >= OPTION_DEL_DBT_QUESTION_ID) &&\r
3851 (QuestionId < (OPTION_DEL_DBT_QUESTION_ID + OPTION_CONFIG_RANGE))) {\r
3852 DeleteSignature (\r
3853 Private,\r
3854 EFI_IMAGE_SECURITY_DATABASE2,\r
3855 &gEfiImageSecurityDatabaseGuid,\r
3856 LABEL_DBT_DELETE,\r
3857 SECUREBOOT_DELETE_SIGNATURE_FROM_DBT,\r
3858 OPTION_DEL_DBT_QUESTION_ID,\r
3859 QuestionId - OPTION_DEL_DBT_QUESTION_ID\r
3860 );\r
3861 }\r
3862 break;\r
3863\r
3864 case KEY_VALUE_NO_SAVE_AND_EXIT_PK:\r
3865 case KEY_VALUE_NO_SAVE_AND_EXIT_KEK:\r
3866 case KEY_VALUE_NO_SAVE_AND_EXIT_DB:\r
3867 case KEY_VALUE_NO_SAVE_AND_EXIT_DBX:\r
3868 case KEY_VALUE_NO_SAVE_AND_EXIT_DBT:\r
3869 if (Private->FileContext->FHandle != NULL) {\r
3870 CloseFile (Private->FileContext->FHandle);\r
3871 Private->FileContext->FHandle = NULL;\r
3872 if (Private->FileContext->FileName!= NULL){\r
3873 FreePool(Private->FileContext->FileName);\r
3874 Private->FileContext->FileName = NULL;\r
3875 }\r
3876 }\r
3877\r
3878 if (Private->SignatureGUID != NULL) {\r
3879 FreePool (Private->SignatureGUID);\r
3880 Private->SignatureGUID = NULL;\r
3881 }\r
3882 break;\r
3883 }\r
3884 } else if (Action == EFI_BROWSER_ACTION_CHANGED) {\r
3885 switch (QuestionId) {\r
3886 case KEY_SECURE_BOOT_ENABLE:\r
3887 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_APPLY;\r
3888 break;\r
3889 case KEY_SECURE_BOOT_MODE:\r
3890 mIsEnterSecureBootForm = FALSE;\r
3891 break;\r
3892 case KEY_TRANS_SECURE_BOOT_MODE:\r
3893 mIsSelectedSecureBootModeForm = FALSE;\r
3894 if (mIsSecureBootModeChanged) {\r
3895 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_RESET;\r
3896 }\r
3897 mIsSecureBootModeChanged = FALSE;\r
3898 break;\r
3899 case KEY_SECURE_BOOT_KEK_GUID:\r
3900 case KEY_SECURE_BOOT_SIGNATURE_GUID_DB:\r
3901 case KEY_SECURE_BOOT_SIGNATURE_GUID_DBX:\r
3902 case KEY_SECURE_BOOT_SIGNATURE_GUID_DBT:\r
3903 ASSERT (Private->SignatureGUID != NULL);\r
3904 Status = StringToGuid (\r
3905 IfrNvData->SignatureGuid,\r
3906 StrLen (IfrNvData->SignatureGuid),\r
3907 Private->SignatureGUID\r
3908 );\r
3909 if (EFI_ERROR (Status)) {\r
3910 break;\r
3911 }\r
3912\r
3913 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_APPLY;\r
3914 break;\r
3915\r
3916 case KEY_SECURE_BOOT_DELETE_PK:\r
3917 if (IfrNvData->CurSecureBootMode == SECURE_BOOT_MODE_USER_MODE || IfrNvData->CurSecureBootMode == SECURE_BOOT_MODE_DEPLOYED_MODE) {\r
3918 IfrNvData->DeletePk = TRUE;\r
3919 IfrNvData->HasPk = FALSE;\r
3920 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_SUBMIT;\r
3921 } else {\r
3922 IfrNvData->DeletePk = FALSE;\r
3923 IfrNvData->HasPk = TRUE;\r
3924 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_APPLY;\r
3925 }\r
3926 break;\r
3927 default:\r
3928 break;\r
3929 }\r
3930 } else if (Action == EFI_BROWSER_ACTION_DEFAULT_STANDARD) {\r
3931 if (QuestionId == KEY_HIDE_SECURE_BOOT) {\r
3932 GetVariable2 (EFI_PLATFORM_KEY_NAME, &gEfiGlobalVariableGuid, (VOID**)&Pk, NULL);\r
3933 if (Pk == NULL) {\r
3934 IfrNvData->HideSecureBoot = TRUE;\r
3935 } else {\r
3936 FreePool (Pk);\r
3937 IfrNvData->HideSecureBoot = FALSE;\r
3938 }\r
3939 Value->b = IfrNvData->HideSecureBoot;\r
3940 }\r
3941 } else if (Action == EFI_BROWSER_ACTION_FORM_CLOSE) {\r
3942 //\r
3943 // Force the platform back to Standard Mode once user leave the setup screen.\r
3944 //\r
3945 GetVariable2 (EFI_CUSTOM_MODE_NAME, &gEfiCustomModeEnableGuid, (VOID**)&SecureBootMode, NULL);\r
3946 if (NULL != SecureBootMode && *SecureBootMode == CUSTOM_SECURE_BOOT_MODE) {\r
3947 IfrNvData->SecureBootMode = STANDARD_SECURE_BOOT_MODE;\r
3948 SetSecureBootMode(STANDARD_SECURE_BOOT_MODE);\r
3949 }\r
3950 if (SecureBootMode != NULL) {\r
3951 FreePool (SecureBootMode);\r
3952 }\r
3953 }\r
3954\r
3955EXIT:\r
3956\r
3957 if (!EFI_ERROR (Status)) {\r
3958 BufferSize = sizeof (SECUREBOOT_CONFIGURATION);\r
3959 HiiSetBrowserData (&gSecureBootConfigFormSetGuid, mSecureBootStorageName, BufferSize, (UINT8*) IfrNvData, NULL);\r
3960 }\r
3961\r
3962 FreePool (IfrNvData);\r
3963\r
3964 if (File != NULL){\r
3965 FreePool(File);\r
3966 File = NULL;\r
3967 }\r
3968\r
3969 return EFI_SUCCESS;\r
3970}\r
3971\r
3972/**\r
3973 This function publish the SecureBoot configuration Form.\r
3974\r
3975 @param[in, out] PrivateData Points to SecureBoot configuration private data.\r
3976\r
3977 @retval EFI_SUCCESS HII Form is installed successfully.\r
3978 @retval EFI_OUT_OF_RESOURCES Not enough resource for HII Form installation.\r
3979 @retval Others Other errors as indicated.\r
3980\r
3981**/\r
3982EFI_STATUS\r
3983InstallSecureBootConfigForm (\r
3984 IN OUT SECUREBOOT_CONFIG_PRIVATE_DATA *PrivateData\r
3985 )\r
3986{\r
3987 EFI_STATUS Status;\r
3988 EFI_HII_HANDLE HiiHandle;\r
3989 EFI_HANDLE DriverHandle;\r
3990 EFI_HII_CONFIG_ACCESS_PROTOCOL *ConfigAccess;\r
3991\r
3992 DriverHandle = NULL;\r
3993 ConfigAccess = &PrivateData->ConfigAccess;\r
3994 Status = gBS->InstallMultipleProtocolInterfaces (\r
3995 &DriverHandle,\r
3996 &gEfiDevicePathProtocolGuid,\r
3997 &mSecureBootHiiVendorDevicePath,\r
3998 &gEfiHiiConfigAccessProtocolGuid,\r
3999 ConfigAccess,\r
4000 NULL\r
4001 );\r
4002 if (EFI_ERROR (Status)) {\r
4003 return Status;\r
4004 }\r
4005\r
4006 PrivateData->DriverHandle = DriverHandle;\r
4007\r
4008 //\r
4009 // Publish the HII package list\r
4010 //\r
4011 HiiHandle = HiiAddPackages (\r
4012 &gSecureBootConfigFormSetGuid,\r
4013 DriverHandle,\r
4014 SecureBootConfigDxeStrings,\r
4015 SecureBootConfigBin,\r
4016 NULL\r
4017 );\r
4018 if (HiiHandle == NULL) {\r
4019 gBS->UninstallMultipleProtocolInterfaces (\r
4020 DriverHandle,\r
4021 &gEfiDevicePathProtocolGuid,\r
4022 &mSecureBootHiiVendorDevicePath,\r
4023 &gEfiHiiConfigAccessProtocolGuid,\r
4024 ConfigAccess,\r
4025 NULL\r
4026 );\r
4027 return EFI_OUT_OF_RESOURCES;\r
4028 }\r
4029\r
4030 PrivateData->HiiHandle = HiiHandle;\r
4031\r
4032 PrivateData->FileContext = AllocateZeroPool (sizeof (SECUREBOOT_FILE_CONTEXT));\r
4033\r
4034 if (PrivateData->FileContext == NULL) {\r
4035 UninstallSecureBootConfigForm (PrivateData);\r
4036 return EFI_OUT_OF_RESOURCES;\r
4037 }\r
4038\r
4039 //\r
4040 // Init OpCode Handle and Allocate space for creation of Buffer\r
4041 //\r
4042 mStartOpCodeHandle = HiiAllocateOpCodeHandle ();\r
4043 if (mStartOpCodeHandle == NULL) {\r
4044 UninstallSecureBootConfigForm (PrivateData);\r
4045 return EFI_OUT_OF_RESOURCES;\r
4046 }\r
4047\r
4048 mEndOpCodeHandle = HiiAllocateOpCodeHandle ();\r
4049 if (mEndOpCodeHandle == NULL) {\r
4050 UninstallSecureBootConfigForm (PrivateData);\r
4051 return EFI_OUT_OF_RESOURCES;\r
4052 }\r
4053\r
4054 //\r
4055 // Create Hii Extend Label OpCode as the start opcode\r
4056 //\r
4057 mStartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (\r
4058 mStartOpCodeHandle,\r
4059 &gEfiIfrTianoGuid,\r
4060 NULL,\r
4061 sizeof (EFI_IFR_GUID_LABEL)\r
4062 );\r
4063 mStartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;\r
4064\r
4065 //\r
4066 // Create Hii Extend Label OpCode as the end opcode\r
4067 //\r
4068 mEndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (\r
4069 mEndOpCodeHandle,\r
4070 &gEfiIfrTianoGuid,\r
4071 NULL,\r
4072 sizeof (EFI_IFR_GUID_LABEL)\r
4073 );\r
4074 mEndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;\r
4075 mEndLabel->Number = LABEL_END;\r
4076\r
4077 return EFI_SUCCESS;\r
4078}\r
4079\r
4080/**\r
4081 This function removes SecureBoot configuration Form.\r
4082\r
4083 @param[in, out] PrivateData Points to SecureBoot configuration private data.\r
4084\r
4085**/\r
4086VOID\r
4087UninstallSecureBootConfigForm (\r
4088 IN OUT SECUREBOOT_CONFIG_PRIVATE_DATA *PrivateData\r
4089 )\r
4090{\r
4091 //\r
4092 // Uninstall HII package list\r
4093 //\r
4094 if (PrivateData->HiiHandle != NULL) {\r
4095 HiiRemovePackages (PrivateData->HiiHandle);\r
4096 PrivateData->HiiHandle = NULL;\r
4097 }\r
4098\r
4099 //\r
4100 // Uninstall HII Config Access Protocol\r
4101 //\r
4102 if (PrivateData->DriverHandle != NULL) {\r
4103 gBS->UninstallMultipleProtocolInterfaces (\r
4104 PrivateData->DriverHandle,\r
4105 &gEfiDevicePathProtocolGuid,\r
4106 &mSecureBootHiiVendorDevicePath,\r
4107 &gEfiHiiConfigAccessProtocolGuid,\r
4108 &PrivateData->ConfigAccess,\r
4109 NULL\r
4110 );\r
4111 PrivateData->DriverHandle = NULL;\r
4112 }\r
4113\r
4114 if (PrivateData->SignatureGUID != NULL) {\r
4115 FreePool (PrivateData->SignatureGUID);\r
4116 }\r
4117\r
4118 if (PrivateData->FileContext != NULL) {\r
4119 FreePool (PrivateData->FileContext);\r
4120 }\r
4121\r
4122 FreePool (PrivateData);\r
4123\r
4124 if (mStartOpCodeHandle != NULL) {\r
4125 HiiFreeOpCodeHandle (mStartOpCodeHandle);\r
4126 }\r
4127\r
4128 if (mEndOpCodeHandle != NULL) {\r
4129 HiiFreeOpCodeHandle (mEndOpCodeHandle);\r
4130 }\r
4131}\r
EFI Development Kit II mirror for PVE