/* Microsoft Reference Implementation for TPM 2.0 * * The copyright in this software is being made available under the BSD License, * included below. This software may be subject to other third party and * contributor rights, including patent rights, and no such rights are granted * under this license. * * Copyright (c) Microsoft Corporation * * All rights reserved. * * BSD License * * Redistribution and use in source and binary forms, with or without modification, * are permitted provided that the following conditions are met: * * Redistributions of source code must retain the above copyright notice, this list * of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright notice, this * list of conditions and the following disclaimer in the documentation and/or * other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS IS"" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ //** Includes #include "Tpm.h" #include "Object_spt_fp.h" //** Local Functions //*** GetIV2BSize() // Get the size of TPM2B_IV in canonical form that will be append to the start of // the sensitive data. It includes both size of size field and size of iv data static UINT16 GetIV2BSize( OBJECT *protector // IN: the protector handle ) { TPM_ALG_ID symAlg; UINT16 keyBits; // Determine the symmetric algorithm and size of key if(protector == NULL) { // Use the context encryption algorithm and key size symAlg = CONTEXT_ENCRYPT_ALG; keyBits = CONTEXT_ENCRYPT_KEY_BITS; } else { symAlg = protector->publicArea.parameters.asymDetail.symmetric.algorithm; keyBits = protector->publicArea.parameters.asymDetail.symmetric.keyBits.sym; } // The IV size is a UINT16 size field plus the block size of the symmetric // algorithm return sizeof(UINT16) + CryptGetSymmetricBlockSize(symAlg, keyBits); } //*** ComputeProtectionKeyParms() // This function retrieves the symmetric protection key parameters for // the sensitive data // The parameters retrieved from this function include encryption algorithm, // key size in bit, and a TPM2B_SYM_KEY containing the key material as well as // the key size in bytes // This function is used for any action that requires encrypting or decrypting of // the sensitive area of an object or a credential blob // /*(See part 1 specification) KDF for generating the protection key material: KDFa(hashAlg, seed, "STORAGE", Name, NULL , bits) where hashAlg for a Primary Object, an algorithm chosen by the TPM vendor for derivations from Primary Seeds. For all other objects, the nameAlg of the object's parent. seed for a Primary Object in the Platform Hierarchy, the PPS. For Primary Objects in either Storage or Endorsement Hierarchy, the SPS. For Temporary Objects, the context encryption seed. For all other objects, the symmetric seed value in the sensitive area of the object's parent. STORAGE label to differentiate use of KDFa() (see 4.7) Name the Name of the object being encrypted bits the number of bits required for a symmetric key and IV */ // Return Type: void static void ComputeProtectionKeyParms( OBJECT *protector, // IN: the protector object TPM_ALG_ID hashAlg, // IN: hash algorithm for KDFa TPM2B *name, // IN: name of the object TPM2B *seedIn, // IN: optional seed for duplication blob. // For non duplication blob, this // parameter should be NULL TPM_ALG_ID *symAlg, // OUT: the symmetric algorithm UINT16 *keyBits, // OUT: the symmetric key size in bits TPM2B_SYM_KEY *symKey // OUT: the symmetric key ) { const TPM2B *seed = seedIn; // Determine the algorithms for the KDF and the encryption/decryption // For TPM_RH_NULL, using context settings if(protector == NULL) { // Use the context encryption algorithm and key size *symAlg = CONTEXT_ENCRYPT_ALG; symKey->t.size = CONTEXT_ENCRYPT_KEY_BYTES; *keyBits = CONTEXT_ENCRYPT_KEY_BITS; } else { TPMT_SYM_DEF_OBJECT *symDef; symDef = &protector->publicArea.parameters.asymDetail.symmetric; *symAlg = symDef->algorithm; *keyBits = symDef->keyBits.sym; symKey->t.size = (*keyBits + 7) / 8; } // Get seed for KDF if(seed == NULL) seed = GetSeedForKDF(protector); // KDFa to generate symmetric key and IV value CryptKDFa(hashAlg, seed, STORAGE_KEY, name, NULL, symKey->t.size * 8, symKey->t.buffer, NULL, FALSE); return; } //*** ComputeOuterIntegrity() // The sensitive area parameter is a buffer that holds a space for // the integrity value and the marshaled sensitive area. The caller should // skip over the area set aside for the integrity value // and compute the hash of the remainder of the object. // The size field of sensitive is in unmarshaled form and the // sensitive area contents is an array of bytes. /*(See part 1 specification) KDFa(hashAlg, seed, "INTEGRITY", NULL, NULL , bits) (38) where hashAlg for a Primary Object, the nameAlg of the object. For all other objects the nameAlg of the object's parent. seed for a Primary Object in the Platform Hierarchy, the PPS. For Primary Objects in either Storage or Endorsement Hierarchy, the SPS. For a Temporary Object, the context encryption key. For all other objects, the symmetric seed value in the sensitive area of the object's parent. "INTEGRITY" a value used to differentiate the uses of the KDF. bits the number of bits in the digest produced by hashAlg. Key is then used in the integrity computation. HMACnameAlg(HMACkey, encSensitive || Name ) where HMACnameAlg() the HMAC function using nameAlg of the object's parent HMACkey value derived from the parent symmetric protection value encSensitive symmetrically encrypted sensitive area Name the Name of the object being protected */ // Return Type: void static void ComputeOuterIntegrity( TPM2B *name, // IN: the name of the object OBJECT *protector, // IN: the object that // provides protection. For an object, // it is a parent. For a credential, it // is the encrypt object. For // a Temporary Object, it is NULL TPMI_ALG_HASH hashAlg, // IN: algorithm to use for integrity TPM2B *seedIn, // IN: an external seed may be provided for // duplication blob. For non duplication // blob, this parameter should be NULL UINT32 sensitiveSize, // IN: size of the marshaled sensitive data BYTE *sensitiveData, // IN: sensitive area TPM2B_DIGEST *integrity // OUT: integrity ) { HMAC_STATE hmacState; TPM2B_DIGEST hmacKey; const TPM2B *seed = seedIn; // // Get seed for KDF if(seed == NULL) seed = GetSeedForKDF(protector); // Determine the HMAC key bits hmacKey.t.size = CryptHashGetDigestSize(hashAlg); // KDFa to generate HMAC key CryptKDFa(hashAlg, seed, INTEGRITY_KEY, NULL, NULL, hmacKey.t.size * 8, hmacKey.t.buffer, NULL, FALSE); // Start HMAC and get the size of the digest which will become the integrity integrity->t.size = CryptHmacStart2B(&hmacState, hashAlg, &hmacKey.b); // Adding the marshaled sensitive area to the integrity value CryptDigestUpdate(&hmacState.hashState, sensitiveSize, sensitiveData); // Adding name CryptDigestUpdate2B(&hmacState.hashState, name); // Compute HMAC CryptHmacEnd2B(&hmacState, &integrity->b); return; } //*** ComputeInnerIntegrity() // This function computes the integrity of an inner wrap static void ComputeInnerIntegrity( TPM_ALG_ID hashAlg, // IN: hash algorithm for inner wrap TPM2B *name, // IN: the name of the object UINT16 dataSize, // IN: the size of sensitive data BYTE *sensitiveData, // IN: sensitive data TPM2B_DIGEST *integrity // OUT: inner integrity ) { HASH_STATE hashState; // // Start hash and get the size of the digest which will become the integrity integrity->t.size = CryptHashStart(&hashState, hashAlg); // Adding the marshaled sensitive area to the integrity value CryptDigestUpdate(&hashState, dataSize, sensitiveData); // Adding name CryptDigestUpdate2B(&hashState, name); // Compute hash CryptHashEnd2B(&hashState, &integrity->b); return; } //*** ProduceInnerIntegrity() // This function produces an inner integrity for regular private, credential or // duplication blob // It requires the sensitive data being marshaled to the innerBuffer, with the // leading bytes reserved for integrity hash. It assume the sensitive data // starts at address (innerBuffer + integrity size). // This function integrity at the beginning of the inner buffer // It returns the total size of buffer with the inner wrap static UINT16 ProduceInnerIntegrity( TPM2B *name, // IN: the name of the object TPM_ALG_ID hashAlg, // IN: hash algorithm for inner wrap UINT16 dataSize, // IN: the size of sensitive data, excluding the // leading integrity buffer size BYTE *innerBuffer // IN/OUT: inner buffer with sensitive data in // it. At input, the leading bytes of this // buffer is reserved for integrity ) { BYTE *sensitiveData; // pointer to the sensitive data TPM2B_DIGEST integrity; UINT16 integritySize; BYTE *buffer; // Auxiliary buffer pointer // // sensitiveData points to the beginning of sensitive data in innerBuffer integritySize = sizeof(UINT16) + CryptHashGetDigestSize(hashAlg); sensitiveData = innerBuffer + integritySize; ComputeInnerIntegrity(hashAlg, name, dataSize, sensitiveData, &integrity); // Add integrity at the beginning of inner buffer buffer = innerBuffer; TPM2B_DIGEST_Marshal(&integrity, &buffer, NULL); return dataSize + integritySize; } //*** CheckInnerIntegrity() // This function check integrity of inner blob // Return Type: TPM_RC // TPM_RC_INTEGRITY if the outer blob integrity is bad // unmarshal errors unmarshal errors while unmarshaling integrity static TPM_RC CheckInnerIntegrity( TPM2B *name, // IN: the name of the object TPM_ALG_ID hashAlg, // IN: hash algorithm for inner wrap UINT16 dataSize, // IN: the size of sensitive data, including the // leading integrity buffer size BYTE *innerBuffer // IN/OUT: inner buffer with sensitive data in // it ) { TPM_RC result; TPM2B_DIGEST integrity; TPM2B_DIGEST integrityToCompare; BYTE *buffer; // Auxiliary buffer pointer INT32 size; // // Unmarshal integrity buffer = innerBuffer; size = (INT32)dataSize; result = TPM2B_DIGEST_Unmarshal(&integrity, &buffer, &size); if(result == TPM_RC_SUCCESS) { // Compute integrity to compare ComputeInnerIntegrity(hashAlg, name, (UINT16)size, buffer, &integrityToCompare); // Compare outer blob integrity if(!MemoryEqual2B(&integrity.b, &integrityToCompare.b)) result = TPM_RC_INTEGRITY; } return result; } //** Public Functions //*** AdjustAuthSize() // This function will validate that the input authValue is no larger than the // digestSize for the nameAlg. It will then pad with zeros to the size of the // digest. BOOL AdjustAuthSize( TPM2B_AUTH *auth, // IN/OUT: value to adjust TPMI_ALG_HASH nameAlg // IN: ) { UINT16 digestSize; // // If there is no nameAlg, then this is a LoadExternal and the authVale can // be any size up to the maximum allowed by the implementation digestSize = (nameAlg == TPM_ALG_NULL) ? sizeof(TPMU_HA) : CryptHashGetDigestSize(nameAlg); if(digestSize < MemoryRemoveTrailingZeros(auth)) return FALSE; else if(digestSize > auth->t.size) MemoryPad2B(&auth->b, digestSize); auth->t.size = digestSize; return TRUE; } //*** AreAttributesForParent() // This function is called by create, load, and import functions. // // Note: The 'isParent' attribute is SET when an object is loaded and it has // attributes that are suitable for a parent object. // Return Type: BOOL // TRUE(1) properties are those of a parent // FALSE(0) properties are not those of a parent BOOL ObjectIsParent( OBJECT *parentObject // IN: parent handle ) { return parentObject->attributes.isParent; } //*** CreateChecks() // Attribute checks that are unique to creation. // Return Type: TPM_RC // TPM_RC_ATTRIBUTES sensitiveDataOrigin is not consistent with the // object type // other returns from PublicAttributesValidation() TPM_RC CreateChecks( OBJECT *parentObject, TPMT_PUBLIC *publicArea, UINT16 sensitiveDataSize ) { TPMA_OBJECT attributes = publicArea->objectAttributes; TPM_RC result = TPM_RC_SUCCESS; // // If the caller indicates that they have provided the data, then make sure that // they have provided some data. if((!IS_ATTRIBUTE(attributes, TPMA_OBJECT, sensitiveDataOrigin)) && (sensitiveDataSize == 0)) return TPM_RCS_ATTRIBUTES; // For an ordinary object, data can only be provided when sensitiveDataOrigin // is CLEAR if((parentObject != NULL) && (IS_ATTRIBUTE(attributes, TPMA_OBJECT, sensitiveDataOrigin)) && (sensitiveDataSize != 0)) return TPM_RCS_ATTRIBUTES; switch(publicArea->type) { case TPM_ALG_KEYEDHASH: // if this is a data object (sign == decrypt == CLEAR) then the // TPM cannot be the data source. if(!IS_ATTRIBUTE(attributes, TPMA_OBJECT, sign) && !IS_ATTRIBUTE(attributes, TPMA_OBJECT, decrypt) && IS_ATTRIBUTE(attributes, TPMA_OBJECT, sensitiveDataOrigin)) result = TPM_RC_ATTRIBUTES; // comment out the next line in order to prevent a fixedTPM derivation // parent // break; case TPM_ALG_SYMCIPHER: // A restricted key symmetric key (SYMCIPHER and KEYEDHASH) // must have sensitiveDataOrigin SET unless it has fixedParent and // fixedTPM CLEAR. if(IS_ATTRIBUTE(attributes, TPMA_OBJECT, restricted)) if(!IS_ATTRIBUTE(attributes, TPMA_OBJECT, sensitiveDataOrigin)) if(IS_ATTRIBUTE(attributes, TPMA_OBJECT, fixedParent) || IS_ATTRIBUTE(attributes, TPMA_OBJECT, fixedTPM)) result = TPM_RCS_ATTRIBUTES; break; default: // Asymmetric keys cannot have the sensitive portion provided if(!IS_ATTRIBUTE(attributes, TPMA_OBJECT, sensitiveDataOrigin)) result = TPM_RCS_ATTRIBUTES; break; } if(TPM_RC_SUCCESS == result) { result = PublicAttributesValidation(parentObject, publicArea); } return result; } //*** SchemeChecks // This function is called by TPM2_LoadExternal() and PublicAttributesValidation(). // This function validates the schemes in the public area of an object. // Return Type: TPM_RC // TPM_RC_HASH non-duplicable storage key and its parent have different // name algorithm // TPM_RC_KDF incorrect KDF specified for decrypting keyed hash object // TPM_RC_KEY invalid key size values in an asymmetric key public area // TPM_RCS_SCHEME inconsistent attributes 'decrypt', 'sign', 'restricted' // and key's scheme ID; or hash algorithm is inconsistent // with the scheme ID for keyed hash object // TPM_RC_SYMMETRIC a storage key with no symmetric algorithm specified; or // non-storage key with symmetric algorithm different from // TPM_ALG_NULL TPM_RC SchemeChecks( OBJECT *parentObject, // IN: parent (null if primary seed) TPMT_PUBLIC *publicArea // IN: public area of the object ) { TPMT_SYM_DEF_OBJECT *symAlgs = NULL; TPM_ALG_ID scheme = TPM_ALG_NULL; TPMA_OBJECT attributes = publicArea->objectAttributes; TPMU_PUBLIC_PARMS *parms = &publicArea->parameters; // switch(publicArea->type) { case TPM_ALG_SYMCIPHER: symAlgs = &parms->symDetail.sym; // If this is a decrypt key, then only the block cipher modes (not // SMAC) are valid. TPM_ALG_NULL is OK too. If this is a 'sign' key, // then any mode that got through the unmarshaling is OK. if(IS_ATTRIBUTE(attributes, TPMA_OBJECT, decrypt) && !CryptSymModeIsValid(symAlgs->mode.sym, TRUE)) return TPM_RCS_SCHEME; break; case TPM_ALG_KEYEDHASH: scheme = parms->keyedHashDetail.scheme.scheme; // if both sign and decrypt if(IS_ATTRIBUTE(attributes, TPMA_OBJECT, sign) == IS_ATTRIBUTE(attributes, TPMA_OBJECT, decrypt)) { // if both sign and decrypt are set or clear, then need // TPM_ALG_NULL as scheme if(scheme != TPM_ALG_NULL) return TPM_RCS_SCHEME; } else if(IS_ATTRIBUTE(attributes, TPMA_OBJECT, sign) && scheme != TPM_ALG_HMAC) return TPM_RCS_SCHEME; else if(IS_ATTRIBUTE(attributes, TPMA_OBJECT, decrypt)) { if(scheme != TPM_ALG_XOR) return TPM_RCS_SCHEME; // If this is a derivation parent, then the KDF needs to be // SP800-108 for this implementation. This is the only derivation // supported by this implementation. Other implementations could // support additional schemes. There is no default. if(IS_ATTRIBUTE(attributes, TPMA_OBJECT, restricted)) { if(parms->keyedHashDetail.scheme.details.xor.kdf != TPM_ALG_KDF1_SP800_108) return TPM_RCS_SCHEME; // Must select a digest. if(CryptHashGetDigestSize( parms->keyedHashDetail.scheme.details.xor.hashAlg) == 0) return TPM_RCS_HASH; } } break; default: // handling for asymmetric scheme = parms->asymDetail.scheme.scheme; symAlgs = &parms->asymDetail.symmetric; // if the key is both sign and decrypt, then the scheme must be // TPM_ALG_NULL because there is no way to specify both a sign and a // decrypt scheme in the key. if(IS_ATTRIBUTE(attributes, TPMA_OBJECT, sign) == IS_ATTRIBUTE(attributes, TPMA_OBJECT, decrypt)) { // scheme must be TPM_ALG_NULL if(scheme != TPM_ALG_NULL) return TPM_RCS_SCHEME; } else if(IS_ATTRIBUTE(attributes, TPMA_OBJECT, sign)) { // If this is a signing key, see if it has a signing scheme if(CryptIsAsymSignScheme(publicArea->type, scheme)) { // if proper signing scheme then it needs a proper hash if(parms->asymDetail.scheme.details.anySig.hashAlg == TPM_ALG_NULL) return TPM_RCS_SCHEME; } else { // signing key that does not have a proper signing scheme. // This is OK if the key is not restricted and its scheme // is TPM_ALG_NULL if(IS_ATTRIBUTE(attributes, TPMA_OBJECT, restricted) || scheme != TPM_ALG_NULL) return TPM_RCS_SCHEME; } } else if(IS_ATTRIBUTE(attributes, TPMA_OBJECT, decrypt)) { if(IS_ATTRIBUTE(attributes, TPMA_OBJECT, restricted)) { // for a restricted decryption key (a parent), scheme // is required to be TPM_ALG_NULL if(scheme != TPM_ALG_NULL) return TPM_RCS_SCHEME; } else { // For an unrestricted decryption key, the scheme has to // be a valid scheme or TPM_ALG_NULL if(scheme != TPM_ALG_NULL && !CryptIsAsymDecryptScheme(publicArea->type, scheme)) return TPM_RCS_SCHEME; } } if(!IS_ATTRIBUTE(attributes, TPMA_OBJECT, restricted) || !IS_ATTRIBUTE(attributes, TPMA_OBJECT, decrypt)) { // For an asymmetric key that is not a parent, the symmetric // algorithms must be TPM_ALG_NULL if(symAlgs->algorithm != TPM_ALG_NULL) return TPM_RCS_SYMMETRIC; } // Special checks for an ECC key #if ALG_ECC if(publicArea->type == TPM_ALG_ECC) { TPM_ECC_CURVE curveID; const TPMT_ECC_SCHEME *curveScheme; curveID = publicArea->parameters.eccDetail.curveID; curveScheme = CryptGetCurveSignScheme(curveID); // The curveId must be valid or the unmarshaling is busted. pAssert(curveScheme != NULL); // If the curveID requires a specific scheme, then the key must // select the same scheme if(curveScheme->scheme != TPM_ALG_NULL) { TPMS_ECC_PARMS *ecc = &publicArea->parameters.eccDetail; if(scheme != curveScheme->scheme) return TPM_RCS_SCHEME; // The scheme can allow any hash, or not... if(curveScheme->details.anySig.hashAlg != TPM_ALG_NULL && (ecc->scheme.details.anySig.hashAlg != curveScheme->details.anySig.hashAlg)) return TPM_RCS_SCHEME; } // For now, the KDF must be TPM_ALG_NULL if(publicArea->parameters.eccDetail.kdf.scheme != TPM_ALG_NULL) return TPM_RCS_KDF; } #endif break; } // If this is a restricted decryption key with symmetric algorithms, then it // is an ordinary parent (not a derivation parent). It needs to specific // symmetric algorithms other than TPM_ALG_NULL if(symAlgs != NULL && IS_ATTRIBUTE(attributes, TPMA_OBJECT, restricted) && IS_ATTRIBUTE(attributes, TPMA_OBJECT, decrypt)) { if(symAlgs->algorithm == TPM_ALG_NULL) return TPM_RCS_SYMMETRIC; #if 0 //?? // This next check is under investigation. Need to see if it will break Windows // before it is enabled. If it does not, then it should be default because a // the mode used with a parent is always CFB and Part 2 indicates as much. if(symAlgs->mode.sym != TPM_ALG_CFB) return TPM_RCS_MODE; #endif // If this parent is not duplicable, then the symmetric algorithms // (encryption and hash) must match those of its parent if(IS_ATTRIBUTE(attributes, TPMA_OBJECT, fixedParent) && (parentObject != NULL)) { if(publicArea->nameAlg != parentObject->publicArea.nameAlg) return TPM_RCS_HASH; if(!MemoryEqual(symAlgs, &parentObject->publicArea.parameters, sizeof(TPMT_SYM_DEF_OBJECT))) return TPM_RCS_SYMMETRIC; } } return TPM_RC_SUCCESS; } //*** PublicAttributesValidation() // This function validates the values in the public area of an object. // This function is used in the processing of TPM2_Create, TPM2_CreatePrimary, // TPM2_CreateLoaded(), TPM2_Load(), TPM2_Import(), and TPM2_LoadExternal(). // For TPM2_Import() this is only used if the new parent has fixedTPM SET. For // TPM2_LoadExternal(), this is not used for a public-only key // Return Type: TPM_RC // TPM_RC_ATTRIBUTES 'fixedTPM', 'fixedParent', or 'encryptedDuplication' // attributes are inconsistent between themselves or with // those of the parent object; // inconsistent 'restricted', 'decrypt' and 'sign' // attributes; // attempt to inject sensitive data for an asymmetric key; // attempt to create a symmetric cipher key that is not // a decryption key // TPM_RC_HASH nameAlg is TPM_ALG_NULL // TPM_RC_SIZE 'authPolicy' size does not match digest size of the name // algorithm in 'publicArea' // other returns from SchemeChecks() TPM_RC PublicAttributesValidation( OBJECT *parentObject, // IN: input parent object TPMT_PUBLIC *publicArea // IN: public area of the object ) { TPMA_OBJECT attributes = publicArea->objectAttributes; TPMA_OBJECT parentAttributes = TPMA_ZERO_INITIALIZER(); // if(parentObject != NULL) parentAttributes = parentObject->publicArea.objectAttributes; if(publicArea->nameAlg == TPM_ALG_NULL) return TPM_RCS_HASH; // If there is an authPolicy, it needs to be the size of the digest produced // by the nameAlg of the object if((publicArea->authPolicy.t.size != 0 && (publicArea->authPolicy.t.size != CryptHashGetDigestSize(publicArea->nameAlg)))) return TPM_RCS_SIZE; // If the parent is fixedTPM (including a Primary Object) the object must have // the same value for fixedTPM and fixedParent if(parentObject == NULL || IS_ATTRIBUTE(parentAttributes, TPMA_OBJECT, fixedTPM)) { if(IS_ATTRIBUTE(attributes, TPMA_OBJECT, fixedParent) != IS_ATTRIBUTE(attributes, TPMA_OBJECT, fixedTPM)) return TPM_RCS_ATTRIBUTES; } else { // The parent is not fixedTPM so the object can't be fixedTPM if(IS_ATTRIBUTE(attributes, TPMA_OBJECT, fixedTPM)) return TPM_RCS_ATTRIBUTES; } // See if sign and decrypt are the same if(IS_ATTRIBUTE(attributes, TPMA_OBJECT, sign) == IS_ATTRIBUTE(attributes, TPMA_OBJECT, decrypt)) { // a restricted key cannot have both SET or both CLEAR if(IS_ATTRIBUTE(attributes, TPMA_OBJECT, restricted)) return TPM_RC_ATTRIBUTES; // only a data object may have both sign and decrypt CLEAR // BTW, since we know that decrypt==sign, no need to check both if(publicArea->type != TPM_ALG_KEYEDHASH && !IS_ATTRIBUTE(attributes, TPMA_OBJECT, sign)) return TPM_RC_ATTRIBUTES; } // If the object can't be duplicated (directly or indirectly) then there // is no justification for having encryptedDuplication SET if(IS_ATTRIBUTE(attributes, TPMA_OBJECT, fixedTPM) && IS_ATTRIBUTE(attributes, TPMA_OBJECT, encryptedDuplication)) return TPM_RCS_ATTRIBUTES; // If a parent object has fixedTPM CLEAR, the child must have the // same encryptedDuplication value as its parent. // Primary objects are considered to have a fixedTPM parent (the seeds). if(parentObject != NULL && !IS_ATTRIBUTE(parentAttributes, TPMA_OBJECT, fixedTPM)) { if(IS_ATTRIBUTE(attributes, TPMA_OBJECT, encryptedDuplication) != IS_ATTRIBUTE(parentAttributes, TPMA_OBJECT, encryptedDuplication)) return TPM_RCS_ATTRIBUTES; } // Special checks for derived objects if((parentObject != NULL) && (parentObject->attributes.derivation == SET)) { // A derived object has the same settings for fixedTPM as its parent if(IS_ATTRIBUTE(attributes, TPMA_OBJECT, fixedTPM) != IS_ATTRIBUTE(parentAttributes, TPMA_OBJECT, fixedTPM)) return TPM_RCS_ATTRIBUTES; // A derived object is required to be fixedParent if(!IS_ATTRIBUTE(attributes, TPMA_OBJECT, fixedParent)) return TPM_RCS_ATTRIBUTES; } return SchemeChecks(parentObject, publicArea); } //*** FillInCreationData() // Fill in creation data for an object. // Return Type: void void FillInCreationData( TPMI_DH_OBJECT parentHandle, // IN: handle of parent TPMI_ALG_HASH nameHashAlg, // IN: name hash algorithm TPML_PCR_SELECTION *creationPCR, // IN: PCR selection TPM2B_DATA *outsideData, // IN: outside data TPM2B_CREATION_DATA *outCreation, // OUT: creation data for output TPM2B_DIGEST *creationDigest // OUT: creation digest ) { BYTE creationBuffer[sizeof(TPMS_CREATION_DATA)]; BYTE *buffer; HASH_STATE hashState; // // Fill in TPMS_CREATION_DATA in outCreation // Compute PCR digest PCRComputeCurrentDigest(nameHashAlg, creationPCR, &outCreation->creationData.pcrDigest); // Put back PCR selection list outCreation->creationData.pcrSelect = *creationPCR; // Get locality outCreation->creationData.locality = LocalityGetAttributes(_plat__LocalityGet()); outCreation->creationData.parentNameAlg = TPM_ALG_NULL; // If the parent is either a primary seed or TPM_ALG_NULL, then the Name // and QN of the parent are the parent's handle. if(HandleGetType(parentHandle) == TPM_HT_PERMANENT) { buffer = &outCreation->creationData.parentName.t.name[0]; outCreation->creationData.parentName.t.size = TPM_HANDLE_Marshal(&parentHandle, &buffer, NULL); // For a primary or temporary object, the parent name (a handle) and the // parent's QN are the same outCreation->creationData.parentQualifiedName = outCreation->creationData.parentName; } else // Regular object { OBJECT *parentObject = HandleToObject(parentHandle); // // Set name algorithm outCreation->creationData.parentNameAlg = parentObject->publicArea.nameAlg; // Copy parent name outCreation->creationData.parentName = parentObject->name; // Copy parent qualified name outCreation->creationData.parentQualifiedName = parentObject->qualifiedName; } // Copy outside information outCreation->creationData.outsideInfo = *outsideData; // Marshal creation data to canonical form buffer = creationBuffer; outCreation->size = TPMS_CREATION_DATA_Marshal(&outCreation->creationData, &buffer, NULL); // Compute hash for creation field in public template creationDigest->t.size = CryptHashStart(&hashState, nameHashAlg); CryptDigestUpdate(&hashState, outCreation->size, creationBuffer); CryptHashEnd2B(&hashState, &creationDigest->b); return; } //*** GetSeedForKDF() // Get a seed for KDF. The KDF for encryption and HMAC key use the same seed. const TPM2B * GetSeedForKDF( OBJECT *protector // IN: the protector handle ) { // Get seed for encryption key. Use input seed if provided. // Otherwise, using protector object's seedValue. TPM_RH_NULL is the only // exception that we may not have a loaded object as protector. In such a // case, use nullProof as seed. if(protector == NULL) return &gr.nullProof.b; else return &protector->sensitive.seedValue.b; } //*** ProduceOuterWrap() // This function produce outer wrap for a buffer containing the sensitive data. // It requires the sensitive data being marshaled to the outerBuffer, with the // leading bytes reserved for integrity hash. If iv is used, iv space should // be reserved at the beginning of the buffer. It assumes the sensitive data // starts at address (outerBuffer + integrity size [+ iv size]). // This function performs: // 1. Add IV before sensitive area if required // 2. encrypt sensitive data, if iv is required, encrypt by iv. otherwise, // encrypted by a NULL iv // 3. add HMAC integrity at the beginning of the buffer // It returns the total size of blob with outer wrap UINT16 ProduceOuterWrap( OBJECT *protector, // IN: The handle of the object that provides // protection. For object, it is parent // handle. For credential, it is the handle // of encrypt object. TPM2B *name, // IN: the name of the object TPM_ALG_ID hashAlg, // IN: hash algorithm for outer wrap TPM2B *seed, // IN: an external seed may be provided for // duplication blob. For non duplication // blob, this parameter should be NULL BOOL useIV, // IN: indicate if an IV is used UINT16 dataSize, // IN: the size of sensitive data, excluding the // leading integrity buffer size or the // optional iv size BYTE *outerBuffer // IN/OUT: outer buffer with sensitive data in // it ) { TPM_ALG_ID symAlg; UINT16 keyBits; TPM2B_SYM_KEY symKey; TPM2B_IV ivRNG; // IV from RNG TPM2B_IV *iv = NULL; UINT16 ivSize = 0; // size of iv area, including the size field BYTE *sensitiveData; // pointer to the sensitive data TPM2B_DIGEST integrity; UINT16 integritySize; BYTE *buffer; // Auxiliary buffer pointer // // Compute the beginning of sensitive data. The outer integrity should // always exist if this function is called to make an outer wrap integritySize = sizeof(UINT16) + CryptHashGetDigestSize(hashAlg); sensitiveData = outerBuffer + integritySize; // If iv is used, adjust the pointer of sensitive data and add iv before it if(useIV) { ivSize = GetIV2BSize(protector); // Generate IV from RNG. The iv data size should be the total IV area // size minus the size of size field ivRNG.t.size = ivSize - sizeof(UINT16); CryptRandomGenerate(ivRNG.t.size, ivRNG.t.buffer); // Marshal IV to buffer buffer = sensitiveData; TPM2B_IV_Marshal(&ivRNG, &buffer, NULL); // adjust sensitive data starting after IV area sensitiveData += ivSize; // Use iv for encryption iv = &ivRNG; } // Compute symmetric key parameters for outer buffer encryption ComputeProtectionKeyParms(protector, hashAlg, name, seed, &symAlg, &keyBits, &symKey); // Encrypt inner buffer in place CryptSymmetricEncrypt(sensitiveData, symAlg, keyBits, symKey.t.buffer, iv, TPM_ALG_CFB, dataSize, sensitiveData); // Compute outer integrity. Integrity computation includes the optional IV // area ComputeOuterIntegrity(name, protector, hashAlg, seed, dataSize + ivSize, outerBuffer + integritySize, &integrity); // Add integrity at the beginning of outer buffer buffer = outerBuffer; TPM2B_DIGEST_Marshal(&integrity, &buffer, NULL); // return the total size in outer wrap return dataSize + integritySize + ivSize; } //*** UnwrapOuter() // This function remove the outer wrap of a blob containing sensitive data // This function performs: // 1. check integrity of outer blob // 2. decrypt outer blob // // Return Type: TPM_RC // TPM_RCS_INSUFFICIENT error during sensitive data unmarshaling // TPM_RCS_INTEGRITY sensitive data integrity is broken // TPM_RCS_SIZE error during sensitive data unmarshaling // TPM_RCS_VALUE IV size for CFB does not match the encryption // algorithm block size TPM_RC UnwrapOuter( OBJECT *protector, // IN: The object that provides // protection. For object, it is parent // handle. For credential, it is the // encrypt object. TPM2B *name, // IN: the name of the object TPM_ALG_ID hashAlg, // IN: hash algorithm for outer wrap TPM2B *seed, // IN: an external seed may be provided for // duplication blob. For non duplication // blob, this parameter should be NULL. BOOL useIV, // IN: indicates if an IV is used UINT16 dataSize, // IN: size of sensitive data in outerBuffer, // including the leading integrity buffer // size, and an optional iv area BYTE *outerBuffer // IN/OUT: sensitive data ) { TPM_RC result; TPM_ALG_ID symAlg = TPM_ALG_NULL; TPM2B_SYM_KEY symKey; UINT16 keyBits = 0; TPM2B_IV ivIn; // input IV retrieved from input buffer TPM2B_IV *iv = NULL; BYTE *sensitiveData; // pointer to the sensitive data TPM2B_DIGEST integrityToCompare; TPM2B_DIGEST integrity; INT32 size; // // Unmarshal integrity sensitiveData = outerBuffer; size = (INT32)dataSize; result = TPM2B_DIGEST_Unmarshal(&integrity, &sensitiveData, &size); if(result == TPM_RC_SUCCESS) { // Compute integrity to compare ComputeOuterIntegrity(name, protector, hashAlg, seed, (UINT16)size, sensitiveData, &integrityToCompare); // Compare outer blob integrity if(!MemoryEqual2B(&integrity.b, &integrityToCompare.b)) return TPM_RCS_INTEGRITY; // Get the symmetric algorithm parameters used for encryption ComputeProtectionKeyParms(protector, hashAlg, name, seed, &symAlg, &keyBits, &symKey); // Retrieve IV if it is used if(useIV) { result = TPM2B_IV_Unmarshal(&ivIn, &sensitiveData, &size); if(result == TPM_RC_SUCCESS) { // The input iv size for CFB must match the encryption algorithm // block size if(ivIn.t.size != CryptGetSymmetricBlockSize(symAlg, keyBits)) result = TPM_RC_VALUE; else iv = &ivIn; } } } // If no errors, decrypt private in place. Since this function uses CFB, // CryptSymmetricDecrypt() will not return any errors. It may fail but it will // not return an error. if(result == TPM_RC_SUCCESS) CryptSymmetricDecrypt(sensitiveData, symAlg, keyBits, symKey.t.buffer, iv, TPM_ALG_CFB, (UINT16)size, sensitiveData); return result; } //*** MarshalSensitive() // This function is used to marshal a sensitive area. Among other things, it // adjusts the size of the authValue to be no smaller than the digest of // 'nameAlg' // Returns the size of the marshaled area. static UINT16 MarshalSensitive( OBJECT *parent, // IN: the object parent (optional) BYTE *buffer, // OUT: receiving buffer TPMT_SENSITIVE *sensitive, // IN: the sensitive area to marshal TPMI_ALG_HASH nameAlg // IN: ) { BYTE *sizeField = buffer; // saved so that size can be // marshaled after it is known UINT16 retVal; // // Pad the authValue if needed MemoryPad2B(&sensitive->authValue.b, CryptHashGetDigestSize(nameAlg)); buffer += 2; // Marshal the structure #if ALG_RSA // If the sensitive size is the special case for a prime in the type if((sensitive->sensitive.rsa.t.size & RSA_prime_flag) > 0) { UINT16 sizeSave = sensitive->sensitive.rsa.t.size; // // Turn off the flag that indicates that the sensitive->sensitive contains // the CRT form of the exponent. sensitive->sensitive.rsa.t.size &= ~(RSA_prime_flag); // If the parent isn't fixedTPM, then truncate the sensitive data to be // the size of the prime. Otherwise, leave it at the current size which // is the full CRT size. if(parent == NULL || !IS_ATTRIBUTE(parent->publicArea.objectAttributes, TPMA_OBJECT, fixedTPM)) sensitive->sensitive.rsa.t.size /= 5; retVal = TPMT_SENSITIVE_Marshal(sensitive, &buffer, NULL); // Restore the flag and the size. sensitive->sensitive.rsa.t.size = sizeSave; } else #endif retVal = TPMT_SENSITIVE_Marshal(sensitive, &buffer, NULL); // Marshal the size retVal = (UINT16)(retVal + UINT16_Marshal(&retVal, &sizeField, NULL)); return retVal; } //*** SensitiveToPrivate() // This function prepare the private blob for off the chip storage // The operations in this function: // 1. marshal TPM2B_SENSITIVE structure into the buffer of TPM2B_PRIVATE // 2. apply encryption to the sensitive area. // 3. apply outer integrity computation. void SensitiveToPrivate( TPMT_SENSITIVE *sensitive, // IN: sensitive structure TPM2B_NAME *name, // IN: the name of the object OBJECT *parent, // IN: The parent object TPM_ALG_ID nameAlg, // IN: hash algorithm in public area. This // parameter is used when parentHandle is // NULL, in which case the object is // temporary. TPM2B_PRIVATE *outPrivate // OUT: output private structure ) { BYTE *sensitiveData; // pointer to the sensitive data UINT16 dataSize; // data blob size TPMI_ALG_HASH hashAlg; // hash algorithm for integrity UINT16 integritySize; UINT16 ivSize; // pAssert(name != NULL && name->t.size != 0); // Find the hash algorithm for integrity computation if(parent == NULL) { // For Temporary Object, using self name algorithm hashAlg = nameAlg; } else { // Otherwise, using parent's name algorithm hashAlg = parent->publicArea.nameAlg; } // Starting of sensitive data without wrappers sensitiveData = outPrivate->t.buffer; // Compute the integrity size integritySize = sizeof(UINT16) + CryptHashGetDigestSize(hashAlg); // Reserve space for integrity sensitiveData += integritySize; // Get iv size ivSize = GetIV2BSize(parent); // Reserve space for iv sensitiveData += ivSize; // Marshal the sensitive area including authValue size adjustments. dataSize = MarshalSensitive(parent, sensitiveData, sensitive, nameAlg); //Produce outer wrap, including encryption and HMAC outPrivate->t.size = ProduceOuterWrap(parent, &name->b, hashAlg, NULL, TRUE, dataSize, outPrivate->t.buffer); return; } //*** PrivateToSensitive() // Unwrap an input private area; check the integrity; decrypt and retrieve data // to a sensitive structure. // The operations in this function: // 1. check the integrity HMAC of the input private area // 2. decrypt the private buffer // 3. unmarshal TPMT_SENSITIVE structure into the buffer of TPMT_SENSITIVE // Return Type: TPM_RC // TPM_RCS_INTEGRITY if the private area integrity is bad // TPM_RC_SENSITIVE unmarshal errors while unmarshaling TPMS_ENCRYPT // from input private // TPM_RCS_SIZE error during sensitive data unmarshaling // TPM_RCS_VALUE outer wrapper does not have an iV of the correct // size TPM_RC PrivateToSensitive( TPM2B *inPrivate, // IN: input private structure TPM2B *name, // IN: the name of the object OBJECT *parent, // IN: parent object TPM_ALG_ID nameAlg, // IN: hash algorithm in public area. It is // passed separately because we only pass // name, rather than the whole public area // of the object. This parameter is used in // the following two cases: 1. primary // objects. 2. duplication blob with inner // wrap. In other cases, this parameter // will be ignored TPMT_SENSITIVE *sensitive // OUT: sensitive structure ) { TPM_RC result; BYTE *buffer; INT32 size; BYTE *sensitiveData; // pointer to the sensitive data UINT16 dataSize; UINT16 dataSizeInput; TPMI_ALG_HASH hashAlg; // hash algorithm for integrity UINT16 integritySize; UINT16 ivSize; // // Make sure that name is provided pAssert(name != NULL && name->size != 0); // Find the hash algorithm for integrity computation // For Temporary Object (parent == NULL) use self name algorithm; // Otherwise, using parent's name algorithm hashAlg = (parent == NULL) ? nameAlg : parent->publicArea.nameAlg; // unwrap outer result = UnwrapOuter(parent, name, hashAlg, NULL, TRUE, inPrivate->size, inPrivate->buffer); if(result != TPM_RC_SUCCESS) return result; // Compute the inner integrity size. integritySize = sizeof(UINT16) + CryptHashGetDigestSize(hashAlg); // Get iv size ivSize = GetIV2BSize(parent); // The starting of sensitive data and data size without outer wrapper sensitiveData = inPrivate->buffer + integritySize + ivSize; dataSize = inPrivate->size - integritySize - ivSize; // Unmarshal input data size buffer = sensitiveData; size = (INT32)dataSize; result = UINT16_Unmarshal(&dataSizeInput, &buffer, &size); if(result == TPM_RC_SUCCESS) { if((dataSizeInput + sizeof(UINT16)) != dataSize) result = TPM_RC_SENSITIVE; else { // Unmarshal sensitive buffer to sensitive structure result = TPMT_SENSITIVE_Unmarshal(sensitive, &buffer, &size); if(result != TPM_RC_SUCCESS || size != 0) { result = TPM_RC_SENSITIVE; } } } return result; } //*** SensitiveToDuplicate() // This function prepare the duplication blob from the sensitive area. // The operations in this function: // 1. marshal TPMT_SENSITIVE structure into the buffer of TPM2B_PRIVATE // 2. apply inner wrap to the sensitive area if required // 3. apply outer wrap if required void SensitiveToDuplicate( TPMT_SENSITIVE *sensitive, // IN: sensitive structure TPM2B *name, // IN: the name of the object OBJECT *parent, // IN: The new parent object TPM_ALG_ID nameAlg, // IN: hash algorithm in public area. It // is passed separately because we // only pass name, rather than the // whole public area of the object. TPM2B *seed, // IN: the external seed. If external // seed is provided with size of 0, // no outer wrap should be applied // to duplication blob. TPMT_SYM_DEF_OBJECT *symDef, // IN: Symmetric key definition. If the // symmetric key algorithm is NULL, // no inner wrap should be applied. TPM2B_DATA *innerSymKey, // IN/OUT: a symmetric key may be // provided to encrypt the inner // wrap of a duplication blob. May // be generated here if needed. TPM2B_PRIVATE *outPrivate // OUT: output private structure ) { BYTE *sensitiveData; // pointer to the sensitive data TPMI_ALG_HASH outerHash = TPM_ALG_NULL;// The hash algorithm for outer wrap TPMI_ALG_HASH innerHash = TPM_ALG_NULL;// The hash algorithm for inner wrap UINT16 dataSize; // data blob size BOOL doInnerWrap = FALSE; BOOL doOuterWrap = FALSE; // // Make sure that name is provided pAssert(name != NULL && name->size != 0); // Make sure symDef and innerSymKey are not NULL pAssert(symDef != NULL && innerSymKey != NULL); // Starting of sensitive data without wrappers sensitiveData = outPrivate->t.buffer; // Find out if inner wrap is required if(symDef->algorithm != TPM_ALG_NULL) { doInnerWrap = TRUE; // Use self nameAlg as inner hash algorithm innerHash = nameAlg; // Adjust sensitive data pointer sensitiveData += sizeof(UINT16) + CryptHashGetDigestSize(innerHash); } // Find out if outer wrap is required if(seed->size != 0) { doOuterWrap = TRUE; // Use parent nameAlg as outer hash algorithm outerHash = parent->publicArea.nameAlg; // Adjust sensitive data pointer sensitiveData += sizeof(UINT16) + CryptHashGetDigestSize(outerHash); } // Marshal sensitive area dataSize = MarshalSensitive(NULL, sensitiveData, sensitive, nameAlg); // Apply inner wrap for duplication blob. It includes both integrity and // encryption if(doInnerWrap) { BYTE *innerBuffer = NULL; BOOL symKeyInput = TRUE; innerBuffer = outPrivate->t.buffer; // Skip outer integrity space if(doOuterWrap) innerBuffer += sizeof(UINT16) + CryptHashGetDigestSize(outerHash); dataSize = ProduceInnerIntegrity(name, innerHash, dataSize, innerBuffer); // Generate inner encryption key if needed if(innerSymKey->t.size == 0) { innerSymKey->t.size = (symDef->keyBits.sym + 7) / 8; CryptRandomGenerate(innerSymKey->t.size, innerSymKey->t.buffer); // TPM generates symmetric encryption. Set the flag to FALSE symKeyInput = FALSE; } else { // assume the input key size should matches the symmetric definition pAssert(innerSymKey->t.size == (symDef->keyBits.sym + 7) / 8); } // Encrypt inner buffer in place CryptSymmetricEncrypt(innerBuffer, symDef->algorithm, symDef->keyBits.sym, innerSymKey->t.buffer, NULL, TPM_ALG_CFB, dataSize, innerBuffer); // If the symmetric encryption key is imported, clear the buffer for // output if(symKeyInput) innerSymKey->t.size = 0; } // Apply outer wrap for duplication blob. It includes both integrity and // encryption if(doOuterWrap) { dataSize = ProduceOuterWrap(parent, name, outerHash, seed, FALSE, dataSize, outPrivate->t.buffer); } // Data size for output outPrivate->t.size = dataSize; return; } //*** DuplicateToSensitive() // Unwrap a duplication blob. Check the integrity, decrypt and retrieve data // to a sensitive structure. // The operations in this function: // 1. check the integrity HMAC of the input private area // 2. decrypt the private buffer // 3. unmarshal TPMT_SENSITIVE structure into the buffer of TPMT_SENSITIVE // // Return Type: TPM_RC // TPM_RC_INSUFFICIENT unmarshaling sensitive data from 'inPrivate' failed // TPM_RC_INTEGRITY 'inPrivate' data integrity is broken // TPM_RC_SIZE unmarshaling sensitive data from 'inPrivate' failed TPM_RC DuplicateToSensitive( TPM2B *inPrivate, // IN: input private structure TPM2B *name, // IN: the name of the object OBJECT *parent, // IN: the parent TPM_ALG_ID nameAlg, // IN: hash algorithm in public area. TPM2B *seed, // IN: an external seed may be provided. // If external seed is provided with // size of 0, no outer wrap is // applied TPMT_SYM_DEF_OBJECT *symDef, // IN: Symmetric key definition. If the // symmetric key algorithm is NULL, // no inner wrap is applied TPM2B *innerSymKey, // IN: a symmetric key may be provided // to decrypt the inner wrap of a // duplication blob. TPMT_SENSITIVE *sensitive // OUT: sensitive structure ) { TPM_RC result; BYTE *buffer; INT32 size; BYTE *sensitiveData; // pointer to the sensitive data UINT16 dataSize; UINT16 dataSizeInput; // // Make sure that name is provided pAssert(name != NULL && name->size != 0); // Make sure symDef and innerSymKey are not NULL pAssert(symDef != NULL && innerSymKey != NULL); // Starting of sensitive data sensitiveData = inPrivate->buffer; dataSize = inPrivate->size; // Find out if outer wrap is applied if(seed->size != 0) { // Use parent nameAlg as outer hash algorithm TPMI_ALG_HASH outerHash = parent->publicArea.nameAlg; result = UnwrapOuter(parent, name, outerHash, seed, FALSE, dataSize, sensitiveData); if(result != TPM_RC_SUCCESS) return result; // Adjust sensitive data pointer and size sensitiveData += sizeof(UINT16) + CryptHashGetDigestSize(outerHash); dataSize -= sizeof(UINT16) + CryptHashGetDigestSize(outerHash); } // Find out if inner wrap is applied if(symDef->algorithm != TPM_ALG_NULL) { // assume the input key size matches the symmetric definition pAssert(innerSymKey->size == (symDef->keyBits.sym + 7) / 8); // Decrypt inner buffer in place CryptSymmetricDecrypt(sensitiveData, symDef->algorithm, symDef->keyBits.sym, innerSymKey->buffer, NULL, TPM_ALG_CFB, dataSize, sensitiveData); // Check inner integrity result = CheckInnerIntegrity(name, nameAlg, dataSize, sensitiveData); if(result != TPM_RC_SUCCESS) return result; // Adjust sensitive data pointer and size sensitiveData += sizeof(UINT16) + CryptHashGetDigestSize(nameAlg); dataSize -= sizeof(UINT16) + CryptHashGetDigestSize(nameAlg); } // Unmarshal input data size buffer = sensitiveData; size = (INT32)dataSize; result = UINT16_Unmarshal(&dataSizeInput, &buffer, &size); if(result == TPM_RC_SUCCESS) { if((dataSizeInput + sizeof(UINT16)) != dataSize) result = TPM_RC_SIZE; else { // Unmarshal sensitive buffer to sensitive structure result = TPMT_SENSITIVE_Unmarshal(sensitive, &buffer, &size); // if the results is OK make sure that all the data was unmarshaled if(result == TPM_RC_SUCCESS && size != 0) result = TPM_RC_SIZE; } } return result; } //*** SecretToCredential() // This function prepare the credential blob from a secret (a TPM2B_DIGEST) // The operations in this function: // 1. marshal TPM2B_DIGEST structure into the buffer of TPM2B_ID_OBJECT // 2. encrypt the private buffer, excluding the leading integrity HMAC area // 3. compute integrity HMAC and append to the beginning of the buffer. // 4. Set the total size of TPM2B_ID_OBJECT buffer void SecretToCredential( TPM2B_DIGEST *secret, // IN: secret information TPM2B *name, // IN: the name of the object TPM2B *seed, // IN: an external seed. OBJECT *protector, // IN: the protector TPM2B_ID_OBJECT *outIDObject // OUT: output credential ) { BYTE *buffer; // Auxiliary buffer pointer BYTE *sensitiveData; // pointer to the sensitive data TPMI_ALG_HASH outerHash; // The hash algorithm for outer wrap UINT16 dataSize; // data blob size // pAssert(secret != NULL && outIDObject != NULL); // use protector's name algorithm as outer hash ???? outerHash = protector->publicArea.nameAlg; // Marshal secret area to credential buffer, leave space for integrity sensitiveData = outIDObject->t.credential + sizeof(UINT16) + CryptHashGetDigestSize(outerHash); // Marshal secret area buffer = sensitiveData; dataSize = TPM2B_DIGEST_Marshal(secret, &buffer, NULL); // Apply outer wrap outIDObject->t.size = ProduceOuterWrap(protector, name, outerHash, seed, FALSE, dataSize, outIDObject->t.credential); return; } //*** CredentialToSecret() // Unwrap a credential. Check the integrity, decrypt and retrieve data // to a TPM2B_DIGEST structure. // The operations in this function: // 1. check the integrity HMAC of the input credential area // 2. decrypt the credential buffer // 3. unmarshal TPM2B_DIGEST structure into the buffer of TPM2B_DIGEST // // Return Type: TPM_RC // TPM_RC_INSUFFICIENT error during credential unmarshaling // TPM_RC_INTEGRITY credential integrity is broken // TPM_RC_SIZE error during credential unmarshaling // TPM_RC_VALUE IV size does not match the encryption algorithm // block size TPM_RC CredentialToSecret( TPM2B *inIDObject, // IN: input credential blob TPM2B *name, // IN: the name of the object TPM2B *seed, // IN: an external seed. OBJECT *protector, // IN: the protector TPM2B_DIGEST *secret // OUT: secret information ) { TPM_RC result; BYTE *buffer; INT32 size; TPMI_ALG_HASH outerHash; // The hash algorithm for outer wrap BYTE *sensitiveData; // pointer to the sensitive data UINT16 dataSize; // // use protector's name algorithm as outer hash outerHash = protector->publicArea.nameAlg; // Unwrap outer, a TPM_RC_INTEGRITY error may be returned at this point result = UnwrapOuter(protector, name, outerHash, seed, FALSE, inIDObject->size, inIDObject->buffer); if(result == TPM_RC_SUCCESS) { // Compute the beginning of sensitive data sensitiveData = inIDObject->buffer + sizeof(UINT16) + CryptHashGetDigestSize(outerHash); dataSize = inIDObject->size - (sizeof(UINT16) + CryptHashGetDigestSize(outerHash)); // Unmarshal secret buffer to TPM2B_DIGEST structure buffer = sensitiveData; size = (INT32)dataSize; result = TPM2B_DIGEST_Unmarshal(secret, &buffer, &size); // If there were no other unmarshaling errors, make sure that the // expected amount of data was recovered if(result == TPM_RC_SUCCESS && size != 0) return TPM_RC_SIZE; } return result; } //*** MemoryRemoveTrailingZeros() // This function is used to adjust the length of an authorization value. // It adjusts the size of the TPM2B so that it does not include octets // at the end of the buffer that contain zero. // The function returns the number of non-zero octets in the buffer. UINT16 MemoryRemoveTrailingZeros( TPM2B_AUTH *auth // IN/OUT: value to adjust ) { while((auth->t.size > 0) && (auth->t.buffer[auth->t.size - 1] == 0)) auth->t.size--; return auth->t.size; } //*** SetLabelAndContext() // This function sets the label and context for a derived key. It is possible // that 'label' or 'context' can end up being an Empty Buffer. TPM_RC SetLabelAndContext( TPMS_DERIVE *labelContext, // IN/OUT: the recovered label and // context TPM2B_SENSITIVE_DATA *sensitive // IN: the sensitive data ) { TPMS_DERIVE sensitiveValue; TPM_RC result; INT32 size; BYTE *buff; // // Unmarshal a TPMS_DERIVE from the TPM2B_SENSITIVE_DATA buffer // If there is something to unmarshal... if(sensitive->t.size != 0) { size = sensitive->t.size; buff = sensitive->t.buffer; result = TPMS_DERIVE_Unmarshal(&sensitiveValue, &buff, &size); if(result != TPM_RC_SUCCESS) return result; // If there was a label in the public area leave it there, otherwise, copy // the new value if(labelContext->label.t.size == 0) MemoryCopy2B(&labelContext->label.b, &sensitiveValue.label.b, sizeof(labelContext->label.t.buffer)); // if there was a context string in publicArea, it overrides if(labelContext->context.t.size == 0) MemoryCopy2B(&labelContext->context.b, &sensitiveValue.context.b, sizeof(labelContext->label.t.buffer)); } return TPM_RC_SUCCESS; } //*** UnmarshalToPublic() // Support function to unmarshal the template. This is used because the // Input may be a TPMT_TEMPLATE and that structure does not have the same // size as a TPMT_PUBLIC because of the difference between the 'unique' and // 'seed' fields. // If 'derive' is not NULL, then the 'seed' field is assumed to contain // a 'label' and 'context' that are unmarshaled into 'derive'. TPM_RC UnmarshalToPublic( TPMT_PUBLIC *tOut, // OUT: output TPM2B_TEMPLATE *tIn, // IN: BOOL derivation, // IN: indicates if this is for a derivation TPMS_DERIVE *labelContext// OUT: label and context if derivation ) { BYTE *buffer = tIn->t.buffer; INT32 size = tIn->t.size; TPM_RC result; // // make sure that tOut is zeroed so that there are no remnants from previous // uses MemorySet(tOut, 0, sizeof(TPMT_PUBLIC)); // Unmarshal the components of the TPMT_PUBLIC up to the unique field result = TPMI_ALG_PUBLIC_Unmarshal(&tOut->type, &buffer, &size); if(result != TPM_RC_SUCCESS) return result; result = TPMI_ALG_HASH_Unmarshal(&tOut->nameAlg, &buffer, &size, FALSE); if(result != TPM_RC_SUCCESS) return result; result = TPMA_OBJECT_Unmarshal(&tOut->objectAttributes, &buffer, &size); if(result != TPM_RC_SUCCESS) return result; result = TPM2B_DIGEST_Unmarshal(&tOut->authPolicy, &buffer, &size); if(result != TPM_RC_SUCCESS) return result; result = TPMU_PUBLIC_PARMS_Unmarshal(&tOut->parameters, &buffer, &size, tOut->type); if(result != TPM_RC_SUCCESS) return result; // Now unmarshal a TPMS_DERIVE if this is for derivation if(derivation) result = TPMS_DERIVE_Unmarshal(labelContext, &buffer, &size); else // otherwise, unmarshal a TPMU_PUBLIC_ID result = TPMU_PUBLIC_ID_Unmarshal(&tOut->unique, &buffer, &size, tOut->type); // Make sure the template was used up if((result == TPM_RC_SUCCESS) && (size != 0)) result = TPM_RC_SIZE; return result; } //*** ObjectSetExternal() // Set the external attributes for an object. void ObjectSetExternal( OBJECT *object ) { object->attributes.external = SET; }