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 }