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