]> git.proxmox.com Git - mirror_edk2.git/blob - SecurityPkg/VariableAuthenticated/SecureBootConfigDxe/SecureBootConfigImpl.c
projects / mirror_edk2.git / blob
? search:


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