]> 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
New EDK Shell binary(r63).
[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
678 UINT32 VarAttr;\r
679 UINT8 SecureBootMode;\r
beda2356 680 UINT8 SecureBootEnable;\r
681 UINTN VariableDataSize;\r
2d3fb919 682\r
0c18794e 683 Status = FindVariable (\r
2d3fb919 684 EFI_SETUP_MODE_NAME,\r
685 &gEfiGlobalVariableGuid,\r
686 &Variable,\r
ecc722ad 687 &mVariableModuleGlobal->VariableGlobal,\r
688 FALSE\r
0c18794e 689 );\r
690 if (EFI_ERROR (Status)) {\r
691 return Status;\r
692 }\r
693\r
05a643f9 694 //\r
695 // Update the value of SetupMode variable by a simple mem copy, this could avoid possible\r
696 // variable storage reclaim at runtime.\r
697 //\r
698 mPlatformMode = (UINT8) Mode;\r
699 CopyMem (GetVariableDataPtr (Variable.CurrPtr), &mPlatformMode, sizeof(UINT8));\r
0c18794e 700\r
2d3fb919 701 if (AtRuntime ()) {\r
702 //\r
703 // SecureBoot Variable indicates whether the platform firmware is operating\r
704 // in Secure boot mode (1) or not (0), so we should not change SecureBoot\r
705 // Variable in runtime.\r
706 //\r
707 return Status;\r
708 }\r
709\r
0c18794e 710 //\r
711 // Check "SecureBoot" variable's existence.\r
712 // If it doesn't exist, firmware has no capability to perform driver signing verification,\r
713 // then set "SecureBoot" to 0.\r
714 //\r
715 Status = FindVariable (\r
2d3fb919 716 EFI_SECURE_BOOT_MODE_NAME,\r
717 &gEfiGlobalVariableGuid,\r
718 &Variable,\r
ecc722ad 719 &mVariableModuleGlobal->VariableGlobal,\r
720 FALSE\r
0c18794e 721 );\r
722 //\r
723 // If "SecureBoot" variable exists, then check "SetupMode" variable update.\r
724 // If "SetupMode" variable is USER_MODE, "SecureBoot" variable is set to 1.\r
725 // If "SetupMode" variable is SETUP_MODE, "SecureBoot" variable is set to 0.\r
726 //\r
727 if (Variable.CurrPtr == NULL) {\r
728 SecureBootMode = SECURE_BOOT_MODE_DISABLE;\r
729 } else {\r
730 if (mPlatformMode == USER_MODE) {\r
731 SecureBootMode = SECURE_BOOT_MODE_ENABLE;\r
732 } else if (mPlatformMode == SETUP_MODE) {\r
733 SecureBootMode = SECURE_BOOT_MODE_DISABLE;\r
734 } else {\r
735 return EFI_NOT_FOUND;\r
736 }\r
737 }\r
738\r
2d3fb919 739 VarAttr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS;\r
beda2356 740 Status = UpdateVariable (\r
0c18794e 741 EFI_SECURE_BOOT_MODE_NAME,\r
742 &gEfiGlobalVariableGuid,\r
743 &SecureBootMode,\r
744 sizeof(UINT8),\r
745 VarAttr,\r
746 0,\r
747 0,\r
748 &Variable,\r
749 NULL\r
750 );\r
beda2356 751 if (EFI_ERROR (Status)) {\r
752 return Status;\r
753 }\r
754\r
755 //\r
756 // Check "SecureBootEnable" variable's existence. It can enable/disable secure boot feature.\r
757 //\r
758 Status = FindVariable (\r
2d3fb919 759 EFI_SECURE_BOOT_ENABLE_NAME,\r
760 &gEfiSecureBootEnableDisableGuid,\r
761 &Variable,\r
ecc722ad 762 &mVariableModuleGlobal->VariableGlobal,\r
763 FALSE\r
beda2356 764 );\r
2d3fb919 765\r
beda2356 766 if (SecureBootMode == SECURE_BOOT_MODE_ENABLE) {\r
767 //\r
768 // Create the "SecureBootEnable" variable as secure boot is enabled.\r
769 //\r
770 SecureBootEnable = SECURE_BOOT_ENABLE;\r
771 VariableDataSize = sizeof (SecureBootEnable);\r
772 } else {\r
773 //\r
2d3fb919 774 // Delete the "SecureBootEnable" variable if this variable exist as "SecureBoot"\r
beda2356 775 // variable is not in secure boot state.\r
776 //\r
777 if (Variable.CurrPtr == NULL || EFI_ERROR (Status)) {\r
778 return EFI_SUCCESS;\r
779 }\r
780 SecureBootEnable = SECURE_BOOT_DISABLE;\r
781 VariableDataSize = 0;\r
782 }\r
2d3fb919 783\r
beda2356 784 Status = UpdateVariable (\r
2d3fb919 785 EFI_SECURE_BOOT_ENABLE_NAME,\r
786 &gEfiSecureBootEnableDisableGuid,\r
787 &SecureBootEnable,\r
788 VariableDataSize,\r
789 EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,\r
790 0,\r
791 0,\r
beda2356 792 &Variable,\r
793 NULL\r
794 );\r
795 return Status;\r
0c18794e 796}\r
797\r
d912bad7 798/**\r
e77f9ef6 799 Check input data form to make sure it is a valid EFI_SIGNATURE_LIST for PK/KEK/db/dbx variable.\r
d912bad7 800\r
801 @param[in] VariableName Name of Variable to be check.\r
802 @param[in] VendorGuid Variable vendor GUID.\r
803 @param[in] Data Point to the variable data to be checked.\r
804 @param[in] DataSize Size of Data.\r
805\r
806 @return EFI_INVALID_PARAMETER Invalid signature list format.\r
807 @return EFI_SUCCESS Passed signature list format check successfully.\r
808 \r
809**/\r
810EFI_STATUS\r
811CheckSignatureListFormat(\r
812 IN CHAR16 *VariableName,\r
813 IN EFI_GUID *VendorGuid,\r
814 IN VOID *Data,\r
815 IN UINTN DataSize\r
816 )\r
817{\r
818 EFI_SIGNATURE_LIST *SigList;\r
819 UINTN SigDataSize;\r
820 UINT32 Index;\r
821 UINT32 SigCount;\r
822 BOOLEAN IsPk;\r
e77f9ef6 823 VOID *RsaContext;\r
824 EFI_SIGNATURE_DATA *CertData;\r
825 UINTN CertLen;\r
d912bad7 826\r
827 if (DataSize == 0) {\r
828 return EFI_SUCCESS;\r
829 }\r
830\r
831 ASSERT (VariableName != NULL && VendorGuid != NULL && Data != NULL);\r
832\r
833 if (CompareGuid (VendorGuid, &gEfiGlobalVariableGuid) && (StrCmp (VariableName, EFI_PLATFORM_KEY_NAME) == 0)){\r
834 IsPk = TRUE;\r
e77f9ef6 835 } else if ((CompareGuid (VendorGuid, &gEfiGlobalVariableGuid) && StrCmp (VariableName, EFI_KEY_EXCHANGE_KEY_NAME) == 0) ||\r
836 (CompareGuid (VendorGuid, &gEfiImageSecurityDatabaseGuid) && \r
837 (StrCmp (VariableName, EFI_IMAGE_SECURITY_DATABASE) == 0 || StrCmp (VariableName, EFI_IMAGE_SECURITY_DATABASE1) == 0))){\r
d912bad7 838 IsPk = FALSE;\r
839 } else {\r
840 return EFI_SUCCESS;\r
841 }\r
842\r
843 SigCount = 0;\r
844 SigList = (EFI_SIGNATURE_LIST *) Data;\r
845 SigDataSize = DataSize;\r
e77f9ef6 846 RsaContext = NULL;\r
d912bad7 847\r
848 //\r
849 // Walk throuth the input signature list and check the data format.\r
850 // If any signature is incorrectly formed, the whole check will fail.\r
851 //\r
852 while ((SigDataSize > 0) && (SigDataSize >= SigList->SignatureListSize)) {\r
853 for (Index = 0; Index < (sizeof (mSupportSigItem) / sizeof (EFI_SIGNATURE_ITEM)); Index++ ) {\r
854 if (CompareGuid (&SigList->SignatureType, &mSupportSigItem[Index].SigType)) {\r
855 //\r
856 // The value of SignatureSize should always be 16 (size of SignatureOwner \r
857 // component) add the data length according to signature type.\r
858 //\r
859 if (mSupportSigItem[Index].SigDataSize != ((UINT32) ~0) && \r
860 (SigList->SignatureSize - sizeof (EFI_GUID)) != mSupportSigItem[Index].SigDataSize) {\r
861 return EFI_INVALID_PARAMETER;\r
862 }\r
863 if (mSupportSigItem[Index].SigHeaderSize != ((UINTN) ~0) &&\r
864 SigList->SignatureHeaderSize != mSupportSigItem[Index].SigHeaderSize) {\r
865 return EFI_INVALID_PARAMETER;\r
866 }\r
867 break;\r
868 }\r
869 }\r
870\r
871 if (Index == (sizeof (mSupportSigItem) / sizeof (EFI_SIGNATURE_ITEM))) {\r
872 //\r
873 // Undefined signature type.\r
874 //\r
875 return EFI_INVALID_PARAMETER;\r
876 }\r
877\r
e77f9ef6 878 if (CompareGuid (&SigList->SignatureType, &gEfiCertX509Guid)) {\r
879 //\r
880 // Try to retrieve the RSA public key from the X.509 certificate.\r
881 // If this operation fails, it's not a valid certificate.\r
882 //\r
883 RsaContext = RsaNew ();\r
884 if (RsaContext == NULL) {\r
885 return EFI_INVALID_PARAMETER;\r
886 }\r
887 CertData = (EFI_SIGNATURE_DATA *) ((UINT8 *) SigList + sizeof (EFI_SIGNATURE_LIST) + SigList->SignatureHeaderSize);\r
888 CertLen = SigList->SignatureSize - sizeof (EFI_GUID);\r
889 if (!RsaGetPublicKeyFromX509 (CertData->SignatureData, CertLen, &RsaContext)) {\r
890 RsaFree (RsaContext);\r
891 return EFI_INVALID_PARAMETER;\r
892 }\r
893 RsaFree (RsaContext);\r
894 }\r
895\r
d912bad7 896 if ((SigList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - SigList->SignatureHeaderSize) % SigList->SignatureSize != 0) {\r
897 return EFI_INVALID_PARAMETER;\r
898 }\r
899 SigCount += (SigList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - SigList->SignatureHeaderSize) / SigList->SignatureSize;\r
900 \r
901 SigDataSize -= SigList->SignatureListSize;\r
902 SigList = (EFI_SIGNATURE_LIST *) ((UINT8 *) SigList + SigList->SignatureListSize);\r
903 }\r
904\r
905 if (((UINTN) SigList - (UINTN) Data) != DataSize) {\r
906 return EFI_INVALID_PARAMETER;\r
907 }\r
908\r
909 if (IsPk && SigCount > 1) {\r
910 return EFI_INVALID_PARAMETER;\r
911 }\r
912\r
913 return EFI_SUCCESS;\r
914}\r
915\r
0c18794e 916/**\r
917 Process variable with platform key for verification.\r
918\r
dc204d5a
JY		 919 Caution: This function may receive untrusted input.\r
920 This function may be invoked in SMM mode, and datasize and data are external input.\r
921 This function will do basic validation, before parse the data.\r
922 This function will parse the authentication carefully to avoid security issues, like\r
923 buffer overflow, integer overflow.\r
924 This function will check attribute carefully to avoid authentication bypass.\r
925\r
0c18794e 926 @param[in] VariableName Name of Variable to be found.\r
927 @param[in] VendorGuid Variable vendor GUID.\r
928 @param[in] Data Data pointer.\r
929 @param[in] DataSize Size of Data found. If size is less than the\r
930 data, this value contains the required size.\r
931 @param[in] Variable The variable information which is used to keep track of variable usage.\r
932 @param[in] Attributes Attribute value of the variable\r
933 @param[in] IsPk Indicate whether it is to process pk.\r
934\r
935 @return EFI_INVALID_PARAMETER Invalid parameter.\r
2d3fb919 936 @return EFI_SECURITY_VIOLATION The variable does NOT pass the validation.\r
937 check carried out by the firmware.\r
0c18794e 938 @return EFI_SUCCESS Variable passed validation successfully.\r
939\r
940**/\r
941EFI_STATUS\r
942ProcessVarWithPk (\r
943 IN CHAR16 *VariableName,\r
944 IN EFI_GUID *VendorGuid,\r
945 IN VOID *Data,\r
946 IN UINTN DataSize,\r
947 IN VARIABLE_POINTER_TRACK *Variable,\r
948 IN UINT32 Attributes OPTIONAL,\r
949 IN BOOLEAN IsPk\r
950 )\r
951{\r
952 EFI_STATUS Status;\r
0c18794e 953 BOOLEAN Del;\r
2d3fb919 954 UINT8 *Payload;\r
955 UINTN PayloadSize;\r
0c18794e 956\r
8c1babfd 957 if ((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0 || \r
958 (Attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) == 0) {\r
0c18794e 959 //\r
05a643f9 960 // PK, KEK and db/dbx should set EFI_VARIABLE_NON_VOLATILE attribute and should be a time-based\r
8c1babfd 961 // authenticated variable.\r
0c18794e 962 //\r
963 return EFI_INVALID_PARAMETER;\r
964 }\r
965\r
785d84ea 966 Del = FALSE;\r
967 if ((InCustomMode() && UserPhysicalPresent()) || (mPlatformMode == SETUP_MODE && !IsPk)) {\r
8c1babfd 968 Payload = (UINT8 *) Data + AUTHINFO2_SIZE (Data);\r
969 PayloadSize = DataSize - AUTHINFO2_SIZE (Data);\r
785d84ea 970 if (PayloadSize == 0) {\r
971 Del = TRUE;\r
972 }\r
2d3fb919 973\r
d912bad7 974 Status = CheckSignatureListFormat(VariableName, VendorGuid, Payload, PayloadSize);\r
975 if (EFI_ERROR (Status)) {\r
976 return Status;\r
977 }\r
978\r
2d3fb919 979 Status = UpdateVariable (\r
980 VariableName,\r
981 VendorGuid,\r
982 Payload,\r
983 PayloadSize,\r
984 Attributes,\r
985 0,\r
8c1babfd 986 0,\r
2d3fb919 987 Variable,\r
8c1babfd 988 &((EFI_VARIABLE_AUTHENTICATION_2 *) Data)->TimeStamp\r
2d3fb919 989 );\r
785d84ea 990 } else if (mPlatformMode == USER_MODE) {\r
991 //\r
992 // Verify against X509 Cert in PK database.\r
993 //\r
994 Status = VerifyTimeBasedPayload (\r
995 VariableName,\r
996 VendorGuid,\r
997 Data,\r
998 DataSize,\r
999 Variable,\r
1000 Attributes,\r
1001 AuthVarTypePk,\r
1002 &Del\r
1003 );\r
1004 } else {\r
1005 //\r
1006 // Verify against the certificate in data payload.\r
1007 //\r
1008 Status = VerifyTimeBasedPayload (\r
1009 VariableName,\r
1010 VendorGuid,\r
1011 Data,\r
1012 DataSize,\r
1013 Variable,\r
1014 Attributes,\r
1015 AuthVarTypePayload,\r
1016 &Del\r
1017 );\r
1018 }\r
ecc722ad 1019\r
785d84ea 1020 if (!EFI_ERROR(Status) && IsPk) {\r
1021 if (mPlatformMode == SETUP_MODE && !Del) {\r
1022 //\r
1023 // If enroll PK in setup mode, need change to user mode.\r
1024 //\r
1025 Status = UpdatePlatformMode (USER_MODE);\r
1026 } else if (mPlatformMode == USER_MODE && Del){\r
1027 //\r
1028 // If delete PK in user mode, need change to setup mode.\r
1029 //\r
1030 Status = UpdatePlatformMode (SETUP_MODE);\r
1031 }\r
0c18794e 1032 }\r
1033\r
1034 return Status;\r
1035}\r
1036\r
1037/**\r
1038 Process variable with key exchange key for verification.\r
1039\r
dc204d5a
JY		 1040 Caution: This function may receive untrusted input.\r
1041 This function may be invoked in SMM mode, and datasize and data are external input.\r
1042 This function will do basic validation, before parse the data.\r
1043 This function will parse the authentication carefully to avoid security issues, like\r
1044 buffer overflow, integer overflow.\r
1045 This function will check attribute carefully to avoid authentication bypass.\r
1046\r
0c18794e 1047 @param[in] VariableName Name of Variable to be found.\r
1048 @param[in] VendorGuid Variable vendor GUID.\r
1049 @param[in] Data Data pointer.\r
1050 @param[in] DataSize Size of Data found. If size is less than the\r
1051 data, this value contains the required size.\r
1052 @param[in] Variable The variable information which is used to keep track of variable usage.\r
1053 @param[in] Attributes Attribute value of the variable.\r
1054\r
1055 @return EFI_INVALID_PARAMETER Invalid parameter.\r
2d3fb919 1056 @return EFI_SECURITY_VIOLATION The variable does NOT pass the validation\r
1057 check carried out by the firmware.\r
0c18794e 1058 @return EFI_SUCCESS Variable pass validation successfully.\r
1059\r
1060**/\r
1061EFI_STATUS\r
1062ProcessVarWithKek (\r
1063 IN CHAR16 *VariableName,\r
1064 IN EFI_GUID *VendorGuid,\r
1065 IN VOID *Data,\r
1066 IN UINTN DataSize,\r
1067 IN VARIABLE_POINTER_TRACK *Variable,\r
1068 IN UINT32 Attributes OPTIONAL\r
1069 )\r
1070{\r
1071 EFI_STATUS Status;\r
2d3fb919 1072 UINT8 *Payload;\r
1073 UINTN PayloadSize;\r
ecc722ad 1074\r
8c1babfd 1075 if ((Attributes & EFI_VARIABLE_NON_VOLATILE) == 0 ||\r
1076 (Attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) == 0) {\r
ecc722ad 1077 //\r
8c1babfd 1078 // DB and DBX should set EFI_VARIABLE_NON_VOLATILE attribute and should be a time-based\r
1079 // authenticated variable.\r
ecc722ad 1080 //\r
1081 return EFI_INVALID_PARAMETER;\r
1082 }\r
0c18794e 1083\r
ecc722ad 1084 Status = EFI_SUCCESS;\r
1085 if (mPlatformMode == USER_MODE && !(InCustomMode() && UserPhysicalPresent())) {\r
8c1babfd 1086 //\r
1087 // Time-based, verify against X509 Cert KEK.\r
1088 //\r
1089 return VerifyTimeBasedPayload (\r
1090 VariableName,\r
1091 VendorGuid,\r
1092 Data,\r
1093 DataSize,\r
1094 Variable,\r
1095 Attributes,\r
1096 AuthVarTypeKek,\r
1097 NULL\r
1098 );\r
0c18794e 1099 } else {\r
1100 //\r
ecc722ad 1101 // If in setup mode or custom secure boot mode, no authentication needed.\r
0c18794e 1102 //\r
8c1babfd 1103 Payload = (UINT8 *) Data + AUTHINFO2_SIZE (Data);\r
1104 PayloadSize = DataSize - AUTHINFO2_SIZE (Data);\r
2d3fb919 1105\r
e77f9ef6 1106 Status = CheckSignatureListFormat(VariableName, VendorGuid, Payload, PayloadSize);\r
1107 if (EFI_ERROR (Status)) {\r
1108 return Status;\r
1109 }\r
1110 \r
0c18794e 1111 Status = UpdateVariable (\r
2d3fb919 1112 VariableName,\r
1113 VendorGuid,\r
1114 Payload,\r
1115 PayloadSize,\r
1116 Attributes,\r
1117 0,\r
8c1babfd 1118 0,\r
0c18794e 1119 Variable,\r
8c1babfd 1120 &((EFI_VARIABLE_AUTHENTICATION_2 *) Data)->TimeStamp\r
0c18794e 1121 );\r
1122 }\r
1123\r
1124 return Status;\r
1125}\r
1126\r
1127/**\r
1128 Process variable with EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS/EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS set\r
1129\r
dc204d5a
JY		 1130 Caution: This function may receive untrusted input.\r
1131 This function may be invoked in SMM mode, and datasize and data are external input.\r
1132 This function will do basic validation, before parse the data.\r
1133 This function will parse the authentication carefully to avoid security issues, like\r
1134 buffer overflow, integer overflow.\r
1135 This function will check attribute carefully to avoid authentication bypass.\r
1136\r
0c18794e 1137 @param[in] VariableName Name of Variable to be found.\r
1138 @param[in] VendorGuid Variable vendor GUID.\r
1139\r
1140 @param[in] Data Data pointer.\r
1141 @param[in] DataSize Size of Data found. If size is less than the\r
1142 data, this value contains the required size.\r
1143 @param[in] Variable The variable information which is used to keep track of variable usage.\r
1144 @param[in] Attributes Attribute value of the variable.\r
1145\r
1146 @return EFI_INVALID_PARAMETER Invalid parameter.\r
1147 @return EFI_WRITE_PROTECTED Variable is write-protected and needs authentication with\r
1148 EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS set.\r
275beb2b 1149 @return EFI_OUT_OF_RESOURCES The Database to save the public key is full.\r
0c18794e 1150 @return EFI_SECURITY_VIOLATION The variable is with EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS\r
2d3fb919 1151 set, but the AuthInfo does NOT pass the validation\r
1152 check carried out by the firmware.\r
0c18794e 1153 @return EFI_SUCCESS Variable is not write-protected or pass validation successfully.\r
1154\r
1155**/\r
1156EFI_STATUS\r
1157ProcessVariable (\r
1158 IN CHAR16 *VariableName,\r
1159 IN EFI_GUID *VendorGuid,\r
1160 IN VOID *Data,\r
1161 IN UINTN DataSize,\r
1162 IN VARIABLE_POINTER_TRACK *Variable,\r
1163 IN UINT32 Attributes\r
1164 )\r
1165{\r
1166 EFI_STATUS Status;\r
1167 BOOLEAN IsDeletion;\r
1168 BOOLEAN IsFirstTime;\r
1169 UINT8 *PubKey;\r
1170 EFI_VARIABLE_AUTHENTICATION *CertData;\r
1171 EFI_CERT_BLOCK_RSA_2048_SHA256 *CertBlock;\r
1172 UINT32 KeyIndex;\r
1173 UINT64 MonotonicCount;\r
1174\r
2d3fb919 1175 KeyIndex = 0;\r
0c18794e 1176 CertData = NULL;\r
1177 CertBlock = NULL;\r
1178 PubKey = NULL;\r
1179 IsDeletion = FALSE;\r
1180\r
ecc722ad 1181 if (NeedPhysicallyPresent(VariableName, VendorGuid) && !UserPhysicalPresent()) {\r
1182 //\r
1183 // This variable is protected, only physical present user could modify its value.\r
1184 //\r
1185 return EFI_SECURITY_VIOLATION;\r
1186 }\r
1187 \r
89be2b03 1188 //\r
1189 // A time-based authenticated variable and a count-based authenticated variable\r
1190 // can't be updated by each other.\r
1191 // \r
1192 if (Variable->CurrPtr != NULL) { \r
1193 if (((Attributes & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) != 0) &&\r
1194 ((Variable->CurrPtr->Attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) != 0)) {\r
1195 return EFI_SECURITY_VIOLATION; \r
1196 }\r
1197 \r
1198 if (((Attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) != 0) && \r
1199 ((Variable->CurrPtr->Attributes & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) != 0)) {\r
1200 return EFI_SECURITY_VIOLATION; \r
1201 }\r
1202 }\r
1203 \r
0c18794e 1204 //\r
1205 // Process Time-based Authenticated variable.\r
1206 //\r
1207 if ((Attributes & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) != 0) {\r
ed47ae02 1208 return VerifyTimeBasedPayload (\r
1209 VariableName,\r
1210 VendorGuid,\r
1211 Data,\r
1212 DataSize,\r
1213 Variable,\r
1214 Attributes,\r
1215 AuthVarTypePriv,\r
1216 NULL\r
1217 );\r
0c18794e 1218 }\r
2d3fb919 1219\r
0c18794e 1220 //\r
1221 // Determine if first time SetVariable with the EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS.\r
1222 //\r
1223 if ((Attributes & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) != 0) {\r
1224 //\r
1225 // Determine current operation type.\r
1226 //\r
1227 if (DataSize == AUTHINFO_SIZE) {\r
1228 IsDeletion = TRUE;\r
1229 }\r
1230 //\r
1231 // Determine whether this is the first time with EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS set.\r
1232 //\r
1233 if (Variable->CurrPtr == NULL) {\r
1234 IsFirstTime = TRUE;\r
1235 } else if ((Variable->CurrPtr->Attributes & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) == 0) {\r
1236 IsFirstTime = TRUE;\r
1237 } else {\r
1238 KeyIndex = Variable->CurrPtr->PubKeyIndex;\r
1239 IsFirstTime = FALSE;\r
1240 }\r
389c8779 1241 } else if ((Variable->CurrPtr != NULL) && \r
1242 ((Variable->CurrPtr->Attributes & (EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS)) != 0)\r
1243 ) {\r
0c18794e 1244 //\r
1245 // If the variable is already write-protected, it always needs authentication before update.\r
1246 //\r
1247 return EFI_WRITE_PROTECTED;\r
1248 } else {\r
1249 //\r
1250 // If without EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS, set and attributes collision.\r
1251 // That means it is not authenticated variable, just update variable as usual.\r
1252 //\r
1253 Status = UpdateVariable (VariableName, VendorGuid, Data, DataSize, Attributes, 0, 0, Variable, NULL);\r
1254 return Status;\r
1255 }\r
1256\r
1257 //\r
1258 // Get PubKey and check Monotonic Count value corresponding to the variable.\r
1259 //\r
1260 CertData = (EFI_VARIABLE_AUTHENTICATION *) Data;\r
1261 CertBlock = (EFI_CERT_BLOCK_RSA_2048_SHA256 *) (CertData->AuthInfo.CertData);\r
1262 PubKey = CertBlock->PublicKey;\r
1263\r
1264 //\r
1265 // Update Monotonic Count value.\r
1266 //\r
1267 MonotonicCount = CertData->MonotonicCount;\r
1268\r
1269 if (!IsFirstTime) {\r
1270 //\r
1271 // Check input PubKey.\r
1272 //\r
1273 if (CompareMem (PubKey, mPubKeyStore + (KeyIndex - 1) * EFI_CERT_TYPE_RSA2048_SIZE, EFI_CERT_TYPE_RSA2048_SIZE) != 0) {\r
1274 return EFI_SECURITY_VIOLATION;\r
1275 }\r
1276 //\r
1277 // Compare the current monotonic count and ensure that it is greater than the last SetVariable\r
1278 // operation with the EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS attribute set.\r
1279 //\r
1280 if (CertData->MonotonicCount <= Variable->CurrPtr->MonotonicCount) {\r
1281 //\r
1282 // Monotonic count check fail, suspicious replay attack, return EFI_SECURITY_VIOLATION.\r
1283 //\r
1284 return EFI_SECURITY_VIOLATION;\r
1285 }\r
2d3fb919 1286 }\r
0c18794e 1287 //\r
1288 // Verify the certificate in Data payload.\r
1289 //\r
1290 Status = VerifyCounterBasedPayload (Data, DataSize, PubKey);\r
1291 if (EFI_ERROR (Status)) {\r
1292 return Status;\r
1293 }\r
2d3fb919 1294\r
0c18794e 1295 //\r
1296 // Now, the signature has been verified!\r
1297 //\r
1298 if (IsFirstTime && !IsDeletion) {\r
1299 //\r
1300 // Update public key database variable if need.\r
1301 //\r
1302 KeyIndex = AddPubKeyInStore (PubKey);\r
4e33001c 1303 if (KeyIndex == 0) {\r
275beb2b 1304 return EFI_OUT_OF_RESOURCES;\r
4e33001c 1305 }\r
0c18794e 1306 }\r
1307\r
1308 //\r
1309 // Verification pass.\r
1310 //\r
1311 return UpdateVariable (VariableName, VendorGuid, (UINT8*)Data + AUTHINFO_SIZE, DataSize - AUTHINFO_SIZE, Attributes, KeyIndex, MonotonicCount, Variable, NULL);\r
1312}\r
1313\r
2d3fb919 1314/**\r
1315 Merge two buffers which formatted as EFI_SIGNATURE_LIST. Only the new EFI_SIGNATURE_DATA\r
1316 will be appended to the original EFI_SIGNATURE_LIST, duplicate EFI_SIGNATURE_DATA\r
1317 will be ignored.\r
1318\r
732d199d 1319 @param[in, out] Data Pointer to original EFI_SIGNATURE_LIST.\r
1320 @param[in] DataSize Size of Data buffer.\r
1321 @param[in] FreeBufSize Size of free data buffer \r
1322 @param[in] NewData Pointer to new EFI_SIGNATURE_LIST to be appended.\r
1323 @param[in] NewDataSize Size of NewData buffer.\r
1324 @param[out] MergedBufSize Size of the merged buffer\r
2d3fb919 1325\r
732d199d 1326 @return EFI_BUFFER_TOO_SMALL if input Data buffer overflowed\r
2d3fb919 1327\r
1328**/\r
732d199d 1329EFI_STATUS\r
2d3fb919 1330AppendSignatureList (\r
1331 IN OUT VOID *Data,\r
1332 IN UINTN DataSize,\r
732d199d 1333 IN UINTN FreeBufSize,\r
2d3fb919 1334 IN VOID *NewData,\r
732d199d 1335 IN UINTN NewDataSize,\r
1336 OUT UINTN *MergedBufSize\r
2d3fb919 1337 )\r
1338{\r
1339 EFI_SIGNATURE_LIST *CertList;\r
1340 EFI_SIGNATURE_DATA *Cert;\r
1341 UINTN CertCount;\r
1342 EFI_SIGNATURE_LIST *NewCertList;\r
1343 EFI_SIGNATURE_DATA *NewCert;\r
1344 UINTN NewCertCount;\r
1345 UINTN Index;\r
1346 UINTN Index2;\r
1347 UINTN Size;\r
1348 UINT8 *Tail;\r
1349 UINTN CopiedCount;\r
1350 UINTN SignatureListSize;\r
1351 BOOLEAN IsNewCert;\r
1352\r
1353 Tail = (UINT8 *) Data + DataSize;\r
1354\r
1355 NewCertList = (EFI_SIGNATURE_LIST *) NewData;\r
1356 while ((NewDataSize > 0) && (NewDataSize >= NewCertList->SignatureListSize)) {\r
1357 NewCert = (EFI_SIGNATURE_DATA *) ((UINT8 *) NewCertList + sizeof (EFI_SIGNATURE_LIST) + NewCertList->SignatureHeaderSize);\r
1358 NewCertCount = (NewCertList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - NewCertList->SignatureHeaderSize) / NewCertList->SignatureSize;\r
1359\r
1360 CopiedCount = 0;\r
1361 for (Index = 0; Index < NewCertCount; Index++) {\r
1362 IsNewCert = TRUE;\r
1363\r
1364 Size = DataSize;\r
1365 CertList = (EFI_SIGNATURE_LIST *) Data;\r
1366 while ((Size > 0) && (Size >= CertList->SignatureListSize)) {\r
1367 if (CompareGuid (&CertList->SignatureType, &NewCertList->SignatureType) &&\r
1368 (CertList->SignatureSize == NewCertList->SignatureSize)) {\r
1369 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertList + sizeof (EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);\r
1370 CertCount = (CertList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - CertList->SignatureHeaderSize) / CertList->SignatureSize;\r
1371 for (Index2 = 0; Index2 < CertCount; Index2++) {\r
1372 //\r
1373 // Iterate each Signature Data in this Signature List.\r
1374 //\r
1375 if (CompareMem (NewCert, Cert, CertList->SignatureSize) == 0) {\r
1376 IsNewCert = FALSE;\r
1377 break;\r
1378 }\r
1379 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) Cert + CertList->SignatureSize);\r
1380 }\r
1381 }\r
1382\r
1383 if (!IsNewCert) {\r
1384 break;\r
1385 }\r
1386 Size -= CertList->SignatureListSize;\r
1387 CertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) CertList + CertList->SignatureListSize);\r
1388 }\r
1389\r
1390 if (IsNewCert) {\r
1391 //\r
1392 // New EFI_SIGNATURE_DATA, append it.\r
1393 //\r
1394 if (CopiedCount == 0) {\r
732d199d 1395 if (FreeBufSize < sizeof (EFI_SIGNATURE_LIST) + NewCertList->SignatureHeaderSize) {\r
1396 return EFI_BUFFER_TOO_SMALL;\r
1397 }\r
1398\r
2d3fb919 1399 //\r
1400 // Copy EFI_SIGNATURE_LIST header for only once.\r
1401 //\r
732d199d 1402\r
2d3fb919 1403 CopyMem (Tail, NewCertList, sizeof (EFI_SIGNATURE_LIST) + NewCertList->SignatureHeaderSize);\r
1404 Tail = Tail + sizeof (EFI_SIGNATURE_LIST) + NewCertList->SignatureHeaderSize;\r
732d199d 1405 FreeBufSize -= sizeof (EFI_SIGNATURE_LIST) + NewCertList->SignatureHeaderSize;\r
2d3fb919 1406 }\r
1407\r
732d199d 1408 if (FreeBufSize < NewCertList->SignatureSize) {\r
1409 return EFI_BUFFER_TOO_SMALL;\r
1410 }\r
2d3fb919 1411 CopyMem (Tail, NewCert, NewCertList->SignatureSize);\r
1412 Tail += NewCertList->SignatureSize;\r
732d199d 1413 FreeBufSize -= NewCertList->SignatureSize;\r
2d3fb919 1414 CopiedCount++;\r
1415 }\r
1416\r
1417 NewCert = (EFI_SIGNATURE_DATA *) ((UINT8 *) NewCert + NewCertList->SignatureSize);\r
1418 }\r
1419\r
1420 //\r
1421 // Update SignatureListSize in newly appended EFI_SIGNATURE_LIST.\r
1422 //\r
1423 if (CopiedCount != 0) {\r
1424 SignatureListSize = sizeof (EFI_SIGNATURE_LIST) + NewCertList->SignatureHeaderSize + (CopiedCount * NewCertList->SignatureSize);\r
1425 CertList = (EFI_SIGNATURE_LIST *) (Tail - SignatureListSize);\r
1426 CertList->SignatureListSize = (UINT32) SignatureListSize;\r
1427 }\r
1428\r
1429 NewDataSize -= NewCertList->SignatureListSize;\r
1430 NewCertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) NewCertList + NewCertList->SignatureListSize);\r
1431 }\r
1432\r
732d199d 1433 *MergedBufSize = (Tail - (UINT8 *) Data);\r
1434 return EFI_SUCCESS;\r
2d3fb919 1435}\r
1436\r
0c18794e 1437/**\r
1438 Compare two EFI_TIME data.\r
1439\r
1440\r
1441 @param FirstTime A pointer to the first EFI_TIME data.\r
1442 @param SecondTime A pointer to the second EFI_TIME data.\r
1443\r
1444 @retval TRUE The FirstTime is not later than the SecondTime.\r
1445 @retval FALSE The FirstTime is later than the SecondTime.\r
1446\r
1447**/\r
1448BOOLEAN\r
1449CompareTimeStamp (\r
1450 IN EFI_TIME *FirstTime,\r
1451 IN EFI_TIME *SecondTime\r
1452 )\r
1453{\r
1454 if (FirstTime->Year != SecondTime->Year) {\r
1455 return (BOOLEAN) (FirstTime->Year < SecondTime->Year);\r
1456 } else if (FirstTime->Month != SecondTime->Month) {\r
1457 return (BOOLEAN) (FirstTime->Month < SecondTime->Month);\r
1458 } else if (FirstTime->Day != SecondTime->Day) {\r
1459 return (BOOLEAN) (FirstTime->Day < SecondTime->Day);\r
1460 } else if (FirstTime->Hour != SecondTime->Hour) {\r
1461 return (BOOLEAN) (FirstTime->Hour < SecondTime->Hour);\r
1462 } else if (FirstTime->Minute != SecondTime->Minute) {\r
42ed7604 1463 return (BOOLEAN) (FirstTime->Minute < SecondTime->Minute);\r
2d3fb919 1464 }\r
0c18794e 1465\r
1466 return (BOOLEAN) (FirstTime->Second <= SecondTime->Second);\r
1467}\r
1468\r
ed47ae02 1469/**\r
1470 Find matching signer's certificates for common authenticated variable\r
1471 by corresponding VariableName and VendorGuid from "certdb".\r
1472\r
1473 The data format of "certdb":\r
1474 //\r
1475 // UINT32 CertDbListSize;\r
1476 // /// AUTH_CERT_DB_DATA Certs1[];\r
1477 // /// AUTH_CERT_DB_DATA Certs2[];\r
1478 // /// ...\r
1479 // /// AUTH_CERT_DB_DATA Certsn[];\r
1480 //\r
1481\r
1482 @param[in] VariableName Name of authenticated Variable.\r
1483 @param[in] VendorGuid Vendor GUID of authenticated Variable.\r
1484 @param[in] Data Pointer to variable "certdb".\r
1485 @param[in] DataSize Size of variable "certdb".\r
1486 @param[out] CertOffset Offset of matching CertData, from starting of Data.\r
1487 @param[out] CertDataSize Length of CertData in bytes.\r
1488 @param[out] CertNodeOffset Offset of matching AUTH_CERT_DB_DATA , from\r
1489 starting of Data.\r
1490 @param[out] CertNodeSize Length of AUTH_CERT_DB_DATA in bytes.\r
1491\r
1492 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.\r
1493 @retval EFI_NOT_FOUND Fail to find matching certs.\r
1494 @retval EFI_SUCCESS Find matching certs and output parameters.\r
1495\r
1496**/\r
1497EFI_STATUS\r
1498FindCertsFromDb (\r
1499 IN CHAR16 *VariableName,\r
1500 IN EFI_GUID *VendorGuid,\r
1501 IN UINT8 *Data,\r
1502 IN UINTN DataSize,\r
1503 OUT UINT32 *CertOffset, OPTIONAL\r
1504 OUT UINT32 *CertDataSize, OPTIONAL\r
1505 OUT UINT32 *CertNodeOffset,OPTIONAL\r
1506 OUT UINT32 *CertNodeSize OPTIONAL\r
1507 )\r
1508{\r
1509 UINT32 Offset;\r
1510 AUTH_CERT_DB_DATA *Ptr;\r
1511 UINT32 CertSize;\r
1512 UINT32 NameSize;\r
1513 UINT32 NodeSize;\r
1514 UINT32 CertDbListSize;\r
1515\r
1516 if ((VariableName == NULL) || (VendorGuid == NULL) || (Data == NULL)) {\r
1517 return EFI_INVALID_PARAMETER;\r
1518 }\r
1519\r
1520 //\r
1521 // Check whether DataSize matches recorded CertDbListSize.\r
1522 //\r
1523 if (DataSize < sizeof (UINT32)) {\r
1524 return EFI_INVALID_PARAMETER;\r
1525 }\r
1526\r
1527 CertDbListSize = ReadUnaligned32 ((UINT32 *) Data);\r
1528\r
1529 if (CertDbListSize != (UINT32) DataSize) {\r
1530 return EFI_INVALID_PARAMETER;\r
1531 }\r
1532\r
1533 Offset = sizeof (UINT32);\r
1534\r
1535 //\r
1536 // Get corresponding certificates by VendorGuid and VariableName.\r
1537 //\r
1538 while (Offset < (UINT32) DataSize) {\r
1539 Ptr = (AUTH_CERT_DB_DATA *) (Data + Offset);\r
1540 //\r
1541 // Check whether VendorGuid matches.\r
1542 //\r
1543 if (CompareGuid (&Ptr->VendorGuid, VendorGuid)) {\r
1544 NodeSize = ReadUnaligned32 (&Ptr->CertNodeSize);\r
1545 NameSize = ReadUnaligned32 (&Ptr->NameSize);\r
1546 CertSize = ReadUnaligned32 (&Ptr->CertDataSize);\r
1547\r
1548 if (NodeSize != sizeof (EFI_GUID) + sizeof (UINT32) * 3 + CertSize +\r
1549 sizeof (CHAR16) * NameSize) {\r
1550 return EFI_INVALID_PARAMETER;\r
1551 }\r
1552\r
1553 Offset = Offset + sizeof (EFI_GUID) + sizeof (UINT32) * 3;\r
1554 //\r
1555 // Check whether VariableName matches.\r
1556 //\r
1557 if ((NameSize == StrLen (VariableName)) && \r
1558 (CompareMem (Data + Offset, VariableName, NameSize * sizeof (CHAR16)) == 0)) {\r
1559 Offset = Offset + NameSize * sizeof (CHAR16);\r
1560\r
1561 if (CertOffset != NULL) {\r
1562 *CertOffset = Offset;\r
1563 }\r
1564\r
1565 if (CertDataSize != NULL) {\r
1566 *CertDataSize = CertSize; \r
1567 }\r
1568\r
1569 if (CertNodeOffset != NULL) {\r
1570 *CertNodeOffset = (UINT32) ((UINT8 *) Ptr - Data);\r
1571 }\r
1572\r
1573 if (CertNodeSize != NULL) {\r
1574 *CertNodeSize = NodeSize;\r
1575 }\r
1576\r
1577 return EFI_SUCCESS;\r
1578 } else {\r
1579 Offset = Offset + NameSize * sizeof (CHAR16) + CertSize;\r
1580 }\r
1581 } else {\r
1582 NodeSize = ReadUnaligned32 (&Ptr->CertNodeSize);\r
1583 Offset = Offset + NodeSize;\r
1584 }\r
1585 }\r
1586\r
1587 return EFI_NOT_FOUND; \r
1588}\r
1589\r
1590/**\r
1591 Retrieve signer's certificates for common authenticated variable\r
1592 by corresponding VariableName and VendorGuid from "certdb".\r
1593\r
1594 @param[in] VariableName Name of authenticated Variable.\r
1595 @param[in] VendorGuid Vendor GUID of authenticated Variable.\r
1596 @param[out] CertData Pointer to signer's certificates.\r
1597 @param[out] CertDataSize Length of CertData in bytes.\r
1598\r
1599 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.\r
1600 @retval EFI_NOT_FOUND Fail to find "certdb" or matching certs.\r
1601 @retval EFI_SUCCESS Get signer's certificates successfully.\r
1602\r
1603**/\r
1604EFI_STATUS\r
1605GetCertsFromDb (\r
1606 IN CHAR16 *VariableName,\r
1607 IN EFI_GUID *VendorGuid,\r
1608 OUT UINT8 **CertData,\r
1609 OUT UINT32 *CertDataSize\r
1610 )\r
1611{\r
1612 VARIABLE_POINTER_TRACK CertDbVariable;\r
1613 EFI_STATUS Status;\r
1614 UINT8 *Data;\r
1615 UINTN DataSize;\r
1616 UINT32 CertOffset;\r
1617\r
1618 if ((VariableName == NULL) || (VendorGuid == NULL) || (CertData == NULL) || (CertDataSize == NULL)) {\r
1619 return EFI_INVALID_PARAMETER;\r
1620 }\r
1621 \r
1622 //\r
1623 // Get variable "certdb".\r
1624 //\r
1625 Status = FindVariable (\r
1626 EFI_CERT_DB_NAME,\r
1627 &gEfiCertDbGuid,\r
1628 &CertDbVariable,\r
1629 &mVariableModuleGlobal->VariableGlobal,\r
1630 FALSE\r
1631 ); \r
1632 if (EFI_ERROR (Status)) {\r
1633 return Status;\r
1634 }\r
1635\r
1636 DataSize = DataSizeOfVariable (CertDbVariable.CurrPtr);\r
1637 Data = GetVariableDataPtr (CertDbVariable.CurrPtr);\r
1638 if ((DataSize == 0) || (Data == NULL)) {\r
1639 ASSERT (FALSE);\r
1640 return EFI_NOT_FOUND;\r
1641 }\r
1642\r
1643 Status = FindCertsFromDb (\r
1644 VariableName,\r
1645 VendorGuid,\r
1646 Data,\r
1647 DataSize,\r
1648 &CertOffset,\r
1649 CertDataSize,\r
1650 NULL,\r
1651 NULL\r
1652 );\r
1653\r
1654 if (EFI_ERROR (Status)) {\r
1655 return Status;\r
1656 }\r
1657\r
1658 *CertData = Data + CertOffset;\r
1659 return EFI_SUCCESS;\r
1660}\r
1661\r
1662/**\r
1663 Delete matching signer's certificates when deleting common authenticated\r
1664 variable by corresponding VariableName and VendorGuid from "certdb".\r
1665\r
1666 @param[in] VariableName Name of authenticated Variable.\r
1667 @param[in] VendorGuid Vendor GUID of authenticated Variable.\r
1668\r
1669 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.\r
1670 @retval EFI_NOT_FOUND Fail to find "certdb" or matching certs.\r
1671 @retval EFI_OUT_OF_RESOURCES The operation is failed due to lack of resources.\r
1672 @retval EFI_SUCCESS The operation is completed successfully.\r
1673\r
1674**/\r
1675EFI_STATUS\r
1676DeleteCertsFromDb (\r
1677 IN CHAR16 *VariableName,\r
1678 IN EFI_GUID *VendorGuid\r
1679 )\r
1680{\r
1681 VARIABLE_POINTER_TRACK CertDbVariable;\r
1682 EFI_STATUS Status;\r
1683 UINT8 *Data;\r
1684 UINTN DataSize;\r
1685 UINT32 VarAttr;\r
1686 UINT32 CertNodeOffset;\r
1687 UINT32 CertNodeSize;\r
1688 UINT8 *NewCertDb;\r
1689 UINT32 NewCertDbSize;\r
1690\r
1691 if ((VariableName == NULL) || (VendorGuid == NULL)) {\r
1692 return EFI_INVALID_PARAMETER;\r
1693 }\r
1694 \r
1695 //\r
1696 // Get variable "certdb".\r
1697 //\r
1698 Status = FindVariable (\r
1699 EFI_CERT_DB_NAME,\r
1700 &gEfiCertDbGuid,\r
1701 &CertDbVariable,\r
1702 &mVariableModuleGlobal->VariableGlobal,\r
1703 FALSE\r
1704 ); \r
1705 if (EFI_ERROR (Status)) {\r
1706 return Status;\r
1707 }\r
1708\r
1709 DataSize = DataSizeOfVariable (CertDbVariable.CurrPtr);\r
1710 Data = GetVariableDataPtr (CertDbVariable.CurrPtr);\r
1711 if ((DataSize == 0) || (Data == NULL)) {\r
1712 ASSERT (FALSE);\r
1713 return EFI_NOT_FOUND;\r
1714 }\r
1715\r
1716 if (DataSize == sizeof (UINT32)) {\r
1717 //\r
1718 // There is no certs in certdb.\r
1719 //\r
1720 return EFI_SUCCESS;\r
1721 }\r
1722\r
1723 //\r
1724 // Get corresponding cert node from certdb.\r
1725 //\r
1726 Status = FindCertsFromDb (\r
1727 VariableName,\r
1728 VendorGuid,\r
1729 Data,\r
1730 DataSize,\r
1731 NULL,\r
1732 NULL,\r
1733 &CertNodeOffset,\r
1734 &CertNodeSize\r
1735 );\r
1736\r
1737 if (EFI_ERROR (Status)) {\r
1738 return Status;\r
1739 }\r
1740\r
1741 if (DataSize < (CertNodeOffset + CertNodeSize)) {\r
1742 return EFI_NOT_FOUND;\r
1743 }\r
1744\r
1745 //\r
1746 // Construct new data content of variable "certdb".\r
1747 //\r
1748 NewCertDbSize = (UINT32) DataSize - CertNodeSize;\r
f6e23353 1749 NewCertDb = (UINT8*) mCertDbStore;\r
ed47ae02 1750\r
1751 //\r
1752 // Copy the DB entries before deleting node.\r
1753 //\r
1754 CopyMem (NewCertDb, Data, CertNodeOffset);\r
1755 //\r
1756 // Update CertDbListSize.\r
1757 //\r
1758 CopyMem (NewCertDb, &NewCertDbSize, sizeof (UINT32));\r
1759 //\r
1760 // Copy the DB entries after deleting node.\r
1761 //\r
1762 if (DataSize > (CertNodeOffset + CertNodeSize)) {\r
1763 CopyMem (\r
1764 NewCertDb + CertNodeOffset,\r
1765 Data + CertNodeOffset + CertNodeSize,\r
1766 DataSize - CertNodeOffset - CertNodeSize\r
1767 );\r
1768 }\r
1769\r
1770 //\r
1771 // Set "certdb".\r
1772 // \r
1773 VarAttr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS; \r
1774 Status = UpdateVariable (\r
1775 EFI_CERT_DB_NAME,\r
1776 &gEfiCertDbGuid,\r
1777 NewCertDb,\r
1778 NewCertDbSize,\r
1779 VarAttr,\r
1780 0,\r
1781 0,\r
1782 &CertDbVariable,\r
1783 NULL\r
1784 );\r
1785\r
ed47ae02 1786 return Status;\r
1787}\r
1788\r
1789/**\r
1790 Insert signer's certificates for common authenticated variable with VariableName\r
1791 and VendorGuid in AUTH_CERT_DB_DATA to "certdb".\r
1792\r
1793 @param[in] VariableName Name of authenticated Variable.\r
1794 @param[in] VendorGuid Vendor GUID of authenticated Variable.\r
1795 @param[in] CertData Pointer to signer's certificates.\r
1796 @param[in] CertDataSize Length of CertData in bytes.\r
1797\r
1798 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.\r
1799 @retval EFI_ACCESS_DENIED An AUTH_CERT_DB_DATA entry with same VariableName\r
1800 and VendorGuid already exists.\r
1801 @retval EFI_OUT_OF_RESOURCES The operation is failed due to lack of resources.\r
1802 @retval EFI_SUCCESS Insert an AUTH_CERT_DB_DATA entry to "certdb"\r
1803\r
1804**/\r
1805EFI_STATUS\r
1806InsertCertsToDb (\r
1807 IN CHAR16 *VariableName,\r
1808 IN EFI_GUID *VendorGuid,\r
1809 IN UINT8 *CertData,\r
1810 IN UINTN CertDataSize\r
1811 )\r
1812{\r
1813 VARIABLE_POINTER_TRACK CertDbVariable;\r
1814 EFI_STATUS Status;\r
1815 UINT8 *Data;\r
1816 UINTN DataSize;\r
1817 UINT32 VarAttr;\r
1818 UINT8 *NewCertDb;\r
1819 UINT32 NewCertDbSize;\r
1820 UINT32 CertNodeSize;\r
1821 UINT32 NameSize;\r
1822 AUTH_CERT_DB_DATA *Ptr;\r
1823\r
1824 if ((VariableName == NULL) || (VendorGuid == NULL) || (CertData == NULL)) {\r
1825 return EFI_INVALID_PARAMETER;\r
1826 }\r
1827 \r
1828 //\r
1829 // Get variable "certdb".\r
1830 //\r
1831 Status = FindVariable (\r
1832 EFI_CERT_DB_NAME,\r
1833 &gEfiCertDbGuid,\r
1834 &CertDbVariable,\r
1835 &mVariableModuleGlobal->VariableGlobal,\r
1836 FALSE\r
1837 ); \r
1838 if (EFI_ERROR (Status)) {\r
1839 return Status;\r
1840 }\r
1841\r
1842 DataSize = DataSizeOfVariable (CertDbVariable.CurrPtr);\r
1843 Data = GetVariableDataPtr (CertDbVariable.CurrPtr);\r
1844 if ((DataSize == 0) || (Data == NULL)) {\r
1845 ASSERT (FALSE);\r
1846 return EFI_NOT_FOUND;\r
1847 }\r
1848\r
1849 //\r
1850 // Find whether matching cert node already exists in "certdb".\r
1851 // If yes return error.\r
1852 //\r
1853 Status = FindCertsFromDb (\r
1854 VariableName,\r
1855 VendorGuid,\r
1856 Data,\r
1857 DataSize,\r
1858 NULL,\r
1859 NULL,\r
1860 NULL,\r
1861 NULL\r
1862 );\r
1863\r
1864 if (!EFI_ERROR (Status)) {\r
1865 ASSERT (FALSE);\r
1866 return EFI_ACCESS_DENIED;\r
1867 }\r
1868\r
1869 //\r
1870 // Construct new data content of variable "certdb".\r
1871 //\r
1872 NameSize = (UINT32) StrLen (VariableName);\r
1873 CertNodeSize = sizeof (AUTH_CERT_DB_DATA) + (UINT32) CertDataSize + NameSize * sizeof (CHAR16); \r
f6e23353 1874 NewCertDbSize = (UINT32) DataSize + CertNodeSize;\r
1875 if (NewCertDbSize > MAX_CERTDB_SIZE) {\r
ed47ae02 1876 return EFI_OUT_OF_RESOURCES;\r
1877 }\r
f6e23353 1878 NewCertDb = (UINT8*) mCertDbStore;\r
ed47ae02 1879\r
1880 //\r
1881 // Copy the DB entries before deleting node.\r
1882 //\r
1883 CopyMem (NewCertDb, Data, DataSize);\r
1884 //\r
1885 // Update CertDbListSize.\r
1886 //\r
1887 CopyMem (NewCertDb, &NewCertDbSize, sizeof (UINT32));\r
1888 //\r
1889 // Construct new cert node.\r
1890 //\r
1891 Ptr = (AUTH_CERT_DB_DATA *) (NewCertDb + DataSize);\r
1892 CopyGuid (&Ptr->VendorGuid, VendorGuid);\r
1893 CopyMem (&Ptr->CertNodeSize, &CertNodeSize, sizeof (UINT32));\r
1894 CopyMem (&Ptr->NameSize, &NameSize, sizeof (UINT32));\r
1895 CopyMem (&Ptr->CertDataSize, &CertDataSize, sizeof (UINT32));\r
1896 \r
1897 CopyMem (\r
1898 (UINT8 *) Ptr + sizeof (AUTH_CERT_DB_DATA),\r
1899 VariableName,\r
1900 NameSize * sizeof (CHAR16)\r
1901 );\r
1902\r
1903 CopyMem (\r
1904 (UINT8 *) Ptr + sizeof (AUTH_CERT_DB_DATA) + NameSize * sizeof (CHAR16),\r
1905 CertData,\r
1906 CertDataSize\r
1907 );\r
1908 \r
1909 //\r
1910 // Set "certdb".\r
1911 // \r
1912 VarAttr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS; \r
1913 Status = UpdateVariable (\r
1914 EFI_CERT_DB_NAME,\r
1915 &gEfiCertDbGuid,\r
1916 NewCertDb,\r
1917 NewCertDbSize,\r
1918 VarAttr,\r
1919 0,\r
1920 0,\r
1921 &CertDbVariable,\r
1922 NULL\r
1923 );\r
1924\r
ed47ae02 1925 return Status;\r
1926}\r
1927\r
0c18794e 1928/**\r
1929 Process variable with EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS set\r
1930\r
dc204d5a
JY		 1931 Caution: This function may receive untrusted input.\r
1932 This function may be invoked in SMM mode, and datasize and data are external input.\r
1933 This function will do basic validation, before parse the data.\r
1934 This function will parse the authentication carefully to avoid security issues, like\r
1935 buffer overflow, integer overflow.\r
1936\r
0c18794e 1937 @param[in] VariableName Name of Variable to be found.\r
1938 @param[in] VendorGuid Variable vendor GUID.\r
1939 @param[in] Data Data pointer.\r
1940 @param[in] DataSize Size of Data found. If size is less than the\r
1941 data, this value contains the required size.\r
1942 @param[in] Variable The variable information which is used to keep track of variable usage.\r
1943 @param[in] Attributes Attribute value of the variable.\r
785d84ea 1944 @param[in] AuthVarType Verify against PK, KEK database, private database or certificate in data payload.\r
0c18794e 1945 @param[out] VarDel Delete the variable or not.\r
1946\r
1947 @retval EFI_INVALID_PARAMETER Invalid parameter.\r
2d3fb919 1948 @retval EFI_SECURITY_VIOLATION The variable does NOT pass the validation\r
1949 check carried out by the firmware.\r
0c18794e 1950 @retval EFI_OUT_OF_RESOURCES Failed to process variable due to lack\r
1951 of resources.\r
1952 @retval EFI_SUCCESS Variable pass validation successfully.\r
1953\r
1954**/\r
1955EFI_STATUS\r
1956VerifyTimeBasedPayload (\r
1957 IN CHAR16 *VariableName,\r
1958 IN EFI_GUID *VendorGuid,\r
1959 IN VOID *Data,\r
1960 IN UINTN DataSize,\r
1961 IN VARIABLE_POINTER_TRACK *Variable,\r
1962 IN UINT32 Attributes,\r
ed47ae02 1963 IN AUTHVAR_TYPE AuthVarType,\r
0c18794e 1964 OUT BOOLEAN *VarDel\r
1965 )\r
1966{\r
1967 UINT8 *RootCert;\r
1968 UINT8 *SigData;\r
2d3fb919 1969 UINT8 *PayloadPtr;\r
0c18794e 1970 UINTN RootCertSize;\r
1971 UINTN Index;\r
2d3fb919 1972 UINTN CertCount;\r
1973 UINTN PayloadSize;\r
0c18794e 1974 UINT32 Attr;\r
1975 UINT32 SigDataSize;\r
1976 UINT32 KekDataSize;\r
0c18794e 1977 BOOLEAN VerifyStatus;\r
1978 EFI_STATUS Status;\r
1979 EFI_SIGNATURE_LIST *CertList;\r
1980 EFI_SIGNATURE_DATA *Cert;\r
1981 VARIABLE_POINTER_TRACK KekVariable;\r
1982 EFI_VARIABLE_AUTHENTICATION_2 *CertData;\r
1983 UINT8 *NewData;\r
1984 UINTN NewDataSize;\r
1985 VARIABLE_POINTER_TRACK PkVariable;\r
2d3fb919 1986 UINT8 *Buffer;\r
1987 UINTN Length;\r
ed47ae02 1988 UINT8 *SignerCerts;\r
1989 UINT8 *WrapSigData;\r
1990 UINTN CertStackSize;\r
1991 UINT8 *CertsInCertDb;\r
1992 UINT32 CertsSizeinDb;\r
0c18794e 1993\r
0c18794e 1994 VerifyStatus = FALSE;\r
1995 CertData = NULL;\r
1996 NewData = NULL;\r
1997 Attr = Attributes;\r
ed47ae02 1998 WrapSigData = NULL;\r
1999 SignerCerts = NULL;\r
2000 RootCert = NULL;\r
0c18794e 2001\r
2002 //\r
2d3fb919 2003 // When the attribute EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS is\r
0c18794e 2004 // set, then the Data buffer shall begin with an instance of a complete (and serialized)\r
2d3fb919 2005 // EFI_VARIABLE_AUTHENTICATION_2 descriptor. The descriptor shall be followed by the new\r
2006 // variable value and DataSize shall reflect the combined size of the descriptor and the new\r
2007 // variable value. The authentication descriptor is not part of the variable data and is not\r
0c18794e 2008 // returned by subsequent calls to GetVariable().\r
2009 //\r
2010 CertData = (EFI_VARIABLE_AUTHENTICATION_2 *) Data;\r
2d3fb919 2011\r
2012 //\r
2013 // Verify that Pad1, Nanosecond, TimeZone, Daylight and Pad2 components of the\r
2014 // TimeStamp value are set to zero.\r
2015 //\r
2016 if ((CertData->TimeStamp.Pad1 != 0) ||\r
2017 (CertData->TimeStamp.Nanosecond != 0) ||\r
2018 (CertData->TimeStamp.TimeZone != 0) ||\r
2019 (CertData->TimeStamp.Daylight != 0) ||\r
2020 (CertData->TimeStamp.Pad2 != 0)) {\r
2e24814a 2021 return EFI_SECURITY_VIOLATION;\r
2d3fb919 2022 }\r
2023\r
0c18794e 2024 if ((Variable->CurrPtr != NULL) && ((Attributes & EFI_VARIABLE_APPEND_WRITE) == 0)) {\r
2025 if (CompareTimeStamp (&CertData->TimeStamp, &Variable->CurrPtr->TimeStamp)) {\r
2026 //\r
2027 // TimeStamp check fail, suspicious replay attack, return EFI_SECURITY_VIOLATION.\r
2028 //\r
2029 return EFI_SECURITY_VIOLATION;\r
2030 }\r
2031 }\r
2032\r
2033 //\r
2034 // wCertificateType should be WIN_CERT_TYPE_EFI_GUID.\r
2035 // Cert type should be EFI_CERT_TYPE_PKCS7_GUID.\r
2036 //\r
2037 if ((CertData->AuthInfo.Hdr.wCertificateType != WIN_CERT_TYPE_EFI_GUID) ||\r
2d3fb919 2038 !CompareGuid (&CertData->AuthInfo.CertType, &gEfiCertPkcs7Guid)) {\r
0c18794e 2039 //\r
2040 // Invalid AuthInfo type, return EFI_SECURITY_VIOLATION.\r
2041 //\r
2042 return EFI_SECURITY_VIOLATION;\r
2043 }\r
2d3fb919 2044\r
0c18794e 2045 //\r
2046 // Find out Pkcs7 SignedData which follows the EFI_VARIABLE_AUTHENTICATION_2 descriptor.\r
2047 // AuthInfo.Hdr.dwLength is the length of the entire certificate, including the length of the header.\r
2048 //\r
2d3fb919 2049 SigData = CertData->AuthInfo.CertData;\r
2050 SigDataSize = CertData->AuthInfo.Hdr.dwLength - (UINT32) (OFFSET_OF (WIN_CERTIFICATE_UEFI_GUID, CertData));\r
648f98d1 2051\r
0c18794e 2052 //\r
2053 // Find out the new data payload which follows Pkcs7 SignedData directly.\r
2054 //\r
2d3fb919 2055 PayloadPtr = SigData + SigDataSize;\r
2056 PayloadSize = DataSize - OFFSET_OF_AUTHINFO2_CERT_DATA - (UINTN) SigDataSize;\r
0c18794e 2057\r
2058 //\r
2059 // Construct a buffer to fill with (VariableName, VendorGuid, Attributes, TimeStamp, Data).\r
2060 //\r
2d3fb919 2061 NewDataSize = PayloadSize + sizeof (EFI_TIME) + sizeof (UINT32) +\r
2062 sizeof (EFI_GUID) + StrSize (VariableName) - sizeof (CHAR16);\r
2063 NewData = mSerializationRuntimeBuffer;\r
0c18794e 2064\r
2d3fb919 2065 Buffer = NewData;\r
2066 Length = StrLen (VariableName) * sizeof (CHAR16);\r
2067 CopyMem (Buffer, VariableName, Length);\r
2068 Buffer += Length;\r
0c18794e 2069\r
2d3fb919 2070 Length = sizeof (EFI_GUID);\r
2071 CopyMem (Buffer, VendorGuid, Length);\r
2072 Buffer += Length;\r
0c18794e 2073\r
2d3fb919 2074 Length = sizeof (UINT32);\r
2075 CopyMem (Buffer, &Attr, Length);\r
2076 Buffer += Length;\r
0c18794e 2077\r
2d3fb919 2078 Length = sizeof (EFI_TIME);\r
2079 CopyMem (Buffer, &CertData->TimeStamp, Length);\r
2080 Buffer += Length;\r
0c18794e 2081\r
2d3fb919 2082 CopyMem (Buffer, PayloadPtr, PayloadSize);\r
0c18794e 2083\r
ed47ae02 2084 if (AuthVarType == AuthVarTypePk) {\r
0c18794e 2085 //\r
2086 // Get platform key from variable.\r
2087 //\r
2088 Status = FindVariable (\r
2d3fb919 2089 EFI_PLATFORM_KEY_NAME,\r
2090 &gEfiGlobalVariableGuid,\r
2091 &PkVariable,\r
ecc722ad 2092 &mVariableModuleGlobal->VariableGlobal,\r
2093 FALSE\r
0c18794e 2094 );\r
2095 if (EFI_ERROR (Status)) {\r
2096 return Status;\r
2097 }\r
2098\r
2099 CertList = (EFI_SIGNATURE_LIST *) GetVariableDataPtr (PkVariable.CurrPtr);\r
2100 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertList + sizeof (EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);\r
2101 RootCert = Cert->SignatureData;\r
4e33001c 2102 RootCertSize = CertList->SignatureSize - (sizeof (EFI_SIGNATURE_DATA) - 1);\r
0c18794e 2103\r
2104\r
2105 //\r
2106 // Verify Pkcs7 SignedData via Pkcs7Verify library.\r
2107 //\r
2108 VerifyStatus = Pkcs7Verify (\r
2109 SigData,\r
2110 SigDataSize,\r
2111 RootCert,\r
2112 RootCertSize,\r
2113 NewData,\r
2114 NewDataSize\r
2115 );\r
2116\r
ed47ae02 2117 } else if (AuthVarType == AuthVarTypeKek) {\r
2d3fb919 2118\r
0c18794e 2119 //\r
2120 // Get KEK database from variable.\r
2121 //\r
2122 Status = FindVariable (\r
2d3fb919 2123 EFI_KEY_EXCHANGE_KEY_NAME,\r
2124 &gEfiGlobalVariableGuid,\r
2125 &KekVariable,\r
ecc722ad 2126 &mVariableModuleGlobal->VariableGlobal,\r
2127 FALSE\r
0c18794e 2128 );\r
2129 if (EFI_ERROR (Status)) {\r
2130 return Status;\r
2131 }\r
2132\r
2133 //\r
2134 // Ready to verify Pkcs7 SignedData. Go through KEK Signature Database to find out X.509 CertList.\r
2d3fb919 2135 //\r
0c18794e 2136 KekDataSize = KekVariable.CurrPtr->DataSize;\r
2137 CertList = (EFI_SIGNATURE_LIST *) GetVariableDataPtr (KekVariable.CurrPtr);\r
2138 while ((KekDataSize > 0) && (KekDataSize >= CertList->SignatureListSize)) {\r
2139 if (CompareGuid (&CertList->SignatureType, &gEfiCertX509Guid)) {\r
2140 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertList + sizeof (EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);\r
2141 CertCount = (CertList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - CertList->SignatureHeaderSize) / CertList->SignatureSize;\r
2142 for (Index = 0; Index < CertCount; Index++) {\r
2143 //\r
2144 // Iterate each Signature Data Node within this CertList for a verify\r
2145 //\r
2146 RootCert = Cert->SignatureData;\r
4e33001c 2147 RootCertSize = CertList->SignatureSize - (sizeof (EFI_SIGNATURE_DATA) - 1);\r
2d3fb919 2148\r
0c18794e 2149 //\r
2150 // Verify Pkcs7 SignedData via Pkcs7Verify library.\r
2151 //\r
2152 VerifyStatus = Pkcs7Verify (\r
2153 SigData,\r
2154 SigDataSize,\r
2155 RootCert,\r
2156 RootCertSize,\r
2157 NewData,\r
2158 NewDataSize\r
2159 );\r
2160 if (VerifyStatus) {\r
2161 goto Exit;\r
2162 }\r
2163 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) Cert + CertList->SignatureSize);\r
2164 }\r
2165 }\r
2166 KekDataSize -= CertList->SignatureListSize;\r
2167 CertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) CertList + CertList->SignatureListSize);\r
2168 }\r
ed47ae02 2169 } else if (AuthVarType == AuthVarTypePriv) {\r
2170\r
2171 //\r
2172 // Process common authenticated variable except PK/KEK/DB/DBX.\r
2173 // Get signer's certificates from SignedData.\r
2174 //\r
2175 VerifyStatus = Pkcs7GetSigners (\r
2176 SigData,\r
2177 SigDataSize,\r
2178 &SignerCerts,\r
2179 &CertStackSize,\r
2180 &RootCert,\r
2181 &RootCertSize\r
2182 );\r
2183 if (!VerifyStatus) {\r
2184 goto Exit;\r
2185 }\r
2186\r
2187 //\r
2188 // Get previously stored signer's certificates from certdb for existing\r
2189 // variable. Check whether they are identical with signer's certificates\r
2190 // in SignedData. If not, return error immediately.\r
2191 //\r
2192 if ((Variable->CurrPtr != NULL)) {\r
2193 VerifyStatus = FALSE;\r
2194\r
2195 Status = GetCertsFromDb (VariableName, VendorGuid, &CertsInCertDb, &CertsSizeinDb);\r
2196 if (EFI_ERROR (Status)) {\r
2197 goto Exit;\r
2198 }\r
2199 \r
2200 if ((CertStackSize != CertsSizeinDb) ||\r
2201 (CompareMem (SignerCerts, CertsInCertDb, CertsSizeinDb) != 0)) {\r
2202 goto Exit;\r
2203 }\r
2204 }\r
2205\r
2206 VerifyStatus = Pkcs7Verify (\r
2207 SigData,\r
2208 SigDataSize,\r
2209 RootCert,\r
2210 RootCertSize,\r
2211 NewData,\r
2212 NewDataSize\r
2213 );\r
2214 if (!VerifyStatus) {\r
2215 goto Exit;\r
2216 }\r
2217\r
2218 //\r
2219 // Delete signer's certificates when delete the common authenticated variable.\r
2220 //\r
275beb2b 2221 if ((PayloadSize == 0) && (Variable->CurrPtr != NULL) && ((Attributes & EFI_VARIABLE_APPEND_WRITE) == 0)) {\r
ed47ae02 2222 Status = DeleteCertsFromDb (VariableName, VendorGuid);\r
2223 if (EFI_ERROR (Status)) {\r
2224 VerifyStatus = FALSE;\r
2225 goto Exit;\r
2226 }\r
275beb2b 2227 } else if (Variable->CurrPtr == NULL && PayloadSize != 0) {\r
ed47ae02 2228 //\r
2229 // Insert signer's certificates when adding a new common authenticated variable.\r
2230 //\r
2231 Status = InsertCertsToDb (VariableName, VendorGuid, SignerCerts, CertStackSize);\r
2232 if (EFI_ERROR (Status)) {\r
2233 VerifyStatus = FALSE;\r
2234 goto Exit;\r
2235 }\r
2236 }\r
785d84ea 2237 } else if (AuthVarType == AuthVarTypePayload) {\r
2238 CertList = (EFI_SIGNATURE_LIST *) PayloadPtr;\r
2239 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertList + sizeof (EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);\r
2240 RootCert = Cert->SignatureData;\r
2241 RootCertSize = CertList->SignatureSize - (sizeof (EFI_SIGNATURE_DATA) - 1);\r
2242 \r
2243 // Verify Pkcs7 SignedData via Pkcs7Verify library.\r
2244 //\r
2245 VerifyStatus = Pkcs7Verify (\r
2246 SigData,\r
2247 SigDataSize,\r
2248 RootCert,\r
2249 RootCertSize,\r
2250 NewData,\r
2251 NewDataSize\r
2252 );\r
ed47ae02 2253 } else {\r
2254 return EFI_SECURITY_VIOLATION;\r
0c18794e 2255 }\r
2256\r
2257Exit:\r
2258\r
ed47ae02 2259 if (AuthVarType == AuthVarTypePriv) {\r
2260 Pkcs7FreeSigners (RootCert);\r
2261 Pkcs7FreeSigners (SignerCerts);\r
2262 }\r
2263\r
0c18794e 2264 if (!VerifyStatus) {\r
2265 return EFI_SECURITY_VIOLATION;\r
2266 }\r
2267\r
d912bad7 2268 Status = CheckSignatureListFormat(VariableName, VendorGuid, PayloadPtr, PayloadSize);\r
2269 if (EFI_ERROR (Status)) {\r
2270 return Status;\r
2271 }\r
2272\r
2d3fb919 2273 if ((PayloadSize == 0) && (VarDel != NULL)) {\r
0c18794e 2274 *VarDel = TRUE;\r
2275 }\r
2d3fb919 2276\r
0c18794e 2277 //\r
2278 // Final step: Update/Append Variable if it pass Pkcs7Verify\r
2279 //\r
ed47ae02 2280 return UpdateVariable (\r
2281 VariableName,\r
2282 VendorGuid,\r
2283 PayloadPtr,\r
2284 PayloadSize,\r
2285 Attributes,\r
2286 0,\r
2287 0,\r
2288 Variable,\r
2289 &CertData->TimeStamp\r
2290 );\r
0c18794e 2291}\r
ed47ae02 2292\r
EFI Development Kit II mirror for PVE