]> 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 the invalid public key will never be removed from public key database.
[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
2d3fb919 195 mStorageArea = AllocateRuntimePool (PcdGet32 (PcdMaxVariableSize));\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
ecc722ad 359 // Check "CustomMode" variable's existence.\r
0c18794e 360 //\r
ecc722ad 361 FindVariable (EFI_CUSTOM_MODE_NAME, &gEfiCustomModeEnableGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);\r
362 if (Variable.CurrPtr != NULL) {\r
363 CustomMode = *(GetVariableDataPtr (Variable.CurrPtr));\r
364 } else {\r
0c18794e 365 //\r
ecc722ad 366 // "CustomMode" not exist, initialize it in STANDARD_SECURE_BOOT_MODE.\r
0c18794e 367 //\r
ecc722ad 368 CustomMode = STANDARD_SECURE_BOOT_MODE;\r
369 Status = UpdateVariable (\r
370 EFI_CUSTOM_MODE_NAME,\r
371 &gEfiCustomModeEnableGuid,\r
372 &CustomMode,\r
373 sizeof (UINT8),\r
374 EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,\r
375 0,\r
376 0,\r
377 &Variable,\r
378 NULL\r
379 );\r
2d3fb919 380 if (EFI_ERROR (Status)) {\r
381 return Status;\r
0c18794e 382 }\r
0c18794e 383 }\r
ecc722ad 384 \r
385 DEBUG ((EFI_D_INFO, "Variable %s is %x\n", EFI_CUSTOM_MODE_NAME, CustomMode));\r
2d3fb919 386\r
ed47ae02 387 //\r
388 // Check "certdb" variable's existence.\r
389 // If it doesn't exist, then create a new one with \r
390 // EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS set.\r
391 //\r
392 Status = FindVariable (\r
393 EFI_CERT_DB_NAME,\r
394 &gEfiCertDbGuid,\r
395 &Variable,\r
396 &mVariableModuleGlobal->VariableGlobal,\r
397 FALSE\r
398 );\r
399\r
400 if (Variable.CurrPtr == NULL) {\r
401 VarAttr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS;\r
f6e23353 402 ListSize = sizeof (UINT32);\r
ed47ae02 403 Status = UpdateVariable (\r
404 EFI_CERT_DB_NAME,\r
405 &gEfiCertDbGuid,\r
406 &ListSize,\r
407 sizeof (UINT32),\r
408 VarAttr,\r
409 0,\r
410 0,\r
411 &Variable,\r
412 NULL\r
413 );\r
f6e23353 414 if (EFI_ERROR (Status)) {\r
415 return Status;\r
416 }\r
ed47ae02 417 } \r
418\r
0c18794e 419 return Status;\r
420}\r
421\r
422/**\r
423 Add public key in store and return its index.\r
424\r
425 @param[in] PubKey Input pointer to Public Key data\r
426\r
427 @return Index of new added item\r
428\r
429**/\r
430UINT32\r
431AddPubKeyInStore (\r
432 IN UINT8 *PubKey\r
433 )\r
434{\r
435 EFI_STATUS Status;\r
436 BOOLEAN IsFound;\r
437 UINT32 Index;\r
438 VARIABLE_POINTER_TRACK Variable;\r
439 UINT8 *Ptr;\r
83758cdc 440 UINT8 *Data;\r
441 UINTN DataSize;\r
0c18794e 442\r
443 if (PubKey == NULL) {\r
444 return 0;\r
445 }\r
446\r
447 Status = FindVariable (\r
448 AUTHVAR_KEYDB_NAME,\r
449 &gEfiAuthenticatedVariableGuid,\r
450 &Variable,\r
ecc722ad 451 &mVariableModuleGlobal->VariableGlobal,\r
452 FALSE\r
0c18794e 453 );\r
454 ASSERT_EFI_ERROR (Status);\r
455 //\r
456 // Check whether the public key entry does exist.\r
457 //\r
458 IsFound = FALSE;\r
459 for (Ptr = mPubKeyStore, Index = 1; Index <= mPubKeyNumber; Index++) {\r
460 if (CompareMem (Ptr, PubKey, EFI_CERT_TYPE_RSA2048_SIZE) == 0) {\r
461 IsFound = TRUE;\r
462 break;\r
463 }\r
464 Ptr += EFI_CERT_TYPE_RSA2048_SIZE;\r
465 }\r
466\r
467 if (!IsFound) {\r
468 //\r
469 // Add public key in database.\r
470 //\r
471 if (mPubKeyNumber == MAX_KEY_NUM) {\r
472 //\r
83758cdc 473 // Public key dadatase is full, try to reclaim invalid key.\r
0c18794e 474 //\r
83758cdc 475 if (AtRuntime ()) {\r
476 //\r
477 // NV storage can't reclaim at runtime.\r
478 //\r
479 return 0;\r
480 }\r
481 \r
482 Status = Reclaim (\r
483 mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,\r
484 &mVariableModuleGlobal->NonVolatileLastVariableOffset,\r
485 FALSE,\r
486 NULL,\r
487 TRUE,\r
488 TRUE\r
489 );\r
490 if (EFI_ERROR (Status)) {\r
491 return 0;\r
492 }\r
493\r
494 Status = FindVariable (\r
495 AUTHVAR_KEYDB_NAME,\r
496 &gEfiAuthenticatedVariableGuid,\r
497 &Variable,\r
498 &mVariableModuleGlobal->VariableGlobal,\r
499 FALSE\r
500 );\r
501 ASSERT_EFI_ERROR (Status);\r
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
1319 @param[in, out] Data Pointer to original EFI_SIGNATURE_LIST.\r
1320 @param[in] DataSize Size of Data buffer.\r
1321 @param[in] NewData Pointer to new EFI_SIGNATURE_LIST to be appended.\r
1322 @param[in] NewDataSize Size of NewData buffer.\r
1323\r
1324 @return Size of the merged buffer.\r
1325\r
1326**/\r
1327UINTN\r
1328AppendSignatureList (\r
1329 IN OUT VOID *Data,\r
1330 IN UINTN DataSize,\r
1331 IN VOID *NewData,\r
1332 IN UINTN NewDataSize\r
1333 )\r
1334{\r
1335 EFI_SIGNATURE_LIST *CertList;\r
1336 EFI_SIGNATURE_DATA *Cert;\r
1337 UINTN CertCount;\r
1338 EFI_SIGNATURE_LIST *NewCertList;\r
1339 EFI_SIGNATURE_DATA *NewCert;\r
1340 UINTN NewCertCount;\r
1341 UINTN Index;\r
1342 UINTN Index2;\r
1343 UINTN Size;\r
1344 UINT8 *Tail;\r
1345 UINTN CopiedCount;\r
1346 UINTN SignatureListSize;\r
1347 BOOLEAN IsNewCert;\r
1348\r
1349 Tail = (UINT8 *) Data + DataSize;\r
1350\r
1351 NewCertList = (EFI_SIGNATURE_LIST *) NewData;\r
1352 while ((NewDataSize > 0) && (NewDataSize >= NewCertList->SignatureListSize)) {\r
1353 NewCert = (EFI_SIGNATURE_DATA *) ((UINT8 *) NewCertList + sizeof (EFI_SIGNATURE_LIST) + NewCertList->SignatureHeaderSize);\r
1354 NewCertCount = (NewCertList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - NewCertList->SignatureHeaderSize) / NewCertList->SignatureSize;\r
1355\r
1356 CopiedCount = 0;\r
1357 for (Index = 0; Index < NewCertCount; Index++) {\r
1358 IsNewCert = TRUE;\r
1359\r
1360 Size = DataSize;\r
1361 CertList = (EFI_SIGNATURE_LIST *) Data;\r
1362 while ((Size > 0) && (Size >= CertList->SignatureListSize)) {\r
1363 if (CompareGuid (&CertList->SignatureType, &NewCertList->SignatureType) &&\r
1364 (CertList->SignatureSize == NewCertList->SignatureSize)) {\r
1365 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertList + sizeof (EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);\r
1366 CertCount = (CertList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - CertList->SignatureHeaderSize) / CertList->SignatureSize;\r
1367 for (Index2 = 0; Index2 < CertCount; Index2++) {\r
1368 //\r
1369 // Iterate each Signature Data in this Signature List.\r
1370 //\r
1371 if (CompareMem (NewCert, Cert, CertList->SignatureSize) == 0) {\r
1372 IsNewCert = FALSE;\r
1373 break;\r
1374 }\r
1375 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) Cert + CertList->SignatureSize);\r
1376 }\r
1377 }\r
1378\r
1379 if (!IsNewCert) {\r
1380 break;\r
1381 }\r
1382 Size -= CertList->SignatureListSize;\r
1383 CertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) CertList + CertList->SignatureListSize);\r
1384 }\r
1385\r
1386 if (IsNewCert) {\r
1387 //\r
1388 // New EFI_SIGNATURE_DATA, append it.\r
1389 //\r
1390 if (CopiedCount == 0) {\r
1391 //\r
1392 // Copy EFI_SIGNATURE_LIST header for only once.\r
1393 //\r
1394 CopyMem (Tail, NewCertList, sizeof (EFI_SIGNATURE_LIST) + NewCertList->SignatureHeaderSize);\r
1395 Tail = Tail + sizeof (EFI_SIGNATURE_LIST) + NewCertList->SignatureHeaderSize;\r
1396 }\r
1397\r
1398 CopyMem (Tail, NewCert, NewCertList->SignatureSize);\r
1399 Tail += NewCertList->SignatureSize;\r
1400 CopiedCount++;\r
1401 }\r
1402\r
1403 NewCert = (EFI_SIGNATURE_DATA *) ((UINT8 *) NewCert + NewCertList->SignatureSize);\r
1404 }\r
1405\r
1406 //\r
1407 // Update SignatureListSize in newly appended EFI_SIGNATURE_LIST.\r
1408 //\r
1409 if (CopiedCount != 0) {\r
1410 SignatureListSize = sizeof (EFI_SIGNATURE_LIST) + NewCertList->SignatureHeaderSize + (CopiedCount * NewCertList->SignatureSize);\r
1411 CertList = (EFI_SIGNATURE_LIST *) (Tail - SignatureListSize);\r
1412 CertList->SignatureListSize = (UINT32) SignatureListSize;\r
1413 }\r
1414\r
1415 NewDataSize -= NewCertList->SignatureListSize;\r
1416 NewCertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) NewCertList + NewCertList->SignatureListSize);\r
1417 }\r
1418\r
1419 return (Tail - (UINT8 *) Data);\r
1420}\r
1421\r
0c18794e 1422/**\r
1423 Compare two EFI_TIME data.\r
1424\r
1425\r
1426 @param FirstTime A pointer to the first EFI_TIME data.\r
1427 @param SecondTime A pointer to the second EFI_TIME data.\r
1428\r
1429 @retval TRUE The FirstTime is not later than the SecondTime.\r
1430 @retval FALSE The FirstTime is later than the SecondTime.\r
1431\r
1432**/\r
1433BOOLEAN\r
1434CompareTimeStamp (\r
1435 IN EFI_TIME *FirstTime,\r
1436 IN EFI_TIME *SecondTime\r
1437 )\r
1438{\r
1439 if (FirstTime->Year != SecondTime->Year) {\r
1440 return (BOOLEAN) (FirstTime->Year < SecondTime->Year);\r
1441 } else if (FirstTime->Month != SecondTime->Month) {\r
1442 return (BOOLEAN) (FirstTime->Month < SecondTime->Month);\r
1443 } else if (FirstTime->Day != SecondTime->Day) {\r
1444 return (BOOLEAN) (FirstTime->Day < SecondTime->Day);\r
1445 } else if (FirstTime->Hour != SecondTime->Hour) {\r
1446 return (BOOLEAN) (FirstTime->Hour < SecondTime->Hour);\r
1447 } else if (FirstTime->Minute != SecondTime->Minute) {\r
42ed7604 1448 return (BOOLEAN) (FirstTime->Minute < SecondTime->Minute);\r
2d3fb919 1449 }\r
0c18794e 1450\r
1451 return (BOOLEAN) (FirstTime->Second <= SecondTime->Second);\r
1452}\r
1453\r
ed47ae02 1454/**\r
1455 Find matching signer's certificates for common authenticated variable\r
1456 by corresponding VariableName and VendorGuid from "certdb".\r
1457\r
1458 The data format of "certdb":\r
1459 //\r
1460 // UINT32 CertDbListSize;\r
1461 // /// AUTH_CERT_DB_DATA Certs1[];\r
1462 // /// AUTH_CERT_DB_DATA Certs2[];\r
1463 // /// ...\r
1464 // /// AUTH_CERT_DB_DATA Certsn[];\r
1465 //\r
1466\r
1467 @param[in] VariableName Name of authenticated Variable.\r
1468 @param[in] VendorGuid Vendor GUID of authenticated Variable.\r
1469 @param[in] Data Pointer to variable "certdb".\r
1470 @param[in] DataSize Size of variable "certdb".\r
1471 @param[out] CertOffset Offset of matching CertData, from starting of Data.\r
1472 @param[out] CertDataSize Length of CertData in bytes.\r
1473 @param[out] CertNodeOffset Offset of matching AUTH_CERT_DB_DATA , from\r
1474 starting of Data.\r
1475 @param[out] CertNodeSize Length of AUTH_CERT_DB_DATA in bytes.\r
1476\r
1477 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.\r
1478 @retval EFI_NOT_FOUND Fail to find matching certs.\r
1479 @retval EFI_SUCCESS Find matching certs and output parameters.\r
1480\r
1481**/\r
1482EFI_STATUS\r
1483FindCertsFromDb (\r
1484 IN CHAR16 *VariableName,\r
1485 IN EFI_GUID *VendorGuid,\r
1486 IN UINT8 *Data,\r
1487 IN UINTN DataSize,\r
1488 OUT UINT32 *CertOffset, OPTIONAL\r
1489 OUT UINT32 *CertDataSize, OPTIONAL\r
1490 OUT UINT32 *CertNodeOffset,OPTIONAL\r
1491 OUT UINT32 *CertNodeSize OPTIONAL\r
1492 )\r
1493{\r
1494 UINT32 Offset;\r
1495 AUTH_CERT_DB_DATA *Ptr;\r
1496 UINT32 CertSize;\r
1497 UINT32 NameSize;\r
1498 UINT32 NodeSize;\r
1499 UINT32 CertDbListSize;\r
1500\r
1501 if ((VariableName == NULL) || (VendorGuid == NULL) || (Data == NULL)) {\r
1502 return EFI_INVALID_PARAMETER;\r
1503 }\r
1504\r
1505 //\r
1506 // Check whether DataSize matches recorded CertDbListSize.\r
1507 //\r
1508 if (DataSize < sizeof (UINT32)) {\r
1509 return EFI_INVALID_PARAMETER;\r
1510 }\r
1511\r
1512 CertDbListSize = ReadUnaligned32 ((UINT32 *) Data);\r
1513\r
1514 if (CertDbListSize != (UINT32) DataSize) {\r
1515 return EFI_INVALID_PARAMETER;\r
1516 }\r
1517\r
1518 Offset = sizeof (UINT32);\r
1519\r
1520 //\r
1521 // Get corresponding certificates by VendorGuid and VariableName.\r
1522 //\r
1523 while (Offset < (UINT32) DataSize) {\r
1524 Ptr = (AUTH_CERT_DB_DATA *) (Data + Offset);\r
1525 //\r
1526 // Check whether VendorGuid matches.\r
1527 //\r
1528 if (CompareGuid (&Ptr->VendorGuid, VendorGuid)) {\r
1529 NodeSize = ReadUnaligned32 (&Ptr->CertNodeSize);\r
1530 NameSize = ReadUnaligned32 (&Ptr->NameSize);\r
1531 CertSize = ReadUnaligned32 (&Ptr->CertDataSize);\r
1532\r
1533 if (NodeSize != sizeof (EFI_GUID) + sizeof (UINT32) * 3 + CertSize +\r
1534 sizeof (CHAR16) * NameSize) {\r
1535 return EFI_INVALID_PARAMETER;\r
1536 }\r
1537\r
1538 Offset = Offset + sizeof (EFI_GUID) + sizeof (UINT32) * 3;\r
1539 //\r
1540 // Check whether VariableName matches.\r
1541 //\r
1542 if ((NameSize == StrLen (VariableName)) && \r
1543 (CompareMem (Data + Offset, VariableName, NameSize * sizeof (CHAR16)) == 0)) {\r
1544 Offset = Offset + NameSize * sizeof (CHAR16);\r
1545\r
1546 if (CertOffset != NULL) {\r
1547 *CertOffset = Offset;\r
1548 }\r
1549\r
1550 if (CertDataSize != NULL) {\r
1551 *CertDataSize = CertSize; \r
1552 }\r
1553\r
1554 if (CertNodeOffset != NULL) {\r
1555 *CertNodeOffset = (UINT32) ((UINT8 *) Ptr - Data);\r
1556 }\r
1557\r
1558 if (CertNodeSize != NULL) {\r
1559 *CertNodeSize = NodeSize;\r
1560 }\r
1561\r
1562 return EFI_SUCCESS;\r
1563 } else {\r
1564 Offset = Offset + NameSize * sizeof (CHAR16) + CertSize;\r
1565 }\r
1566 } else {\r
1567 NodeSize = ReadUnaligned32 (&Ptr->CertNodeSize);\r
1568 Offset = Offset + NodeSize;\r
1569 }\r
1570 }\r
1571\r
1572 return EFI_NOT_FOUND; \r
1573}\r
1574\r
1575/**\r
1576 Retrieve signer's certificates for common authenticated variable\r
1577 by corresponding VariableName and VendorGuid from "certdb".\r
1578\r
1579 @param[in] VariableName Name of authenticated Variable.\r
1580 @param[in] VendorGuid Vendor GUID of authenticated Variable.\r
1581 @param[out] CertData Pointer to signer's certificates.\r
1582 @param[out] CertDataSize Length of CertData in bytes.\r
1583\r
1584 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.\r
1585 @retval EFI_NOT_FOUND Fail to find "certdb" or matching certs.\r
1586 @retval EFI_SUCCESS Get signer's certificates successfully.\r
1587\r
1588**/\r
1589EFI_STATUS\r
1590GetCertsFromDb (\r
1591 IN CHAR16 *VariableName,\r
1592 IN EFI_GUID *VendorGuid,\r
1593 OUT UINT8 **CertData,\r
1594 OUT UINT32 *CertDataSize\r
1595 )\r
1596{\r
1597 VARIABLE_POINTER_TRACK CertDbVariable;\r
1598 EFI_STATUS Status;\r
1599 UINT8 *Data;\r
1600 UINTN DataSize;\r
1601 UINT32 CertOffset;\r
1602\r
1603 if ((VariableName == NULL) || (VendorGuid == NULL) || (CertData == NULL) || (CertDataSize == NULL)) {\r
1604 return EFI_INVALID_PARAMETER;\r
1605 }\r
1606 \r
1607 //\r
1608 // Get variable "certdb".\r
1609 //\r
1610 Status = FindVariable (\r
1611 EFI_CERT_DB_NAME,\r
1612 &gEfiCertDbGuid,\r
1613 &CertDbVariable,\r
1614 &mVariableModuleGlobal->VariableGlobal,\r
1615 FALSE\r
1616 ); \r
1617 if (EFI_ERROR (Status)) {\r
1618 return Status;\r
1619 }\r
1620\r
1621 DataSize = DataSizeOfVariable (CertDbVariable.CurrPtr);\r
1622 Data = GetVariableDataPtr (CertDbVariable.CurrPtr);\r
1623 if ((DataSize == 0) || (Data == NULL)) {\r
1624 ASSERT (FALSE);\r
1625 return EFI_NOT_FOUND;\r
1626 }\r
1627\r
1628 Status = FindCertsFromDb (\r
1629 VariableName,\r
1630 VendorGuid,\r
1631 Data,\r
1632 DataSize,\r
1633 &CertOffset,\r
1634 CertDataSize,\r
1635 NULL,\r
1636 NULL\r
1637 );\r
1638\r
1639 if (EFI_ERROR (Status)) {\r
1640 return Status;\r
1641 }\r
1642\r
1643 *CertData = Data + CertOffset;\r
1644 return EFI_SUCCESS;\r
1645}\r
1646\r
1647/**\r
1648 Delete matching signer's certificates when deleting common authenticated\r
1649 variable by corresponding VariableName and VendorGuid from "certdb".\r
1650\r
1651 @param[in] VariableName Name of authenticated Variable.\r
1652 @param[in] VendorGuid Vendor GUID of authenticated Variable.\r
1653\r
1654 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.\r
1655 @retval EFI_NOT_FOUND Fail to find "certdb" or matching certs.\r
1656 @retval EFI_OUT_OF_RESOURCES The operation is failed due to lack of resources.\r
1657 @retval EFI_SUCCESS The operation is completed successfully.\r
1658\r
1659**/\r
1660EFI_STATUS\r
1661DeleteCertsFromDb (\r
1662 IN CHAR16 *VariableName,\r
1663 IN EFI_GUID *VendorGuid\r
1664 )\r
1665{\r
1666 VARIABLE_POINTER_TRACK CertDbVariable;\r
1667 EFI_STATUS Status;\r
1668 UINT8 *Data;\r
1669 UINTN DataSize;\r
1670 UINT32 VarAttr;\r
1671 UINT32 CertNodeOffset;\r
1672 UINT32 CertNodeSize;\r
1673 UINT8 *NewCertDb;\r
1674 UINT32 NewCertDbSize;\r
1675\r
1676 if ((VariableName == NULL) || (VendorGuid == NULL)) {\r
1677 return EFI_INVALID_PARAMETER;\r
1678 }\r
1679 \r
1680 //\r
1681 // Get variable "certdb".\r
1682 //\r
1683 Status = FindVariable (\r
1684 EFI_CERT_DB_NAME,\r
1685 &gEfiCertDbGuid,\r
1686 &CertDbVariable,\r
1687 &mVariableModuleGlobal->VariableGlobal,\r
1688 FALSE\r
1689 ); \r
1690 if (EFI_ERROR (Status)) {\r
1691 return Status;\r
1692 }\r
1693\r
1694 DataSize = DataSizeOfVariable (CertDbVariable.CurrPtr);\r
1695 Data = GetVariableDataPtr (CertDbVariable.CurrPtr);\r
1696 if ((DataSize == 0) || (Data == NULL)) {\r
1697 ASSERT (FALSE);\r
1698 return EFI_NOT_FOUND;\r
1699 }\r
1700\r
1701 if (DataSize == sizeof (UINT32)) {\r
1702 //\r
1703 // There is no certs in certdb.\r
1704 //\r
1705 return EFI_SUCCESS;\r
1706 }\r
1707\r
1708 //\r
1709 // Get corresponding cert node from certdb.\r
1710 //\r
1711 Status = FindCertsFromDb (\r
1712 VariableName,\r
1713 VendorGuid,\r
1714 Data,\r
1715 DataSize,\r
1716 NULL,\r
1717 NULL,\r
1718 &CertNodeOffset,\r
1719 &CertNodeSize\r
1720 );\r
1721\r
1722 if (EFI_ERROR (Status)) {\r
1723 return Status;\r
1724 }\r
1725\r
1726 if (DataSize < (CertNodeOffset + CertNodeSize)) {\r
1727 return EFI_NOT_FOUND;\r
1728 }\r
1729\r
1730 //\r
1731 // Construct new data content of variable "certdb".\r
1732 //\r
1733 NewCertDbSize = (UINT32) DataSize - CertNodeSize;\r
f6e23353 1734 NewCertDb = (UINT8*) mCertDbStore;\r
ed47ae02 1735\r
1736 //\r
1737 // Copy the DB entries before deleting node.\r
1738 //\r
1739 CopyMem (NewCertDb, Data, CertNodeOffset);\r
1740 //\r
1741 // Update CertDbListSize.\r
1742 //\r
1743 CopyMem (NewCertDb, &NewCertDbSize, sizeof (UINT32));\r
1744 //\r
1745 // Copy the DB entries after deleting node.\r
1746 //\r
1747 if (DataSize > (CertNodeOffset + CertNodeSize)) {\r
1748 CopyMem (\r
1749 NewCertDb + CertNodeOffset,\r
1750 Data + CertNodeOffset + CertNodeSize,\r
1751 DataSize - CertNodeOffset - CertNodeSize\r
1752 );\r
1753 }\r
1754\r
1755 //\r
1756 // Set "certdb".\r
1757 // \r
1758 VarAttr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS; \r
1759 Status = UpdateVariable (\r
1760 EFI_CERT_DB_NAME,\r
1761 &gEfiCertDbGuid,\r
1762 NewCertDb,\r
1763 NewCertDbSize,\r
1764 VarAttr,\r
1765 0,\r
1766 0,\r
1767 &CertDbVariable,\r
1768 NULL\r
1769 );\r
1770\r
ed47ae02 1771 return Status;\r
1772}\r
1773\r
1774/**\r
1775 Insert signer's certificates for common authenticated variable with VariableName\r
1776 and VendorGuid in AUTH_CERT_DB_DATA to "certdb".\r
1777\r
1778 @param[in] VariableName Name of authenticated Variable.\r
1779 @param[in] VendorGuid Vendor GUID of authenticated Variable.\r
1780 @param[in] CertData Pointer to signer's certificates.\r
1781 @param[in] CertDataSize Length of CertData in bytes.\r
1782\r
1783 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.\r
1784 @retval EFI_ACCESS_DENIED An AUTH_CERT_DB_DATA entry with same VariableName\r
1785 and VendorGuid already exists.\r
1786 @retval EFI_OUT_OF_RESOURCES The operation is failed due to lack of resources.\r
1787 @retval EFI_SUCCESS Insert an AUTH_CERT_DB_DATA entry to "certdb"\r
1788\r
1789**/\r
1790EFI_STATUS\r
1791InsertCertsToDb (\r
1792 IN CHAR16 *VariableName,\r
1793 IN EFI_GUID *VendorGuid,\r
1794 IN UINT8 *CertData,\r
1795 IN UINTN CertDataSize\r
1796 )\r
1797{\r
1798 VARIABLE_POINTER_TRACK CertDbVariable;\r
1799 EFI_STATUS Status;\r
1800 UINT8 *Data;\r
1801 UINTN DataSize;\r
1802 UINT32 VarAttr;\r
1803 UINT8 *NewCertDb;\r
1804 UINT32 NewCertDbSize;\r
1805 UINT32 CertNodeSize;\r
1806 UINT32 NameSize;\r
1807 AUTH_CERT_DB_DATA *Ptr;\r
1808\r
1809 if ((VariableName == NULL) || (VendorGuid == NULL) || (CertData == NULL)) {\r
1810 return EFI_INVALID_PARAMETER;\r
1811 }\r
1812 \r
1813 //\r
1814 // Get variable "certdb".\r
1815 //\r
1816 Status = FindVariable (\r
1817 EFI_CERT_DB_NAME,\r
1818 &gEfiCertDbGuid,\r
1819 &CertDbVariable,\r
1820 &mVariableModuleGlobal->VariableGlobal,\r
1821 FALSE\r
1822 ); \r
1823 if (EFI_ERROR (Status)) {\r
1824 return Status;\r
1825 }\r
1826\r
1827 DataSize = DataSizeOfVariable (CertDbVariable.CurrPtr);\r
1828 Data = GetVariableDataPtr (CertDbVariable.CurrPtr);\r
1829 if ((DataSize == 0) || (Data == NULL)) {\r
1830 ASSERT (FALSE);\r
1831 return EFI_NOT_FOUND;\r
1832 }\r
1833\r
1834 //\r
1835 // Find whether matching cert node already exists in "certdb".\r
1836 // If yes return error.\r
1837 //\r
1838 Status = FindCertsFromDb (\r
1839 VariableName,\r
1840 VendorGuid,\r
1841 Data,\r
1842 DataSize,\r
1843 NULL,\r
1844 NULL,\r
1845 NULL,\r
1846 NULL\r
1847 );\r
1848\r
1849 if (!EFI_ERROR (Status)) {\r
1850 ASSERT (FALSE);\r
1851 return EFI_ACCESS_DENIED;\r
1852 }\r
1853\r
1854 //\r
1855 // Construct new data content of variable "certdb".\r
1856 //\r
1857 NameSize = (UINT32) StrLen (VariableName);\r
1858 CertNodeSize = sizeof (AUTH_CERT_DB_DATA) + (UINT32) CertDataSize + NameSize * sizeof (CHAR16); \r
f6e23353 1859 NewCertDbSize = (UINT32) DataSize + CertNodeSize;\r
1860 if (NewCertDbSize > MAX_CERTDB_SIZE) {\r
ed47ae02 1861 return EFI_OUT_OF_RESOURCES;\r
1862 }\r
f6e23353 1863 NewCertDb = (UINT8*) mCertDbStore;\r
ed47ae02 1864\r
1865 //\r
1866 // Copy the DB entries before deleting node.\r
1867 //\r
1868 CopyMem (NewCertDb, Data, DataSize);\r
1869 //\r
1870 // Update CertDbListSize.\r
1871 //\r
1872 CopyMem (NewCertDb, &NewCertDbSize, sizeof (UINT32));\r
1873 //\r
1874 // Construct new cert node.\r
1875 //\r
1876 Ptr = (AUTH_CERT_DB_DATA *) (NewCertDb + DataSize);\r
1877 CopyGuid (&Ptr->VendorGuid, VendorGuid);\r
1878 CopyMem (&Ptr->CertNodeSize, &CertNodeSize, sizeof (UINT32));\r
1879 CopyMem (&Ptr->NameSize, &NameSize, sizeof (UINT32));\r
1880 CopyMem (&Ptr->CertDataSize, &CertDataSize, sizeof (UINT32));\r
1881 \r
1882 CopyMem (\r
1883 (UINT8 *) Ptr + sizeof (AUTH_CERT_DB_DATA),\r
1884 VariableName,\r
1885 NameSize * sizeof (CHAR16)\r
1886 );\r
1887\r
1888 CopyMem (\r
1889 (UINT8 *) Ptr + sizeof (AUTH_CERT_DB_DATA) + NameSize * sizeof (CHAR16),\r
1890 CertData,\r
1891 CertDataSize\r
1892 );\r
1893 \r
1894 //\r
1895 // Set "certdb".\r
1896 // \r
1897 VarAttr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS; \r
1898 Status = UpdateVariable (\r
1899 EFI_CERT_DB_NAME,\r
1900 &gEfiCertDbGuid,\r
1901 NewCertDb,\r
1902 NewCertDbSize,\r
1903 VarAttr,\r
1904 0,\r
1905 0,\r
1906 &CertDbVariable,\r
1907 NULL\r
1908 );\r
1909\r
ed47ae02 1910 return Status;\r
1911}\r
1912\r
0c18794e 1913/**\r
1914 Process variable with EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS set\r
1915\r
dc204d5a
JY		 1916 Caution: This function may receive untrusted input.\r
1917 This function may be invoked in SMM mode, and datasize and data are external input.\r
1918 This function will do basic validation, before parse the data.\r
1919 This function will parse the authentication carefully to avoid security issues, like\r
1920 buffer overflow, integer overflow.\r
1921\r
0c18794e 1922 @param[in] VariableName Name of Variable to be found.\r
1923 @param[in] VendorGuid Variable vendor GUID.\r
1924 @param[in] Data Data pointer.\r
1925 @param[in] DataSize Size of Data found. If size is less than the\r
1926 data, this value contains the required size.\r
1927 @param[in] Variable The variable information which is used to keep track of variable usage.\r
1928 @param[in] Attributes Attribute value of the variable.\r
785d84ea 1929 @param[in] AuthVarType Verify against PK, KEK database, private database or certificate in data payload.\r
0c18794e 1930 @param[out] VarDel Delete the variable or not.\r
1931\r
1932 @retval EFI_INVALID_PARAMETER Invalid parameter.\r
2d3fb919 1933 @retval EFI_SECURITY_VIOLATION The variable does NOT pass the validation\r
1934 check carried out by the firmware.\r
0c18794e 1935 @retval EFI_OUT_OF_RESOURCES Failed to process variable due to lack\r
1936 of resources.\r
1937 @retval EFI_SUCCESS Variable pass validation successfully.\r
1938\r
1939**/\r
1940EFI_STATUS\r
1941VerifyTimeBasedPayload (\r
1942 IN CHAR16 *VariableName,\r
1943 IN EFI_GUID *VendorGuid,\r
1944 IN VOID *Data,\r
1945 IN UINTN DataSize,\r
1946 IN VARIABLE_POINTER_TRACK *Variable,\r
1947 IN UINT32 Attributes,\r
ed47ae02 1948 IN AUTHVAR_TYPE AuthVarType,\r
0c18794e 1949 OUT BOOLEAN *VarDel\r
1950 )\r
1951{\r
1952 UINT8 *RootCert;\r
1953 UINT8 *SigData;\r
2d3fb919 1954 UINT8 *PayloadPtr;\r
0c18794e 1955 UINTN RootCertSize;\r
1956 UINTN Index;\r
2d3fb919 1957 UINTN CertCount;\r
1958 UINTN PayloadSize;\r
0c18794e 1959 UINT32 Attr;\r
1960 UINT32 SigDataSize;\r
1961 UINT32 KekDataSize;\r
0c18794e 1962 BOOLEAN VerifyStatus;\r
1963 EFI_STATUS Status;\r
1964 EFI_SIGNATURE_LIST *CertList;\r
1965 EFI_SIGNATURE_DATA *Cert;\r
1966 VARIABLE_POINTER_TRACK KekVariable;\r
1967 EFI_VARIABLE_AUTHENTICATION_2 *CertData;\r
1968 UINT8 *NewData;\r
1969 UINTN NewDataSize;\r
1970 VARIABLE_POINTER_TRACK PkVariable;\r
2d3fb919 1971 UINT8 *Buffer;\r
1972 UINTN Length;\r
ed47ae02 1973 UINT8 *SignerCerts;\r
1974 UINT8 *WrapSigData;\r
1975 UINTN CertStackSize;\r
1976 UINT8 *CertsInCertDb;\r
1977 UINT32 CertsSizeinDb;\r
0c18794e 1978\r
0c18794e 1979 VerifyStatus = FALSE;\r
1980 CertData = NULL;\r
1981 NewData = NULL;\r
1982 Attr = Attributes;\r
ed47ae02 1983 WrapSigData = NULL;\r
1984 SignerCerts = NULL;\r
1985 RootCert = NULL;\r
0c18794e 1986\r
1987 //\r
2d3fb919 1988 // When the attribute EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS is\r
0c18794e 1989 // set, then the Data buffer shall begin with an instance of a complete (and serialized)\r
2d3fb919 1990 // EFI_VARIABLE_AUTHENTICATION_2 descriptor. The descriptor shall be followed by the new\r
1991 // variable value and DataSize shall reflect the combined size of the descriptor and the new\r
1992 // variable value. The authentication descriptor is not part of the variable data and is not\r
0c18794e 1993 // returned by subsequent calls to GetVariable().\r
1994 //\r
1995 CertData = (EFI_VARIABLE_AUTHENTICATION_2 *) Data;\r
2d3fb919 1996\r
1997 //\r
1998 // Verify that Pad1, Nanosecond, TimeZone, Daylight and Pad2 components of the\r
1999 // TimeStamp value are set to zero.\r
2000 //\r
2001 if ((CertData->TimeStamp.Pad1 != 0) ||\r
2002 (CertData->TimeStamp.Nanosecond != 0) ||\r
2003 (CertData->TimeStamp.TimeZone != 0) ||\r
2004 (CertData->TimeStamp.Daylight != 0) ||\r
2005 (CertData->TimeStamp.Pad2 != 0)) {\r
2e24814a 2006 return EFI_SECURITY_VIOLATION;\r
2d3fb919 2007 }\r
2008\r
0c18794e 2009 if ((Variable->CurrPtr != NULL) && ((Attributes & EFI_VARIABLE_APPEND_WRITE) == 0)) {\r
2010 if (CompareTimeStamp (&CertData->TimeStamp, &Variable->CurrPtr->TimeStamp)) {\r
2011 //\r
2012 // TimeStamp check fail, suspicious replay attack, return EFI_SECURITY_VIOLATION.\r
2013 //\r
2014 return EFI_SECURITY_VIOLATION;\r
2015 }\r
2016 }\r
2017\r
2018 //\r
2019 // wCertificateType should be WIN_CERT_TYPE_EFI_GUID.\r
2020 // Cert type should be EFI_CERT_TYPE_PKCS7_GUID.\r
2021 //\r
2022 if ((CertData->AuthInfo.Hdr.wCertificateType != WIN_CERT_TYPE_EFI_GUID) ||\r
2d3fb919 2023 !CompareGuid (&CertData->AuthInfo.CertType, &gEfiCertPkcs7Guid)) {\r
0c18794e 2024 //\r
2025 // Invalid AuthInfo type, return EFI_SECURITY_VIOLATION.\r
2026 //\r
2027 return EFI_SECURITY_VIOLATION;\r
2028 }\r
2d3fb919 2029\r
0c18794e 2030 //\r
2031 // Find out Pkcs7 SignedData which follows the EFI_VARIABLE_AUTHENTICATION_2 descriptor.\r
2032 // AuthInfo.Hdr.dwLength is the length of the entire certificate, including the length of the header.\r
2033 //\r
2d3fb919 2034 SigData = CertData->AuthInfo.CertData;\r
2035 SigDataSize = CertData->AuthInfo.Hdr.dwLength - (UINT32) (OFFSET_OF (WIN_CERTIFICATE_UEFI_GUID, CertData));\r
648f98d1 2036\r
0c18794e 2037 //\r
2038 // Find out the new data payload which follows Pkcs7 SignedData directly.\r
2039 //\r
2d3fb919 2040 PayloadPtr = SigData + SigDataSize;\r
2041 PayloadSize = DataSize - OFFSET_OF_AUTHINFO2_CERT_DATA - (UINTN) SigDataSize;\r
0c18794e 2042\r
2043 //\r
2044 // Construct a buffer to fill with (VariableName, VendorGuid, Attributes, TimeStamp, Data).\r
2045 //\r
2d3fb919 2046 NewDataSize = PayloadSize + sizeof (EFI_TIME) + sizeof (UINT32) +\r
2047 sizeof (EFI_GUID) + StrSize (VariableName) - sizeof (CHAR16);\r
2048 NewData = mSerializationRuntimeBuffer;\r
0c18794e 2049\r
2d3fb919 2050 Buffer = NewData;\r
2051 Length = StrLen (VariableName) * sizeof (CHAR16);\r
2052 CopyMem (Buffer, VariableName, Length);\r
2053 Buffer += Length;\r
0c18794e 2054\r
2d3fb919 2055 Length = sizeof (EFI_GUID);\r
2056 CopyMem (Buffer, VendorGuid, Length);\r
2057 Buffer += Length;\r
0c18794e 2058\r
2d3fb919 2059 Length = sizeof (UINT32);\r
2060 CopyMem (Buffer, &Attr, Length);\r
2061 Buffer += Length;\r
0c18794e 2062\r
2d3fb919 2063 Length = sizeof (EFI_TIME);\r
2064 CopyMem (Buffer, &CertData->TimeStamp, Length);\r
2065 Buffer += Length;\r
0c18794e 2066\r
2d3fb919 2067 CopyMem (Buffer, PayloadPtr, PayloadSize);\r
0c18794e 2068\r
ed47ae02 2069 if (AuthVarType == AuthVarTypePk) {\r
0c18794e 2070 //\r
2071 // Get platform key from variable.\r
2072 //\r
2073 Status = FindVariable (\r
2d3fb919 2074 EFI_PLATFORM_KEY_NAME,\r
2075 &gEfiGlobalVariableGuid,\r
2076 &PkVariable,\r
ecc722ad 2077 &mVariableModuleGlobal->VariableGlobal,\r
2078 FALSE\r
0c18794e 2079 );\r
2080 if (EFI_ERROR (Status)) {\r
2081 return Status;\r
2082 }\r
2083\r
2084 CertList = (EFI_SIGNATURE_LIST *) GetVariableDataPtr (PkVariable.CurrPtr);\r
2085 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertList + sizeof (EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);\r
2086 RootCert = Cert->SignatureData;\r
4e33001c 2087 RootCertSize = CertList->SignatureSize - (sizeof (EFI_SIGNATURE_DATA) - 1);\r
0c18794e 2088\r
2089\r
2090 //\r
2091 // Verify Pkcs7 SignedData via Pkcs7Verify library.\r
2092 //\r
2093 VerifyStatus = Pkcs7Verify (\r
2094 SigData,\r
2095 SigDataSize,\r
2096 RootCert,\r
2097 RootCertSize,\r
2098 NewData,\r
2099 NewDataSize\r
2100 );\r
2101\r
ed47ae02 2102 } else if (AuthVarType == AuthVarTypeKek) {\r
2d3fb919 2103\r
0c18794e 2104 //\r
2105 // Get KEK database from variable.\r
2106 //\r
2107 Status = FindVariable (\r
2d3fb919 2108 EFI_KEY_EXCHANGE_KEY_NAME,\r
2109 &gEfiGlobalVariableGuid,\r
2110 &KekVariable,\r
ecc722ad 2111 &mVariableModuleGlobal->VariableGlobal,\r
2112 FALSE\r
0c18794e 2113 );\r
2114 if (EFI_ERROR (Status)) {\r
2115 return Status;\r
2116 }\r
2117\r
2118 //\r
2119 // Ready to verify Pkcs7 SignedData. Go through KEK Signature Database to find out X.509 CertList.\r
2d3fb919 2120 //\r
0c18794e 2121 KekDataSize = KekVariable.CurrPtr->DataSize;\r
2122 CertList = (EFI_SIGNATURE_LIST *) GetVariableDataPtr (KekVariable.CurrPtr);\r
2123 while ((KekDataSize > 0) && (KekDataSize >= CertList->SignatureListSize)) {\r
2124 if (CompareGuid (&CertList->SignatureType, &gEfiCertX509Guid)) {\r
2125 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertList + sizeof (EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);\r
2126 CertCount = (CertList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - CertList->SignatureHeaderSize) / CertList->SignatureSize;\r
2127 for (Index = 0; Index < CertCount; Index++) {\r
2128 //\r
2129 // Iterate each Signature Data Node within this CertList for a verify\r
2130 //\r
2131 RootCert = Cert->SignatureData;\r
4e33001c 2132 RootCertSize = CertList->SignatureSize - (sizeof (EFI_SIGNATURE_DATA) - 1);\r
2d3fb919 2133\r
0c18794e 2134 //\r
2135 // Verify Pkcs7 SignedData via Pkcs7Verify library.\r
2136 //\r
2137 VerifyStatus = Pkcs7Verify (\r
2138 SigData,\r
2139 SigDataSize,\r
2140 RootCert,\r
2141 RootCertSize,\r
2142 NewData,\r
2143 NewDataSize\r
2144 );\r
2145 if (VerifyStatus) {\r
2146 goto Exit;\r
2147 }\r
2148 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) Cert + CertList->SignatureSize);\r
2149 }\r
2150 }\r
2151 KekDataSize -= CertList->SignatureListSize;\r
2152 CertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) CertList + CertList->SignatureListSize);\r
2153 }\r
ed47ae02 2154 } else if (AuthVarType == AuthVarTypePriv) {\r
2155\r
2156 //\r
2157 // Process common authenticated variable except PK/KEK/DB/DBX.\r
2158 // Get signer's certificates from SignedData.\r
2159 //\r
2160 VerifyStatus = Pkcs7GetSigners (\r
2161 SigData,\r
2162 SigDataSize,\r
2163 &SignerCerts,\r
2164 &CertStackSize,\r
2165 &RootCert,\r
2166 &RootCertSize\r
2167 );\r
2168 if (!VerifyStatus) {\r
2169 goto Exit;\r
2170 }\r
2171\r
2172 //\r
2173 // Get previously stored signer's certificates from certdb for existing\r
2174 // variable. Check whether they are identical with signer's certificates\r
2175 // in SignedData. If not, return error immediately.\r
2176 //\r
2177 if ((Variable->CurrPtr != NULL)) {\r
2178 VerifyStatus = FALSE;\r
2179\r
2180 Status = GetCertsFromDb (VariableName, VendorGuid, &CertsInCertDb, &CertsSizeinDb);\r
2181 if (EFI_ERROR (Status)) {\r
2182 goto Exit;\r
2183 }\r
2184 \r
2185 if ((CertStackSize != CertsSizeinDb) ||\r
2186 (CompareMem (SignerCerts, CertsInCertDb, CertsSizeinDb) != 0)) {\r
2187 goto Exit;\r
2188 }\r
2189 }\r
2190\r
2191 VerifyStatus = Pkcs7Verify (\r
2192 SigData,\r
2193 SigDataSize,\r
2194 RootCert,\r
2195 RootCertSize,\r
2196 NewData,\r
2197 NewDataSize\r
2198 );\r
2199 if (!VerifyStatus) {\r
2200 goto Exit;\r
2201 }\r
2202\r
2203 //\r
2204 // Delete signer's certificates when delete the common authenticated variable.\r
2205 //\r
275beb2b 2206 if ((PayloadSize == 0) && (Variable->CurrPtr != NULL) && ((Attributes & EFI_VARIABLE_APPEND_WRITE) == 0)) {\r
ed47ae02 2207 Status = DeleteCertsFromDb (VariableName, VendorGuid);\r
2208 if (EFI_ERROR (Status)) {\r
2209 VerifyStatus = FALSE;\r
2210 goto Exit;\r
2211 }\r
275beb2b 2212 } else if (Variable->CurrPtr == NULL && PayloadSize != 0) {\r
ed47ae02 2213 //\r
2214 // Insert signer's certificates when adding a new common authenticated variable.\r
2215 //\r
2216 Status = InsertCertsToDb (VariableName, VendorGuid, SignerCerts, CertStackSize);\r
2217 if (EFI_ERROR (Status)) {\r
2218 VerifyStatus = FALSE;\r
2219 goto Exit;\r
2220 }\r
2221 }\r
785d84ea 2222 } else if (AuthVarType == AuthVarTypePayload) {\r
2223 CertList = (EFI_SIGNATURE_LIST *) PayloadPtr;\r
2224 Cert = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertList + sizeof (EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);\r
2225 RootCert = Cert->SignatureData;\r
2226 RootCertSize = CertList->SignatureSize - (sizeof (EFI_SIGNATURE_DATA) - 1);\r
2227 \r
2228 // Verify Pkcs7 SignedData via Pkcs7Verify library.\r
2229 //\r
2230 VerifyStatus = Pkcs7Verify (\r
2231 SigData,\r
2232 SigDataSize,\r
2233 RootCert,\r
2234 RootCertSize,\r
2235 NewData,\r
2236 NewDataSize\r
2237 );\r
ed47ae02 2238 } else {\r
2239 return EFI_SECURITY_VIOLATION;\r
0c18794e 2240 }\r
2241\r
2242Exit:\r
2243\r
ed47ae02 2244 if (AuthVarType == AuthVarTypePriv) {\r
2245 Pkcs7FreeSigners (RootCert);\r
2246 Pkcs7FreeSigners (SignerCerts);\r
2247 }\r
2248\r
0c18794e 2249 if (!VerifyStatus) {\r
2250 return EFI_SECURITY_VIOLATION;\r
2251 }\r
2252\r
d912bad7 2253 Status = CheckSignatureListFormat(VariableName, VendorGuid, PayloadPtr, PayloadSize);\r
2254 if (EFI_ERROR (Status)) {\r
2255 return Status;\r
2256 }\r
2257\r
2d3fb919 2258 if ((PayloadSize == 0) && (VarDel != NULL)) {\r
0c18794e 2259 *VarDel = TRUE;\r
2260 }\r
2d3fb919 2261\r
0c18794e 2262 //\r
2263 // Final step: Update/Append Variable if it pass Pkcs7Verify\r
2264 //\r
ed47ae02 2265 return UpdateVariable (\r
2266 VariableName,\r
2267 VendorGuid,\r
2268 PayloadPtr,\r
2269 PayloadSize,\r
2270 Attributes,\r
2271 0,\r
2272 0,\r
2273 Variable,\r
2274 &CertData->TimeStamp\r
2275 );\r
0c18794e 2276}\r
ed47ae02 2277\r
EFI Development Kit II mirror for PVE