]> 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: Initialize Status in ProcessVariable().
[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
aef8cea9 1360 Status = EFI_SUCCESS;\r
0c18794e 1361\r
f6c50319 1362 if (UserPhysicalPresent()) {\r
ecc722ad 1363 //\r
f6c50319 1364 // Allow the delete operation of common authenticated variable at user physical presence.\r
ecc722ad 1365 //\r
f6c50319
SZ		 1366 if (IsDeleteAuthVariable (Data, DataSize, Variable, Attributes)) {\r
1367 if ((Attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) != 0) {\r
1368 Status = DeleteCertsFromDb (VariableName, VendorGuid);\r
1369 }\r
1370 if (!EFI_ERROR (Status)) {\r
1371 Status = UpdateVariable (\r
1372 VariableName,\r
1373 VendorGuid,\r
1374 NULL,\r
1375 0,\r
1376 0,\r
1377 0,\r
1378 0,\r
1379 Variable,\r
1380 NULL\r
1381 );\r
1382 }\r
1383 return Status;\r
1384 }\r
1385 } else {\r
1386 if (NeedPhysicallyPresent(VariableName, VendorGuid)) {\r
1387 //\r
1388 // This variable is protected, only physical present user could modify its value.\r
1389 //\r
1390 return EFI_SECURITY_VIOLATION;\r
1391 }\r
ecc722ad 1392 }\r
20333c6d 1393\r
89be2b03 1394 //\r
1395 // A time-based authenticated variable and a count-based authenticated variable\r
1396 // can't be updated by each other.\r
20333c6d
QL		 1397 //\r
1398 if (Variable->CurrPtr != NULL) {\r
89be2b03 1399 if (((Attributes & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) != 0) &&\r
1400 ((Variable->CurrPtr->Attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) != 0)) {\r
20333c6d 1401 return EFI_SECURITY_VIOLATION;\r
89be2b03 1402 }\r
20333c6d
QL		 1403\r
1404 if (((Attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) != 0) &&\r
89be2b03 1405 ((Variable->CurrPtr->Attributes & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) != 0)) {\r
20333c6d 1406 return EFI_SECURITY_VIOLATION;\r
89be2b03 1407 }\r
1408 }\r
20333c6d 1409\r
0c18794e 1410 //\r
1411 // Process Time-based Authenticated variable.\r
1412 //\r
1413 if ((Attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) != 0) {\r
ed47ae02 1414 return VerifyTimeBasedPayload (\r
1415 VariableName,\r
1416 VendorGuid,\r
1417 Data,\r
1418 DataSize,\r
1419 Variable,\r
1420 Attributes,\r
1421 AuthVarTypePriv,\r
1422 NULL\r
1423 );\r
0c18794e 1424 }\r
2d3fb919 1425\r
0c18794e 1426 //\r
1427 // Determine if first time SetVariable with the EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS.\r
1428 //\r
1429 if ((Attributes & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) != 0) {\r
1430 //\r
1431 // Determine current operation type.\r
1432 //\r
1433 if (DataSize == AUTHINFO_SIZE) {\r
1434 IsDeletion = TRUE;\r
1435 }\r
1436 //\r
1437 // Determine whether this is the first time with EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS set.\r
1438 //\r
1439 if (Variable->CurrPtr == NULL) {\r
1440 IsFirstTime = TRUE;\r
1441 } else if ((Variable->CurrPtr->Attributes & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) == 0) {\r
1442 IsFirstTime = TRUE;\r
1443 } else {\r
1444 KeyIndex = Variable->CurrPtr->PubKeyIndex;\r
1445 IsFirstTime = FALSE;\r
1446 }\r
20333c6d 1447 } else if ((Variable->CurrPtr != NULL) &&\r
389c8779 1448 ((Variable->CurrPtr->Attributes & (EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS)) != 0)\r
1449 ) {\r
0c18794e 1450 //\r
1451 // If the variable is already write-protected, it always needs authentication before update.\r
1452 //\r
1453 return EFI_WRITE_PROTECTED;\r
1454 } else {\r
1455 //\r
1456 // If without EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS, set and attributes collision.\r
1457 // That means it is not authenticated variable, just update variable as usual.\r
1458 //\r
1459 Status = UpdateVariable (VariableName, VendorGuid, Data, DataSize, Attributes, 0, 0, Variable, NULL);\r
1460 return Status;\r
1461 }\r
1462\r
1463 //\r
1464 // Get PubKey and check Monotonic Count value corresponding to the variable.\r
1465 //\r
1466 CertData = (EFI_VARIABLE_AUTHENTICATION *) Data;\r
1467 CertBlock = (EFI_CERT_BLOCK_RSA_2048_SHA256 *) (CertData->AuthInfo.CertData);\r
1468 PubKey = CertBlock->PublicKey;\r
1469\r
1470 //\r
1471 // Update Monotonic Count value.\r
1472 //\r
1473 MonotonicCount = CertData->MonotonicCount;\r
1474\r
1475 if (!IsFirstTime) {\r
1476 //\r
8c83d0c0 1477 // 2 cases need to check here\r
20333c6d 1478 // 1. Internal PubKey variable. PubKeyIndex is always 0\r
8c83d0c0 1479 // 2. Other counter-based AuthVariable. Check input PubKey.\r
0c18794e 1480 //\r
8c83d0c0 1481 if (KeyIndex == 0 || CompareMem (PubKey, mPubKeyStore + (KeyIndex - 1) * EFI_CERT_TYPE_RSA2048_SIZE, EFI_CERT_TYPE_RSA2048_SIZE) != 0) {\r
0c18794e 1482 return EFI_SECURITY_VIOLATION;\r
1483 }\r
1484 //\r
1485 // Compare the current monotonic count and ensure that it is greater than the last SetVariable\r
1486 // operation with the EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS attribute set.\r
1487 //\r
1488 if (CertData->MonotonicCount <= Variable->CurrPtr->MonotonicCount) {\r
1489 //\r
1490 // Monotonic count check fail, suspicious replay attack, return EFI_SECURITY_VIOLATION.\r
1491 //\r
1492 return EFI_SECURITY_VIOLATION;\r
1493 }\r
2d3fb919 1494 }\r
0c18794e 1495 //\r
1496 // Verify the certificate in Data payload.\r
1497 //\r
1498 Status = VerifyCounterBasedPayload (Data, DataSize, PubKey);\r
1499 if (EFI_ERROR (Status)) {\r
1500 return Status;\r
1501 }\r
2d3fb919 1502\r
0c18794e 1503 //\r
1504 // Now, the signature has been verified!\r
1505 //\r
1506 if (IsFirstTime && !IsDeletion) {\r
9a12e582
DG		 1507 VariableDataEntry.VariableSize = DataSize - AUTHINFO_SIZE;\r
1508 VariableDataEntry.Guid = VendorGuid;\r
1509 VariableDataEntry.Name = VariableName;\r
1510\r
0c18794e 1511 //\r
1512 // Update public key database variable if need.\r
1513 //\r
9a12e582 1514 KeyIndex = AddPubKeyInStore (PubKey, &VariableDataEntry);\r
4e33001c 1515 if (KeyIndex == 0) {\r
275beb2b 1516 return EFI_OUT_OF_RESOURCES;\r
4e33001c 1517 }\r
0c18794e 1518 }\r
1519\r
1520 //\r
1521 // Verification pass.\r
1522 //\r
1523 return UpdateVariable (VariableName, VendorGuid, (UINT8*)Data + AUTHINFO_SIZE, DataSize - AUTHINFO_SIZE, Attributes, KeyIndex, MonotonicCount, Variable, NULL);\r
1524}\r
1525\r
2d3fb919 1526/**\r
1527 Merge two buffers which formatted as EFI_SIGNATURE_LIST. Only the new EFI_SIGNATURE_DATA\r
1528 will be appended to the original EFI_SIGNATURE_LIST, duplicate EFI_SIGNATURE_DATA\r
1529 will be ignored.\r
1530\r
732d199d 1531 @param[in, out] Data Pointer to original EFI_SIGNATURE_LIST.\r
1532 @param[in] DataSize Size of Data buffer.\r
20333c6d 1533 @param[in] FreeBufSize Size of free data buffer\r
732d199d 1534 @param[in] NewData Pointer to new EFI_SIGNATURE_LIST to be appended.\r
1535 @param[in] NewDataSize Size of NewData buffer.\r
1536 @param[out] MergedBufSize Size of the merged buffer\r
2d3fb919 1537\r
732d199d 1538 @return EFI_BUFFER_TOO_SMALL if input Data buffer overflowed\r
2d3fb919 1539\r
1540**/\r
732d199d 1541EFI_STATUS\r
2d3fb919 1542AppendSignatureList (\r
1543 IN OUT VOID *Data,\r
1544 IN UINTN DataSize,\r
732d199d 1545 IN UINTN FreeBufSize,\r
2d3fb919 1546 IN VOID *NewData,\r
732d199d 1547 IN UINTN NewDataSize,\r
1548 OUT UINTN *MergedBufSize\r
2d3fb919 1549 )\r
1550{\r
1551 EFI_SIGNATURE_LIST *CertList;\r
1552 EFI_SIGNATURE_DATA *Cert;\r
1553 UINTN CertCount;\r
1554 EFI_SIGNATURE_LIST *NewCertList;\r
1555 EFI_SIGNATURE_DATA *NewCert;\r
1556 UINTN NewCertCount;\r
1557 UINTN Index;\r
1558 UINTN Index2;\r
1559 UINTN Size;\r
1560 UINT8 *Tail;\r
1561 UINTN CopiedCount;\r
1562 UINTN SignatureListSize;\r
1563 BOOLEAN IsNewCert;\r
1564\r
1565 Tail = (UINT8 *) Data + DataSize;\r
1566\r
1567 NewCertList = (EFI_SIGNATURE_LIST *) NewData;\r
1568 while ((NewDataSize > 0) && (NewDataSize >= NewCertList->SignatureListSize)) {\r
1569 NewCert = (EFI_SIGNATURE_DATA *) ((UINT8 *) NewCertList + sizeof (EFI_SIGNATURE_LIST) + NewCertList->SignatureHeaderSize);\r
1570 NewCertCount = (NewCertList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - NewCertList->SignatureHeaderSize) / NewCertList->SignatureSize;\r
1571\r
1572 CopiedCount = 0;\r
1573 for (Index = 0; Index < NewCertCount; Index++) {\r
1574 IsNewCert = TRUE;\r
1575\r
1576 Size = DataSize;\r
1577 CertList = (EFI_SIGNATURE_LIST *) Data;\r
1578 while ((Size > 0) && (Size >= CertList->SignatureListSize)) {\r
1579 if (CompareGuid (&CertList->SignatureType, &NewCertList->SignatureType) &&\r
1580 (CertList->SignatureSize == NewCertList->SignatureSize)) {\r
1581 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertList + sizeof (EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);\r
1582 CertCount = (CertList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - CertList->SignatureHeaderSize) / CertList->SignatureSize;\r
1583 for (Index2 = 0; Index2 < CertCount; Index2++) {\r
1584 //\r
1585 // Iterate each Signature Data in this Signature List.\r
1586 //\r
1587 if (CompareMem (NewCert, Cert, CertList->SignatureSize) == 0) {\r
1588 IsNewCert = FALSE;\r
1589 break;\r
1590 }\r
1591 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) Cert + CertList->SignatureSize);\r
1592 }\r
1593 }\r
1594\r
1595 if (!IsNewCert) {\r
1596 break;\r
1597 }\r
1598 Size -= CertList->SignatureListSize;\r
1599 CertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) CertList + CertList->SignatureListSize);\r
1600 }\r
1601\r
1602 if (IsNewCert) {\r
1603 //\r
1604 // New EFI_SIGNATURE_DATA, append it.\r
1605 //\r
1606 if (CopiedCount == 0) {\r
732d199d 1607 if (FreeBufSize < sizeof (EFI_SIGNATURE_LIST) + NewCertList->SignatureHeaderSize) {\r
1608 return EFI_BUFFER_TOO_SMALL;\r
1609 }\r
1610\r
2d3fb919 1611 //\r
1612 // Copy EFI_SIGNATURE_LIST header for only once.\r
1613 //\r
732d199d 1614\r
2d3fb919 1615 CopyMem (Tail, NewCertList, sizeof (EFI_SIGNATURE_LIST) + NewCertList->SignatureHeaderSize);\r
1616 Tail = Tail + sizeof (EFI_SIGNATURE_LIST) + NewCertList->SignatureHeaderSize;\r
732d199d 1617 FreeBufSize -= sizeof (EFI_SIGNATURE_LIST) + NewCertList->SignatureHeaderSize;\r
2d3fb919 1618 }\r
1619\r
732d199d 1620 if (FreeBufSize < NewCertList->SignatureSize) {\r
1621 return EFI_BUFFER_TOO_SMALL;\r
1622 }\r
2d3fb919 1623 CopyMem (Tail, NewCert, NewCertList->SignatureSize);\r
1624 Tail += NewCertList->SignatureSize;\r
732d199d 1625 FreeBufSize -= NewCertList->SignatureSize;\r
2d3fb919 1626 CopiedCount++;\r
1627 }\r
1628\r
1629 NewCert = (EFI_SIGNATURE_DATA *) ((UINT8 *) NewCert + NewCertList->SignatureSize);\r
1630 }\r
1631\r
1632 //\r
1633 // Update SignatureListSize in newly appended EFI_SIGNATURE_LIST.\r
1634 //\r
1635 if (CopiedCount != 0) {\r
1636 SignatureListSize = sizeof (EFI_SIGNATURE_LIST) + NewCertList->SignatureHeaderSize + (CopiedCount * NewCertList->SignatureSize);\r
1637 CertList = (EFI_SIGNATURE_LIST *) (Tail - SignatureListSize);\r
1638 CertList->SignatureListSize = (UINT32) SignatureListSize;\r
1639 }\r
1640\r
1641 NewDataSize -= NewCertList->SignatureListSize;\r
1642 NewCertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) NewCertList + NewCertList->SignatureListSize);\r
1643 }\r
1644\r
732d199d 1645 *MergedBufSize = (Tail - (UINT8 *) Data);\r
1646 return EFI_SUCCESS;\r
2d3fb919 1647}\r
1648\r
0c18794e 1649/**\r
1650 Compare two EFI_TIME data.\r
1651\r
1652\r
1653 @param FirstTime A pointer to the first EFI_TIME data.\r
1654 @param SecondTime A pointer to the second EFI_TIME data.\r
1655\r
1656 @retval TRUE The FirstTime is not later than the SecondTime.\r
1657 @retval FALSE The FirstTime is later than the SecondTime.\r
1658\r
1659**/\r
1660BOOLEAN\r
1661CompareTimeStamp (\r
1662 IN EFI_TIME *FirstTime,\r
1663 IN EFI_TIME *SecondTime\r
1664 )\r
1665{\r
1666 if (FirstTime->Year != SecondTime->Year) {\r
1667 return (BOOLEAN) (FirstTime->Year < SecondTime->Year);\r
1668 } else if (FirstTime->Month != SecondTime->Month) {\r
1669 return (BOOLEAN) (FirstTime->Month < SecondTime->Month);\r
1670 } else if (FirstTime->Day != SecondTime->Day) {\r
1671 return (BOOLEAN) (FirstTime->Day < SecondTime->Day);\r
1672 } else if (FirstTime->Hour != SecondTime->Hour) {\r
1673 return (BOOLEAN) (FirstTime->Hour < SecondTime->Hour);\r
1674 } else if (FirstTime->Minute != SecondTime->Minute) {\r
42ed7604 1675 return (BOOLEAN) (FirstTime->Minute < SecondTime->Minute);\r
2d3fb919 1676 }\r
0c18794e 1677\r
1678 return (BOOLEAN) (FirstTime->Second <= SecondTime->Second);\r
1679}\r
1680\r
ed47ae02 1681/**\r
1682 Find matching signer's certificates for common authenticated variable\r
1683 by corresponding VariableName and VendorGuid from "certdb".\r
1684\r
1685 The data format of "certdb":\r
1686 //\r
1687 // UINT32 CertDbListSize;\r
1688 // /// AUTH_CERT_DB_DATA Certs1[];\r
1689 // /// AUTH_CERT_DB_DATA Certs2[];\r
1690 // /// ...\r
1691 // /// AUTH_CERT_DB_DATA Certsn[];\r
1692 //\r
1693\r
1694 @param[in] VariableName Name of authenticated Variable.\r
1695 @param[in] VendorGuid Vendor GUID of authenticated Variable.\r
1696 @param[in] Data Pointer to variable "certdb".\r
1697 @param[in] DataSize Size of variable "certdb".\r
1698 @param[out] CertOffset Offset of matching CertData, from starting of Data.\r
1699 @param[out] CertDataSize Length of CertData in bytes.\r
1700 @param[out] CertNodeOffset Offset of matching AUTH_CERT_DB_DATA , from\r
1701 starting of Data.\r
1702 @param[out] CertNodeSize Length of AUTH_CERT_DB_DATA in bytes.\r
1703\r
1704 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.\r
1705 @retval EFI_NOT_FOUND Fail to find matching certs.\r
1706 @retval EFI_SUCCESS Find matching certs and output parameters.\r
1707\r
1708**/\r
1709EFI_STATUS\r
1710FindCertsFromDb (\r
1711 IN CHAR16 *VariableName,\r
1712 IN EFI_GUID *VendorGuid,\r
1713 IN UINT8 *Data,\r
1714 IN UINTN DataSize,\r
1715 OUT UINT32 *CertOffset, OPTIONAL\r
1716 OUT UINT32 *CertDataSize, OPTIONAL\r
1717 OUT UINT32 *CertNodeOffset,OPTIONAL\r
1718 OUT UINT32 *CertNodeSize OPTIONAL\r
1719 )\r
1720{\r
1721 UINT32 Offset;\r
1722 AUTH_CERT_DB_DATA *Ptr;\r
1723 UINT32 CertSize;\r
1724 UINT32 NameSize;\r
1725 UINT32 NodeSize;\r
1726 UINT32 CertDbListSize;\r
1727\r
1728 if ((VariableName == NULL) || (VendorGuid == NULL) || (Data == NULL)) {\r
1729 return EFI_INVALID_PARAMETER;\r
1730 }\r
1731\r
1732 //\r
1733 // Check whether DataSize matches recorded CertDbListSize.\r
1734 //\r
1735 if (DataSize < sizeof (UINT32)) {\r
1736 return EFI_INVALID_PARAMETER;\r
1737 }\r
1738\r
1739 CertDbListSize = ReadUnaligned32 ((UINT32 *) Data);\r
1740\r
1741 if (CertDbListSize != (UINT32) DataSize) {\r
1742 return EFI_INVALID_PARAMETER;\r
1743 }\r
1744\r
1745 Offset = sizeof (UINT32);\r
1746\r
1747 //\r
1748 // Get corresponding certificates by VendorGuid and VariableName.\r
1749 //\r
1750 while (Offset < (UINT32) DataSize) {\r
1751 Ptr = (AUTH_CERT_DB_DATA *) (Data + Offset);\r
1752 //\r
1753 // Check whether VendorGuid matches.\r
1754 //\r
1755 if (CompareGuid (&Ptr->VendorGuid, VendorGuid)) {\r
1756 NodeSize = ReadUnaligned32 (&Ptr->CertNodeSize);\r
1757 NameSize = ReadUnaligned32 (&Ptr->NameSize);\r
1758 CertSize = ReadUnaligned32 (&Ptr->CertDataSize);\r
1759\r
1760 if (NodeSize != sizeof (EFI_GUID) + sizeof (UINT32) * 3 + CertSize +\r
1761 sizeof (CHAR16) * NameSize) {\r
1762 return EFI_INVALID_PARAMETER;\r
1763 }\r
1764\r
1765 Offset = Offset + sizeof (EFI_GUID) + sizeof (UINT32) * 3;\r
1766 //\r
1767 // Check whether VariableName matches.\r
1768 //\r
20333c6d 1769 if ((NameSize == StrLen (VariableName)) &&\r
ed47ae02 1770 (CompareMem (Data + Offset, VariableName, NameSize * sizeof (CHAR16)) == 0)) {\r
1771 Offset = Offset + NameSize * sizeof (CHAR16);\r
1772\r
1773 if (CertOffset != NULL) {\r
1774 *CertOffset = Offset;\r
1775 }\r
1776\r
1777 if (CertDataSize != NULL) {\r
20333c6d 1778 *CertDataSize = CertSize;\r
ed47ae02 1779 }\r
1780\r
1781 if (CertNodeOffset != NULL) {\r
1782 *CertNodeOffset = (UINT32) ((UINT8 *) Ptr - Data);\r
1783 }\r
1784\r
1785 if (CertNodeSize != NULL) {\r
1786 *CertNodeSize = NodeSize;\r
1787 }\r
1788\r
1789 return EFI_SUCCESS;\r
1790 } else {\r
1791 Offset = Offset + NameSize * sizeof (CHAR16) + CertSize;\r
1792 }\r
1793 } else {\r
1794 NodeSize = ReadUnaligned32 (&Ptr->CertNodeSize);\r
1795 Offset = Offset + NodeSize;\r
1796 }\r
1797 }\r
1798\r
20333c6d 1799 return EFI_NOT_FOUND;\r
ed47ae02 1800}\r
1801\r
1802/**\r
1803 Retrieve signer's certificates for common authenticated variable\r
1804 by corresponding VariableName and VendorGuid from "certdb".\r
1805\r
1806 @param[in] VariableName Name of authenticated Variable.\r
1807 @param[in] VendorGuid Vendor GUID of authenticated Variable.\r
1808 @param[out] CertData Pointer to signer's certificates.\r
1809 @param[out] CertDataSize Length of CertData in bytes.\r
1810\r
1811 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.\r
1812 @retval EFI_NOT_FOUND Fail to find "certdb" or matching certs.\r
1813 @retval EFI_SUCCESS Get signer's certificates successfully.\r
1814\r
1815**/\r
1816EFI_STATUS\r
1817GetCertsFromDb (\r
1818 IN CHAR16 *VariableName,\r
1819 IN EFI_GUID *VendorGuid,\r
1820 OUT UINT8 **CertData,\r
1821 OUT UINT32 *CertDataSize\r
1822 )\r
1823{\r
1824 VARIABLE_POINTER_TRACK CertDbVariable;\r
1825 EFI_STATUS Status;\r
1826 UINT8 *Data;\r
1827 UINTN DataSize;\r
1828 UINT32 CertOffset;\r
1829\r
1830 if ((VariableName == NULL) || (VendorGuid == NULL) || (CertData == NULL) || (CertDataSize == NULL)) {\r
1831 return EFI_INVALID_PARAMETER;\r
1832 }\r
20333c6d 1833\r
ed47ae02 1834 //\r
1835 // Get variable "certdb".\r
1836 //\r
1837 Status = FindVariable (\r
1838 EFI_CERT_DB_NAME,\r
1839 &gEfiCertDbGuid,\r
1840 &CertDbVariable,\r
1841 &mVariableModuleGlobal->VariableGlobal,\r
1842 FALSE\r
20333c6d 1843 );\r
ed47ae02 1844 if (EFI_ERROR (Status)) {\r
1845 return Status;\r
1846 }\r
1847\r
1848 DataSize = DataSizeOfVariable (CertDbVariable.CurrPtr);\r
1849 Data = GetVariableDataPtr (CertDbVariable.CurrPtr);\r
1850 if ((DataSize == 0) || (Data == NULL)) {\r
1851 ASSERT (FALSE);\r
1852 return EFI_NOT_FOUND;\r
1853 }\r
1854\r
1855 Status = FindCertsFromDb (\r
1856 VariableName,\r
1857 VendorGuid,\r
1858 Data,\r
1859 DataSize,\r
1860 &CertOffset,\r
1861 CertDataSize,\r
1862 NULL,\r
1863 NULL\r
1864 );\r
1865\r
1866 if (EFI_ERROR (Status)) {\r
1867 return Status;\r
1868 }\r
1869\r
1870 *CertData = Data + CertOffset;\r
1871 return EFI_SUCCESS;\r
1872}\r
1873\r
1874/**\r
1875 Delete matching signer's certificates when deleting common authenticated\r
1876 variable by corresponding VariableName and VendorGuid from "certdb".\r
1877\r
1878 @param[in] VariableName Name of authenticated Variable.\r
1879 @param[in] VendorGuid Vendor GUID of authenticated Variable.\r
1880\r
1881 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.\r
1882 @retval EFI_NOT_FOUND Fail to find "certdb" or matching certs.\r
1883 @retval EFI_OUT_OF_RESOURCES The operation is failed due to lack of resources.\r
1884 @retval EFI_SUCCESS The operation is completed successfully.\r
1885\r
1886**/\r
1887EFI_STATUS\r
1888DeleteCertsFromDb (\r
1889 IN CHAR16 *VariableName,\r
1890 IN EFI_GUID *VendorGuid\r
1891 )\r
1892{\r
1893 VARIABLE_POINTER_TRACK CertDbVariable;\r
1894 EFI_STATUS Status;\r
1895 UINT8 *Data;\r
1896 UINTN DataSize;\r
1897 UINT32 VarAttr;\r
1898 UINT32 CertNodeOffset;\r
1899 UINT32 CertNodeSize;\r
1900 UINT8 *NewCertDb;\r
1901 UINT32 NewCertDbSize;\r
1902\r
1903 if ((VariableName == NULL) || (VendorGuid == NULL)) {\r
1904 return EFI_INVALID_PARAMETER;\r
1905 }\r
20333c6d 1906\r
ed47ae02 1907 //\r
1908 // Get variable "certdb".\r
1909 //\r
1910 Status = FindVariable (\r
1911 EFI_CERT_DB_NAME,\r
1912 &gEfiCertDbGuid,\r
1913 &CertDbVariable,\r
1914 &mVariableModuleGlobal->VariableGlobal,\r
1915 FALSE\r
20333c6d 1916 );\r
ed47ae02 1917 if (EFI_ERROR (Status)) {\r
1918 return Status;\r
1919 }\r
1920\r
1921 DataSize = DataSizeOfVariable (CertDbVariable.CurrPtr);\r
1922 Data = GetVariableDataPtr (CertDbVariable.CurrPtr);\r
1923 if ((DataSize == 0) || (Data == NULL)) {\r
1924 ASSERT (FALSE);\r
1925 return EFI_NOT_FOUND;\r
1926 }\r
1927\r
1928 if (DataSize == sizeof (UINT32)) {\r
1929 //\r
1930 // There is no certs in certdb.\r
1931 //\r
1932 return EFI_SUCCESS;\r
1933 }\r
1934\r
1935 //\r
1936 // Get corresponding cert node from certdb.\r
1937 //\r
1938 Status = FindCertsFromDb (\r
1939 VariableName,\r
1940 VendorGuid,\r
1941 Data,\r
1942 DataSize,\r
1943 NULL,\r
1944 NULL,\r
1945 &CertNodeOffset,\r
1946 &CertNodeSize\r
1947 );\r
1948\r
1949 if (EFI_ERROR (Status)) {\r
1950 return Status;\r
1951 }\r
1952\r
1953 if (DataSize < (CertNodeOffset + CertNodeSize)) {\r
1954 return EFI_NOT_FOUND;\r
1955 }\r
1956\r
1957 //\r
1958 // Construct new data content of variable "certdb".\r
1959 //\r
1960 NewCertDbSize = (UINT32) DataSize - CertNodeSize;\r
f6e23353 1961 NewCertDb = (UINT8*) mCertDbStore;\r
ed47ae02 1962\r
1963 //\r
1964 // Copy the DB entries before deleting node.\r
1965 //\r
1966 CopyMem (NewCertDb, Data, CertNodeOffset);\r
1967 //\r
1968 // Update CertDbListSize.\r
1969 //\r
1970 CopyMem (NewCertDb, &NewCertDbSize, sizeof (UINT32));\r
1971 //\r
1972 // Copy the DB entries after deleting node.\r
1973 //\r
1974 if (DataSize > (CertNodeOffset + CertNodeSize)) {\r
1975 CopyMem (\r
1976 NewCertDb + CertNodeOffset,\r
1977 Data + CertNodeOffset + CertNodeSize,\r
1978 DataSize - CertNodeOffset - CertNodeSize\r
1979 );\r
1980 }\r
1981\r
1982 //\r
1983 // Set "certdb".\r
20333c6d
QL		 1984 //\r
1985 VarAttr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS;\r
ed47ae02 1986 Status = UpdateVariable (\r
1987 EFI_CERT_DB_NAME,\r
1988 &gEfiCertDbGuid,\r
1989 NewCertDb,\r
1990 NewCertDbSize,\r
1991 VarAttr,\r
1992 0,\r
1993 0,\r
1994 &CertDbVariable,\r
1995 NULL\r
1996 );\r
1997\r
ed47ae02 1998 return Status;\r
1999}\r
2000\r
2001/**\r
2002 Insert signer's certificates for common authenticated variable with VariableName\r
2003 and VendorGuid in AUTH_CERT_DB_DATA to "certdb".\r
2004\r
2005 @param[in] VariableName Name of authenticated Variable.\r
2006 @param[in] VendorGuid Vendor GUID of authenticated Variable.\r
2007 @param[in] CertData Pointer to signer's certificates.\r
2008 @param[in] CertDataSize Length of CertData in bytes.\r
2009\r
2010 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.\r
2011 @retval EFI_ACCESS_DENIED An AUTH_CERT_DB_DATA entry with same VariableName\r
2012 and VendorGuid already exists.\r
2013 @retval EFI_OUT_OF_RESOURCES The operation is failed due to lack of resources.\r
2014 @retval EFI_SUCCESS Insert an AUTH_CERT_DB_DATA entry to "certdb"\r
2015\r
2016**/\r
2017EFI_STATUS\r
2018InsertCertsToDb (\r
2019 IN CHAR16 *VariableName,\r
2020 IN EFI_GUID *VendorGuid,\r
2021 IN UINT8 *CertData,\r
2022 IN UINTN CertDataSize\r
2023 )\r
2024{\r
2025 VARIABLE_POINTER_TRACK CertDbVariable;\r
2026 EFI_STATUS Status;\r
2027 UINT8 *Data;\r
2028 UINTN DataSize;\r
2029 UINT32 VarAttr;\r
2030 UINT8 *NewCertDb;\r
2031 UINT32 NewCertDbSize;\r
2032 UINT32 CertNodeSize;\r
2033 UINT32 NameSize;\r
2034 AUTH_CERT_DB_DATA *Ptr;\r
2035\r
2036 if ((VariableName == NULL) || (VendorGuid == NULL) || (CertData == NULL)) {\r
2037 return EFI_INVALID_PARAMETER;\r
2038 }\r
20333c6d 2039\r
ed47ae02 2040 //\r
2041 // Get variable "certdb".\r
2042 //\r
2043 Status = FindVariable (\r
2044 EFI_CERT_DB_NAME,\r
2045 &gEfiCertDbGuid,\r
2046 &CertDbVariable,\r
2047 &mVariableModuleGlobal->VariableGlobal,\r
2048 FALSE\r
20333c6d 2049 );\r
ed47ae02 2050 if (EFI_ERROR (Status)) {\r
2051 return Status;\r
2052 }\r
2053\r
2054 DataSize = DataSizeOfVariable (CertDbVariable.CurrPtr);\r
2055 Data = GetVariableDataPtr (CertDbVariable.CurrPtr);\r
2056 if ((DataSize == 0) || (Data == NULL)) {\r
2057 ASSERT (FALSE);\r
2058 return EFI_NOT_FOUND;\r
2059 }\r
2060\r
2061 //\r
2062 // Find whether matching cert node already exists in "certdb".\r
2063 // If yes return error.\r
2064 //\r
2065 Status = FindCertsFromDb (\r
2066 VariableName,\r
2067 VendorGuid,\r
2068 Data,\r
2069 DataSize,\r
2070 NULL,\r
2071 NULL,\r
2072 NULL,\r
2073 NULL\r
2074 );\r
2075\r
2076 if (!EFI_ERROR (Status)) {\r
2077 ASSERT (FALSE);\r
2078 return EFI_ACCESS_DENIED;\r
2079 }\r
2080\r
2081 //\r
2082 // Construct new data content of variable "certdb".\r
2083 //\r
2084 NameSize = (UINT32) StrLen (VariableName);\r
20333c6d 2085 CertNodeSize = sizeof (AUTH_CERT_DB_DATA) + (UINT32) CertDataSize + NameSize * sizeof (CHAR16);\r
f6e23353 2086 NewCertDbSize = (UINT32) DataSize + CertNodeSize;\r
4ccef561 2087 if (NewCertDbSize > mMaxCertDbSize) {\r
ed47ae02 2088 return EFI_OUT_OF_RESOURCES;\r
2089 }\r
f6e23353 2090 NewCertDb = (UINT8*) mCertDbStore;\r
ed47ae02 2091\r
2092 //\r
2093 // Copy the DB entries before deleting node.\r
2094 //\r
2095 CopyMem (NewCertDb, Data, DataSize);\r
2096 //\r
2097 // Update CertDbListSize.\r
2098 //\r
2099 CopyMem (NewCertDb, &NewCertDbSize, sizeof (UINT32));\r
2100 //\r
2101 // Construct new cert node.\r
2102 //\r
2103 Ptr = (AUTH_CERT_DB_DATA *) (NewCertDb + DataSize);\r
2104 CopyGuid (&Ptr->VendorGuid, VendorGuid);\r
2105 CopyMem (&Ptr->CertNodeSize, &CertNodeSize, sizeof (UINT32));\r
2106 CopyMem (&Ptr->NameSize, &NameSize, sizeof (UINT32));\r
2107 CopyMem (&Ptr->CertDataSize, &CertDataSize, sizeof (UINT32));\r
20333c6d 2108\r
ed47ae02 2109 CopyMem (\r
2110 (UINT8 *) Ptr + sizeof (AUTH_CERT_DB_DATA),\r
2111 VariableName,\r
2112 NameSize * sizeof (CHAR16)\r
2113 );\r
2114\r
2115 CopyMem (\r
2116 (UINT8 *) Ptr + sizeof (AUTH_CERT_DB_DATA) + NameSize * sizeof (CHAR16),\r
2117 CertData,\r
2118 CertDataSize\r
2119 );\r
20333c6d 2120\r
ed47ae02 2121 //\r
2122 // Set "certdb".\r
20333c6d
QL		 2123 //\r
2124 VarAttr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS;\r
ed47ae02 2125 Status = UpdateVariable (\r
2126 EFI_CERT_DB_NAME,\r
2127 &gEfiCertDbGuid,\r
2128 NewCertDb,\r
2129 NewCertDbSize,\r
2130 VarAttr,\r
2131 0,\r
2132 0,\r
2133 &CertDbVariable,\r
2134 NULL\r
2135 );\r
2136\r
ed47ae02 2137 return Status;\r
2138}\r
2139\r
0c18794e 2140/**\r
2141 Process variable with EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS set\r
2142\r
dc204d5a
JY		 2143 Caution: This function may receive untrusted input.\r
2144 This function may be invoked in SMM mode, and datasize and data are external input.\r
2145 This function will do basic validation, before parse the data.\r
2146 This function will parse the authentication carefully to avoid security issues, like\r
2147 buffer overflow, integer overflow.\r
2148\r
0c18794e 2149 @param[in] VariableName Name of Variable to be found.\r
2150 @param[in] VendorGuid Variable vendor GUID.\r
2151 @param[in] Data Data pointer.\r
2152 @param[in] DataSize Size of Data found. If size is less than the\r
2153 data, this value contains the required size.\r
2154 @param[in] Variable The variable information which is used to keep track of variable usage.\r
2155 @param[in] Attributes Attribute value of the variable.\r
785d84ea 2156 @param[in] AuthVarType Verify against PK, KEK database, private database or certificate in data payload.\r
0c18794e 2157 @param[out] VarDel Delete the variable or not.\r
2158\r
2159 @retval EFI_INVALID_PARAMETER Invalid parameter.\r
2d3fb919 2160 @retval EFI_SECURITY_VIOLATION The variable does NOT pass the validation\r
2161 check carried out by the firmware.\r
0c18794e 2162 @retval EFI_OUT_OF_RESOURCES Failed to process variable due to lack\r
2163 of resources.\r
2164 @retval EFI_SUCCESS Variable pass validation successfully.\r
2165\r
2166**/\r
2167EFI_STATUS\r
2168VerifyTimeBasedPayload (\r
2169 IN CHAR16 *VariableName,\r
2170 IN EFI_GUID *VendorGuid,\r
2171 IN VOID *Data,\r
2172 IN UINTN DataSize,\r
2173 IN VARIABLE_POINTER_TRACK *Variable,\r
2174 IN UINT32 Attributes,\r
ed47ae02 2175 IN AUTHVAR_TYPE AuthVarType,\r
0c18794e 2176 OUT BOOLEAN *VarDel\r
2177 )\r
2178{\r
2179 UINT8 *RootCert;\r
2180 UINT8 *SigData;\r
2d3fb919 2181 UINT8 *PayloadPtr;\r
0c18794e 2182 UINTN RootCertSize;\r
2183 UINTN Index;\r
2d3fb919 2184 UINTN CertCount;\r
2185 UINTN PayloadSize;\r
0c18794e 2186 UINT32 Attr;\r
2187 UINT32 SigDataSize;\r
2188 UINT32 KekDataSize;\r
0c18794e 2189 BOOLEAN VerifyStatus;\r
2190 EFI_STATUS Status;\r
2191 EFI_SIGNATURE_LIST *CertList;\r
2192 EFI_SIGNATURE_DATA *Cert;\r
2193 VARIABLE_POINTER_TRACK KekVariable;\r
2194 EFI_VARIABLE_AUTHENTICATION_2 *CertData;\r
2195 UINT8 *NewData;\r
2196 UINTN NewDataSize;\r
2197 VARIABLE_POINTER_TRACK PkVariable;\r
2d3fb919 2198 UINT8 *Buffer;\r
2199 UINTN Length;\r
ed47ae02 2200 UINT8 *SignerCerts;\r
2201 UINT8 *WrapSigData;\r
2202 UINTN CertStackSize;\r
2203 UINT8 *CertsInCertDb;\r
2204 UINT32 CertsSizeinDb;\r
0c18794e 2205\r
0c18794e 2206 VerifyStatus = FALSE;\r
2207 CertData = NULL;\r
2208 NewData = NULL;\r
2209 Attr = Attributes;\r
ed47ae02 2210 WrapSigData = NULL;\r
2211 SignerCerts = NULL;\r
2212 RootCert = NULL;\r
d4193108 2213 CertsInCertDb = NULL;\r
0c18794e 2214\r
2215 //\r
2d3fb919 2216 // When the attribute EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS is\r
0c18794e 2217 // set, then the Data buffer shall begin with an instance of a complete (and serialized)\r
2d3fb919 2218 // EFI_VARIABLE_AUTHENTICATION_2 descriptor. The descriptor shall be followed by the new\r
2219 // variable value and DataSize shall reflect the combined size of the descriptor and the new\r
2220 // variable value. The authentication descriptor is not part of the variable data and is not\r
0c18794e 2221 // returned by subsequent calls to GetVariable().\r
2222 //\r
2223 CertData = (EFI_VARIABLE_AUTHENTICATION_2 *) Data;\r
2d3fb919 2224\r
2225 //\r
2226 // Verify that Pad1, Nanosecond, TimeZone, Daylight and Pad2 components of the\r
2227 // TimeStamp value are set to zero.\r
2228 //\r
2229 if ((CertData->TimeStamp.Pad1 != 0) ||\r
2230 (CertData->TimeStamp.Nanosecond != 0) ||\r
2231 (CertData->TimeStamp.TimeZone != 0) ||\r
2232 (CertData->TimeStamp.Daylight != 0) ||\r
2233 (CertData->TimeStamp.Pad2 != 0)) {\r
2e24814a 2234 return EFI_SECURITY_VIOLATION;\r
2d3fb919 2235 }\r
2236\r
0c18794e 2237 if ((Variable->CurrPtr != NULL) && ((Attributes & EFI_VARIABLE_APPEND_WRITE) == 0)) {\r
2238 if (CompareTimeStamp (&CertData->TimeStamp, &Variable->CurrPtr->TimeStamp)) {\r
2239 //\r
2240 // TimeStamp check fail, suspicious replay attack, return EFI_SECURITY_VIOLATION.\r
2241 //\r
2242 return EFI_SECURITY_VIOLATION;\r
2243 }\r
2244 }\r
2245\r
2246 //\r
2247 // wCertificateType should be WIN_CERT_TYPE_EFI_GUID.\r
2248 // Cert type should be EFI_CERT_TYPE_PKCS7_GUID.\r
2249 //\r
2250 if ((CertData->AuthInfo.Hdr.wCertificateType != WIN_CERT_TYPE_EFI_GUID) ||\r
2d3fb919 2251 !CompareGuid (&CertData->AuthInfo.CertType, &gEfiCertPkcs7Guid)) {\r
0c18794e 2252 //\r
2253 // Invalid AuthInfo type, return EFI_SECURITY_VIOLATION.\r
2254 //\r
2255 return EFI_SECURITY_VIOLATION;\r
2256 }\r
2d3fb919 2257\r
0c18794e 2258 //\r
2259 // Find out Pkcs7 SignedData which follows the EFI_VARIABLE_AUTHENTICATION_2 descriptor.\r
2260 // AuthInfo.Hdr.dwLength is the length of the entire certificate, including the length of the header.\r
2261 //\r
2d3fb919 2262 SigData = CertData->AuthInfo.CertData;\r
2263 SigDataSize = CertData->AuthInfo.Hdr.dwLength - (UINT32) (OFFSET_OF (WIN_CERTIFICATE_UEFI_GUID, CertData));\r
648f98d1 2264\r
0c18794e 2265 //\r
2266 // Find out the new data payload which follows Pkcs7 SignedData directly.\r
2267 //\r
2d3fb919 2268 PayloadPtr = SigData + SigDataSize;\r
2269 PayloadSize = DataSize - OFFSET_OF_AUTHINFO2_CERT_DATA - (UINTN) SigDataSize;\r
0c18794e 2270\r
2271 //\r
2272 // Construct a buffer to fill with (VariableName, VendorGuid, Attributes, TimeStamp, Data).\r
2273 //\r
2d3fb919 2274 NewDataSize = PayloadSize + sizeof (EFI_TIME) + sizeof (UINT32) +\r
2275 sizeof (EFI_GUID) + StrSize (VariableName) - sizeof (CHAR16);\r
2276 NewData = mSerializationRuntimeBuffer;\r
0c18794e 2277\r
2d3fb919 2278 Buffer = NewData;\r
2279 Length = StrLen (VariableName) * sizeof (CHAR16);\r
2280 CopyMem (Buffer, VariableName, Length);\r
2281 Buffer += Length;\r
0c18794e 2282\r
2d3fb919 2283 Length = sizeof (EFI_GUID);\r
2284 CopyMem (Buffer, VendorGuid, Length);\r
2285 Buffer += Length;\r
0c18794e 2286\r
2d3fb919 2287 Length = sizeof (UINT32);\r
2288 CopyMem (Buffer, &Attr, Length);\r
2289 Buffer += Length;\r
0c18794e 2290\r
2d3fb919 2291 Length = sizeof (EFI_TIME);\r
2292 CopyMem (Buffer, &CertData->TimeStamp, Length);\r
2293 Buffer += Length;\r
0c18794e 2294\r
2d3fb919 2295 CopyMem (Buffer, PayloadPtr, PayloadSize);\r
0c18794e 2296\r
ed47ae02 2297 if (AuthVarType == AuthVarTypePk) {\r
0c18794e 2298 //\r
74b5fd7a
FS		 2299 // Verify that the signature has been made with the current Platform Key (no chaining for PK).\r
2300 // First, get signer's certificates from SignedData.\r
2301 //\r
2302 VerifyStatus = Pkcs7GetSigners (\r
2303 SigData,\r
2304 SigDataSize,\r
2305 &SignerCerts,\r
2306 &CertStackSize,\r
2307 &RootCert,\r
2308 &RootCertSize\r
2309 );\r
2310 if (!VerifyStatus) {\r
2311 goto Exit;\r
2312 }\r
2313\r
2314 //\r
2315 // Second, get the current platform key from variable. Check whether it's identical with signer's certificates\r
2316 // in SignedData. If not, return error immediately.\r
0c18794e 2317 //\r
2318 Status = FindVariable (\r
2d3fb919 2319 EFI_PLATFORM_KEY_NAME,\r
2320 &gEfiGlobalVariableGuid,\r
2321 &PkVariable,\r
ecc722ad 2322 &mVariableModuleGlobal->VariableGlobal,\r
2323 FALSE\r
0c18794e 2324 );\r
2325 if (EFI_ERROR (Status)) {\r
74b5fd7a
FS		 2326 VerifyStatus = FALSE;\r
2327 goto Exit;\r
0c18794e 2328 }\r
0c18794e 2329 CertList = (EFI_SIGNATURE_LIST *) GetVariableDataPtr (PkVariable.CurrPtr);\r
2330 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertList + sizeof (EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);\r
74b5fd7a
FS		 2331 if ((RootCertSize != (CertList->SignatureSize - (sizeof (EFI_SIGNATURE_DATA) - 1))) ||\r
2332 (CompareMem (Cert->SignatureData, RootCert, RootCertSize) != 0)) {\r
2333 VerifyStatus = FALSE;\r
2334 goto Exit;\r
2335 }\r
0c18794e 2336\r
2337 //\r
2338 // Verify Pkcs7 SignedData via Pkcs7Verify library.\r
2339 //\r
2340 VerifyStatus = Pkcs7Verify (\r
2341 SigData,\r
2342 SigDataSize,\r
2343 RootCert,\r
2344 RootCertSize,\r
2345 NewData,\r
2346 NewDataSize\r
2347 );\r
2348\r
ed47ae02 2349 } else if (AuthVarType == AuthVarTypeKek) {\r
2d3fb919 2350\r
0c18794e 2351 //\r
2352 // Get KEK database from variable.\r
2353 //\r
2354 Status = FindVariable (\r
2d3fb919 2355 EFI_KEY_EXCHANGE_KEY_NAME,\r
2356 &gEfiGlobalVariableGuid,\r
2357 &KekVariable,\r
ecc722ad 2358 &mVariableModuleGlobal->VariableGlobal,\r
2359 FALSE\r
0c18794e 2360 );\r
2361 if (EFI_ERROR (Status)) {\r
2362 return Status;\r
2363 }\r
2364\r
2365 //\r
2366 // Ready to verify Pkcs7 SignedData. Go through KEK Signature Database to find out X.509 CertList.\r
2d3fb919 2367 //\r
0c18794e 2368 KekDataSize = KekVariable.CurrPtr->DataSize;\r
2369 CertList = (EFI_SIGNATURE_LIST *) GetVariableDataPtr (KekVariable.CurrPtr);\r
2370 while ((KekDataSize > 0) && (KekDataSize >= CertList->SignatureListSize)) {\r
2371 if (CompareGuid (&CertList->SignatureType, &gEfiCertX509Guid)) {\r
2372 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertList + sizeof (EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);\r
2373 CertCount = (CertList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - CertList->SignatureHeaderSize) / CertList->SignatureSize;\r
2374 for (Index = 0; Index < CertCount; Index++) {\r
2375 //\r
2376 // Iterate each Signature Data Node within this CertList for a verify\r
2377 //\r
2378 RootCert = Cert->SignatureData;\r
4e33001c 2379 RootCertSize = CertList->SignatureSize - (sizeof (EFI_SIGNATURE_DATA) - 1);\r
2d3fb919 2380\r
0c18794e 2381 //\r
2382 // Verify Pkcs7 SignedData via Pkcs7Verify library.\r
2383 //\r
2384 VerifyStatus = Pkcs7Verify (\r
2385 SigData,\r
2386 SigDataSize,\r
2387 RootCert,\r
2388 RootCertSize,\r
2389 NewData,\r
2390 NewDataSize\r
2391 );\r
2392 if (VerifyStatus) {\r
2393 goto Exit;\r
2394 }\r
2395 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) Cert + CertList->SignatureSize);\r
2396 }\r
2397 }\r
2398 KekDataSize -= CertList->SignatureListSize;\r
2399 CertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) CertList + CertList->SignatureListSize);\r
2400 }\r
ed47ae02 2401 } else if (AuthVarType == AuthVarTypePriv) {\r
2402\r
2403 //\r
20333c6d 2404 // Process common authenticated variable except PK/KEK/DB/DBX/DBT.\r
ed47ae02 2405 // Get signer's certificates from SignedData.\r
2406 //\r
2407 VerifyStatus = Pkcs7GetSigners (\r
2408 SigData,\r
2409 SigDataSize,\r
2410 &SignerCerts,\r
2411 &CertStackSize,\r
2412 &RootCert,\r
2413 &RootCertSize\r
2414 );\r
2415 if (!VerifyStatus) {\r
2416 goto Exit;\r
2417 }\r
2418\r
2419 //\r
2420 // Get previously stored signer's certificates from certdb for existing\r
2421 // variable. Check whether they are identical with signer's certificates\r
2422 // in SignedData. If not, return error immediately.\r
2423 //\r
2424 if ((Variable->CurrPtr != NULL)) {\r
2425 VerifyStatus = FALSE;\r
2426\r
2427 Status = GetCertsFromDb (VariableName, VendorGuid, &CertsInCertDb, &CertsSizeinDb);\r
2428 if (EFI_ERROR (Status)) {\r
2429 goto Exit;\r
2430 }\r
20333c6d 2431\r
ed47ae02 2432 if ((CertStackSize != CertsSizeinDb) ||\r
2433 (CompareMem (SignerCerts, CertsInCertDb, CertsSizeinDb) != 0)) {\r
2434 goto Exit;\r
2435 }\r
2436 }\r
2437\r
2438 VerifyStatus = Pkcs7Verify (\r
2439 SigData,\r
2440 SigDataSize,\r
2441 RootCert,\r
2442 RootCertSize,\r
2443 NewData,\r
2444 NewDataSize\r
2445 );\r
2446 if (!VerifyStatus) {\r
2447 goto Exit;\r
2448 }\r
2449\r
2450 //\r
2451 // Delete signer's certificates when delete the common authenticated variable.\r
2452 //\r
275beb2b 2453 if ((PayloadSize == 0) && (Variable->CurrPtr != NULL) && ((Attributes & EFI_VARIABLE_APPEND_WRITE) == 0)) {\r
ed47ae02 2454 Status = DeleteCertsFromDb (VariableName, VendorGuid);\r
2455 if (EFI_ERROR (Status)) {\r
2456 VerifyStatus = FALSE;\r
2457 goto Exit;\r
2458 }\r
275beb2b 2459 } else if (Variable->CurrPtr == NULL && PayloadSize != 0) {\r
ed47ae02 2460 //\r
2461 // Insert signer's certificates when adding a new common authenticated variable.\r
2462 //\r
2463 Status = InsertCertsToDb (VariableName, VendorGuid, SignerCerts, CertStackSize);\r
2464 if (EFI_ERROR (Status)) {\r
2465 VerifyStatus = FALSE;\r
2466 goto Exit;\r
2467 }\r
2468 }\r
785d84ea 2469 } else if (AuthVarType == AuthVarTypePayload) {\r
2470 CertList = (EFI_SIGNATURE_LIST *) PayloadPtr;\r
2471 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertList + sizeof (EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);\r
2472 RootCert = Cert->SignatureData;\r
2473 RootCertSize = CertList->SignatureSize - (sizeof (EFI_SIGNATURE_DATA) - 1);\r
20333c6d 2474\r
785d84ea 2475 // Verify Pkcs7 SignedData via Pkcs7Verify library.\r
2476 //\r
2477 VerifyStatus = Pkcs7Verify (\r
2478 SigData,\r
2479 SigDataSize,\r
2480 RootCert,\r
2481 RootCertSize,\r
2482 NewData,\r
2483 NewDataSize\r
2484 );\r
ed47ae02 2485 } else {\r
2486 return EFI_SECURITY_VIOLATION;\r
0c18794e 2487 }\r
2488\r
2489Exit:\r
2490\r
74b5fd7a 2491 if (AuthVarType == AuthVarTypePk || AuthVarType == AuthVarTypePriv) {\r
ed47ae02 2492 Pkcs7FreeSigners (RootCert);\r
2493 Pkcs7FreeSigners (SignerCerts);\r
2494 }\r
2495\r
0c18794e 2496 if (!VerifyStatus) {\r
2497 return EFI_SECURITY_VIOLATION;\r
2498 }\r
2499\r
d912bad7 2500 Status = CheckSignatureListFormat(VariableName, VendorGuid, PayloadPtr, PayloadSize);\r
2501 if (EFI_ERROR (Status)) {\r
2502 return Status;\r
2503 }\r
2504\r
2d3fb919 2505 if ((PayloadSize == 0) && (VarDel != NULL)) {\r
0c18794e 2506 *VarDel = TRUE;\r
2507 }\r
2d3fb919 2508\r
0c18794e 2509 //\r
2510 // Final step: Update/Append Variable if it pass Pkcs7Verify\r
2511 //\r
ed47ae02 2512 return UpdateVariable (\r
2513 VariableName,\r
2514 VendorGuid,\r
2515 PayloadPtr,\r
2516 PayloadSize,\r
2517 Attributes,\r
2518 0,\r
2519 0,\r
2520 Variable,\r
2521 &CertData->TimeStamp\r
2522 );\r
0c18794e 2523}\r
EFI Development Kit II mirror for PVE