]> git.proxmox.com Git - mirror_edk2.git/blame - SecurityPkg/Library/AuthVariableLib/AuthService.c
projects / mirror_edk2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
SecurityPkg: Remove Counter Based AuthVariable support
[mirror_edk2.git] / SecurityPkg / Library / AuthVariableLib / AuthService.c
CommitLineData
a6811666
SZ		 1/** @file\r
2 Implement authentication services for the authenticated variables.\r
3\r
4 Caution: This module requires additional review when modified.\r
5 This driver will have external input - variable data. It may be input in SMM mode.\r
6 This external input must be validated carefully to avoid security issue like\r
7 buffer overflow, integer overflow.\r
8 Variable attribute should also be checked to avoid authentication bypass.\r
9 The whole SMM authentication variable design relies on the integrity of flash part and SMM.\r
10 which is assumed to be protected by platform. All variable code and metadata in flash/SMM Memory\r
11 may not be modified without authorization. If platform fails to protect these resources,\r
12 the authentication service provided in this driver will be broken, and the behavior is undefined.\r
13\r
14 ProcessVarWithPk(), ProcessVarWithKek() and ProcessVariable() are the function to do\r
15 variable authentication.\r
16\r
17 VerifyTimeBasedPayloadAndUpdate() and VerifyCounterBasedPayload() are sub function to do verification.\r
18 They will do basic validation for authentication data structure, then call crypto library\r
19 to verify the signature.\r
20\r
c035e373 21Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>\r
a6811666
SZ		 22This program and the accompanying materials\r
23are licensed and made available under the terms and conditions of the BSD License\r
24which accompanies this distribution. The full text of the license may be found at\r
25http://opensource.org/licenses/bsd-license.php\r
26\r
27THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
28WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
29\r
30**/\r
31\r
32#include "AuthServiceInternal.h"\r
33\r
34//\r
35// Public Exponent of RSA Key.\r
36//\r
37CONST UINT8 mRsaE[] = { 0x01, 0x00, 0x01 };\r
38\r
c035e373
ZL		 39CONST UINT8 mSha256OidValue[] = { 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01 };\r
40\r
a6811666
SZ		 41//\r
42// Requirement for different signature type which have been defined in UEFI spec.\r
43// These data are used to perform SignatureList format check while setting PK/KEK variable.\r
44//\r
45EFI_SIGNATURE_ITEM mSupportSigItem[] = {\r
46//{SigType, SigHeaderSize, SigDataSize }\r
47 {EFI_CERT_SHA256_GUID, 0, 32 },\r
48 {EFI_CERT_RSA2048_GUID, 0, 256 },\r
49 {EFI_CERT_RSA2048_SHA256_GUID, 0, 256 },\r
50 {EFI_CERT_SHA1_GUID, 0, 20 },\r
51 {EFI_CERT_RSA2048_SHA1_GUID, 0, 256 },\r
52 {EFI_CERT_X509_GUID, 0, ((UINT32) ~0)},\r
53 {EFI_CERT_SHA224_GUID, 0, 28 },\r
54 {EFI_CERT_SHA384_GUID, 0, 48 },\r
55 {EFI_CERT_SHA512_GUID, 0, 64 },\r
56 {EFI_CERT_X509_SHA256_GUID, 0, 48 },\r
57 {EFI_CERT_X509_SHA384_GUID, 0, 64 },\r
58 {EFI_CERT_X509_SHA512_GUID, 0, 80 }\r
59};\r
60\r
61/**\r
62 Finds variable in storage blocks of volatile and non-volatile storage areas.\r
63\r
64 This code finds variable in storage blocks of volatile and non-volatile storage areas.\r
65 If VariableName is an empty string, then we just return the first\r
66 qualified variable without comparing VariableName and VendorGuid.\r
67\r
68 @param[in] VariableName Name of the variable to be found.\r
69 @param[in] VendorGuid Variable vendor GUID to be found.\r
70 @param[out] Data Pointer to data address.\r
71 @param[out] DataSize Pointer to data size.\r
72\r
73 @retval EFI_INVALID_PARAMETER If VariableName is not an empty string,\r
74 while VendorGuid is NULL.\r
75 @retval EFI_SUCCESS Variable successfully found.\r
76 @retval EFI_NOT_FOUND Variable not found\r
77\r
78**/\r
79EFI_STATUS\r
80AuthServiceInternalFindVariable (\r
81 IN CHAR16 *VariableName,\r
82 IN EFI_GUID *VendorGuid,\r
83 OUT VOID **Data,\r
84 OUT UINTN *DataSize\r
85 )\r
86{\r
87 EFI_STATUS Status;\r
88 AUTH_VARIABLE_INFO AuthVariableInfo;\r
89\r
90 ZeroMem (&AuthVariableInfo, sizeof (AuthVariableInfo));\r
91 Status = mAuthVarLibContextIn->FindVariable (\r
92 VariableName,\r
93 VendorGuid,\r
94 &AuthVariableInfo\r
95 );\r
96 *Data = AuthVariableInfo.Data;\r
97 *DataSize = AuthVariableInfo.DataSize;\r
98 return Status;\r
99}\r
100\r
101/**\r
102 Update the variable region with Variable information.\r
103\r
104 @param[in] VariableName Name of variable.\r
105 @param[in] VendorGuid Guid of variable.\r
106 @param[in] Data Data pointer.\r
107 @param[in] DataSize Size of Data.\r
108 @param[in] Attributes Attribute value of the variable.\r
109\r
110 @retval EFI_SUCCESS The update operation is success.\r
111 @retval EFI_INVALID_PARAMETER Invalid parameter.\r
112 @retval EFI_WRITE_PROTECTED Variable is write-protected.\r
113 @retval EFI_OUT_OF_RESOURCES There is not enough resource.\r
114\r
115**/\r
116EFI_STATUS\r
117AuthServiceInternalUpdateVariable (\r
118 IN CHAR16 *VariableName,\r
119 IN EFI_GUID *VendorGuid,\r
120 IN VOID *Data,\r
121 IN UINTN DataSize,\r
122 IN UINT32 Attributes\r
123 )\r
124{\r
125 AUTH_VARIABLE_INFO AuthVariableInfo;\r
126\r
127 ZeroMem (&AuthVariableInfo, sizeof (AuthVariableInfo));\r
128 AuthVariableInfo.VariableName = VariableName;\r
129 AuthVariableInfo.VendorGuid = VendorGuid;\r
130 AuthVariableInfo.Data = Data;\r
131 AuthVariableInfo.DataSize = DataSize;\r
132 AuthVariableInfo.Attributes = Attributes;\r
133\r
134 return mAuthVarLibContextIn->UpdateVariable (\r
135 &AuthVariableInfo\r
136 );\r
137}\r
138\r
a6811666 139/**\r
560ac77e 140 Update the variable region with Variable information.\r
a6811666 141\r
560ac77e
ZC		 142 @param[in] VariableName Name of variable.\r
143 @param[in] VendorGuid Guid of variable.\r
144 @param[in] Data Data pointer.\r
145 @param[in] DataSize Size of Data.\r
146 @param[in] Attributes Attribute value of the variable.\r
147 @param[in] TimeStamp Value of associated TimeStamp.\r
a6811666 148\r
560ac77e
ZC		 149 @retval EFI_SUCCESS The update operation is success.\r
150 @retval EFI_INVALID_PARAMETER Invalid parameter.\r
151 @retval EFI_WRITE_PROTECTED Variable is write-protected.\r
a6811666
SZ		 152 @retval EFI_OUT_OF_RESOURCES There is not enough resource.\r
153\r
154**/\r
155EFI_STATUS\r
560ac77e
ZC		 156AuthServiceInternalUpdateVariableWithTimeStamp (\r
157 IN CHAR16 *VariableName,\r
158 IN EFI_GUID *VendorGuid,\r
159 IN VOID *Data,\r
160 IN UINTN DataSize,\r
161 IN UINT32 Attributes,\r
162 IN EFI_TIME *TimeStamp\r
a6811666
SZ		 163 )\r
164{\r
560ac77e
ZC		 165 EFI_STATUS FindStatus;\r
166 VOID *OrgData;\r
167 UINTN OrgDataSize;\r
168 AUTH_VARIABLE_INFO AuthVariableInfo;\r
169\r
170 FindStatus = AuthServiceInternalFindVariable (\r
171 VariableName,\r
172 VendorGuid,\r
173 &OrgData,\r
174 &OrgDataSize\r
175 );\r
a6811666
SZ		 176\r
177 //\r
560ac77e 178 // EFI_VARIABLE_APPEND_WRITE attribute only effects for existing variable\r
a6811666 179 //\r
560ac77e
ZC		 180 if (!EFI_ERROR (FindStatus) && ((Attributes & EFI_VARIABLE_APPEND_WRITE) != 0)) {\r
181 if ((CompareGuid (VendorGuid, &gEfiImageSecurityDatabaseGuid) &&\r
182 ((StrCmp (VariableName, EFI_IMAGE_SECURITY_DATABASE) == 0) || (StrCmp (VariableName, EFI_IMAGE_SECURITY_DATABASE1) == 0) ||\r
183 (StrCmp (VariableName, EFI_IMAGE_SECURITY_DATABASE2) == 0))) ||\r
184 (CompareGuid (VendorGuid, &gEfiGlobalVariableGuid) && (StrCmp (VariableName, EFI_KEY_EXCHANGE_KEY_NAME) == 0))) {\r
185 //\r
186 // For variables with formatted as EFI_SIGNATURE_LIST, the driver shall not perform an append of\r
187 // EFI_SIGNATURE_DATA values that are already part of the existing variable value.\r
188 //\r
189 FilterSignatureList (\r
190 OrgData,\r
191 OrgDataSize,\r
192 Data,\r
193 &DataSize\r
194 );\r
195 }\r
a6811666
SZ		 196 }\r
197\r
560ac77e
ZC		 198 ZeroMem (&AuthVariableInfo, sizeof (AuthVariableInfo));\r
199 AuthVariableInfo.VariableName = VariableName;\r
200 AuthVariableInfo.VendorGuid = VendorGuid;\r
201 AuthVariableInfo.Data = Data;\r
202 AuthVariableInfo.DataSize = DataSize;\r
203 AuthVariableInfo.Attributes = Attributes;\r
204 AuthVariableInfo.TimeStamp = TimeStamp;\r
205 return mAuthVarLibContextIn->UpdateVariable (\r
206 &AuthVariableInfo\r
207 );\r
a6811666
SZ		 208}\r
209\r
210/**\r
211 Determine whether this operation needs a physical present user.\r
212\r
213 @param[in] VariableName Name of the Variable.\r
214 @param[in] VendorGuid GUID of the Variable.\r
215\r
216 @retval TRUE This variable is protected, only a physical present user could set this variable.\r
217 @retval FALSE This variable is not protected.\r
218\r
219**/\r
220BOOLEAN\r
221NeedPhysicallyPresent(\r
222 IN CHAR16 *VariableName,\r
223 IN EFI_GUID *VendorGuid\r
224 )\r
225{\r
226 if ((CompareGuid (VendorGuid, &gEfiSecureBootEnableDisableGuid) && (StrCmp (VariableName, EFI_SECURE_BOOT_ENABLE_NAME) == 0))\r
227 || (CompareGuid (VendorGuid, &gEfiCustomModeEnableGuid) && (StrCmp (VariableName, EFI_CUSTOM_MODE_NAME) == 0))) {\r
228 return TRUE;\r
229 }\r
230\r
231 return FALSE;\r
232}\r
233\r
234/**\r
235 Determine whether the platform is operating in Custom Secure Boot mode.\r
236\r
237 @retval TRUE The platform is operating in Custom mode.\r
238 @retval FALSE The platform is operating in Standard mode.\r
239\r
240**/\r
241BOOLEAN\r
242InCustomMode (\r
243 VOID\r
244 )\r
245{\r
246 EFI_STATUS Status;\r
247 VOID *Data;\r
248 UINTN DataSize;\r
249\r
250 Status = AuthServiceInternalFindVariable (EFI_CUSTOM_MODE_NAME, &gEfiCustomModeEnableGuid, &Data, &DataSize);\r
251 if (!EFI_ERROR (Status) && (*(UINT8 *) Data == CUSTOM_SECURE_BOOT_MODE)) {\r
252 return TRUE;\r
253 }\r
254\r
255 return FALSE;\r
256}\r
257\r
560ac77e
ZC		 258/**\r
259 Update platform mode.\r
260\r
261 @param[in] Mode SETUP_MODE or USER_MODE.\r
262\r
263 @return EFI_INVALID_PARAMETER Invalid parameter.\r
264 @return EFI_SUCCESS Update platform mode successfully.\r
265\r
266**/\r
267EFI_STATUS\r
268UpdatePlatformMode (\r
269 IN UINT32 Mode\r
270 )\r
271{\r
272 EFI_STATUS Status;\r
273 VOID *Data;\r
274 UINTN DataSize;\r
275 UINT8 SecureBootMode;\r
276 UINT8 SecureBootEnable;\r
277 UINTN VariableDataSize;\r
278\r
279 Status = AuthServiceInternalFindVariable (\r
280 EFI_SETUP_MODE_NAME,\r
281 &gEfiGlobalVariableGuid,\r
282 &Data,\r
283 &DataSize\r
284 );\r
285 if (EFI_ERROR (Status)) {\r
286 return Status;\r
287 }\r
288\r
289 //\r
290 // Update the value of SetupMode variable by a simple mem copy, this could avoid possible\r
291 // variable storage reclaim at runtime.\r
292 //\r
293 mPlatformMode = (UINT8) Mode;\r
294 CopyMem (Data, &mPlatformMode, sizeof(UINT8));\r
295\r
296 if (mAuthVarLibContextIn->AtRuntime ()) {\r
297 //\r
298 // SecureBoot Variable indicates whether the platform firmware is operating\r
299 // in Secure boot mode (1) or not (0), so we should not change SecureBoot\r
300 // Variable in runtime.\r
301 //\r
302 return Status;\r
303 }\r
304\r
305 //\r
306 // Check "SecureBoot" variable's existence.\r
307 // If it doesn't exist, firmware has no capability to perform driver signing verification,\r
308 // then set "SecureBoot" to 0.\r
309 //\r
310 Status = AuthServiceInternalFindVariable (\r
311 EFI_SECURE_BOOT_MODE_NAME,\r
312 &gEfiGlobalVariableGuid,\r
313 &Data,\r
314 &DataSize\r
315 );\r
316 //\r
317 // If "SecureBoot" variable exists, then check "SetupMode" variable update.\r
318 // If "SetupMode" variable is USER_MODE, "SecureBoot" variable is set to 1.\r
319 // If "SetupMode" variable is SETUP_MODE, "SecureBoot" variable is set to 0.\r
320 //\r
321 if (EFI_ERROR (Status)) {\r
322 SecureBootMode = SECURE_BOOT_MODE_DISABLE;\r
323 } else {\r
324 if (mPlatformMode == USER_MODE) {\r
325 SecureBootMode = SECURE_BOOT_MODE_ENABLE;\r
326 } else if (mPlatformMode == SETUP_MODE) {\r
327 SecureBootMode = SECURE_BOOT_MODE_DISABLE;\r
328 } else {\r
329 return EFI_NOT_FOUND;\r
330 }\r
331 }\r
332\r
333 Status = AuthServiceInternalUpdateVariable (\r
334 EFI_SECURE_BOOT_MODE_NAME,\r
335 &gEfiGlobalVariableGuid,\r
336 &SecureBootMode,\r
337 sizeof(UINT8),\r
338 EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS\r
339 );\r
340 if (EFI_ERROR (Status)) {\r
341 return Status;\r
342 }\r
343\r
344 //\r
345 // Check "SecureBootEnable" variable's existence. It can enable/disable secure boot feature.\r
346 //\r
347 Status = AuthServiceInternalFindVariable (\r
348 EFI_SECURE_BOOT_ENABLE_NAME,\r
349 &gEfiSecureBootEnableDisableGuid,\r
350 &Data,\r
351 &DataSize\r
352 );\r
353\r
354 if (SecureBootMode == SECURE_BOOT_MODE_ENABLE) {\r
355 //\r
356 // Create the "SecureBootEnable" variable as secure boot is enabled.\r
357 //\r
358 SecureBootEnable = SECURE_BOOT_ENABLE;\r
359 VariableDataSize = sizeof (SecureBootEnable);\r
360 } else {\r
361 //\r
362 // Delete the "SecureBootEnable" variable if this variable exist as "SecureBoot"\r
363 // variable is not in secure boot state.\r
364 //\r
365 if (EFI_ERROR (Status)) {\r
366 return EFI_SUCCESS;\r
367 }\r
368 SecureBootEnable = SECURE_BOOT_DISABLE;\r
369 VariableDataSize = 0;\r
370 }\r
371\r
372 Status = AuthServiceInternalUpdateVariable (\r
373 EFI_SECURE_BOOT_ENABLE_NAME,\r
374 &gEfiSecureBootEnableDisableGuid,\r
375 &SecureBootEnable,\r
376 VariableDataSize,\r
377 EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS\r
378 );\r
379 return Status;\r
380}\r
a6811666
SZ		 381\r
382/**\r
383 Check input data form to make sure it is a valid EFI_SIGNATURE_LIST for PK/KEK/db/dbx/dbt variable.\r
384\r
385 @param[in] VariableName Name of Variable to be check.\r
386 @param[in] VendorGuid Variable vendor GUID.\r
387 @param[in] Data Point to the variable data to be checked.\r
388 @param[in] DataSize Size of Data.\r
389\r
390 @return EFI_INVALID_PARAMETER Invalid signature list format.\r
391 @return EFI_SUCCESS Passed signature list format check successfully.\r
392\r
393**/\r
394EFI_STATUS\r
395CheckSignatureListFormat(\r
396 IN CHAR16 *VariableName,\r
397 IN EFI_GUID *VendorGuid,\r
398 IN VOID *Data,\r
399 IN UINTN DataSize\r
400 )\r
401{\r
402 EFI_SIGNATURE_LIST *SigList;\r
403 UINTN SigDataSize;\r
404 UINT32 Index;\r
405 UINT32 SigCount;\r
406 BOOLEAN IsPk;\r
407 VOID *RsaContext;\r
408 EFI_SIGNATURE_DATA *CertData;\r
409 UINTN CertLen;\r
410\r
411 if (DataSize == 0) {\r
412 return EFI_SUCCESS;\r
413 }\r
414\r
415 ASSERT (VariableName != NULL && VendorGuid != NULL && Data != NULL);\r
416\r
417 if (CompareGuid (VendorGuid, &gEfiGlobalVariableGuid) && (StrCmp (VariableName, EFI_PLATFORM_KEY_NAME) == 0)){\r
418 IsPk = TRUE;\r
419 } else if ((CompareGuid (VendorGuid, &gEfiGlobalVariableGuid) && (StrCmp (VariableName, EFI_KEY_EXCHANGE_KEY_NAME) == 0)) ||\r
420 (CompareGuid (VendorGuid, &gEfiImageSecurityDatabaseGuid) &&\r
421 ((StrCmp (VariableName, EFI_IMAGE_SECURITY_DATABASE) == 0) || (StrCmp (VariableName, EFI_IMAGE_SECURITY_DATABASE1) == 0) ||\r
422 (StrCmp (VariableName, EFI_IMAGE_SECURITY_DATABASE2) == 0)))) {\r
423 IsPk = FALSE;\r
424 } else {\r
425 return EFI_SUCCESS;\r
426 }\r
427\r
428 SigCount = 0;\r
429 SigList = (EFI_SIGNATURE_LIST *) Data;\r
430 SigDataSize = DataSize;\r
431 RsaContext = NULL;\r
432\r
433 //\r
434 // Walk throuth the input signature list and check the data format.\r
435 // If any signature is incorrectly formed, the whole check will fail.\r
436 //\r
437 while ((SigDataSize > 0) && (SigDataSize >= SigList->SignatureListSize)) {\r
438 for (Index = 0; Index < (sizeof (mSupportSigItem) / sizeof (EFI_SIGNATURE_ITEM)); Index++ ) {\r
439 if (CompareGuid (&SigList->SignatureType, &mSupportSigItem[Index].SigType)) {\r
440 //\r
441 // The value of SignatureSize should always be 16 (size of SignatureOwner\r
442 // component) add the data length according to signature type.\r
443 //\r
444 if (mSupportSigItem[Index].SigDataSize != ((UINT32) ~0) &&\r
445 (SigList->SignatureSize - sizeof (EFI_GUID)) != mSupportSigItem[Index].SigDataSize) {\r
446 return EFI_INVALID_PARAMETER;\r
447 }\r
448 if (mSupportSigItem[Index].SigHeaderSize != ((UINT32) ~0) &&\r
449 SigList->SignatureHeaderSize != mSupportSigItem[Index].SigHeaderSize) {\r
450 return EFI_INVALID_PARAMETER;\r
451 }\r
452 break;\r
453 }\r
454 }\r
455\r
456 if (Index == (sizeof (mSupportSigItem) / sizeof (EFI_SIGNATURE_ITEM))) {\r
457 //\r
458 // Undefined signature type.\r
459 //\r
460 return EFI_INVALID_PARAMETER;\r
461 }\r
462\r
463 if (CompareGuid (&SigList->SignatureType, &gEfiCertX509Guid)) {\r
464 //\r
465 // Try to retrieve the RSA public key from the X.509 certificate.\r
466 // If this operation fails, it's not a valid certificate.\r
467 //\r
468 RsaContext = RsaNew ();\r
469 if (RsaContext == NULL) {\r
470 return EFI_INVALID_PARAMETER;\r
471 }\r
472 CertData = (EFI_SIGNATURE_DATA *) ((UINT8 *) SigList + sizeof (EFI_SIGNATURE_LIST) + SigList->SignatureHeaderSize);\r
473 CertLen = SigList->SignatureSize - sizeof (EFI_GUID);\r
474 if (!RsaGetPublicKeyFromX509 (CertData->SignatureData, CertLen, &RsaContext)) {\r
475 RsaFree (RsaContext);\r
476 return EFI_INVALID_PARAMETER;\r
477 }\r
478 RsaFree (RsaContext);\r
479 }\r
480\r
481 if ((SigList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - SigList->SignatureHeaderSize) % SigList->SignatureSize != 0) {\r
482 return EFI_INVALID_PARAMETER;\r
483 }\r
484 SigCount += (SigList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - SigList->SignatureHeaderSize) / SigList->SignatureSize;\r
485\r
486 SigDataSize -= SigList->SignatureListSize;\r
487 SigList = (EFI_SIGNATURE_LIST *) ((UINT8 *) SigList + SigList->SignatureListSize);\r
488 }\r
489\r
490 if (((UINTN) SigList - (UINTN) Data) != DataSize) {\r
491 return EFI_INVALID_PARAMETER;\r
492 }\r
493\r
494 if (IsPk && SigCount > 1) {\r
495 return EFI_INVALID_PARAMETER;\r
496 }\r
497\r
498 return EFI_SUCCESS;\r
499}\r
500\r
501/**\r
502 Update "VendorKeys" variable to record the out of band secure boot key modification.\r
503\r
504 @return EFI_SUCCESS Variable is updated successfully.\r
505 @return Others Failed to update variable.\r
506\r
507**/\r
508EFI_STATUS\r
509VendorKeyIsModified (\r
510 VOID\r
511 )\r
512{\r
513 EFI_STATUS Status;\r
514\r
515 if (mVendorKeyState == VENDOR_KEYS_MODIFIED) {\r
516 return EFI_SUCCESS;\r
517 }\r
518 mVendorKeyState = VENDOR_KEYS_MODIFIED;\r
519\r
520 Status = AuthServiceInternalUpdateVariable (\r
521 EFI_VENDOR_KEYS_NV_VARIABLE_NAME,\r
522 &gEfiVendorKeysNvGuid,\r
523 &mVendorKeyState,\r
524 sizeof (UINT8),\r
525 EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS\r
526 );\r
527 if (EFI_ERROR (Status)) {\r
528 return Status;\r
529 }\r
530\r
531 return AuthServiceInternalUpdateVariable (\r
532 EFI_VENDOR_KEYS_VARIABLE_NAME,\r
533 &gEfiGlobalVariableGuid,\r
534 &mVendorKeyState,\r
535 sizeof (UINT8),\r
536 EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS\r
537 );\r
538}\r
539\r
540/**\r
541 Process variable with platform key for verification.\r
542\r
543 Caution: This function may receive untrusted input.\r
544 This function may be invoked in SMM mode, and datasize and data are external input.\r
545 This function will do basic validation, before parse the data.\r
546 This function will parse the authentication carefully to avoid security issues, like\r
547 buffer overflow, integer overflow.\r
548 This function will check attribute carefully to avoid authentication bypass.\r
549\r
550 @param[in] VariableName Name of Variable to be found.\r
551 @param[in] VendorGuid Variable vendor GUID.\r
552 @param[in] Data Data pointer.\r
553 @param[in] DataSize Size of Data found. If size is less than the\r
554 data, this value contains the required size.\r
555 @param[in] Attributes Attribute value of the variable\r
556 @param[in] IsPk Indicate whether it is to process pk.\r
557\r
558 @return EFI_INVALID_PARAMETER Invalid parameter.\r
559 @return EFI_SECURITY_VIOLATION The variable does NOT pass the validation.\r
560 check carried out by the firmware.\r
561 @return EFI_SUCCESS Variable passed validation successfully.\r
562\r
563**/\r
564EFI_STATUS\r
565ProcessVarWithPk (\r
566 IN CHAR16 *VariableName,\r
567 IN EFI_GUID *VendorGuid,\r
568 IN VOID *Data,\r
569 IN UINTN DataSize,\r
570 IN UINT32 Attributes OPTIONAL,\r
571 IN BOOLEAN IsPk\r
572 )\r
573{\r
574 EFI_STATUS Status;\r
575 BOOLEAN Del;\r
576 UINT8 *Payload;\r
577 UINTN PayloadSize;\r
578\r
579 if ((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0 ||\r
580 (Attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) == 0) {\r
581 //\r
582 // PK, KEK and db/dbx/dbt should set EFI_VARIABLE_NON_VOLATILE attribute and should be a time-based\r
583 // authenticated variable.\r
584 //\r
585 return EFI_INVALID_PARAMETER;\r
586 }\r
587\r
4fc08e8d
CZ		 588 //\r
589 // Init state of Del. State may change due to secure check\r
590 //\r
a6811666 591 Del = FALSE;\r
76bfc7e3 592 if ((InCustomMode() && UserPhysicalPresent()) || (mPlatformMode == SETUP_MODE && !IsPk)) {\r
560ac77e
ZC		 593 Payload = (UINT8 *) Data + AUTHINFO2_SIZE (Data);\r
594 PayloadSize = DataSize - AUTHINFO2_SIZE (Data);\r
595 if (PayloadSize == 0) {\r
596 Del = TRUE;\r
597 }\r
a6811666
SZ		 598\r
599 Status = CheckSignatureListFormat(VariableName, VendorGuid, Payload, PayloadSize);\r
600 if (EFI_ERROR (Status)) {\r
601 return Status;\r
602 }\r
603\r
604 Status = AuthServiceInternalUpdateVariableWithTimeStamp (\r
605 VariableName,\r
606 VendorGuid,\r
607 Payload,\r
608 PayloadSize,\r
609 Attributes,\r
610 &((EFI_VARIABLE_AUTHENTICATION_2 *) Data)->TimeStamp\r
611 );\r
612 if (EFI_ERROR(Status)) {\r
613 return Status;\r
614 }\r
615\r
560ac77e 616 if ((mPlatformMode != SETUP_MODE) || IsPk) {\r
a6811666
SZ		 617 Status = VendorKeyIsModified ();\r
618 }\r
560ac77e 619 } else if (mPlatformMode == USER_MODE) {\r
a6811666
SZ		 620 //\r
621 // Verify against X509 Cert in PK database.\r
622 //\r
623 Status = VerifyTimeBasedPayloadAndUpdate (\r
624 VariableName,\r
625 VendorGuid,\r
626 Data,\r
627 DataSize,\r
628 Attributes,\r
629 AuthVarTypePk,\r
630 &Del\r
631 );\r
632 } else {\r
633 //\r
634 // Verify against the certificate in data payload.\r
635 //\r
636 Status = VerifyTimeBasedPayloadAndUpdate (\r
637 VariableName,\r
638 VendorGuid,\r
639 Data,\r
640 DataSize,\r
641 Attributes,\r
642 AuthVarTypePayload,\r
643 &Del\r
644 );\r
645 }\r
646\r
647 if (!EFI_ERROR(Status) && IsPk) {\r
560ac77e
ZC		 648 if (mPlatformMode == SETUP_MODE && !Del) {\r
649 //\r
650 // If enroll PK in setup mode, need change to user mode.\r
651 //\r
652 Status = UpdatePlatformMode (USER_MODE);\r
653 } else if (mPlatformMode == USER_MODE && Del){\r
654 //\r
655 // If delete PK in user mode, need change to setup mode.\r
656 //\r
657 Status = UpdatePlatformMode (SETUP_MODE);\r
a6811666
SZ		 658 }\r
659 }\r
660\r
661 return Status;\r
662}\r
663\r
664/**\r
665 Process variable with key exchange key for verification.\r
666\r
667 Caution: This function may receive untrusted input.\r
668 This function may be invoked in SMM mode, and datasize and data are external input.\r
669 This function will do basic validation, before parse the data.\r
670 This function will parse the authentication carefully to avoid security issues, like\r
671 buffer overflow, integer overflow.\r
672 This function will check attribute carefully to avoid authentication bypass.\r
673\r
674 @param[in] VariableName Name of Variable to be found.\r
675 @param[in] VendorGuid Variable vendor GUID.\r
676 @param[in] Data Data pointer.\r
677 @param[in] DataSize Size of Data found. If size is less than the\r
678 data, this value contains the required size.\r
679 @param[in] Attributes Attribute value of the variable.\r
680\r
681 @return EFI_INVALID_PARAMETER Invalid parameter.\r
682 @return EFI_SECURITY_VIOLATION The variable does NOT pass the validation\r
683 check carried out by the firmware.\r
684 @return EFI_SUCCESS Variable pass validation successfully.\r
685\r
686**/\r
687EFI_STATUS\r
688ProcessVarWithKek (\r
689 IN CHAR16 *VariableName,\r
690 IN EFI_GUID *VendorGuid,\r
691 IN VOID *Data,\r
692 IN UINTN DataSize,\r
693 IN UINT32 Attributes OPTIONAL\r
694 )\r
695{\r
696 EFI_STATUS Status;\r
697 UINT8 *Payload;\r
698 UINTN PayloadSize;\r
699\r
700 if ((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0 ||\r
701 (Attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) == 0) {\r
702 //\r
703 // DB, DBX and DBT should set EFI_VARIABLE_NON_VOLATILE attribute and should be a time-based\r
704 // authenticated variable.\r
705 //\r
706 return EFI_INVALID_PARAMETER;\r
707 }\r
708\r
709 Status = EFI_SUCCESS;\r
76bfc7e3 710 if (mPlatformMode == USER_MODE && !(InCustomMode() && UserPhysicalPresent())) {\r
a6811666
SZ		 711 //\r
712 // Time-based, verify against X509 Cert KEK.\r
713 //\r
714 return VerifyTimeBasedPayloadAndUpdate (\r
715 VariableName,\r
716 VendorGuid,\r
717 Data,\r
718 DataSize,\r
719 Attributes,\r
720 AuthVarTypeKek,\r
721 NULL\r
722 );\r
723 } else {\r
724 //\r
725 // If in setup mode or custom secure boot mode, no authentication needed.\r
726 //\r
727 Payload = (UINT8 *) Data + AUTHINFO2_SIZE (Data);\r
728 PayloadSize = DataSize - AUTHINFO2_SIZE (Data);\r
729\r
730 Status = CheckSignatureListFormat(VariableName, VendorGuid, Payload, PayloadSize);\r
731 if (EFI_ERROR (Status)) {\r
732 return Status;\r
733 }\r
734\r
735 Status = AuthServiceInternalUpdateVariableWithTimeStamp (\r
736 VariableName,\r
737 VendorGuid,\r
738 Payload,\r
739 PayloadSize,\r
740 Attributes,\r
741 &((EFI_VARIABLE_AUTHENTICATION_2 *) Data)->TimeStamp\r
742 );\r
743 if (EFI_ERROR (Status)) {\r
744 return Status;\r
745 }\r
746\r
560ac77e 747 if (mPlatformMode != SETUP_MODE) {\r
a6811666
SZ		 748 Status = VendorKeyIsModified ();\r
749 }\r
750 }\r
751\r
752 return Status;\r
753}\r
754\r
755/**\r
756 Check if it is to delete auth variable.\r
757\r
758 @param[in] OrgAttributes Original attribute value of the variable.\r
759 @param[in] Data Data pointer.\r
760 @param[in] DataSize Size of Data.\r
761 @param[in] Attributes Attribute value of the variable.\r
762\r
763 @retval TRUE It is to delete auth variable.\r
764 @retval FALSE It is not to delete auth variable.\r
765\r
766**/\r
767BOOLEAN\r
768IsDeleteAuthVariable (\r
769 IN UINT32 OrgAttributes,\r
770 IN VOID *Data,\r
771 IN UINTN DataSize,\r
772 IN UINT32 Attributes\r
773 )\r
774{\r
775 BOOLEAN Del;\r
776 UINTN PayloadSize;\r
777\r
778 Del = FALSE;\r
779\r
780 //\r
781 // To delete a variable created with the EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS\r
782 // or the EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS attribute,\r
783 // SetVariable must be used with attributes matching the existing variable\r
784 // and the DataSize set to the size of the AuthInfo descriptor.\r
785 //\r
786 if ((Attributes == OrgAttributes) &&\r
787 ((Attributes & (EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS)) != 0)) {\r
788 if ((Attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) != 0) {\r
789 PayloadSize = DataSize - AUTHINFO2_SIZE (Data);\r
790 if (PayloadSize == 0) {\r
791 Del = TRUE;\r
792 }\r
793 } else {\r
794 PayloadSize = DataSize - AUTHINFO_SIZE;\r
795 if (PayloadSize == 0) {\r
796 Del = TRUE;\r
797 }\r
798 }\r
799 }\r
800\r
801 return Del;\r
802}\r
803\r
804/**\r
0130fdde 805 Process variable with EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS set\r
a6811666
SZ		 806\r
807 Caution: This function may receive untrusted input.\r
808 This function may be invoked in SMM mode, and datasize and data are external input.\r
809 This function will do basic validation, before parse the data.\r
810 This function will parse the authentication carefully to avoid security issues, like\r
811 buffer overflow, integer overflow.\r
812 This function will check attribute carefully to avoid authentication bypass.\r
813\r
814 @param[in] VariableName Name of the variable.\r
815 @param[in] VendorGuid Variable vendor GUID.\r
816 @param[in] Data Data pointer.\r
817 @param[in] DataSize Size of Data.\r
818 @param[in] Attributes Attribute value of the variable.\r
819\r
820 @return EFI_INVALID_PARAMETER Invalid parameter.\r
821 @return EFI_WRITE_PROTECTED Variable is write-protected and needs authentication with\r
0130fdde 822 EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS or EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS set.\r
a6811666 823 @return EFI_OUT_OF_RESOURCES The Database to save the public key is full.\r
0130fdde 824 @return EFI_SECURITY_VIOLATION The variable is with EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS\r
a6811666
SZ		 825 set, but the AuthInfo does NOT pass the validation\r
826 check carried out by the firmware.\r
827 @return EFI_SUCCESS Variable is not write-protected or pass validation successfully.\r
828\r
829**/\r
830EFI_STATUS\r
831ProcessVariable (\r
832 IN CHAR16 *VariableName,\r
833 IN EFI_GUID *VendorGuid,\r
834 IN VOID *Data,\r
835 IN UINTN DataSize,\r
98c2d961 836 IN UINT32 Attributes\r
a6811666
SZ		 837 )\r
838{\r
839 EFI_STATUS Status;\r
a6811666
SZ		 840 AUTH_VARIABLE_INFO OrgVariableInfo;\r
841\r
a6811666
SZ		 842 Status = EFI_SUCCESS;\r
843\r
844 ZeroMem (&OrgVariableInfo, sizeof (OrgVariableInfo));\r
845 Status = mAuthVarLibContextIn->FindVariable (\r
846 VariableName,\r
847 VendorGuid,\r
848 &OrgVariableInfo\r
849 );\r
850\r
76bfc7e3 851 if ((!EFI_ERROR (Status)) && IsDeleteAuthVariable (OrgVariableInfo.Attributes, Data, DataSize, Attributes) && UserPhysicalPresent()) {\r
a6811666 852 //\r
0130fdde 853 // Allow the delete operation of common authenticated variable(AT or AW) at user physical presence.\r
a6811666 854 //\r
64b6a3ff
CZ		 855 Status = AuthServiceInternalUpdateVariable (\r
856 VariableName,\r
857 VendorGuid,\r
858 NULL,\r
859 0,\r
860 0\r
861 );\r
862 if (!EFI_ERROR (Status) && ((Attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) != 0)) {\r
98c2d961 863 Status = DeleteCertsFromDb (VariableName, VendorGuid, Attributes);\r
a6811666 864 }\r
64b6a3ff 865\r
a6811666
SZ		 866 return Status;\r
867 }\r
868\r
76bfc7e3 869 if (NeedPhysicallyPresent (VariableName, VendorGuid) && !UserPhysicalPresent()) {\r
a6811666
SZ		 870 //\r
871 // This variable is protected, only physical present user could modify its value.\r
872 //\r
873 return EFI_SECURITY_VIOLATION;\r
874 }\r
875\r
876 //\r
0130fdde
ZC		 877 if ((Attributes & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) != 0) {\r
878 //\r
879 // Reject Counter Based Auth Variable processing request.\r
880 //\r
881 return EFI_UNSUPPORTED;\r
882 } else if ((Attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) != 0) {\r
883 //\r
884 // Process Time-based Authenticated variable.\r
885 //\r
a6811666
SZ		 886 return VerifyTimeBasedPayloadAndUpdate (\r
887 VariableName,\r
888 VendorGuid,\r
889 Data,\r
890 DataSize,\r
891 Attributes,\r
892 AuthVarTypePriv,\r
893 NULL\r
894 );\r
895 }\r
896\r
0130fdde
ZC		 897 if ((OrgVariableInfo.Data != NULL) &&\r
898 ((OrgVariableInfo.Attributes & (EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS)) != 0)) {\r
a6811666
SZ		 899 //\r
900 // If the variable is already write-protected, it always needs authentication before update.\r
901 //\r
902 return EFI_WRITE_PROTECTED;\r
a6811666
SZ		 903 }\r
904\r
905 //\r
0130fdde 906 // Not authenticated variable, just update variable as usual.\r
a6811666 907 //\r
0130fdde
ZC		 908 Status = AuthServiceInternalUpdateVariable (VariableName, VendorGuid, Data, DataSize, Attributes);\r
909 return Status;\r
a6811666 910\r
a6811666
SZ		 911}\r
912\r
913/**\r
914 Filter out the duplicated EFI_SIGNATURE_DATA from the new data by comparing to the original data.\r
915\r
916 @param[in] Data Pointer to original EFI_SIGNATURE_LIST.\r
917 @param[in] DataSize Size of Data buffer.\r
918 @param[in, out] NewData Pointer to new EFI_SIGNATURE_LIST.\r
919 @param[in, out] NewDataSize Size of NewData buffer.\r
920\r
921**/\r
922EFI_STATUS\r
923FilterSignatureList (\r
924 IN VOID *Data,\r
925 IN UINTN DataSize,\r
926 IN OUT VOID *NewData,\r
927 IN OUT UINTN *NewDataSize\r
928 )\r
929{\r
930 EFI_SIGNATURE_LIST *CertList;\r
931 EFI_SIGNATURE_DATA *Cert;\r
932 UINTN CertCount;\r
933 EFI_SIGNATURE_LIST *NewCertList;\r
934 EFI_SIGNATURE_DATA *NewCert;\r
935 UINTN NewCertCount;\r
936 UINTN Index;\r
937 UINTN Index2;\r
938 UINTN Size;\r
939 UINT8 *Tail;\r
940 UINTN CopiedCount;\r
941 UINTN SignatureListSize;\r
942 BOOLEAN IsNewCert;\r
943 UINT8 *TempData;\r
944 UINTN TempDataSize;\r
945 EFI_STATUS Status;\r
946\r
947 if (*NewDataSize == 0) {\r
948 return EFI_SUCCESS;\r
949 }\r
950\r
951 TempDataSize = *NewDataSize;\r
952 Status = mAuthVarLibContextIn->GetScratchBuffer (&TempDataSize, (VOID **) &TempData);\r
953 if (EFI_ERROR (Status)) {\r
954 return EFI_OUT_OF_RESOURCES;\r
955 }\r
956\r
957 Tail = TempData;\r
958\r
959 NewCertList = (EFI_SIGNATURE_LIST *) NewData;\r
960 while ((*NewDataSize > 0) && (*NewDataSize >= NewCertList->SignatureListSize)) {\r
961 NewCert = (EFI_SIGNATURE_DATA *) ((UINT8 *) NewCertList + sizeof (EFI_SIGNATURE_LIST) + NewCertList->SignatureHeaderSize);\r
962 NewCertCount = (NewCertList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - NewCertList->SignatureHeaderSize) / NewCertList->SignatureSize;\r
963\r
964 CopiedCount = 0;\r
965 for (Index = 0; Index < NewCertCount; Index++) {\r
966 IsNewCert = TRUE;\r
967\r
968 Size = DataSize;\r
969 CertList = (EFI_SIGNATURE_LIST *) Data;\r
970 while ((Size > 0) && (Size >= CertList->SignatureListSize)) {\r
971 if (CompareGuid (&CertList->SignatureType, &NewCertList->SignatureType) &&\r
972 (CertList->SignatureSize == NewCertList->SignatureSize)) {\r
973 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertList + sizeof (EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);\r
974 CertCount = (CertList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - CertList->SignatureHeaderSize) / CertList->SignatureSize;\r
975 for (Index2 = 0; Index2 < CertCount; Index2++) {\r
976 //\r
977 // Iterate each Signature Data in this Signature List.\r
978 //\r
979 if (CompareMem (NewCert, Cert, CertList->SignatureSize) == 0) {\r
980 IsNewCert = FALSE;\r
981 break;\r
982 }\r
983 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) Cert + CertList->SignatureSize);\r
984 }\r
985 }\r
986\r
987 if (!IsNewCert) {\r
988 break;\r
989 }\r
990 Size -= CertList->SignatureListSize;\r
991 CertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) CertList + CertList->SignatureListSize);\r
992 }\r
993\r
994 if (IsNewCert) {\r
995 //\r
996 // New EFI_SIGNATURE_DATA, keep it.\r
997 //\r
998 if (CopiedCount == 0) {\r
999 //\r
1000 // Copy EFI_SIGNATURE_LIST header for only once.\r
1001 //\r
1002 CopyMem (Tail, NewCertList, sizeof (EFI_SIGNATURE_LIST) + NewCertList->SignatureHeaderSize);\r
1003 Tail = Tail + sizeof (EFI_SIGNATURE_LIST) + NewCertList->SignatureHeaderSize;\r
1004 }\r
1005\r
1006 CopyMem (Tail, NewCert, NewCertList->SignatureSize);\r
1007 Tail += NewCertList->SignatureSize;\r
1008 CopiedCount++;\r
1009 }\r
1010\r
1011 NewCert = (EFI_SIGNATURE_DATA *) ((UINT8 *) NewCert + NewCertList->SignatureSize);\r
1012 }\r
1013\r
1014 //\r
1015 // Update SignatureListSize in the kept EFI_SIGNATURE_LIST.\r
1016 //\r
1017 if (CopiedCount != 0) {\r
1018 SignatureListSize = sizeof (EFI_SIGNATURE_LIST) + NewCertList->SignatureHeaderSize + (CopiedCount * NewCertList->SignatureSize);\r
1019 CertList = (EFI_SIGNATURE_LIST *) (Tail - SignatureListSize);\r
1020 CertList->SignatureListSize = (UINT32) SignatureListSize;\r
1021 }\r
1022\r
1023 *NewDataSize -= NewCertList->SignatureListSize;\r
1024 NewCertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) NewCertList + NewCertList->SignatureListSize);\r
1025 }\r
1026\r
1027 TempDataSize = (Tail - (UINT8 *) TempData);\r
1028\r
1029 CopyMem (NewData, TempData, TempDataSize);\r
1030 *NewDataSize = TempDataSize;\r
1031\r
1032 return EFI_SUCCESS;\r
1033}\r
1034\r
1035/**\r
1036 Compare two EFI_TIME data.\r
1037\r
1038\r
1039 @param FirstTime A pointer to the first EFI_TIME data.\r
1040 @param SecondTime A pointer to the second EFI_TIME data.\r
1041\r
1042 @retval TRUE The FirstTime is not later than the SecondTime.\r
1043 @retval FALSE The FirstTime is later than the SecondTime.\r
1044\r
1045**/\r
1046BOOLEAN\r
1047AuthServiceInternalCompareTimeStamp (\r
1048 IN EFI_TIME *FirstTime,\r
1049 IN EFI_TIME *SecondTime\r
1050 )\r
1051{\r
1052 if (FirstTime->Year != SecondTime->Year) {\r
1053 return (BOOLEAN) (FirstTime->Year < SecondTime->Year);\r
1054 } else if (FirstTime->Month != SecondTime->Month) {\r
1055 return (BOOLEAN) (FirstTime->Month < SecondTime->Month);\r
1056 } else if (FirstTime->Day != SecondTime->Day) {\r
1057 return (BOOLEAN) (FirstTime->Day < SecondTime->Day);\r
1058 } else if (FirstTime->Hour != SecondTime->Hour) {\r
1059 return (BOOLEAN) (FirstTime->Hour < SecondTime->Hour);\r
1060 } else if (FirstTime->Minute != SecondTime->Minute) {\r
1061 return (BOOLEAN) (FirstTime->Minute < SecondTime->Minute);\r
1062 }\r
1063\r
1064 return (BOOLEAN) (FirstTime->Second <= SecondTime->Second);\r
1065}\r
1066\r
53c6ff18
ZC		 1067/**\r
1068 Calculate SHA256 digest of SignerCert CommonName + ToplevelCert tbsCertificate\r
1069 SignerCert and ToplevelCert are inside the signer certificate chain.\r
1070\r
1071 @param[in] SignerCert A pointer to SignerCert data.\r
1072 @param[in] SignerCertSize Length of SignerCert data.\r
1073 @param[in] TopLevelCert A pointer to TopLevelCert data.\r
1074 @param[in] TopLevelCertSize Length of TopLevelCert data.\r
1075 @param[out] Sha256Digest Sha256 digest calculated.\r
1076\r
1077 @return EFI_ABORTED Digest process failed.\r
1078 @return EFI_SUCCESS SHA256 Digest is succesfully calculated.\r
1079\r
1080**/\r
1081EFI_STATUS\r
1082CalculatePrivAuthVarSignChainSHA256Digest(\r
1083 IN UINT8 *SignerCert,\r
1084 IN UINTN SignerCertSize,\r
1085 IN UINT8 *TopLevelCert,\r
1086 IN UINTN TopLevelCertSize,\r
1087 OUT UINT8 *Sha256Digest\r
1088 )\r
1089{\r
1090 UINT8 *TbsCert;\r
1091 UINTN TbsCertSize;\r
11b74aa4 1092 CHAR8 CertCommonName[128];\r
53c6ff18
ZC		 1093 UINTN CertCommonNameSize;\r
1094 BOOLEAN CryptoStatus;\r
1095 EFI_STATUS Status;\r
1096\r
1097 CertCommonNameSize = sizeof(CertCommonName);\r
1098\r
1099 //\r
1100 // Get SignerCert CommonName\r
1101 //\r
1102 Status = X509GetCommonName(SignerCert, SignerCertSize, CertCommonName, &CertCommonNameSize);\r
1103 if (EFI_ERROR(Status)) {\r
1104 DEBUG((DEBUG_INFO, "%a Get SignerCert CommonName failed with status %x\n", __FUNCTION__, Status));\r
1105 return EFI_ABORTED;\r
1106 }\r
1107\r
1108 //\r
1109 // Get TopLevelCert tbsCertificate\r
1110 //\r
1111 if (!X509GetTBSCert(TopLevelCert, TopLevelCertSize, &TbsCert, &TbsCertSize)) {\r
1112 DEBUG((DEBUG_INFO, "%a Get Top-level Cert tbsCertificate failed!\n", __FUNCTION__));\r
1113 return EFI_ABORTED;\r
1114 }\r
1115\r
1116 //\r
1117 // Digest SignerCert CN + TopLevelCert tbsCertificate\r
1118 //\r
1119 ZeroMem (Sha256Digest, SHA256_DIGEST_SIZE);\r
1120 CryptoStatus = Sha256Init (mHashCtx);\r
1121 if (!CryptoStatus) {\r
1122 return EFI_ABORTED;\r
1123 }\r
1124\r
1125 //\r
1126 // '\0' is forced in CertCommonName. No overflow issue\r
1127 //\r
11b74aa4
LE		 1128 CryptoStatus = Sha256Update (\r
1129 mHashCtx,\r
1130 CertCommonName,\r
1131 AsciiStrLen (CertCommonName)\r
1132 );\r
53c6ff18
ZC		 1133 if (!CryptoStatus) {\r
1134 return EFI_ABORTED;\r
1135 }\r
1136\r
1137 CryptoStatus = Sha256Update (mHashCtx, TbsCert, TbsCertSize);\r
1138 if (!CryptoStatus) {\r
1139 return EFI_ABORTED;\r
1140 }\r
1141\r
1142 CryptoStatus = Sha256Final (mHashCtx, Sha256Digest);\r
1143 if (!CryptoStatus) {\r
1144 return EFI_ABORTED;\r
1145 }\r
1146\r
1147 return EFI_SUCCESS;\r
1148}\r
1149\r
a6811666
SZ		 1150/**\r
1151 Find matching signer's certificates for common authenticated variable\r
98c2d961 1152 by corresponding VariableName and VendorGuid from "certdb" or "certdbv".\r
a6811666 1153\r
98c2d961 1154 The data format of "certdb" or "certdbv":\r
a6811666
SZ		 1155 //\r
1156 // UINT32 CertDbListSize;\r
1157 // /// AUTH_CERT_DB_DATA Certs1[];\r
1158 // /// AUTH_CERT_DB_DATA Certs2[];\r
1159 // /// ...\r
1160 // /// AUTH_CERT_DB_DATA Certsn[];\r
1161 //\r
1162\r
1163 @param[in] VariableName Name of authenticated Variable.\r
1164 @param[in] VendorGuid Vendor GUID of authenticated Variable.\r
98c2d961
CZ		 1165 @param[in] Data Pointer to variable "certdb" or "certdbv".\r
1166 @param[in] DataSize Size of variable "certdb" or "certdbv".\r
a6811666
SZ		 1167 @param[out] CertOffset Offset of matching CertData, from starting of Data.\r
1168 @param[out] CertDataSize Length of CertData in bytes.\r
1169 @param[out] CertNodeOffset Offset of matching AUTH_CERT_DB_DATA , from\r
1170 starting of Data.\r
1171 @param[out] CertNodeSize Length of AUTH_CERT_DB_DATA in bytes.\r
1172\r
1173 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.\r
1174 @retval EFI_NOT_FOUND Fail to find matching certs.\r
1175 @retval EFI_SUCCESS Find matching certs and output parameters.\r
1176\r
1177**/\r
1178EFI_STATUS\r
1179FindCertsFromDb (\r
1180 IN CHAR16 *VariableName,\r
1181 IN EFI_GUID *VendorGuid,\r
1182 IN UINT8 *Data,\r
1183 IN UINTN DataSize,\r
1184 OUT UINT32 *CertOffset, OPTIONAL\r
1185 OUT UINT32 *CertDataSize, OPTIONAL\r
1186 OUT UINT32 *CertNodeOffset,OPTIONAL\r
1187 OUT UINT32 *CertNodeSize OPTIONAL\r
1188 )\r
1189{\r
1190 UINT32 Offset;\r
1191 AUTH_CERT_DB_DATA *Ptr;\r
1192 UINT32 CertSize;\r
1193 UINT32 NameSize;\r
1194 UINT32 NodeSize;\r
1195 UINT32 CertDbListSize;\r
1196\r
1197 if ((VariableName == NULL) || (VendorGuid == NULL) || (Data == NULL)) {\r
1198 return EFI_INVALID_PARAMETER;\r
1199 }\r
1200\r
1201 //\r
1202 // Check whether DataSize matches recorded CertDbListSize.\r
1203 //\r
1204 if (DataSize < sizeof (UINT32)) {\r
1205 return EFI_INVALID_PARAMETER;\r
1206 }\r
1207\r
1208 CertDbListSize = ReadUnaligned32 ((UINT32 *) Data);\r
1209\r
1210 if (CertDbListSize != (UINT32) DataSize) {\r
1211 return EFI_INVALID_PARAMETER;\r
1212 }\r
1213\r
1214 Offset = sizeof (UINT32);\r
1215\r
1216 //\r
1217 // Get corresponding certificates by VendorGuid and VariableName.\r
1218 //\r
1219 while (Offset < (UINT32) DataSize) {\r
1220 Ptr = (AUTH_CERT_DB_DATA *) (Data + Offset);\r
1221 //\r
1222 // Check whether VendorGuid matches.\r
1223 //\r
1224 if (CompareGuid (&Ptr->VendorGuid, VendorGuid)) {\r
1225 NodeSize = ReadUnaligned32 (&Ptr->CertNodeSize);\r
1226 NameSize = ReadUnaligned32 (&Ptr->NameSize);\r
1227 CertSize = ReadUnaligned32 (&Ptr->CertDataSize);\r
1228\r
1229 if (NodeSize != sizeof (EFI_GUID) + sizeof (UINT32) * 3 + CertSize +\r
1230 sizeof (CHAR16) * NameSize) {\r
1231 return EFI_INVALID_PARAMETER;\r
1232 }\r
1233\r
1234 Offset = Offset + sizeof (EFI_GUID) + sizeof (UINT32) * 3;\r
1235 //\r
1236 // Check whether VariableName matches.\r
1237 //\r
1238 if ((NameSize == StrLen (VariableName)) &&\r
1239 (CompareMem (Data + Offset, VariableName, NameSize * sizeof (CHAR16)) == 0)) {\r
1240 Offset = Offset + NameSize * sizeof (CHAR16);\r
1241\r
1242 if (CertOffset != NULL) {\r
1243 *CertOffset = Offset;\r
1244 }\r
1245\r
1246 if (CertDataSize != NULL) {\r
1247 *CertDataSize = CertSize;\r
1248 }\r
1249\r
1250 if (CertNodeOffset != NULL) {\r
1251 *CertNodeOffset = (UINT32) ((UINT8 *) Ptr - Data);\r
1252 }\r
1253\r
1254 if (CertNodeSize != NULL) {\r
1255 *CertNodeSize = NodeSize;\r
1256 }\r
1257\r
1258 return EFI_SUCCESS;\r
1259 } else {\r
1260 Offset = Offset + NameSize * sizeof (CHAR16) + CertSize;\r
1261 }\r
1262 } else {\r
1263 NodeSize = ReadUnaligned32 (&Ptr->CertNodeSize);\r
1264 Offset = Offset + NodeSize;\r
1265 }\r
1266 }\r
1267\r
1268 return EFI_NOT_FOUND;\r
1269}\r
1270\r
1271/**\r
1272 Retrieve signer's certificates for common authenticated variable\r
98c2d961
CZ		 1273 by corresponding VariableName and VendorGuid from "certdb"\r
1274 or "certdbv" according to authenticated variable attributes.\r
a6811666
SZ		 1275\r
1276 @param[in] VariableName Name of authenticated Variable.\r
1277 @param[in] VendorGuid Vendor GUID of authenticated Variable.\r
98c2d961 1278 @param[in] Attributes Attributes of authenticated variable.\r
a6811666
SZ		 1279 @param[out] CertData Pointer to signer's certificates.\r
1280 @param[out] CertDataSize Length of CertData in bytes.\r
1281\r
1282 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.\r
98c2d961 1283 @retval EFI_NOT_FOUND Fail to find "certdb"/"certdbv" or matching certs.\r
a6811666
SZ		 1284 @retval EFI_SUCCESS Get signer's certificates successfully.\r
1285\r
1286**/\r
1287EFI_STATUS\r
1288GetCertsFromDb (\r
1289 IN CHAR16 *VariableName,\r
1290 IN EFI_GUID *VendorGuid,\r
98c2d961 1291 IN UINT32 Attributes,\r
a6811666
SZ		 1292 OUT UINT8 **CertData,\r
1293 OUT UINT32 *CertDataSize\r
1294 )\r
1295{\r
1296 EFI_STATUS Status;\r
1297 UINT8 *Data;\r
1298 UINTN DataSize;\r
1299 UINT32 CertOffset;\r
98c2d961 1300 CHAR16 *DbName;\r
a6811666
SZ		 1301\r
1302 if ((VariableName == NULL) || (VendorGuid == NULL) || (CertData == NULL) || (CertDataSize == NULL)) {\r
1303 return EFI_INVALID_PARAMETER;\r
1304 }\r
1305\r
98c2d961
CZ		 1306 \r
1307 if ((Attributes & EFI_VARIABLE_NON_VOLATILE) != 0) {\r
1308 //\r
1309 // Get variable "certdb".\r
1310 //\r
1311 DbName = EFI_CERT_DB_NAME;\r
1312 } else {\r
1313 //\r
1314 // Get variable "certdbv".\r
1315 //\r
1316 DbName = EFI_CERT_DB_VOLATILE_NAME;\r
1317 }\r
1318\r
a6811666 1319 //\r
98c2d961 1320 // Get variable "certdb" or "certdbv".\r
a6811666
SZ		 1321 //\r
1322 Status = AuthServiceInternalFindVariable (\r
98c2d961 1323 DbName,\r
a6811666
SZ		 1324 &gEfiCertDbGuid,\r
1325 (VOID **) &Data,\r
1326 &DataSize\r
1327 );\r
1328 if (EFI_ERROR (Status)) {\r
1329 return Status;\r
1330 }\r
1331\r
1332 if ((DataSize == 0) || (Data == NULL)) {\r
1333 ASSERT (FALSE);\r
1334 return EFI_NOT_FOUND;\r
1335 }\r
1336\r
1337 Status = FindCertsFromDb (\r
1338 VariableName,\r
1339 VendorGuid,\r
1340 Data,\r
1341 DataSize,\r
1342 &CertOffset,\r
1343 CertDataSize,\r
1344 NULL,\r
1345 NULL\r
1346 );\r
1347\r
1348 if (EFI_ERROR (Status)) {\r
1349 return Status;\r
1350 }\r
1351\r
1352 *CertData = Data + CertOffset;\r
1353 return EFI_SUCCESS;\r
1354}\r
1355\r
1356/**\r
1357 Delete matching signer's certificates when deleting common authenticated\r
98c2d961
CZ		 1358 variable by corresponding VariableName and VendorGuid from "certdb" or \r
1359 "certdbv" according to authenticated variable attributes.\r
a6811666
SZ		 1360\r
1361 @param[in] VariableName Name of authenticated Variable.\r
1362 @param[in] VendorGuid Vendor GUID of authenticated Variable.\r
98c2d961 1363 @param[in] Attributes Attributes of authenticated variable.\r
a6811666
SZ		 1364\r
1365 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.\r
98c2d961 1366 @retval EFI_NOT_FOUND Fail to find "certdb"/"certdbv" or matching certs.\r
a6811666
SZ		 1367 @retval EFI_OUT_OF_RESOURCES The operation is failed due to lack of resources.\r
1368 @retval EFI_SUCCESS The operation is completed successfully.\r
1369\r
1370**/\r
1371EFI_STATUS\r
1372DeleteCertsFromDb (\r
1373 IN CHAR16 *VariableName,\r
98c2d961
CZ		 1374 IN EFI_GUID *VendorGuid,\r
1375 IN UINT32 Attributes\r
a6811666
SZ		 1376 )\r
1377{\r
1378 EFI_STATUS Status;\r
1379 UINT8 *Data;\r
1380 UINTN DataSize;\r
1381 UINT32 VarAttr;\r
1382 UINT32 CertNodeOffset;\r
1383 UINT32 CertNodeSize;\r
1384 UINT8 *NewCertDb;\r
1385 UINT32 NewCertDbSize;\r
98c2d961 1386 CHAR16 *DbName;\r
a6811666
SZ		 1387\r
1388 if ((VariableName == NULL) || (VendorGuid == NULL)) {\r
1389 return EFI_INVALID_PARAMETER;\r
1390 }\r
1391\r
98c2d961
CZ		 1392 if ((Attributes & EFI_VARIABLE_NON_VOLATILE) != 0) {\r
1393 //\r
1394 // Get variable "certdb".\r
1395 //\r
1396 DbName = EFI_CERT_DB_NAME;\r
1397 VarAttr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS;\r
1398 } else {\r
1399 //\r
1400 // Get variable "certdbv".\r
1401 //\r
1402 DbName = EFI_CERT_DB_VOLATILE_NAME;\r
1403 VarAttr = EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS;\r
1404 }\r
1405\r
a6811666 1406 Status = AuthServiceInternalFindVariable (\r
98c2d961 1407 DbName,\r
a6811666
SZ		 1408 &gEfiCertDbGuid,\r
1409 (VOID **) &Data,\r
1410 &DataSize\r
1411 );\r
98c2d961 1412\r
a6811666
SZ		 1413 if (EFI_ERROR (Status)) {\r
1414 return Status;\r
1415 }\r
1416\r
1417 if ((DataSize == 0) || (Data == NULL)) {\r
1418 ASSERT (FALSE);\r
1419 return EFI_NOT_FOUND;\r
1420 }\r
1421\r
1422 if (DataSize == sizeof (UINT32)) {\r
1423 //\r
98c2d961 1424 // There is no certs in "certdb" or "certdbv".\r
a6811666
SZ		 1425 //\r
1426 return EFI_SUCCESS;\r
1427 }\r
1428\r
1429 //\r
98c2d961 1430 // Get corresponding cert node from "certdb" or "certdbv".\r
a6811666
SZ		 1431 //\r
1432 Status = FindCertsFromDb (\r
1433 VariableName,\r
1434 VendorGuid,\r
1435 Data,\r
1436 DataSize,\r
1437 NULL,\r
1438 NULL,\r
1439 &CertNodeOffset,\r
1440 &CertNodeSize\r
1441 );\r
1442\r
1443 if (EFI_ERROR (Status)) {\r
1444 return Status;\r
1445 }\r
1446\r
1447 if (DataSize < (CertNodeOffset + CertNodeSize)) {\r
1448 return EFI_NOT_FOUND;\r
1449 }\r
1450\r
1451 //\r
98c2d961 1452 // Construct new data content of variable "certdb" or "certdbv".\r
a6811666
SZ		 1453 //\r
1454 NewCertDbSize = (UINT32) DataSize - CertNodeSize;\r
1455 NewCertDb = (UINT8*) mCertDbStore;\r
1456\r
1457 //\r
1458 // Copy the DB entries before deleting node.\r
1459 //\r
1460 CopyMem (NewCertDb, Data, CertNodeOffset);\r
1461 //\r
1462 // Update CertDbListSize.\r
1463 //\r
1464 CopyMem (NewCertDb, &NewCertDbSize, sizeof (UINT32));\r
1465 //\r
1466 // Copy the DB entries after deleting node.\r
1467 //\r
1468 if (DataSize > (CertNodeOffset + CertNodeSize)) {\r
1469 CopyMem (\r
1470 NewCertDb + CertNodeOffset,\r
1471 Data + CertNodeOffset + CertNodeSize,\r
1472 DataSize - CertNodeOffset - CertNodeSize\r
1473 );\r
1474 }\r
1475\r
1476 //\r
98c2d961 1477 // Set "certdb" or "certdbv".\r
a6811666 1478 //\r
a6811666 1479 Status = AuthServiceInternalUpdateVariable (\r
98c2d961 1480 DbName,\r
a6811666
SZ		 1481 &gEfiCertDbGuid,\r
1482 NewCertDb,\r
1483 NewCertDbSize,\r
1484 VarAttr\r
1485 );\r
1486\r
1487 return Status;\r
1488}\r
1489\r
1490/**\r
1491 Insert signer's certificates for common authenticated variable with VariableName\r
98c2d961 1492 and VendorGuid in AUTH_CERT_DB_DATA to "certdb" or "certdbv" according to\r
53c6ff18
ZC		 1493 time based authenticated variable attributes. CertData is the SHA256 digest of\r
1494 SignerCert CommonName + TopLevelCert tbsCertificate.\r
a6811666 1495\r
53c6ff18
ZC		 1496 @param[in] VariableName Name of authenticated Variable.\r
1497 @param[in] VendorGuid Vendor GUID of authenticated Variable.\r
1498 @param[in] Attributes Attributes of authenticated variable.\r
1499 @param[in] SignerCert Signer certificate data.\r
1500 @param[in] SignerCertSize Length of signer certificate.\r
1501 @param[in] TopLevelCert Top-level certificate data.\r
1502 @param[in] TopLevelCertSize Length of top-level certificate.\r
a6811666
SZ		 1503\r
1504 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.\r
1505 @retval EFI_ACCESS_DENIED An AUTH_CERT_DB_DATA entry with same VariableName\r
1506 and VendorGuid already exists.\r
1507 @retval EFI_OUT_OF_RESOURCES The operation is failed due to lack of resources.\r
98c2d961 1508 @retval EFI_SUCCESS Insert an AUTH_CERT_DB_DATA entry to "certdb" or "certdbv"\r
a6811666
SZ		 1509\r
1510**/\r
1511EFI_STATUS\r
1512InsertCertsToDb (\r
1513 IN CHAR16 *VariableName,\r
1514 IN EFI_GUID *VendorGuid,\r
98c2d961 1515 IN UINT32 Attributes,\r
53c6ff18
ZC		 1516 IN UINT8 *SignerCert,\r
1517 IN UINTN SignerCertSize,\r
1518 IN UINT8 *TopLevelCert,\r
1519 IN UINTN TopLevelCertSize\r
a6811666
SZ		 1520 )\r
1521{\r
1522 EFI_STATUS Status;\r
1523 UINT8 *Data;\r
1524 UINTN DataSize;\r
1525 UINT32 VarAttr;\r
1526 UINT8 *NewCertDb;\r
1527 UINT32 NewCertDbSize;\r
1528 UINT32 CertNodeSize;\r
1529 UINT32 NameSize;\r
53c6ff18 1530 UINT32 CertDataSize;\r
a6811666 1531 AUTH_CERT_DB_DATA *Ptr;\r
98c2d961 1532 CHAR16 *DbName;\r
53c6ff18 1533 UINT8 Sha256Digest[SHA256_DIGEST_SIZE];\r
a6811666 1534\r
53c6ff18 1535 if ((VariableName == NULL) || (VendorGuid == NULL) || (SignerCert == NULL) ||(TopLevelCert == NULL)) {\r
a6811666
SZ		 1536 return EFI_INVALID_PARAMETER;\r
1537 }\r
1538\r
98c2d961
CZ		 1539 if ((Attributes & EFI_VARIABLE_NON_VOLATILE) != 0) {\r
1540 //\r
1541 // Get variable "certdb".\r
1542 //\r
1543 DbName = EFI_CERT_DB_NAME;\r
1544 VarAttr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS;\r
1545 } else {\r
1546 //\r
1547 // Get variable "certdbv".\r
1548 //\r
1549 DbName = EFI_CERT_DB_VOLATILE_NAME;\r
1550 VarAttr = EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS;\r
1551 }\r
1552\r
a6811666 1553 //\r
98c2d961 1554 // Get variable "certdb" or "certdbv".\r
a6811666
SZ		 1555 //\r
1556 Status = AuthServiceInternalFindVariable (\r
98c2d961 1557 DbName,\r
a6811666
SZ		 1558 &gEfiCertDbGuid,\r
1559 (VOID **) &Data,\r
1560 &DataSize\r
1561 );\r
1562 if (EFI_ERROR (Status)) {\r
1563 return Status;\r
1564 }\r
1565\r
1566 if ((DataSize == 0) || (Data == NULL)) {\r
1567 ASSERT (FALSE);\r
1568 return EFI_NOT_FOUND;\r
1569 }\r
1570\r
1571 //\r
98c2d961 1572 // Find whether matching cert node already exists in "certdb" or "certdbv".\r
a6811666
SZ		 1573 // If yes return error.\r
1574 //\r
1575 Status = FindCertsFromDb (\r
1576 VariableName,\r
1577 VendorGuid,\r
1578 Data,\r
1579 DataSize,\r
1580 NULL,\r
1581 NULL,\r
1582 NULL,\r
1583 NULL\r
1584 );\r
1585\r
1586 if (!EFI_ERROR (Status)) {\r
1587 ASSERT (FALSE);\r
1588 return EFI_ACCESS_DENIED;\r
1589 }\r
1590\r
1591 //\r
98c2d961 1592 // Construct new data content of variable "certdb" or "certdbv".\r
a6811666
SZ		 1593 //\r
1594 NameSize = (UINT32) StrLen (VariableName);\r
53c6ff18 1595 CertDataSize = sizeof(Sha256Digest);\r
a6811666
SZ		 1596 CertNodeSize = sizeof (AUTH_CERT_DB_DATA) + (UINT32) CertDataSize + NameSize * sizeof (CHAR16);\r
1597 NewCertDbSize = (UINT32) DataSize + CertNodeSize;\r
1598 if (NewCertDbSize > mMaxCertDbSize) {\r
1599 return EFI_OUT_OF_RESOURCES;\r
1600 }\r
53c6ff18
ZC		 1601\r
1602 Status = CalculatePrivAuthVarSignChainSHA256Digest(\r
1603 SignerCert,\r
1604 SignerCertSize,\r
1605 TopLevelCert,\r
1606 TopLevelCertSize,\r
1607 Sha256Digest\r
1608 );\r
1609 if (EFI_ERROR (Status)) {\r
1610 return Status;\r
1611 }\r
1612\r
a6811666
SZ		 1613 NewCertDb = (UINT8*) mCertDbStore;\r
1614\r
1615 //\r
1616 // Copy the DB entries before inserting node.\r
1617 //\r
1618 CopyMem (NewCertDb, Data, DataSize);\r
1619 //\r
1620 // Update CertDbListSize.\r
1621 //\r
1622 CopyMem (NewCertDb, &NewCertDbSize, sizeof (UINT32));\r
1623 //\r
1624 // Construct new cert node.\r
1625 //\r
1626 Ptr = (AUTH_CERT_DB_DATA *) (NewCertDb + DataSize);\r
1627 CopyGuid (&Ptr->VendorGuid, VendorGuid);\r
1628 CopyMem (&Ptr->CertNodeSize, &CertNodeSize, sizeof (UINT32));\r
1629 CopyMem (&Ptr->NameSize, &NameSize, sizeof (UINT32));\r
1630 CopyMem (&Ptr->CertDataSize, &CertDataSize, sizeof (UINT32));\r
1631\r
1632 CopyMem (\r
1633 (UINT8 *) Ptr + sizeof (AUTH_CERT_DB_DATA),\r
1634 VariableName,\r
1635 NameSize * sizeof (CHAR16)\r
1636 );\r
1637\r
1638 CopyMem (\r
1639 (UINT8 *) Ptr + sizeof (AUTH_CERT_DB_DATA) + NameSize * sizeof (CHAR16),\r
53c6ff18 1640 Sha256Digest,\r
a6811666
SZ		 1641 CertDataSize\r
1642 );\r
1643\r
1644 //\r
98c2d961 1645 // Set "certdb" or "certdbv".\r
a6811666 1646 //\r
a6811666 1647 Status = AuthServiceInternalUpdateVariable (\r
98c2d961 1648 DbName,\r
a6811666
SZ		 1649 &gEfiCertDbGuid,\r
1650 NewCertDb,\r
1651 NewCertDbSize,\r
1652 VarAttr\r
1653 );\r
1654\r
1655 return Status;\r
1656}\r
1657\r
64b6a3ff
CZ		 1658/**\r
1659 Clean up signer's certificates for common authenticated variable\r
1660 by corresponding VariableName and VendorGuid from "certdb".\r
f3964772
SZ		 1661 System may break down during Timebased Variable update & certdb update,\r
1662 make them inconsistent, this function is called in AuthVariable Init\r
1663 to ensure consistency.\r
1664\r
1665 @retval EFI_NOT_FOUND Fail to find variable "certdb".\r
1666 @retval EFI_OUT_OF_RESOURCES The operation is failed due to lack of resources.\r
1667 @retval EFI_SUCCESS The operation is completed successfully.\r
64b6a3ff
CZ		 1668\r
1669**/\r
1670EFI_STATUS\r
1671CleanCertsFromDb (\r
1672 VOID\r
72362a75
CZ		 1673 )\r
1674{\r
64b6a3ff
CZ		 1675 UINT32 Offset;\r
1676 AUTH_CERT_DB_DATA *Ptr;\r
1677 UINT32 NameSize;\r
1678 UINT32 NodeSize;\r
1679 CHAR16 *VariableName;\r
1680 EFI_STATUS Status;\r
1681 BOOLEAN CertCleaned;\r
1682 UINT8 *Data;\r
1683 UINTN DataSize;\r
64b6a3ff 1684 EFI_GUID AuthVarGuid;\r
98c2d961 1685 AUTH_VARIABLE_INFO AuthVariableInfo;\r
64b6a3ff
CZ		 1686\r
1687 Status = EFI_SUCCESS;\r
1688\r
1689 //\r
1690 // Get corresponding certificates by VendorGuid and VariableName.\r
1691 //\r
1692 do {\r
1693 CertCleaned = FALSE;\r
1694\r
1695 //\r
1696 // Get latest variable "certdb"\r
1697 //\r
1698 Status = AuthServiceInternalFindVariable (\r
1699 EFI_CERT_DB_NAME,\r
1700 &gEfiCertDbGuid,\r
1701 (VOID **) &Data,\r
1702 &DataSize\r
1703 );\r
1704 if (EFI_ERROR (Status)) {\r
1705 return Status;\r
1706 }\r
1707\r
1708 if ((DataSize == 0) || (Data == NULL)) {\r
1709 ASSERT (FALSE);\r
1710 return EFI_NOT_FOUND;\r
1711 }\r
1712\r
1713 Offset = sizeof (UINT32);\r
1714\r
1715 while (Offset < (UINT32) DataSize) {\r
1716 Ptr = (AUTH_CERT_DB_DATA *) (Data + Offset);\r
64b6a3ff
CZ		 1717 NodeSize = ReadUnaligned32 (&Ptr->CertNodeSize);\r
1718 NameSize = ReadUnaligned32 (&Ptr->NameSize);\r
1719\r
1720 //\r
1721 // Get VarName tailed with '\0'\r
1722 //\r
1723 VariableName = AllocateZeroPool((NameSize + 1) * sizeof(CHAR16));\r
1724 if (VariableName == NULL) {\r
1725 return EFI_OUT_OF_RESOURCES;\r
1726 }\r
1727 CopyMem (VariableName, (UINT8 *) Ptr + sizeof (AUTH_CERT_DB_DATA), NameSize * sizeof(CHAR16));\r
1728 //\r
1729 // Keep VarGuid aligned\r
1730 //\r
1731 CopyMem (&AuthVarGuid, &Ptr->VendorGuid, sizeof(EFI_GUID));\r
1732\r
1733 //\r
1734 // Find corresponding time auth variable\r
1735 //\r
98c2d961
CZ		 1736 ZeroMem (&AuthVariableInfo, sizeof (AuthVariableInfo));\r
1737 Status = mAuthVarLibContextIn->FindVariable (\r
1738 VariableName,\r
1739 &AuthVarGuid,\r
1740 &AuthVariableInfo\r
1741 );\r
64b6a3ff 1742\r
fd4d9c64 1743 if (EFI_ERROR(Status) || (AuthVariableInfo.Attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) == 0) {\r
98c2d961
CZ		 1744 Status = DeleteCertsFromDb(\r
1745 VariableName,\r
1746 &AuthVarGuid,\r
1747 AuthVariableInfo.Attributes\r
1748 );\r
64b6a3ff
CZ		 1749 CertCleaned = TRUE;\r
1750 DEBUG((EFI_D_INFO, "Recovery!! Cert for Auth Variable %s Guid %g is removed for consistency\n", VariableName, &AuthVarGuid));\r
1751 FreePool(VariableName);\r
1752 break;\r
1753 }\r
1754\r
1755 FreePool(VariableName);\r
1756 Offset = Offset + NodeSize;\r
1757 }\r
1758 } while (CertCleaned);\r
1759\r
1760 return Status;\r
1761}\r
1762\r
a6811666
SZ		 1763/**\r
1764 Process variable with EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS set\r
1765\r
1766 Caution: This function may receive untrusted input.\r
1767 This function may be invoked in SMM mode, and datasize and data are external input.\r
1768 This function will do basic validation, before parse the data.\r
1769 This function will parse the authentication carefully to avoid security issues, like\r
1770 buffer overflow, integer overflow.\r
1771\r
1772 @param[in] VariableName Name of Variable to be found.\r
1773 @param[in] VendorGuid Variable vendor GUID.\r
1774 @param[in] Data Data pointer.\r
1775 @param[in] DataSize Size of Data found. If size is less than the\r
1776 data, this value contains the required size.\r
1777 @param[in] Attributes Attribute value of the variable.\r
1778 @param[in] AuthVarType Verify against PK, KEK database, private database or certificate in data payload.\r
1779 @param[in] OrgTimeStamp Pointer to original time stamp,\r
1780 original variable is not found if NULL.\r
1781 @param[out] VarPayloadPtr Pointer to variable payload address.\r
1782 @param[out] VarPayloadSize Pointer to variable payload size.\r
1783\r
1784 @retval EFI_INVALID_PARAMETER Invalid parameter.\r
1785 @retval EFI_SECURITY_VIOLATION The variable does NOT pass the validation\r
1786 check carried out by the firmware.\r
1787 @retval EFI_OUT_OF_RESOURCES Failed to process variable due to lack\r
1788 of resources.\r
1789 @retval EFI_SUCCESS Variable pass validation successfully.\r
1790\r
1791**/\r
1792EFI_STATUS\r
1793VerifyTimeBasedPayload (\r
1794 IN CHAR16 *VariableName,\r
1795 IN EFI_GUID *VendorGuid,\r
1796 IN VOID *Data,\r
1797 IN UINTN DataSize,\r
1798 IN UINT32 Attributes,\r
1799 IN AUTHVAR_TYPE AuthVarType,\r
1800 IN EFI_TIME *OrgTimeStamp,\r
1801 OUT UINT8 **VarPayloadPtr,\r
1802 OUT UINTN *VarPayloadSize\r
1803 )\r
1804{\r
1805 EFI_VARIABLE_AUTHENTICATION_2 *CertData;\r
1806 UINT8 *SigData;\r
1807 UINT32 SigDataSize;\r
1808 UINT8 *PayloadPtr;\r
1809 UINTN PayloadSize;\r
1810 UINT32 Attr;\r
1811 BOOLEAN VerifyStatus;\r
1812 EFI_STATUS Status;\r
1813 EFI_SIGNATURE_LIST *CertList;\r
1814 EFI_SIGNATURE_DATA *Cert;\r
1815 UINTN Index;\r
1816 UINTN CertCount;\r
1817 UINT32 KekDataSize;\r
1818 UINT8 *NewData;\r
1819 UINTN NewDataSize;\r
1820 UINT8 *Buffer;\r
1821 UINTN Length;\r
53c6ff18
ZC		 1822 UINT8 *TopLevelCert;\r
1823 UINTN TopLevelCertSize;\r
1824 UINT8 *TrustedCert;\r
1825 UINTN TrustedCertSize;\r
a6811666
SZ		 1826 UINT8 *SignerCerts;\r
1827 UINTN CertStackSize;\r
1828 UINT8 *CertsInCertDb;\r
1829 UINT32 CertsSizeinDb;\r
53c6ff18 1830 UINT8 Sha256Digest[SHA256_DIGEST_SIZE];\r
a6811666 1831\r
53c6ff18
ZC		 1832 //\r
1833 // 1. TopLevelCert is the top-level issuer certificate in signature Signer Cert Chain\r
1834 // 2. TrustedCert is the certificate which firmware trusts. It could be saved in protected\r
1835 // storage or PK payload on PK init\r
1836 //\r
a6811666
SZ		 1837 VerifyStatus = FALSE;\r
1838 CertData = NULL;\r
1839 NewData = NULL;\r
1840 Attr = Attributes;\r
1841 SignerCerts = NULL;\r
53c6ff18 1842 TopLevelCert = NULL;\r
a6811666
SZ		 1843 CertsInCertDb = NULL;\r
1844\r
1845 //\r
1846 // When the attribute EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS is\r
1847 // set, then the Data buffer shall begin with an instance of a complete (and serialized)\r
1848 // EFI_VARIABLE_AUTHENTICATION_2 descriptor. The descriptor shall be followed by the new\r
1849 // variable value and DataSize shall reflect the combined size of the descriptor and the new\r
1850 // variable value. The authentication descriptor is not part of the variable data and is not\r
1851 // returned by subsequent calls to GetVariable().\r
1852 //\r
1853 CertData = (EFI_VARIABLE_AUTHENTICATION_2 *) Data;\r
1854\r
1855 //\r
1856 // Verify that Pad1, Nanosecond, TimeZone, Daylight and Pad2 components of the\r
1857 // TimeStamp value are set to zero.\r
1858 //\r
1859 if ((CertData->TimeStamp.Pad1 != 0) ||\r
1860 (CertData->TimeStamp.Nanosecond != 0) ||\r
1861 (CertData->TimeStamp.TimeZone != 0) ||\r
1862 (CertData->TimeStamp.Daylight != 0) ||\r
1863 (CertData->TimeStamp.Pad2 != 0)) {\r
1864 return EFI_SECURITY_VIOLATION;\r
1865 }\r
1866\r
1867 if ((OrgTimeStamp != NULL) && ((Attributes & EFI_VARIABLE_APPEND_WRITE) == 0)) {\r
1868 if (AuthServiceInternalCompareTimeStamp (&CertData->TimeStamp, OrgTimeStamp)) {\r
1869 //\r
1870 // TimeStamp check fail, suspicious replay attack, return EFI_SECURITY_VIOLATION.\r
1871 //\r
1872 return EFI_SECURITY_VIOLATION;\r
1873 }\r
1874 }\r
1875\r
1876 //\r
1877 // wCertificateType should be WIN_CERT_TYPE_EFI_GUID.\r
1878 // Cert type should be EFI_CERT_TYPE_PKCS7_GUID.\r
1879 //\r
1880 if ((CertData->AuthInfo.Hdr.wCertificateType != WIN_CERT_TYPE_EFI_GUID) ||\r
1881 !CompareGuid (&CertData->AuthInfo.CertType, &gEfiCertPkcs7Guid)) {\r
1882 //\r
1883 // Invalid AuthInfo type, return EFI_SECURITY_VIOLATION.\r
1884 //\r
1885 return EFI_SECURITY_VIOLATION;\r
1886 }\r
1887\r
1888 //\r
1889 // Find out Pkcs7 SignedData which follows the EFI_VARIABLE_AUTHENTICATION_2 descriptor.\r
1890 // AuthInfo.Hdr.dwLength is the length of the entire certificate, including the length of the header.\r
1891 //\r
1892 SigData = CertData->AuthInfo.CertData;\r
1893 SigDataSize = CertData->AuthInfo.Hdr.dwLength - (UINT32) (OFFSET_OF (WIN_CERTIFICATE_UEFI_GUID, CertData));\r
1894\r
c035e373
ZL		 1895 //\r
1896 // SignedData.digestAlgorithms shall contain the digest algorithm used when preparing the\r
1897 // signature. Only a digest algorithm of SHA-256 is accepted.\r
1898 //\r
1899 // According to PKCS#7 Definition:\r
1900 // SignedData ::= SEQUENCE {\r
1901 // version Version,\r
1902 // digestAlgorithms DigestAlgorithmIdentifiers,\r
1903 // contentInfo ContentInfo,\r
1904 // .... }\r
1905 // The DigestAlgorithmIdentifiers can be used to determine the hash algorithm \r
1906 // in VARIABLE_AUTHENTICATION_2 descriptor.\r
1907 // This field has the fixed offset (+13) and be calculated based on two bytes of length encoding.\r
1908 //\r
1909 if ((Attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) != 0) {\r
1910 if (SigDataSize >= (13 + sizeof (mSha256OidValue))) {\r
1911 if (((*(SigData + 1) & TWO_BYTE_ENCODE) != TWO_BYTE_ENCODE) || \r
1912 (CompareMem (SigData + 13, &mSha256OidValue, sizeof (mSha256OidValue)) != 0)) {\r
1913 return EFI_SECURITY_VIOLATION;\r
1914 }\r
1915 }\r
1916 }\r
1917\r
a6811666
SZ		 1918 //\r
1919 // Find out the new data payload which follows Pkcs7 SignedData directly.\r
1920 //\r
1921 PayloadPtr = SigData + SigDataSize;\r
1922 PayloadSize = DataSize - OFFSET_OF_AUTHINFO2_CERT_DATA - (UINTN) SigDataSize;\r
1923\r
1924 //\r
1925 // Construct a serialization buffer of the values of the VariableName, VendorGuid and Attributes\r
1926 // parameters of the SetVariable() call and the TimeStamp component of the\r
1927 // EFI_VARIABLE_AUTHENTICATION_2 descriptor followed by the variable's new value\r
1928 // i.e. (VariableName, VendorGuid, Attributes, TimeStamp, Data)\r
1929 //\r
1930 NewDataSize = PayloadSize + sizeof (EFI_TIME) + sizeof (UINT32) +\r
1931 sizeof (EFI_GUID) + StrSize (VariableName) - sizeof (CHAR16);\r
1932\r
1933 //\r
1934 // Here is to reuse scratch data area(at the end of volatile variable store)\r
1935 // to reduce SMRAM consumption for SMM variable driver.\r
1936 // The scratch buffer is enough to hold the serialized data and safe to use,\r
1937 // because it is only used at here to do verification temporarily first\r
1938 // and then used in UpdateVariable() for a time based auth variable set.\r
1939 //\r
1940 Status = mAuthVarLibContextIn->GetScratchBuffer (&NewDataSize, (VOID **) &NewData);\r
1941 if (EFI_ERROR (Status)) {\r
1942 return EFI_OUT_OF_RESOURCES;\r
1943 }\r
1944\r
1945 Buffer = NewData;\r
1946 Length = StrLen (VariableName) * sizeof (CHAR16);\r
1947 CopyMem (Buffer, VariableName, Length);\r
1948 Buffer += Length;\r
1949\r
1950 Length = sizeof (EFI_GUID);\r
1951 CopyMem (Buffer, VendorGuid, Length);\r
1952 Buffer += Length;\r
1953\r
1954 Length = sizeof (UINT32);\r
1955 CopyMem (Buffer, &Attr, Length);\r
1956 Buffer += Length;\r
1957\r
1958 Length = sizeof (EFI_TIME);\r
1959 CopyMem (Buffer, &CertData->TimeStamp, Length);\r
1960 Buffer += Length;\r
1961\r
1962 CopyMem (Buffer, PayloadPtr, PayloadSize);\r
1963\r
1964 if (AuthVarType == AuthVarTypePk) {\r
1965 //\r
1966 // Verify that the signature has been made with the current Platform Key (no chaining for PK).\r
1967 // First, get signer's certificates from SignedData.\r
1968 //\r
1969 VerifyStatus = Pkcs7GetSigners (\r
1970 SigData,\r
1971 SigDataSize,\r
1972 &SignerCerts,\r
1973 &CertStackSize,\r
53c6ff18
ZC		 1974 &TopLevelCert,\r
1975 &TopLevelCertSize\r
a6811666
SZ		 1976 );\r
1977 if (!VerifyStatus) {\r
1978 goto Exit;\r
1979 }\r
1980\r
1981 //\r
1982 // Second, get the current platform key from variable. Check whether it's identical with signer's certificates\r
1983 // in SignedData. If not, return error immediately.\r
1984 //\r
1985 Status = AuthServiceInternalFindVariable (\r
1986 EFI_PLATFORM_KEY_NAME,\r
1987 &gEfiGlobalVariableGuid,\r
1988 &Data,\r
1989 &DataSize\r
1990 );\r
1991 if (EFI_ERROR (Status)) {\r
1992 VerifyStatus = FALSE;\r
1993 goto Exit;\r
1994 }\r
1995 CertList = (EFI_SIGNATURE_LIST *) Data;\r
1996 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertList + sizeof (EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);\r
53c6ff18
ZC		 1997 if ((TopLevelCertSize != (CertList->SignatureSize - (sizeof (EFI_SIGNATURE_DATA) - 1))) ||\r
1998 (CompareMem (Cert->SignatureData, TopLevelCert, TopLevelCertSize) != 0)) {\r
a6811666
SZ		 1999 VerifyStatus = FALSE;\r
2000 goto Exit;\r
2001 }\r
2002\r
2003 //\r
2004 // Verify Pkcs7 SignedData via Pkcs7Verify library.\r
2005 //\r
2006 VerifyStatus = Pkcs7Verify (\r
2007 SigData,\r
2008 SigDataSize,\r
53c6ff18
ZC		 2009 TopLevelCert,\r
2010 TopLevelCertSize,\r
a6811666
SZ		 2011 NewData,\r
2012 NewDataSize\r
2013 );\r
2014\r
2015 } else if (AuthVarType == AuthVarTypeKek) {\r
2016\r
2017 //\r
2018 // Get KEK database from variable.\r
2019 //\r
2020 Status = AuthServiceInternalFindVariable (\r
2021 EFI_KEY_EXCHANGE_KEY_NAME,\r
2022 &gEfiGlobalVariableGuid,\r
2023 &Data,\r
2024 &DataSize\r
2025 );\r
2026 if (EFI_ERROR (Status)) {\r
2027 return Status;\r
2028 }\r
2029\r
2030 //\r
2031 // Ready to verify Pkcs7 SignedData. Go through KEK Signature Database to find out X.509 CertList.\r
2032 //\r
2033 KekDataSize = (UINT32) DataSize;\r
2034 CertList = (EFI_SIGNATURE_LIST *) Data;\r
2035 while ((KekDataSize > 0) && (KekDataSize >= CertList->SignatureListSize)) {\r
2036 if (CompareGuid (&CertList->SignatureType, &gEfiCertX509Guid)) {\r
2037 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertList + sizeof (EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);\r
2038 CertCount = (CertList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - CertList->SignatureHeaderSize) / CertList->SignatureSize;\r
2039 for (Index = 0; Index < CertCount; Index++) {\r
2040 //\r
2041 // Iterate each Signature Data Node within this CertList for a verify\r
2042 //\r
53c6ff18
ZC		 2043 TrustedCert = Cert->SignatureData;\r
2044 TrustedCertSize = CertList->SignatureSize - (sizeof (EFI_SIGNATURE_DATA) - 1);\r
a6811666
SZ		 2045\r
2046 //\r
2047 // Verify Pkcs7 SignedData via Pkcs7Verify library.\r
2048 //\r
2049 VerifyStatus = Pkcs7Verify (\r
2050 SigData,\r
2051 SigDataSize,\r
53c6ff18
ZC		 2052 TrustedCert,\r
2053 TrustedCertSize,\r
a6811666
SZ		 2054 NewData,\r
2055 NewDataSize\r
2056 );\r
2057 if (VerifyStatus) {\r
2058 goto Exit;\r
2059 }\r
2060 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) Cert + CertList->SignatureSize);\r
2061 }\r
2062 }\r
2063 KekDataSize -= CertList->SignatureListSize;\r
2064 CertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) CertList + CertList->SignatureListSize);\r
2065 }\r
2066 } else if (AuthVarType == AuthVarTypePriv) {\r
2067\r
2068 //\r
2069 // Process common authenticated variable except PK/KEK/DB/DBX/DBT.\r
2070 // Get signer's certificates from SignedData.\r
2071 //\r
2072 VerifyStatus = Pkcs7GetSigners (\r
2073 SigData,\r
2074 SigDataSize,\r
2075 &SignerCerts,\r
2076 &CertStackSize,\r
53c6ff18
ZC		 2077 &TopLevelCert,\r
2078 &TopLevelCertSize\r
a6811666
SZ		 2079 );\r
2080 if (!VerifyStatus) {\r
2081 goto Exit;\r
2082 }\r
2083\r
2084 //\r
98c2d961 2085 // Get previously stored signer's certificates from certdb or certdbv for existing\r
a6811666
SZ		 2086 // variable. Check whether they are identical with signer's certificates\r
2087 // in SignedData. If not, return error immediately.\r
2088 //\r
2089 if (OrgTimeStamp != NULL) {\r
2090 VerifyStatus = FALSE;\r
2091\r
98c2d961 2092 Status = GetCertsFromDb (VariableName, VendorGuid, Attributes, &CertsInCertDb, &CertsSizeinDb);\r
a6811666
SZ		 2093 if (EFI_ERROR (Status)) {\r
2094 goto Exit;\r
2095 }\r
2096\r
53c6ff18
ZC		 2097 if (CertsSizeinDb == SHA256_DIGEST_SIZE) {\r
2098 //\r
2099 // Check hash of signer cert CommonName + Top-level issuer tbsCertificate against data in CertDb\r
2100 //\r
2101 Status = CalculatePrivAuthVarSignChainSHA256Digest(\r
2102 SignerCerts + sizeof(UINT8) + sizeof(UINT32),\r
2103 ReadUnaligned32 ((UINT32 *)(SignerCerts + sizeof(UINT8))),\r
2104 TopLevelCert,\r
2105 TopLevelCertSize,\r
2106 Sha256Digest\r
2107 );\r
2108 if (EFI_ERROR(Status) || CompareMem (Sha256Digest, CertsInCertDb, CertsSizeinDb) != 0){\r
2109 goto Exit;\r
2110 }\r
2111 } else {\r
2112 //\r
2113 // Keep backward compatible with previous solution which saves whole signer certs stack in CertDb\r
2114 //\r
2115 if ((CertStackSize != CertsSizeinDb) ||\r
2116 (CompareMem (SignerCerts, CertsInCertDb, CertsSizeinDb) != 0)) {\r
2117 goto Exit;\r
2118 }\r
a6811666
SZ		 2119 }\r
2120 }\r
2121\r
2122 VerifyStatus = Pkcs7Verify (\r
2123 SigData,\r
2124 SigDataSize,\r
53c6ff18
ZC		 2125 TopLevelCert,\r
2126 TopLevelCertSize,\r
a6811666
SZ		 2127 NewData,\r
2128 NewDataSize\r
2129 );\r
2130 if (!VerifyStatus) {\r
2131 goto Exit;\r
2132 }\r
2133\r
64b6a3ff 2134 if ((OrgTimeStamp == NULL) && (PayloadSize != 0)) {\r
a6811666 2135 //\r
53c6ff18 2136 // When adding a new common authenticated variable, always save Hash of cn of signer cert + tbsCertificate of Top-level issuer\r
a6811666 2137 //\r
53c6ff18
ZC		 2138 Status = InsertCertsToDb (\r
2139 VariableName,\r
2140 VendorGuid,\r
2141 Attributes,\r
2142 SignerCerts + sizeof(UINT8) + sizeof(UINT32),\r
2143 ReadUnaligned32 ((UINT32 *)(SignerCerts + sizeof(UINT8))),\r
2144 TopLevelCert,\r
2145 TopLevelCertSize\r
2146 );\r
a6811666
SZ		 2147 if (EFI_ERROR (Status)) {\r
2148 VerifyStatus = FALSE;\r
2149 goto Exit;\r
2150 }\r
2151 }\r
2152 } else if (AuthVarType == AuthVarTypePayload) {\r
2153 CertList = (EFI_SIGNATURE_LIST *) PayloadPtr;\r
2154 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertList + sizeof (EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);\r
53c6ff18
ZC		 2155 TrustedCert = Cert->SignatureData;\r
2156 TrustedCertSize = CertList->SignatureSize - (sizeof (EFI_SIGNATURE_DATA) - 1);\r
a6811666
SZ		 2157 //\r
2158 // Verify Pkcs7 SignedData via Pkcs7Verify library.\r
2159 //\r
2160 VerifyStatus = Pkcs7Verify (\r
2161 SigData,\r
2162 SigDataSize,\r
53c6ff18
ZC		 2163 TrustedCert,\r
2164 TrustedCertSize,\r
a6811666
SZ		 2165 NewData,\r
2166 NewDataSize\r
2167 );\r
2168 } else {\r
2169 return EFI_SECURITY_VIOLATION;\r
2170 }\r
2171\r
2172Exit:\r
2173\r
2174 if (AuthVarType == AuthVarTypePk || AuthVarType == AuthVarTypePriv) {\r
53c6ff18 2175 Pkcs7FreeSigners (TopLevelCert);\r
a6811666
SZ		 2176 Pkcs7FreeSigners (SignerCerts);\r
2177 }\r
2178\r
2179 if (!VerifyStatus) {\r
2180 return EFI_SECURITY_VIOLATION;\r
2181 }\r
2182\r
2183 Status = CheckSignatureListFormat(VariableName, VendorGuid, PayloadPtr, PayloadSize);\r
2184 if (EFI_ERROR (Status)) {\r
2185 return Status;\r
2186 }\r
2187\r
2188 *VarPayloadPtr = PayloadPtr;\r
2189 *VarPayloadSize = PayloadSize;\r
2190\r
2191 return EFI_SUCCESS;\r
2192}\r
2193\r
2194/**\r
2195 Process variable with EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS set\r
2196\r
2197 Caution: This function may receive untrusted input.\r
2198 This function may be invoked in SMM mode, and datasize and data are external input.\r
2199 This function will do basic validation, before parse the data.\r
2200 This function will parse the authentication carefully to avoid security issues, like\r
2201 buffer overflow, integer overflow.\r
2202\r
2203 @param[in] VariableName Name of Variable to be found.\r
2204 @param[in] VendorGuid Variable vendor GUID.\r
2205 @param[in] Data Data pointer.\r
2206 @param[in] DataSize Size of Data found. If size is less than the\r
2207 data, this value contains the required size.\r
2208 @param[in] Attributes Attribute value of the variable.\r
2209 @param[in] AuthVarType Verify against PK, KEK database, private database or certificate in data payload.\r
2210 @param[out] VarDel Delete the variable or not.\r
2211\r
2212 @retval EFI_INVALID_PARAMETER Invalid parameter.\r
2213 @retval EFI_SECURITY_VIOLATION The variable does NOT pass the validation\r
2214 check carried out by the firmware.\r
2215 @retval EFI_OUT_OF_RESOURCES Failed to process variable due to lack\r
2216 of resources.\r
2217 @retval EFI_SUCCESS Variable pass validation successfully.\r
2218\r
2219**/\r
2220EFI_STATUS\r
2221VerifyTimeBasedPayloadAndUpdate (\r
2222 IN CHAR16 *VariableName,\r
2223 IN EFI_GUID *VendorGuid,\r
2224 IN VOID *Data,\r
2225 IN UINTN DataSize,\r
2226 IN UINT32 Attributes,\r
2227 IN AUTHVAR_TYPE AuthVarType,\r
2228 OUT BOOLEAN *VarDel\r
2229 )\r
2230{\r
2231 EFI_STATUS Status;\r
2232 EFI_STATUS FindStatus;\r
2233 UINT8 *PayloadPtr;\r
2234 UINTN PayloadSize;\r
2235 EFI_VARIABLE_AUTHENTICATION_2 *CertData;\r
2236 AUTH_VARIABLE_INFO OrgVariableInfo;\r
64b6a3ff 2237 BOOLEAN IsDel;\r
a6811666
SZ		 2238\r
2239 ZeroMem (&OrgVariableInfo, sizeof (OrgVariableInfo));\r
2240 FindStatus = mAuthVarLibContextIn->FindVariable (\r
2241 VariableName,\r
2242 VendorGuid,\r
2243 &OrgVariableInfo\r
2244 );\r
2245\r
2246 Status = VerifyTimeBasedPayload (\r
2247 VariableName,\r
2248 VendorGuid,\r
2249 Data,\r
2250 DataSize,\r
2251 Attributes,\r
2252 AuthVarType,\r
2253 (!EFI_ERROR (FindStatus)) ? OrgVariableInfo.TimeStamp : NULL,\r
2254 &PayloadPtr,\r
2255 &PayloadSize\r
2256 );\r
2257 if (EFI_ERROR (Status)) {\r
2258 return Status;\r
2259 }\r
2260\r
64b6a3ff
CZ		 2261 if (!EFI_ERROR(FindStatus)\r
2262 && (PayloadSize == 0)\r
2263 && ((Attributes & EFI_VARIABLE_APPEND_WRITE) == 0)) {\r
2264 IsDel = TRUE;\r
2265 } else {\r
2266 IsDel = FALSE;\r
a6811666
SZ		 2267 }\r
2268\r
2269 CertData = (EFI_VARIABLE_AUTHENTICATION_2 *) Data;\r
2270\r
2271 //\r
2272 // Final step: Update/Append Variable if it pass Pkcs7Verify\r
2273 //\r
64b6a3ff
CZ		 2274 Status = AuthServiceInternalUpdateVariableWithTimeStamp (\r
2275 VariableName,\r
2276 VendorGuid,\r
2277 PayloadPtr,\r
2278 PayloadSize,\r
2279 Attributes,\r
2280 &CertData->TimeStamp\r
2281 );\r
2282\r
2283 //\r
2284 // Delete signer's certificates when delete the common authenticated variable.\r
2285 //\r
2286 if (IsDel && AuthVarType == AuthVarTypePriv && !EFI_ERROR(Status) ) {\r
98c2d961 2287 Status = DeleteCertsFromDb (VariableName, VendorGuid, Attributes);\r
64b6a3ff
CZ		 2288 }\r
2289\r
2290 if (VarDel != NULL) {\r
2291 if (IsDel && !EFI_ERROR(Status)) {\r
2292 *VarDel = TRUE;\r
2293 } else {\r
2294 *VarDel = FALSE;\r
2295 }\r
2296 }\r
2297\r
2298 return Status;\r
a6811666 2299}\r
EFI Development Kit II mirror for PVE