int encrypt(char *password, char *plaintext, char *ciphertext) { MCRYPT td; int i; char *key; char block_buffer; char *IV; char *salt; td = mcrypt_module_open(algorithm, NULL, mode, NULL); if (td == MCRYPT_FAILED) { printf("failed to open module\n"); return 1; } salt = crypt_malloc(saltsize); crypt_random(salt, saltsize); // printf("salt:%s\n",salt); IV = crypt_malloc(ivsize); crypt_random(IV, ivsize); // printf("IV:%s\n",IV); putin_meg(ciphertext, salt, IV); key = crypt_malloc(keysize); data.hash_algorithm[0] = hash_algo; data.count = 0; data.salt = salt; data.salt_size = saltsize; mhash_keygen_ext(KEYGEN_MCRYPT, data, key, keysize, password, strlen(password)); printf("key:%s\n",key); i = mcrypt_generic_init(td, key, keysize, IV); if (i<0) { mcrypt_perror(i); return 1; } // printf("%d",strlen(plaintext)); // Here to encrypt in CFB performed in bytes for(i=36; i<strlen(plaintext); i++) { // printf("%c",plaintext[i]); block_buffer = plaintext[i]; mcrypt_generic (td, &block_buffer, 1); ciphertext[i] = block_buffer; // printf("%c",ciphertext[i]); } // Deinit the encryption thread, and unload the module mcrypt_generic_end(td); return 0; }
main() { MCRYPT td; int i; char *key; char password[20]; char block_buffer; char *IV; int keysize=19; /* 128 bits */ key=calloc(1, keysize); strcpy(password, "A_large_key"); /* Generate the key using the password */ /* mhash_keygen( KEYGEN_MCRYPT, MHASH_MD5, key, keysize, NULL, 0, password, strlen(password)); */ memmove( key, password, strlen(password)); td = mcrypt_module_open("twofish", NULL, "cfb", NULL); if (td==MCRYPT_FAILED) { return 1; } IV = malloc(mcrypt_enc_get_iv_size(td)); /* Put random data in IV. Note these are not real random data, * consider using /dev/random or /dev/urandom. */ /* srand(time(0)); */ for (i=0; i< mcrypt_enc_get_iv_size( td); i++) { IV[i]=rand(); } i=mcrypt_generic_init( td, key, keysize, IV); if (i<0) { mcrypt_perror(i); return 1; } /* Encryption in CFB is performed in bytes */ while ( fread (&block_buffer, 1, 1, stdin) == 1 ) { mcrypt_generic (td, &block_buffer, 1); /* Comment above and uncomment this to decrypt */ /* mdecrypt_generic (td, &block_buffer, 1); */ fwrite ( &block_buffer, 1, 1, stdout); } mcrypt_generic_deinit(td); mcrypt_module_close(td); return 0; }
int dencrypt(char *password, char *ciphertext, char *plaintext) { MCRYPT td; int i; char *key; char block_buffer; char *IV; char *salt; td = mcrypt_module_open(algorithm, NULL, mode, NULL); if (td==MCRYPT_FAILED) { return 1; } salt = crypt_malloc(saltsize); IV = crypt_malloc(ivsize); read_meg(ciphertext, salt, IV); i=mcrypt_generic_init( td, key, keysize, IV); if (i<0) { mcrypt_perror(i); return 1; } // printf("%d",strlen(plaintext)); for(i=saltsize + ivsize; i<=strlen(ciphertext); i++) { // printf("%c",plaintext[i]); block_buffer=ciphertext[i]; //Here begin to decrypt mdecrypt_generic (td, &block_buffer, 1); plaintext[i]=block_buffer; // printf("%c",ciphertext[i]); } mcrypt_generic_end(td); return 0; }
void dump_testcase_block(MCRYPT td, unsigned char *key, int key_size, unsigned char *iv, int iv_size, int data_size, padding_t padding) { int mc_ret; int is_block, block_size, block_overlap, block_fill; int i; unsigned char *plaintext, *ciphertext; mc_ret = mcrypt_generic_init(td, (void *)key, key_size, (void *)iv); if (mc_ret < 0) { mcrypt_perror(mc_ret); return; } plaintext = gen_rand_data(data_size); if (plaintext == NULL) { return; } is_block = mcrypt_enc_is_block_mode(td); if (is_block) { block_size = mcrypt_enc_get_block_size(td); block_overlap = data_size % block_size; block_fill = block_size - block_overlap; if (padding == PADDING_NONE) { /* do nothing */ } else if (padding == PADDING_PKCS7) { if (block_fill == 0) { /* ALWAYS add padding */ block_fill = block_size; } plaintext = (unsigned char *)realloc(plaintext, data_size + block_fill); for (i = 0; i < block_fill; i++) { plaintext[data_size+i] = block_fill; } data_size = data_size + block_fill; if ((data_size % block_size) != 0) { fprintf(stderr, "bad data size!\n"); exit(1); } } else if (padding == PADDING_ZEROS) { if (block_overlap != 0) { plaintext = (unsigned char *)realloc(plaintext, data_size + block_fill); for (i = 0; i < block_fill; i++) { plaintext[data_size+i] = '\0'; } data_size = data_size + block_fill; } } else { fprintf(stderr, "bad error\n"); exit(1); } } ciphertext = malloc(data_size); if (ciphertext == NULL) { fprintf(stderr, "Out of memory\n"); return; } memcpy( (void *)ciphertext, (void *)plaintext, data_size); mc_ret = mcrypt_generic(td, ciphertext, data_size); if (mc_ret == 0) { char *enc_key, *enc_iv, *enc_pt, *enc_ct; enc_key = dump_value( (void *)key, key_size ); enc_iv = dump_value( (void *)iv, iv_size ); enc_pt = dump_value( (void *)plaintext, data_size ); enc_ct = dump_value( (void *)ciphertext, data_size ); printf("algo=%s,mode=%s,key=%s,iv=%s,padding=%s,pt=%s,ct=%s\n", testing_algo, testing_mode, enc_key, enc_iv, padding_name(padding), enc_pt, enc_ct); free(enc_key); free(enc_iv); free(enc_pt); free(enc_ct); } free(plaintext); free(ciphertext); mc_ret = mcrypt_generic_deinit(td); if (mc_ret < 0) { fprintf(stderr, "Error %d during deinit of %s in %s mode" " (%d-byte key)\n", testing_algo, testing_mode, key_size); return; } }