uint32_t TPM_WriteKey(struct tpm_buffer * buffer, keydata * k)
{
uint16_t filler = 0;
uint32_t ret;
if (k->v.tag == TPM_TAG_KEY12)
ret = TSS_buildbuff(FORMAT_TPM_KEY12_EMB_RSA, buffer,
PARAMS_TPM_KEY12_EMB_RSA_W(k));
else
ret = TSS_buildbuff(FORMAT_TPM_KEY_EMB_RSA, buffer,
PARAMS_TPM_KEY_EMB_RSA_W(k));
return ret;
}
uint32_t TPM_WriteQuoteInfo(struct tpm_buffer *buffer, TPM_QUOTE_INFO * info)
{
uint32_t ret = 0;
ret = TSS_buildbuff(FORMAT_TPM_QUOTE_INFO, buffer,
PARAMS_TPM_QUOTE_INFO_W(info));
return ret;
}
uint32_t TPM_WriteDelegateOwnerBlob(struct tpm_buffer *buffer, TPM_DELEGATE_OWNER_BLOB * blob)
{
uint32_t ret;
ret = TSS_buildbuff(FORMAT_TPM_DELEGATE_OWNER_BLOB, buffer,
PARAMS_TPM_DELEGATE_OWNER_BLOB_W(blob));
return ret;
}
uint32_t TPM_WriteDelegatePublic(struct tpm_buffer *buffer, TPM_DELEGATE_PUBLIC * pub)
{
uint32_t ret;
ret = TSS_buildbuff(FORMAT_TPM_DELEGATE_PUBLIC,buffer,
PARAMS_TPM_DELEGATE_PUBLIC_W(pub));
return ret;
}
uint32_t TPM_WriteStoreAsymkey(struct tpm_buffer *buffer, TPM_STORE_ASYMKEY * sak)
{
uint32_t ret;
ret = TSS_buildbuff(FORMAT_TPM_STORE_ASYMKEY, buffer,
PARAMS_TPM_STORE_ASYMKEY_W(sak));
return ret;
}
uint32_t TPM_WriteStoredData(struct tpm_buffer *buffer, TPM_STORED_DATA *sd)
{
uint32_t ret;
ret = TSS_buildbuff(FORMAT_TPM_STORED_DATA, buffer,
PARAMS_TPM_STORED_DATA_W(sd));
return ret;
}
uint32_t TPM_SHA1CompleteExtend(void *data, uint32_t datalen,
uint32_t pcrNum,
unsigned char * hash,
unsigned char * pcrValue)
{
uint32_t ordinal_no;
uint32_t pcrNum_no = htonl(pcrNum);
uint32_t ret;
STACK_TPM_BUFFER(tpmdata)
/* move Network byte order data to varaible for hmac calcualtion */
ordinal_no = htonl(TPM_ORD_SHA1CompleteExtend);
TSS_buildbuff("00 c1 T l l @", &tpmdata,
ordinal_no,
pcrNum_no,
datalen, data);
/* transmit the request buffer to the TPM device and read the reply */
ret = TPM_Transmit(&tpmdata,"SHA1CompleteExtend");
if (0 != ret) {
return ret;
}
memcpy(hash,
&tpmdata.buffer[TPM_DATA_OFFSET],
TPM_HASH_SIZE);
memcpy(pcrValue,
&tpmdata.buffer[TPM_DATA_OFFSET + TPM_HASH_SIZE],
TPM_HASH_SIZE);
return ret;
}
uint32_t TPM_SHA1Update(void * data, uint32_t datalen) {
uint32_t ordinal_no;
uint32_t ret;
struct tpm_buffer *tpmdata = TSS_AllocTPMBuffer(datalen+20);
/* move Network byte order data to variable for hmac calcualtion */
ordinal_no = htonl(TPM_ORD_SHA1Update);
if (NULL == tpmdata) {
return ERR_BAD_SIZE;
}
ret = TSS_buildbuff("00 c1 T l @", tpmdata,
ordinal_no,
datalen, data);
if (ret & ERR_MASK) {
goto err_exit;
}
/* transmit the request buffer to the TPM device and read the reply */
ret = TPM_Transmit(tpmdata,"SHA1Update");
err_exit:
TSS_FreeTPMBuffer(tpmdata);
return ret;
}
uint32_t TPM_DirRead(uint32_t dirIndex,
unsigned char * dirValueBuffer)
{
uint32_t ret;
uint32_t ordinal_no = htonl(TPM_ORD_DirRead);
STACK_TPM_BUFFER(tpmdata)
uint32_t dirIndex_no = htonl(dirIndex);
ret = TSS_buildbuff("00 c1 T l l",&tpmdata,
ordinal_no,
dirIndex_no);
if ((ret & ERR_MASK)) {
return ret;
}
ret = TPM_Transmit(&tpmdata,"DirRead");
if (ret != 0) {
return ret;
}
if (tpmdata.used != 30) {
ret = ERR_BAD_RESP;
}
if (NULL != dirValueBuffer) {
memcpy(dirValueBuffer,
&tpmdata.buffer[TPM_DATA_OFFSET],
20);
}
return ret;
}
uint32_t TPM_LoadKeyContext(struct tpm_buffer *context,
uint32_t *keyhandle)
{
uint32_t ret;
uint32_t ordinal_no = htonl(TPM_ORD_LoadKeyContext);
STACK_TPM_BUFFER(tpmdata);
ret = TSS_buildbuff("00 c1 T l @",&tpmdata,
ordinal_no,
context->used, context->buffer);
if ((ret & ERR_MASK) != 0) {
return ret;
}
ret = TPM_Transmit(&tpmdata,"LoadKeyContext");
if (ret != 0) {
return ret;
}
ret = tpm_buffer_load32(&tpmdata, TPM_DATA_OFFSET, keyhandle);
if ((ret & ERR_MASK)) {
return ret;
}
return ret;
}
uint32_t TPM_LoadAuthContext(unsigned char *authContextBlob, uint32_t authContextSize,
uint32_t *authhandle)
{
uint32_t ret;
uint32_t ordinal_no = htonl(TPM_ORD_LoadAuthContext);
STACK_TPM_BUFFER(tpmdata);
ret = TSS_buildbuff("00 c1 T l @",&tpmdata,
ordinal_no,
authContextSize, authContextBlob);
if ( ( ret & ERR_MASK ) != 0) {
return ret;
}
ret = TPM_Transmit(&tpmdata,"LoadAuthContext");
if (ret != 0) {
return ret;
}
ret = tpm_buffer_load32(&tpmdata, TPM_DATA_OFFSET, authhandle);
if ((ret & ERR_MASK)) {
return ret;
}
return ret;
}
uint32_t TPM_WriteContextBlob(struct tpm_buffer *buffer, TPM_CONTEXT_BLOB * context)
{
uint32_t ret;
ret = TSS_buildbuff(FORMAT_TPM_CONTEXT_BLOB, buffer,
PARAMS_TPM_CONTEXT_BLOB_W(context));
return ret;
}
uint32_t TPM_WriteSymmetricKey(struct tpm_buffer *buffer, TPM_SYMMETRIC_KEY * key)
{
uint32_t ret;
ret = TSS_buildbuff(FORMAT_TPM_SYMMETRIC_KEY, buffer,
PARAMS_TPM_SYMMETRIC_KEY_W(key));
return ret;
}
uint32_t TPM_GetRandom(uint32_t bytesreq,
unsigned char * buffer, uint32_t * bytesret)
{
uint32_t ret;
STACK_TPM_BUFFER( tpmdata )
uint32_t ordinal_no = htonl(TPM_ORD_GetRandom);
uint32_t numbytes_no = htonl(bytesreq);
TSS_buildbuff("00 c1 T l l",&tpmdata,
ordinal_no,
numbytes_no);
ret = TPM_Transmit(&tpmdata,"GetRandom");
if (0 != ret) {
return ret;
}
ret = tpm_buffer_load32(&tpmdata, TPM_DATA_OFFSET, bytesret);
if ((ret & ERR_MASK)) {
return ret;
}
memcpy(buffer,
&tpmdata.buffer[TPM_DATA_OFFSET + TPM_U32_SIZE],
*bytesret);
return ret;
}
uint32_t TPM_Extend(uint32_t pcrIndex,
unsigned char * event,
unsigned char * outDigest) {
uint32_t ret;
uint32_t ordinal_no = htonl(TPM_ORD_Extend);
uint32_t pcrIndex_no = htonl(pcrIndex);
STACK_TPM_BUFFER(tpmdata)
ret = TSS_buildbuff("00 c1 T l l %",&tpmdata,
ordinal_no,
pcrIndex_no,
TPM_HASH_SIZE, event);
if ((ret & ERR_MASK)) {
return ret;
}
ret = TPM_Transmit(&tpmdata,"Extend");
if (0 != ret) {
return ret;
}
if (NULL != outDigest) {
memcpy(outDigest,
&tpmdata.buffer[TPM_DATA_OFFSET],
TPM_HASH_SIZE);
}
return ret;
}
uint32_t TPM_WriteEkBlob(struct tpm_buffer * buffer, TPM_EK_BLOB * blob)
{
uint32_t ret = 0;
ret = TSS_buildbuff(FORMAT_TPM_EK_BLOB, buffer,
PARAMS_TPM_EK_BLOB_W(blob));
return ret;
}
uint32_t TPM_WriteSignInfo(struct tpm_buffer * tb, TPM_SIGN_INFO * tsi)
{
uint32_t ret = 0;
ret = TSS_buildbuff(FORMAT_TPM_SIGN_INFO, tb,
PARAMS_TPM_SIGN_INFO_W(tsi));
return ret;
}
uint32_t TPM_WriteTPMFamilyLabel(struct tpm_buffer * buffer,
TPM_FAMILY_LABEL l)
{
uint32_t ret;
ret = TSS_buildbuff("o", buffer, l);
return ret;
}
uint32_t TPM_WriteCMKAuth(struct tpm_buffer * buffer, TPM_CMK_AUTH * auth)
{
uint32_t ret;
ret = TSS_buildbuff(FORMAT_TPM_CMK_AUTH, buffer,
PARAMS_TPM_CMK_AUTH_W(auth));
return ret;
}
uint32_t TPM_WriteAuditEventOut(struct tpm_buffer *buffer, TPM_AUDIT_EVENT_OUT * aeo)
{
uint32_t ret;
ret = TSS_buildbuff(FORMAT_TPM_AUDIT_EVENT_OUT, buffer,
PARAMS_TPM_AUDIT_EVENT_OUT_W(aeo));
return ret;
}
uint32_t TPM_WriteAuditEventIn(struct tpm_buffer *buffer, TPM_AUDIT_EVENT_IN * aei)
{
uint32_t ret;
ret = TSS_buildbuff(FORMAT_TPM_AUDIT_EVENT_IN, buffer,
PARAMS_TPM_AUDIT_EVENT_IN_W(aei));
return ret;
}
uint32_t TPM_PCRReset(TPM_PCR_SELECTION * selection)
{
uint32_t ret;
uint32_t ordinal_no = htonl(TPM_ORD_PCR_Reset);
STACK_TPM_BUFFER(tpmdata)
struct tpm_buffer *serPCRMap = TSS_AllocTPMBuffer(TPM_U16_SIZE + selection->sizeOfSelect + 10);
uint32_t serPCRMapSize;
if (NULL == serPCRMap) {
return ERR_MEM_ERR;
}
ret = TPM_WritePCRSelection(serPCRMap, selection);
if ((ret & ERR_MASK) != 0) {
TSS_FreeTPMBuffer(serPCRMap);
return ret;
}
serPCRMapSize = ret;
ret = TSS_buildbuff("00 c1 T l %",&tpmdata,
ordinal_no,
serPCRMapSize, serPCRMap->buffer);
TSS_FreeTPMBuffer(serPCRMap);
if ((ret & ERR_MASK)) {
return ret;
}
ret = TPM_Transmit(&tpmdata,"PCR Reset");
return ret;
}
uint32_t TPM_WriteTransportAuth(struct tpm_buffer * tb,
TPM_TRANSPORT_AUTH * tta)
{
uint32_t ret = 0;
ret = TSS_buildbuff(FORMAT_TPM_TRANSPORT_AUTH, tb,
PARAMS_TPM_TRANSPORT_AUTH_W(tta));
return ret;
}
uint32_t TPM_WriteTransportPublic(struct tpm_buffer * tb,
TPM_TRANSPORT_PUBLIC * ttp)
{
uint32_t ret = 0;
ret = TSS_buildbuff(FORMAT_TPM_TRANSPORT_PUBLIC, tb,
PARAMS_TPM_TRANSPORT_PUBLIC_W(ttp));
return ret;
}
uint32_t TPM_WriteCounterValue(struct tpm_buffer * tb,
TPM_COUNTER_VALUE * ctr)
{
uint32_t ret = 0;
ret = TSS_buildbuff(FORMAT_TPM_COUNTER_VALUE, tb,
PARAMS_TPM_COUNTER_VALUE_W(ctr));
return ret;
}
uint32_t TPM_WriteTPMDelegateKeyBlob(struct tpm_buffer * buffer,
TPM_DELEGATE_KEY_BLOB * tdob)
{
uint32_t ret;
ret = TSS_buildbuff(FORMAT_TPM_DELEGATE_KEY_BLOB, buffer,
PARAMS_TPM_DELEGATE_KEY_BLOB_W(tdob));
return ret;
}
uint32_t TPM_WriteTPMDelegations(struct tpm_buffer * buffer,
TPM_DELEGATIONS * td)
{
uint32_t ret;
ret = TSS_buildbuff(FORMAT_TPM_DELEGATIONS, buffer,
PARAMS_TPM_DELEGATIONS_W(td));
return ret;
}
uint32_t TPM_WriteMSAComposite(struct tpm_buffer *buffer, TPM_MSA_COMPOSITE * comp)
{
uint32_t ret;
ret = TSS_buildbuff("L %", buffer,
comp->MSAlist,
comp->MSAlist * TPM_HASH_SIZE, comp->migAuthDigest);
return ret;
}
uint32_t TPM_WriteCAContents(struct tpm_buffer * buffer,
TPM_ASYM_CA_CONTENTS * data)
{
uint32_t ret = 0;
ret = TSS_buildbuff(FORMAT_TPM_ASYM_CA_CONTENTS, buffer,
PARAMS_TPM_ASYM_CA_CONTENTS_W(data));
return ret;
}
uint32_t TPM_WriteKeyInfo(struct tpm_buffer *buffer, keydata *k)
{
uint32_t ret;
ret = TSS_buildbuff(FORMAT_TPM_KEY_PARMS_EMB_RSA, buffer,
PARAMS_TPM_KEY_PARMS_EMB_RSA_W(&k->pub.algorithmParms));
return ret;
}