| /* Microsoft Reference Implementation for TPM 2.0 | |
| * | |
| * The copyright in this software is being made available under the BSD License, | |
| * included below. This software may be subject to other third party and | |
| * contributor rights, including patent rights, and no such rights are granted | |
| * under this license. | |
| * | |
| * Copyright (c) Microsoft Corporation | |
| * | |
| * All rights reserved. | |
| * | |
| * BSD License | |
| * | |
| * Redistribution and use in source and binary forms, with or without modification, | |
| * are permitted provided that the following conditions are met: | |
| * | |
| * Redistributions of source code must retain the above copyright notice, this list | |
| * of conditions and the following disclaimer. | |
| * | |
| * Redistributions in binary form must reproduce the above copyright notice, this | |
| * list of conditions and the following disclaimer in the documentation and/or | |
| * other materials provided with the distribution. | |
| * | |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS IS"" | |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR | |
| * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | |
| * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON | |
| * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | |
| * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| */ | |
| //** Description | |
| // This file contains internal global type definitions and data declarations that | |
| // are need between subsystems. The instantiation of global data is in Global.c. | |
| // The initialization of global data is in the subsystem that is the primary owner | |
| // of the data. | |
| // | |
| // The first part of this file has the 'typedefs' for structures and other defines | |
| // used in many portions of the code. After the 'typedef' section, is a section that | |
| // defines global values that are only present in RAM. The next three sections | |
| // define the structures for the NV data areas: persistent, orderly, and state | |
| // save. Additional sections define the data that is used in specific modules. That | |
| // data is private to the module but is collected here to simplify the management | |
| // of the instance data. | |
| // | |
| // All the data is instanced in Global.c. | |
| #if !defined _TPM_H_ | |
| #error "Should only be instanced in TPM.h" | |
| #endif | |
| //** Includes | |
| #ifndef GLOBAL_H | |
| #define GLOBAL_H | |
| _REDUCE_WARNING_LEVEL_(2) | |
| #include <string.h> | |
| #include <stddef.h> | |
| _NORMAL_WARNING_LEVEL_ | |
| #include "Capabilities.h" | |
| #include "TpmTypes.h" | |
| #include "CommandAttributes.h" | |
| #include "CryptTest.h" | |
| #include "BnValues.h" | |
| #include "CryptHash.h" | |
| #include "CryptSym.h" | |
| #include "CryptRand.h" | |
| #include "CryptEcc.h" | |
| #include "CryptRsa.h" | |
| #include "CryptTest.h" | |
| #include "TpmError.h" | |
| #include "NV.h" | |
| #include "ACT.h" | |
| //** Defines and Types | |
| //*** Size Types | |
| // These types are used to differentiate the two different size values used. | |
| // | |
| // NUMBYTES is used when a size is a number of bytes (usually a TPM2B) | |
| typedef UINT16 NUMBYTES; | |
| //*** Other Types | |
| // An AUTH_VALUE is a BYTE array containing a digest (TPMU_HA) | |
| typedef BYTE AUTH_VALUE[sizeof(TPMU_HA)]; | |
| // A TIME_INFO is a BYTE array that can contain a TPMS_TIME_INFO | |
| typedef BYTE TIME_INFO[sizeof(TPMS_TIME_INFO)]; | |
| // A NAME is a BYTE array that can contain a TPMU_NAME | |
| typedef BYTE NAME[sizeof(TPMU_NAME)]; | |
| // Definition for a PROOF value | |
| TPM2B_TYPE(PROOF, PROOF_SIZE); | |
| // Definition for a Primary Seed value | |
| TPM2B_TYPE(SEED, PRIMARY_SEED_SIZE); | |
| // A CLOCK_NONCE is used to tag the time value in the authorization session and | |
| // in the ticket computation so that the ticket expires when there is a time | |
| // discontinuity. When the clock stops during normal operation, the nonce is | |
| // 64-bit value kept in RAM but it is a 32-bit counter when the clock only stops | |
| // during power events. | |
| #if CLOCK_STOPS | |
| typedef UINT64 CLOCK_NONCE; | |
| #else | |
| typedef UINT32 CLOCK_NONCE; | |
| #endif | |
| //** Loaded Object Structures | |
| //*** Description | |
| // The structures in this section define the object layout as it exists in TPM | |
| // memory. | |
| // | |
| // Two types of objects are defined: an ordinary object such as a key, and a | |
| // sequence object that may be a hash, HMAC, or event. | |
| // | |
| //*** OBJECT_ATTRIBUTES | |
| // An OBJECT_ATTRIBUTES structure contains the variable attributes of an object. | |
| // These properties are not part of the public properties but are used by the | |
| // TPM in managing the object. An OBJECT_ATTRIBUTES is used in the definition of | |
| // the OBJECT data type. | |
| typedef struct | |
| { | |
| unsigned publicOnly : 1; //0) SET if only the public portion of | |
| // an object is loaded | |
| unsigned epsHierarchy : 1; //1) SET if the object belongs to EPS | |
| // Hierarchy | |
| unsigned ppsHierarchy : 1; //2) SET if the object belongs to PPS | |
| // Hierarchy | |
| unsigned spsHierarchy : 1; //3) SET f the object belongs to SPS | |
| // Hierarchy | |
| unsigned evict : 1; //4) SET if the object is a platform or | |
| // owner evict object. Platform- | |
| // evict object belongs to PPS | |
| // hierarchy, owner-evict object | |
| // belongs to SPS or EPS hierarchy. | |
| // This bit is also used to mark a | |
| // completed sequence object so it | |
| // will be flush when the | |
| // SequenceComplete command succeeds. | |
| unsigned primary : 1; //5) SET for a primary object | |
| unsigned temporary : 1; //6) SET for a temporary object | |
| unsigned stClear : 1; //7) SET for an stClear object | |
| unsigned hmacSeq : 1; //8) SET for an HMAC or MAC sequence | |
| // object | |
| unsigned hashSeq : 1; //9) SET for a hash sequence object | |
| unsigned eventSeq : 1; //10) SET for an event sequence object | |
| unsigned ticketSafe : 1; //11) SET if a ticket is safe to create | |
| // for hash sequence object | |
| unsigned firstBlock : 1; //12) SET if the first block of hash | |
| // data has been received. It | |
| // works with ticketSafe bit | |
| unsigned isParent : 1; //13) SET if the key has the proper | |
| // attributes to be a parent key | |
| // unsigned privateExp : 1; //14) SET when the private exponent | |
| // // of an RSA key has been validated. | |
| unsigned not_used_14 : 1; | |
| unsigned occupied : 1; //15) SET when the slot is occupied. | |
| unsigned derivation : 1; //16) SET when the key is a derivation | |
| // parent | |
| unsigned external : 1; //17) SET when the object is loaded with | |
| // TPM2_LoadExternal(); | |
| } OBJECT_ATTRIBUTES; | |
| #if ALG_RSA | |
| // There is an overload of the sensitive.rsa.t.size field of a TPMT_SENSITIVE when an | |
| // RSA key is loaded. When the sensitive->sensitive contains an RSA key with all of | |
| // the CRT values, then the MSB of the size field will be set to indicate that the | |
| // buffer contains all 5 of the CRT private key values. | |
| #define RSA_prime_flag 0x8000 | |
| #endif | |
| //*** OBJECT Structure | |
| // An OBJECT structure holds the object public, sensitive, and meta-data | |
| // associated. This structure is implementation dependent. For this | |
| // implementation, the structure is not optimized for space but rather | |
| // for clarity of the reference implementation. Other implementations | |
| // may choose to overlap portions of the structure that are not used | |
| // simultaneously. These changes would necessitate changes to the source | |
| // code but those changes would be compatible with the reference | |
| // implementation. | |
| typedef struct OBJECT | |
| { | |
| // The attributes field is required to be first followed by the publicArea. | |
| // This allows the overlay of the object structure and a sequence structure | |
| OBJECT_ATTRIBUTES attributes; // object attributes | |
| TPMT_PUBLIC publicArea; // public area of an object | |
| TPMT_SENSITIVE sensitive; // sensitive area of an object | |
| TPM2B_NAME qualifiedName; // object qualified name | |
| TPMI_DH_OBJECT evictHandle; // if the object is an evict object, | |
| // the original handle is kept here. | |
| // The 'working' handle will be the | |
| // handle of an object slot. | |
| TPM2B_NAME name; // Name of the object name. Kept here | |
| // to avoid repeatedly computing it. | |
| } OBJECT; | |
| //*** HASH_OBJECT Structure | |
| // This structure holds a hash sequence object or an event sequence object. | |
| // | |
| // The first four components of this structure are manually set to be the same as | |
| // the first four components of the object structure. This prevents the object | |
| // from being inadvertently misused as sequence objects occupy the same memory as | |
| // a regular object. A debug check is present to make sure that the offsets are | |
| // what they are supposed to be. | |
| // NOTE: In a future version, this will probably be renamed as SEQUENCE_OBJECT | |
| typedef struct HASH_OBJECT | |
| { | |
| OBJECT_ATTRIBUTES attributes; // The attributes of the HASH object | |
| TPMI_ALG_PUBLIC type; // algorithm | |
| TPMI_ALG_HASH nameAlg; // name algorithm | |
| TPMA_OBJECT objectAttributes; // object attributes | |
| // The data below is unique to a sequence object | |
| TPM2B_AUTH auth; // authorization for use of sequence | |
| union | |
| { | |
| HASH_STATE hashState[HASH_COUNT]; | |
| HMAC_STATE hmacState; | |
| } state; | |
| } HASH_OBJECT; | |
| typedef BYTE HASH_OBJECT_BUFFER[sizeof(HASH_OBJECT)]; | |
| //*** ANY_OBJECT | |
| // This is the union for holding either a sequence object or a regular object | |
| // for ContextSave and ContextLoad. | |
| typedef union ANY_OBJECT | |
| { | |
| OBJECT entity; | |
| HASH_OBJECT hash; | |
| } ANY_OBJECT; | |
| typedef BYTE ANY_OBJECT_BUFFER[sizeof(ANY_OBJECT)]; | |
| //**AUTH_DUP Types | |
| // These values are used in the authorization processing. | |
| typedef UINT32 AUTH_ROLE; | |
| #define AUTH_NONE ((AUTH_ROLE)(0)) | |
| #define AUTH_USER ((AUTH_ROLE)(1)) | |
| #define AUTH_ADMIN ((AUTH_ROLE)(2)) | |
| #define AUTH_DUP ((AUTH_ROLE)(3)) | |
| //** Active Session Context | |
| //*** Description | |
| // The structures in this section define the internal structure of a session | |
| // context. | |
| // | |
| //*** SESSION_ATTRIBUTES | |
| // The attributes in the SESSION_ATTRIBUTES structure track the various properties | |
| // of the session. It maintains most of the tracking state information for the | |
| // policy session. It is used within the SESSION structure. | |
| typedef struct SESSION_ATTRIBUTES | |
| { | |
| unsigned isPolicy : 1; //1) SET if the session may only be used | |
| // for policy | |
| unsigned isAudit : 1; //2) SET if the session is used for audit | |
| unsigned isBound : 1; //3) SET if the session is bound to with an | |
| // entity. This attribute will be CLEAR | |
| // if either isPolicy or isAudit is SET. | |
| unsigned isCpHashDefined : 1; //4) SET if the cpHash has been defined | |
| // This attribute is not SET unless | |
| // 'isPolicy' is SET. | |
| unsigned isAuthValueNeeded : 1; //5) SET if the authValue is required for | |
| // computing the session HMAC. This | |
| // attribute is not SET unless 'isPolicy' | |
| // is SET. | |
| unsigned isPasswordNeeded : 1; //6) SET if a password authValue is required | |
| // for authorization This attribute is not | |
| // SET unless 'isPolicy' is SET. | |
| unsigned isPPRequired : 1; //7) SET if physical presence is required to | |
| // be asserted when the authorization is | |
| // checked. This attribute is not SET | |
| // unless 'isPolicy' is SET. | |
| unsigned isTrialPolicy : 1; //8) SET if the policy session is created | |
| // for trial of the policy's policyHash | |
| // generation. This attribute is not SET | |
| // unless 'isPolicy' is SET. | |
| unsigned isDaBound : 1; //9) SET if the bind entity had noDA CLEAR. | |
| // If this is SET, then an authorization | |
| // failure using this session will count | |
| // against lockout even if the object | |
| // being authorized is exempt from DA. | |
| unsigned isLockoutBound : 1; //10) SET if the session is bound to | |
| // lockoutAuth. | |
| unsigned includeAuth : 1; //11) This attribute is SET when the | |
| // authValue of an object is to be | |
| // included in the computation of the | |
| // HMAC key for the command and response | |
| // computations. (was 'requestWasBound') | |
| unsigned checkNvWritten : 1; //12) SET if the TPMA_NV_WRITTEN attribute | |
| // needs to be checked when the policy is | |
| // used for authorization for NV access. | |
| // If this is SET for any other type, the | |
| // policy will fail. | |
| unsigned nvWrittenState : 1; //13) SET if TPMA_NV_WRITTEN is required to | |
| // be SET. Used when 'checkNvWritten' is | |
| // SET | |
| unsigned isTemplateSet : 1; //14) SET if the templateHash needs to be | |
| // checked for Create, CreatePrimary, or | |
| // CreateLoaded. | |
| } SESSION_ATTRIBUTES; | |
| //*** SESSION Structure | |
| // The SESSION structure contains all the context of a session except for the | |
| // associated contextID. | |
| // | |
| // Note: The contextID of a session is only relevant when the session context | |
| // is stored off the TPM. | |
| typedef struct SESSION | |
| { | |
| SESSION_ATTRIBUTES attributes; // session attributes | |
| UINT32 pcrCounter; // PCR counter value when PCR is | |
| // included (policy session) | |
| // If no PCR is included, this | |
| // value is 0. | |
| UINT64 startTime; // The value in g_time when the session | |
| // was started (policy session) | |
| UINT64 timeout; // The timeout relative to g_time | |
| // There is no timeout if this value | |
| // is 0. | |
| CLOCK_NONCE epoch; // The g_clockEpoch value when the | |
| // session was started. If g_clockEpoch | |
| // does not match this value when the | |
| // timeout is used, then | |
| // then the command will fail. | |
| TPM_CC commandCode; // command code (policy session) | |
| TPM_ALG_ID authHashAlg; // session hash algorithm | |
| TPMA_LOCALITY commandLocality; // command locality (policy session) | |
| TPMT_SYM_DEF symmetric; // session symmetric algorithm (if any) | |
| TPM2B_AUTH sessionKey; // session secret value used for | |
| // this session | |
| TPM2B_NONCE nonceTPM; // last TPM-generated nonce for | |
| // generating HMAC and encryption keys | |
| union | |
| { | |
| TPM2B_NAME boundEntity; // value used to track the entity to | |
| // which the session is bound | |
| TPM2B_DIGEST cpHash; // the required cpHash value for the | |
| // command being authorized | |
| TPM2B_DIGEST nameHash; // the required nameHash | |
| TPM2B_DIGEST templateHash; // the required template for creation | |
| } u1; | |
| union | |
| { | |
| TPM2B_DIGEST auditDigest; // audit session digest | |
| TPM2B_DIGEST policyDigest; // policyHash | |
| } u2; // audit log and policyHash may | |
| // share space to save memory | |
| } SESSION; | |
| #define EXPIRES_ON_RESET INT32_MIN | |
| #define TIMEOUT_ON_RESET UINT64_MAX | |
| #define EXPIRES_ON_RESTART (INT32_MIN + 1) | |
| #define TIMEOUT_ON_RESTART (UINT64_MAX - 1) | |
| typedef BYTE SESSION_BUF[sizeof(SESSION)]; | |
| //********************************************************************************* | |
| //** PCR | |
| //********************************************************************************* | |
| //***PCR_SAVE Structure | |
| // The PCR_SAVE structure type contains the PCR data that are saved across power | |
| // cycles. Only the static PCR are required to be saved across power cycles. The | |
| // DRTM and resettable PCR are not saved. The number of static and resettable PCR | |
| // is determined by the platform-specific specification to which the TPM is built. | |
| #define PCR_SAVE_SPACE(HASH, Hash) BYTE Hash[NUM_STATIC_PCR][HASH##_DIGEST_SIZE]; | |
| typedef struct PCR_SAVE | |
| { | |
| FOR_EACH_HASH(PCR_SAVE_SPACE) | |
| // This counter increments whenever the PCR are updated. | |
| // NOTE: A platform-specific specification may designate | |
| // certain PCR changes as not causing this counter | |
| // to increment. | |
| UINT32 pcrCounter; | |
| } PCR_SAVE; | |
| //***PCR_POLICY | |
| #if defined NUM_POLICY_PCR_GROUP && NUM_POLICY_PCR_GROUP > 0 | |
| // This structure holds the PCR policies, one for each group of PCR controlled | |
| // by policy. | |
| typedef struct PCR_POLICY | |
| { | |
| TPMI_ALG_HASH hashAlg[NUM_POLICY_PCR_GROUP]; | |
| TPM2B_DIGEST a; | |
| TPM2B_DIGEST policy[NUM_POLICY_PCR_GROUP]; | |
| } PCR_POLICY; | |
| #endif | |
| //***PCR_AUTHVALUE | |
| // This structure holds the PCR policies, one for each group of PCR controlled | |
| // by policy. | |
| typedef struct PCR_AUTH_VALUE | |
| { | |
| TPM2B_DIGEST auth[NUM_AUTHVALUE_PCR_GROUP]; | |
| } PCR_AUTHVALUE; | |
| //**STARTUP_TYPE | |
| // This enumeration is the possible startup types. The type is determined | |
| // by the combination of TPM2_ShutDown and TPM2_Startup. | |
| typedef enum | |
| { | |
| SU_RESET, | |
| SU_RESTART, | |
| SU_RESUME | |
| } STARTUP_TYPE; | |
| //**NV | |
| //***NV_INDEX | |
| // The NV_INDEX structure defines the internal format for an NV index. | |
| // The 'indexData' size varies according to the type of the index. | |
| // In this implementation, all of the index is manipulated as a unit. | |
| typedef struct NV_INDEX | |
| { | |
| TPMS_NV_PUBLIC publicArea; | |
| TPM2B_AUTH authValue; | |
| } NV_INDEX; | |
| //*** NV_REF | |
| // An NV_REF is an opaque value returned by the NV subsystem. It is used to | |
| // reference and NV Index in a relatively efficient way. Rather than having to | |
| // continually search for an Index, its reference value may be used. In this | |
| // implementation, an NV_REF is a byte pointer that points to the copy of the | |
| // NV memory that is kept in RAM. | |
| typedef UINT32 NV_REF; | |
| typedef BYTE *NV_RAM_REF; | |
| //***NV_PIN | |
| // This structure deals with the possible endianess differences between the | |
| // canonical form of the TPMS_NV_PIN_COUNTER_PARAMETERS structure and the internal | |
| // value. The structures allow the data in a PIN index to be read as an 8-octet | |
| // value using NvReadUINT64Data(). That function will byte swap all the values on a | |
| // little endian system. This will put the bytes with the 4-octet values in the | |
| // correct order but will swap the pinLimit and pinCount values. When written, the | |
| // PIN index is simply handled as a normal index with the octets in canonical order. | |
| #if BIG_ENDIAN_TPM | |
| typedef struct | |
| { | |
| UINT32 pinCount; | |
| UINT32 pinLimit; | |
| } PIN_DATA; | |
| #else | |
| typedef struct | |
| { | |
| UINT32 pinLimit; | |
| UINT32 pinCount; | |
| } PIN_DATA; | |
| #endif | |
| typedef union | |
| { | |
| UINT64 intVal; | |
| PIN_DATA pin; | |
| } NV_PIN; | |
| //**COMMIT_INDEX_MASK | |
| // This is the define for the mask value that is used when manipulating | |
| // the bits in the commit bit array. The commit counter is a 64-bit | |
| // value and the low order bits are used to index the commitArray. | |
| // This mask value is applied to the commit counter to extract the | |
| // bit number in the array. | |
| #if ALG_ECC | |
| #define COMMIT_INDEX_MASK ((UINT16)((sizeof(gr.commitArray)*8)-1)) | |
| #endif | |
| //***************************************************************************** | |
| //***************************************************************************** | |
| //** RAM Global Values | |
| //***************************************************************************** | |
| //***************************************************************************** | |
| //*** Description | |
| // The values in this section are only extant in RAM or ROM as constant values. | |
| //*** Crypto Self-Test Values | |
| EXTERN ALGORITHM_VECTOR g_implementedAlgorithms; | |
| EXTERN ALGORITHM_VECTOR g_toTest; | |
| //*** g_rcIndex[] | |
| // This array is used to contain the array of values that are added to a return | |
| // code when it is a parameter-, handle-, or session-related error. | |
| // This is an implementation choice and the same result can be achieved by using | |
| // a macro. | |
| #define g_rcIndexInitializer { TPM_RC_1, TPM_RC_2, TPM_RC_3, TPM_RC_4, \ | |
| TPM_RC_5, TPM_RC_6, TPM_RC_7, TPM_RC_8, \ | |
| TPM_RC_9, TPM_RC_A, TPM_RC_B, TPM_RC_C, \ | |
| TPM_RC_D, TPM_RC_E, TPM_RC_F } | |
| EXTERN const UINT16 g_rcIndex[15] INITIALIZER(g_rcIndexInitializer); | |
| //*** g_exclusiveAuditSession | |
| // This location holds the session handle for the current exclusive audit | |
| // session. If there is no exclusive audit session, the location is set to | |
| // TPM_RH_UNASSIGNED. | |
| EXTERN TPM_HANDLE g_exclusiveAuditSession; | |
| //*** g_time | |
| // This is the value in which we keep the current command time. This is initialized | |
| // at the start of each command. The time is the accumulated time since the last | |
| // time that the TPM's timer was last powered up. Clock is the accumulated time | |
| // since the last time that the TPM was cleared. g_time is in mS. | |
| EXTERN UINT64 g_time; | |
| //*** g_timeEpoch | |
| // This value contains the current clock Epoch. It changes when there is a clock | |
| // discontinuity. It may be necessary to place this in NV should the timer be able | |
| // to run across a power down of the TPM but not in all cases (e.g. dead battery). | |
| // If the nonce is placed in NV, it should go in gp because it should be changing | |
| // slowly. | |
| #if CLOCK_STOPS | |
| EXTERN CLOCK_NONCE g_timeEpoch; | |
| #else | |
| #define g_timeEpoch gp.timeEpoch | |
| #endif | |
| //*** g_phEnable | |
| // This is the platform hierarchy control and determines if the platform hierarchy | |
| // is available. This value is SET on each TPM2_Startup(). The default value is | |
| // SET. | |
| EXTERN BOOL g_phEnable; | |
| //*** g_pcrReConfig | |
| // This value is SET if a TPM2_PCR_Allocate command successfully executed since | |
| // the last TPM2_Startup(). If so, then the next shutdown is required to be | |
| // Shutdown(CLEAR). | |
| EXTERN BOOL g_pcrReConfig; | |
| //*** g_DRTMHandle | |
| // This location indicates the sequence object handle that holds the DRTM | |
| // sequence data. When not used, it is set to TPM_RH_UNASSIGNED. A sequence | |
| // DRTM sequence is started on either _TPM_Init or _TPM_Hash_Start. | |
| EXTERN TPMI_DH_OBJECT g_DRTMHandle; | |
| //*** g_DrtmPreStartup | |
| // This value indicates that an H-CRTM occurred after _TPM_Init but before | |
| // TPM2_Startup(). The define for PRE_STARTUP_FLAG is used to add the | |
| // g_DrtmPreStartup value to gp_orderlyState at shutdown. This hack is to avoid | |
| // adding another NV variable. | |
| EXTERN BOOL g_DrtmPreStartup; | |
| //*** g_StartupLocality3 | |
| // This value indicates that a TPM2_Startup() occurred at locality 3. Otherwise, it | |
| // at locality 0. The define for STARTUP_LOCALITY_3 is to | |
| // indicate that the startup was not at locality 0. This hack is to avoid | |
| // adding another NV variable. | |
| EXTERN BOOL g_StartupLocality3; | |
| //***TPM_SU_NONE | |
| // Part 2 defines the two shutdown/startup types that may be used in | |
| // TPM2_Shutdown() and TPM2_Starup(). This additional define is | |
| // used by the TPM to indicate that no shutdown was received. | |
| // NOTE: This is a reserved value. | |
| #define SU_NONE_VALUE (0xFFFF) | |
| #define TPM_SU_NONE (TPM_SU)(SU_NONE_VALUE) | |
| //*** TPM_SU_DA_USED | |
| // As with TPM_SU_NONE, this value is added to allow indication that the shutdown | |
| // was not orderly and that a DA=protected object was reference during the previous | |
| // cycle. | |
| #define SU_DA_USED_VALUE (SU_NONE_VALUE - 1) | |
| #define TPM_SU_DA_USED (TPM_SU)(SU_DA_USED_VALUE) | |
| //*** Startup Flags | |
| // These flags are included in gp.orderlyState. These are hacks and are being | |
| // used to avoid having to change the layout of gp. The PRE_STARTUP_FLAG indicates | |
| // that a _TPM_Hash_Start/_Data/_End sequence was received after _TPM_Init but | |
| // before TPM2_StartUp(). STARTUP_LOCALITY_3 indicates that the last TPM2_Startup() | |
| // was received at locality 3. These flags are only relevant if after a | |
| // TPM2_Shutdown(STATE). | |
| #define PRE_STARTUP_FLAG 0x8000 | |
| #define STARTUP_LOCALITY_3 0x4000 | |
| #if USE_DA_USED | |
| //*** g_daUsed | |
| // This location indicates if a DA-protected value is accessed during a boot | |
| // cycle. If none has, then there is no need to increment 'failedTries' on the | |
| // next non-orderly startup. This bit is merged with gp.orderlyState when | |
| // gp.orderly is set to SU_NONE_VALUE | |
| EXTERN BOOL g_daUsed; | |
| #endif | |
| //*** g_updateNV | |
| // This flag indicates if NV should be updated at the end of a command. | |
| // This flag is set to UT_NONE at the beginning of each command in ExecuteCommand(). | |
| // This flag is checked in ExecuteCommand() after the detailed actions of a command | |
| // complete. If the command execution was successful and this flag is not UT_NONE, | |
| // any pending NV writes will be committed to NV. | |
| // UT_ORDERLY causes any RAM data to be written to the orderly space for staging | |
| // the write to NV. | |
| typedef BYTE UPDATE_TYPE; | |
| #define UT_NONE (UPDATE_TYPE)0 | |
| #define UT_NV (UPDATE_TYPE)1 | |
| #define UT_ORDERLY (UPDATE_TYPE)(UT_NV + 2) | |
| EXTERN UPDATE_TYPE g_updateNV; | |
| //*** g_powerWasLost | |
| // This flag is used to indicate if the power was lost. It is SET in _TPM__Init. | |
| // This flag is cleared by TPM2_Startup() after all power-lost activities are | |
| // completed. | |
| // Note: When power is applied, this value can come up as anything. However, | |
| // _plat__WasPowerLost() will provide the proper indication in that case. So, when | |
| // power is actually lost, we get the correct answer. When power was not lost, but | |
| // the power-lost processing has not been completed before the next _TPM_Init(), | |
| // then the TPM still does the correct thing. | |
| EXTERN BOOL g_powerWasLost; | |
| //*** g_clearOrderly | |
| // This flag indicates if the execution of a command should cause the orderly | |
| // state to be cleared. This flag is set to FALSE at the beginning of each | |
| // command in ExecuteCommand() and is checked in ExecuteCommand() after the | |
| // detailed actions of a command complete but before the check of | |
| // 'g_updateNV'. If this flag is TRUE, and the orderly state is not | |
| // SU_NONE_VALUE, then the orderly state in NV memory will be changed to | |
| // SU_NONE_VALUE or SU_DA_USED_VALUE. | |
| EXTERN BOOL g_clearOrderly; | |
| //*** g_prevOrderlyState | |
| // This location indicates how the TPM was shut down before the most recent | |
| // TPM2_Startup(). This value, along with the startup type, determines if | |
| // the TPM should do a TPM Reset, TPM Restart, or TPM Resume. | |
| EXTERN TPM_SU g_prevOrderlyState; | |
| //*** g_nvOk | |
| // This value indicates if the NV integrity check was successful or not. If not and | |
| // the failure was severe, then the TPM would have been put into failure mode after | |
| // it had been re-manufactured. If the NV failure was in the area where the state-save | |
| // data is kept, then this variable will have a value of FALSE indicating that | |
| // a TPM2_Startup(CLEAR) is required. | |
| EXTERN BOOL g_nvOk; | |
| // NV availability is sampled as the start of each command and stored here | |
| // so that its value remains consistent during the command execution | |
| EXTERN TPM_RC g_NvStatus; | |
| //*** g_platformUnique | |
| // This location contains the unique value(s) used to identify the TPM. It is | |
| // loaded on every _TPM2_Startup() | |
| // The first value is used to seed the RNG. The second value is used as a vendor | |
| // authValue. The value used by the RNG would be the value derived from the | |
| // chip unique value (such as fused) with a dependency on the authorities of the | |
| // code in the TPM boot path. The second would be derived from the chip unique value | |
| // with a dependency on the details of the code in the boot path. That is, the | |
| // first value depends on the various signers of the code and the second depends on | |
| // what was signed. The TPM vendor should not be able to know the first value but | |
| // they are expected to know the second. | |
| EXTERN TPM2B_AUTH g_platformUniqueAuthorities; // Reserved for RNG | |
| EXTERN TPM2B_AUTH g_platformUniqueDetails; // referenced by VENDOR_PERMANENT | |
| //********************************************************************************* | |
| //********************************************************************************* | |
| //** Persistent Global Values | |
| //********************************************************************************* | |
| //********************************************************************************* | |
| //*** Description | |
| // The values in this section are global values that are persistent across power | |
| // events. The lifetime of the values determines the structure in which the value | |
| // is placed. | |
| //********************************************************************************* | |
| //*** PERSISTENT_DATA | |
| //********************************************************************************* | |
| // This structure holds the persistent values that only change as a consequence | |
| // of a specific Protected Capability and are not affected by TPM power events | |
| // (TPM2_Startup() or TPM2_Shutdown(). | |
| typedef struct | |
| { | |
| //********************************************************************************* | |
| // Hierarchy | |
| //********************************************************************************* | |
| // The values in this section are related to the hierarchies. | |
| BOOL disableClear; // TRUE if TPM2_Clear() using | |
| // lockoutAuth is disabled | |
| // Hierarchy authPolicies | |
| TPMI_ALG_HASH ownerAlg; | |
| TPMI_ALG_HASH endorsementAlg; | |
| TPMI_ALG_HASH lockoutAlg; | |
| TPM2B_DIGEST ownerPolicy; | |
| TPM2B_DIGEST endorsementPolicy; | |
| TPM2B_DIGEST lockoutPolicy; | |
| // Hierarchy authValues | |
| TPM2B_AUTH ownerAuth; | |
| TPM2B_AUTH endorsementAuth; | |
| TPM2B_AUTH lockoutAuth; | |
| // Primary Seeds | |
| TPM2B_SEED EPSeed; | |
| TPM2B_SEED SPSeed; | |
| TPM2B_SEED PPSeed; | |
| // Note there is a nullSeed in the state_reset memory. | |
| // Hierarchy proofs | |
| TPM2B_PROOF phProof; | |
| TPM2B_PROOF shProof; | |
| TPM2B_PROOF ehProof; | |
| // Note there is a nullProof in the state_reset memory. | |
| //********************************************************************************* | |
| // Reset Events | |
| //********************************************************************************* | |
| // A count that increments at each TPM reset and never get reset during the life | |
| // time of TPM. The value of this counter is initialized to 1 during TPM | |
| // manufacture process. It is used to invalidate all saved contexts after a TPM | |
| // Reset. | |
| UINT64 totalResetCount; | |
| // This counter increments on each TPM Reset. The counter is reset by | |
| // TPM2_Clear(). | |
| UINT32 resetCount; | |
| //********************************************************************************* | |
| // PCR | |
| //********************************************************************************* | |
| // This structure hold the policies for those PCR that have an update policy. | |
| // This implementation only supports a single group of PCR controlled by | |
| // policy. If more are required, then this structure would be changed to | |
| // an array. | |
| #if defined NUM_POLICY_PCR_GROUP && NUM_POLICY_PCR_GROUP > 0 | |
| PCR_POLICY pcrPolicies; | |
| #endif | |
| // This structure indicates the allocation of PCR. The structure contains a | |
| // list of PCR allocations for each implemented algorithm. If no PCR are | |
| // allocated for an algorithm, a list entry still exists but the bit map | |
| // will contain no SET bits. | |
| TPML_PCR_SELECTION pcrAllocated; | |
| //********************************************************************************* | |
| // Physical Presence | |
| //********************************************************************************* | |
| // The PP_LIST type contains a bit map of the commands that require physical | |
| // to be asserted when the authorization is evaluated. Physical presence will be | |
| // checked if the corresponding bit in the array is SET and if the authorization | |
| // handle is TPM_RH_PLATFORM. | |
| // | |
| // These bits may be changed with TPM2_PP_Commands(). | |
| BYTE ppList[(COMMAND_COUNT + 7) / 8]; | |
| //********************************************************************************* | |
| // Dictionary attack values | |
| //********************************************************************************* | |
| // These values are used for dictionary attack tracking and control. | |
| UINT32 failedTries; // the current count of unexpired | |
| // authorization failures | |
| UINT32 maxTries; // number of unexpired authorization | |
| // failures before the TPM is in | |
| // lockout | |
| UINT32 recoveryTime; // time between authorization failures | |
| // before failedTries is decremented | |
| UINT32 lockoutRecovery; // time that must expire between | |
| // authorization failures associated | |
| // with lockoutAuth | |
| BOOL lockOutAuthEnabled; // TRUE if use of lockoutAuth is | |
| // allowed | |
| //***************************************************************************** | |
| // Orderly State | |
| //***************************************************************************** | |
| // The orderly state for current cycle | |
| TPM_SU orderlyState; | |
| //***************************************************************************** | |
| // Command audit values. | |
| //***************************************************************************** | |
| BYTE auditCommands[((COMMAND_COUNT + 1) + 7) / 8]; | |
| TPMI_ALG_HASH auditHashAlg; | |
| UINT64 auditCounter; | |
| //***************************************************************************** | |
| // Algorithm selection | |
| //***************************************************************************** | |
| // | |
| // The 'algorithmSet' value indicates the collection of algorithms that are | |
| // currently in used on the TPM. The interpretation of value is vendor dependent. | |
| UINT32 algorithmSet; | |
| //***************************************************************************** | |
| // Firmware version | |
| //***************************************************************************** | |
| // The firmwareV1 and firmwareV2 values are instanced in TimeStamp.c. This is | |
| // a scheme used in development to allow determination of the linker build time | |
| // of the TPM. An actual implementation would implement these values in a way that | |
| // is consistent with vendor needs. The values are maintained in RAM for simplified | |
| // access with a master version in NV. These values are modified in a | |
| // vendor-specific way. | |
| // g_firmwareV1 contains the more significant 32-bits of the vendor version number. | |
| // In the reference implementation, if this value is printed as a hex | |
| // value, it will have the format of YYYYMMDD | |
| UINT32 firmwareV1; | |
| // g_firmwareV1 contains the less significant 32-bits of the vendor version number. | |
| // In the reference implementation, if this value is printed as a hex | |
| // value, it will have the format of 00 HH MM SS | |
| UINT32 firmwareV2; | |
| //***************************************************************************** | |
| // Timer Epoch | |
| //***************************************************************************** | |
| // timeEpoch contains a nonce that has a vendor=specific size (should not be | |
| // less than 8 bytes. This nonce changes when the clock epoch changes. The clock | |
| // epoch changes when there is a discontinuity in the timing of the TPM. | |
| #if !CLOCK_STOPS | |
| CLOCK_NONCE timeEpoch; | |
| #endif | |
| } PERSISTENT_DATA; | |
| EXTERN PERSISTENT_DATA gp; | |
| //********************************************************************************* | |
| //********************************************************************************* | |
| //*** ORDERLY_DATA | |
| //********************************************************************************* | |
| //********************************************************************************* | |
| // The data in this structure is saved to NV on each TPM2_Shutdown(). | |
| typedef struct orderly_data | |
| { | |
| //***************************************************************************** | |
| // TIME | |
| //***************************************************************************** | |
| // Clock has two parts. One is the state save part and one is the NV part. The | |
| // state save version is updated on each command. When the clock rolls over, the | |
| // NV version is updated. When the TPM starts up, if the TPM was shutdown in and | |
| // orderly way, then the sClock value is used to initialize the clock. If the | |
| // TPM shutdown was not orderly, then the persistent value is used and the safe | |
| // attribute is clear. | |
| UINT64 clock; // The orderly version of clock | |
| TPMI_YES_NO clockSafe; // Indicates if the clock value is | |
| // safe. | |
| // In many implementations, the quality of the entropy available is not that | |
| // high. To compensate, the current value of the drbgState can be saved and | |
| // restored on each power cycle. This prevents the internal state from reverting | |
| // to the initial state on each power cycle and starting with a limited amount | |
| // of entropy. By keeping the old state and adding entropy, the entropy will | |
| // accumulate. | |
| DRBG_STATE drbgState; | |
| // These values allow the accumulation of self-healing time across orderly shutdown | |
| // of the TPM. | |
| #if ACCUMULATE_SELF_HEAL_TIMER | |
| UINT64 selfHealTimer; // current value of s_selfHealTimer | |
| UINT64 lockoutTimer; // current value of s_lockoutTimer | |
| UINT64 time; // current value of g_time at shutdown | |
| #endif // ACCUMULATE_SELF_HEAL_TIMER | |
| // These are the ACT Timeout values. They are saved with the other timers | |
| #define DefineActData(N) ACT_STATE ACT_##N; | |
| FOR_EACH_ACT(DefineActData) | |
| // this is the 'signaled' attribute data for all the ACT. It is done this way so | |
| // that they can be manipulated by ACT number rather than having to access a | |
| // structure. | |
| UINT16 signaledACT; | |
| UINT16 preservedSignaled; | |
| } ORDERLY_DATA; | |
| #if ACCUMULATE_SELF_HEAL_TIMER | |
| #define s_selfHealTimer go.selfHealTimer | |
| #define s_lockoutTimer go.lockoutTimer | |
| #endif // ACCUMULATE_SELF_HEAL_TIMER | |
| # define drbgDefault go.drbgState | |
| EXTERN ORDERLY_DATA go; | |
| //********************************************************************************* | |
| //********************************************************************************* | |
| //*** STATE_CLEAR_DATA | |
| //********************************************************************************* | |
| //********************************************************************************* | |
| // This structure contains the data that is saved on Shutdown(STATE) | |
| // and restored on Startup(STATE). The values are set to their default | |
| // settings on any Startup(Clear). In other words, the data is only persistent | |
| // across TPM Resume. | |
| // | |
| // If the comments associated with a parameter indicate a default reset value, the | |
| // value is applied on each Startup(CLEAR). | |
| typedef struct state_clear_data | |
| { | |
| //***************************************************************************** | |
| // Hierarchy Control | |
| //***************************************************************************** | |
| BOOL shEnable; // default reset is SET | |
| BOOL ehEnable; // default reset is SET | |
| BOOL phEnableNV; // default reset is SET | |
| TPMI_ALG_HASH platformAlg; // default reset is TPM_ALG_NULL | |
| TPM2B_DIGEST platformPolicy; // default reset is an Empty Buffer | |
| TPM2B_AUTH platformAuth; // default reset is an Empty Buffer | |
| //***************************************************************************** | |
| // PCR | |
| //***************************************************************************** | |
| // The set of PCR to be saved on Shutdown(STATE) | |
| PCR_SAVE pcrSave; // default reset is 0...0 | |
| // This structure hold the authorization values for those PCR that have an | |
| // update authorization. | |
| // This implementation only supports a single group of PCR controlled by | |
| // authorization. If more are required, then this structure would be changed to | |
| // an array. | |
| PCR_AUTHVALUE pcrAuthValues; | |
| //***************************************************************************** | |
| // ACT | |
| //***************************************************************************** | |
| #define DefineActPolicySpace(N) TPMT_HA act_##N; | |
| FOR_EACH_ACT(DefineActPolicySpace) | |
| } STATE_CLEAR_DATA; | |
| EXTERN STATE_CLEAR_DATA gc; | |
| //********************************************************************************* | |
| //********************************************************************************* | |
| //*** State Reset Data | |
| //********************************************************************************* | |
| //********************************************************************************* | |
| // This structure contains data is that is saved on Shutdown(STATE) and restored on | |
| // the subsequent Startup(ANY). That is, the data is preserved across TPM Resume | |
| // and TPM Restart. | |
| // | |
| // If a default value is specified in the comments this value is applied on | |
| // TPM Reset. | |
| typedef struct state_reset_data | |
| { | |
| //***************************************************************************** | |
| // Hierarchy Control | |
| //***************************************************************************** | |
| TPM2B_PROOF nullProof; // The proof value associated with | |
| // the TPM_RH_NULL hierarchy. The | |
| // default reset value is from the RNG. | |
| TPM2B_SEED nullSeed; // The seed value for the TPM_RN_NULL | |
| // hierarchy. The default reset value | |
| // is from the RNG. | |
| //***************************************************************************** | |
| // Context | |
| //***************************************************************************** | |
| // The 'clearCount' counter is incremented each time the TPM successfully executes | |
| // a TPM Resume. The counter is included in each saved context that has 'stClear' | |
| // SET (including descendants of keys that have 'stClear' SET). This prevents these | |
| // objects from being loaded after a TPM Resume. | |
| // If 'clearCount' is at its maximum value when the TPM receives a Shutdown(STATE), | |
| // the TPM will return TPM_RC_RANGE and the TPM will only accept Shutdown(CLEAR). | |
| UINT32 clearCount; // The default reset value is 0. | |
| UINT64 objectContextID; // This is the context ID for a saved | |
| // object context. The default reset | |
| // value is 0. | |
| CONTEXT_SLOT contextArray[MAX_ACTIVE_SESSIONS]; // This array contains | |
| // contains the values used to track | |
| // the version numbers of saved | |
| // contexts (see | |
| // Session.c in for details). The | |
| // default reset value is {0}. | |
| CONTEXT_COUNTER contextCounter; // This is the value from which the | |
| // 'contextID' is derived. The | |
| // default reset value is {0}. | |
| //***************************************************************************** | |
| // Command Audit | |
| //***************************************************************************** | |
| // When an audited command completes, ExecuteCommand() checks the return | |
| // value. If it is TPM_RC_SUCCESS, and the command is an audited command, the | |
| // TPM will extend the cpHash and rpHash for the command to this value. If this | |
| // digest was the Zero Digest before the cpHash was extended, the audit counter | |
| // is incremented. | |
| TPM2B_DIGEST commandAuditDigest; // This value is set to an Empty Digest | |
| // by TPM2_GetCommandAuditDigest() or a | |
| // TPM Reset. | |
| //***************************************************************************** | |
| // Boot counter | |
| //***************************************************************************** | |
| UINT32 restartCount; // This counter counts TPM Restarts. | |
| // The default reset value is 0. | |
| //********************************************************************************* | |
| // PCR | |
| //********************************************************************************* | |
| // This counter increments whenever the PCR are updated. This counter is preserved | |
| // across TPM Resume even though the PCR are not preserved. This is because | |
| // sessions remain active across TPM Restart and the count value in the session | |
| // is compared to this counter so this counter must have values that are unique | |
| // as long as the sessions are active. | |
| // NOTE: A platform-specific specification may designate that certain PCR changes | |
| // do not increment this counter to increment. | |
| UINT32 pcrCounter; // The default reset value is 0. | |
| #if ALG_ECC | |
| //***************************************************************************** | |
| // ECDAA | |
| //***************************************************************************** | |
| UINT64 commitCounter; // This counter increments each time | |
| // TPM2_Commit() returns | |
| // TPM_RC_SUCCESS. The default reset | |
| // value is 0. | |
| TPM2B_NONCE commitNonce; // This random value is used to compute | |
| // the commit values. The default reset | |
| // value is from the RNG. | |
| // This implementation relies on the number of bits in g_commitArray being a | |
| // power of 2 (8, 16, 32, 64, etc.) and no greater than 64K. | |
| BYTE commitArray[16]; // The default reset value is {0}. | |
| #endif // ALG_ECC | |
| } STATE_RESET_DATA; | |
| EXTERN STATE_RESET_DATA gr; | |
| //** NV Layout | |
| // The NV data organization is | |
| // 1) a PERSISTENT_DATA structure | |
| // 2) a STATE_RESET_DATA structure | |
| // 3) a STATE_CLEAR_DATA structure | |
| // 4) an ORDERLY_DATA structure | |
| // 5) the user defined NV index space | |
| #define NV_PERSISTENT_DATA (0) | |
| #define NV_STATE_RESET_DATA (NV_PERSISTENT_DATA + sizeof(PERSISTENT_DATA)) | |
| #define NV_STATE_CLEAR_DATA (NV_STATE_RESET_DATA + sizeof(STATE_RESET_DATA)) | |
| #define NV_ORDERLY_DATA (NV_STATE_CLEAR_DATA + sizeof(STATE_CLEAR_DATA)) | |
| #define NV_INDEX_RAM_DATA (NV_ORDERLY_DATA + sizeof(ORDERLY_DATA)) | |
| #define NV_USER_DYNAMIC (NV_INDEX_RAM_DATA + sizeof(s_indexOrderlyRam)) | |
| #define NV_USER_DYNAMIC_END NV_MEMORY_SIZE | |
| //** Global Macro Definitions | |
| // The NV_READ_PERSISTENT and NV_WRITE_PERSISTENT macros are used to access members | |
| // of the PERSISTENT_DATA structure in NV. | |
| #define NV_READ_PERSISTENT(to, from) \ | |
| NvRead(&to, offsetof(PERSISTENT_DATA, from), sizeof(to)) | |
| #define NV_WRITE_PERSISTENT(to, from) \ | |
| NvWrite(offsetof(PERSISTENT_DATA, to), sizeof(gp.to), &from) | |
| #define CLEAR_PERSISTENT(item) \ | |
| NvClearPersistent(offsetof(PERSISTENT_DATA, item), sizeof(gp.item)) | |
| #define NV_SYNC_PERSISTENT(item) NV_WRITE_PERSISTENT(item, gp.item) | |
| // At the start of command processing, the index of the command is determined. This | |
| // index value is used to access the various data tables that contain per-command | |
| // information. There are multiple options for how the per-command tables can be | |
| // implemented. This is resolved in GetClosestCommandIndex(). | |
| typedef UINT16 COMMAND_INDEX; | |
| #define UNIMPLEMENTED_COMMAND_INDEX ((COMMAND_INDEX)(~0)) | |
| typedef struct _COMMAND_FLAGS_ | |
| { | |
| unsigned trialPolicy : 1; //1) If SET, one of the handles references a | |
| // trial policy and authorization may be | |
| // skipped. This is only allowed for a policy | |
| // command. | |
| } COMMAND_FLAGS; | |
| // This structure is used to avoid having to manage a large number of | |
| // parameters being passed through various levels of the command input processing. | |
| // | |
| // The following macros are used to define the space for the CP and RP hashes. Space, | |
| // is provided for each implemented hash algorithm because it is not known what the | |
| // caller may use. | |
| #define CP_HASH(HASH, Hash) TPM2B_##HASH##_DIGEST Hash##CpHash; | |
| #define RP_HASH(HASH, Hash) TPM2B_##HASH##_DIGEST Hash##RpHash; | |
| typedef struct COMMAND | |
| { | |
| TPM_ST tag; // the parsed command tag | |
| TPM_CC code; // the parsed command code | |
| COMMAND_INDEX index; // the computed command index | |
| UINT32 handleNum; // the number of entity handles in the | |
| // handle area of the command | |
| TPM_HANDLE handles[MAX_HANDLE_NUM]; // the parsed handle values | |
| UINT32 sessionNum; // the number of sessions found | |
| INT32 parameterSize; // starts out with the parsed command size | |
| // and is reduced and values are | |
| // unmarshaled. Just before calling the | |
| // command actions, this should be zero. | |
| // After the command actions, this number | |
| // should grow as values are marshaled | |
| // in to the response buffer. | |
| INT32 authSize; // this is initialized with the parsed size | |
| // of authorizationSize field and should | |
| // be zero when the authorizations are | |
| // parsed. | |
| BYTE *parameterBuffer; // input to ExecuteCommand | |
| BYTE *responseBuffer; // input to ExecuteCommand | |
| FOR_EACH_HASH(CP_HASH) // space for the CP hashes | |
| FOR_EACH_HASH(RP_HASH) // space for the RP hashes | |
| } COMMAND; | |
| // Global string constants for consistency in KDF function calls. | |
| // These string constants are shared across functions to make sure that they | |
| // are all using consistent string values. | |
| #define STRING_INITIALIZER(value) {{sizeof(value), {value}}} | |
| #define TPM2B_STRING(name, value) \ | |
| typedef union name##_ { \ | |
| struct { \ | |
| UINT16 size; \ | |
| BYTE buffer[sizeof(value)]; \ | |
| } t; \ | |
| TPM2B b; \ | |
| } TPM2B_##name##_; \ | |
| EXTERN const TPM2B_##name##_ name##_ INITIALIZER(STRING_INITIALIZER(value)); \ | |
| EXTERN const TPM2B *name INITIALIZER(&name##_.b) | |
| TPM2B_STRING(PRIMARY_OBJECT_CREATION, "Primary Object Creation"); | |
| TPM2B_STRING(CFB_KEY, "CFB"); | |
| TPM2B_STRING(CONTEXT_KEY, "CONTEXT"); | |
| TPM2B_STRING(INTEGRITY_KEY, "INTEGRITY"); | |
| TPM2B_STRING(SECRET_KEY, "SECRET"); | |
| TPM2B_STRING(SESSION_KEY, "ATH"); | |
| TPM2B_STRING(STORAGE_KEY, "STORAGE"); | |
| TPM2B_STRING(XOR_KEY, "XOR"); | |
| TPM2B_STRING(COMMIT_STRING, "ECDAA Commit"); | |
| TPM2B_STRING(DUPLICATE_STRING, "DUPLICATE"); | |
| TPM2B_STRING(IDENTITY_STRING, "IDENTITY"); | |
| TPM2B_STRING(OBFUSCATE_STRING, "OBFUSCATE"); | |
| #if SELF_TEST | |
| TPM2B_STRING(OAEP_TEST_STRING, "OAEP Test Value"); | |
| #endif // SELF_TEST | |
| //***************************************************************************** | |
| //** From CryptTest.c | |
| //***************************************************************************** | |
| // This structure contains the self-test state values for the cryptographic modules. | |
| EXTERN CRYPTO_SELF_TEST_STATE g_cryptoSelfTestState; | |
| //***************************************************************************** | |
| //** From Manufacture.c | |
| //***************************************************************************** | |
| EXTERN BOOL g_manufactured INITIALIZER(FALSE); | |
| // This value indicates if a TPM2_Startup commands has been | |
| // receive since the power on event. This flag is maintained in power | |
| // simulation module because this is the only place that may reliably set this | |
| // flag to FALSE. | |
| EXTERN BOOL g_initialized; | |
| //** Private data | |
| //***************************************************************************** | |
| //*** From SessionProcess.c | |
| //***************************************************************************** | |
| #if defined SESSION_PROCESS_C || defined GLOBAL_C || defined MANUFACTURE_C | |
| // The following arrays are used to save command sessions information so that the | |
| // command handle/session buffer does not have to be preserved for the duration of | |
| // the command. These arrays are indexed by the session index in accordance with | |
| // the order of sessions in the session area of the command. | |
| // | |
| // Array of the authorization session handles | |
| EXTERN TPM_HANDLE s_sessionHandles[MAX_SESSION_NUM]; | |
| // Array of authorization session attributes | |
| EXTERN TPMA_SESSION s_attributes[MAX_SESSION_NUM]; | |
| // Array of handles authorized by the corresponding authorization sessions; | |
| // and if none, then TPM_RH_UNASSIGNED value is used | |
| EXTERN TPM_HANDLE s_associatedHandles[MAX_SESSION_NUM]; | |
| // Array of nonces provided by the caller for the corresponding sessions | |
| EXTERN TPM2B_NONCE s_nonceCaller[MAX_SESSION_NUM]; | |
| // Array of authorization values (HMAC's or passwords) for the corresponding | |
| // sessions | |
| EXTERN TPM2B_AUTH s_inputAuthValues[MAX_SESSION_NUM]; | |
| // Array of pointers to the SESSION structures for the sessions in a command | |
| EXTERN SESSION *s_usedSessions[MAX_SESSION_NUM]; | |
| // Special value to indicate an undefined session index | |
| #define UNDEFINED_INDEX (0xFFFF) | |
| // Index of the session used for encryption of a response parameter | |
| EXTERN UINT32 s_encryptSessionIndex; | |
| // Index of the session used for decryption of a command parameter | |
| EXTERN UINT32 s_decryptSessionIndex; | |
| // Index of a session used for audit | |
| EXTERN UINT32 s_auditSessionIndex; | |
| // The cpHash for command audit | |
| #ifdef TPM_CC_GetCommandAuditDigest | |
| EXTERN TPM2B_DIGEST s_cpHashForCommandAudit; | |
| #endif | |
| // Flag indicating if NV update is pending for the lockOutAuthEnabled or | |
| // failedTries DA parameter | |
| EXTERN BOOL s_DAPendingOnNV; | |
| #endif // SESSION_PROCESS_C | |
| //***************************************************************************** | |
| //*** From DA.c | |
| //***************************************************************************** | |
| #if defined DA_C || defined GLOBAL_C || defined MANUFACTURE_C | |
| // This variable holds the accumulated time since the last time | |
| // that 'failedTries' was decremented. This value is in millisecond. | |
| #if !ACCUMULATE_SELF_HEAL_TIMER | |
| EXTERN UINT64 s_selfHealTimer; | |
| // This variable holds the accumulated time that the lockoutAuth has been | |
| // blocked. | |
| EXTERN UINT64 s_lockoutTimer; | |
| #endif // ACCUMULATE_SELF_HEAL_TIMER | |
| #endif // DA_C | |
| //***************************************************************************** | |
| //*** From NV.c | |
| //***************************************************************************** | |
| #if defined NV_C || defined GLOBAL_C | |
| // This marks the end of the NV area. This is a run-time variable as it might | |
| // not be compile-time constant. | |
| EXTERN NV_REF s_evictNvEnd; | |
| // This space is used to hold the index data for an orderly Index. It also contains | |
| // the attributes for the index. | |
| EXTERN BYTE s_indexOrderlyRam[RAM_INDEX_SPACE]; // The orderly NV Index data | |
| // This value contains the current max counter value. It is written to the end of | |
| // allocatable NV space each time an index is deleted or added. This value is | |
| // initialized on Startup. The indices are searched and the maximum of all the | |
| // current counter indices and this value is the initial value for this. | |
| EXTERN UINT64 s_maxCounter; | |
| // This is space used for the NV Index cache. As with a persistent object, the | |
| // contents of a referenced index are copied into the cache so that the | |
| // NV Index memory scanning and data copying can be reduced. | |
| // Only code that operates on NV Index data should use this cache directly. When | |
| // that action code runs, s_lastNvIndex will contain the index header information. | |
| // It will have been loaded when the handles were verified. | |
| // NOTE: An NV index handle can appear in many commands that do not operate on the | |
| // NV data (e.g. TPM2_StartAuthSession). However, only one NV Index at a time is | |
| // ever directly referenced by any command. If that changes, then the NV Index | |
| // caching needs to be changed to accommodate that. Currently, the code will verify | |
| // that only one NV Index is referenced by the handles of the command. | |
| EXTERN NV_INDEX s_cachedNvIndex; | |
| EXTERN NV_REF s_cachedNvRef; | |
| EXTERN BYTE *s_cachedNvRamRef; | |
| // Initial NV Index/evict object iterator value | |
| #define NV_REF_INIT (NV_REF)0xFFFFFFFF | |
| #endif | |
| //***************************************************************************** | |
| //*** From Object.c | |
| //***************************************************************************** | |
| #if defined OBJECT_C || defined GLOBAL_C | |
| // This type is the container for an object. | |
| EXTERN OBJECT s_objects[MAX_LOADED_OBJECTS]; | |
| #endif // OBJECT_C | |
| //***************************************************************************** | |
| //*** From PCR.c | |
| //***************************************************************************** | |
| #if defined PCR_C || defined GLOBAL_C | |
| // The following macro is used to define the per-implemented-hash space. This | |
| // implementation reserves space for all implemented hashes. | |
| #define PCR_ALL_HASH(HASH, Hash) BYTE Hash##Pcr[HASH##_DIGEST_SIZE]; | |
| typedef struct | |
| { | |
| FOR_EACH_HASH(PCR_ALL_HASH) | |
| } PCR; | |
| typedef struct | |
| { | |
| unsigned int stateSave : 1; // if the PCR value should be | |
| // saved in state save | |
| unsigned int resetLocality : 5; // The locality that the PCR | |
| // can be reset | |
| unsigned int extendLocality : 5; // The locality that the PCR | |
| // can be extend | |
| } PCR_Attributes; | |
| EXTERN PCR s_pcrs[IMPLEMENTATION_PCR]; | |
| #endif // PCR_C | |
| //***************************************************************************** | |
| //*** From Session.c | |
| //***************************************************************************** | |
| #if defined SESSION_C || defined GLOBAL_C | |
| // Container for HMAC or policy session tracking information | |
| typedef struct | |
| { | |
| BOOL occupied; | |
| SESSION session; // session structure | |
| } SESSION_SLOT; | |
| EXTERN SESSION_SLOT s_sessions[MAX_LOADED_SESSIONS]; | |
| // The index in contextArray that has the value of the oldest saved session | |
| // context. When no context is saved, this will have a value that is greater | |
| // than or equal to MAX_ACTIVE_SESSIONS. | |
| EXTERN UINT32 s_oldestSavedSession; | |
| // The number of available session slot openings. When this is 1, | |
| // a session can't be created or loaded if the GAP is maxed out. | |
| // The exception is that the oldest saved session context can always | |
| // be loaded (assuming that there is a space in memory to put it) | |
| EXTERN int s_freeSessionSlots; | |
| #endif // SESSION_C | |
| //***************************************************************************** | |
| //*** From IoBuffers.c | |
| //***************************************************************************** | |
| #if defined IO_BUFFER_C || defined GLOBAL_C | |
| // Each command function is allowed a structure for the inputs to the function and | |
| // a structure for the outputs. The command dispatch code unmarshals the input butter | |
| // to the command action input structure starting at the first byte of | |
| // s_actionIoBuffer. The value of s_actionIoAllocation is the number of UINT64 values | |
| // allocated. It is used to set the pointer for the response structure. The command | |
| // dispatch code will marshal the response values into the final output buffer. | |
| EXTERN UINT64 s_actionIoBuffer[768]; // action I/O buffer | |
| EXTERN UINT32 s_actionIoAllocation; // number of UIN64 allocated for the | |
| // action input structure | |
| #endif // IO_BUFFER_C | |
| //***************************************************************************** | |
| //*** From TPMFail.c | |
| //***************************************************************************** | |
| // This value holds the address of the string containing the name of the function | |
| // in which the failure occurred. This address value is not useful for anything | |
| // other than helping the vendor to know in which file the failure occurred. | |
| EXTERN BOOL g_inFailureMode; // Indicates that the TPM is in failure mode | |
| #if SIMULATION | |
| EXTERN BOOL g_forceFailureMode; // flag to force failure mode during test | |
| #endif | |
| typedef void(FailFunction)(const char *function, int line, int code); | |
| #if defined TPM_FAIL_C || defined GLOBAL_C | |
| EXTERN UINT32 s_failFunction; | |
| EXTERN UINT32 s_failLine; // the line in the file at which | |
| // the error was signaled | |
| EXTERN UINT32 s_failCode; // the error code used | |
| EXTERN FailFunction *LibFailCallback; | |
| #endif // TPM_FAIL_C | |
| //***************************************************************************** | |
| //*** From ACT_spt.c | |
| //***************************************************************************** | |
| // This value is used to indicate if an ACT has been updated since the last | |
| // TPM2_Startup() (one bit for each ACT). If the ACT is not updated | |
| // (TPM2_ACT_SetTimeout()) after a startup, then on each TPM2_Shutdown() the TPM will | |
| // save 1/2 of the current timer value. This prevents an attack on the ACT by saving | |
| // the counter and then running for a long period of time before doing a TPM Restart. | |
| // A quick TPM2_Shutdown() after each | |
| EXTERN UINT16 s_ActUpdated; | |
| //***************************************************************************** | |
| //*** From CommandCodeAttributes.c | |
| //***************************************************************************** | |
| // This array is instanced in CommandCodeAttributes.c when it includes | |
| // CommandCodeAttributes.h. Don't change the extern to EXTERN. | |
| extern const TPMA_CC s_ccAttr[]; | |
| extern const COMMAND_ATTRIBUTES s_commandAttributes[]; | |
| #endif // GLOBAL_H |