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