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