summaryrefslogtreecommitdiffstats
path: root/src/tpm2/Global.h
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/tpm2/Global.h1350
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