370 lines
18 KiB
C
370 lines
18 KiB
C
/*
|
|
* Copyright 2015 The Chromium OS Authors. All rights reserved.
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
|
|
#ifndef __SOURCE_CRYPTUTIL_FP_H
|
|
#define __SOURCE_CRYPTUTIL_FP_H
|
|
|
|
BOOL CryptAreKeySizesConsistent(
|
|
TPMT_PUBLIC *publicArea // IN: the public area to check
|
|
);
|
|
TPMI_YES_NO CryptCapGetECCCurve(
|
|
TPM_ECC_CURVE curveID, // IN: the starting ECC curve
|
|
UINT32 maxCount, // IN: count of returned curve
|
|
TPML_ECC_CURVE *curveList // OUT: ECC curve list
|
|
);
|
|
UINT32 CryptCapGetEccCurveNumber(void);
|
|
UINT16 CryptCommit(void);
|
|
LIB_EXPORT int CryptCompare(const UINT32 aSize, // IN: size of a
|
|
const BYTE *a, // IN: a buffer
|
|
const UINT32 bSize, // IN: size of b
|
|
const BYTE *b // IN: b buffer
|
|
);
|
|
TPM_RC CryptCommitCompute(
|
|
TPMS_ECC_POINT *K, // OUT: [d]B
|
|
TPMS_ECC_POINT *L, // OUT: [r]B
|
|
TPMS_ECC_POINT *E, // OUT: [r]M
|
|
TPM_ECC_CURVE curveID, // IN: The curve for the computation
|
|
TPMS_ECC_POINT *M, // IN: M (P1)
|
|
TPMS_ECC_POINT *B, // IN: B (x2, y2)
|
|
TPM2B_ECC_PARAMETER *d, // IN: the private scalar
|
|
TPM2B_ECC_PARAMETER *r // IN: the computed r value
|
|
);
|
|
int CryptCompareSigned(UINT32 aSize, // IN: size of a
|
|
BYTE *a, // IN: a buffer
|
|
UINT32 bSize, // IN: size of b
|
|
BYTE *b // IN: b buffer
|
|
);
|
|
void CryptComputeSymmetricUnique(
|
|
TPMI_ALG_HASH nameAlg, // IN: object name algorithm
|
|
TPMT_SENSITIVE *sensitive, // IN: sensitive area
|
|
TPM2B_DIGEST *unique // OUT: unique buffer
|
|
);
|
|
LIB_EXPORT UINT16
|
|
CryptCompleteHMAC2B(HMAC_STATE *hmacState, // IN: the state of HMAC stack
|
|
TPM2B *digest // OUT: HMAC
|
|
);
|
|
LIB_EXPORT UINT16
|
|
CryptCompleteHash(void *state, // IN: the state of hash stack
|
|
UINT16 digestSize, // IN: size of digest buffer
|
|
BYTE *digest // OUT: hash digest
|
|
);
|
|
UINT16 CryptCompleteHash2B(
|
|
void *state, // IN: the state of hash stack
|
|
TPM2B *digest // IN: the size of the buffer Out: requested number of byte
|
|
);
|
|
TPM_RC CryptCreateObject(
|
|
TPM_HANDLE parentHandle, // IN/OUT: indication of the seed source
|
|
TPMT_PUBLIC *publicArea, // IN/OUT: public area
|
|
TPMS_SENSITIVE_CREATE *sensitiveCreate, // IN: sensitive creation
|
|
TPMT_SENSITIVE *sensitive // OUT: sensitive area
|
|
);
|
|
void CryptDrbgGetPutState(GET_PUT direction // IN: Get from or put to DRBG
|
|
);
|
|
TPM_RC CryptDecryptRSA(
|
|
UINT16 *dataOutSize, // OUT: size of plain text in byte
|
|
BYTE *dataOut, // OUT: plain text
|
|
OBJECT *rsaKey, // IN: internal RSA key
|
|
TPMT_RSA_DECRYPT *scheme, // IN: selects the padding scheme
|
|
UINT16 cipherInSize, // IN: size of cipher text in byte
|
|
BYTE *cipherIn, // IN: cipher text
|
|
const char *label // IN: a label, when needed
|
|
);
|
|
TPM_RC CryptDivide(
|
|
TPM2B *numerator, // IN: numerator
|
|
TPM2B *denominator, // IN: denominator
|
|
TPM2B *quotient, // OUT: quotient = numerator / denominator.
|
|
TPM2B *remainder // OUT: numerator mod denominator.
|
|
);
|
|
void CryptDrbgGetPutState(GET_PUT direction // IN: Get from or put to DRBG
|
|
);
|
|
//
|
|
//
|
|
// 10.2.6.3 CryptEccGetKeySizeBytes()
|
|
//
|
|
// This macro returns the size of the ECC key in bytes. It uses
|
|
// CryptEccGetKeySizeInBits().
|
|
//
|
|
#define CryptEccGetKeySizeInBytes(curve) \
|
|
((CryptEccGetKeySizeInBits(curve) + 7) / 8)
|
|
|
|
TPM_RC CryptEcc2PhaseKeyExchange(
|
|
TPMS_ECC_POINT *outZ1, // OUT: the computed point
|
|
TPMS_ECC_POINT *outZ2, // OUT: optional second point
|
|
TPM_ALG_ID scheme, // IN: the key exchange scheme
|
|
TPM_ECC_CURVE curveId, // IN: the curve for the computation
|
|
TPM2B_ECC_PARAMETER *dsA, // IN: static private TPM key
|
|
TPM2B_ECC_PARAMETER *deA, // IN: ephemeral private TPM key
|
|
TPMS_ECC_POINT *QsB, // IN: static public party B key
|
|
TPMS_ECC_POINT *QeB // IN: ephemeral public party B key
|
|
);
|
|
TPM_RC CryptEncryptRSA(
|
|
UINT16 *cipherOutSize, // OUT: size of cipher text in byte
|
|
BYTE *cipherOut, // OUT: cipher text
|
|
OBJECT *rsaKey, // IN: internal RSA key
|
|
TPMT_RSA_DECRYPT *scheme, // IN: selects the padding scheme
|
|
UINT16 dataInSize, // IN: size of plain text in byte
|
|
BYTE *dataIn, // IN: plain text
|
|
const char *label // IN: an optional label
|
|
);
|
|
TPM_ALG_ID CryptGetContextAlg(void *state // IN: the context to check
|
|
);
|
|
LIB_EXPORT TPM_ALG_ID CryptGetHashAlgByIndex(UINT32 index // IN: the index
|
|
);
|
|
LIB_EXPORT UINT16
|
|
CryptGetHashDigestSize(TPM_ALG_ID hashAlg // IN: hash algorithm
|
|
);
|
|
LIB_EXPORT const TPM2B *CryptEccGetParameter(
|
|
char p, // IN: the parameter selector
|
|
TPM_ECC_CURVE curveId // IN: the curve id
|
|
);
|
|
BOOL CryptEccGetParameters(
|
|
TPM_ECC_CURVE curveId, // IN: ECC curve ID
|
|
TPMS_ALGORITHM_DETAIL_ECC *parameters // OUT: ECC parameter
|
|
);
|
|
TPM_RC CryptEccPointMultiply(TPMS_ECC_POINT *pOut, // OUT: output point
|
|
TPM_ECC_CURVE curveId, // IN: curve selector
|
|
TPM2B_ECC_PARAMETER *dIn, // IN: public scalar
|
|
TPMS_ECC_POINT *pIn // IN: optional point
|
|
);
|
|
BOOL CryptEccIsPointOnCurve(TPM_ECC_CURVE curveID, // IN: ECC curve ID
|
|
TPMS_ECC_POINT *Q // IN: ECC point
|
|
);
|
|
void CryptEndCommit(UINT16 c // IN: the counter value of the commitment
|
|
);
|
|
BOOL CryptGenerateR(
|
|
TPM2B_ECC_PARAMETER *r, // OUT: the generated random value
|
|
UINT16 *c, // IN/OUT: count value.
|
|
TPMI_ECC_CURVE curveID, // IN: the curve for the value
|
|
TPM2B_NAME *name // IN: optional name of a key to associate with 'r'
|
|
);
|
|
UINT16 CryptGenerateRandom(UINT16 randomSize, // IN: size of random number
|
|
BYTE *buffer // OUT: buffer of random number
|
|
);
|
|
void CryptGenerateNewSymmetric(
|
|
TPMS_SENSITIVE_CREATE *sensitiveCreate, // IN: sensitive creation data
|
|
TPMT_SENSITIVE *sensitive, // OUT: sensitive area
|
|
TPM_ALG_ID hashAlg, // IN: hash algorithm for the KDF
|
|
TPM2B_SEED *seed, // IN: seed used in creation
|
|
TPM2B_NAME *name // IN: name of the object
|
|
);
|
|
const TPMT_ECC_SCHEME *CryptGetCurveSignScheme(
|
|
TPM_ECC_CURVE curveId // IN: The curve selector
|
|
);
|
|
LIB_EXPORT UINT16
|
|
CryptGetHashDigestSize(TPM_ALG_ID hashAlg // IN: hash algorithm
|
|
);
|
|
TPMI_ALG_HASH CryptGetSignHashAlg(TPMT_SIGNATURE *auth // IN: signature
|
|
);
|
|
INT16 CryptGetSymmetricBlockSize(
|
|
TPMI_ALG_SYM algorithm, // IN: symmetric algorithm
|
|
UINT16 keySize // IN: key size in bit
|
|
);
|
|
TPM_RC CryptGetTestResult(TPM2B_MAX_BUFFER *outData // OUT: test result data
|
|
);
|
|
LIB_EXPORT UINT16
|
|
CryptHashBlock(TPM_ALG_ID algId, // IN: the hash algorithm to use
|
|
UINT16 blockSize, // IN: size of the data block
|
|
BYTE *block, // IN: address of the block to hash
|
|
UINT16 retSize, // IN: size of the return buffer
|
|
BYTE *ret // OUT: address of the buffer
|
|
);
|
|
//
|
|
//
|
|
//
|
|
// 10.2.4.23 CryptKDFa()
|
|
//
|
|
// This function generates a key using the KDFa() formulation in Part 1 of the
|
|
// TPM specification. In this implementation, this is a macro invocation of
|
|
// _cpri__KDFa() in the hash module of the CryptoEngine(). This macro sets
|
|
// once to FALSE so that KDFa() will iterate as many times as necessary to
|
|
// generate sizeInBits number of bits.
|
|
//
|
|
#define CryptKDFa(hashAlg, key, label, contextU, contextV, sizeInBits, \
|
|
keyStream, counterInOut) \
|
|
TEST_HASH(hashAlg); \
|
|
_cpri__KDFa(((TPM_ALG_ID)hashAlg), ((TPM2B *)key), ((const char *)label), \
|
|
((TPM2B *)contextU), ((TPM2B *)contextV), ((UINT32)sizeInBits), \
|
|
((BYTE *)keyStream), ((UINT32 *)counterInOut), ((BOOL)FALSE))
|
|
|
|
//
|
|
//
|
|
// 10.2.4.24 CryptKDFaOnce()
|
|
//
|
|
// This function generates a key using the KDFa() formulation in Part 1 of the
|
|
// TPM specification. In this implementation, this is a macro invocation of
|
|
// _cpri__KDFa() in the hash module of the CryptoEngine(). This macro will
|
|
// call _cpri__KDFa() with once TRUE so that only one iteration is performed,
|
|
// regardless of sizeInBits.
|
|
//
|
|
#define CryptKDFaOnce(hashAlg, key, label, contextU, contextV, sizeInBits, \
|
|
keyStream, counterInOut) \
|
|
TEST_HASH(hashAlg); \
|
|
_cpri__KDFa(((TPM_ALG_ID)hashAlg), ((TPM2B *)key), ((const char *)label), \
|
|
((TPM2B *)contextU), ((TPM2B *)contextV), ((UINT32)sizeInBits), \
|
|
((BYTE *)keyStream), ((UINT32 *)counterInOut), ((BOOL)TRUE))
|
|
|
|
//
|
|
//
|
|
// 10.2.4.26 CryptKDFe()
|
|
//
|
|
// This function generates a key using the KDFa() formulation in Part 1 of
|
|
// the TPM specification. In this implementation, this is a macro invocation
|
|
// of _cpri__KDFe() in the hash module of the CryptoEngine().
|
|
//
|
|
#define CryptKDFe(hashAlg, Z, label, partyUInfo, partyVInfo, sizeInBits, \
|
|
keyStream) \
|
|
TEST_HASH(hashAlg); \
|
|
_cpri__KDFe(((TPM_ALG_ID)hashAlg), ((TPM2B *)Z), ((const char *)label), \
|
|
((TPM2B *)partyUInfo), ((TPM2B *)partyVInfo), \
|
|
((UINT32)sizeInBits), ((BYTE *)keyStream))
|
|
|
|
void CryptHashStateImportExport(
|
|
HASH_STATE *internalFmt, // IN: state to LIB_EXPORT
|
|
HASH_STATE *externalFmt, // OUT: exported state
|
|
IMPORT_EXPORT direction);
|
|
void CryptInitUnits(void);
|
|
BOOL CryptIsAsymAlgorithm(TPM_ALG_ID algID // IN: algorithm ID
|
|
);
|
|
BOOL CryptIsDecryptScheme(TPMI_ALG_ASYM_SCHEME scheme);
|
|
BOOL CryptIsSchemeAnonymous(
|
|
TPM_ALG_ID scheme // IN: the scheme algorithm to test
|
|
);
|
|
BOOL CryptIsSignScheme(TPMI_ALG_ASYM_SCHEME scheme);
|
|
BOOL CryptIsSplitSign(TPM_ALG_ID scheme // IN: the algorithm selector
|
|
);
|
|
TPM_RC CryptNewEccKey(TPM_ECC_CURVE curveID, // IN: ECC curve
|
|
TPMS_ECC_POINT *publicPoint, // OUT: public point
|
|
TPM2B_ECC_PARAMETER *sensitive // OUT: private area
|
|
);
|
|
BOOL CryptObjectIsPublicConsistent(TPMT_PUBLIC *publicArea // IN: public area
|
|
);
|
|
TPM_RC CryptObjectPublicPrivateMatch(OBJECT *object // IN: the object to check
|
|
);
|
|
TPM_RC CryptParameterDecryption(
|
|
TPM_HANDLE handle, // IN: encrypted session handle
|
|
TPM2B *nonceCaller, // IN: nonce caller
|
|
UINT32 bufferSize, // IN: size of parameter buffer
|
|
UINT16
|
|
leadingSizeInByte, // IN: the size of the leading size field in byte
|
|
TPM2B_AUTH *extraKey, // IN: the authValue
|
|
BYTE *buffer // IN/OUT: parameter buffer to be decrypted
|
|
);
|
|
void CryptParameterEncryption(
|
|
TPM_HANDLE handle, // IN: encrypt session handle
|
|
TPM2B *nonceCaller, // IN: nonce caller
|
|
UINT16 leadingSizeInByte, // IN: the size of the leading size field in byte
|
|
TPM2B_AUTH *
|
|
extraKey, // IN: additional key material other than session auth
|
|
BYTE *buffer // IN/OUT: parameter buffer to be encrypted
|
|
);
|
|
TPM_RC CryptSecretDecrypt(
|
|
TPM_HANDLE tpmKey, // IN: decrypt key
|
|
TPM2B_NONCE *nonceCaller, // IN: nonceCaller. It is needed for symmetric
|
|
// decryption. For asymmetric decryption, this
|
|
// parameter is NULL
|
|
const char *label, // IN: a null-terminated string as L
|
|
TPM2B_ENCRYPTED_SECRET *secret, // IN: input secret
|
|
TPM2B_DATA *data // OUT: decrypted secret value
|
|
);
|
|
TPM_RC CryptSecretEncrypt(
|
|
TPMI_DH_OBJECT keyHandle, // IN: encryption key handle
|
|
const char *label, // IN: a null-terminated string as L
|
|
TPM2B_DATA *data, // OUT: secret value
|
|
TPM2B_ENCRYPTED_SECRET *secret // OUT: secret structure
|
|
);
|
|
TPMT_RSA_DECRYPT *CryptSelectRSAScheme(
|
|
TPMI_DH_OBJECT rsaHandle, // IN: handle of sign key
|
|
TPMT_RSA_DECRYPT *scheme // IN: a sign or decrypt scheme
|
|
);
|
|
TPM_RC CryptSelectSignScheme(
|
|
TPMI_DH_OBJECT signHandle, // IN: handle of signing key
|
|
TPMT_SIG_SCHEME *scheme // IN/OUT: signing scheme
|
|
);
|
|
TPM_RC CryptSign(TPMI_DH_OBJECT signHandle, // IN: The handle of sign key
|
|
TPMT_SIG_SCHEME *signScheme, // IN: sign scheme.
|
|
TPM2B_DIGEST *digest, // IN: The digest being signed
|
|
TPMT_SIGNATURE *signature // OUT: signature
|
|
);
|
|
LIB_EXPORT UINT16
|
|
CryptStartHMAC2B(TPMI_ALG_HASH hashAlg, // IN: hash algorithm
|
|
TPM2B *key, // IN: HMAC key
|
|
HMAC_STATE *hmacState // OUT: the state of HMAC stack. It will
|
|
// be used in HMAC update and completion
|
|
);
|
|
UINT16 CryptStartHMACSequence2B(TPMI_ALG_HASH hashAlg, // IN: hash algorithm
|
|
TPM2B *key, // IN: HMAC key
|
|
HMAC_STATE *hmacState // OUT: the state of HMAC
|
|
// stack. It will be used
|
|
// in HMAC update and
|
|
// completion
|
|
);
|
|
UINT16 CryptStartHashSequence(TPMI_ALG_HASH hashAlg, // IN: hash algorithm
|
|
HASH_STATE *hashState // OUT: the state of hash
|
|
// stack. It will be used
|
|
// in hash update and
|
|
// completion
|
|
);
|
|
void CryptStirRandom(UINT32 entropySize, // IN: size of entropy buffer
|
|
BYTE *buffer // IN: entropy buffer
|
|
);
|
|
void CryptStopUnits(void);
|
|
void CryptSymmetricDecrypt(
|
|
BYTE *decrypted,
|
|
TPM_ALG_ID algorithm, // IN: algorithm for encryption
|
|
UINT16 keySizeInBits, // IN: key size in bit
|
|
TPMI_ALG_SYM_MODE mode, // IN: symmetric encryption mode
|
|
BYTE *key, // IN: encryption key
|
|
TPM2B_IV *ivIn, // IN/OUT: IV for next block
|
|
UINT32 dataSize, // IN: data size in byte
|
|
BYTE *data // IN/OUT: data buffer
|
|
);
|
|
void CryptSymmetricEncrypt(
|
|
BYTE *encrypted, // OUT: the encrypted data
|
|
TPM_ALG_ID algorithm, // IN: algorithm for encryption
|
|
UINT16 keySizeInBits, // IN: key size in bit
|
|
TPMI_ALG_SYM_MODE mode, // IN: symmetric encryption mode
|
|
BYTE *key, // IN: encryption key
|
|
TPM2B_IV *ivIn, // IN/OUT: Input IV and output chaining value for the
|
|
// next block
|
|
UINT32 dataSize, // IN: data size in byte
|
|
BYTE *data // IN/OUT: data buffer
|
|
);
|
|
UINT16 CryptStartHash(TPMI_ALG_HASH hashAlg, // IN: hash algorithm
|
|
HASH_STATE *hashState // OUT: the state of hash stack. It
|
|
// will be used in hash update and
|
|
// completion
|
|
);
|
|
void CryptUpdateDigest(void *digestState, // IN: the state of hash stack
|
|
UINT32 dataSize, // IN: the size of data
|
|
BYTE *data // IN: data to be hashed
|
|
);
|
|
LIB_EXPORT void CryptUpdateDigest2B(void *digestState, // IN: the digest state
|
|
TPM2B *bIn // IN: 2B containing the data
|
|
);
|
|
void CryptUpdateDigestInt(void *state, // IN: the state of hash stack
|
|
UINT32 intSize, // IN: the size of 'intValue' in byte
|
|
void *intValue // IN: integer value to be hashed
|
|
);
|
|
BOOL CryptUtilStartup(STARTUP_TYPE type // IN: the startup type
|
|
);
|
|
TPM_RC CryptVerifySignature(
|
|
TPMI_DH_OBJECT keyHandle, // IN: The handle of sign key
|
|
TPM2B_DIGEST *digest, // IN: The digest being validated
|
|
TPMT_SIGNATURE *signature // IN: signature
|
|
);
|
|
void KDFa(TPM_ALG_ID hash, // IN: hash algorithm used in HMAC
|
|
TPM2B *key, // IN: HMAC key
|
|
const char *label, // IN: a null-terminated label for KDF
|
|
TPM2B *contextU, // IN: context U
|
|
TPM2B *contextV, // IN: context V
|
|
UINT32 sizeInBits, // IN: size of generated key in bit
|
|
BYTE *keyStream, // OUT: key buffer
|
|
UINT32 *counterInOut // IN/OUT: caller may provide the iteration
|
|
// counter for incremental operations to avoid
|
|
// large intermediate buffers.
|
|
);
|
|
|
|
#endif // __SOURCE_CRYPTUTIL_FP_H
|