static int
idea_init(pgp_crypt_t *crypt)
{
if (crypt->keysize != IDEA_KEY_LENGTH) {
(void) fprintf(stderr, "idea_init: keysize wrong\n");
return 0;
}
if (crypt->encrypt_key) {
free(crypt->encrypt_key);
}
if ((crypt->encrypt_key = calloc(1, sizeof(IDEA_KEY_SCHEDULE))) == NULL) {
(void) fprintf(stderr, "idea_init: alloc failure\n");
return 0;
}
/* note that we don't invert the key when decrypting for CFB mode */
idea_set_encrypt_key(crypt->key, crypt->encrypt_key);
if (crypt->decrypt_key) {
free(crypt->decrypt_key);
}
if ((crypt->decrypt_key = calloc(1, sizeof(IDEA_KEY_SCHEDULE))) == NULL) {
(void) fprintf(stderr, "idea_init: alloc failure\n");
return 0;
}
idea_set_decrypt_key(crypt->encrypt_key, crypt->decrypt_key);
return 1;
}
static int cfb64_test(unsigned char *cfb_cipher)
{
IDEA_KEY_SCHEDULE eks, dks;
int err = 0, i, n;
idea_set_encrypt_key(cfb_key, &eks);
idea_set_decrypt_key(&eks, &dks);
memcpy(cfb_tmp, cfb_iv, 8);
n = 0;
idea_cfb64_encrypt(plain, cfb_buf1, (long)12, &eks,
cfb_tmp, &n, IDEA_ENCRYPT);
idea_cfb64_encrypt(&(plain[12]), &(cfb_buf1[12]),
(long)CFB_TEST_SIZE - 12, &eks,
cfb_tmp, &n, IDEA_ENCRYPT);
if (memcmp(cfb_cipher, cfb_buf1, CFB_TEST_SIZE) != 0) {
err = 1;
printf("idea_cfb64_encrypt encrypt error\n");
for (i = 0; i < CFB_TEST_SIZE; i += 8)
printf("%s\n", pt(&(cfb_buf1[i])));
}
memcpy(cfb_tmp, cfb_iv, 8);
n = 0;
idea_cfb64_encrypt(cfb_buf1, cfb_buf2, (long)13, &eks,
cfb_tmp, &n, IDEA_DECRYPT);
idea_cfb64_encrypt(&(cfb_buf1[13]), &(cfb_buf2[13]),
(long)CFB_TEST_SIZE - 13, &eks,
cfb_tmp, &n, IDEA_DECRYPT);
if (memcmp(plain, cfb_buf2, CFB_TEST_SIZE) != 0) {
err = 1;
printf("idea_cfb_encrypt decrypt error\n");
for (i = 0; i < 24; i += 8)
printf("%s\n", pt(&(cfb_buf2[i])));
}
return (err);
}
static int idea_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
const unsigned char *iv, int enc)
{
if(!enc) {
if (EVP_CIPHER_CTX_mode(ctx) == EVP_CIPH_OFB_MODE) enc = 1;
else if (EVP_CIPHER_CTX_mode(ctx) == EVP_CIPH_CFB_MODE) enc = 1;
}
if (enc) idea_set_encrypt_key(key,ctx->cipher_data);
else
{
IDEA_KEY_SCHEDULE tmp;
idea_set_encrypt_key(key,&tmp);
idea_set_decrypt_key(&tmp,ctx->cipher_data);
OPENSSL_cleanse((unsigned char *)&tmp,
sizeof(IDEA_KEY_SCHEDULE));
}
return 1;
}
static int idea_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
const unsigned char *iv, int enc)
{
if(!enc) {
if (EVP_CIPHER_CTX_mode(ctx) == EVP_CIPH_OFB_MODE) enc = 1;
else if (EVP_CIPHER_CTX_mode(ctx) == EVP_CIPH_CFB_MODE) enc = 1;
}
if (enc) idea_set_encrypt_key(key,&(ctx->c.idea_ks));
else
{
IDEA_KEY_SCHEDULE tmp;
idea_set_encrypt_key(key,&tmp);
idea_set_decrypt_key(&tmp,&(ctx->c.idea_ks));
memset((unsigned char *)&tmp,0,
sizeof(IDEA_KEY_SCHEDULE));
}
return 1;
}
static void idea_init(ops_crypt_t *crypt)
{
assert(crypt->keysize == IDEA_KEY_LENGTH);
if (crypt->encrypt_key)
free(crypt->encrypt_key);
crypt->encrypt_key=malloc(sizeof(IDEA_KEY_SCHEDULE));
// note that we don't invert the key when decrypting for CFB mode
idea_set_encrypt_key(crypt->key,crypt->encrypt_key);
if (crypt->decrypt_key)
free(crypt->decrypt_key);
crypt->decrypt_key=malloc(sizeof(IDEA_KEY_SCHEDULE));
idea_set_decrypt_key(crypt->encrypt_key,crypt->decrypt_key);
}
static int cfb64_test(unsigned char *cfb_cipher)
{
IDEA_KEY_SCHEDULE eks,dks;
int err=0,i,n;
idea_set_encrypt_key(cfb_key,&eks);
idea_set_decrypt_key(&eks,&dks);
TINYCLR_SSL_MEMCPY(cfb_tmp,cfb_iv,8);
n=0;
idea_cfb64_encrypt(plain,cfb_buf1,(long)12,&eks,
cfb_tmp,&n,IDEA_ENCRYPT);
idea_cfb64_encrypt(&(plain[12]),&(cfb_buf1[12]),
(long)CFB_TEST_SIZE-12,&eks,
cfb_tmp,&n,IDEA_ENCRYPT);
if (TINYCLR_SSL_MEMCMP(cfb_cipher,cfb_buf1,CFB_TEST_SIZE) != 0)
{
err=1;
TINYCLR_SSL_PRINTF("idea_cfb64_encrypt encrypt error\n");
for (i=0; i<CFB_TEST_SIZE; i+=8)
TINYCLR_SSL_PRINTF("%s\n",pt(&(cfb_buf1[i])));
}
TINYCLR_SSL_MEMCPY(cfb_tmp,cfb_iv,8);
n=0;
idea_cfb64_encrypt(cfb_buf1,cfb_buf2,(long)17,&eks,
cfb_tmp,&n,IDEA_DECRYPT);
idea_cfb64_encrypt(&(cfb_buf1[17]),&(cfb_buf2[17]),
(long)CFB_TEST_SIZE-17,&dks,
cfb_tmp,&n,IDEA_DECRYPT);
if (TINYCLR_SSL_MEMCMP(plain,cfb_buf2,CFB_TEST_SIZE) != 0)
{
err=1;
TINYCLR_SSL_PRINTF("idea_cfb_encrypt decrypt error\n");
for (i=0; i<24; i+=8)
TINYCLR_SSL_PRINTF("%s\n",pt(&(cfb_buf2[i])));
}
return(err);
}
int main(int argc, char *argv[])
{
int i,err=0;
IDEA_KEY_SCHEDULE key,dkey;
unsigned char iv[8];
idea_set_encrypt_key(k,&key);
idea_ecb_encrypt(in,out,&key);
if (memcmp(out,c,8) != 0)
{
printf("ecb idea error encrypting\n");
printf("got :");
for (i=0; i<8; i++)
printf("%02X ",out[i]);
printf("\n");
printf("expected:");
for (i=0; i<8; i++)
printf("%02X ",c[i]);
err=20;
printf("\n");
}
idea_set_decrypt_key(&key,&dkey);
idea_ecb_encrypt(c,out,&dkey);
if (memcmp(out,in,8) != 0)
{
printf("ecb idea error decrypting\n");
printf("got :");
for (i=0; i<8; i++)
printf("%02X ",out[i]);
printf("\n");
printf("expected:");
for (i=0; i<8; i++)
printf("%02X ",in[i]);
printf("\n");
err=3;
}
if (err == 0) printf("ecb idea ok\n");
memcpy(iv,k,8);
idea_cbc_encrypt((unsigned char *)text,out,strlen(text)+1,&key,iv,1);
memcpy(iv,k,8);
idea_cbc_encrypt(out,out,8,&dkey,iv,0);
idea_cbc_encrypt(&(out[8]),&(out[8]),strlen(text)+1-8,&dkey,iv,0);
if (memcmp(text,out,strlen(text)+1) != 0)
{
printf("cbc idea bad\n");
err=4;
}
else
printf("cbc idea ok\n");
printf("cfb64 idea ");
if (cfb64_test(cfb_cipher64))
{
printf("bad\n");
err=5;
}
else
printf("ok\n");
#ifdef OPENSSL_SYS_NETWARE
if (err) printf("ERROR: %d\n", err);
#endif
EXIT(err);
return(err);
}
/* {{{ CI_Ceay_DecryptInit */
CK_DEFINE_FUNCTION(CK_RV, CI_Ceay_DecryptInit)(
CK_I_SESSION_DATA_PTR session_data,
CK_MECHANISM_PTR pMechanism, /* the decryption mechanism */
CK_I_OBJ_PTR key_obj /* handle of decryption key */
)
{
CK_RV rv = CKR_OK;
CI_LogEntry("C_DecryptInit", "starting...", rv , 0);
switch(pMechanism->mechanism)
{
/* {{{ CKM_RSA_PKCS */
case CKM_RSA_PKCS:
{
RSA CK_PTR internal_key_obj = NULL_PTR;
/* check that object is a private key */
if((CI_ObjLookup(key_obj,CK_IA_CLASS) == NULL_PTR) ||
(*((CK_OBJECT_CLASS CK_PTR)CI_ObjLookup(key_obj,CK_IA_CLASS)->pValue) != CKO_PRIVATE_KEY))
return CKR_KEY_TYPE_INCONSISTENT;
CI_LogEntry("C_Ceay_DecryptInit", "RSA PKCS starting", rv, 2);
internal_key_obj = CI_Ceay_Obj2RSA(key_obj);
if(internal_key_obj == NULL_PTR)
return CKR_HOST_MEMORY;
session_data->decrypt_state = (CK_VOID_PTR)internal_key_obj;
session_data->decrypt_mechanism = CKM_RSA_PKCS;
}
break;
/* }}} */
/* {{{ CKM_RSA_X_509 */
case CKM_RSA_X_509:
{
RSA CK_PTR internal_key_obj = NULL_PTR;
/* check that object is a private key */
if((CI_ObjLookup(key_obj,CK_IA_CLASS) == NULL_PTR) ||
(*((CK_OBJECT_CLASS CK_PTR)CI_ObjLookup(key_obj,CK_IA_CLASS)->pValue) != CKO_PRIVATE_KEY))
return CKR_KEY_TYPE_INCONSISTENT;
CI_LogEntry("C_Ceay_DecryptInit", "RSA X509 starting", rv, 2);
internal_key_obj = CI_Ceay_Obj2RSA(key_obj);
if(internal_key_obj == NULL_PTR)
return CKR_HOST_MEMORY;
session_data->decrypt_state = (CK_VOID_PTR)internal_key_obj;
session_data->decrypt_mechanism = CKM_RSA_X_509;
}
break;
/* }}} */
/* {{{ CKM_RC4 */
case CKM_RC4:
{
RC4_KEY CK_PTR internal_obj = NULL_PTR;
CK_ULONG key_len;
CI_LogEntry("C_Ceay_DecryptInit", "RC4 starting", rv, 2);
internal_obj = CI_RC4Key_new();
if(internal_obj == NULL_PTR)
return CKR_HOST_MEMORY;
if(CI_ObjLookup(key_obj,CK_IA_VALUE_LEN) != NULL_PTR)
key_len = *((CK_ULONG_PTR)(CI_ObjLookup(key_obj,CK_IA_VALUE_LEN)->pValue));
else
key_len = (CI_ObjLookup(key_obj,CK_IA_VALUE)->ulValueLen);
RC4_set_key(internal_obj,
key_len,
CI_ObjLookup(key_obj,CK_IA_VALUE)->pValue);
session_data->decrypt_state = (CK_VOID_PTR)internal_obj;
session_data->decrypt_mechanism = CKM_RC4;
}
break;
/* }}} */
/* {{{ CKM_RC2_ECB */
case CKM_RC2_ECB:
{
RC2_KEY CK_PTR internal_obj = NULL_PTR;
CK_ULONG key_len;
/* check correct parameter */
if((pMechanism->pParameter == NULL_PTR) ||
(pMechanism->ulParameterLen != sizeof(CK_RC2_PARAMS)))
return CKR_MECHANISM_PARAM_INVALID;
CI_LogEntry("C_CL_DecryptInit", "RC2 ECB starting", rv, 2);
internal_obj = CI_RC2Key_new();
if(internal_obj == NULL_PTR)
return CKR_HOST_MEMORY;
if(CI_ObjLookup(key_obj,CK_IA_VALUE_LEN) != NULL_PTR)
key_len = *((CK_ULONG_PTR)(CI_ObjLookup(key_obj,CK_IA_VALUE_LEN)->pValue));
else
key_len = CI_ObjLookup(key_obj,CK_IA_VALUE)->ulValueLen;
RC2_set_key(internal_obj,
key_len,
CI_ObjLookup(key_obj,CK_IA_VALUE)->pValue,
(int)pMechanism->pParameter);
session_data->decrypt_state = (CK_VOID_PTR)internal_obj;
session_data->decrypt_mechanism = CKM_RC2_ECB;
}
break;
/* }}} */
/* {{{ CKM_RC2_CBC */
case CKM_RC2_CBC:
{
CK_I_CEAY_RC2_INFO_PTR internal_obj = NULL_PTR;
CK_ULONG key_len;
CK_RC2_CBC_PARAMS_PTR para = pMechanism->pParameter;
rv = CKR_OK;
internal_obj= CI_RC2_INFO_new();
if(internal_obj == NULL_PTR)
{
rv = CKR_HOST_MEMORY;
goto decrypt_init_rc2_error;
}
CI_LogEntry("C_CL_DecryptInit", "RC2 CBC starting", rv, 2);
/* Ok, alles alloziert, jetzt die wirklichen Werte eintragen */
/* Mechanism zuerst, denn da kann ja der Parameter fehlen */
if((pMechanism->pParameter == NULL_PTR) ||
(pMechanism->ulParameterLen != sizeof(CK_RC2_CBC_PARAMS)))
{
rv = CKR_MECHANISM_PARAM_INVALID;
goto decrypt_init_rc2_error;
}
/* Na da wolle wir mal besser sicher gehen das ceay und pkcs11 vom gleichen reden! */
assert(sizeof(CK_BYTE) == sizeof(unsigned char));
memcpy(internal_obj->ivec,para->iv, sizeof(CK_BYTE)*8);
{
CK_BYTE_PTR tmp_str = NULL_PTR;
CI_VarLogEntry("CI_Ceay_EncryptInit", "RC2 CBC ivec: %s", rv, 2,
tmp_str = CI_PrintableByteStream(internal_obj->ivec,
sizeof(CK_BYTE)*8));
TC_free(tmp_str);
}
if(CI_ObjLookup(key_obj,CK_IA_VALUE_LEN) != NULL_PTR)
key_len = *((CK_ULONG_PTR)(CI_ObjLookup(key_obj,CK_IA_VALUE_LEN)->pValue));
else
key_len = CI_ObjLookup(key_obj,CK_IA_VALUE)->ulValueLen;
/* TODO: check that the size of the effective Bits are valid */
RC2_set_key(internal_obj->key,
key_len,
(unsigned char*)CI_ObjLookup(key_obj,CK_IA_VALUE)->pValue,
(int)para->ulEffectiveBits);
session_data->decrypt_state = internal_obj;
session_data->decrypt_mechanism = CKM_RC2_CBC;
decrypt_init_rc2_error:
if(rv != CKR_OK)
{
if(internal_obj->key) TC_free(internal_obj->key);
if(internal_obj) TC_free(internal_obj);
}
}
break;
/* }}} */
/* {{{ CKM_DES_ECB */
case CKM_DES_ECB:
{
des_key_schedule CK_PTR internal_obj = NULL_PTR;
CK_BYTE_PTR tmp_key_data;
internal_obj = TC_malloc(sizeof(des_key_schedule));
if(internal_obj == NULL_PTR)
return CKR_HOST_MEMORY;
CI_LogEntry("C_CL_DecryptInit", "DES ECB starting", rv, 2);
tmp_key_data = CI_ObjLookup(key_obj,CK_IA_VALUE)->pValue;
if(tmp_key_data == NULL_PTR)
return CKR_KEY_TYPE_INCONSISTENT;
des_set_key((des_cblock*)tmp_key_data,
*((des_key_schedule CK_PTR)internal_obj));
session_data->decrypt_state = (CK_VOID_PTR)internal_obj;
session_data->decrypt_mechanism = CKM_DES_ECB;
}
break;
/* }}} */
/* {{{ CKM_DES_CBC */
case CKM_DES_CBC:
{
CK_I_CEAY_DES_INFO_PTR internal_obj = NULL_PTR;
CK_BYTE_PTR tmp_key_data;
rv = CKR_OK; /* positiv denken */
CI_LogEntry("C_CL_DecryptInit", "DES CBC starting", rv, 2);
internal_obj= CI_DES_INFO_new();
if(internal_obj == NULL_PTR)
{
rv = CKR_HOST_MEMORY;
goto decrypt_init_des_error;
}
/* Ok, alles alloziert, jetzt die wirklichen Werte eintragen */
/* Mechanism zuerst, denn da kann ja der Parameter fehlen */
if((pMechanism->pParameter == NULL_PTR) ||
(pMechanism->ulParameterLen != sizeof(des_cblock)))
{
rv = CKR_MECHANISM_PARAM_INVALID;
goto decrypt_init_des_error;
}
memcpy(internal_obj->ivec,pMechanism->pParameter, sizeof(des_cblock));
{
CK_BYTE_PTR tmp_str = NULL_PTR;
CI_VarLogEntry("CI_Ceay_EncryptInit", "DES CBC ivec: %s", rv, 2,
tmp_str = CI_PrintableByteStream((CK_BYTE_PTR)internal_obj->ivec,
sizeof(des_cblock)));
TC_free(tmp_str);
}
tmp_key_data = CI_ObjLookup(key_obj,CK_IA_VALUE)->pValue;
if(tmp_key_data == NULL_PTR) return CKR_KEY_TYPE_INCONSISTENT;
des_set_key((des_cblock*)tmp_key_data,internal_obj->sched);
session_data->decrypt_state = internal_obj;
session_data->decrypt_mechanism = CKM_DES_CBC;
/* ugly global value from the ceay lib */
des_rw_mode = DES_CBC_MODE;
decrypt_init_des_error:
if(rv != CKR_OK)
CI_DES_INFO_delete(internal_obj);
}
break;
/* }}} */
/* {{{ CKM_DES_CBC_PAD */
case CKM_DES_CBC_PAD:
{
CK_I_CEAY_DES_INFO_PTR internal_obj = NULL_PTR;
CK_BYTE_PTR tmp_key_data;
rv = CKR_OK; /* positiv denken */
internal_obj= CI_DES_INFO_new();
if(internal_obj == NULL_PTR)
{
rv = CKR_HOST_MEMORY;
goto decrypt_init_des_error;
}
/* Ok, alles alloziert, jetzt die wirklichen Werte eintragen */
/* Mechanism zuerst, denn da kann ja der Parameter fehlen */
if((pMechanism->pParameter == NULL_PTR) ||
(pMechanism->ulParameterLen != sizeof(des_cblock)))
{
rv = CKR_MECHANISM_PARAM_INVALID;
goto decrypt_init_des_pad_error;
}
memcpy(internal_obj->ivec,pMechanism->pParameter, sizeof(des_cblock));
{
CK_BYTE_PTR tmp_str = NULL_PTR;
CI_VarLogEntry("CI_Ceay_EncryptInit", "DES CBC PAD ivec: %s", rv, 2,
tmp_str = CI_PrintableByteStream((CK_BYTE_PTR)internal_obj->ivec,
sizeof(des_cblock)));
TC_free(tmp_str);
}
tmp_key_data = CI_ObjLookup(key_obj,CK_IA_VALUE)->pValue;
if(tmp_key_data == NULL_PTR) return CKR_KEY_TYPE_INCONSISTENT;
des_set_key((des_cblock*)tmp_key_data,internal_obj->sched);
session_data->decrypt_state = internal_obj;
session_data->decrypt_mechanism = CKM_DES_CBC_PAD;
((CK_I_CEAY_DES_INFO_PTR)session_data->decrypt_state)->pad = 0;
memset(((CK_I_CEAY_DES_INFO_PTR)session_data->decrypt_state)->lastblock, 0, 8);
/* ugly global value from the ceay lib */
des_rw_mode = DES_CBC_MODE;
decrypt_init_des_pad_error:
if(rv != CKR_OK)
CI_DES_INFO_delete(internal_obj);
}
break;
/* }}} */
/* {{{ CKM_DES3_ECB */
case CKM_DES3_ECB:
{
CK_I_CEAY_DES3_INFO_PTR internal_obj = NULL_PTR;
CI_LogEntry("C_CL_DecryptInit", "DES3 ECB starting", rv, 2);
/* TODO: change this into des_cblock[3] */
internal_obj = CI_DES3_INFO_new(CI_ObjLookup(key_obj,CK_IA_VALUE)->pValue);
if(internal_obj == NULL_PTR)
return CKR_HOST_MEMORY;
session_data->decrypt_state = (CK_VOID_PTR)internal_obj;
session_data->decrypt_mechanism = CKM_DES3_ECB;
}
break;
/* }}} */
/* {{{ CKM_DES3_CBC */
case CKM_DES3_CBC:
{
CK_I_CEAY_DES3_INFO_PTR internal_obj = NULL_PTR;
rv = CKR_OK; /* positiv denken */
/* Mechanism zuerst prüfen, denn da kann ja der Parameter fehlen */
if((pMechanism->pParameter == NULL_PTR) ||
(pMechanism->ulParameterLen != sizeof(des_cblock)))
return CKR_MECHANISM_PARAM_INVALID;
CI_LogEntry("C_CL_DecryptInit", "DES3 CBC/PAD starting", rv, 2);
internal_obj= CI_DES3_INFO_new(CI_ObjLookup(key_obj,CK_IA_VALUE)->pValue);
if(internal_obj == NULL_PTR)
return CKR_HOST_MEMORY;
/* Ok, alles alloziert, jetzt die wirklichen Werte eintragen */
memcpy(internal_obj->ivec,pMechanism->pParameter, sizeof(des_cblock));
{
CK_BYTE_PTR tmp_str = NULL_PTR;
CI_VarLogEntry("CI_Ceay_EncryptInit", "DES3 CBC ivec: %s", rv, 2,
tmp_str = CI_PrintableByteStream((CK_BYTE_PTR)internal_obj->ivec,
sizeof(des_cblock)));
TC_free(tmp_str);
}
session_data->decrypt_state = internal_obj;
session_data->decrypt_mechanism = CKM_DES3_CBC;
/* ugly global value from the ceay lib */
des_rw_mode = DES_CBC_MODE;
}
break;
/* }}} */
/* {{{ CKM_IDEA_ECB */
case CKM_IDEA_ECB:
{
IDEA_KEY_SCHEDULE CK_PTR internal_obj = NULL_PTR;
IDEA_KEY_SCHEDULE temp_sched;
CI_LogEntry("C_CL_DecryptInit", "IDEA ECB starting", rv, 2);
internal_obj = CI_IDEA_KEY_SCHEDULE_new();
if(internal_obj == NULL_PTR)
return CKR_HOST_MEMORY;
/*
* This is the IDEA way: generate an encryption key and then convert
* it to a decrypt key
*/
idea_set_encrypt_key(CI_ObjLookup(key_obj,CK_IA_VALUE)->pValue,
&temp_sched);
idea_set_decrypt_key(&temp_sched,internal_obj);
session_data->decrypt_state = (CK_VOID_PTR)internal_obj;
session_data->decrypt_mechanism = CKM_IDEA_ECB;
rv = CKR_OK;
}
break;
/* }}} */
/* {{{ CKM_IDEA_CBC */
case CKM_IDEA_CBC:
{
CK_I_CEAY_IDEA_INFO_PTR internal_obj = NULL_PTR;
IDEA_KEY_SCHEDULE temp_sched;
rv = CKR_OK; /* positiv denken */
/* check Mechanism first, there might be a parameter missing */
if((pMechanism->pParameter == NULL_PTR) ||
(pMechanism->ulParameterLen != sizeof(des_cblock)))
return CKR_MECHANISM_PARAM_INVALID;
CI_LogEntry("C_CL_DecryptInit", "IDEA CBC starting", rv, 2);
internal_obj= CI_IDEA_INFO_new();
if(internal_obj == NULL_PTR)
return CKR_HOST_MEMORY;
/* Ok, alles alloziert, jetzt die wirklichen Werte eintragen */
memcpy(internal_obj->ivec,pMechanism->pParameter, sizeof(des_cblock));
{
CK_BYTE_PTR tmp_str = NULL_PTR;
CI_VarLogEntry("CI_Ceay_EncryptInit", "IDEA CBC ivec: %s", rv, 2,
tmp_str = CI_PrintableByteStream(internal_obj->ivec,
sizeof(des_cblock)));
TC_free(tmp_str);
}
idea_set_encrypt_key(CI_ObjLookup(key_obj,CK_IA_VALUE)->pValue,&temp_sched);
idea_set_decrypt_key(&temp_sched,&(internal_obj->sched));
session_data->decrypt_state = internal_obj;
session_data->decrypt_mechanism = CKM_IDEA_CBC;
}
break;
/* }}} */
default:
rv = CKR_MECHANISM_INVALID;
CI_VarLogEntry("C_DecryptInit", "algorithm specified: %s", rv, 0,
CI_MechanismStr(pMechanism->mechanism));
}
return rv;
}
static int cuda_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, int enc) {
switch ((ctx->cipher)->nid) {
case NID_des_ecb:
case NID_des_cbc:
if (!quiet && verbose) fprintf(stdout,"Start calculating DES key schedule...");
DES_key_schedule des_key_schedule;
DES_set_key((const_DES_cblock *)key,&des_key_schedule);
DES_cuda_transfer_key_schedule(&des_key_schedule);
if(iv)
DES_cuda_transfer_iv(iv);
break;
case NID_bf_ecb:
case NID_bf_cbc:
if (!quiet && verbose) fprintf(stdout,"Start calculating Blowfish key schedule...\n");
BF_KEY key_schedule;
BF_set_key(&key_schedule,ctx->key_len,key);
BF_cuda_transfer_key_schedule(&key_schedule);
if(iv)
BF_cuda_transfer_iv(iv);
break;
case NID_cast5_ecb:
case NID_cast5_cbc:
if (!quiet && verbose) fprintf(stdout,"Start calculating CAST5 key schedule...\n");
CAST_KEY cast_key_schedule;
CAST_set_key(&cast_key_schedule,ctx->key_len*8,key);
CAST_cuda_transfer_key_schedule(&cast_key_schedule);
if(iv)
CAST_cuda_transfer_iv(iv);
break;
case NID_camellia_128_ecb:
case NID_camellia_128_cbc:
if (!quiet && verbose) fprintf(stdout,"Start calculating Camellia key schedule...\n");
CAMELLIA_KEY cmll_key_schedule;
Camellia_set_key(key,ctx->key_len*8,&cmll_key_schedule);
CMLL_cuda_transfer_key_schedule(&cmll_key_schedule);
if(iv)
CMLL_cuda_transfer_iv(iv);
break;
case NID_idea_ecb:
case NID_idea_cbc:
if (!quiet && verbose) fprintf(stdout,"Start calculating IDEA key schedule...\n");
{
IDEA_KEY_SCHEDULE idea_key_schedule, idea_dec_key_schedule;
idea_set_encrypt_key(key,&idea_key_schedule);
if(!(ctx->encrypt)) {
idea_set_decrypt_key(&idea_key_schedule,&idea_dec_key_schedule);
IDEA_cuda_transfer_key_schedule(&idea_dec_key_schedule);
} else {
IDEA_cuda_transfer_key_schedule(&idea_key_schedule);
}
}
if(iv)
IDEA_cuda_transfer_iv(iv);
break;
case NID_aes_128_ecb:
case NID_aes_128_cbc:
{
if (!quiet && verbose) fprintf(stdout,"Start calculating AES-128 key schedule...\n");
AES_KEY aes_key_schedule;
if(ctx->encrypt)
AES_cuda_set_encrypt_key(key,128,&aes_key_schedule);
else
AES_cuda_set_decrypt_key(key,128,&aes_key_schedule);
AES_cuda_transfer_key_schedule(&aes_key_schedule);
}
if(iv)
AES_cuda_transfer_iv(iv);
break;
case NID_aes_192_ecb:
case NID_aes_192_cbc:
if (!quiet && verbose) fprintf(stdout,"Start calculating AES-192 key schedule...\n");
{
AES_KEY aes_key_schedule;
if(ctx->encrypt)
AES_cuda_set_encrypt_key(key,192,&aes_key_schedule);
else
AES_cuda_set_decrypt_key(key,192,&aes_key_schedule);
AES_cuda_transfer_key_schedule(&aes_key_schedule);
if(iv)
AES_cuda_transfer_iv(iv);
}
break;
case NID_aes_256_ecb:
case NID_aes_256_cbc:
if (!quiet && verbose) fprintf(stdout,"Start calculating AES-256 key schedule...\n");
{
AES_KEY aes_key_schedule;
if(ctx->encrypt)
AES_cuda_set_encrypt_key(key,256,&aes_key_schedule);
else
AES_cuda_set_decrypt_key(key,256,&aes_key_schedule);
AES_cuda_transfer_key_schedule(&aes_key_schedule);
if(iv)
AES_cuda_transfer_iv(iv);
}
break;
default:
return 0;
}
if (!quiet && verbose) fprintf(stdout,"DONE!\n");
return 1;
}
int main (int argc, char **argv)
{
long count;
static unsigned char buf[BUFSIZE];
static unsigned char key[] = {
0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,
};
IDEA_KEY_SCHEDULE sch;
double a, aa, b, c, d;
#ifndef SIGALRM
long ca, cca, cb, cc;
#endif
#ifndef TIMES
printf ("To get the most accurate results, try to run this\n");
printf ("program when this computer is idle.\n");
#endif
#ifndef SIGALRM
printf ("First we calculate the approximate speed ...\n");
idea_set_encrypt_key (key, &sch);
count = 10;
do
{
long i;
IDEA_INT data[2];
count *= 2;
Time_F (START);
for (i = count; i; i--)
idea_encrypt (data, &sch);
d = Time_F (STOP);
}
while (d < 3.0);
ca = count / 4;
cca = count / 200;
cb = count;
cc = count * 8 / BUFSIZE + 1;
printf ("idea_set_encrypt_key %ld times\n", ca);
#define COND(d) (count <= (d))
#define COUNT(d) (d)
#else
#define COND(c) (run)
#define COUNT(d) (count)
signal (SIGALRM, sig_done);
printf ("Doing idea_set_encrypt_key for 10 seconds\n");
alarm (10);
#endif
Time_F (START);
for (count = 0, run = 1; COND (ca); count += 4)
{
idea_set_encrypt_key (key, &sch);
idea_set_encrypt_key (key, &sch);
idea_set_encrypt_key (key, &sch);
idea_set_encrypt_key (key, &sch);
}
d = Time_F (STOP);
printf ("%ld idea idea_set_encrypt_key's in %.2f seconds\n", count, d);
a = ((double) COUNT (ca)) / d;
#ifdef SIGALRM
printf ("Doing idea_set_decrypt_key for 10 seconds\n");
alarm (10);
#else
printf ("Doing idea_set_decrypt_key %ld times\n", cca);
#endif
Time_F (START);
for (count = 0, run = 1; COND (cca); count += 4)
{
idea_set_decrypt_key (&sch, &sch);
idea_set_decrypt_key (&sch, &sch);
idea_set_decrypt_key (&sch, &sch);
idea_set_decrypt_key (&sch, &sch);
}
d = Time_F (STOP);
printf ("%ld idea idea_set_decrypt_key's in %.2f seconds\n", count, d);
aa = ((double) COUNT (cca)) / d;
#ifdef SIGALRM
printf ("Doing idea_encrypt's for 10 seconds\n");
alarm (10);
#else
printf ("Doing idea_encrypt %ld times\n", cb);
#endif
Time_F (START);
for (count = 0, run = 1; COND (cb); count += 4)
{
unsigned long data[2];
idea_encrypt (data, &sch);
idea_encrypt (data, &sch);
idea_encrypt (data, &sch);
idea_encrypt (data, &sch);
}
d = Time_F (STOP);
printf ("%ld idea_encrypt's in %.2f second\n", count, d);
b = ((double) COUNT (cb) * 8) / d;
#ifdef SIGALRM
printf ("Doing idea_cbc_encrypt on %ld byte blocks for 10 seconds\n", BUFSIZE);
alarm (10);
#else
printf ("Doing idea_cbc_encrypt %ld times on %ld byte blocks\n", cc, BUFSIZE);
#endif
Time_F (START);
for (count = 0, run = 1; COND (cc); count++)
idea_cbc_encrypt (buf, buf, BUFSIZE, &sch, &(key[0]), IDEA_ENCRYPT);
d = Time_F (STOP);
printf ("%ld idea_cbc_encrypt's of %ld byte blocks in %.2f second\n", count, BUFSIZE, d);
c = ((double) COUNT (cc) * BUFSIZE) / d;
printf ("IDEA set_encrypt_key per sec = %12.2f (%9.3fuS)\n", a, 1.0e6 / a);
printf ("IDEA set_decrypt_key per sec = %12.2f (%9.3fuS)\n", aa, 1.0e6 / aa);
printf ("IDEA raw ecb bytes per sec = %12.2f (%9.3fuS)\n", b, 8.0e6 / b);
printf ("IDEA cbc bytes per sec = %12.2f (%9.3fuS)\n", c, 8.0e6 / c);
exit (0);
#if defined(LINT) || defined(OPENSSL_SYS_MSDOS)
return (0);
#endif
}
