diff options
Diffstat (limited to '')
| -rw-r--r-- | src/tpm2/Global.h | 1350 |
1 files changed, 1350 insertions, 0 deletions
diff --git a/src/tpm2/Global.h b/src/tpm2/Global.h new file mode 100644 index 0000000..84a0d13 --- /dev/null +++ b/src/tpm2/Global.h @@ -0,0 +1,1350 @@ +/********************************************************************************/ +/* */ +/* Internal Global Type Definitions */ +/* Written by Ken Goldman */ +/* IBM Thomas J. Watson Research Center */ +/* $Id: Global.h 1658 2021-01-22 23:14:01Z kgoldman $ */ +/* */ +/* Licenses and Notices */ +/* */ +/* 1. Copyright Licenses: */ +/* */ +/* - Trusted Computing Group (TCG) grants to the user of the source code in */ +/* this specification (the "Source Code") a worldwide, irrevocable, */ +/* nonexclusive, royalty free, copyright license to reproduce, create */ +/* derivative works, distribute, display and perform the Source Code and */ +/* derivative works thereof, and to grant others the rights granted herein. */ +/* */ +/* - The TCG grants to the user of the other parts of the specification */ +/* (other than the Source Code) the rights to reproduce, distribute, */ +/* display, and perform the specification solely for the purpose of */ +/* developing products based on such documents. */ +/* */ +/* 2. Source Code Distribution Conditions: */ +/* */ +/* - Redistributions of Source Code must retain the above copyright licenses, */ +/* this list of conditions and the following disclaimers. */ +/* */ +/* - Redistributions in binary form must reproduce the above copyright */ +/* licenses, this list of conditions and the following disclaimers in the */ +/* documentation and/or other materials provided with the distribution. */ +/* */ +/* 3. Disclaimers: */ +/* */ +/* - THE COPYRIGHT LICENSES SET FORTH ABOVE DO NOT REPRESENT ANY FORM OF */ +/* LICENSE OR WAIVER, EXPRESS OR IMPLIED, BY ESTOPPEL OR OTHERWISE, WITH */ +/* RESPECT TO PATENT RIGHTS HELD BY TCG MEMBERS (OR OTHER THIRD PARTIES) */ +/* THAT MAY BE NECESSARY TO IMPLEMENT THIS SPECIFICATION OR OTHERWISE. */ +/* Contact TCG Administration (admin@trustedcomputinggroup.org) for */ +/* information on specification licensing rights available through TCG */ +/* membership agreements. */ +/* */ +/* - THIS SPECIFICATION IS PROVIDED "AS IS" WITH NO EXPRESS OR IMPLIED */ +/* WARRANTIES WHATSOEVER, INCLUDING ANY WARRANTY OF MERCHANTABILITY OR */ +/* FITNESS FOR A PARTICULAR PURPOSE, ACCURACY, COMPLETENESS, OR */ +/* NONINFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS, OR ANY WARRANTY */ +/* OTHERWISE ARISING OUT OF ANY PROPOSAL, SPECIFICATION OR SAMPLE. */ +/* */ +/* - Without limitation, TCG and its members and licensors disclaim all */ +/* liability, including liability for infringement of any proprietary */ +/* rights, relating to use of information in this specification and to the */ +/* implementation of this specification, and TCG disclaims all liability for */ +/* cost of procurement of substitute goods or services, lost profits, loss */ +/* of use, loss of data or any incidental, consequential, direct, indirect, */ +/* or special damages, whether under contract, tort, warranty or otherwise, */ +/* arising in any way out of use or reliance upon this specification or any */ +/* information herein. */ +/* */ +/* (c) Copyright IBM Corp. and others, 2016 - 2021 */ +/* */ +/********************************************************************************/ + +/* 5.9 Global.h */ +/* 5.9.2 Includes */ + +#if !defined _TPM_H_ +#error "Should only be instanced in TPM.h" +#endif + +#ifndef GLOBAL_H +#define GLOBAL_H +_REDUCE_WARNING_LEVEL_(2) +#include <string.h> +#include <stddef.h> +_NORMAL_WARNING_LEVEL_ +#include "BackwardsCompatibility.h" // libtpms added + +#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" +#include "Utils.h" // libtpms added + +//** 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 + +// 5.9.3 Loaded Object Structures +// 5.9.3.1 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. + +/* 5.9.3.2 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 +{ +#if LITTLE_ENDIAN_TPM == YES /* libtpms added */ + 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 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(); + unsigned reserved : 14; //18-31) /* libtpms added */ +#endif /* libtpms added */ +#if BIG_ENDIAN_TPM == YES /* libtpms added begin */ + unsigned reserved : 14; //18-31) + unsigned external : 1; //17) SET when the object is loaded with + unsigned derivation : 1; //16) SET when the key is a derivation + unsigned occupied : 1; //15) SET when the slot is occupied. + unsigned privateExp : 1; //14) SET when the private exponent + unsigned isParent : 1; //13) SET if the key has the proper + unsigned firstBlock : 1; //12) SET if the first block of hash + unsigned ticketSafe : 1; //11) SET if a ticket is safe to create + unsigned eventSeq : 1; //10) SET for an event sequence object + unsigned hashSeq : 1; //9) SET for a hash sequence object + unsigned hmacSeq : 1; //8) SET for an HMAC sequence object + unsigned stClear : 1; //7) SET for an stClear object + unsigned temporary : 1; //6) SET for a temporary object + unsigned primary : 1; //5) SET for a primary object + + unsigned evict : 1; //4) SET if the object is a platform or + unsigned spsHierarchy : 1; //3) SET f the object belongs to SPS + unsigned ppsHierarchy : 1; //2) SET if the object belongs to PPS + unsigned epsHierarchy : 1; //1) SET if the object belongs to EPS + unsigned publicOnly : 1; //0) SET if only the public portion of +#endif /* libtpms added end */ +} 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 + +/* 5.9.3.3 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 +#if ALG_RSA + privateExponent_t privateExponent; // Additional field for the private +#endif + 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. + + // libtpms added: SEED_COMPAT_LEVEL to use for deriving child keys + SEED_COMPAT_LEVEL seedCompatLevel; + // libtpms added: OBJECT lies in NVRAM; to avoid that it needs different number + // of bytes on 32 bit and 64 bit architectures, we need to make sure it's the + // same size; simple padding at the end works here + UINT8 _pad[3]; +} OBJECT; + +/* 5.9.3.4 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)]; + +/* 5.9.3.5 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)]; + +/* 5.9.4 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)) + +/* 5.9.5 Active Session Context */ +/* 5.9.5.1 Description */ +/* The structures in this section define the internal structure of a session context. */ +/* 5.9.5.2 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 +{ +#if LITTLE_ENDIAN_TPM == YES /* libtpms added */ + 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. + unsigned _reserved : 18; //15-32 /* libtpms added */ +#endif /* libtpms added */ +#if BIG_ENDIAN_TPM == YES /* libtpms added begin */ + unsigned _reserved : 18; //15-32 + unsigned isTemplateSet : 1; //14) SET if the templateHash needs to be + unsigned nvWrittenState : 1; //13) SET if TPMA_NV_WRITTEN is required to + unsigned checkNvWritten : 1; //12) SET if the TPMA_NV_WRITTEN attribute + unsigned includeAuth : 1; //11) This attribute is SET when the + unsigned isLockoutBound : 1; //10) SET if the session is bound to + unsigned isDaBound : 1; //9) SET if the bind entity had noDA CLEAR. + unsigned isTrialPolicy : 1; //8) SET if the policy session is created + unsigned isPPRequired : 1; //7) SET if physical presence is required to + unsigned isPasswordNeeded : 1; //6) SET if a password authValue is required + unsigned isAuthValueNeeded : 1; //5) SET if the authValue is required for + unsigned isCpHashDefined : 1; //4) SET if the cpHash has been defined + unsigned isBound : 1; //3) SET if the session is bound to with an + unsigned isAudit : 1; //2) SET if the session is used for audit + unsigned isPolicy : 1; //1) SET if the session may only be used +#endif /* libtpms added end */ +} SESSION_ATTRIBUTES; + +/* 5.9.5.3 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)]; + +/* 5.9.7 PCR */ +/* 5.9.7.1 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; + +/* 5.9.6.2 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_unused; /* libtpms: renamed field since not used and not initialized */ + TPM2B_DIGEST policy[NUM_POLICY_PCR_GROUP]; +} PCR_POLICY; +#endif + +/* 5.9.6.3 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; + +/* 5.9.7 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; + +/* 5.9.8 NV */ +/* 5.9.8.1 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; + +/* 5.9.8.2 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; + +/* 5.9.8.3 NV_PIN */ +/* This structure deals with the possible endianness 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; + +/* 5.9.9 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 + +/* 5.9.10 RAM Global Values */ +/* 5.9.10.1 Description */ +/* The values in this section are only extant in RAM or ROM as constant values. */ +/* 5.9.10.2 Crypto Self-Test Values */ +EXTERN ALGORITHM_VECTOR g_implementedAlgorithms; +EXTERN ALGORITHM_VECTOR g_toTest; + +/* 5.9.10.3 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); + +/* 5.9.10.4 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; + +/* 5.9.10.5 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; + +/* 5.9.10.6 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 + +/* 5.9.10.7 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; + +/* 5.9.10.8 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; + +/* 5.9.10.9 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; + +/* 5.9.10.10 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; + +/* 5.9.10.11 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; + +/* 5.9.10.12 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) + +/* 5.9.10.13 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) + +/* 5.9.10.14 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 +#define TPM_SU_STATE_MASK ~(PRE_STARTUP_FLAG | STARTUP_LOCALITY_3) // libtpms added +#if USE_DA_USED + +/* 5.9.10.15 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 */ + +/* This global is set to FALSE on startup (after a decision has been made on whether to increment + the failedTries or not). On a first attempt to access a DA protected object: this global is set + to 1, the orderlyState is set to SU_DA_USED, committed to NV and the command execution returns + with RC_RETRY (without exposing any information on the DA attempt). */ +EXTERN BOOL g_daUsed; +#endif + +/* 5.9.10.16 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; +/* 5.9.10.17 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; + +/* 5.9.10.18 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; + +/* 5.9.10.19 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; + +/* 5.9.10.20 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; + +/* 5.9.10.21 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. + +/* 5.9.11.2 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; + // SEED_COMPAT_LEVELs related to creation time of seeds + SEED_COMPAT_LEVEL EPSeedCompatLevel; // libtpms added begin + SEED_COMPAT_LEVEL SPSeedCompatLevel; + SEED_COMPAT_LEVEL PPSeedCompatLevel; // libtpms added end + // 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; + +/* 5.9.11.3 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 + +#ifndef __ACT_DISABLED // libtpms added +#error ACT not supported in ORDERLY_DATA! + // 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; +#endif // libtpms added +} 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; + +/* 5.9.11.4 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; + +#ifndef __ACT_DISABLED // libtpms added + //***************************************************************************** + // ACT + //***************************************************************************** +#define DefineActPolicySpace(N) TPMT_HA act_##N; + FOR_EACH_ACT(DefineActPolicySpace) + +#endif // libtpms added +} STATE_CLEAR_DATA; +EXTERN STATE_CLEAR_DATA gc; + +/* 5.9.11.5 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 + SEED_COMPAT_LEVEL nullSeedCompatLevel; // libtpms added + // 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; + + // libtpms added begin +/* The s_ContextSlotMask masks CONTEXT_SLOT values; this variable can have + * only two valid values, 0xff or 0xffff. The former is used to simulate + * a CONTEXT_SLOT defined as UINT8, the latter is used for the CONTEXT_SLOT + * when it is a UINT16. The original TPM 2 code uses a cast to CONTEXT_SLOT + * to truncate larger values and has been modified to use CONTEXT_SLOT_MASKED + * to achieve the same effect with the above two values. + * + * Using CONTEXT_SLOT_MASKED we make sure that when we write values into + * gr.contextArray that these values are properly masked/truncated so that + * when we read values from gr.contextArray that we don't have to mask + * them again. + * + * s_ContextSlotMask may only be initialized to 0xff when resuming an older + * state from the time when CONTEXT_SLOT was UINT8, otherwise it must be set + * to 0xffff. We set it to 0xffff in SessionStartup(SU_CLEAR) and to be + * able to save the TPM state really early (and restore it) also in + * TPM_Manufacture(). + */ +EXTERN CONTEXT_SLOT s_ContextSlotMask; +#define CONTEXT_SLOT_MASKED(val) ((CONTEXT_SLOT)(val) & s_ContextSlotMask) // libtpms added end + +/* 5.9.12 NV Layout */ +/* The NV data organization is */ +/* a) a PERSISTENT_DATA structure */ +/* b) a STATE_RESET_DATA structure */ +/* c) a STATE_CLEAR_DATA structure */ +/* d) an ORDERLY_DATA structure */ +/* e) the user defined NV index space */ + +/* libtpms added: to put certain data structure at fixed offsets + * to give the ones below some room to expand + */ +#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 TPM2_ROUNDUP(NV_ORDERLY_DATA + sizeof(ORDERLY_DATA),\ + 1024) /* libtpms added */ +#define NV_USER_DYNAMIC (NV_INDEX_RAM_DATA + sizeof(s_indexOrderlyRam)) +#define NV_USER_DYNAMIC_END NV_MEMORY_SIZE + +/* 5.9.13 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)) +#if 0 /* libtpms added */ +typedef struct _COMMAND_FLAGS_ +{ +#if LITTLE_ENDIAN_TPM == YES /* libtpms added */ + 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. + unsigned reserved : 31; //2-31) /* libtpms added begin */ +#endif +#if BIG_ENDIAN_TPM == YES + unsigned reserved : 31; //2-31) + unsigned trialPolicy : 1; //1) If SET, one of the handles references a +#endif /* libtpms added end */ +} COMMAND_FLAGS; +#endif /* libtpms added */ + +/* 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 + +// 5.9.14 From CryptTest.c +// This structure contains the self-test state values for the cryptographic modules. +EXTERN CRYPTO_SELF_TEST_STATE g_cryptoSelfTestState; + +/* 5.9.15 From Manufacture.c */ +EXTERN BOOL g_manufactured; +/* 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; + +/* 5.9.16 Private data */ +#if defined SESSION_PROCESS_C || defined GLOBAL_C || defined MANUFACTURE_C +/* From SessionProcess.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 */ +#if 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 + +/* 5.9.16.2 From DA.c */ +#if defined DA_C || defined GLOBAL_C || defined MANUFACTURE_C + +/* From DA.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 + +/* 5.9.16.3 From NV.c */ + +#if defined NV_C || defined GLOBAL_C + +/* From NV.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 + +/* 5.9.16.4 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 + +/* 5.9.17.5 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 + +/* 5.9.16.6 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 + +/* 5.9.16.7 From IoBuffers.c */ + +#if defined IO_BUFFER_C || defined GLOBAL_C + +/* The value of s_actionIoAllocation is the number of UINT64 values allocated. It is used to set the + pointer for the response structure. */ +EXTERN UINT64 s_actionIoBuffer[768]; // action I/O buffer +EXTERN UINT32 s_actionIoAllocation; // number of UIN64 allocated for the action input + // structure +#endif // MEMORY_LIB_C + +/* 5.9.16.8 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 isn't 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 || 1 +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; + +/* 5.9.16.9 From CommandCodeAttributes.c */ + +extern const TPMA_CC s_ccAttr[]; +extern const COMMAND_ATTRIBUTES s_commandAttributes[]; + +#endif // GLOBAL_H |