mcuxClFfdh_KeyAgreement_ffdhe2048_example.c

Example for the mcuxClFfdh component.

Example for the mcuxClFfdh component

/*--------------------------------------------------------------------------*/
/* Copyright 2025 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.                                              */
/*--------------------------------------------------------------------------*/

 
#include <mcuxClToolchain.h>
#include <mcuxClSession.h>
#include <mcuxClKey.h>
#include <mcuxClFfdh.h>
#include <mcuxClCore_Examples.h>
#include <mcuxClExample_Session_Helper.h>
#include <mcuxClExample_RNG_Helper.h>
#include <mcuxClRandom.h>
#include <mcuxCsslFlowProtection.h>
#include <mcuxClCore_FunctionIdentifiers.h> // Code flow protection
#include <mcuxClCore_Macros.h>
 
#define MAX_CPUWA_SIZE (MCUXCLKEY_AGREEMENT_FFDH_WACPU_SIZE_2048)
 
#define MAX_PKCWA_SIZE (MCUXCLKEY_AGREEMENT_FFDH_WAPKC_SIZE_2048)
 
/* Private key Alice (randomly generated) [BE] 0x488eb17582896ae355e1a4b38852abccd03c6c2eb516c5040d268cf62183270755da4dbe9afac3d0d32526a1caf2fda17be7ada3012117336fcfa12feb13499007ddecc08a3e537926be2f8151f190d1870bbd854a1543b691d2baac2822b894047e5148106f025ac9a7a507609d8d9ddc2525f6170d099d6c7a5d7a18ebddbfd7e07fa462d3b19430d6169f0ad0457104e4c09540ef9701d996e189c42ebf8547ee51751ecd3e1de92528add07bd3c3580b22ed0392a9a599d086a9ee574f45fc40f20b9e5d0fb307ead40c8c330104091390ad7c49a49a51dfacde6b5e633aa9855deb0c8fbf1bb38e5041393d893e6c0d522dffcc125ed8c658ec6da68d6 */
static const ALIGNED uint8_t pAlicePrivKeyData[MCUXCLFFDH_FFDHE2048_SIZE_PRIVATEKEY] = {
  0x04U, 0x88U, 0xEBU, 0x17U, 0x58U, 0x28U, 0x96U, 0xAEU, 0x35U, 0x5EU, 0x1AU, 0x4BU, 0x38U, 0x85U, 0x2AU, 0xBCU,
  0xCDU, 0x03U, 0xC6U, 0xC2U, 0xEBU, 0x51U, 0x6CU, 0x50U, 0x40U, 0xD2U, 0x68U, 0xCFU, 0x62U, 0x18U, 0x32U, 0x70U,
  0x75U, 0x5DU, 0xA4U, 0xDBU, 0xE9U, 0xAFU, 0xACU, 0x3DU, 0x0DU, 0x32U, 0x52U, 0x6AU, 0x1CU, 0xAFU, 0x2FU, 0xDAU,
  0x17U, 0xBEU, 0x7AU, 0xDAU, 0x30U, 0x12U, 0x11U, 0x73U, 0x36U, 0xFCU, 0xFAU, 0x12U, 0xFEU, 0xB1U, 0x34U, 0x99U,
  0x00U, 0x7DU, 0xDEU, 0xCCU, 0x08U, 0xA3U, 0xE5U, 0x37U, 0x92U, 0x6BU, 0xE2U, 0xF8U, 0x15U, 0x1FU, 0x19U, 0x0DU,
  0x18U, 0x70U, 0xBBU, 0xD8U, 0x54U, 0xA1U, 0x54U, 0x3BU, 0x69U, 0x1DU, 0x2BU, 0xAAU, 0xC2U, 0x82U, 0x2BU, 0x89U,
  0x40U, 0x47U, 0xE5U, 0x14U, 0x81U, 0x06U, 0xF0U, 0x25U, 0xACU, 0x9AU, 0x7AU, 0x50U, 0x76U, 0x09U, 0xD8U, 0xD9U,
  0xDDU, 0xC2U, 0x52U, 0x5FU, 0x61U, 0x70U, 0xD0U, 0x99U, 0xD6U, 0xC7U, 0xA5U, 0xD7U, 0xA1U, 0x8EU, 0xBDU, 0xDBU,
  0xFDU, 0x7EU, 0x07U, 0xFAU, 0x46U, 0x2DU, 0x3BU, 0x19U, 0x43U, 0x0DU, 0x61U, 0x69U, 0xF0U, 0xADU, 0x04U, 0x57U,
  0x10U, 0x4EU, 0x4CU, 0x09U, 0x54U, 0x0EU, 0xF9U, 0x70U, 0x1DU, 0x99U, 0x6EU, 0x18U, 0x9CU, 0x42U, 0xEBU, 0xF8U,
  0x54U, 0x7EU, 0xE5U, 0x17U, 0x51U, 0xECU, 0xD3U, 0xE1U, 0xDEU, 0x92U, 0x52U, 0x8AU, 0xDDU, 0x07U, 0xBDU, 0x3CU,
  0x35U, 0x80U, 0xB2U, 0x2EU, 0xD0U, 0x39U, 0x2AU, 0x9AU, 0x59U, 0x9DU, 0x08U, 0x6AU, 0x9EU, 0xE5U, 0x74U, 0xF4U,
  0x5FU, 0xC4U, 0x0FU, 0x20U, 0xB9U, 0xE5U, 0xD0U, 0xFBU, 0x30U, 0x7EU, 0xADU, 0x40U, 0xC8U, 0xC3U, 0x30U, 0x10U,
  0x40U, 0x91U, 0x39U, 0x0AU, 0xD7U, 0xC4U, 0x9AU, 0x49U, 0xA5U, 0x1DU, 0xFAU, 0xCDU, 0xE6U, 0xB5U, 0xE6U, 0x33U,
  0xAAU, 0x98U, 0x55U, 0xDEU, 0xB0U, 0xC8U, 0xFBU, 0xF1U, 0xBBU, 0x38U, 0xE5U, 0x04U, 0x13U, 0x93U, 0xD8U, 0x93U,
  0xE6U, 0xC0U, 0xD5U, 0x22U, 0xDFU, 0xFCU, 0xC1U, 0x25U, 0xEDU, 0x8CU, 0x65U, 0x8EU, 0xC6U, 0xDAU, 0x68U, 0xD6U
};
 
/* Public key Alice [BE] 0x79dd7c39b336c2ed1f9367c763200d45836096d4dd6630ed5d8d5ab6d1a6c66ec9e41d05d9e934a1860ffc5053a9397a5807a8a2157ff63ab8c6d32359acfb3cd4a156de6554d8c33fe3837f7eaad8c77a156c297f548091f80a2d1996e216b0b1430e6ca6ba0b898fd401142a38809c44473696c409d23f0e67cf5e347368399a15f137c225ef07e29405c08a3b90e55f31eb2defe050a082bc9fbd6bda68bc975f73fc7726a8ff918d523102178d35b433767df9fcae8da28f4164886c25c569fe411b4e1ad18253556dcae4a2d78a55da7af5a9ca44e049a615cc0f05b2a3e1911887c6def7634db75d5e3341727aaa82e82b2b32fb882112a92b498b44f5 */
static const ALIGNED uint8_t pAlicePubKeyData[MCUXCLFFDH_FFDHE2048_SIZE_PUBLICKEY] = {
  0x79U, 0xDDU, 0x7CU, 0x39U, 0xB3U, 0x36U, 0xC2U, 0xEDU, 0x1FU, 0x93U, 0x67U, 0xC7U, 0x63U, 0x20U, 0x0DU, 0x45U,
  0x83U, 0x60U, 0x96U, 0xD4U, 0xDDU, 0x66U, 0x30U, 0xEDU, 0x5DU, 0x8DU, 0x5AU, 0xB6U, 0xD1U, 0xA6U, 0xC6U, 0x6EU,
  0xC9U, 0xE4U, 0x1DU, 0x05U, 0xD9U, 0xE9U, 0x34U, 0xA1U, 0x86U, 0x0FU, 0xFCU, 0x50U, 0x53U, 0xA9U, 0x39U, 0x7AU,
  0x58U, 0x07U, 0xA8U, 0xA2U, 0x15U, 0x7FU, 0xF6U, 0x3AU, 0xB8U, 0xC6U, 0xD3U, 0x23U, 0x59U, 0xACU, 0xFBU, 0x3CU,
  0xD4U, 0xA1U, 0x56U, 0xDEU, 0x65U, 0x54U, 0xD8U, 0xC3U, 0x3FU, 0xE3U, 0x83U, 0x7FU, 0x7EU, 0xAAU, 0xD8U, 0xC7U,
  0x7AU, 0x15U, 0x6CU, 0x29U, 0x7FU, 0x54U, 0x80U, 0x91U, 0xF8U, 0x0AU, 0x2DU, 0x19U, 0x96U, 0xE2U, 0x16U, 0xB0U,
  0xB1U, 0x43U, 0x0EU, 0x6CU, 0xA6U, 0xBAU, 0x0BU, 0x89U, 0x8FU, 0xD4U, 0x01U, 0x14U, 0x2AU, 0x38U, 0x80U, 0x9CU,
  0x44U, 0x47U, 0x36U, 0x96U, 0xC4U, 0x09U, 0xD2U, 0x3FU, 0x0EU, 0x67U, 0xCFU, 0x5EU, 0x34U, 0x73U, 0x68U, 0x39U,
  0x9AU, 0x15U, 0xF1U, 0x37U, 0xC2U, 0x25U, 0xEFU, 0x07U, 0xE2U, 0x94U, 0x05U, 0xC0U, 0x8AU, 0x3BU, 0x90U, 0xE5U,
  0x5FU, 0x31U, 0xEBU, 0x2DU, 0xEFU, 0xE0U, 0x50U, 0xA0U, 0x82U, 0xBCU, 0x9FU, 0xBDU, 0x6BU, 0xDAU, 0x68U, 0xBCU,
  0x97U, 0x5FU, 0x73U, 0xFCU, 0x77U, 0x26U, 0xA8U, 0xFFU, 0x91U, 0x8DU, 0x52U, 0x31U, 0x02U, 0x17U, 0x8DU, 0x35U,
  0xB4U, 0x33U, 0x76U, 0x7DU, 0xF9U, 0xFCU, 0xAEU, 0x8DU, 0xA2U, 0x8FU, 0x41U, 0x64U, 0x88U, 0x6CU, 0x25U, 0xC5U,
  0x69U, 0xFEU, 0x41U, 0x1BU, 0x4EU, 0x1AU, 0xD1U, 0x82U, 0x53U, 0x55U, 0x6DU, 0xCAU, 0xE4U, 0xA2U, 0xD7U, 0x8AU,
  0x55U, 0xDAU, 0x7AU, 0xF5U, 0xA9U, 0xCAU, 0x44U, 0xE0U, 0x49U, 0xA6U, 0x15U, 0xCCU, 0x0FU, 0x05U, 0xB2U, 0xA3U,
  0xE1U, 0x91U, 0x18U, 0x87U, 0xC6U, 0xDEU, 0xF7U, 0x63U, 0x4DU, 0xB7U, 0x5DU, 0x5EU, 0x33U, 0x41U, 0x72U, 0x7AU,
  0xAAU, 0x82U, 0xE8U, 0x2BU, 0x2BU, 0x32U, 0xFBU, 0x88U, 0x21U, 0x12U, 0xA9U, 0x2BU, 0x49U, 0x8BU, 0x44U, 0xF5U
};
 
/* Private key Bob (randomly generated) [BE] 0x25181d20e111627cbc07442bcf07e605a8c197cd292f92a0db89dc0f92c0c1e348455465e6b7658fb320e6852795497fa1ac1083af9d9efd4c752037073dde2b7f422d5352bdaab59aa9d0dbfb01ca0ec36d065563924e3f1d3086b523d2a02a69387dceaf5112d0239e5f0efc9ccf0127eb779fbbfa5ad091ddfc37a9762ad7cb07e240b512bf52a8c7a18b4a1a478180e65c4dc6ddc773389ef858790c159f227a7e148857935bce34512c494fc6a626d3ccb84595f5fc4cf207115df7ddf8859be5f07affb3903a4d6223addca12a3397565e7d0a289598181a4d66080798b2619eb6fe5054c798e945c7907ffa61465ffa83e37fa6acd5f83fd0ae0025c1 */
static const ALIGNED uint8_t pBobPrivKeyData[MCUXCLFFDH_FFDHE2048_SIZE_PRIVATEKEY] = {
  0x25U, 0x18U, 0x1DU, 0x20U, 0xE1U, 0x11U, 0x62U, 0x7CU, 0xBCU, 0x07U, 0x44U, 0x2BU, 0xCFU, 0x07U, 0xE6U, 0x05U,
  0xA8U, 0xC1U, 0x97U, 0xCDU, 0x29U, 0x2FU, 0x92U, 0xA0U, 0xDBU, 0x89U, 0xDCU, 0x0FU, 0x92U, 0xC0U, 0xC1U, 0xE3U,
  0x48U, 0x45U, 0x54U, 0x65U, 0xE6U, 0xB7U, 0x65U, 0x8FU, 0xB3U, 0x20U, 0xE6U, 0x85U, 0x27U, 0x95U, 0x49U, 0x7FU,
  0xA1U, 0xACU, 0x10U, 0x83U, 0xAFU, 0x9DU, 0x9EU, 0xFDU, 0x4CU, 0x75U, 0x20U, 0x37U, 0x07U, 0x3DU, 0xDEU, 0x2BU,
  0x7FU, 0x42U, 0x2DU, 0x53U, 0x52U, 0xBDU, 0xAAU, 0xB5U, 0x9AU, 0xA9U, 0xD0U, 0xDBU, 0xFBU, 0x01U, 0xCAU, 0x0EU,
  0xC3U, 0x6DU, 0x06U, 0x55U, 0x63U, 0x92U, 0x4EU, 0x3FU, 0x1DU, 0x30U, 0x86U, 0xB5U, 0x23U, 0xD2U, 0xA0U, 0x2AU,
  0x69U, 0x38U, 0x7DU, 0xCEU, 0xAFU, 0x51U, 0x12U, 0xD0U, 0x23U, 0x9EU, 0x5FU, 0x0EU, 0xFCU, 0x9CU, 0xCFU, 0x01U,
  0x27U, 0xEBU, 0x77U, 0x9FU, 0xBBU, 0xFAU, 0x5AU, 0xD0U, 0x91U, 0xDDU, 0xFCU, 0x37U, 0xA9U, 0x76U, 0x2AU, 0xD7U,
  0xCBU, 0x07U, 0xE2U, 0x40U, 0xB5U, 0x12U, 0xBFU, 0x52U, 0xA8U, 0xC7U, 0xA1U, 0x8BU, 0x4AU, 0x1AU, 0x47U, 0x81U,
  0x80U, 0xE6U, 0x5CU, 0x4DU, 0xC6U, 0xDDU, 0xC7U, 0x73U, 0x38U, 0x9EU, 0xF8U, 0x58U, 0x79U, 0x0CU, 0x15U, 0x9FU,
  0x22U, 0x7AU, 0x7EU, 0x14U, 0x88U, 0x57U, 0x93U, 0x5BU, 0xCEU, 0x34U, 0x51U, 0x2CU, 0x49U, 0x4FU, 0xC6U, 0xA6U,
  0x26U, 0xD3U, 0xCCU, 0xB8U, 0x45U, 0x95U, 0xF5U, 0xFCU, 0x4CU, 0xF2U, 0x07U, 0x11U, 0x5DU, 0xF7U, 0xDDU, 0xF8U,
  0x85U, 0x9BU, 0xE5U, 0xF0U, 0x7AU, 0xFFU, 0xB3U, 0x90U, 0x3AU, 0x4DU, 0x62U, 0x23U, 0xADU, 0xDCU, 0xA1U, 0x2AU,
  0x33U, 0x97U, 0x56U, 0x5EU, 0x7DU, 0x0AU, 0x28U, 0x95U, 0x98U, 0x18U, 0x1AU, 0x4DU, 0x66U, 0x08U, 0x07U, 0x98U,
  0xB2U, 0x61U, 0x9EU, 0xB6U, 0xFEU, 0x50U, 0x54U, 0xC7U, 0x98U, 0xE9U, 0x45U, 0xC7U, 0x90U, 0x7FU, 0xFAU, 0x61U,
  0x46U, 0x5FU, 0xFAU, 0x83U, 0xE3U, 0x7FU, 0xA6U, 0xACU, 0xD5U, 0xF8U, 0x3FU, 0xD0U, 0xAEU, 0x00U, 0x25U, 0xC1U
};
 
/* Public key Bob [BE] 0xbc2bf27151b633b6f6f3a2bdd5111a9b0eb662f6f726c8252ab5381d304ca191025a85faa50bf9c47c293ca67a184d436764f47483462b2bd2b1aefeab7406bf6cfcdbe7121ba0d6c4340885438acf072670de0af64456ced44bcf2e916dace34e4c869dab5ef4fdd247e73ad3fe58142d9a887ccee4e39964d0bfd8a1caf4eaac7925f7b7a8157fa16c1dbafb8aa5e9715155982b47e6b19844c79a4d7a0ea18baf4afef00001bcb46087da22707a47d4c3290605b002ee16c468242331706f454253268fa36c8ad80f58978c9ae82b36da0e53b27aad807c90c84b9c9cf8dbeb038b8448a86f16b3474ca216591d8430303a83773c86d949003f895e1b18c6 */
static const ALIGNED uint8_t pBobPubKeyData[MCUXCLFFDH_FFDHE2048_SIZE_PUBLICKEY] = {
  0xBCU, 0x2BU, 0xF2U, 0x71U, 0x51U, 0xB6U, 0x33U, 0xB6U, 0xF6U, 0xF3U, 0xA2U, 0xBDU, 0xD5U, 0x11U, 0x1AU, 0x9BU,
  0x0EU, 0xB6U, 0x62U, 0xF6U, 0xF7U, 0x26U, 0xC8U, 0x25U, 0x2AU, 0xB5U, 0x38U, 0x1DU, 0x30U, 0x4CU, 0xA1U, 0x91U,
  0x02U, 0x5AU, 0x85U, 0xFAU, 0xA5U, 0x0BU, 0xF9U, 0xC4U, 0x7CU, 0x29U, 0x3CU, 0xA6U, 0x7AU, 0x18U, 0x4DU, 0x43U,
  0x67U, 0x64U, 0xF4U, 0x74U, 0x83U, 0x46U, 0x2BU, 0x2BU, 0xD2U, 0xB1U, 0xAEU, 0xFEU, 0xABU, 0x74U, 0x06U, 0xBFU,
  0x6CU, 0xFCU, 0xDBU, 0xE7U, 0x12U, 0x1BU, 0xA0U, 0xD6U, 0xC4U, 0x34U, 0x08U, 0x85U, 0x43U, 0x8AU, 0xCFU, 0x07U,
  0x26U, 0x70U, 0xDEU, 0x0AU, 0xF6U, 0x44U, 0x56U, 0xCEU, 0xD4U, 0x4BU, 0xCFU, 0x2EU, 0x91U, 0x6DU, 0xACU, 0xE3U,
  0x4EU, 0x4CU, 0x86U, 0x9DU, 0xABU, 0x5EU, 0xF4U, 0xFDU, 0xD2U, 0x47U, 0xE7U, 0x3AU, 0xD3U, 0xFEU, 0x58U, 0x14U,
  0x2DU, 0x9AU, 0x88U, 0x7CU, 0xCEU, 0xE4U, 0xE3U, 0x99U, 0x64U, 0xD0U, 0xBFU, 0xD8U, 0xA1U, 0xCAU, 0xF4U, 0xEAU,
  0xACU, 0x79U, 0x25U, 0xF7U, 0xB7U, 0xA8U, 0x15U, 0x7FU, 0xA1U, 0x6CU, 0x1DU, 0xBAU, 0xFBU, 0x8AU, 0xA5U, 0xE9U,
  0x71U, 0x51U, 0x55U, 0x98U, 0x2BU, 0x47U, 0xE6U, 0xB1U, 0x98U, 0x44U, 0xC7U, 0x9AU, 0x4DU, 0x7AU, 0x0EU, 0xA1U,
  0x8BU, 0xAFU, 0x4AU, 0xFEU, 0xF0U, 0x00U, 0x01U, 0xBCU, 0xB4U, 0x60U, 0x87U, 0xDAU, 0x22U, 0x70U, 0x7AU, 0x47U,
  0xD4U, 0xC3U, 0x29U, 0x06U, 0x05U, 0xB0U, 0x02U, 0xEEU, 0x16U, 0xC4U, 0x68U, 0x24U, 0x23U, 0x31U, 0x70U, 0x6FU,
  0x45U, 0x42U, 0x53U, 0x26U, 0x8FU, 0xA3U, 0x6CU, 0x8AU, 0xD8U, 0x0FU, 0x58U, 0x97U, 0x8CU, 0x9AU, 0xE8U, 0x2BU,
  0x36U, 0xDAU, 0x0EU, 0x53U, 0xB2U, 0x7AU, 0xADU, 0x80U, 0x7CU, 0x90U, 0xC8U, 0x4BU, 0x9CU, 0x9CU, 0xF8U, 0xDBU,
  0xEBU, 0x03U, 0x8BU, 0x84U, 0x48U, 0xA8U, 0x6FU, 0x16U, 0xB3U, 0x47U, 0x4CU, 0xA2U, 0x16U, 0x59U, 0x1DU, 0x84U,
  0x30U, 0x30U, 0x3AU, 0x83U, 0x77U, 0x3CU, 0x86U, 0xD9U, 0x49U, 0x00U, 0x3FU, 0x89U, 0x5EU, 0x1BU, 0x18U, 0xC6U
};
 
/* Shared secret ZZ [BE] 0x28b3a0a7248681045374820a16599c4146d510d959947698247003c2028d7fcc1d7175601d9397733af7fac221959556b738f2d117b04b8b95cfd9e1d89d72147e8f047f328ea5526a1a994948482d14f0fdf71d10e3276e1c9985a0d20d7c0cf6bb420c82575f4528fd6d4ffe132a17fa6fe31a6b27d1bfde6dac54d9fe80b64ebbf44909120a5ea4b48cb6fc6c508b26bcc80b925e9d88ba0b5ec67f1e5623d6168e8cf77c4009a063a4b5740821ac9a2b6b0a8e2dce61ff93f16238bca37ee2e25e94127daab01968809f5833372e73ca61ae64962c983ebd53ab45553614f62009f10ecf37a44e489ac63ef0e6fabe7f47a5f291f3395a57f23d1ce35b35 */
 
MCUXCLEXAMPLE_FUNCTION(mcuxClFfdh_KeyAgreement_ffdhe2048_example)
{
  /**************************************************************************/
  /* Preparation                                                            */
  /**************************************************************************/
 
  /* Setup one session to be used by all functions called */
  mcuxClSession_Descriptor_t sessionDesc;
  mcuxClSession_Handle_t session = &sessionDesc;
  MCUXCLEXAMPLE_ALLOCATE_AND_INITIALIZE_SESSION(session, MAX_CPUWA_SIZE, MAX_PKCWA_SIZE);
 
  /* Allocate space for and initialize Alice's private key handle for an ffdhe2048 private key */
  uint32_t alicePrivKeyDesc[MCUXCLKEY_DESCRIPTOR_SIZE_IN_WORDS];
  MCUX_CSSL_ANALYSIS_START_PATTERN_REINTERPRET_MEMORY_OF_OPAQUE_TYPES()
  mcuxClKey_Handle_t alicePrivKey = (mcuxClKey_Handle_t) &alicePrivKeyDesc;
  MCUX_CSSL_ANALYSIS_STOP_PATTERN_REINTERPRET_MEMORY_OF_OPAQUE_TYPES()
 
  MCUX_CSSL_FP_FUNCTION_CALL_BEGIN(aliceprivkeyinit_result, aliceprivkeyinit_token, mcuxClKey_init(
  /* mcuxClSession_Handle_t session         */ session,
  /* mcuxClKey_Handle_t key                 */ alicePrivKey,
  /* mcuxClKey_Type_t type                  */ mcuxClKey_Type_Ffdh_ffdhe2048_Priv,
  /* const uint8_t * pKeyData              */ pAlicePrivKeyData,
  /* uint32_t keyDataLength                */ MCUXCLFFDH_FFDHE2048_SIZE_PRIVATEKEY));
 
  if((MCUX_CSSL_FP_FUNCTION_CALLED(mcuxClKey_init) != aliceprivkeyinit_token) || (MCUXCLKEY_STATUS_OK != aliceprivkeyinit_result))
  {
    return MCUXCLEXAMPLE_STATUS_ERROR;
  }
  MCUX_CSSL_FP_FUNCTION_CALL_END();
 
  /* Allocate space for and initialize Alice's public key handle for an ffdhe2048 public key */
  uint32_t alicePubKeyDesc[MCUXCLKEY_DESCRIPTOR_SIZE_IN_WORDS];
  MCUX_CSSL_ANALYSIS_START_PATTERN_REINTERPRET_MEMORY_OF_OPAQUE_TYPES()
  mcuxClKey_Handle_t alicePubKey = (mcuxClKey_Handle_t) &alicePubKeyDesc;
  MCUX_CSSL_ANALYSIS_STOP_PATTERN_REINTERPRET_MEMORY_OF_OPAQUE_TYPES()
 
  MCUX_CSSL_FP_FUNCTION_CALL_BEGIN(alicepubkeyinit_result, alicepubkeyinit_token, mcuxClKey_init(
  /* mcuxClSession_Handle_t session         */ session,
  /* mcuxClKey_Handle_t key                 */ alicePubKey,
  /* mcuxClKey_Type_t type                  */ mcuxClKey_Type_Ffdh_ffdhe2048_Pub,
  /* const uint8_t * pKeyData              */ pAlicePubKeyData,
  /* uint32_t keyDataLength                */ MCUXCLFFDH_FFDHE2048_SIZE_PUBLICKEY));
 
  if((MCUX_CSSL_FP_FUNCTION_CALLED(mcuxClKey_init) != alicepubkeyinit_token) || (MCUXCLKEY_STATUS_OK != alicepubkeyinit_result))
  {
    return MCUXCLEXAMPLE_STATUS_ERROR;
  }
  MCUX_CSSL_FP_FUNCTION_CALL_END();
 
  /* Allocate space for and initialize Bob's private key handle for an ffdhe2048 private key */
  uint32_t bobPrivKeyDesc[MCUXCLKEY_DESCRIPTOR_SIZE_IN_WORDS];
  MCUX_CSSL_ANALYSIS_START_PATTERN_REINTERPRET_MEMORY_OF_OPAQUE_TYPES()
  mcuxClKey_Handle_t bobPrivKey = (mcuxClKey_Handle_t) &bobPrivKeyDesc;
  MCUX_CSSL_ANALYSIS_STOP_PATTERN_REINTERPRET_MEMORY_OF_OPAQUE_TYPES()
 
  MCUX_CSSL_FP_FUNCTION_CALL_BEGIN(bobprivkeyinit_result, bobprivkeyinit_token, mcuxClKey_init(
  /* mcuxClSession_Handle_t session         */ session,
  /* mcuxClKey_Handle_t key                 */ bobPrivKey,
  /* mcuxClKey_Type_t type                  */ mcuxClKey_Type_Ffdh_ffdhe2048_Priv,
  /* const uint8_t * pKeyData              */ pBobPrivKeyData,
  /* uint32_t keyDataLength                */ MCUXCLFFDH_FFDHE2048_SIZE_PRIVATEKEY));
 
  if((MCUX_CSSL_FP_FUNCTION_CALLED(mcuxClKey_init) != bobprivkeyinit_token) || (MCUXCLKEY_STATUS_OK != bobprivkeyinit_result))
  {
    return MCUXCLEXAMPLE_STATUS_ERROR;
  }
  MCUX_CSSL_FP_FUNCTION_CALL_END();
 
  /* Allocate space for and initialize Bob's public key handle for an ffdhe2048 public key */
  uint32_t bobPubKeyDesc[MCUXCLKEY_DESCRIPTOR_SIZE_IN_WORDS];
  MCUX_CSSL_ANALYSIS_START_PATTERN_REINTERPRET_MEMORY_OF_OPAQUE_TYPES()
  mcuxClKey_Handle_t bobPubKey = (mcuxClKey_Handle_t) &bobPubKeyDesc;
  MCUX_CSSL_ANALYSIS_STOP_PATTERN_REINTERPRET_MEMORY_OF_OPAQUE_TYPES()
 
  MCUX_CSSL_FP_FUNCTION_CALL_BEGIN(bobpubkeyinit_result, bobpubkeyinit_token, mcuxClKey_init(
  /* mcuxClSession_Handle_t session         */ session,
  /* mcuxClKey_Handle_t key                 */ bobPubKey,
  /* mcuxClKey_Type_t type                  */ mcuxClKey_Type_Ffdh_ffdhe2048_Pub,
  /* const uint8_t * pKeyData              */ pBobPubKeyData,
  /* uint32_t keyDataLength                */ MCUXCLFFDH_FFDHE2048_SIZE_PUBLICKEY));
 
  if((MCUX_CSSL_FP_FUNCTION_CALLED(mcuxClKey_init) != bobpubkeyinit_token) || (MCUXCLKEY_STATUS_OK != bobpubkeyinit_result))
  {
    return MCUXCLEXAMPLE_STATUS_ERROR;
  }
  MCUX_CSSL_FP_FUNCTION_CALL_END();
 
  /* Initialize the PRNG */
  MCUXCLEXAMPLE_INITIALIZE_PRNG(session);
 
  /**************************************************************************/
  /* FFDH key agreement on ffdhe2048                                        */
  /**************************************************************************/
 
  /* Alice computes the shared key, additionalInputs parameter is not required */
  uint8_t aliceSharedSecret[MCUXCLFFDH_FFDHE2048_SIZE_SHAREDSECRET];
  uint32_t aliceSharedSecretSize = 0u;
  MCUX_CSSL_FP_FUNCTION_CALL_BEGIN(alice_keyagreement_result, alice_keyagreement_token, mcuxClKey_agreement(
    /* mcuxClSession_Handle_t pSession:                          */ session,
    /* mcuxClKey_Agreement_t agreement:                          */ mcuxClKey_Agreement_FFDH,
    /* mcuxClKey_Handle_t key:                                   */ alicePrivKey,
    /* mcuxClKey_Handle_t otherKey:                              */ bobPubKey,
    MCUX_CSSL_ANALYSIS_START_SUPPRESS_NULL_POINTER_CONSTANT("NULL is used in code")
    /* mcuxClKey_Agreement_AdditionalInput_t additionalInputs[]: */ NULL,
    MCUX_CSSL_ANALYSIS_STOP_SUPPRESS_NULL_POINTER_CONSTANT()
    /* uint32_t numberOfInputs:                                 */ 0U,
    /* uint8_t * pOut:                                          */ aliceSharedSecret,
    /* uint32_t * const pOutLength:                             */ &aliceSharedSecretSize));
 
  if ((MCUX_CSSL_FP_FUNCTION_CALLED(mcuxClKey_agreement) != alice_keyagreement_token) || (MCUXCLKEY_STATUS_OK != alice_keyagreement_result) || (aliceSharedSecretSize != MCUXCLFFDH_FFDHE2048_SIZE_SHAREDSECRET))
  {
    return MCUXCLEXAMPLE_STATUS_ERROR;
  }
  MCUX_CSSL_FP_FUNCTION_CALL_END();
 
  /* Bob computes the shared key, additionalInputs parameter is not required */
  uint8_t bobSharedSecret[MCUXCLFFDH_FFDHE2048_SIZE_SHAREDSECRET];
  uint32_t bobSharedSecretSize = 0u;
  MCUX_CSSL_FP_FUNCTION_CALL_BEGIN(bob_keyagreement_result, bob_keyagreement_token, mcuxClKey_agreement(
    /* mcuxClSession_Handle_t pSession:                          */ session,
    /* mcuxClKey_Agreement_t agreement:                          */ mcuxClKey_Agreement_FFDH,
    /* mcuxClKey_Handle_t key:                                   */ bobPrivKey,
    /* mcuxClKey_Handle_t otherKey:                              */ alicePubKey,
    MCUX_CSSL_ANALYSIS_START_SUPPRESS_NULL_POINTER_CONSTANT("NULL is used in code")
    /* mcuxClKey_Agreement_AdditionalInput_t additionalInputs[]: */ NULL,
    MCUX_CSSL_ANALYSIS_STOP_SUPPRESS_NULL_POINTER_CONSTANT()
    /* uint32_t numberOfInputs:                                 */ 0U,
    /* uint8_t * pOut:                                          */ bobSharedSecret,
    /* uint32_t * const pOutLength:                             */ &bobSharedSecretSize));
 
  if ((MCUX_CSSL_FP_FUNCTION_CALLED(mcuxClKey_agreement) != bob_keyagreement_token) || (MCUXCLKEY_STATUS_OK != bob_keyagreement_result) || (bobSharedSecretSize != MCUXCLFFDH_FFDHE2048_SIZE_SHAREDSECRET))
  {
    return MCUXCLEXAMPLE_STATUS_ERROR;
  }
  MCUX_CSSL_FP_FUNCTION_CALL_END();
 
  /* Verify that Alice and Bob computed the same shared key */
  if(!mcuxClCore_assertEqual(bobSharedSecret, aliceSharedSecret, MCUXCLFFDH_FFDHE2048_SIZE_SHAREDSECRET))
  {
    return MCUXCLEXAMPLE_STATUS_ERROR;
  }
 
  /* Destroy Session and cleanup Session */
  if(!mcuxClExample_Session_Clean(session))
  {
    return MCUXCLEXAMPLE_STATUS_ERROR;
  }
 
  return MCUXCLEXAMPLE_STATUS_OK;
}