void tee_cipher_final(void *ctx, uint32_t algo)
{
switch (algo) {
case TEE_ALG_AES_ECB_NOPAD:
case TEE_ALG_DES_ECB_NOPAD:
case TEE_ALG_DES3_ECB_NOPAD:
ecb_done((symmetric_ECB *)ctx);
break;
case TEE_ALG_AES_CBC_NOPAD:
case TEE_ALG_DES_CBC_NOPAD:
case TEE_ALG_DES3_CBC_NOPAD:
cbc_done((symmetric_CBC *)ctx);
break;
case TEE_ALG_AES_CTR:
ctr_done((symmetric_CTR *)ctx);
break;
case TEE_ALG_AES_XTS:
xts_done((symmetric_xts *)ctx);
break;
case TEE_ALG_AES_CTS:
cbc_done(&(((struct symmetric_CTS *)ctx)->cbc));
ecb_done(&(((struct symmetric_CTS *)ctx)->ecb));
break;
default:
/* TEE_ERROR_NOT_SUPPORTED; */
break;
}
}
C4Err ECB_Encrypt(Cipher_Algorithm algorithm,
const void * key,
const void * in,
size_t bytesIn,
void * out )
{
int err = kC4Err_NoErr;
int status = CRYPT_OK;
symmetric_ECB ECB;
int keylen = 0;
int cipher = -1;
switch(algorithm)
{
case kCipher_Algorithm_AES128:
keylen = 128 >> 3;
cipher = find_cipher("aes");
break;
case kCipher_Algorithm_AES192:
keylen = 192 >> 3;
cipher = find_cipher("aes");
break;
case kCipher_Algorithm_AES256:
keylen = 256 >> 3;
cipher = find_cipher("aes");
break;
case kCipher_Algorithm_2FISH256:
keylen = 256 >> 3;
cipher = find_cipher("twofish");
break;
default:
RETERR(kC4Err_BadCipherNumber);
}
status = ecb_start(cipher, key, keylen, 0, &ECB ); CKSTAT;
status = ecb_encrypt(in, out, bytesIn, &ECB); CKSTAT;
done:
ecb_done(&ECB);
if(status != CRYPT_OK)
err = sCrypt2C4Err(status);
return err;
}
void ltc_cleanup(void)
{
TRACE_DEBUG("LTC: Cleaning up ...\n\r");
#if defined(ENCRYPTION_ECB)
ecb_done(&sECB);
#elif defined(ENCRYPTION_CBC)
cbc_done(&sCBC);
#elif defined(ENCRYPTION_CTR)
ctr_done(&sCTR);
#endif
TRACE_DEBUG("LTC: Cleanup done.\n\r");
}
static int
EncryptECB(
int cipher,
int rounds,
int counterMode,
unsigned char *iv,
unsigned char *key,
unsigned long keyLength,
unsigned char *data,
unsigned long dataLength,
unsigned char *dest
)
{
int status;
symmetric_ECB state;
status = ecb_start(cipher, key, keyLength, rounds, &state);
if (status == CRYPT_OK) {
status = ecb_encrypt(data, dest, dataLength, &state);
ecb_done(&state);
}
return status;
}
static int RunCipherKAT( katvector *kat)
{
int err = CRYPT_OK;
char* name = NULL;
uint8_t *out = NULL;
size_t alloc_len = MAX(kat->EBClen, kat->CBClen);
symmetric_ECB ECB;
symmetric_CBC CBC;
out = malloc(alloc_len);
ZERO(out, alloc_len);
// err = cipher_is_valid(kat->algor); CKERR;
name = cipher_name(kat->algor);
printf("\t%-7s %d ", name, kat->keysize);
printf("%6s", "ECB");
DO( ecb_start(kat->algor, kat->key, kat->keysize>>3, 0, &ECB));
DO( ecb_encrypt(kat->PT, out, kat->PTlen, &ECB))
/* check against know-answer */
DO( compareResults( kat->EBC, out, kat->EBClen , kResultFormat_Byte, "Symmetric Encrypt"));
DO(ecb_decrypt(out, out, kat->PTlen, &ECB));
/* check against orginal plain-text */
DO(compareResults( kat->PT, out, kat->PTlen , kResultFormat_Byte, "Symmetric Decrypt"));
printf("%6s", "CBC");
DO(cbc_start(kat->algor, kat->IV, kat->key, kat->keysize>>3, 0, &CBC));
DO(cbc_encrypt(kat->PT, out, kat->PTlen, &CBC));
/* check against know-answer */
DO(compareResults( kat->CBC, out, kat->CBClen , kResultFormat_Byte, "Symmetric Encrypt"));
// reset CBC befire decrypt*/
cbc_done(&CBC);
DO(cbc_start(kat->algor, kat->IV, kat->key, kat->keysize>>3, 0, &CBC));
DO(cbc_decrypt(out, out, kat->PTlen, &CBC));
/* check against orginal plain-text */
DO( compareResults( kat->PT, out, kat->PTlen , kResultFormat_Byte, "Symmetric Decrypt"));
done:
ecb_done(&ECB);
cbc_done(&CBC);
free(out);
printf("\n");
return err;
}
void ltc_cleanup_ECB(void)
{
TRACE_DEBUG("LTC: Cleaning up ECB...\n\r");
ecb_done(&sECB);
TRACE_DEBUG("LTC: Cleanup done.\n\r");
}
