Marshal_PolicyFidoSigned.c

/*
 * Copyright 2019 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.
 */
#include "MemoryLib_fp.h"
#include "PolicyFidoSigned_fp.h"

#if IS_CCE_ENABLED(PolicyFidoSigned)
/*
 * Marshal output data of PolicyFidoSigned command.
 *
 * @param source  input buffer of data to marshal
 * @param tag     Request tag
 * @param buffer  output buffer to write marshalled data
 * @param size    size of marshalled data
 * @return actual size of response excluding the size of the parameter field.
 */
static UINT16
PolicyFidoSigned_Out_Marshal(PolicyFidoSigned_Out* source,
                             TPMI_ST_COMMAND_TAG tag,
                             BYTE** buffer,
                             INT32* size)
{
  if (tag == TPM_ST_SESSIONS) {
    UINT32 param_size = 0;

    /* Add param_size=0 to indicate size of the parameter area. */
    UINT32_Marshal(&param_size, buffer, size);
  }

  return 0;
}

/*
 * Unmarshal input data of PolicyFidoSigned command.
 *
 * @param target       input buffer to unmarshal
 * @param req_handles
 * @param buffer       output buffer to write unmarshalled data
 * @param size         size of unmarshalled data.
 * @return TPM_RC_SUCCESS if processed successfully, or
 *         TPM_RC_SIZE if input data size is not correct, or
 *         TPM_RC_SCHEME if Authenticator algorithm is not specified, or
 *         TPM_RC_HASH if hash is missing or wrong.
 *
 *
 */
static TPM_RC
PolicyFidoSigned_In_Unmarshal(PolicyFidoSigned_In* target,
                              TPM_HANDLE req_handles[],
                              BYTE** buffer,
                              INT32* size)
{
  TPM_RC result = TPM_RC_SUCCESS;
  int i;

  /* Get request handles from req_handles array. */
  target->authObject = req_handles[0];
  target->policySession = req_handles[1];

  result = UINT16_Unmarshal(&target->authData.t.size, buffer, size);
  if (result != TPM_RC_SUCCESS)
    return result;

  if (target->authData.t.size > MAX_AUTH_DATA_SIZE ||
      target->authData.t.size == 0)
    return TPM_RC_SIZE;

  /* Unmarshall authData. */
  for (i = 0; i < target->authData.t.size; ++i) {
    result = BYTE_Unmarshal(&(target->authData.t.buffer[i]), buffer, size);
    if (result != TPM_RC_SUCCESS)
      return result;
  }

  /* Unmarshal request parameters. */
  result = UINT16_Unmarshal(&target->authDataDescrCount, buffer, size);
  if (result != TPM_RC_SUCCESS)
    return result;

  if (target->authDataDescrCount > sizeof(target->authDataDescr))
    return TPM_RC_SIZE;

  /* Unmarshall authDataDescr. */
  for (i = 0; i < target->authDataDescrCount; i++) {
    result = UINT16_Unmarshal(&(target->authDataDescr[i].offset), buffer, size);
    if (result != TPM_RC_SUCCESS)
      return result;

    result = UINT16_Unmarshal(&(target->authDataDescr[i].size), buffer, size);
    if (result != TPM_RC_SUCCESS)
      return result;

    /* The range size should be non-zero. */
    if (target->authDataDescr[i].size == 0)
      return TPM_RC_VALUE;

    /* The range is beyond the actual authData string */
    if (target->authDataDescr[i].offset + target->authDataDescr[i].size >
        target->authData.t.size)
      return TPM_RC_VALUE;
  }

  result = TPMT_SIGNATURE_Unmarshal(&target->auth, buffer, size);
  if (result != TPM_RC_SUCCESS)
    return result;

  /* Size should be zero. */
  if (*size)
    return TPM_RC_SIZE;

  return result;
}

TPM_RC Exec_PolicyFidoSigned(TPMI_ST_COMMAND_TAG tag,
                             BYTE** req_param_buffer,
                             INT32* req_param_buffer_size,
                             TPM_HANDLE req_handles[],
                             UINT32* resp_handle_buf_size,
                             UINT32* resp_param_buf_size)
{
  TPM_RC result = TPM_RC_SUCCESS;
  PolicyFidoSigned_In in;
  PolicyFidoSigned_Out out;
  BYTE* resp_buf;
  INT32 resp_buf_size;
  const INT32 resp_header_size = sizeof(TPM_ST) + sizeof(UINT32) +
                                 sizeof(TPM_RC);

  *resp_handle_buf_size = 0;
  *resp_param_buf_size = 0;

  /* Unmarshal request parameters to input structure. */
  result = PolicyFidoSigned_In_Unmarshal(&in,
                                         req_handles,
                                         req_param_buffer,
                                         req_param_buffer_size);
  if (result != TPM_RC_SUCCESS)
    return result;

  /* Execute command. */
  result = TPM2_PolicyFidoSigned(&in, &out);
  if (result != TPM_RC_SUCCESS)
    return result;

  /* Marshal output structure to global response buffer. */
  resp_buf = MemoryGetResponseBuffer(TPM_CCE_PolicyFidoSigned)
             + resp_header_size;
  resp_buf_size = MAX_RESPONSE_SIZE - resp_header_size;

  *resp_param_buf_size = PolicyFidoSigned_Out_Marshal(&out,
                                                      tag,
                                                      &resp_buf,
                                                      &resp_buf_size);
  return TPM_RC_SUCCESS;
}
#endif    /* IS_CCE_ENABLED(PolicyFidoSigned) */