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