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