SecurityPkg/Library/TcgStorageCoreLib/TcgStorageUtil.c

   1 /** @file
   2   Provide functions to provide tcg storage core spec related functions.
   3
   4 Copyright (c) 2016, Intel Corporation. All rights reserved.<BR>
   5 SPDX-License-Identifier: BSD-2-Clause-Patent
   6
   7 **/
   8
   9 #include <Library/TcgStorageCoreLib.h>
  10
  11 #include <Library/BaseLib.h>
  12 #include <Library/BaseMemoryLib.h>
  13 #include <Library/DebugLib.h>
  14
  15 typedef struct {
  16     UINT16                                FeatureCode;
  17     TCG_LEVEL0_FEATURE_DESCRIPTOR_HEADER  *Feature;
  18     UINTN                                 FeatureSize;
  19 } TCG_FIND_FEATURE_CTX;
  20
  21 /**
  22   Returns a human-readable string representing a method status return code.
  23
  24   @param[in]  MethodStatus   Method status to translate to a string
  25
  26
  27   @retval   return the string info.
  28 **/
  29 CHAR8*
  30 EFIAPI
  31 TcgMethodStatusString(
  32   UINT8 MethodStatus
  33   )
  34 {
  35   switch (MethodStatus) {
  36     #define C(status) case TCG_METHOD_STATUS_CODE_ ## status: return #status
  37             C(SUCCESS);
  38             C(NOT_AUTHORIZED);
  39             C(OBSOLETE);
  40             C(SP_BUSY);
  41             C(SP_FAILED);
  42             C(SP_DISABLED);
  43             C(SP_FROZEN);
  44             C(NO_SESSIONS_AVAILABLE);
  45             C(UNIQUENESS_CONFLICT);
  46             C(INSUFFICIENT_SPACE);
  47             C(INSUFFICIENT_ROWS);
  48             C(INVALID_PARAMETER);
  49             C(OBSOLETE2);
  50             C(OBSOLETE3);
  51             C(TPER_MALFUNCTION);
  52             C(TRANSACTION_FAILURE);
  53             C(RESPONSE_OVERFLOW);
  54             C(AUTHORITY_LOCKED_OUT);
  55             C(FAIL);
  56     #undef C
  57   }
  58   return "unknown";
  59 }
  60
  61
  62 /**
  63   adds call token and method Header (invoking id, and method id).
  64
  65   @param    CreateStruct             The input create structure.
  66   @param    InvokingId               Invoking id.
  67   @param    MethodId                 Method id.
  68
  69 **/
  70 TCG_RESULT
  71 EFIAPI
  72 TcgStartMethodCall(
  73   TCG_CREATE_STRUCT   *CreateStruct,
  74   TCG_UID             InvokingId,
  75   TCG_UID             MethodId
  76   )
  77 {
  78   NULL_CHECK(CreateStruct);
  79
  80   if (CreateStruct->ComPacket == NULL ||
  81       CreateStruct->CurPacket == NULL ||
  82       CreateStruct->CurSubPacket == NULL
  83      ) {
  84     DEBUG ((DEBUG_INFO, "unexpected state: ComPacket=%p CurPacket=%p CurSubPacket=%p\n", CreateStruct->ComPacket, CreateStruct->CurPacket, CreateStruct->CurSubPacket));
  85     return (TcgResultFailureInvalidAction);
  86   }
  87
  88   ERROR_CHECK(TcgAddCall(CreateStruct));
  89   ERROR_CHECK(TcgAddTcgUid(CreateStruct, InvokingId));
  90   ERROR_CHECK(TcgAddTcgUid(CreateStruct, MethodId));
  91
  92   return TcgResultSuccess;
  93 }
  94
  95 /**
  96   Adds START LIST token.
  97
  98   @param    CreateStruct        The input create structure.
  99
 100 **/
 101 TCG_RESULT
 102 EFIAPI
 103 TcgStartParameters(
 104   TCG_CREATE_STRUCT           *CreateStruct
 105   )
 106 {
 107   NULL_CHECK(CreateStruct);
 108
 109   if (CreateStruct->ComPacket == NULL ||
 110       CreateStruct->CurPacket == NULL ||
 111       CreateStruct->CurSubPacket == NULL
 112      ) {
 113     DEBUG ((DEBUG_INFO, "unexpected state: ComPacket=%p CurPacket=%p CurSubPacket=%p\n", CreateStruct->ComPacket, CreateStruct->CurPacket, CreateStruct->CurSubPacket));
 114     return (TcgResultFailureInvalidAction);
 115   }
 116
 117   return TcgAddStartList(CreateStruct);
 118 }
 119
 120 /**
 121   Adds END LIST token.
 122
 123   @param    CreateStruct        The input create structure.
 124
 125 **/
 126 TCG_RESULT
 127 EFIAPI
 128 TcgEndParameters(
 129   TCG_CREATE_STRUCT   *CreateStruct
 130   )
 131 {
 132   NULL_CHECK(CreateStruct);
 133
 134   if (CreateStruct->ComPacket == NULL ||
 135       CreateStruct->CurPacket == NULL ||
 136       CreateStruct->CurSubPacket == NULL
 137      ) {
 138     DEBUG ((DEBUG_INFO, "unexpected state: ComPacket=%p CurPacket=%p CurSubPacket=%p\n", CreateStruct->ComPacket, CreateStruct->CurPacket, CreateStruct->CurSubPacket));
 139     return (TcgResultFailureInvalidAction);
 140   }
 141
 142   return TcgAddEndList(CreateStruct);
 143 }
 144
 145 /**
 146   Adds END Data token and method list.
 147
 148   @param    CreateStruct        The input create structure.
 149
 150 **/
 151 TCG_RESULT
 152 EFIAPI
 153 TcgEndMethodCall(
 154   TCG_CREATE_STRUCT      *CreateStruct
 155   )
 156 {
 157   NULL_CHECK(CreateStruct);
 158
 159   if (CreateStruct->ComPacket == NULL ||
 160       CreateStruct->CurPacket == NULL ||
 161       CreateStruct->CurSubPacket == NULL
 162      ) {
 163     DEBUG ((DEBUG_INFO, "unexpected state: ComPacket=%p CurPacket=%p CurSubPacket=%p\n", CreateStruct->ComPacket, CreateStruct->CurPacket, CreateStruct->CurSubPacket));
 164     return (TcgResultFailureInvalidAction);
 165   }
 166
 167   ERROR_CHECK(TcgAddEndOfData(CreateStruct));
 168
 169   ERROR_CHECK(TcgAddStartList(CreateStruct));
 170   ERROR_CHECK(TcgAddUINT8(CreateStruct, 0x00));   // expected to complete properly
 171   ERROR_CHECK(TcgAddUINT8(CreateStruct, 0x00));   // reserved
 172   ERROR_CHECK(TcgAddUINT8(CreateStruct, 0x00));   // reserved
 173   ERROR_CHECK(TcgAddEndList(CreateStruct));
 174
 175   return TcgResultSuccess;
 176 }
 177
 178 /**
 179   Retrieves the comID and Extended comID of the ComPacket in the Tcg response.
 180   It is intended to be used to confirm the received Tcg response is intended for user that received it.
 181
 182   @param [in]        ParseStruct        Structure used to parse received TCG response.
 183   @param [in/out]    ComId              comID retrieved from received ComPacket.
 184   @param [in/out]    ComIdExtension     Extended comID retrieved from received ComPacket
 185
 186 **/
 187 TCG_RESULT
 188 EFIAPI
 189 TcgGetComIds(
 190   const TCG_PARSE_STRUCT     *ParseStruct,
 191   UINT16                     *ComId,
 192   UINT16                     *ComIdExtension
 193   )
 194 {
 195   NULL_CHECK(ParseStruct);
 196   NULL_CHECK(ComId);
 197   NULL_CHECK(ComIdExtension);
 198
 199   if (ParseStruct->ComPacket == NULL) {
 200     DEBUG ((DEBUG_INFO, "unexpected state: ComPacket=%p\n", ParseStruct->ComPacket));
 201     return TcgResultFailureInvalidAction;
 202   }
 203
 204   *ComId = SwapBytes16(ParseStruct->ComPacket->ComIDBE);
 205   *ComIdExtension = SwapBytes16(ParseStruct->ComPacket->ComIDExtensionBE);
 206
 207   return TcgResultSuccess;
 208 }
 209
 210 /**
 211   Checks if the ComIDs of the response match the expected values.
 212
 213   @param[in]   ParseStruct               Structure used to parse received TCG response
 214   @param[in]   ExpectedComId             Expected comID
 215   @param[in]   ExpectedComIdExtension    Expected extended comID
 216
 217 **/
 218 TCG_RESULT
 219 EFIAPI
 220 TcgCheckComIds(
 221   const TCG_PARSE_STRUCT     *ParseStruct,
 222   UINT16                     ExpectedComId,
 223   UINT16                     ExpectedComIdExtension
 224   )
 225 {
 226   UINT16 ParseComId;
 227   UINT16 ParseComIdExtension;
 228
 229   ERROR_CHECK(TcgGetComIds(ParseStruct, &ParseComId, &ParseComIdExtension));
 230   if (ParseComId != ExpectedComId || ParseComIdExtension != ExpectedComIdExtension) {
 231     DEBUG ((DEBUG_INFO, "Com ID: Actual 0x%02X Expected 0x%02X\n", ParseComId, ExpectedComId));
 232     DEBUG ((DEBUG_INFO, "Extended Com ID: 0x%02X Expected 0x%02X\n", ParseComIdExtension, ExpectedComIdExtension));
 233     return TcgResultFailure;
 234   }
 235   return TcgResultSuccess;
 236 }
 237
 238 /**
 239  Returns the method status of the current subpacket.  Does not affect the current position
 240  in the ComPacket.  In other words, it can be called whenever you have a valid SubPacket.
 241
 242  @param [in/out]  ParseStruct       Structure used to parse received TCG response
 243  @param [in/out]  MethodStatus      Method status retrieved of the current SubPacket
 244
 245 **/
 246 TCG_RESULT
 247 EFIAPI
 248 TcgGetMethodStatus(
 249   const TCG_PARSE_STRUCT            *ParseStruct,
 250   UINT8                             *MethodStatus
 251   )
 252 {
 253   TCG_PARSE_STRUCT TmpParseStruct;
 254   TCG_TOKEN TcgToken;
 255   UINT8 Reserved1, Reserved2;
 256
 257   NULL_CHECK(ParseStruct);
 258   NULL_CHECK(MethodStatus);
 259
 260   if (ParseStruct->ComPacket == NULL ||
 261       ParseStruct->CurPacket == NULL ||
 262       ParseStruct->CurSubPacket == NULL
 263      ) {
 264     DEBUG ((DEBUG_INFO, "unexpected state: ComPacket=%p CurPacket=%p CurSubPacket=%p\n", ParseStruct->ComPacket, ParseStruct->CurPacket, ParseStruct->CurSubPacket));
 265     return TcgResultFailureInvalidAction;
 266   }
 267
 268   // duplicate ParseStruct, then don't need to "reset" location cur ptr
 269   CopyMem (&TmpParseStruct, ParseStruct, sizeof(TCG_PARSE_STRUCT));
 270
 271   // method status list exists after the end method call in the subpacket
 272   // skip tokens until ENDDATA is found
 273   do {
 274     ERROR_CHECK(TcgGetNextToken(&TmpParseStruct, &TcgToken));
 275   } while (TcgToken.Type != TcgTokenTypeEndOfData);
 276
 277   // only reach here if enddata is found
 278   // at this point, the curptr is pointing at method status list beginning
 279   ERROR_CHECK(TcgGetNextStartList(&TmpParseStruct));
 280   ERROR_CHECK(TcgGetNextUINT8(&TmpParseStruct, MethodStatus));
 281   ERROR_CHECK(TcgGetNextUINT8(&TmpParseStruct, &Reserved1));
 282   ERROR_CHECK(TcgGetNextUINT8(&TmpParseStruct, &Reserved2));
 283   ERROR_CHECK(TcgGetNextEndList(&TmpParseStruct));
 284
 285   if (Reserved1 != 0) {
 286     DEBUG ((DEBUG_INFO, "Method status reserved1 = 0x%02X (expected 0)\n", Reserved1));
 287     return TcgResultFailure;
 288   }
 289
 290   if (Reserved2 != 0) {
 291     DEBUG ((DEBUG_INFO, "Method status reserved2 = 0x%02X (expected 0)\n", Reserved1));
 292     return TcgResultFailure;
 293   }
 294
 295   return TcgResultSuccess;
 296 }
 297
 298 /**
 299   Return the toke type string info.
 300
 301   @param    Type       Input the type info.
 302
 303   @retval   Return the string for this type.
 304
 305 **/
 306 CHAR8*
 307 EFIAPI
 308 TcgTokenTypeString(
 309   TCG_TOKEN_TYPE  Type
 310   )
 311 {
 312   switch (Type) {
 313     case TcgTokenTypeReserved: return "Reserved";
 314     case TcgTokenTypeTinyAtom: return "Tiny Atom";
 315     case TcgTokenTypeShortAtom: return "Short Atom";
 316     case TcgTokenTypeMediumAtom: return "Medium Atom";
 317     case TcgTokenTypeLongAtom: return "Long Atom";
 318     case TcgTokenTypeStartList: return "Start List";
 319     case TcgTokenTypeEndList: return "End List";
 320     case TcgTokenTypeStartName: return "Start Name";
 321     case TcgTokenTypeEndName: return "End Name";
 322     case TcgTokenTypeCall: return "Call";
 323     case TcgTokenTypeEndOfData: return "End of Data";
 324     case TcgTokenTypeEndOfSession: return "End of Session";
 325     case TcgTokenTypeStartTransaction: return "Start Transaction";
 326     case TcgTokenTypeEndTransaction: return "End Transaction";
 327     case TcgTokenTypeEmptyAtom: return "Empty atom";
 328   }
 329   return "Unknown";
 330 }
 331
 332
 333 /**
 334
 335   Adds Start Session call to the data structure.  This creates the entire ComPacket structure and
 336   returns the size of the entire compacket in the size parameter.
 337
 338   @param [in/out]    CreateStruct               Structure used to add the start session call
 339   @param [in/out]    Size                       Describes the size of the entire ComPacket (header and payload). Filled out by function.
 340   @param [in]        ComId                      ComID for the ComPacket
 341   @param [in]        ComIdExtension             Extended ComID for the ComPacket
 342   @param [in]        HostSessionId              Host Session ID
 343   @param [in]        SpId                       Security Provider to start session with
 344   @param [in]        Write                      Write option for start session.  TRUE = start session requests write access
 345   @param [in]        HostChallengeLength        Length of the host challenge.  Length should be 0 if hostChallenge is NULL
 346   @param [in]        HostChallenge              Host challenge for Host Signing Authority.  If NULL, then no Host Challenge shall be sent.
 347   @param [in]        HostSigningAuthority       Host Signing Authority used for start session.  If NULL, then no Host Signing Authority shall be sent.
 348
 349 **/
 350 TCG_RESULT
 351 EFIAPI
 352 TcgCreateStartSession(
 353   TCG_CREATE_STRUCT     *CreateStruct,
 354   UINT32                *Size,
 355   UINT16                ComId,
 356   UINT16                ComIdExtension,
 357   UINT32                HostSessionId,
 358   TCG_UID               SpId,
 359   BOOLEAN               Write,
 360   UINT32                HostChallengeLength,
 361   const VOID            *HostChallenge,
 362   TCG_UID               HostSigningAuthority
 363   )
 364 {
 365   ERROR_CHECK(TcgStartComPacket(CreateStruct, ComId, ComIdExtension));
 366   ERROR_CHECK(TcgStartPacket(CreateStruct, 0x0, 0x0, 0x0, 0x0, 0x0)) ;
 367   ERROR_CHECK(TcgStartSubPacket(CreateStruct, 0x0));
 368   ERROR_CHECK(TcgStartMethodCall(CreateStruct, TCG_UID_SMUID, TCG_UID_SM_START_SESSION));
 369   ERROR_CHECK(TcgStartParameters(CreateStruct));
 370   ERROR_CHECK(TcgAddUINT32(CreateStruct, HostSessionId));
 371   ERROR_CHECK(TcgAddTcgUid(CreateStruct, SpId));
 372   ERROR_CHECK(TcgAddBOOLEAN(CreateStruct, Write));
 373
 374   // optional parameters
 375   if (HostChallenge != NULL && HostChallengeLength != 0) {
 376     ERROR_CHECK(TcgAddStartName(CreateStruct));
 377     ERROR_CHECK(TcgAddUINT8(CreateStruct, 0x00));   //TODO Create Enum for Method Optional Parameters?
 378     ERROR_CHECK(TcgAddByteSequence(CreateStruct, HostChallenge, HostChallengeLength, FALSE));
 379     ERROR_CHECK(TcgAddEndName(CreateStruct));
 380   }
 381   // optional parameters
 382   if (HostSigningAuthority != 0) {
 383     ERROR_CHECK(TcgAddStartName(CreateStruct));
 384     ERROR_CHECK(TcgAddUINT8(CreateStruct, 0x03));   //TODO Create Enum for Method Optional Parameters?
 385     ERROR_CHECK(TcgAddTcgUid(CreateStruct, HostSigningAuthority));
 386     ERROR_CHECK(TcgAddEndName(CreateStruct));
 387   }
 388
 389   ERROR_CHECK(TcgEndParameters(CreateStruct));
 390   ERROR_CHECK(TcgEndMethodCall(CreateStruct));
 391   ERROR_CHECK(TcgEndSubPacket(CreateStruct));
 392   ERROR_CHECK(TcgEndPacket(CreateStruct));
 393   ERROR_CHECK(TcgEndComPacket(CreateStruct, Size));
 394
 395   return TcgResultSuccess;
 396 }
 397
 398 /**
 399  Parses the Sync Session response contained in the parseStruct to retrieve Tper session ID.  If the Sync Session response
 400  parameters do not match the comID, extended ComID and host session ID then a failure is returned.
 401
 402  @param[in/out]   ParseStruct          Structure used to parse received TCG response, contains Sync Session response.
 403  @param[in]       ComId                Expected ComID that is compared to actual ComID of response
 404  @param[in]       ComIdExtension       Expected Extended ComID that is compared to actual Extended ComID of response
 405  @param[in]       HostSessionId        Expected Host Session ID that is compared to actual  Host Session ID of response
 406  @param[in/out]   TperSessionId        Tper Session ID retrieved from the Sync Session response.
 407
 408 **/
 409 TCG_RESULT
 410 EFIAPI
 411 TcgParseSyncSession(
 412   const TCG_PARSE_STRUCT  *ParseStruct,
 413   UINT16                  ComId,
 414   UINT16                  ComIdExtension,
 415   UINT32                  HostSessionId,
 416   UINT32                  *TperSessionId
 417   )
 418 {
 419   UINT8 MethodStatus;
 420   TCG_PARSE_STRUCT TmpParseStruct;
 421   UINT16 ParseComId;
 422   UINT16 ParseExtComId;
 423   TCG_UID InvokingUID;
 424   TCG_UID MethodUID;
 425   UINT32 RecvHostSessionId;
 426
 427   NULL_CHECK(ParseStruct);
 428   NULL_CHECK(TperSessionId);
 429
 430   CopyMem (&TmpParseStruct, ParseStruct, sizeof(TCG_PARSE_STRUCT));
 431
 432   // verify method status is good
 433   ERROR_CHECK(TcgGetMethodStatus(&TmpParseStruct, &MethodStatus));
 434   METHOD_STATUS_ERROR_CHECK (MethodStatus, TcgResultFailure);
 435
 436   // verify comids
 437   ERROR_CHECK(TcgGetComIds(&TmpParseStruct, &ParseComId, &ParseExtComId));
 438
 439   if ((ComId != ParseComId) || (ComIdExtension != ParseExtComId)) {
 440     DEBUG ((DEBUG_INFO, "unmatched comid (exp: 0x%X recv: 0x%X) or comid extension (exp: 0x%X recv: 0x%X)\n", ComId, ParseComId, ComIdExtension, ParseExtComId));
 441     return TcgResultFailure;
 442   }
 443   ERROR_CHECK(TcgGetNextCall(&TmpParseStruct));
 444   ERROR_CHECK(TcgGetNextTcgUid(&TmpParseStruct, &InvokingUID));
 445   ERROR_CHECK(TcgGetNextTcgUid(&TmpParseStruct, &MethodUID));
 446   ERROR_CHECK(TcgGetNextStartList(&TmpParseStruct));
 447   ERROR_CHECK(TcgGetNextUINT32(&TmpParseStruct, &RecvHostSessionId));
 448   ERROR_CHECK(TcgGetNextUINT32(&TmpParseStruct, TperSessionId));
 449   ERROR_CHECK(TcgGetNextEndList(&TmpParseStruct));
 450   ERROR_CHECK(TcgGetNextEndOfData(&TmpParseStruct));
 451
 452   if (InvokingUID != TCG_UID_SMUID) {
 453     DEBUG ((DEBUG_INFO, "Invoking UID did not match UID_SMUID\n"));
 454     return TcgResultFailure;
 455   }
 456
 457   if (MethodUID != TCG_UID_SM_SYNC_SESSION) {
 458     DEBUG ((DEBUG_INFO, "Method UID did not match UID_SM_SYNC_SESSION\n"));
 459     return TcgResultFailure;
 460   }
 461
 462   if (HostSessionId != RecvHostSessionId) {
 463     DEBUG ((DEBUG_INFO, "unmatched HostSessionId (exp: 0x%X recv: 0x%X)\n", HostSessionId, RecvHostSessionId));
 464     return TcgResultFailure;
 465   }
 466
 467   return TcgResultSuccess;
 468 }
 469
 470 /**
 471
 472   Creates ComPacket with EndSession.
 473   This assumes a start session has already been opened.
 474
 475   @param  [in/out]    CreateStruct        Structure used to add Endsession
 476   @param  [in/out]    Size                Describes the size of the entire ComPacket (header and payload). Filled out by function.
 477   @param  [in]        ComId               ComID for the ComPacket
 478   @param  [in]        ComIdExtension      Extended ComID for the ComPacket
 479   @param  [in]        HostSessionId         Host Session ID for the Packet
 480   @param  [in]        TpSessionId         Tper Session ID for the Packet
 481
 482 **/
 483 TCG_RESULT
 484 EFIAPI
 485 TcgCreateEndSession(
 486   TCG_CREATE_STRUCT   *CreateStruct,
 487   UINT32              *Size,
 488   UINT16              ComId,
 489   UINT16              ComIdExtension,
 490   UINT32              HostSessionId,
 491   UINT32              TpSessionId
 492   )
 493 {
 494   ERROR_CHECK(TcgStartComPacket(CreateStruct, ComId, ComIdExtension));
 495   ERROR_CHECK(TcgStartPacket(CreateStruct, TpSessionId, HostSessionId, 0x0, 0x0, 0x0));
 496   ERROR_CHECK(TcgStartSubPacket(CreateStruct, 0x0));
 497   ERROR_CHECK(TcgAddEndOfSession(CreateStruct));
 498   ERROR_CHECK(TcgEndSubPacket(CreateStruct));
 499   ERROR_CHECK(TcgEndPacket(CreateStruct));
 500   ERROR_CHECK(TcgEndComPacket(CreateStruct, Size));
 501
 502   return TcgResultSuccess;
 503 }
 504
 505 /**
 506   Set start method.
 507
 508   @param     CreateStruct   Input create structure.
 509   @param     Row            Input the row info.
 510   @param     ColumnNumber   the column info.
 511
 512 **/
 513 TCG_RESULT
 514 EFIAPI
 515 TcgStartMethodSet(
 516   TCG_CREATE_STRUCT        *CreateStruct,
 517   TCG_UID                  Row,
 518   UINT32                   ColumnNumber
 519   )
 520 {
 521   ERROR_CHECK(TcgStartMethodCall(CreateStruct, Row, TCG_UID_METHOD_SET));
 522   ERROR_CHECK(TcgStartParameters(CreateStruct));
 523   ERROR_CHECK(TcgAddStartName(CreateStruct));
 524   ERROR_CHECK(TcgAddUINT8(CreateStruct, 0x01)); // "Values"
 525   ERROR_CHECK(TcgAddStartList(CreateStruct));
 526   ERROR_CHECK(TcgAddStartName(CreateStruct));
 527   ERROR_CHECK(TcgAddUINT32(CreateStruct, ColumnNumber));
 528   return TcgResultSuccess;
 529 }
 530
 531 /**
 532   Set end method.
 533
 534   @param     CreateStruct  Input create structure.
 535
 536 **/
 537 TCG_RESULT
 538 EFIAPI
 539 TcgEndMethodSet(
 540   TCG_CREATE_STRUCT        *CreateStruct
 541   )
 542 {
 543   ERROR_CHECK(TcgAddEndName(CreateStruct));
 544   ERROR_CHECK(TcgAddEndList(CreateStruct));
 545   ERROR_CHECK(TcgAddEndName(CreateStruct));
 546   ERROR_CHECK(TcgEndParameters(CreateStruct));
 547   ERROR_CHECK(TcgEndMethodCall(CreateStruct));
 548   return TcgResultSuccess;
 549 }
 550
 551 /**
 552   Creates ComPacket with a Method call that sets the PIN column for the row specified.
 553   This assumes a start session has already been opened with the desired SP.
 554
 555   @param [in/out]   CreateStruct           Structure used to add method call.
 556   @param [in/out]   Size                   Describes the size of the entire ComPacket (header and payload). Filled out by function.
 557   @param [in]       ComId                  ComID for the ComPacket
 558   @param [in]       ComIdExtension         Extended ComID for the ComPacket
 559   @param [in]       TperSession            Tper Session ID for the Packet
 560   @param [in]       HostSession            Host Session ID for the Packet
 561   @param [in]       SidRow                 UID of row of current SP to set PIN column
 562   @param [in]       Password               value of PIN to set
 563   @param [in]       PasswordSize           Size of PIN
 564
 565 **/
 566 TCG_RESULT
 567 EFIAPI
 568 TcgCreateSetCPin(
 569   TCG_CREATE_STRUCT       *CreateStruct,
 570   UINT32                  *Size,
 571   UINT16                  ComId,
 572   UINT16                  ComIdExtension,
 573   UINT32                  TperSession,
 574   UINT32                  HostSession,
 575   TCG_UID                 SidRow,
 576   const VOID              *Password,
 577   UINT32                  PasswordSize
 578   )
 579 {
 580   // set new SID Password
 581   ERROR_CHECK(TcgStartComPacket(CreateStruct, ComId, ComIdExtension));
 582   ERROR_CHECK(TcgStartPacket(CreateStruct, TperSession, HostSession, 0x0, 0x0, 0x0));
 583   ERROR_CHECK(TcgStartSubPacket(CreateStruct, 0x0));
 584   ERROR_CHECK(TcgStartMethodSet(CreateStruct, SidRow, 0x03)); // "PIN"
 585   ERROR_CHECK(TcgAddByteSequence(CreateStruct, Password, PasswordSize, FALSE));
 586   ERROR_CHECK(TcgEndMethodSet(CreateStruct));
 587   ERROR_CHECK(TcgEndSubPacket(CreateStruct));
 588   ERROR_CHECK(TcgEndPacket(CreateStruct));
 589   ERROR_CHECK(TcgEndComPacket(CreateStruct, Size));
 590   return TcgResultSuccess;
 591 }
 592
 593 /**
 594  Creates ComPacket with a Method call that sets the "Enabled" column for the row specified using the value specified.
 595  This assumes a start session has already been opened with the desired SP.
 596
 597  @param [in/out]  CreateStruct          Structure used to add method call
 598  @param [in/out]  Size                  Describes the size of the entire ComPacket (header and payload). Filled out by function.
 599  @param [in]      ComId                 ComID for the ComPacket
 600  @param [in]      ComIdExtension        Extended ComID for the ComPacket
 601  @param [in]      TperSession           Tper Session ID for the Packet
 602  @param [in]      HostSession           Host Session ID for the Packet
 603  @param [in]      AuthorityUid          Authority UID to modify the "Enabled" column for
 604  @param [in]      Enabled               Value to set the "Enabled" column to
 605
 606 **/
 607 TCG_RESULT
 608 EFIAPI
 609 TcgSetAuthorityEnabled(
 610   TCG_CREATE_STRUCT           *CreateStruct,
 611   UINT32                      *Size,
 612   UINT16                      ComId,
 613   UINT16                      ComIdExtension,
 614   UINT32                      TperSession,
 615   UINT32                      HostSession,
 616   TCG_UID                     AuthorityUid,
 617   BOOLEAN                     Enabled
 618   )
 619 {
 620   ERROR_CHECK(TcgStartComPacket(CreateStruct, ComId, ComIdExtension));
 621   ERROR_CHECK(TcgStartPacket(CreateStruct, TperSession, HostSession, 0x0, 0x0, 0x0));
 622   ERROR_CHECK(TcgStartSubPacket(CreateStruct, 0x0));
 623   ERROR_CHECK(TcgStartMethodSet(CreateStruct, AuthorityUid, 0x05)); // "Enabled"
 624   ERROR_CHECK(TcgAddBOOLEAN(CreateStruct, Enabled));
 625   ERROR_CHECK(TcgEndMethodSet(CreateStruct));
 626   ERROR_CHECK(TcgEndSubPacket(CreateStruct));
 627   ERROR_CHECK(TcgEndPacket(CreateStruct));
 628   ERROR_CHECK(TcgEndComPacket(CreateStruct, Size));
 629   return TcgResultSuccess;
 630 }
 631
 632 /**
 633   Create set ace.
 634
 635   @param     CreateStruct      Input create structure.
 636   @param     Size              size info.
 637   @param     ComId             ComId info.
 638   @param     ComIdExtension    ComId extension info.
 639   @param     TperSession       Tper session data.
 640   @param     HostSession       Host session data.
 641   @param     AceRow            Ace row info.
 642   @param     Authority1        Authority 1 info.
 643   @param     LogicalOperator   Logiccal operator info.
 644   @param     Authority2        Authority 2 info.
 645
 646   @retval    Return the action result.
 647
 648 **/
 649 TCG_RESULT
 650 EFIAPI
 651 TcgCreateSetAce(
 652   TCG_CREATE_STRUCT        *CreateStruct,
 653   UINT32                   *Size,
 654   UINT16                   ComId,
 655   UINT16                   ComIdExtension,
 656   UINT32                   TperSession,
 657   UINT32                   HostSession,
 658   TCG_UID                  AceRow,
 659   TCG_UID                  Authority1,
 660   BOOLEAN                  LogicalOperator,
 661   TCG_UID                  Authority2
 662   )
 663 {
 664   UINT8 HalfUidAuthorityObjectRef[4];
 665   UINT8 HalfUidBooleanAce[4];
 666
 667   HalfUidAuthorityObjectRef[0] = 0x0;
 668   HalfUidAuthorityObjectRef[1] = 0x0;
 669   HalfUidAuthorityObjectRef[2] = 0xC;
 670   HalfUidAuthorityObjectRef[3] = 0x5;
 671
 672   HalfUidBooleanAce[0] = 0x0;
 673   HalfUidBooleanAce[1] = 0x0;
 674   HalfUidBooleanAce[2] = 0x4;
 675   HalfUidBooleanAce[3] = 0xE;
 676
 677   ERROR_CHECK(TcgStartComPacket(CreateStruct, ComId, ComIdExtension));
 678   ERROR_CHECK(TcgStartPacket(CreateStruct, TperSession, HostSession, 0x0, 0x0, 0x0));
 679   ERROR_CHECK(TcgStartSubPacket(CreateStruct, 0x0));
 680   ERROR_CHECK(TcgStartMethodSet(CreateStruct, AceRow, 0x03));     // "BooleanExpr"
 681   ERROR_CHECK(TcgAddStartList(CreateStruct));
 682   ERROR_CHECK(TcgAddStartName(CreateStruct));
 683   ERROR_CHECK(TcgAddByteSequence(CreateStruct, HalfUidAuthorityObjectRef, sizeof(HalfUidAuthorityObjectRef), FALSE));
 684   ERROR_CHECK(TcgAddTcgUid(CreateStruct, Authority1));
 685   ERROR_CHECK(TcgAddEndName(CreateStruct));
 686   ERROR_CHECK(TcgAddStartName(CreateStruct));
 687   ERROR_CHECK(TcgAddByteSequence(CreateStruct, HalfUidAuthorityObjectRef, sizeof(HalfUidAuthorityObjectRef), FALSE));
 688   ERROR_CHECK(TcgAddTcgUid(CreateStruct, Authority2));
 689   ERROR_CHECK(TcgAddEndName(CreateStruct));
 690
 691   ERROR_CHECK(TcgAddStartName(CreateStruct));
 692   ERROR_CHECK(TcgAddByteSequence(CreateStruct, HalfUidBooleanAce, sizeof(HalfUidBooleanAce), FALSE));
 693   ERROR_CHECK(TcgAddBOOLEAN(CreateStruct, LogicalOperator));
 694   ERROR_CHECK(TcgAddEndName(CreateStruct));
 695   ERROR_CHECK(TcgAddEndList(CreateStruct));
 696   ERROR_CHECK(TcgEndMethodSet(CreateStruct));
 697   ERROR_CHECK(TcgEndSubPacket(CreateStruct));
 698   ERROR_CHECK(TcgEndPacket(CreateStruct));
 699   ERROR_CHECK(TcgEndComPacket(CreateStruct, Size));
 700   return TcgResultSuccess;
 701 }
 702
 703 /**
 704   Enum level 0 discovery.
 705
 706   @param     DiscoveryHeader   Discovery header.
 707   @param     Callback          Callback function.
 708   @param     Context           The context for the function.
 709
 710   @retval    return true if the callback return TRUE, else return FALSE.
 711
 712 **/
 713 BOOLEAN
 714 EFIAPI
 715 TcgEnumLevel0Discovery(
 716   const TCG_LEVEL0_DISCOVERY_HEADER  *DiscoveryHeader,
 717   TCG_LEVEL0_ENUM_CALLBACK           Callback,
 718   VOID                               *Context
 719   )
 720 {
 721   UINT32                                  BytesLeft;
 722   const UINT8                             *DiscoveryBufferPtr;
 723   UINT32                                  FeatLength;
 724   TCG_LEVEL0_FEATURE_DESCRIPTOR_HEADER    *Feat;
 725
 726   //
 727   // Total bytes including descriptors but not including the Length field
 728   //
 729   BytesLeft = SwapBytes32(DiscoveryHeader->LengthBE);
 730
 731   //
 732   // If discovery Header is not valid, exit
 733   //
 734   if (BytesLeft == 0) {
 735     return FALSE;
 736   }
 737
 738   //
 739   // Subtract the Length of the Header, except the Length field, which is not included
 740   //
 741   BytesLeft -= (sizeof(TCG_LEVEL0_DISCOVERY_HEADER) - sizeof(DiscoveryHeader->LengthBE));
 742
 743   //
 744   // Move ptr to first descriptor
 745   //
 746   DiscoveryBufferPtr = (const UINT8*)DiscoveryHeader + sizeof(TCG_LEVEL0_DISCOVERY_HEADER);
 747
 748   while (BytesLeft > sizeof(TCG_LEVEL0_FEATURE_DESCRIPTOR_HEADER)) {
 749     //
 750     // Pointer to beginning of descriptor (including common Header)
 751     //
 752     Feat = (TCG_LEVEL0_FEATURE_DESCRIPTOR_HEADER*)DiscoveryBufferPtr;
 753
 754     FeatLength = Feat->Length + sizeof(TCG_LEVEL0_FEATURE_DESCRIPTOR_HEADER);
 755
 756     //
 757     // Not enough bytes left for Feature descriptor
 758     //
 759     if (BytesLeft < FeatLength) {
 760       break;
 761     }
 762
 763     //
 764     // Report the Feature to the callback
 765     //
 766     if (Callback(DiscoveryHeader, Feat, FeatLength, Context)) {
 767       return TRUE;
 768     }
 769
 770     //
 771     // Descriptor Length only describes Data after common Header
 772     //
 773     BytesLeft -= FeatLength;
 774     DiscoveryBufferPtr += FeatLength;
 775   }
 776
 777   return FALSE;
 778 }
 779
 780 /**
 781   The callback function for Get Feature function.
 782
 783   @param     DiscoveryHeader   Input discovery header.
 784   @param     Feature           Input Feature.
 785   @param     FeatureSize       Input Feature size.
 786   @param     Context           The context.
 787
 788 **/
 789 BOOLEAN
 790 EFIAPI
 791 TcgFindFeatureCallback(
 792   const TCG_LEVEL0_DISCOVERY_HEADER           *DiscoveryHeader,
 793   TCG_LEVEL0_FEATURE_DESCRIPTOR_HEADER        *Feature,
 794   UINTN                                       FeatureSize,
 795   VOID                                        *Context
 796   )
 797 {
 798   TCG_FIND_FEATURE_CTX* FindCtx;
 799
 800   FindCtx = (TCG_FIND_FEATURE_CTX*)Context;
 801   if ( SwapBytes16( Feature->FeatureCode_BE ) == FindCtx->FeatureCode ) {
 802     FindCtx->Feature = Feature;
 803     FindCtx->FeatureSize = FeatureSize;
 804     return TRUE; // done enumerating features
 805   }
 806   return FALSE; // continue enumerating
 807 }
 808
 809 /**
 810   Get Feature code from the header.
 811
 812   @param     DiscoveryHeader    The discovery header.
 813   @param     FeatureCode        return the Feature code.
 814   @param     FeatureSize        return the Feature size.
 815
 816   @retval    return the Feature code data.
 817 **/
 818 TCG_LEVEL0_FEATURE_DESCRIPTOR_HEADER*
 819 EFIAPI
 820 TcgGetFeature(
 821   const TCG_LEVEL0_DISCOVERY_HEADER  *DiscoveryHeader,
 822   UINT16                             FeatureCode,
 823   UINTN                              *FeatureSize
 824   )
 825 {
 826   TCG_FIND_FEATURE_CTX FindCtx;
 827
 828   FindCtx.FeatureCode = FeatureCode;
 829   FindCtx.Feature = NULL;
 830   FindCtx.FeatureSize = 0;
 831
 832   TcgEnumLevel0Discovery(DiscoveryHeader, TcgFindFeatureCallback, &FindCtx);
 833   if (FeatureSize != NULL) {
 834     *FeatureSize = FindCtx.FeatureSize;
 835   }
 836   return FindCtx.Feature;
 837 }
 838
 839 /**
 840   Determines if the protocol provided is part of the provided supported protocol list.
 841
 842   @param[in]  ProtocolList     Supported protocol list to investigate
 843   @param[in]  Protocol         Protocol value to determine if supported
 844
 845   @return TRUE = protocol is supported, FALSE = protocol is not supported
 846 **/
 847 BOOLEAN
 848 EFIAPI
 849 TcgIsProtocolSupported(
 850   const TCG_SUPPORTED_SECURITY_PROTOCOLS   *ProtocolList,
 851   UINT16                                   Protocol
 852   )
 853 {
 854   UINT16 Index;
 855   UINT16 ListLength;
 856
 857   ListLength = SwapBytes16(ProtocolList->ListLength_BE);
 858
 859   if (ListLength > sizeof(ProtocolList->List)) {
 860     DEBUG ((DEBUG_INFO, "WARNING: list Length is larger than max allowed Value; truncating\n"));
 861     ListLength = sizeof(ProtocolList->List);
 862   }
 863
 864   for (Index = 0; Index < ListLength; Index++) {
 865     if (ProtocolList->List[Index] == Protocol) {
 866       return TRUE;
 867     }
 868   }
 869
 870   return FALSE;
 871 }
 872
 873 /**
 874   Check whether lock or not.
 875
 876   @param     Discovery
 877
 878   @retval    TRUE if lock, FALSE if not lock.
 879 **/
 880 BOOLEAN
 881 EFIAPI
 882 TcgIsLocked(
 883   const TCG_LEVEL0_DISCOVERY_HEADER         *Discovery
 884   )
 885 {
 886   UINTN Size;
 887   TCG_LOCKING_FEATURE_DESCRIPTOR     *LockDescriptor;
 888
 889   Size = 0;
 890   LockDescriptor =(TCG_LOCKING_FEATURE_DESCRIPTOR*) TcgGetFeature (Discovery, TCG_FEATURE_LOCKING, &Size);
 891
 892   if (LockDescriptor != NULL && Size >= sizeof(*LockDescriptor)) {
 893     DEBUG ((DEBUG_INFO, "locked: %d\n", LockDescriptor->Locked));
 894     return LockDescriptor->Locked;
 895   }
 896
 897   //
 898   // Descriptor was not found
 899   //
 900   return FALSE;
 901 }