Importing a Wrapped Key Blob Using PSA Crypto APIs on RW612
Introduction
In a previous article, we demonstrated how to import an RFC3394-wrapped key blob into ELS by manually performing the following operations:
Deriving NXP_DIE_KEK_SK using CKDF-SP800-108
Importing the wrapped blob with mcuxClEls_KeyImport_Async()
Deleting the temporary KEK after import
While this approach provides full visibility into the underlying ELS operations, applications using the PSA Crypto API can achieve the same result with significantly less code.
This article demonstrates how to use psa_import_key() together with PSA_KEY_LOCATION_S50_RFC3394_STORAGE to import a wrapped key blob stored in OTP. The PSA Oracle driver transparently handles the secure key loading sequence, including KEK derivation, key unwrapping, ELS slot management, and cleanup.
Prerequisites
FRDM-RW612
Key blob wrapped using RFC3394 format using HSM_STORE_KEY
Key blob programmed to OTP fuses using LoadKeyBlob command.
Required Headers:
#include "mcux_els.h"
#include "psa/crypto.h"
#include "mcuxClPsaDriver_Oracle_Interface_key_locations.h"
#include "fsl_romapi_otp.h"
Step 0 – Read the Wrapped Key Blob from OTP
The example reads the blob directly from OTP memory.
static psa_status_t read_blob_from_otp(uint8_t *blob_data,
uint32_t blob_length,
uint32_t starting_fuse_index)
{
status_t otp_status;
uint32_t num_fuse_words = blob_length / 4u;
PRINTF("Reading %d fuse words starting from index %d\n",
num_fuse_words, starting_fuse_index);
otp_status = otp_init(DEFAULT_SYSTEM_CLOCK);
if (otp_status != kStatus_Success)
{
PRINTF("Error: otp_init failed: 0x%x\n", otp_status);
return PSA_ERROR_HARDWARE_FAILURE;
}
for (uint32_t i = 0u; i < num_fuse_words; i++)
{
uint32_t fuse_word = 0u;
otp_status = otp_fuse_read(starting_fuse_index + i, &fuse_word);
if (otp_status != kStatus_Success)
{
PRINTF("Error: Failed to read fuse word %d, status: 0x%x\n",
starting_fuse_index + i, otp_status);
return PSA_ERROR_HARDWARE_FAILURE;
}
/* Store fuse word as 4 bytes in little-endian order */
blob_data[i * 4u + 0u] = (uint8_t)((fuse_word >> 0u) & 0xFFu);
blob_data[i * 4u + 1u] = (uint8_t)((fuse_word >> 8u) & 0xFFu);
blob_data[i * 4u + 2u] = (uint8_t)((fuse_word >> 16u) & 0xFFu);
blob_data[i * 4u + 3u] = (uint8_t)((fuse_word >> 24u) & 0xFFu);
PRINTF(" Fuse[%d] = 0x%08X\n", starting_fuse_index + i, fuse_word);
}
PRINTF("Blob data read from OTP successfully\n");
return PSA_SUCCESS;
}
Each fuse word contains four bytes.
These words are assembled into a contiguous buffer:
blob_data[i * 4 + 0] = (fuse_word >> 0) & 0xFF;
blob_data[i * 4 + 1] = (fuse_word >> 8) & 0xFF;
blob_data[i * 4 + 2] = (fuse_word >> 16) & 0xFF;
blob_data[i * 4 + 3] = (fuse_word >> 24) & 0xFF;
The resulting buffer contains the RFC3394 wrapped key.
Step 1 – Configure PSA Key Attributes
Before importing the blob, PSA key attributes must describe how the key should be managed.
The most important configuration is the key location:
psa_set_key_lifetime(
&attributes,
PSA_KEY_LIFETIME_FROM_PERSISTENCE_AND_LOCATION(
PSA_KEY_PERSISTENCE_VOLATILE,
PSA_KEY_LOCATION_S50_RFC3394_STORAGE));
The PSA_KEY_LOCATION_S50_RFC3394_STORAGE location informs the Oracle driver that:
The provided data is an RFC3394-wrapped key blob.
The blob requires unwrapping before use.
NXP_DIE_KEK_SK must be derived automatically during key loading.
In this example we used an AES 128-bit key. The key type and size must match the wrapped key:
psa_set_key_type(&attributes, PSA_KEY_TYPE_AES);
psa_set_key_bits(&attributes, 128);
Usage permissions are then assigned:
psa_set_key_usage_flags(
&attributes,
PSA_KEY_USAGE_ENCRYPT |
PSA_KEY_USAGE_DECRYPT);
Finally, specify the algorithm:
psa_set_key_algorithm(
&attributes,
PSA_ALG_ECB_NO_PADDING);
Step 2 – Import the Wrapped Blob
The blob is imported using a single PSA API call:
psa_import_key(
&attributes,
blob_data,
blob_length,
&key_handle);
For developers familiar with the low-level ELS implementation, this single call effectively replaces:
derive_nxp_die_kek_sk()
import_wrapped_key_blob()
delete_key_from_slot()
At this point, PSA stores the wrapped blob and returns a key handle:
psa_key_id_t key_handle;
The returned handle is subsequently used for cryptographic operations.
Next Steps
At this point, the wrapped key blob has been successfully imported into the target ELS key slot, and the temporary NXP_DIE_KEK_SK has been removed. The imported key is now available for use by ELS-protected cryptographic operations without exposing the underlying key material to application software.
The next step is to validate the imported key by performing the operation it was provisioned for.
For this example, we used AES-ECB encryption:
psa_cipher_encrypt(
key_handle,
PSA_ALG_ECB_NO_PADDING,
plaintext,
sizeof(plaintext),
ciphertext,
sizeof(ciphertext),
&ciphertext_length);
Step 4 – Cleanup
Once the key is no longer required, destroy it using:
psa_destroy_key(key_handle);
This releases the PSA key object and allows the Oracle driver to clean up any associated secure resources.
Unlike the low-level ELS implementation, the application does not need to explicitly manage ELS keyslots.
PSA vs Direct ELS Implementation
Direct ELS API
PSA Crypto API
Derive KEK manually
Automatic
Import blob manually
Automatic
Manage keyslots
Managed by Oracle
Delete temporary KEK
Automatic
Greater control
Simpler application code
Higher implementation effort
Faster integration
Both approaches ultimately leverage the same secure hardware mechanisms within RW612. The PSA approach simply abstracts the underlying ELS operations behind a standardized cryptographic interface.
View full article
