| // This file was extracted from the TCG Published |
| // Trusted Platform Module Library |
| // Part 4: Supporting Routines |
| // Family "2.0" |
| // Level 00 Revision 01.16 |
| // October 30, 2014 |
| |
| #include "InternalRoutines.h" |
| #include "Object_spt_fp.h" |
| #include "Platform.h" |
| // |
| // |
| // |
| // Local Functions |
| // |
| // EqualCryptSet() |
| // |
| // Check if the crypto sets in two public areas are equal |
| // |
| // Error Returns Meaning |
| // |
| // TPM_RC_ASYMMETRIC mismatched parameters |
| // TPM_RC_HASH mismatched name algorithm |
| // TPM_RC_TYPE mismatched type |
| // |
| static TPM_RC |
| EqualCryptSet( |
| TPMT_PUBLIC *publicArea1, // IN: public area 1 |
| TPMT_PUBLIC *publicArea2 // IN: public area 2 |
| ) |
| { |
| UINT16 size1; |
| UINT16 size2; |
| BYTE params1[sizeof(TPMU_PUBLIC_PARMS)]; |
| BYTE params2[sizeof(TPMU_PUBLIC_PARMS)]; |
| BYTE *buffer; |
| INT32 bufferSize; |
| // Compare name hash |
| if(publicArea1->nameAlg != publicArea2->nameAlg) |
| return TPM_RC_HASH; |
| // Compare algorithm |
| if(publicArea1->type != publicArea2->type) |
| return TPM_RC_TYPE; |
| // TPMU_PUBLIC_PARMS field should be identical |
| buffer = params1; |
| bufferSize = sizeof(TPMU_PUBLIC_PARMS); |
| size1 = TPMU_PUBLIC_PARMS_Marshal(&publicArea1->parameters, &buffer, |
| &bufferSize, publicArea1->type); |
| buffer = params2; |
| bufferSize = sizeof(TPMU_PUBLIC_PARMS); |
| size2 = TPMU_PUBLIC_PARMS_Marshal(&publicArea2->parameters, &buffer, |
| &bufferSize, publicArea2->type); |
| if(size1 != size2 || !MemoryEqual(params1, params2, size1)) |
| return TPM_RC_ASYMMETRIC; |
| return TPM_RC_SUCCESS; |
| } |
| // |
| // |
| // 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 |
| // |
| // Return Value Meaning |
| // |
| static UINT16 |
| GetIV2BSize( |
| TPM_HANDLE protectorHandle // IN: the protector handle |
| ) |
| { |
| OBJECT *protector = NULL; // Pointer to the protector object |
| TPM_ALG_ID symAlg; |
| // |
| UINT16 keyBits; |
| // Determine the symmetric algorithm and size of key |
| if(protectorHandle == TPM_RH_NULL) |
| { |
| // Use the context encryption algorithm and key size |
| symAlg = CONTEXT_ENCRYPT_ALG; |
| keyBits = CONTEXT_ENCRYPT_KEY_BITS; |
| } |
| else |
| { |
| protector = ObjectGet(protectorHandle); |
| 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 |
| // |
| static void |
| ComputeProtectionKeyParms( |
| TPM_HANDLE protectorHandle, // IN: the protector handle |
| TPM_ALG_ID hashAlg, // IN: hash algorithm for KDFa |
| TPM2B_NAME *name, // IN: name of the object |
| TPM2B_SEED *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 |
| ) |
| { |
| TPM2B_SEED *seed = NULL; |
| OBJECT *protector = NULL; // Pointer to the protector |
| // Determine the algorithms for the KDF and the encryption/decryption |
| // For TPM_RH_NULL, using context settings |
| if(protectorHandle == TPM_RH_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; |
| protector = ObjectGet(protectorHandle); |
| symDef = &protector->publicArea.parameters.asymDetail.symmetric; |
| *symAlg = symDef->algorithm; |
| *keyBits= symDef->keyBits.sym; |
| symKey->t.size = (*keyBits + 7) / 8; |
| } |
| // Get seed for KDF |
| seed = GetSeedForKDF(protectorHandle, seedIn); |
| // KDFa to generate symmetric key and IV value |
| KDFa(hashAlg, (TPM2B *)seed, "STORAGE", (TPM2B *)name, NULL, |
| symKey->t.size * 8, symKey->t.buffer, NULL); |
| 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. |
| // |
| static void |
| ComputeOuterIntegrity( |
| TPM2B_NAME *name, // IN: the name of the object |
| TPM_HANDLE protectorHandle, // IN: The handle of the object that |
| // provides protection. For object, it |
| // is parent handle. For credential, it |
| // is the handle of encrypt object. For |
| // a Temporary Object, it is TPM_RH_NULL |
| TPMI_ALG_HASH hashAlg, // IN: algorithm to use for integrity |
| TPM2B_SEED *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; |
| TPM2B_SEED *seed = NULL; |
| // Get seed for KDF |
| seed = GetSeedForKDF(protectorHandle, seedIn); |
| // Determine the HMAC key bits |
| hmacKey.t.size = CryptGetHashDigestSize(hashAlg); |
| // KDFa to generate HMAC key |
| KDFa(hashAlg, (TPM2B *)seed, "INTEGRITY", NULL, NULL, |
| hmacKey.t.size * 8, hmacKey.t.buffer, NULL); |
| // Start HMAC and get the size of the digest which will become the integrity |
| integrity->t.size = CryptStartHMAC2B(hashAlg, &hmacKey.b, &hmacState); |
| // Adding the marshaled sensitive area to the integrity value |
| CryptUpdateDigest(&hmacState, sensitiveSize, sensitiveData); |
| // Adding name |
| CryptUpdateDigest2B(&hmacState, (TPM2B *)name); |
| // Compute HMAC |
| CryptCompleteHMAC2B(&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 *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 = CryptStartHash(hashAlg, &hashState); |
| // Adding the marshaled sensitive area to the integrity value |
| CryptUpdateDigest(&hashState, dataSize, sensitiveData); |
| // Adding name |
| CryptUpdateDigest2B(&hashState, &name->b); |
| // Compute hash |
| CryptCompleteHash2B(&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 *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 |
| INT32 bufferSize; |
| // sensitiveData points to the beginning of sensitive data in innerBuffer |
| integritySize = sizeof(UINT16) + CryptGetHashDigestSize(hashAlg); |
| sensitiveData = innerBuffer + integritySize; |
| ComputeInnerIntegrity(hashAlg, name, dataSize, sensitiveData, &integrity); |
| // Add integrity at the beginning of inner buffer |
| buffer = innerBuffer; |
| bufferSize = sizeof(TPM2B_DIGEST); |
| TPM2B_DIGEST_Marshal(&integrity, &buffer, &bufferSize); |
| return dataSize + integritySize; |
| } |
| // |
| // |
| // CheckInnerIntegrity() |
| // |
| // This function check integrity of inner blob |
| // |
| // Error Returns Meaning |
| // |
| // TPM_RC_INTEGRITY if the outer blob integrity is bad |
| // unmarshal errors unmarshal errors while unmarshaling integrity |
| // |
| static TPM_RC |
| CheckInnerIntegrity( |
| TPM2B_NAME *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(!Memory2BEqual(&integrity.b, &integrityToCompare.b)) |
| result = TPM_RC_INTEGRITY; |
| } |
| return result; |
| } |
| // |
| // |
| // Public Functions |
| // |
| // AreAttributesForParent() |
| // |
| // This function is called by create, load, and import functions. |
| // |
| // Return Value Meaning |
| // |
| // TRUE properties are those of a parent |
| // FALSE properties are not those of a parent |
| // |
| BOOL |
| AreAttributesForParent( |
| OBJECT *parentObject // IN: parent handle |
| ) |
| { |
| // This function is only called when a parent is needed. Any |
| // time a "parent" is used, it must be authorized. When |
| // the authorization is checked, both the public and sensitive |
| // areas must be loaded. Just make sure... |
| pAssert(parentObject->attributes.publicOnly == CLEAR); |
| if(ObjectDataIsStorage(&parentObject->publicArea)) |
| return TRUE; |
| else |
| return FALSE; |
| } |
| // |
| // |
| // SchemeChecks() |
| // |
| // This function validates the schemes in the public area of an object. This function is called by |
| // TPM2_LoadExternal() and PublicAttributesValidation(). |
| // |
| // Error Returns Meaning |
| // |
| // TPM_RC_ASYMMETRIC non-duplicable storage key and its parent have different public |
| // parameters |
| // TPM_RC_ATTRIBUTES attempt to inject sensitive data for an asymmetric key; or attempt to |
| // create a symmetric cipher key that is not a decryption key |
| // 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_RC_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_TYPE unexpected object type; or non-duplicable storage key and its parent |
| // have different types |
| // |
| TPM_RC |
| SchemeChecks( |
| BOOL load, // IN: TRUE if load checks, FALSE if |
| // TPM2_Create() |
| TPMI_DH_OBJECT parentHandle, // IN: input parent handle |
| TPMT_PUBLIC *publicArea // IN: public area of the object |
| ) |
| { |
| // Checks for an asymmetric key |
| if(CryptIsAsymAlgorithm(publicArea->type)) |
| { |
| TPMT_ASYM_SCHEME *keyScheme; |
| keyScheme = &publicArea->parameters.asymDetail.scheme; |
| // An asymmetric key can't be injected |
| // This is only checked when creating an object |
| if(!load && (publicArea->objectAttributes.sensitiveDataOrigin == CLEAR)) |
| return TPM_RC_ATTRIBUTES; |
| if(load && !CryptAreKeySizesConsistent(publicArea)) |
| return TPM_RC_KEY; |
| // Keys that are both signing and decrypting must have TPM_ALG_NULL |
| // for scheme |
| if( publicArea->objectAttributes.sign == SET |
| && publicArea->objectAttributes.decrypt == SET |
| && keyScheme->scheme != TPM_ALG_NULL) |
| return TPM_RC_SCHEME; |
| // A restrict sign key must have a non-NULL scheme |
| if( publicArea->objectAttributes.restricted == SET |
| && publicArea->objectAttributes.sign == SET |
| && keyScheme->scheme == TPM_ALG_NULL) |
| return TPM_RC_SCHEME; |
| // Keys must have a valid sign or decrypt scheme, or a TPM_ALG_NULL |
| // scheme |
| // NOTE: The unmarshaling for a public area will unmarshal based on the |
| // object type. If the type is an RSA key, then only RSA schemes will be |
| // allowed because a TPMI_ALG_RSA_SCHEME will be unmarshaled and it |
| // consists only of those algorithms that are allowed with an RSA key. |
| // This means that there is no need to again make sure that the algorithm |
| // is compatible with the object type. |
| if( keyScheme->scheme != TPM_ALG_NULL |
| && ( ( publicArea->objectAttributes.sign == SET |
| && !CryptIsSignScheme(keyScheme->scheme) |
| ) |
| || ( publicArea->objectAttributes.decrypt == SET |
| && !CryptIsDecryptScheme(keyScheme->scheme) |
| ) |
| ) |
| ) |
| return TPM_RC_SCHEME; |
| // Special checks for an ECC key |
| #ifdef TPM_ALG_ECC |
| if(publicArea->type == TPM_ALG_ECC) |
| { |
| TPM_ECC_CURVE curveID = publicArea->parameters.eccDetail.curveID; |
| const TPMT_ECC_SCHEME *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) |
| { |
| if(keyScheme->scheme != curveScheme->scheme) |
| return TPM_RC_SCHEME; |
| // The scheme can allow any hash, or not... |
| if( curveScheme->details.anySig.hashAlg != TPM_ALG_NULL |
| && ( keyScheme->details.anySig.hashAlg |
| != curveScheme->details.anySig.hashAlg |
| ) |
| ) |
| return TPM_RC_SCHEME; |
| } |
| // For now, the KDF must be TPM_ALG_NULL |
| if(publicArea->parameters.eccDetail.kdf.scheme != TPM_ALG_NULL) |
| return TPM_RC_KDF; |
| } |
| #endif |
| // Checks for a storage key (restricted + decryption) |
| if( publicArea->objectAttributes.restricted == SET |
| && publicArea->objectAttributes.decrypt == SET) |
| { |
| // A storage key must have a valid protection key |
| if( publicArea->parameters.asymDetail.symmetric.algorithm |
| == TPM_ALG_NULL) |
| return TPM_RC_SYMMETRIC; |
| // A storage key must have a null scheme |
| if(publicArea->parameters.asymDetail.scheme.scheme != TPM_ALG_NULL) |
| return TPM_RC_SCHEME; |
| // A storage key must match its parent algorithms unless |
| // it is duplicable or a primary (including Temporary Primary Objects) |
| if( HandleGetType(parentHandle) != TPM_HT_PERMANENT |
| && publicArea->objectAttributes.fixedParent == SET |
| ) |
| { |
| // If the object to be created is a storage key, and is fixedParent, |
| // its crypto set has to match its parent's crypto set. TPM_RC_TYPE, |
| // TPM_RC_HASH or TPM_RC_ASYMMETRIC may be returned at this point |
| return EqualCryptSet(publicArea, |
| &(ObjectGet(parentHandle)->publicArea)); |
| } |
| } |
| else |
| { |
| // Non-storage keys must have TPM_ALG_NULL for the symmetric algorithm |
| if( publicArea->parameters.asymDetail.symmetric.algorithm |
| != TPM_ALG_NULL) |
| return TPM_RC_SYMMETRIC; |
| }// End of asymmetric decryption key checks |
| } // End of asymmetric checks |
| // Check for bit attributes |
| else if(publicArea->type == TPM_ALG_KEYEDHASH) |
| { |
| TPMT_KEYEDHASH_SCHEME *scheme |
| = &publicArea->parameters.keyedHashDetail.scheme; |
| // If both sign and decrypt are set the scheme must be TPM_ALG_NULL |
| // and the scheme selected when the key is used. |
| // If neither sign nor decrypt is set, the scheme must be TPM_ALG_NULL |
| // because this is a data object. |
| if( publicArea->objectAttributes.sign |
| == publicArea->objectAttributes.decrypt) |
| { |
| if(scheme->scheme != TPM_ALG_NULL) |
| return TPM_RC_SCHEME; |
| return TPM_RC_SUCCESS; |
| } |
| // If this is a decryption key, make sure that is is XOR and that there |
| // is a KDF |
| else if(publicArea->objectAttributes.decrypt) |
| { |
| if( scheme->scheme != TPM_ALG_XOR |
| || scheme->details.xor_.hashAlg == TPM_ALG_NULL) |
| return TPM_RC_SCHEME; |
| if(scheme->details.xor_.kdf == TPM_ALG_NULL) |
| return TPM_RC_KDF; |
| return TPM_RC_SUCCESS; |
| } |
| // only supported signing scheme for keyedHash object is HMAC |
| if( scheme->scheme != TPM_ALG_HMAC |
| || scheme->details.hmac.hashAlg == TPM_ALG_NULL) |
| return TPM_RC_SCHEME; |
| // end of the checks for keyedHash |
| return TPM_RC_SUCCESS; |
| } |
| else if (publicArea->type == TPM_ALG_SYMCIPHER) |
| { |
| // Must be a decrypting key and may not be a signing key |
| if( publicArea->objectAttributes.decrypt == CLEAR |
| || publicArea->objectAttributes.sign == SET |
| ) |
| return TPM_RC_ATTRIBUTES; |
| } |
| else |
| return TPM_RC_TYPE; |
| return TPM_RC_SUCCESS; |
| } |
| // |
| // |
| // PublicAttributesValidation() |
| // |
| // This function validates the values in the public area of an object. This function is called by |
| // TPM2_Create(), TPM2_Load(), and TPM2_CreatePrimary() |
| // |
| // Error Returns Meaning |
| // |
| // TPM_RC_ASYMMETRIC non-duplicable storage key and its parent have different public |
| // parameters |
| // 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 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_RC_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_SIZE authPolicy size does not match digest size of the name algorithm in |
| // publicArea |
| // 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_TYPE unexpected object type; or non-duplicable storage key and its parent |
| // have different types |
| // |
| TPM_RC |
| PublicAttributesValidation( |
| BOOL load, // IN: TRUE if load checks, FALSE if |
| // TPM2_Create() |
| TPMI_DH_OBJECT parentHandle, // IN: input parent handle |
| TPMT_PUBLIC *publicArea // IN: public area of the object |
| ) |
| { |
| OBJECT *parentObject = NULL; |
| if(HandleGetType(parentHandle) != TPM_HT_PERMANENT) |
| parentObject = ObjectGet(parentHandle); |
| if (publicArea->nameAlg == TPM_ALG_NULL) |
| return TPM_RC_HASH; |
| // Check authPolicy digest consistency |
| if( publicArea->authPolicy.t.size != 0 |
| && ( publicArea->authPolicy.t.size |
| != CryptGetHashDigestSize(publicArea->nameAlg) |
| ) |
| ) |
| return TPM_RC_SIZE; |
| // If the parent is fixedTPM (including a Primary Object) the object must have |
| // the same value for fixedTPM and fixedParent |
| if( parentObject == NULL |
| || parentObject->publicArea.objectAttributes.fixedTPM == SET) |
| { |
| if( publicArea->objectAttributes.fixedParent |
| != publicArea->objectAttributes.fixedTPM |
| ) |
| return TPM_RC_ATTRIBUTES; |
| } |
| else |
| // The parent is not fixedTPM so the object can't be fixedTPM |
| if(publicArea->objectAttributes.fixedTPM == SET) |
| return TPM_RC_ATTRIBUTES; |
| // A restricted object cannot be both sign and decrypt and it can't be neither |
| // sign nor decrypt |
| if ( publicArea->objectAttributes.restricted == SET |
| && ( publicArea->objectAttributes.decrypt |
| == publicArea->objectAttributes.sign) |
| ) |
| return TPM_RC_ATTRIBUTES; |
| // A fixedTPM object can not have encryptedDuplication bit SET |
| if( publicArea->objectAttributes.fixedTPM == SET |
| && publicArea->objectAttributes.encryptedDuplication == SET) |
| return TPM_RC_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 |
| && parentObject->publicArea.objectAttributes.fixedTPM == CLEAR) |
| // Get here if parent is not fixed TPM |
| && ( publicArea->objectAttributes.encryptedDuplication |
| != parentObject->publicArea.objectAttributes.encryptedDuplication |
| ) |
| ) |
| return TPM_RC_ATTRIBUTES; |
| return SchemeChecks(load, parentHandle, publicArea); |
| } |
| // |
| // |
| // FillInCreationData() |
| // |
| // Fill in creation data for an object. |
| // |
| 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; |
| INT32 bufferSize; |
| HASH_STATE hashState; |
| // Fill in TPMS_CREATION_DATA in outCreation |
| // Compute PCR digest |
| PCRComputeCurrentDigest(nameHashAlg, creationPCR, |
| &outCreation->t.creationData.pcrDigest); |
| // Put back PCR selection list |
| outCreation->t.creationData.pcrSelect = *creationPCR; |
| // Get locality |
| outCreation->t.creationData.locality |
| = LocalityGetAttributes(_plat__LocalityGet()); |
| outCreation->t.creationData.parentNameAlg = TPM_ALG_NULL; |
| // If the parent is 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) |
| { |
| BYTE *buffer = &outCreation->t.creationData.parentName.t.name[0]; |
| INT32 bufferSize = sizeof(TPM_HANDLE); |
| outCreation->t.creationData.parentName.t.size = |
| TPM_HANDLE_Marshal(&parentHandle, &buffer, &bufferSize); |
| // Parent qualified name of a Temporary Object is the same as parent's |
| // name |
| MemoryCopy2B(&outCreation->t.creationData.parentQualifiedName.b, |
| &outCreation->t.creationData.parentName.b, |
| sizeof(outCreation->t.creationData.parentQualifiedName.t.name)); |
| } |
| else // Regular object |
| { |
| OBJECT *parentObject = ObjectGet(parentHandle); |
| // Set name algorithm |
| outCreation->t.creationData.parentNameAlg = |
| parentObject->publicArea.nameAlg; |
| // Copy parent name |
| outCreation->t.creationData.parentName = parentObject->name; |
| // Copy parent qualified name |
| outCreation->t.creationData.parentQualifiedName = |
| parentObject->qualifiedName; |
| } |
| // Copy outside information |
| outCreation->t.creationData.outsideInfo = *outsideData; |
| // Marshal creation data to canonical form |
| buffer = creationBuffer; |
| bufferSize = sizeof(TPMS_CREATION_DATA); |
| outCreation->t.size = TPMS_CREATION_DATA_Marshal(&outCreation->t.creationData, |
| &buffer, &bufferSize); |
| // Compute hash for creation field in public template |
| creationDigest->t.size = CryptStartHash(nameHashAlg, &hashState); |
| CryptUpdateDigest(&hashState, outCreation->t.size, creationBuffer); |
| CryptCompleteHash2B(&hashState, &creationDigest->b); |
| return; |
| } |
| // GetSeedForKDF() |
| // |
| // Get a seed for KDF. The KDF for encryption and HMAC key use the same seed. It returns a pointer to |
| // the seed |
| // |
| TPM2B_SEED* |
| GetSeedForKDF( |
| TPM_HANDLE protectorHandle, // IN: the protector handle |
| TPM2B_SEED *seedIn // IN: the optional input seed |
| ) |
| { |
| OBJECT *protector = NULL; // Pointer to the protector |
| // 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(seedIn != NULL) |
| { |
| return seedIn; |
| } |
| else |
| { |
| if(protectorHandle == TPM_RH_NULL) |
| { |
| return (TPM2B_SEED *) &gr.nullProof; |
| } |
| else |
| { |
| protector = ObjectGet(protectorHandle); |
| return (TPM2B_SEED *) &protector->sensitive.seedValue; |
| } |
| } |
| } |
| // |
| // |
| // 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: |
| // a) Add IV before sensitive area if required |
| // b) encrypt sensitive data, if iv is required, encrypt by iv. otherwise, encrypted by a NULL iv |
| // c) add HMAC integrity at the beginning of the buffer It returns the total size of blob with outer wrap |
| // |
| UINT16 |
| ProduceOuterWrap( |
| TPM_HANDLE 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 *name, // IN: the name of the object |
| TPM_ALG_ID hashAlg, // IN: hash algorithm for outer wrap |
| TPM2B_SEED *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 |
| INT32 bufferSize; |
| // Compute the beginning of sensitive data. The outer integrity should |
| // always exist if this function function is called to make an outer wrap |
| integritySize = sizeof(UINT16) + CryptGetHashDigestSize(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); |
| CryptGenerateRandom(ivRNG.t.size, ivRNG.t.buffer); |
| // Marshal IV to buffer |
| buffer = sensitiveData; |
| bufferSize = sizeof(TPM2B_IV); |
| TPM2B_IV_Marshal(&ivRNG, &buffer, &bufferSize); |
| // 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, |
| TPM_ALG_CFB, symKey.t.buffer, iv, 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; |
| bufferSize = sizeof(TPM2B_DIGEST); |
| TPM2B_DIGEST_Marshal(&integrity, &buffer, &bufferSize); |
| // 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: |
| // a) check integrity of outer blob |
| // b) decrypt outer blob |
| // |
| // Error Returns Meaning |
| // |
| // TPM_RC_INSUFFICIENT error during sensitive data unmarshaling |
| // TPM_RC_INTEGRITY sensitive data integrity is broken |
| // TPM_RC_SIZE error during sensitive data unmarshaling |
| // TPM_RC_VALUE IV size for CFB does not match the encryption algorithm block size |
| // |
| TPM_RC |
| UnwrapOuter( |
| TPM_HANDLE 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 *name, // IN: the name of the object |
| TPM_ALG_ID hashAlg, // IN: hash algorithm for outer wrap |
| TPM2B_SEED *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(!Memory2BEqual(&integrity.b, &integrityToCompare.b)) |
| return TPM_RC_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 |
| if(result == TPM_RC_SUCCESS) |
| CryptSymmetricDecrypt(sensitiveData, symAlg, keyBits, |
| TPM_ALG_CFB, symKey.t.buffer, iv, |
| (UINT16) size, sensitiveData); |
| return result; |
| } |
| // |
| // |
| // SensitiveToPrivate() |
| // |
| // This function prepare the private blob for off the chip storage The operations in this function: |
| // a) marshal TPM2B_SENSITIVE structure into the buffer of TPM2B_PRIVATE |
| // b) apply encryption to the sensitive area. |
| // c) apply outer integrity computation. |
| // |
| void |
| SensitiveToPrivate( |
| TPMT_SENSITIVE *sensitive, // IN: sensitive structure |
| TPM2B_NAME *name, // IN: the name of the object |
| TPM_HANDLE parentHandle, // IN: The parent's handle |
| 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 *buffer; // Auxiliary buffer pointer |
| INT32 bufferSize; |
| 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(parentHandle == TPM_RH_NULL) |
| { |
| // For Temporary Object, using self name algorithm |
| hashAlg = nameAlg; |
| } |
| else |
| { |
| // Otherwise, using parent's name algorithm |
| hashAlg = ObjectGetNameAlg(parentHandle); |
| } |
| // Starting of sensitive data without wrappers |
| sensitiveData = outPrivate->t.buffer; |
| // Compute the integrity size |
| integritySize = sizeof(UINT16) + CryptGetHashDigestSize(hashAlg); |
| // Reserve space for integrity |
| sensitiveData += integritySize; |
| // Get iv size |
| ivSize = GetIV2BSize(parentHandle); |
| // Reserve space for iv |
| sensitiveData += ivSize; |
| // Marshal sensitive area, leaving the leading 2 bytes for size |
| buffer = sensitiveData + sizeof(UINT16); |
| bufferSize = sizeof(TPMT_SENSITIVE); |
| dataSize = TPMT_SENSITIVE_Marshal(sensitive, &buffer, &bufferSize); |
| // Adding size before the data area |
| buffer = sensitiveData; |
| bufferSize = sizeof(UINT16); |
| UINT16_Marshal(&dataSize, &buffer, &bufferSize); |
| // Adjust the dataSize to include the size field |
| dataSize += sizeof(UINT16); |
| // Adjust the pointer to inner buffer including the iv |
| sensitiveData = outPrivate->t.buffer + ivSize; |
| //Produce outer wrap, including encryption and HMAC |
| outPrivate->t.size = ProduceOuterWrap(parentHandle, name, hashAlg, NULL, |
| TRUE, dataSize, outPrivate->t.buffer); |
| return; |
| } |
| // |
| // |
| // PrivateToSensitive() |
| // |
| // Unwrap a input private area. Check the integrity, decrypt and retrieve data to a sensitive structure. The |
| // operations in this function: |
| // a) check the integrity HMAC of the input private area |
| // b) decrypt the private buffer |
| // c) unmarshal TPMT_SENSITIVE structure into the buffer of TPMT_SENSITIVE |
| // |
| // Error Returns Meaning |
| // |
| // TPM_RC_INTEGRITY if the private area integrity is bad |
| // TPM_RC_SENSITIVE unmarshal errors while unmarshaling TPMS_ENCRYPT from input |
| // private |
| // TPM_RC_VALUE outer wrapper does not have an iV of the correct size |
| // |
| TPM_RC |
| PrivateToSensitive( |
| TPM2B_PRIVATE *inPrivate, // IN: input private structure |
| TPM2B_NAME *name, // IN: the name of the object |
| TPM_HANDLE parentHandle, // IN: The parent's handle |
| 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 |
| OBJECT *parent = NULL; |
| UINT16 integritySize; |
| UINT16 ivSize; |
| // Make sure that name is provided |
| pAssert(name != NULL && name->t.size != 0); |
| // Find the hash algorithm for integrity computation |
| if(parentHandle == TPM_RH_NULL) |
| { |
| // For Temporary Object, using self name algorithm |
| hashAlg = nameAlg; |
| } |
| else |
| { |
| // Otherwise, using parent's name algorithm |
| hashAlg = ObjectGetNameAlg(parentHandle); |
| } |
| // unwrap outer |
| result = UnwrapOuter(parentHandle, name, hashAlg, NULL, TRUE, |
| inPrivate->t.size, inPrivate->t.buffer); |
| if(result != TPM_RC_SUCCESS) |
| return result; |
| // Compute the inner integrity size. |
| integritySize = sizeof(UINT16) + CryptGetHashDigestSize(hashAlg); |
| // Get iv size |
| ivSize = GetIV2BSize(parentHandle); |
| // The starting of sensitive data and data size without outer wrapper |
| sensitiveData = inPrivate->t.buffer + integritySize + ivSize; |
| dataSize = inPrivate->t.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) |
| { |
| pAssert( (parent == NULL) |
| || parent->publicArea.objectAttributes.fixedTPM == CLEAR); |
| result = TPM_RC_SENSITIVE; |
| } |
| else |
| { |
| // Always remove trailing zeros at load so that it is not necessary |
| // to check |
| // each time auth is checked. |
| MemoryRemoveTrailingZeros(&(sensitive->authValue)); |
| } |
| } |
| } |
| return result; |
| } |
| // |
| // |
| // SensitiveToDuplicate() |
| // |
| // This function prepare the duplication blob from the sensitive area. The operations in this function: |
| // a) marshal TPMT_SENSITIVE structure into the buffer of TPM2B_PRIVATE |
| // b) apply inner wrap to the sensitive area if required |
| // c) apply outer wrap if required |
| // |
| void |
| SensitiveToDuplicate( |
| TPMT_SENSITIVE *sensitive, // IN: sensitive structure |
| TPM2B_NAME *name, // IN: the name of the object |
| TPM_HANDLE parentHandle, // IN: The new parent's handle |
| 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 *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 *buffer; // Auxiliary buffer pointer |
| INT32 bufferSize; |
| 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->t.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) + CryptGetHashDigestSize(innerHash); |
| } |
| // Find out if outer wrap is required |
| if(seed->t.size != 0) |
| { |
| doOuterWrap = TRUE; |
| // Use parent nameAlg as outer hash algorithm |
| outerHash = ObjectGetNameAlg(parentHandle); |
| // Adjust sensitive data pointer |
| sensitiveData += sizeof(UINT16) + CryptGetHashDigestSize(outerHash); |
| } |
| // Marshal sensitive area, leaving the leading 2 bytes for size |
| buffer = sensitiveData + sizeof(UINT16); |
| bufferSize = sizeof(TPMT_SENSITIVE); |
| dataSize = TPMT_SENSITIVE_Marshal(sensitive, &buffer, &bufferSize); |
| // Adding size before the data area |
| buffer = sensitiveData; |
| bufferSize = sizeof(UINT16); |
| UINT16_Marshal(&dataSize, &buffer, &bufferSize); |
| // Adjust the dataSize to include the size field |
| dataSize += sizeof(UINT16); |
| // 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) + CryptGetHashDigestSize(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; |
| CryptGenerateRandom(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, TPM_ALG_CFB, |
| innerSymKey->t.buffer, NULL, 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(parentHandle, 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: |
| // a) check the integrity HMAC of the input private area |
| // b) decrypt the private buffer |
| // c) unmarshal TPMT_SENSITIVE structure into the buffer of TPMT_SENSITIVE |
| // |
| // Error Returns Meaning |
| // |
| // 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_PRIVATE *inPrivate, // IN: input private structure |
| TPM2B_NAME *name, // IN: the name of the object |
| TPM_HANDLE parentHandle, // IN: The parent's handle |
| TPM_ALG_ID nameAlg, // IN: hash algorithm in public area. |
| TPM2B_SEED *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_DATA *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->t.size != 0); |
| // Make sure symDef and innerSymKey are not NULL |
| pAssert(symDef != NULL && innerSymKey != NULL); |
| // Starting of sensitive data |
| sensitiveData = inPrivate->t.buffer; |
| dataSize = inPrivate->t.size; |
| // Find out if outer wrap is applied |
| if(seed->t.size != 0) |
| { |
| TPMI_ALG_HASH outerHash = TPM_ALG_NULL; |
| // Use parent nameAlg as outer hash algorithm |
| outerHash = ObjectGetNameAlg(parentHandle); |
| result = UnwrapOuter(parentHandle, name, outerHash, seed, FALSE, |
| dataSize, sensitiveData); |
| if(result != TPM_RC_SUCCESS) |
| return result; |
| // Adjust sensitive data pointer and size |
| sensitiveData += sizeof(UINT16) + CryptGetHashDigestSize(outerHash); |
| dataSize -= sizeof(UINT16) + CryptGetHashDigestSize(outerHash); |
| } |
| // Find out if inner wrap is applied |
| if(symDef->algorithm != TPM_ALG_NULL) |
| { |
| TPMI_ALG_HASH innerHash = TPM_ALG_NULL; |
| // assume the input key size should matches the symmetric definition |
| pAssert(innerSymKey->t.size == (symDef->keyBits.sym + 7) / 8); |
| // Decrypt inner buffer in place |
| CryptSymmetricDecrypt(sensitiveData, symDef->algorithm, |
| symDef->keyBits.sym, TPM_ALG_CFB, |
| innerSymKey->t.buffer, NULL, dataSize, |
| sensitiveData); |
| // Use self nameAlg as inner hash algorithm |
| innerHash = nameAlg; |
| // Check inner integrity |
| result = CheckInnerIntegrity(name, innerHash, dataSize, sensitiveData); |
| if(result != TPM_RC_SUCCESS) |
| return result; |
| // Adjust sensitive data pointer and size |
| sensitiveData += sizeof(UINT16) + CryptGetHashDigestSize(innerHash); |
| dataSize -= sizeof(UINT16) + CryptGetHashDigestSize(innerHash); |
| } |
| // 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; |
| } |
| } |
| // Always remove trailing zeros at load so that it is not necessary to check |
| // each time auth is checked. |
| if(result == TPM_RC_SUCCESS) |
| MemoryRemoveTrailingZeros(&(sensitive->authValue)); |
| return result; |
| } |
| // |
| // |
| // SecretToCredential() |
| // |
| // This function prepare the credential blob from a secret (a TPM2B_DIGEST) The operations in this |
| // function: |
| // a) marshal TPM2B_DIGEST structure into the buffer of TPM2B_ID_OBJECT |
| // b) encrypt the private buffer, excluding the leading integrity HMAC area |
| // c) compute integrity HMAC and append to the beginning of the buffer. |
| // d) Set the total size of TPM2B_ID_OBJECT buffer |
| // |
| void |
| SecretToCredential( |
| TPM2B_DIGEST *secret, // IN: secret information |
| TPM2B_NAME *name, // IN: the name of the object |
| TPM2B_SEED *seed, // IN: an external seed. |
| TPM_HANDLE protector, // IN: The protector's handle |
| TPM2B_ID_OBJECT *outIDObject // OUT: output credential |
| ) |
| { |
| BYTE *buffer; // Auxiliary buffer pointer |
| INT32 bufferSize; |
| 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 = ObjectGetNameAlg(protector); |
| // Marshal secret area to credential buffer, leave space for integrity |
| sensitiveData = outIDObject->t.credential |
| + sizeof(UINT16) + CryptGetHashDigestSize(outerHash); |
| // Marshal secret area |
| buffer = sensitiveData; |
| bufferSize = sizeof(TPM2B_DIGEST); |
| dataSize = TPM2B_DIGEST_Marshal(secret, &buffer, &bufferSize); |
| // 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: |
| // a) check the integrity HMAC of the input credential area |
| // b) decrypt the credential buffer |
| // c) unmarshal TPM2B_DIGEST structure into the buffer of TPM2B_DIGEST |
| // |
| // Error Returns Meaning |
| // |
| // 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_ID_OBJECT *inIDObject, // IN: input credential blob |
| TPM2B_NAME *name, // IN: the name of the object |
| TPM2B_SEED *seed, // IN: an external seed. |
| TPM_HANDLE protector, // IN: The protector's handle |
| 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 = ObjectGetNameAlg(protector); |
| // Unwrap outer, a TPM_RC_INTEGRITY error may be returned at this point |
| result = UnwrapOuter(protector, name, outerHash, seed, FALSE, |
| inIDObject->t.size, inIDObject->t.credential); |
| if(result == TPM_RC_SUCCESS) |
| { |
| // Compute the beginning of sensitive data |
| sensitiveData = inIDObject->t.credential |
| + sizeof(UINT16) + CryptGetHashDigestSize(outerHash); |
| dataSize = inIDObject->t.size |
| - (sizeof(UINT16) + CryptGetHashDigestSize(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; |
| } |
