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