mcuxClKey_Functions.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------*/
/* Copyright 2020-2026 NXP                                                  */
/*                                                                          */
/* NXP Confidential and Proprietary. This software is owned or controlled   */
/* by NXP and may only be used strictly in accordance with the applicable   */
/* license terms.  By expressly accepting such terms or by downloading,     */
/* installing, activating and/or otherwise using the software, you are      */
/* agreeing that you have read, and that you agree to comply with and are   */
/* bound by, such license terms.  If you do not agree to be bound by the    */
/* applicable license terms, then you may not retain, install, activate or  */
/* otherwise use the software.                                              */
/*--------------------------------------------------------------------------*/

 
#ifndef MCUXCLKEY_FUNCTIONS_H_
#define MCUXCLKEY_FUNCTIONS_H_
 
#include <mcuxClConfig.h> // Exported features flags header
#include <mcuxClSession.h>
#include <mcuxClSession_Types.h>
 
#include <mcuxClKey_Types.h>
 
#include <mcuxCsslFlowProtection.h>
#include <mcuxClCore_FunctionIdentifiers.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/**********************************************
 * FUNCTIONS
 **********************************************/


MCUX_CSSL_FP_FUNCTION_DECL(mcuxClKey_init)
MCUX_CSSL_FP_PROTECTED_TYPE(mcuxClKey_Status_t) mcuxClKey_init(
    mcuxClSession_Handle_t session,
    mcuxClKey_Handle_t key,
    mcuxClKey_Type_t type,
    const uint8_t * pKeyData,
    uint32_t keyDataLength
);
 

MCUX_CSSL_FP_FUNCTION_DECL(mcuxClKey_linkKeyPair)
MCUX_CSSL_FP_PROTECTED_TYPE(void) mcuxClKey_linkKeyPair(
    mcuxClSession_Handle_t session,
    mcuxClKey_Handle_t privKey,
    mcuxClKey_Handle_t pubKey
);

MCUX_CSSL_FP_FUNCTION_DECL(mcuxClKey_setEncoding)
MCUX_CSSL_FP_PROTECTED_TYPE(mcuxClKey_Status_t) mcuxClKey_setEncoding(
    mcuxClSession_Handle_t session,
    mcuxClKey_Handle_t key,
    mcuxClKey_Encoding_t encoding,
    const uint8_t * pAuxData,
    uint32_t auxDataLength
);

/* To delete a key again from the key slot, call @ref mcuxClKey_flush.
 */
/* @attention In case the key is already loaded to a key slot that differs from the @p slot,
 * the previous slot will be flushed before loading the key to the given new slot.
 *
 * @if (MCUXCL_FEATURE_CSSL_FP_USE_SECURE_COUNTER && MCUXCL_FEATURE_CSSL_SC_USE_SW_LOCAL)
 *  @return A code-flow protected error code (see @ref mcuxCsslFlowProtection). The error code can be any error code in @ref MCUXCLKEY_STATUS_, see individual documentation for more information
 * @else
 *  @return An error code that can be any error code in @ref MCUXCLKEY_STATUS_, see individual documentation for more information
 * @endif
 *
 * @retval #MCUXCLKEY_STATUS_OK             on successful operation
 * @retval #MCUXCLKEY_STATUS_INVALID_INPUT  if the given loadOptions do not fit the key type
 * @retval #MCUXCLKEY_STATUS_FAULT_ATTACK   if a fault attack was detected
 */
MCUX_CSSL_FP_FUNCTION_DECL(mcuxClKey_loadCopro)
MCUX_CSSL_FP_PROTECTED_TYPE(mcuxClKey_Status_t) mcuxClKey_loadCopro(
    mcuxClSession_Handle_t session,
    mcuxClKey_Handle_t key,
    uint32_t loadOptions
);

MCUX_CSSL_FP_FUNCTION_DECL(mcuxClKey_flush)
MCUX_CSSL_FP_PROTECTED_TYPE(mcuxClKey_Status_t) mcuxClKey_flush(
    mcuxClSession_Handle_t session,
    mcuxClKey_Handle_t key
);
 

MCUX_CSSL_FP_FUNCTION_DECL(mcuxClKey_generate_keypair)
MCUX_CSSL_FP_PROTECTED_TYPE(mcuxClKey_Status_t) mcuxClKey_generate_keypair(
    mcuxClSession_Handle_t session,
    mcuxClKey_Generation_t generation,
    mcuxClKey_Handle_t privKey,
    mcuxClKey_Handle_t pubKey
); /* generate a fresh new key (pair) */

MCUX_CSSL_FP_FUNCTION_DECL(mcuxClKey_agreement)
MCUX_CSSL_FP_PROTECTED_TYPE(mcuxClKey_Status_t) mcuxClKey_agreement(
    mcuxClSession_Handle_t session,
    mcuxClKey_Agreement_t agreement,
    mcuxClKey_Handle_t key,
    mcuxClKey_Handle_t otherKey,
    mcuxClKey_Agreement_AdditionalInput_t additionalInputs[],
    uint32_t numberOfInputs,
    uint8_t * pOut,
    uint32_t * const pOutLength
); /* determine a shared key on based on public and private inputs */
 

MCUX_CSSL_FP_FUNCTION_DECL(mcuxClKey_encode)
MCUX_CSSL_FP_PROTECTED_TYPE(mcuxClKey_Status_t) mcuxClKey_encode(
    mcuxClSession_Handle_t session,
    mcuxClKey_Encoding_t encoding,
    mcuxClKey_Handle_t encodedKey,
    mcuxClKey_Type_t type,
    const uint8_t * pPlainKeyData,
    uint32_t plainKeyDataLength,
    const uint8_t * pAuxData,
    uint32_t auxDataLength,
    uint8_t * pEncodedKeyData,
    uint32_t * const pEncodedKeyDataLength
);

MCUX_CSSL_FP_FUNCTION_DECL(mcuxClKey_recode)
MCUX_CSSL_FP_PROTECTED_TYPE(mcuxClKey_Status_t) mcuxClKey_recode(
    mcuxClSession_Handle_t session,
    mcuxClKey_Handle_t encodedKey,
    mcuxClKey_Encoding_t encoding,
    mcuxClKey_Handle_t recodedKey,
    const uint8_t * pAuxData,
    uint32_t auxDataLength,
    uint8_t * pEncodedKeyData,
    uint32_t * const pEncodedKeyDataLength
);

MCUX_CSSL_FP_FUNCTION_DECL(mcuxClKey_validate)
MCUX_CSSL_FP_PROTECTED_TYPE(mcuxClKey_Status_t) mcuxClKey_validate(
    mcuxClSession_Handle_t session,
    mcuxClKey_Validation_t validation,
    mcuxClKey_Handle_t key
);
 /* mcuxClKey_Functions */
 
#ifdef __cplusplus
} /* extern "C" */
#endif
 
#endif /* MCUXCLKEY_FUNCTIONS_H_ */