tpm_funcs.c

// SPDX-License-Identifier: MIT
/*
MIT License

Copyright (c) 2025 UBITECH Ltd (https://ubitech.eu)

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/

#include "tpm_funcs.h"

#include <ibmtss/TPM_Types.h>
#include <ibmtss/Unmarshal_fp.h>
#include <ibmtss/tss.h>
#include <ibmtss/tsscrypto.h>
#include <ibmtss/tssmarshal.h>
#include <ibmtss/tssresponsecode.h>
#include <ibmtss/tsstransmit.h>
#include <ibmtss/tssutils.h>
#include <string.h>

/**
 * Translate a TPM response code into a human-readable message and optionally exit.
 *
 * Parameters:
 * - last_err: TPM_RC error code.
 * - isCritical: If non-zero, the function terminates the process.
 */
void handle_TPM_error(TPM_RC last_err, int isCritical);

void handle_TPM_error(TPM_RC last_err, int isCritical) {
    const char* msg;
    const char* submsg;
    const char* num;

    TSS_ResponseCode_toString(&msg, &submsg, &num, last_err);

    printf("An error has occurred: %s%s%s\n", msg, submsg, num);

    if (isCritical) {
        exit(EXIT_FAILURE);
    }
}

/**
 * Initialize a TSS/TPM context and execute TPM2_Startup.
 *
 * Parameters:
 * - ctx: Optional pre-existing context (ignored, created internally).
 * - locality: Interface string (e.g., "/dev/tpmrm0" or hostname:port).
 *
 * Returns:
 * - Pointer to initialized TSS_CONTEXT, or NULL on failure.
 */
TSS_CONTEXT* start_tpm(TSS_CONTEXT* ctx, const char* locality) {
    TPM_RC     rc = 0;
    Startup_In in;
    TPM_SU     startupType = TPM_SU_CLEAR;

    if (rc == 0) {
        rc = TSS_Create(&ctx);
        if (rc != 0) {
            handle_TPM_error(rc, 1);
            return NULL;
        }
    }

    if ((rc == 0) && (locality != NULL)) {
        TSS_SetProperty(ctx, TPM_COMMAND_PORT, locality);
    } else if (rc == 0) {
        TSS_SetProperty(ctx, TPM_INTERFACE_TYPE, "dev");
    }

    if (rc == 0) {
        in.startupType = startupType;
        rc = TSS_Execute(ctx, NULL, (COMMAND_PARAMETERS*)&in, NULL, TPM_CC_Startup, TPM_RH_NULL,
                         NULL, 0);
        if (rc != 0) {
            handle_TPM_error(rc, 1);
        }
    }

    return ctx;
}

/**
 * Execute TPM2_Shutdown and free the TSS context.
 * Safe to call with NULL.
 */
void shutdown_tpm(TSS_CONTEXT* ctx) {
    TPM_RC      rc = 0;
    Shutdown_In in;

    if (ctx == NULL) {
        return;
    }

    in.shutdownType = TPM_SU_CLEAR;

    rc = TSS_Execute(ctx, NULL, (COMMAND_PARAMETERS*)&in, NULL, TPM_CC_Shutdown, TPM_RH_NULL, NULL,
                     0);

    if (rc != 0) {
        handle_TPM_error(rc, 1);
    }

    TSS_Delete(ctx);
}

/**
 * Wrapper for TPM2_CreatePrimary.
 *
 * Parameters:
 * - ctx: TSS context.
 * - public_template: Public properties of the key to create.
 * - Hierarchy: Parent hierarchy (e.g., TPM_RH_OWNER).
 *
 * Returns:
 * - CreatePrimary_Out with handle and public data (fatal on TPM error).
 */
CreatePrimary_Out create_primary(TSS_CONTEXT* ctx, TPM2B_PUBLIC public_template,
                                 TPMI_RH_HIERARCHY Hierarchy) {

    CreatePrimary_In  in_create;
    CreatePrimary_Out out_create;

    TPMI_RH_HIERARCHY    primaryHandle      = Hierarchy;
    const char*          parentPasswordPtr  = NULL;
    TPMI_SH_AUTH_SESSION sessionHandle0     = TPM_RS_PW;
    unsigned int         sessionAttributes0 = 0;
    TPMI_SH_AUTH_SESSION sessionHandle1     = TPM_RH_NULL;
    unsigned int         sessionAttributes1 = 0;
    TPMI_SH_AUTH_SESSION sessionHandle2     = TPM_RH_NULL;
    unsigned int         sessionAttributes2 = 0;

    TPM_RC rc = 0;

    in_create.primaryHandle                         = primaryHandle;
    in_create.inSensitive.sensitive.userAuth.t.size = 0;
    in_create.inSensitive.sensitive.data.t.size     = 0;

    in_create.inPublic = public_template;

    in_create.outsideInfo.t.size = 0;
    in_create.creationPCR.count  = 0;

    rc = TSS_Execute(ctx, (RESPONSE_PARAMETERS*)&out_create, (COMMAND_PARAMETERS*)&in_create, NULL,
                     TPM_CC_CreatePrimary, sessionHandle0, parentPasswordPtr, sessionAttributes0,
                     sessionHandle1, NULL, sessionAttributes1, sessionHandle2, NULL,
                     sessionAttributes2, TPM_RH_NULL, NULL, 0);

    if (rc != TPM_RC_SUCCESS) {
        handle_TPM_error(rc, 1);
    }
    return out_create;
}

/**
 * Wrapper for TPM2_Commit used in ECDAA operations.
 *
 * Parameters:
 * - ctx: TSS context.
 * - key: Signing key handle.
 * - point: Optional point P1; if NULL, empty P1 is used.
 * - session: Authorized policy session handle.
 * - secret: Optional s2 parameter.
 * - param: Optional y2 parameter.
 *
 * Returns:
 * - Commit_Out structure (fatal on TPM error).
 */
Commit_Out commit(TSS_CONTEXT* ctx, TPM_HANDLE key, TPM2B_ECC_POINT* point,
                  TPMI_SH_AUTH_SESSION session, TPM2B_SENSITIVE_DATA* secret,
                  TPM2B_ECC_PARAMETER* param) {
    Commit_In  in;
    Commit_Out out;
    TPM_RC     rc = 0;

    in.signHandle = key;
    if (point != NULL) {
        in.P1 = *point;
    } else {
        in.P1.size           = 0;
        in.P1.point.x.t.size = 0;
        in.P1.point.y.t.size = 0;
    }
    if (secret != NULL) {
        in.s2 = *secret;
    } else {
        in.s2.t.size = 0;
    }
    if (param != NULL) {
        in.y2 = *param;
    } else {
        in.y2.t.size = 0;
    }

    rc = TSS_Execute(ctx, (RESPONSE_PARAMETERS*)&out, (COMMAND_PARAMETERS*)&in, NULL, TPM_CC_Commit,
                     session, NULL, 0, TPM_RH_NULL, NULL, 0);

    if (rc != TPM_RC_SUCCESS) {
        handle_TPM_error(rc, 1);
        return out;
    }

    return out;
}

/**
 * Wrapper for TPM2_Hash.
 *
 * Parameters:
 * - ctx: TSS context.
 * - buffer: Input buffer to hash.
 * - hierarchy: Authorization hierarchy for hash ticket.
 * - hashAlg: Hash algorithm (e.g., TPM_ALG_SHA256).
 *
 * Returns:
 * - Hash_Out with digest and validation ticket.
 */
Hash_Out hash(TSS_CONTEXT* ctx, TPM2B_MAX_BUFFER* buffer, TPM_HANDLE hierarchy,
              TPMI_ALG_HASH hashAlg) {
    Hash_In  in;
    Hash_Out out;
    TPM_RC   rc = 0;

    in.data      = *buffer;
    in.hashAlg   = hashAlg;
    in.hierarchy = hierarchy;

    rc = TSS_Execute(ctx, (RESPONSE_PARAMETERS*)&out, (COMMAND_PARAMETERS*)&in, NULL, TPM_CC_Hash,
                     TPM_RH_NULL, NULL, 0);

    if (rc != TPM_RC_SUCCESS) {
        handle_TPM_error(rc, 1);
        return out;
    }

    return out;
}

/**
 * Wrapper for TPM2_Sign using an active policy session.
 *
 * Parameters:
 * - ctx: TSS context.
 * - key: Signing key handle.
 * - session: Policy session authorizing TPM2_Sign.
 * - scheme: Signing scheme (e.g., ECDAA parameters).
 * - hash: Precomputed digest and validation.
 *
 * Returns:
 * - Sign_Out with signature.
 */
Sign_Out sign(TSS_CONTEXT* ctx, TPM_HANDLE key, StartAuthSession_Out session,
              TPMT_SIG_SCHEME* scheme, Hash_Out hash) {
    Sign_In  in;
    Sign_Out out;
    TPM_RC   rc = 0;

    TPMI_SH_AUTH_SESSION sessionHandle0     = session.sessionHandle;
    unsigned int         sessionAttributes0 = 1;
    unsigned int         sessionAttributes1 = 0;
    unsigned int         sessionAttributes2 = 0;

    in.keyHandle  = key;
    in.inScheme   = *scheme;
    in.digest     = hash.outHash;
    in.validation = hash.validation;

    rc =
        TSS_Execute(ctx, (RESPONSE_PARAMETERS*)&out, (COMMAND_PARAMETERS*)&in, NULL, TPM_CC_Sign,
                    sessionHandle0, NULL, sessionAttributes0, TPM_RH_NULL, NULL, sessionAttributes1,
                    TPM_RH_NULL, NULL, sessionAttributes2, TPM_RH_NULL, NULL, 0);

    if (rc != TPM_RC_SUCCESS) {
        handle_TPM_error(rc, 1);
        return out;
    }

    return out;
}

/**
 * Start a TPM authorization session (HMAC or policy).
 *
 * Parameters:
 * - ctx: TSS context.
 * - session_type: TPM_SE_POLICY or TPM_SE_HMAC.
 *
 * Returns:
 * - StartAuthSession_Out with session handle.
 */
StartAuthSession_Out auth_session(TSS_CONTEXT* ctx, TPMI_SH_POLICY session_type) {
    StartAuthSession_In  in;
    StartAuthSession_Out out;
    TPM_RC               rc = 0;

    in.tpmKey              = TPM_RH_NULL;
    in.bind                = TPM_RH_NULL;
    in.sessionType         = session_type;
    in.nonceCaller.t.size  = 0;
    in.symmetric.algorithm = TPM_ALG_NULL;
    in.authHash            = TPM_ALG_SHA256;

    rc = TSS_Execute(ctx, (RESPONSE_PARAMETERS*)&out, (COMMAND_PARAMETERS*)&in, NULL,
                     TPM_CC_StartAuthSession, TPM_RH_NULL, NULL, 0);

    if (rc != TPM_RC_SUCCESS) {
        handle_TPM_error(rc, 1);
        return out;
    }

    return out;
}

/**
 * Flush a TPM handle from context.
 */
void flush_context(TSS_CONTEXT* ctx, TPM_HANDLE handle) {

    TPM_RC          rc;
    FlushContext_In in;

    in.flushHandle = handle;
    rc = TSS_Execute(ctx, NULL, (COMMAND_PARAMETERS*)&in, NULL, TPM_CC_FlushContext, TPM_RH_NULL,
                     NULL, 0);

    if (rc != TPM_RC_SUCCESS) {
        handle_TPM_error(rc, 1);
    }
}

/**
 * Apply PolicyCommandCode to a session to restrict it to a TPM command.
 *
 * Parameters:
 * - ctx: TSS context.
 * - session: Auth session.
 * - commandCode: TPM_CC to authorize.
 *
 * Returns:
 * - TPM_RC result code (fatal logged on failure).
 */
TPM_RC policy_command_code(TSS_CONTEXT* ctx, StartAuthSession_Out session, TPM_CC commandCode) {
    PolicyCommandCode_In in;
    TPM_RC               rc = 0;
    in.policySession        = session.sessionHandle;
    in.code                 = commandCode;

    rc = TSS_Execute(ctx, NULL, (COMMAND_PARAMETERS*)&in, NULL, TPM_CC_PolicyCommandCode,
                     TPM_RH_NULL, NULL, 0);

    if (rc != TPM_RC_SUCCESS) {
        handle_TPM_error(rc, 1);
        return rc;
    }
    return rc;
}

/**
 * Apply PolicyOR with a list of digests to the session policy.
 *
 * Parameters:
 * - ctx: TSS context.
 * - session: Auth session.
 * - digestArray: Array of digests to OR.
 * - len: Number of digests.
 *
 * Returns:
 * - TPM_RC result code (fatal logged on failure).
 */
TPM_RC policy_or(TSS_CONTEXT* ctx, StartAuthSession_Out session, TPM2B_DIGEST* digestArray,
                 size_t len) {

    TPM_RC      rc = 0;
    PolicyOR_In in;

    TPMI_SH_AUTH_SESSION sessionHandle0     = TPM_RH_NULL;
    unsigned int         sessionAttributes0 = 0;
    TPMI_SH_AUTH_SESSION sessionHandle1     = TPM_RH_NULL;
    unsigned int         sessionAttributes1 = 0;
    TPMI_SH_AUTH_SESSION sessionHandle2     = TPM_RH_NULL;
    unsigned int         sessionAttributes2 = 0;

    in.policySession   = session.sessionHandle;
    in.pHashList.count = (UINT32)len;
    for (int i = 0; i < len; i++)
        in.pHashList.digests[i] = digestArray[i];

    rc = TSS_Execute(ctx, NULL, (COMMAND_PARAMETERS*)&in, NULL, TPM_CC_PolicyOR, sessionHandle0,
                     NULL, sessionAttributes0, sessionHandle1, NULL, sessionAttributes1,
                     sessionHandle2, NULL, sessionAttributes2, TPM_RH_NULL, NULL, 0);

    if (rc != TPM_RC_SUCCESS)
        handle_TPM_error(rc, 1);

    return rc;
}