/*!
* Create two links using keys allocated in the scc
*
* @param header The Sahara header value for the descriptor.
* @param in1 The first input buffer (or NULL)
* @param in1_length Size of @a in1
* @param[out] in2 The second input buffer (or NULL)
* @param in2_length Size of @a in2
* @param mu Memory functions
* @param[in,out] desc_chain Chain to start or append to
*
* @return A return code of type #fsl_shw_return_t.
*/
fsl_shw_return_t add_key_key_desc(uint32_t header,
fsl_shw_sko_t * key_info1,
fsl_shw_sko_t * key_info2,
const sah_Mem_Util * mu,
sah_Head_Desc ** desc_chain)
{
fsl_shw_return_t status;
sah_Link *link1 = NULL;
sah_Link *link2 = NULL;
status = sah_Create_Key_Link(mu, &link1, key_info1);
if (status == FSL_RETURN_OK_S) {
status = sah_Create_Key_Link(mu, &link2, key_info2);
}
if (status != FSL_RETURN_OK_S) {
if (link1 != NULL) {
sah_Destroy_Link(mu, link1);
}
if (link2 != NULL) {
sah_Destroy_Link(mu, link2);
}
} else {
status = sah_Append_Desc(mu, desc_chain, header, link1, link2);
}
return status;
}
/*!
* Add descriptor where both links are inputs, the second one being a key.
*
* @param header The Sahara header value for the descriptor.
* @param in1 The first input buffer (or NULL)
* @param in1_length Size of @a in1
* @param[out] in2 The second input buffer (or NULL)
* @param in2_length Size of @a in2
* @param mu Memory functions
* @param[in,out] desc_chain Chain to start or append to
*
* @return A return code of type #fsl_shw_return_t.
*/
fsl_shw_return_t add_in_key_desc(uint32_t header,
const uint8_t * in1,
uint32_t in1_length,
fsl_shw_sko_t * key_info,
const sah_Mem_Util * mu,
sah_Head_Desc ** desc_chain)
{
fsl_shw_return_t status = FSL_RETURN_OK_S;
sah_Link *link1 = NULL;
sah_Link *link2 = NULL;
if (in1 != NULL) {
status = sah_Create_Link(mu, &link1,
(sah_Oct_Str) in1, in1_length,
SAH_USES_LINK_DATA);
}
if (status == FSL_RETURN_OK_S) {
status = sah_Create_Key_Link(mu, &link2, key_info);
}
if (status != FSL_RETURN_OK_S) {
if (link1 != NULL) {
sah_Destroy_Link(mu, link1);
}
if (link2 != NULL) {
sah_Destroy_Link(mu, link2);
}
} else {
status = sah_Append_Desc(mu, desc_chain, header, link1, link2);
}
return status;
}
/*!
* Add descriptor where link1 is a key, link2 is output buffer.
*
* @param header The Sahara header value for the descriptor.
* @param key_info Key information
* @param[out] out The output buffer
* @param out_length Size of the output buffer
* @param mu Memory functions
* @param[in,out] desc_chain Chain to start or append to
*
* @return A return code of type #fsl_shw_return_t.
*/
fsl_shw_return_t add_key_out_desc(uint32_t header, fsl_shw_sko_t * key_info,
uint8_t * out, uint32_t out_length,
const sah_Mem_Util * mu,
sah_Head_Desc ** desc_chain)
{
fsl_shw_return_t status;
sah_Link *link1 = NULL;
sah_Link *link2 = NULL;
status = sah_Create_Key_Link(mu, &link1, key_info);
if ((status == FSL_RETURN_OK_S) && (out != NULL)) {
status = sah_Create_Link(mu, &link2,
(sah_Oct_Str) out, out_length,
SAH_OUTPUT_LINK | SAH_USES_LINK_DATA);
}
if (status != FSL_RETURN_OK_S) {
if (link1 != NULL) {
sah_Destroy_Link(mu, link1);
}
if (link2 != NULL) {
sah_Destroy_Link(mu, link2);
}
} else {
status = sah_Append_Desc(mu, desc_chain, header, link1, link2);
}
return status;
}
/*!
* Perform wrapping of a black key from a RED slot
*
* @param user_ctx A user context from #fsl_shw_register_user().
* @param[in,out] key_info The information about the key to be which will
* be wrapped... key length, slot info, etc.
* @param black_key Place to store encrypted key
*
* @return A return code of type #fsl_shw_return_t.
*/
static fsl_shw_return_t wrap(fsl_shw_uco_t * user_ctx,
fsl_shw_sko_t * key_info, uint8_t * black_key)
{
fsl_shw_return_t ret;
sah_Head_Desc *desc_chain = NULL;
unsigned slots_allocated = 0; /* boolean */
fsl_shw_sko_t T_key_info; /* for holding T */
fsl_shw_sko_t KEK_key_info; /* for holding KEK */
black_key[LENGTH_OFFSET] = key_info->key_length;
black_key[ALGORITHM_OFFSET] = key_info->algorithm;
memcpy(&T_key_info, key_info, sizeof(T_key_info));
fsl_shw_sko_set_key_length(&T_key_info, T_LENGTH);
T_key_info.algorithm = FSL_KEY_ALG_HMAC;
memcpy(&KEK_key_info, &T_key_info, sizeof(KEK_key_info));
KEK_key_info.algorithm = FSL_KEY_ALG_AES;
ret = do_scc_slot_alloc(user_ctx, T_LENGTH, key_info->userid,
&T_key_info.handle);
if (ret == FSL_RETURN_OK_S) {
ret = do_scc_slot_alloc(user_ctx, KEK_LENGTH, key_info->userid,
&KEK_key_info.handle);
if (ret != FSL_RETURN_OK_S) {
#ifdef DIAG_SECURITY_FUNC
LOG_DIAG("do_scc_slot_alloc() failed");
#endif
do_scc_slot_dealloc(user_ctx, key_info->userid,
T_key_info.handle);
} else {
slots_allocated = 1;
}
}
/* Set up to compute everything except T' ... */
if (ret == FSL_RETURN_OK_S) {
uint32_t header;
#ifndef DO_REPEATABLE_WRAP
/* Compute T = RND() */
header = SAH_HDR_RNG_GENERATE; /* Desc. #18 */
ret = add_key_out_desc(header, &T_key_info, NULL, 0,
user_ctx->mem_util, &desc_chain);
#else
ret = do_scc_slot_load_slot(user_ctx, T_key_info.userid,
T_key_info.handle, T_block,
T_key_info.key_length);
#endif
/* Compute KEK = SHA1(T | Ownerid) */
if (ret == FSL_RETURN_OK_S) {
sah_Link *link1;
sah_Link *link2;
header = (SAH_HDR_MDHA_SET_MODE_HASH /* #8 */
^ insert_mdha_init
^ insert_mdha_algorithm[FSL_HASH_ALG_SHA1]
^ insert_mdha_pdata);
/* Input - Start with T */
ret =
sah_Create_Key_Link(user_ctx->mem_util, &link1,
&T_key_info);
if (ret == FSL_RETURN_OK_S) {
/* Still input - append ownerid */
ret = sah_Append_Link(user_ctx->mem_util, link1,
(void *)&key_info->userid,
sizeof(key_info->userid),
SAH_USES_LINK_DATA);
}
if (ret == FSL_RETURN_OK_S) {
/* Output - KEK goes into RED slot */
ret =
sah_Create_Key_Link(user_ctx->mem_util,
&link2, &KEK_key_info);
}
/* Put the Hash calculation into the chain. */
if (ret == FSL_RETURN_OK_S) {
ret =
sah_Append_Desc(user_ctx->mem_util,
&desc_chain, header, link1,
link2);
}
}
/* Compute KEY' = AES-encrypt(KEK, KEY) */
if (ret == FSL_RETURN_OK_S) {
header = (SAH_HDR_SKHA_SET_MODE_IV_KEY /* #1 */
^ insert_skha_mode[FSL_SYM_MODE_CTR]
^ insert_skha_algorithm[FSL_KEY_ALG_AES]
^ insert_skha_modulus[FSL_CTR_MOD_128]);
/* Set up KEK as key to use */
ret = add_in_key_desc(header, NULL, 0, &KEK_key_info,
user_ctx->mem_util, &desc_chain);
/* Set up KEY as input, KEY' as output */
if (ret == FSL_RETURN_OK_S) {
header = SAH_HDR_SKHA_ENC_DEC; /* #4 */
ret = add_key_out_desc(header, key_info,
black_key +
KEY_PRIME_OFFSET,
key_info->key_length,
user_ctx->mem_util,
&desc_chain);
}
#ifdef DIAG_SECURITY_FUNC
if (ret != FSL_RETURN_OK_S) {
LOG_DIAG
("Creation of sah_Key_Link failed due to bad key"
" flag!\n");
}
#endif /*DIAG_SECURITY_FUNC */
}
/* Compute and store ICV into Black Key */
if (ret == FSL_RETURN_OK_S) {
ret =
create_icv_calc(user_ctx, &desc_chain, &T_key_info,
black_key, key_info->key_length,
black_key + ICV_OFFSET);
#ifdef DIAG_SECURITY_FUNC
if (ret != FSL_RETURN_OK_S) {
LOG_DIAG
("Creation of sah_Key_Link failed due to bad key"
" flag!\n");
}
#endif /*DIAG_SECURITY_FUNC */
}
}
/* Now get Sahara to do the work. */
if (ret == FSL_RETURN_OK_S) {
ret = sah_Descriptor_Chain_Execute(desc_chain, user_ctx);
#ifdef DIAG_SECURITY_FUNC
if (ret != FSL_RETURN_OK_S) {
LOG_DIAG("sah_Descriptor_Chain_Execute() failed");
}
#endif
}
/* Compute T' = SLID_encrypt(T); Result goes to Black Key */
if (ret == FSL_RETURN_OK_S) {
ret = do_scc_slot_encrypt(user_ctx, T_key_info.userid,
T_key_info.handle,
T_LENGTH, black_key + T_PRIME_OFFSET);
#ifdef DIAG_SECURITY_FUNC
if (ret != FSL_RETURN_OK_S) {
LOG_DIAG("do_scc_slot_encrypt() failed");
}
#endif
}
if (slots_allocated) {
do_scc_slot_dealloc(user_ctx, key_info->userid,
T_key_info.handle);
do_scc_slot_dealloc(user_ctx, key_info->userid,
KEK_key_info.handle);
}
return ret;
} /* wrap */
/*!
* Perform unwrapping of a black key into a RED slot
*
* @param user_ctx A user context from #fsl_shw_register_user().
* @param[in,out] key_info The information about the key to be which will
* be unwrapped... key length, slot info, etc.
* @param black_key Encrypted key
*
* @return A return code of type #fsl_shw_return_t.
*/
static fsl_shw_return_t unwrap(fsl_shw_uco_t * user_ctx,
fsl_shw_sko_t * key_info,
const uint8_t * black_key)
{
fsl_shw_return_t ret = FSL_RETURN_ERROR_S;
sah_Mem_Util *mu = user_ctx->mem_util;
uint8_t *hmac = mu->mu_malloc(mu->mu_ref, ICV_LENGTH);
if (hmac == NULL) {
ret = FSL_RETURN_NO_RESOURCE_S;
} else {
sah_Head_Desc *desc_chain = NULL;
fsl_shw_sko_t t_key_info;
unsigned i;
/* Set up key_info for "T" - use same slot as eventual key */
fsl_shw_sko_init(&t_key_info, FSL_KEY_ALG_AES);
t_key_info.userid = key_info->userid;
t_key_info.handle = key_info->handle;
t_key_info.flags = key_info->flags;
t_key_info.key_length = T_LENGTH;
/* Compute T = SLID_decrypt(T'); leave in RED slot */
ret = do_scc_slot_decrypt(user_ctx, key_info->userid,
t_key_info.handle,
T_LENGTH, black_key + T_PRIME_OFFSET);
/* Compute ICV = HMAC(T, ownerid | len | alg | key' */
if (ret == FSL_RETURN_OK_S) {
ret =
create_icv_calc(user_ctx, &desc_chain, &t_key_info,
black_key, key_info->key_length,
hmac);
if (ret == FSL_RETURN_OK_S) {
ret =
sah_Descriptor_Chain_Execute(desc_chain,
user_ctx);
desc_chain = NULL;
}
#ifdef DIAG_SECURITY_FUNC
else {
LOG_DIAG
("Creation of sah_Key_Link failed due to bad key"
" flag!\n");
}
#endif /*DIAG_SECURITY_FUNC */
/* Check computed ICV against value in Black Key */
if (ret == FSL_RETURN_OK_S) {
for (i = 0; i < ICV_LENGTH; i++) {
if (black_key[ICV_OFFSET + i] !=
hmac[i]) {
ret = FSL_RETURN_AUTH_FAILED_S;
break;
}
}
}
/* This is no longer needed. */
mu->mu_free(mu->mu_ref, hmac);
/* Compute KEK = SHA1(T | ownerid). Rewrite slot with value */
if (ret == FSL_RETURN_OK_S) {
sah_Link *link1 = NULL;
sah_Link *link2 = NULL;
uint32_t header;
header = (SAH_HDR_MDHA_SET_MODE_HASH /* #8 */
^ insert_mdha_init
^ insert_mdha_algorithm_sha1
^ insert_mdha_pdata);
/* Input - Start with T */
ret =
sah_Create_Key_Link(user_ctx->mem_util,
&link1, &t_key_info);
if (ret == FSL_RETURN_OK_S) {
/* Still input - append ownerid */
ret =
sah_Append_Link(user_ctx->mem_util,
link1,
(void *)&key_info->
userid,
sizeof(key_info->
userid),
SAH_USES_LINK_DATA);
}
if (ret == FSL_RETURN_OK_S) {
/* Output - KEK goes into RED slot */
ret =
sah_Create_Key_Link(user_ctx->
mem_util,
&link2,
&t_key_info);
}
if (ret == FSL_RETURN_OK_S) {
/* Put the Hash calculation into the chain. */
ret =
sah_Append_Desc(user_ctx->mem_util,
&desc_chain, header,
link1, link2);
}
}
/* Compute KEY = AES-decrypt(KEK, KEY') */
if (ret == FSL_RETURN_OK_S) {
uint32_t header;
unsigned rounded_key_length;
unsigned original_key_length =
key_info->key_length;
header = (SAH_HDR_SKHA_SET_MODE_IV_KEY /* #1 */
^ insert_skha_mode_ctr
^ insert_skha_algorithm_aes
^ insert_skha_modulus_128);
/* Load KEK in as the key to use */
ret =
add_in_key_desc(header, NULL, 0,
&t_key_info,
user_ctx->mem_util,
&desc_chain);
/* Make sure that KEY = AES(KEK, KEY') step writes a multiple
of words into the SCC to avoid 'Byte Access errors.' */
if ((original_key_length & 3) != 0) {
rounded_key_length =
original_key_length + 4 -
(original_key_length & 3);
} else {
rounded_key_length =
original_key_length;
}
key_info->key_length = rounded_key_length;
if (ret == FSL_RETURN_OK_S) {
/* Now set up for computation. Result in RED */
header = SAH_HDR_SKHA_ENC_DEC; /* #4 */
ret =
add_in_key_desc(header,
black_key +
KEY_PRIME_OFFSET,
rounded_key_length,
key_info,
user_ctx->mem_util,
&desc_chain);
key_info->key_length =
original_key_length;
/* Perform the operation */
if (ret == FSL_RETURN_OK_S) {
ret =
sah_Descriptor_Chain_Execute
(desc_chain, user_ctx);
}
}
}
/* Erase tracks */
t_key_info.userid = 0xdeadbeef;
t_key_info.handle = 0xdeadbeef;
}
}
return ret;
} /* unwrap */
/*!
* Perform wrapping of a black key from a RED slot
*
* @param user_ctx A user context from #fsl_shw_register_user().
* @param[in,out] key_info The information about the key to be which will
* be wrapped... key length, slot info, etc.
* @param black_key Place to store encrypted key
*
* @return A return code of type #fsl_shw_return_t.
*/
static fsl_shw_return_t wrap(fsl_shw_uco_t * user_ctx,
fsl_shw_sko_t * key_info, uint8_t * black_key)
{
SAH_SF_DCLS;
unsigned slots_allocated = 0; /* boolean */
fsl_shw_sko_t T_key_info; /* for holding T */
fsl_shw_sko_t KEK_key_info; /* for holding KEK */
unsigned original_key_length = key_info->key_length;
unsigned rounded_key_length;
sah_Link *link1;
sah_Link *link2;
black_key[LENGTH_OFFSET] = key_info->key_length;
black_key[ALGORITHM_OFFSET] = key_info->algorithm;
memcpy(&T_key_info, key_info, sizeof(T_key_info));
fsl_shw_sko_set_key_length(&T_key_info, T_LENGTH);
T_key_info.algorithm = FSL_KEY_ALG_HMAC;
memcpy(&KEK_key_info, &T_key_info, sizeof(KEK_key_info));
KEK_key_info.algorithm = FSL_KEY_ALG_AES;
if (key_info->keystore == NULL) {
/* Key goes in system keystore */
ret = do_system_keystore_slot_alloc(user_ctx,
T_LENGTH, key_info->userid,
&T_key_info.handle);
} else {
/* Key goes in user keystore */
ret = keystore_slot_alloc(key_info->keystore,
T_LENGTH,
key_info->userid, &T_key_info.handle);
}
if (ret != FSL_RETURN_OK_S) {
goto out;
}
if (key_info->keystore == NULL) {
/* Key goes in system keystore */
ret = do_system_keystore_slot_alloc(user_ctx,
KEK_LENGTH, key_info->userid,
&KEK_key_info.handle);
} else {
/* Key goes in user keystore */
ret = keystore_slot_alloc(key_info->keystore,
KEK_LENGTH, key_info->userid,
&KEK_key_info.handle);
}
if (ret != FSL_RETURN_OK_S) {
#ifdef DIAG_SECURITY_FUNC
LOG_DIAG("do_scc_slot_alloc() failed");
#endif
if (key_info->keystore == NULL) {
/* Key goes in system keystore */
(void)do_system_keystore_slot_dealloc(user_ctx,
key_info->userid, T_key_info.handle);
} else {
/* Key goes in user keystore */
(void)keystore_slot_dealloc(key_info->keystore,
key_info->userid, T_key_info.handle);
}
} else {
slots_allocated = 1;
}
/* Set up to compute everything except T' ... */
#ifndef DO_REPEATABLE_WRAP
/* Compute T = RND() */
header = SAH_HDR_RNG_GENERATE; /* Desc. #18 */
DESC_KEY_OUT(header, &T_key_info, 0, NULL);
#else
if (key_info->keystore == NULL) {
/* Key goes in system keystore */
ret = do_system_keystore_slot_load(user_ctx,
T_key_info.userid,
T_key_info.handle, T_block,
T_key_info.key_length);
} else {
/* Key goes in user keystore */
ret = keystore_slot_load(key_info->keystore,
T_key_info.userid,
T_key_info.handle,
T_block, T_key_info.key_length);
}
if (ret != FSL_RETURN_OK_S) {
goto out;
}
#endif
/* Compute KEK = SHA256(T | Ownerid) */
header = (SAH_HDR_MDHA_SET_MODE_HASH /* #8 */
^ sah_insert_mdha_init
^ sah_insert_mdha_algorithm[FSL_HASH_ALG_SHA256]
^ sah_insert_mdha_pdata);
/* Input - Start with T */
ret = sah_Create_Key_Link(user_ctx->mem_util, &link1, &T_key_info);
if (ret != FSL_RETURN_OK_S) {
goto out;
}
/* Still input - append ownerid */
ret = sah_Append_Link(user_ctx->mem_util, link1,
(void *)&key_info->userid,
sizeof(key_info->userid), SAH_USES_LINK_DATA);
if (ret != FSL_RETURN_OK_S) {
goto out;
}
/* Output - KEK goes into RED slot */
ret = sah_Create_Key_Link(user_ctx->mem_util, &link2, &KEK_key_info);
if (ret != FSL_RETURN_OK_S) {
goto out;
}
/* Put the Hash calculation into the chain. */
ret = sah_Append_Desc(user_ctx->mem_util, &desc_chain,
header, link1, link2);
if (ret != FSL_RETURN_OK_S) {
goto out;
}
#if defined(NEED_CTR_WORKAROUND)
rounded_key_length = ROUND_LENGTH(original_key_length);
key_info->key_length = rounded_key_length;
#else
rounded_key_length = original_key_length;
#endif
/* Compute KEY' = AES-encrypt(KEK, KEY) */
header = (SAH_HDR_SKHA_SET_MODE_IV_KEY /* #1 */
^ sah_insert_skha_mode[FSL_SYM_MODE_CTR]
^ sah_insert_skha_algorithm[FSL_KEY_ALG_AES]
^ sah_insert_skha_modulus[FSL_CTR_MOD_128]);
/* Set up KEK as key to use */
DESC_IN_KEY(header, 0, NULL, &KEK_key_info);
header = SAH_HDR_SKHA_ENC_DEC;
DESC_KEY_OUT(header, key_info,
key_info->key_length, black_key + KEY_PRIME_OFFSET);
/* Set up flags info */
black_key[FLAGS_OFFSET] = 0;
if (key_info->flags & FSL_SKO_KEY_SW_KEY) {
black_key[FLAGS_OFFSET] |= FLAGS_SW_KEY;
}
/* Compute and store ICV into Black Key */
ret = create_icv_calc(user_ctx, &desc_chain, &T_key_info,
black_key, original_key_length,
black_key + ICV_OFFSET);
if (ret != FSL_RETURN_OK_S) {
#ifdef DIAG_SECURITY_FUNC
LOG_DIAG("Creation of sah_Key_Link failed due to bad key"
" flag!\n");
#endif /*DIAG_SECURITY_FUNC */
goto out;
}
/* Now get Sahara to do the work. */
#ifdef DIAG_SECURITY_FUNC
LOG_DIAG("Encrypting key with KEK");
#endif
SAH_SF_EXECUTE();
if (ret != FSL_RETURN_OK_S) {
#ifdef DIAG_SECURITY_FUNC
LOG_DIAG("sah_Descriptor_Chain_Execute() failed");
#endif
goto out;
}
/* Compute T' = SLID_encrypt(T); Result goes to Black Key */
if (key_info->keystore == NULL) {
/* Key goes in system keystore */
ret = do_system_keystore_slot_encrypt(user_ctx,
T_key_info.userid, T_key_info.handle,
T_LENGTH, black_key + T_PRIME_OFFSET);
} else {
/* Key goes in user keystore */
ret = keystore_slot_encrypt(user_ctx,
key_info->keystore,
T_key_info.userid,
T_key_info.handle,
T_LENGTH,
black_key + T_PRIME_OFFSET);
}
if (ret != FSL_RETURN_OK_S) {
#ifdef DIAG_SECURITY_FUNC
LOG_DIAG("do_scc_slot_encrypt() failed");
#endif
goto out;
}
out:
key_info->key_length = original_key_length;
SAH_SF_DESC_CLEAN();
if (slots_allocated) {
if (key_info->keystore == NULL) {
/* Key goes in system keystore */
(void)do_system_keystore_slot_dealloc(user_ctx,
key_info->userid,
T_key_info.
handle);
(void)do_system_keystore_slot_dealloc(user_ctx,
key_info->userid,
KEK_key_info.
handle);
} else {
/* Key goes in user keystore */
(void)keystore_slot_dealloc(key_info->keystore,
key_info->userid,
T_key_info.handle);
(void)keystore_slot_dealloc(key_info->keystore,
key_info->userid,
KEK_key_info.handle);
}
}
return ret;
} /* wrap */
/*!
* Perform unwrapping of a black key into a RED slot
*
* @param user_ctx A user context from #fsl_shw_register_user().
* @param[in,out] key_info The information about the key to be which will
* be unwrapped... key length, slot info, etc.
* @param black_key Encrypted key
*
* @return A return code of type #fsl_shw_return_t.
*/
static fsl_shw_return_t unwrap(fsl_shw_uco_t * user_ctx,
fsl_shw_sko_t * key_info,
const uint8_t * black_key)
{
SAH_SF_DCLS;
uint8_t *hmac = NULL;
fsl_shw_sko_t t_key_info;
sah_Link *link1 = NULL;
sah_Link *link2 = NULL;
unsigned i;
unsigned rounded_key_length;
unsigned original_key_length = key_info->key_length;
hmac = DESC_TEMP_ALLOC(ICV_LENGTH);
/* Set up key_info for "T" - use same slot as eventual key */
fsl_shw_sko_init(&t_key_info, FSL_KEY_ALG_AES);
t_key_info.userid = key_info->userid;
t_key_info.handle = key_info->handle;
t_key_info.flags = key_info->flags;
t_key_info.key_length = T_LENGTH;
t_key_info.keystore = key_info->keystore;
/* Validate SW flags to prevent misuse */
if ((key_info->flags & FSL_SKO_KEY_SW_KEY)
&& !(black_key[FLAGS_OFFSET] & FLAGS_SW_KEY)) {
ret = FSL_RETURN_BAD_FLAG_S;
goto out;
}
/* Compute T = SLID_decrypt(T'); leave in RED slot */
if (key_info->keystore == NULL) {
/* Key goes in system keystore */
ret = do_system_keystore_slot_decrypt(user_ctx,
key_info->userid,
t_key_info.handle,
T_LENGTH,
black_key + T_PRIME_OFFSET);
} else {
/* Key goes in user keystore */
ret = keystore_slot_decrypt(user_ctx,
key_info->keystore,
key_info->userid,
t_key_info.handle,
T_LENGTH,
black_key + T_PRIME_OFFSET);
}
if (ret != FSL_RETURN_OK_S) {
goto out;
}
/* Compute ICV = HMAC(T, ownerid | len | alg | key' */
ret = create_icv_calc(user_ctx, &desc_chain, &t_key_info,
black_key, original_key_length, hmac);
if (ret != FSL_RETURN_OK_S) {
#ifdef DIAG_SECURITY_FUNC
LOG_DIAG("Creation of sah_Key_Link failed due to bad key"
" flag!\n");
#endif /*DIAG_SECURITY_FUNC */
goto out;
}
#ifdef DIAG_SECURITY_FUNC
LOG_DIAG("Validating MAC of wrapped key");
#endif
SAH_SF_EXECUTE();
if (ret != FSL_RETURN_OK_S) {
goto out;
}
SAH_SF_DESC_CLEAN();
/* Check computed ICV against value in Black Key */
for (i = 0; i < ICV_LENGTH; i++) {
if (black_key[ICV_OFFSET + i] != hmac[i]) {
#ifdef DIAG_SECURITY_FUNC
LOG_DIAG_ARGS("computed ICV fails at offset %i\n", i);
{
char buff[300];
int a;
for (a = 0; a < ICV_LENGTH; a++)
sprintf(&(buff[a * 2]), "%02x",
black_key[ICV_OFFSET + a]);
buff[a * 2 + 1] = 0;
LOG_DIAG_ARGS("black key: %s", buff);
for (a = 0; a < ICV_LENGTH; a++)
sprintf(&(buff[a * 2]), "%02x",
hmac[a]);
buff[a * 2 + 1] = 0;
LOG_DIAG_ARGS("hmac: %s", buff);
}
#endif
ret = FSL_RETURN_AUTH_FAILED_S;
goto out;
}
}
/* This is no longer needed. */
DESC_TEMP_FREE(hmac);
/* Compute KEK = SHA256(T | ownerid). Rewrite slot with value */
header = (SAH_HDR_MDHA_SET_MODE_HASH /* #8 */
^ sah_insert_mdha_init
^ sah_insert_mdha_algorithm_sha256 ^ sah_insert_mdha_pdata);
/* Input - Start with T */
ret = sah_Create_Key_Link(user_ctx->mem_util, &link1, &t_key_info);
if (ret != FSL_RETURN_OK_S) {
goto out;
}
/* Still input - append ownerid */
ret = sah_Append_Link(user_ctx->mem_util, link1,
(void *)&key_info->userid,
sizeof(key_info->userid), SAH_USES_LINK_DATA);
if (ret != FSL_RETURN_OK_S) {
goto out;
}
/* Output - KEK goes into RED slot */
ret = sah_Create_Key_Link(user_ctx->mem_util, &link2, &t_key_info);
if (ret != FSL_RETURN_OK_S) {
goto out;
}
/* Put the Hash calculation into the chain. */
ret = sah_Append_Desc(user_ctx->mem_util, &desc_chain,
header, link1, link2);
if (ret != FSL_RETURN_OK_S) {
goto out;
}
/* Compute KEY = AES-decrypt(KEK, KEY') */
header = (SAH_HDR_SKHA_SET_MODE_IV_KEY /* #1 */
^ sah_insert_skha_mode_ctr
^ sah_insert_skha_algorithm_aes
^ sah_insert_skha_modulus_128);
/* Load KEK in as the key to use */
DESC_IN_KEY(header, 0, NULL, &t_key_info);
rounded_key_length = ROUND_LENGTH(original_key_length);
key_info->key_length = rounded_key_length;
/* Now set up for computation. Result in RED */
header = SAH_HDR_SKHA_ENC_DEC; /* #4 */
DESC_IN_KEY(header, rounded_key_length, black_key + KEY_PRIME_OFFSET,
key_info);
/* Perform the operation */
#ifdef DIAG_SECURITY_FUNC
LOG_DIAG("Decrypting key with KEK");
#endif
SAH_SF_EXECUTE();
out:
key_info->key_length = original_key_length;
SAH_SF_DESC_CLEAN();
DESC_TEMP_FREE(hmac);
/* Erase tracks */
t_key_info.userid = 0xdeadbeef;
t_key_info.handle = 0xdeadbeef;
return ret;
} /* unwrap */
