RA Flexible Software Package Documentation  Release v5.9.0

 
Functions
Secure Key Injection (r_rsip_key_injection)
Modules » Security

Functions

fsp_err_t R_RSIP_AES128_InitialKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_aes_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_AES192_InitialKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_aes_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_AES256_InitialKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_aes_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_AES128_XTS_InitialKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_aes_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_AES256_XTS_InitialKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_aes_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_RSA2048_InitialPublicKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_rsa2048_public_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_RSA2048_InitialPrivateKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_rsa2048_private_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_RSA3072_InitialPublicKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_rsa3072_public_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_RSA3072_InitialPrivateKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_rsa3072_private_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_RSA4096_InitialPublicKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_rsa4096_public_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_RSA4096_InitialPrivateKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_rsa4096_private_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_ECC_secp256r1_InitialPublicKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_ecc_public_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_ECC_secp256r1_InitialPrivateKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_ecc_private_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_ECC_secp384r1_InitialPublicKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_ecc_public_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_ECC_secp384r1_InitialPrivateKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_ecc_private_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_ECC_secp521r1_InitialPublicKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_ecc_public_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_ECC_secp521r1_InitialPrivateKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_ecc_private_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_ECC_secp256k1_InitialPublicKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_ecc_public_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_ECC_secp256k1_InitialPrivateKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_ecc_private_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_ECC_brainpoolP256r1_InitialPublicKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_ecc_public_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_ECC_brainpoolP256r1_InitialPrivateKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_ecc_private_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_ECC_brainpoolP384r1_InitialPublicKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_ecc_public_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_ECC_brainpoolP384r1_InitialPrivateKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_ecc_private_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_ECC_brainpoolP512r1_InitialPublicKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_ecc_public_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_ECC_brainpoolP512r1_InitialPrivateKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_ecc_private_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_ECC_Ed25519_InitialPublicKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_ecc_public_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_ECC_Ed25519_InitialPrivateKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_ecc_private_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_HMAC_SHA224_InitialKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_hmac_sha_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_HMAC_SHA256_InitialKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_hmac_sha_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_HMAC_SHA384_InitialKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_hmac_sha_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_HMAC_SHA512_InitialKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_hmac_sha_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_HMAC_SHA512_224_InitialKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_hmac_sha_wrapped_key_t *const p_wrapped_key)
 
fsp_err_t R_RSIP_HMAC_SHA512_256_InitialKeyWrap (rsip_key_injection_type_t const key_injection_type, uint8_t const *const p_wrapped_user_factory_programming_key, uint8_t const *const p_initial_vector, uint8_t const *const p_user_key, rsip_hmac_sha_wrapped_key_t *const p_wrapped_key)
 

Detailed Description

Driver for the Secure Key Injection on RA MCUs.

Overview

This module provides RSIP functions in PSA Crypto.

HW Overview

Crypto Peripheral version Devices
RSIP-E11A RA4L1
RSIP-E51A RA8M1, RA8D1, RA8T1

Features

The RSIP Key Injection Module has two types of APIs, InitialKeyWrap and EncryptedKeyWrap. The available APIs differ depending on used RSIP. Please refer to the following for details.

Key Support

AES Key Injection

Crypto Peripheral version 128 bit 192 bit 256 bit
RSIP-E11A Support No support Support
RSIP-E51A Support Support Support

AES XTS Key Injection

Crypto Peripheral version 128 bit XTS 256 bit XTS
RSIP-E11A No support No support
RSIP-E51A Support Support

RSA Key Injection

Crypto Peripheral version 2048 bit 3072 bit 4096 bit
RSIP-E11A No support No support No support
RSIP-E51A Support Support Support

ECC Key Injection

Crypto Peripheral version secp256r1 secp384r1 secp521r1 secp256k1 brainpool P256r1 brainpool P384r1 brainpool P512r1 Ed25519
RSIP-E11A Private Key Wrap Only No support No support Private Key Wrap Only Private Key Wrap Only No support No support No support
RSIP-E51A Support Support Support Support Support Support Support Support

HMAC Key Injection

Crypto Peripheral version SHA224 SHA256 SHA384 SHA512 SHA512/224 SHA512/256
RSIP-E11A Support Support No support No support No support No support
RSIP-E51A Support Support Support Support Support Support

Configuration

Clock Configuration

This module does not require a specific clock configuration.

Pin Configuration

This module does not use I/O pins.

Usage Notes

Module activation

RSIP Key Umport for PSA Crypto Module is off by default. To use it, please On the Stacks tab, add New > Security > MbedTLS or MbedTLS (Crypto Only), Add Requires RSIP Driver > New > (*1), Add Key Injection for RSA Crypto (Optional) > New > Key Injectin for RSA Crypto for PSA Crypto Module after adding MbedTLS. For information on how to injection and update secure keys, refer to the Application Note R11AN0496.

Hardware Initialization

Please refer to Hardware Initialization in Mbed Crypto H/W Acceleration (rm_psa_crypto).

Function Documentation

◆ R_RSIP_AES128_InitialKeyWrap()

fsp_err_t R_RSIP_AES128_InitialKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_aes_wrapped_key_t *const  p_wrapped_key 
)

This API generates 128-bit AES key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key128-bit AES wrapped key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_AES192_InitialKeyWrap()

fsp_err_t R_RSIP_AES192_InitialKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_aes_wrapped_key_t *const  p_wrapped_key 
)

This API generates 192-bit AES key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key192-bit AES wrapped key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
  • FSP_ERR_UNSUPPORTED This API is not supported on this device.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_AES256_InitialKeyWrap()

fsp_err_t R_RSIP_AES256_InitialKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_aes_wrapped_key_t *const  p_wrapped_key 
)

This API generates 256-bit AES key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key256-bit AES wrapped key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_AES128_XTS_InitialKeyWrap()

fsp_err_t R_RSIP_AES128_XTS_InitialKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_aes_wrapped_key_t *const  p_wrapped_key 
)

This API generates 128-bit AES-XTS key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key128-bit AES-XTS wrapped key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
  • FSP_ERR_UNSUPPORTED This API is not supported on this device.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_AES256_XTS_InitialKeyWrap()

fsp_err_t R_RSIP_AES256_XTS_InitialKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_aes_wrapped_key_t *const  p_wrapped_key 
)

This API generates 256-bit AES-XTS key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key256-bit AES-XTS wrapped key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
  • FSP_ERR_UNSUPPORTED This API is not supported on this device.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_RSA2048_InitialPublicKeyWrap()

fsp_err_t R_RSIP_RSA2048_InitialPublicKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_rsa2048_public_wrapped_key_t *const  p_wrapped_key 
)

This API generates 2048-bit RSA public key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key2048-bit RSA wrapped public key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
  • FSP_ERR_UNSUPPORTED This API is not supported on this device.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_RSA2048_InitialPrivateKeyWrap()

fsp_err_t R_RSIP_RSA2048_InitialPrivateKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_rsa2048_private_wrapped_key_t *const  p_wrapped_key 
)

This API generates 2048-bit RSA private key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key2048-bit RSA wrapped private key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
  • FSP_ERR_UNSUPPORTED This API is not supported on this device.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_RSA3072_InitialPublicKeyWrap()

fsp_err_t R_RSIP_RSA3072_InitialPublicKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_rsa3072_public_wrapped_key_t *const  p_wrapped_key 
)

This API generates 3072-bit RSA public key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key3072-bit RSA wrapped public key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
  • FSP_ERR_UNSUPPORTED This API is not supported on this device.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_RSA3072_InitialPrivateKeyWrap()

fsp_err_t R_RSIP_RSA3072_InitialPrivateKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_rsa3072_private_wrapped_key_t *const  p_wrapped_key 
)

This API generates 3072-bit RSA private key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key3072-bit RSA wrapped private key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
  • FSP_ERR_UNSUPPORTED This API is not supported on this device.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_RSA4096_InitialPublicKeyWrap()

fsp_err_t R_RSIP_RSA4096_InitialPublicKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_rsa4096_public_wrapped_key_t *const  p_wrapped_key 
)

This API generates 4096-bit RSA public key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key4096-bit RSA wrapped public key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
  • FSP_ERR_UNSUPPORTED This API is not supported on this device.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_RSA4096_InitialPrivateKeyWrap()

fsp_err_t R_RSIP_RSA4096_InitialPrivateKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_rsa4096_private_wrapped_key_t *const  p_wrapped_key 
)

This API generates 4096-bit RSA private key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key4096-bit RSA wrapped private key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
  • FSP_ERR_UNSUPPORTED This API is not supported on this device.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_ECC_secp256r1_InitialPublicKeyWrap()

fsp_err_t R_RSIP_ECC_secp256r1_InitialPublicKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_ecc_public_wrapped_key_t *const  p_wrapped_key 
)

This API generates 256-bit ECC public key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key256-bit ECC wrapped public key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
  • FSP_ERR_UNSUPPORTED This API is not supported on this device.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_ECC_secp256r1_InitialPrivateKeyWrap()

fsp_err_t R_RSIP_ECC_secp256r1_InitialPrivateKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_ecc_private_wrapped_key_t *const  p_wrapped_key 
)

This API generates 256-bit ECC private key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key256-bit ECC wrapped private key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_ECC_secp384r1_InitialPublicKeyWrap()

fsp_err_t R_RSIP_ECC_secp384r1_InitialPublicKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_ecc_public_wrapped_key_t *const  p_wrapped_key 
)

This API generates 384-bit ECC public key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key384-bit ECC wrapped public key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
  • FSP_ERR_UNSUPPORTED This API is not supported on this device.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_ECC_secp384r1_InitialPrivateKeyWrap()

fsp_err_t R_RSIP_ECC_secp384r1_InitialPrivateKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_ecc_private_wrapped_key_t *const  p_wrapped_key 
)

This API generates 384-bit ECC private key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key384-bit ECC wrapped private key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
  • FSP_ERR_UNSUPPORTED This API is not supported on this device.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_ECC_secp521r1_InitialPublicKeyWrap()

fsp_err_t R_RSIP_ECC_secp521r1_InitialPublicKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_ecc_public_wrapped_key_t *const  p_wrapped_key 
)

This API generates 521-bit ECC public key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key521-bit ECC wrapped public key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
  • FSP_ERR_UNSUPPORTED This API is not supported on this device.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_ECC_secp521r1_InitialPrivateKeyWrap()

fsp_err_t R_RSIP_ECC_secp521r1_InitialPrivateKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_ecc_private_wrapped_key_t *const  p_wrapped_key 
)

This API generates 521-bit ECC private key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key521-bit ECC wrapped private key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
  • FSP_ERR_UNSUPPORTED This API is not supported on this device.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_ECC_secp256k1_InitialPublicKeyWrap()

fsp_err_t R_RSIP_ECC_secp256k1_InitialPublicKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_ecc_public_wrapped_key_t *const  p_wrapped_key 
)

This API generates 256-bit ECC public key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key256-bit ECC wrapped public key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
  • FSP_ERR_UNSUPPORTED This API is not supported on this device.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_ECC_secp256k1_InitialPrivateKeyWrap()

fsp_err_t R_RSIP_ECC_secp256k1_InitialPrivateKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_ecc_private_wrapped_key_t *const  p_wrapped_key 
)

This API generates 256-bit ECC private key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key256-bit ECC wrapped private key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
  • FSP_ERR_UNSUPPORTED This API is not supported on this device.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_ECC_brainpoolP256r1_InitialPublicKeyWrap()

fsp_err_t R_RSIP_ECC_brainpoolP256r1_InitialPublicKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_ecc_public_wrapped_key_t *const  p_wrapped_key 
)

This API generates 256-bit brainpool ECC public key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key256-bit ECC wrapped public key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
  • FSP_ERR_UNSUPPORTED This API is not supported on this device.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_ECC_brainpoolP256r1_InitialPrivateKeyWrap()

fsp_err_t R_RSIP_ECC_brainpoolP256r1_InitialPrivateKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_ecc_private_wrapped_key_t *const  p_wrapped_key 
)

This API generates 256-bit brainpool ECC private key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key256-bit ECC wrapped private key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
  • FSP_ERR_UNSUPPORTED This API is not supported on this device.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_ECC_brainpoolP384r1_InitialPublicKeyWrap()

fsp_err_t R_RSIP_ECC_brainpoolP384r1_InitialPublicKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_ecc_public_wrapped_key_t *const  p_wrapped_key 
)

This API generates 384-bit brainpool ECC public key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key384-bit ECC wrapped public key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
  • FSP_ERR_UNSUPPORTED This API is not supported on this device.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_ECC_brainpoolP384r1_InitialPrivateKeyWrap()

fsp_err_t R_RSIP_ECC_brainpoolP384r1_InitialPrivateKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_ecc_private_wrapped_key_t *const  p_wrapped_key 
)

This API generates 384-bit brainpool ECC private key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key384-bit ECC wrapped key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
  • FSP_ERR_UNSUPPORTED This API is not supported on this device.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_ECC_brainpoolP512r1_InitialPublicKeyWrap()

fsp_err_t R_RSIP_ECC_brainpoolP512r1_InitialPublicKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_ecc_public_wrapped_key_t *const  p_wrapped_key 
)

This API generates 512-bit brainpool ECC public key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key512-bit ECC wrapped public key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
  • FSP_ERR_UNSUPPORTED This API is not supported on this device.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_ECC_brainpoolP512r1_InitialPrivateKeyWrap()

fsp_err_t R_RSIP_ECC_brainpoolP512r1_InitialPrivateKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_ecc_private_wrapped_key_t *const  p_wrapped_key 
)

This API generates 512-bit brainpool ECC private key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key512-bit ECC wrapped private key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
  • FSP_ERR_UNSUPPORTED This API is not supported on this device.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_ECC_Ed25519_InitialPublicKeyWrap()

fsp_err_t R_RSIP_ECC_Ed25519_InitialPublicKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_ecc_public_wrapped_key_t *const  p_wrapped_key 
)

This API generates 256-bit Edwards curve ECC public key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key256-bit ECC wrapped public key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
  • FSP_ERR_UNSUPPORTED This API is not supported on this device.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_ECC_Ed25519_InitialPrivateKeyWrap()

fsp_err_t R_RSIP_ECC_Ed25519_InitialPrivateKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_ecc_private_wrapped_key_t *const  p_wrapped_key 
)

This API generates 256-bit Edwards curve ECC private key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key256-bit ECC wrapped private key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
  • FSP_ERR_UNSUPPORTED This API is not supported on this device.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_HMAC_SHA224_InitialKeyWrap()

fsp_err_t R_RSIP_HMAC_SHA224_InitialKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_hmac_sha_wrapped_key_t *const  p_wrapped_key 
)

This API generates 224-bit HMAC-SHA key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key224-bit HMAC-SHA wrapped key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_HMAC_SHA256_InitialKeyWrap()

fsp_err_t R_RSIP_HMAC_SHA256_InitialKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_hmac_sha_wrapped_key_t *const  p_wrapped_key 
)

This API generates 256-bit HMAC-SHA key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key256-bit HMAC-SHA wrapped key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_HMAC_SHA384_InitialKeyWrap()

fsp_err_t R_RSIP_HMAC_SHA384_InitialKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_hmac_sha_wrapped_key_t *const  p_wrapped_key 
)

This API generates 384-bit HMAC-SHA key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key384-bit HMAC-SHA wrapped key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
  • FSP_ERR_UNSUPPORTED This API is not supported on this device.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_HMAC_SHA512_InitialKeyWrap()

fsp_err_t R_RSIP_HMAC_SHA512_InitialKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_hmac_sha_wrapped_key_t *const  p_wrapped_key 
)

This API generates 512-bit HMAC-SHA key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key512-bit HMAC-SHA wrapped key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
  • FSP_ERR_UNSUPPORTED This API is not supported on this device.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_HMAC_SHA512_224_InitialKeyWrap()

fsp_err_t R_RSIP_HMAC_SHA512_224_InitialKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_hmac_sha_wrapped_key_t *const  p_wrapped_key 
)

This API generates 512/224-bit HMAC-SHA key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key512/224-bit HMAC-SHA wrapped key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
  • FSP_ERR_UNSUPPORTED This API is not supported on this device.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.

◆ R_RSIP_HMAC_SHA512_256_InitialKeyWrap()

fsp_err_t R_RSIP_HMAC_SHA512_256_InitialKeyWrap ( rsip_key_injection_type_t const  key_injection_type,
uint8_t const *const  p_wrapped_user_factory_programming_key,
uint8_t const *const  p_initial_vector,
uint8_t const *const  p_user_key,
rsip_hmac_sha_wrapped_key_t *const  p_wrapped_key 
)

This API generates 512/256-bit HMAC-SHA key within the user routine.

Parameters
[in]key_injection_typeSelection key injection type when generating wrapped key
[in]p_wrapped_user_factory_programming_keyWrapped user factory programming key by the Renesas Key Wrap Service. When key injection type is plain, this is not required and any value can be specified.
[in]p_initial_vectorInitialization vector when generating encrypted key. When key injection type is plain, this is not required and any value can be specified.
[in]p_user_keyUser key. If key injection type is not plain, it is encrypted and MAC appended
[out]p_wrapped_key512/256-bit HMAC-SHA wrapped key
Return values
FSP_SUCCESSNormal termination.
Returns
If an error occurs, the return value will be as follows.
  • FSP_ERR_ASSERTION A required parameter is NULL.
  • FSP_ERR_CRYPTO_SCE_FAIL MAC anomaly detection.
  • FSP_ERR_CRYPTO_SCE_RESOURCE_CONFLICT Resource conflict.
  • FSP_ERR_CRYPTO_UNKNOWN An unknown error occurred.
  • FSP_ERR_INVALID_STATE Internal state is illegal.
  • FSP_ERR_UNSUPPORTED This API is not supported on this device.
Note
The pre-run state is RSIP Enabled State. After the function runs the state transitions to RSIP Enabled State.