b2549b4d34
The TPM2_PCR_Event command is introduced to tss2 to allow the user to extend a specific PCR. The related data structure and unmarshal function are also introduced. However, simply invoking TPM2_PCR_Event does not automatically record the event into the TPM event log. The TPM event log is primarily maintained by the system firmware (e.g., BIOS/UEFI). Therefore, for most standard use cases, the recommended method for extending PCRs and ensuring proper event logging is to utilize the system firmware functions. There are specific scenarios where direct use of TPM2_PCR_Event becomes necessary. For instance, in environments lacking system firmware support for PCR extension, such as the grub-emu, TPM2_PCR_Event serves as the only available method to extend PCRs. Signed-off-by: Gary Lin <glin@suse.com> Reviewed-by: Sudhakar Kuppusamy <sudhakar@linux.ibm.com> Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
1232 lines
34 KiB
C
1232 lines
34 KiB
C
/*
|
|
* GRUB -- GRand Unified Bootloader
|
|
* Copyright (C) 2022 Microsoft Corporation
|
|
* Copyright (C) 2024 Free Software Foundation, Inc.
|
|
*
|
|
* GRUB is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* GRUB is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <grub/mm.h>
|
|
#include <grub/misc.h>
|
|
|
|
#include <tss2_mu.h>
|
|
|
|
void
|
|
grub_Tss2_MU_TPMS_AUTH_COMMAND_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMS_AUTH_COMMAND_t *authCommand)
|
|
{
|
|
grub_uint32_t start;
|
|
grub_uint32_t tmp;
|
|
|
|
grub_tpm2_buffer_pack_u32 (buffer, 0);
|
|
start = buffer->size;
|
|
|
|
grub_tpm2_buffer_pack_u32 (buffer, authCommand->sessionHandle);
|
|
|
|
grub_tpm2_buffer_pack_u16 (buffer, authCommand->nonce.size);
|
|
grub_tpm2_buffer_pack (buffer, authCommand->nonce.buffer, authCommand->nonce.size);
|
|
|
|
grub_tpm2_buffer_pack_u8 (buffer, *((const grub_uint8_t *) &authCommand->sessionAttributes));
|
|
|
|
grub_tpm2_buffer_pack_u16 (buffer, authCommand->hmac.size);
|
|
grub_tpm2_buffer_pack (buffer, authCommand->hmac.buffer, authCommand->hmac.size);
|
|
|
|
tmp = grub_cpu_to_be32 (buffer->size - start);
|
|
grub_memcpy (&buffer->data[start - sizeof (grub_uint32_t)], &tmp, sizeof (tmp));
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPM2B_Marshal (grub_tpm2_buffer_t buffer,
|
|
const grub_uint16_t size,
|
|
const grub_uint8_t *b)
|
|
{
|
|
grub_uint16_t i;
|
|
|
|
grub_tpm2_buffer_pack_u16 (buffer, size);
|
|
|
|
for (i = 0; i < size; i++)
|
|
grub_tpm2_buffer_pack_u8 (buffer, b[i]);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMU_SYM_KEY_BITS_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMI_ALG_SYM_OBJECT_t algorithm,
|
|
const TPMU_SYM_KEY_BITS_t *p)
|
|
{
|
|
switch (algorithm)
|
|
{
|
|
case TPM_ALG_AES:
|
|
case TPM_ALG_SM4:
|
|
case TPM_ALG_CAMELLIA:
|
|
case TPM_ALG_XOR:
|
|
grub_tpm2_buffer_pack_u16 (buffer, *((const grub_uint16_t *) p));
|
|
break;
|
|
case TPM_ALG_NULL:
|
|
break;
|
|
default:
|
|
buffer->error = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMU_SYM_MODE_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMI_ALG_SYM_OBJECT_t algorithm,
|
|
const TPMU_SYM_MODE_t *p)
|
|
{
|
|
switch (algorithm)
|
|
{
|
|
case TPM_ALG_AES:
|
|
case TPM_ALG_SM4:
|
|
case TPM_ALG_CAMELLIA:
|
|
grub_tpm2_buffer_pack_u16 (buffer, *((const grub_uint16_t *) p));
|
|
break;
|
|
case TPM_ALG_XOR:
|
|
case TPM_ALG_NULL:
|
|
break;
|
|
default:
|
|
buffer->error = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMT_SYM_DEF_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMT_SYM_DEF_t *p)
|
|
{
|
|
grub_tpm2_buffer_pack_u16 (buffer, p->algorithm);
|
|
grub_Tss2_MU_TPMU_SYM_KEY_BITS_Marshal (buffer, p->algorithm, &p->keyBits);
|
|
grub_Tss2_MU_TPMU_SYM_MODE_Marshal (buffer, p->algorithm, &p->mode);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMS_PCR_SELECTION_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMS_PCR_SELECTION_t *pcrSelection)
|
|
{
|
|
grub_uint32_t i;
|
|
|
|
grub_tpm2_buffer_pack_u16 (buffer, pcrSelection->hash);
|
|
grub_tpm2_buffer_pack_u8 (buffer, pcrSelection->sizeOfSelect);
|
|
|
|
for (i = 0; i < pcrSelection->sizeOfSelect; i++)
|
|
grub_tpm2_buffer_pack_u8 (buffer, pcrSelection->pcrSelect[i]);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPML_PCR_SELECTION_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPML_PCR_SELECTION_t *pcrSelection)
|
|
{
|
|
grub_uint32_t i;
|
|
|
|
grub_tpm2_buffer_pack_u32 (buffer, pcrSelection->count);
|
|
|
|
for (i = 0; i < pcrSelection->count; i++)
|
|
grub_Tss2_MU_TPMS_PCR_SELECTION_Marshal (buffer, &pcrSelection->pcrSelections[i]);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMA_OBJECT_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMA_OBJECT_t *p)
|
|
{
|
|
grub_tpm2_buffer_pack_u32 (buffer, *((const grub_uint32_t *) p));
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMS_SCHEME_XOR_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMS_SCHEME_XOR_t *p)
|
|
{
|
|
grub_tpm2_buffer_pack_u16 (buffer, p->hashAlg);
|
|
grub_tpm2_buffer_pack_u16 (buffer, p->kdf);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMS_SCHEME_HMAC_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMS_SCHEME_HMAC_t *p)
|
|
{
|
|
grub_tpm2_buffer_pack_u16 (buffer, p->hashAlg);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMU_SCHEME_KEYEDHASH_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMI_ALG_KEYEDHASH_SCHEME_t scheme,
|
|
const TPMU_SCHEME_KEYEDHASH_t *p)
|
|
{
|
|
switch (scheme)
|
|
{
|
|
case TPM_ALG_HMAC:
|
|
grub_Tss2_MU_TPMS_SCHEME_HMAC_Marshal (buffer, &p->hmac);
|
|
break;
|
|
case TPM_ALG_XOR:
|
|
grub_Tss2_MU_TPMS_SCHEME_XOR_Marshal (buffer, &p->exclusiveOr);
|
|
break;
|
|
case TPM_ALG_NULL:
|
|
break;
|
|
default:
|
|
buffer->error = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMT_KEYEDHASH_SCHEME_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMT_KEYEDHASH_SCHEME_t *p)
|
|
{
|
|
grub_tpm2_buffer_pack_u16 (buffer, p->scheme);
|
|
grub_Tss2_MU_TPMU_SCHEME_KEYEDHASH_Marshal (buffer, p->scheme, &p->details);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMS_KEYEDHASH_PARMS_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMS_KEYEDHASH_PARMS_t *p)
|
|
{
|
|
grub_Tss2_MU_TPMT_KEYEDHASH_SCHEME_Marshal (buffer, &p->scheme);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMT_SYM_DEF_OBJECT_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMT_SYM_DEF_OBJECT_t *p)
|
|
{
|
|
grub_tpm2_buffer_pack_u16 (buffer, p->algorithm);
|
|
grub_Tss2_MU_TPMU_SYM_KEY_BITS_Marshal (buffer, p->algorithm, &p->keyBits);
|
|
grub_Tss2_MU_TPMU_SYM_MODE_Marshal (buffer, p->algorithm, &p->mode);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMU_ASYM_SCHEME_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMI_ALG_RSA_DECRYPT_t scheme,
|
|
const TPMU_ASYM_SCHEME_t *p __attribute__ ((unused)))
|
|
{
|
|
switch (scheme)
|
|
{
|
|
case TPM_ALG_NULL:
|
|
break;
|
|
default:
|
|
/* Unsupported */
|
|
buffer->error = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMT_RSA_SCHEME_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMT_RSA_SCHEME_t *p)
|
|
{
|
|
grub_tpm2_buffer_pack_u16 (buffer, p->scheme);
|
|
grub_Tss2_MU_TPMU_ASYM_SCHEME_Marshal (buffer, p->scheme, &p->details);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMS_RSA_PARMS_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMS_RSA_PARMS_t *p)
|
|
{
|
|
grub_Tss2_MU_TPMT_SYM_DEF_OBJECT_Marshal (buffer, &p->symmetric);
|
|
grub_Tss2_MU_TPMT_RSA_SCHEME_Marshal (buffer, &p->scheme);
|
|
grub_tpm2_buffer_pack_u16 (buffer, p->keyBits);
|
|
grub_tpm2_buffer_pack_u32 (buffer, p->exponent);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMS_SYMCIPHER_PARMS_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMS_SYMCIPHER_PARMS_t *p)
|
|
{
|
|
grub_Tss2_MU_TPMT_SYM_DEF_OBJECT_Marshal (buffer, &p->sym);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMT_ECC_SCHEME_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMT_ECC_SCHEME_t *p)
|
|
{
|
|
grub_tpm2_buffer_pack_u16 (buffer, p->scheme);
|
|
grub_Tss2_MU_TPMU_ASYM_SCHEME_Marshal (buffer, p->scheme, &p->details);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMU_KDF_SCHEME_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMI_ALG_KDF_t scheme,
|
|
const TPMU_KDF_SCHEME_t *p)
|
|
{
|
|
switch (scheme)
|
|
{
|
|
case TPM_ALG_MGF1:
|
|
grub_tpm2_buffer_pack_u16 (buffer, p->mgf1.hashAlg);
|
|
break;
|
|
case TPM_ALG_KDF1_SP800_56A:
|
|
grub_tpm2_buffer_pack_u16 (buffer, p->kdf1_sp800_56a.hashAlg);
|
|
break;
|
|
case TPM_ALG_KDF2:
|
|
grub_tpm2_buffer_pack_u16 (buffer, p->kdf2.hashAlg);
|
|
break;
|
|
case TPM_ALG_KDF1_SP800_108:
|
|
grub_tpm2_buffer_pack_u16 (buffer, p->kdf1_sp800_108.hashAlg);
|
|
break;
|
|
case TPM_ALG_NULL:
|
|
break;
|
|
default:
|
|
buffer->error = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMT_KDF_SCHEME_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMT_KDF_SCHEME_t *p)
|
|
{
|
|
grub_tpm2_buffer_pack_u16 (buffer, p->scheme);
|
|
grub_Tss2_MU_TPMU_KDF_SCHEME_Marshal (buffer, p->scheme, &p->details);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMS_ECC_PARMS_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMS_ECC_PARMS_t *p)
|
|
{
|
|
grub_Tss2_MU_TPMT_SYM_DEF_OBJECT_Marshal (buffer, &p->symmetric);
|
|
grub_Tss2_MU_TPMT_ECC_SCHEME_Marshal (buffer, &p->scheme);
|
|
grub_tpm2_buffer_pack_u16 (buffer, p->curveID);
|
|
grub_Tss2_MU_TPMT_KDF_SCHEME_Marshal (buffer, &p->kdf);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMU_PUBLIC_PARMS_Marshal (grub_tpm2_buffer_t buffer,
|
|
const grub_uint32_t type,
|
|
const TPMU_PUBLIC_PARMS_t *p)
|
|
{
|
|
switch (type)
|
|
{
|
|
case TPM_ALG_KEYEDHASH:
|
|
grub_Tss2_MU_TPMS_KEYEDHASH_PARMS_Marshal (buffer, &p->keyedHashDetail);
|
|
break;
|
|
case TPM_ALG_SYMCIPHER:
|
|
grub_Tss2_MU_TPMS_SYMCIPHER_PARMS_Marshal (buffer, &p->symDetail);
|
|
break;
|
|
case TPM_ALG_RSA:
|
|
grub_Tss2_MU_TPMS_RSA_PARMS_Marshal (buffer, &p->rsaDetail);
|
|
break;
|
|
case TPM_ALG_ECC:
|
|
grub_Tss2_MU_TPMS_ECC_PARMS_Marshal (buffer, &p->eccDetail);
|
|
break;
|
|
default:
|
|
buffer->error = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMS_ECC_POINT_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMS_ECC_POINT_t *p)
|
|
{
|
|
grub_Tss2_MU_TPM2B_Marshal (buffer, p->x.size, p->x.buffer);
|
|
grub_Tss2_MU_TPM2B_Marshal (buffer, p->y.size, p->y.buffer);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMU_PUBLIC_ID_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMI_ALG_PUBLIC_t type,
|
|
const TPMU_PUBLIC_ID_t *p)
|
|
{
|
|
switch(type)
|
|
{
|
|
case TPM_ALG_KEYEDHASH:
|
|
grub_Tss2_MU_TPM2B_Marshal (buffer, p->keyedHash.size, p->keyedHash.buffer);
|
|
break;
|
|
case TPM_ALG_SYMCIPHER:
|
|
grub_Tss2_MU_TPM2B_Marshal (buffer, p->sym.size, p->sym.buffer);
|
|
break;
|
|
case TPM_ALG_RSA:
|
|
grub_Tss2_MU_TPM2B_Marshal (buffer, p->rsa.size, p->rsa.buffer);
|
|
break;
|
|
case TPM_ALG_ECC:
|
|
grub_Tss2_MU_TPMS_ECC_POINT_Marshal (buffer, &p->ecc);
|
|
break;
|
|
default:
|
|
buffer->error = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMT_PUBLIC_PARMS_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMT_PUBLIC_PARMS_t *p)
|
|
{
|
|
grub_tpm2_buffer_pack_u16 (buffer, p->type);
|
|
grub_Tss2_MU_TPMU_PUBLIC_PARMS_Marshal (buffer, p->type, &p->parameters);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMT_PUBLIC_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMT_PUBLIC_t *p)
|
|
{
|
|
grub_tpm2_buffer_pack_u16 (buffer, p->type);
|
|
grub_tpm2_buffer_pack_u16 (buffer, p->nameAlg);
|
|
grub_Tss2_MU_TPMA_OBJECT_Marshal (buffer, &p->objectAttributes);
|
|
grub_Tss2_MU_TPM2B_Marshal (buffer, p->authPolicy.size, p->authPolicy.buffer);
|
|
grub_Tss2_MU_TPMU_PUBLIC_PARMS_Marshal (buffer, p->type, &p->parameters);
|
|
grub_Tss2_MU_TPMU_PUBLIC_ID_Marshal (buffer, p->type, &p->unique);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPM2B_PUBLIC_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPM2B_PUBLIC_t *p)
|
|
{
|
|
grub_uint32_t start;
|
|
grub_uint16_t size;
|
|
|
|
if (p)
|
|
{
|
|
grub_tpm2_buffer_pack_u16 (buffer, p->size);
|
|
|
|
start = buffer->size;
|
|
grub_Tss2_MU_TPMT_PUBLIC_Marshal (buffer, &p->publicArea);
|
|
size = grub_cpu_to_be16 (buffer->size - start);
|
|
grub_memcpy (&buffer->data[start - sizeof (grub_uint16_t)], &size, sizeof (size));
|
|
}
|
|
else
|
|
grub_tpm2_buffer_pack_u16 (buffer, 0);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMS_SENSITIVE_CREATE_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMS_SENSITIVE_CREATE_t *p)
|
|
{
|
|
grub_Tss2_MU_TPM2B_Marshal (buffer, p->userAuth.size, p->userAuth.buffer);
|
|
grub_Tss2_MU_TPM2B_Marshal (buffer, p->data.size, p->data.buffer);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMU_SENSITIVE_COMPOSITE_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMI_ALG_PUBLIC_t type,
|
|
const TPMU_SENSITIVE_COMPOSITE_t *p)
|
|
{
|
|
switch(type)
|
|
{
|
|
case TPM_ALG_RSA:
|
|
grub_Tss2_MU_TPM2B_Marshal (buffer, p->rsa.size, p->rsa.buffer);
|
|
break;
|
|
case TPM_ALG_ECC:
|
|
grub_Tss2_MU_TPM2B_Marshal (buffer, p->ecc.size, p->ecc.buffer);
|
|
break;
|
|
case TPM_ALG_KEYEDHASH:
|
|
grub_Tss2_MU_TPM2B_Marshal (buffer, p->bits.size, p->bits.buffer);
|
|
break;
|
|
case TPM_ALG_SYMCIPHER:
|
|
grub_Tss2_MU_TPM2B_Marshal (buffer, p->sym.size, p->sym.buffer);
|
|
break;
|
|
default:
|
|
buffer->error = 1;
|
|
}
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMT_SENSITIVE_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMT_SENSITIVE_t *p)
|
|
{
|
|
grub_tpm2_buffer_pack_u16 (buffer, p->sensitiveType);
|
|
grub_Tss2_MU_TPM2B_Marshal (buffer, p->authValue.size, p->authValue.buffer);
|
|
grub_Tss2_MU_TPM2B_Marshal (buffer, p->seedValue.size, p->seedValue.buffer);
|
|
grub_Tss2_MU_TPMU_SENSITIVE_COMPOSITE_Marshal (buffer, p->sensitiveType, &p->sensitive);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPM2B_SENSITIVE_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPM2B_SENSITIVE_t *p)
|
|
{
|
|
grub_tpm2_buffer_pack_u16 (buffer, p->size);
|
|
grub_Tss2_MU_TPMT_SENSITIVE_Marshal (buffer, &p->sensitiveArea);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPM2B_SENSITIVE_CREATE_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPM2B_SENSITIVE_CREATE_t *sensitiveCreate)
|
|
{
|
|
grub_uint32_t start;
|
|
grub_uint16_t size;
|
|
|
|
if (sensitiveCreate)
|
|
{
|
|
grub_tpm2_buffer_pack_u16 (buffer, sensitiveCreate->size);
|
|
start = buffer->size;
|
|
grub_Tss2_MU_TPMS_SENSITIVE_CREATE_Marshal (buffer, &sensitiveCreate->sensitive);
|
|
size = grub_cpu_to_be16 (buffer->size - start);
|
|
|
|
grub_memcpy (&buffer->data[start - sizeof (grub_uint16_t)], &size, sizeof (size));
|
|
}
|
|
else
|
|
grub_tpm2_buffer_pack_u16 (buffer, 0);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMS_SIGNATURE_RSA_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMS_SIGNATURE_RSA_t *p)
|
|
{
|
|
grub_tpm2_buffer_pack_u16 (buffer, p->hash);
|
|
grub_Tss2_MU_TPM2B_Marshal (buffer, p->sig.size, p->sig.buffer);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMS_SIGNATURE_ECC_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMS_SIGNATURE_ECC_t *p)
|
|
{
|
|
grub_tpm2_buffer_pack_u16 (buffer, p->hash);
|
|
grub_Tss2_MU_TPM2B_Marshal (buffer, p->signatureR.size, p->signatureR.buffer);
|
|
grub_Tss2_MU_TPM2B_Marshal (buffer, p->signatureS.size, p->signatureS.buffer);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMU_HA_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMI_ALG_HASH_t hashAlg,
|
|
const TPMU_HA_t *p)
|
|
{
|
|
grub_uint16_t i;
|
|
|
|
switch (hashAlg)
|
|
{
|
|
case TPM_ALG_SHA1:
|
|
for (i = 0; i < TPM_SHA1_DIGEST_SIZE; i++)
|
|
grub_tpm2_buffer_pack_u8 (buffer, p->sha1[i]);
|
|
break;
|
|
case TPM_ALG_SHA256:
|
|
for (i = 0; i < TPM_SHA256_DIGEST_SIZE; i++)
|
|
grub_tpm2_buffer_pack_u8 (buffer, p->sha256[i]);
|
|
break;
|
|
case TPM_ALG_SHA384:
|
|
for (i = 0; i < TPM_SHA384_DIGEST_SIZE; i++)
|
|
grub_tpm2_buffer_pack_u8 (buffer, p->sha384[i]);
|
|
break;
|
|
case TPM_ALG_SHA512:
|
|
for (i = 0; i < TPM_SHA512_DIGEST_SIZE; i++)
|
|
grub_tpm2_buffer_pack_u8 (buffer, p->sha512[i]);
|
|
break;
|
|
default:
|
|
buffer->error = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMT_HA_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMT_HA_t *p)
|
|
{
|
|
grub_tpm2_buffer_pack_u16 (buffer, p->hashAlg);
|
|
grub_Tss2_MU_TPMU_HA_Marshal (buffer, p->hashAlg, &p->digest);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMU_SIGNATURE_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMI_ALG_SIG_SCHEME_t sigAlg,
|
|
const TPMU_SIGNATURE_t *p)
|
|
{
|
|
switch (sigAlg)
|
|
{
|
|
case TPM_ALG_RSASSA:
|
|
grub_Tss2_MU_TPMS_SIGNATURE_RSA_Marshal (buffer, (TPMS_SIGNATURE_RSA_t *) &p->rsassa);
|
|
break;
|
|
case TPM_ALG_RSAPSS:
|
|
grub_Tss2_MU_TPMS_SIGNATURE_RSA_Marshal (buffer, (TPMS_SIGNATURE_RSA_t *) &p->rsapss);
|
|
break;
|
|
case TPM_ALG_ECDSA:
|
|
grub_Tss2_MU_TPMS_SIGNATURE_ECC_Marshal (buffer, (TPMS_SIGNATURE_ECC_t *) &p->ecdsa);
|
|
break;
|
|
case TPM_ALG_ECDAA:
|
|
grub_Tss2_MU_TPMS_SIGNATURE_ECC_Marshal (buffer, (TPMS_SIGNATURE_ECC_t *) &p->ecdaa);
|
|
break;
|
|
case TPM_ALG_SM2:
|
|
grub_Tss2_MU_TPMS_SIGNATURE_ECC_Marshal (buffer, (TPMS_SIGNATURE_ECC_t *) &p->sm2);
|
|
break;
|
|
case TPM_ALG_ECSCHNORR:
|
|
grub_Tss2_MU_TPMS_SIGNATURE_ECC_Marshal (buffer, (TPMS_SIGNATURE_ECC_t *) &p->ecschnorr);
|
|
break;
|
|
case TPM_ALG_HMAC:
|
|
grub_Tss2_MU_TPMT_HA_Marshal (buffer, &p->hmac);
|
|
break;
|
|
case TPM_ALG_NULL:
|
|
break;
|
|
default:
|
|
buffer->error = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMT_SIGNATURE_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMT_SIGNATURE_t *p)
|
|
{
|
|
grub_tpm2_buffer_pack_u16 (buffer, p->sigAlg);
|
|
grub_Tss2_MU_TPMU_SIGNATURE_Marshal (buffer, p->sigAlg, &p->signature);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMT_TK_VERIFIED_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMT_TK_VERIFIED_t *p)
|
|
{
|
|
grub_tpm2_buffer_pack_u16 (buffer, p->tag);
|
|
grub_tpm2_buffer_pack_u32 (buffer, p->hierarchy);
|
|
grub_Tss2_MU_TPM2B_Marshal (buffer, p->digest.size, p->digest.buffer);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMS_NV_PUBLIC_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPMS_NV_PUBLIC_t *p)
|
|
{
|
|
grub_tpm2_buffer_pack_u32 (buffer, p->nvIndex);
|
|
grub_tpm2_buffer_pack_u16 (buffer, p->nameAlg);
|
|
grub_tpm2_buffer_pack_u32 (buffer, p->attributes);
|
|
grub_Tss2_MU_TPM2B_Marshal (buffer, p->authPolicy.size, p->authPolicy.buffer);
|
|
grub_tpm2_buffer_pack_u16 (buffer, p->dataSize);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPM2B_NV_PUBLIC_Marshal (grub_tpm2_buffer_t buffer,
|
|
const TPM2B_NV_PUBLIC_t *p)
|
|
{
|
|
grub_uint32_t start;
|
|
grub_uint16_t size;
|
|
|
|
if (p != NULL)
|
|
{
|
|
grub_tpm2_buffer_pack_u16 (buffer, p->size);
|
|
|
|
start = buffer->size;
|
|
grub_Tss2_MU_TPMS_NV_PUBLIC_Marshal (buffer, &p->nvPublic);
|
|
size = grub_cpu_to_be16 (buffer->size - start);
|
|
grub_memcpy (&buffer->data[start - sizeof (grub_uint16_t)], &size, sizeof (size));
|
|
}
|
|
else
|
|
grub_tpm2_buffer_pack_u16 (buffer, 0);
|
|
}
|
|
|
|
static void
|
|
__Tss2_MU_TPM2B_BUFFER_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPM2B_t *p, grub_uint16_t bound)
|
|
{
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &p->size);
|
|
|
|
if (p->size > bound)
|
|
{
|
|
buffer->error = 1;
|
|
return;
|
|
}
|
|
|
|
grub_tpm2_buffer_unpack (buffer, &p->buffer, p->size);
|
|
}
|
|
|
|
#define TPM2B_BUFFER_UNMARSHAL(buffer, type, data) \
|
|
__Tss2_MU_TPM2B_BUFFER_Unmarshal(buffer, (TPM2B_t *)data, sizeof(type) - sizeof(grub_uint16_t))
|
|
|
|
void
|
|
grub_Tss2_MU_TPMS_AUTH_RESPONSE_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMS_AUTH_RESPONSE_t *p)
|
|
{
|
|
grub_uint8_t tmp;
|
|
grub_uint32_t tmp32;
|
|
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &p->nonce.size);
|
|
|
|
if (p->nonce.size)
|
|
grub_tpm2_buffer_unpack (buffer, &p->nonce.buffer, p->nonce.size);
|
|
|
|
grub_tpm2_buffer_unpack_u8 (buffer, &tmp);
|
|
tmp32 = tmp;
|
|
grub_memcpy (&p->sessionAttributes, &tmp32, sizeof (grub_uint32_t));
|
|
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &p->hmac.size);
|
|
|
|
if (p->hmac.size)
|
|
grub_tpm2_buffer_unpack (buffer, &p->hmac.buffer, p->hmac.size);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPM2B_DIGEST_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPM2B_DIGEST_t *digest)
|
|
{
|
|
TPM2B_BUFFER_UNMARSHAL (buffer, TPM2B_DIGEST_t, digest);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPM2B_NONCE_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPM2B_NONCE_t *nonce)
|
|
{
|
|
TPM2B_BUFFER_UNMARSHAL (buffer, TPM2B_NONCE_t, nonce);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPM2B_DATA_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPM2B_DATA_t *data)
|
|
{
|
|
TPM2B_BUFFER_UNMARSHAL (buffer, TPM2B_DATA_t, data);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMS_CREATION_DATA_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMS_CREATION_DATA_t *data)
|
|
{
|
|
grub_Tss2_MU_TPML_PCR_SELECTION_Unmarshal (buffer, &data->pcrSelect);
|
|
grub_Tss2_MU_TPM2B_DIGEST_Unmarshal (buffer, &data->pcrDigest);
|
|
grub_tpm2_buffer_unpack_u8 (buffer, (grub_uint8_t *)&data->locality);
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &data->parentNameAlg);
|
|
grub_Tss2_MU_TPM2B_NAME_Unmarshal (buffer, &data->parentName);
|
|
grub_Tss2_MU_TPM2B_NAME_Unmarshal (buffer, &data->parentQualifiedName);
|
|
grub_Tss2_MU_TPM2B_DATA_Unmarshal (buffer, &data->outsideInfo);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPM2B_CREATION_DATA_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPM2B_CREATION_DATA_t *data)
|
|
{
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &data->size);
|
|
grub_Tss2_MU_TPMS_CREATION_DATA_Unmarshal (buffer, &data->creationData);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPM2B_PRIVATE_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPM2B_PRIVATE_t *private)
|
|
{
|
|
TPM2B_BUFFER_UNMARSHAL (buffer, TPM2B_PRIVATE_t, private);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPM2B_SENSITIVE_DATA_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPM2B_SENSITIVE_DATA_t *data)
|
|
{
|
|
TPM2B_BUFFER_UNMARSHAL (buffer, TPM2B_SENSITIVE_DATA_t, data);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPM2B_PUBLIC_KEY_RSA_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPM2B_PUBLIC_KEY_RSA_t *rsa)
|
|
{
|
|
TPM2B_BUFFER_UNMARSHAL (buffer, TPM2B_PUBLIC_KEY_RSA_t, rsa);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPM2B_ECC_PARAMETER_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPM2B_ECC_PARAMETER_t *param)
|
|
{
|
|
TPM2B_BUFFER_UNMARSHAL (buffer, TPM2B_ECC_PARAMETER_t, param);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMA_OBJECT_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMA_OBJECT_t *p)
|
|
{
|
|
grub_tpm2_buffer_unpack_u32 (buffer, (grub_uint32_t *) p);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMS_SCHEME_HMAC_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMS_SCHEME_HMAC_t *p)
|
|
{
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &p->hashAlg);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMS_SCHEME_XOR_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMS_SCHEME_XOR_t *p)
|
|
{
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &p->hashAlg);
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &p->kdf);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMU_SCHEME_KEYEDHASH_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMI_ALG_KEYEDHASH_SCHEME_t scheme,
|
|
TPMU_SCHEME_KEYEDHASH_t *p)
|
|
{
|
|
switch (scheme)
|
|
{
|
|
case TPM_ALG_HMAC:
|
|
grub_Tss2_MU_TPMS_SCHEME_HMAC_Unmarshal (buffer, &p->hmac);
|
|
break;
|
|
case TPM_ALG_XOR:
|
|
grub_Tss2_MU_TPMS_SCHEME_XOR_Unmarshal (buffer, &p->exclusiveOr);
|
|
break;
|
|
case TPM_ALG_NULL:
|
|
break;
|
|
default:
|
|
buffer->error = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMT_KEYEDHASH_SCHEME_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMT_KEYEDHASH_SCHEME_t *p)
|
|
{
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &p->scheme);
|
|
grub_Tss2_MU_TPMU_SCHEME_KEYEDHASH_Unmarshal (buffer, p->scheme, &p->details);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMS_KEYEDHASH_PARMS_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMS_KEYEDHASH_PARMS_t *p)
|
|
{
|
|
grub_Tss2_MU_TPMT_KEYEDHASH_SCHEME_Unmarshal (buffer, &p->scheme);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMU_SYM_KEY_BITS_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMI_ALG_SYM_OBJECT_t algorithm,
|
|
TPMU_SYM_KEY_BITS_t *p)
|
|
{
|
|
switch (algorithm)
|
|
{
|
|
case TPM_ALG_AES:
|
|
case TPM_ALG_SM4:
|
|
case TPM_ALG_CAMELLIA:
|
|
case TPM_ALG_XOR:
|
|
grub_tpm2_buffer_unpack_u16 (buffer, (grub_uint16_t *) p);
|
|
break;
|
|
case TPM_ALG_NULL:
|
|
break;
|
|
default:
|
|
buffer->error = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMU_SYM_MODE_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMI_ALG_SYM_OBJECT_t algorithm,
|
|
TPMU_SYM_MODE_t *p)
|
|
{
|
|
switch (algorithm)
|
|
{
|
|
case TPM_ALG_AES:
|
|
case TPM_ALG_SM4:
|
|
case TPM_ALG_CAMELLIA:
|
|
grub_tpm2_buffer_unpack_u16 (buffer, (grub_uint16_t *) p);
|
|
break;
|
|
case TPM_ALG_XOR:
|
|
case TPM_ALG_NULL:
|
|
break;
|
|
default:
|
|
buffer->error = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMT_SYM_DEF_OBJECT_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMT_SYM_DEF_OBJECT_t *p)
|
|
{
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &p->algorithm);
|
|
grub_Tss2_MU_TPMU_SYM_KEY_BITS_Unmarshal (buffer, p->algorithm, &p->keyBits);
|
|
grub_Tss2_MU_TPMU_SYM_MODE_Unmarshal (buffer, p->algorithm, &p->mode);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMS_SYMCIPHER_PARMS_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMS_SYMCIPHER_PARMS_t *p)
|
|
{
|
|
grub_Tss2_MU_TPMT_SYM_DEF_OBJECT_Unmarshal (buffer, &p->sym);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMU_ASYM_SCHEME_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMI_ALG_RSA_DECRYPT_t scheme,
|
|
TPMU_ASYM_SCHEME_t *p __attribute__((unused)))
|
|
{
|
|
switch (scheme)
|
|
{
|
|
case TPM_ALG_NULL:
|
|
break;
|
|
default:
|
|
/* Unsupported */
|
|
buffer->error = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMT_RSA_SCHEME_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMT_RSA_SCHEME_t *p)
|
|
{
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &p->scheme);
|
|
grub_Tss2_MU_TPMU_ASYM_SCHEME_Unmarshal (buffer, p->scheme, &p->details);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMS_RSA_PARMS_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMS_RSA_PARMS_t *p)
|
|
{
|
|
grub_Tss2_MU_TPMT_SYM_DEF_OBJECT_Unmarshal (buffer, &p->symmetric);
|
|
grub_Tss2_MU_TPMT_RSA_SCHEME_Unmarshal (buffer, &p->scheme);
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &p->keyBits);
|
|
grub_tpm2_buffer_unpack_u32 (buffer, &p->exponent);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMT_ECC_SCHEME_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMT_ECC_SCHEME_t *p)
|
|
{
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &p->scheme);
|
|
grub_Tss2_MU_TPMU_ASYM_SCHEME_Unmarshal (buffer, p->scheme, &p->details);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMU_KDF_SCHEME_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMI_ALG_KDF_t scheme,
|
|
TPMU_KDF_SCHEME_t *p)
|
|
{
|
|
switch (scheme)
|
|
{
|
|
case TPM_ALG_MGF1:
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &p->mgf1.hashAlg);
|
|
break;
|
|
case TPM_ALG_KDF1_SP800_56A:
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &p->kdf1_sp800_56a.hashAlg);
|
|
break;
|
|
case TPM_ALG_KDF2:
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &p->kdf2.hashAlg);
|
|
break;
|
|
case TPM_ALG_KDF1_SP800_108:
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &p->kdf1_sp800_108.hashAlg);
|
|
break;
|
|
case TPM_ALG_NULL:
|
|
break;
|
|
default:
|
|
buffer->error = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMT_KDF_SCHEME_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMT_KDF_SCHEME_t *p)
|
|
{
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &p->scheme);
|
|
grub_Tss2_MU_TPMU_KDF_SCHEME_Unmarshal (buffer, p->scheme, &p->details);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMS_ECC_PARMS_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMS_ECC_PARMS_t *p)
|
|
{
|
|
grub_Tss2_MU_TPMT_SYM_DEF_OBJECT_Unmarshal (buffer, &p->symmetric);
|
|
grub_Tss2_MU_TPMT_ECC_SCHEME_Unmarshal (buffer, &p->scheme );
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &p->curveID);
|
|
grub_Tss2_MU_TPMT_KDF_SCHEME_Unmarshal (buffer, &p->kdf);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMU_PUBLIC_PARMS_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
grub_uint32_t type,
|
|
TPMU_PUBLIC_PARMS_t *p)
|
|
{
|
|
switch (type)
|
|
{
|
|
case TPM_ALG_KEYEDHASH:
|
|
grub_Tss2_MU_TPMS_KEYEDHASH_PARMS_Unmarshal (buffer, &p->keyedHashDetail);
|
|
break;
|
|
case TPM_ALG_SYMCIPHER:
|
|
grub_Tss2_MU_TPMS_SYMCIPHER_PARMS_Unmarshal (buffer, &p->symDetail);
|
|
break;
|
|
case TPM_ALG_RSA:
|
|
grub_Tss2_MU_TPMS_RSA_PARMS_Unmarshal (buffer, &p->rsaDetail);
|
|
break;
|
|
case TPM_ALG_ECC:
|
|
grub_Tss2_MU_TPMS_ECC_PARMS_Unmarshal (buffer, &p->eccDetail);
|
|
break;
|
|
default:
|
|
buffer->error = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMS_ECC_POINT_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMS_ECC_POINT_t *p)
|
|
{
|
|
grub_Tss2_MU_TPM2B_ECC_PARAMETER_Unmarshal (buffer, &p->x);
|
|
grub_Tss2_MU_TPM2B_ECC_PARAMETER_Unmarshal (buffer, &p->y);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMU_PUBLIC_ID_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMI_ALG_PUBLIC_t type,
|
|
TPMU_PUBLIC_ID_t *p)
|
|
{
|
|
switch(type)
|
|
{
|
|
case TPM_ALG_KEYEDHASH:
|
|
grub_Tss2_MU_TPM2B_DIGEST_Unmarshal (buffer, &p->keyedHash);
|
|
break;
|
|
case TPM_ALG_SYMCIPHER:
|
|
grub_Tss2_MU_TPM2B_DIGEST_Unmarshal (buffer, &p->sym);
|
|
break;
|
|
case TPM_ALG_RSA:
|
|
grub_Tss2_MU_TPM2B_PUBLIC_KEY_RSA_Unmarshal (buffer, &p->rsa);
|
|
break;
|
|
case TPM_ALG_ECC:
|
|
grub_Tss2_MU_TPMS_ECC_POINT_Unmarshal (buffer, &p->ecc);
|
|
break;
|
|
default:
|
|
buffer->error = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMT_PUBLIC_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMT_PUBLIC_t *p)
|
|
{
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &p->type);
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &p->nameAlg);
|
|
grub_Tss2_MU_TPMA_OBJECT_Unmarshal (buffer, &p->objectAttributes);
|
|
grub_Tss2_MU_TPM2B_DIGEST_Unmarshal (buffer, &p->authPolicy);
|
|
grub_Tss2_MU_TPMU_PUBLIC_PARMS_Unmarshal (buffer, p->type, &p->parameters);
|
|
grub_Tss2_MU_TPMU_PUBLIC_ID_Unmarshal (buffer, p->type, &p->unique);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPM2B_PUBLIC_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPM2B_PUBLIC_t *p)
|
|
{
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &p->size);
|
|
grub_Tss2_MU_TPMT_PUBLIC_Unmarshal (buffer, &p->publicArea);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMS_NV_PUBLIC_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMS_NV_PUBLIC_t *p)
|
|
{
|
|
grub_tpm2_buffer_unpack_u32 (buffer, &p->nvIndex);
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &p->nameAlg);
|
|
grub_tpm2_buffer_unpack_u32 (buffer, &p->attributes);
|
|
grub_Tss2_MU_TPM2B_DIGEST_Unmarshal (buffer, &p->authPolicy);
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &p->dataSize);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPM2B_NV_PUBLIC_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPM2B_NV_PUBLIC_t *p)
|
|
{
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &p->size);
|
|
grub_Tss2_MU_TPMS_NV_PUBLIC_Unmarshal (buffer, &p->nvPublic);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPM2B_NAX_NV_BUFFER_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPM2B_MAX_NV_BUFFER_t *p)
|
|
{
|
|
TPM2B_BUFFER_UNMARSHAL (buffer, TPM2B_MAX_NV_BUFFER_t, p);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPM2B_NAME_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPM2B_NAME_t *n)
|
|
{
|
|
TPM2B_BUFFER_UNMARSHAL (buffer, TPM2B_NAME_t, n);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMS_TAGGED_PROPERTY_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMS_TAGGED_PROPERTY_t *property)
|
|
{
|
|
grub_tpm2_buffer_unpack_u32 (buffer, &property->property);
|
|
grub_tpm2_buffer_unpack_u32 (buffer, &property->value);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMT_TK_CREATION_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMT_TK_CREATION_t *p)
|
|
{
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &p->tag);
|
|
grub_tpm2_buffer_unpack_u32 (buffer, &p->hierarchy);
|
|
grub_Tss2_MU_TPM2B_DIGEST_Unmarshal (buffer, &p->digest);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMT_TK_HASHCHECK_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMT_TK_HASHCHECK_t *p)
|
|
{
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &p->tag);
|
|
grub_tpm2_buffer_unpack_u32 (buffer, &p->hierarchy);
|
|
grub_Tss2_MU_TPM2B_DIGEST_Unmarshal (buffer, &p->digest);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMT_TK_VERIFIED_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMT_TK_VERIFIED_t *p)
|
|
{
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &p->tag);
|
|
grub_tpm2_buffer_unpack_u32 (buffer, &p->hierarchy);
|
|
grub_Tss2_MU_TPM2B_DIGEST_Unmarshal (buffer, &p->digest);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMS_PCR_SELECTION_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMS_PCR_SELECTION_t *pcrSelection)
|
|
{
|
|
grub_uint32_t i;
|
|
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &pcrSelection->hash);
|
|
grub_tpm2_buffer_unpack_u8 (buffer, &pcrSelection->sizeOfSelect);
|
|
|
|
if (pcrSelection->sizeOfSelect > TPM_PCR_SELECT_MAX)
|
|
{
|
|
buffer->error = 1;
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < pcrSelection->sizeOfSelect; i++)
|
|
grub_tpm2_buffer_unpack_u8 (buffer, &pcrSelection->pcrSelect[i]);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPML_PCR_SELECTION_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPML_PCR_SELECTION_t *pcrSelection)
|
|
{
|
|
grub_uint32_t i;
|
|
|
|
grub_tpm2_buffer_unpack_u32 (buffer, &pcrSelection->count);
|
|
|
|
if (pcrSelection->count > TPM_NUM_PCR_BANKS)
|
|
{
|
|
buffer->error = 1;
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < pcrSelection->count; i++)
|
|
grub_Tss2_MU_TPMS_PCR_SELECTION_Unmarshal (buffer, &pcrSelection->pcrSelections[i]);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPML_DIGEST_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPML_DIGEST_t *digest)
|
|
{
|
|
grub_uint32_t i;
|
|
|
|
grub_tpm2_buffer_unpack_u32 (buffer, &digest->count);
|
|
|
|
if (digest->count > 8)
|
|
{
|
|
buffer->error = 1;
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < digest->count; i++)
|
|
grub_Tss2_MU_TPM2B_DIGEST_Unmarshal (buffer, &digest->digests[i]);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPML_DIGEST_VALUE_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPML_DIGEST_VALUES_t *digests)
|
|
{
|
|
grub_uint32_t i;
|
|
|
|
grub_tpm2_buffer_unpack_u32 (buffer, &digests->count);
|
|
|
|
if (digests->count > TPM_NUM_PCR_BANKS)
|
|
{
|
|
buffer->error = true;
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < digests->count; i++)
|
|
grub_Tss2_MU_TPMT_HA_Unmarshal (buffer, &digests->digests[i]);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMS_SIGNATURE_RSA_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMS_SIGNATURE_RSA_t *rsa)
|
|
{
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &rsa->hash);
|
|
grub_Tss2_MU_TPM2B_PUBLIC_KEY_RSA_Unmarshal (buffer, &rsa->sig);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMS_SIGNATURE_ECC_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMS_SIGNATURE_ECC_t *ecc)
|
|
{
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &ecc->hash);
|
|
grub_Tss2_MU_TPM2B_ECC_PARAMETER_Unmarshal (buffer, &ecc->signatureR);
|
|
grub_Tss2_MU_TPM2B_ECC_PARAMETER_Unmarshal (buffer, &ecc->signatureS);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMU_HA_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMI_ALG_HASH_t hashAlg,
|
|
TPMU_HA_t *p)
|
|
{
|
|
switch (hashAlg)
|
|
{
|
|
case TPM_ALG_SHA1:
|
|
grub_tpm2_buffer_unpack (buffer, &p->sha1, TPM_SHA1_DIGEST_SIZE);
|
|
break;
|
|
case TPM_ALG_SHA256:
|
|
grub_tpm2_buffer_unpack (buffer, &p->sha256, TPM_SHA256_DIGEST_SIZE);
|
|
break;
|
|
case TPM_ALG_SHA384:
|
|
grub_tpm2_buffer_unpack (buffer, &p->sha384, TPM_SHA384_DIGEST_SIZE);
|
|
break;
|
|
case TPM_ALG_SHA512:
|
|
grub_tpm2_buffer_unpack (buffer, &p->sha512, TPM_SHA512_DIGEST_SIZE);
|
|
break;
|
|
default:
|
|
buffer->error = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMT_HA_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMT_HA_t *p)
|
|
{
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &p->hashAlg);
|
|
grub_Tss2_MU_TPMU_HA_Unmarshal (buffer, p->hashAlg, &p->digest);
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMU_SIGNATURE_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMI_ALG_SIG_SCHEME_t sigAlg,
|
|
TPMU_SIGNATURE_t *p)
|
|
{
|
|
switch (sigAlg)
|
|
{
|
|
case TPM_ALG_RSASSA:
|
|
grub_Tss2_MU_TPMS_SIGNATURE_RSA_Unmarshal (buffer, (TPMS_SIGNATURE_RSA_t *)&p->rsassa);
|
|
break;
|
|
case TPM_ALG_RSAPSS:
|
|
grub_Tss2_MU_TPMS_SIGNATURE_RSA_Unmarshal (buffer, (TPMS_SIGNATURE_RSA_t *)&p->rsapss);
|
|
break;
|
|
case TPM_ALG_ECDSA:
|
|
grub_Tss2_MU_TPMS_SIGNATURE_ECC_Unmarshal (buffer, (TPMS_SIGNATURE_ECC_t *)&p->ecdsa);
|
|
break;
|
|
case TPM_ALG_ECDAA:
|
|
grub_Tss2_MU_TPMS_SIGNATURE_ECC_Unmarshal (buffer, (TPMS_SIGNATURE_ECC_t *)&p->ecdaa);
|
|
break;
|
|
case TPM_ALG_SM2:
|
|
grub_Tss2_MU_TPMS_SIGNATURE_ECC_Unmarshal (buffer, (TPMS_SIGNATURE_ECC_t *)&p->sm2);
|
|
break;
|
|
case TPM_ALG_ECSCHNORR:
|
|
grub_Tss2_MU_TPMS_SIGNATURE_ECC_Unmarshal (buffer, (TPMS_SIGNATURE_ECC_t *)&p->ecschnorr);
|
|
break;
|
|
case TPM_ALG_HMAC:
|
|
grub_Tss2_MU_TPMT_HA_Unmarshal (buffer, &p->hmac);
|
|
break;
|
|
case TPM_ALG_NULL:
|
|
break;
|
|
default:
|
|
buffer->error = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
grub_Tss2_MU_TPMT_SIGNATURE_Unmarshal (grub_tpm2_buffer_t buffer,
|
|
TPMT_SIGNATURE_t *p)
|
|
{
|
|
grub_tpm2_buffer_unpack_u16 (buffer, &p->sigAlg);
|
|
grub_Tss2_MU_TPMU_SIGNATURE_Unmarshal (buffer, p->sigAlg, &p->signature);
|
|
}
|