Question

I’m new here so please excuse if I’m doing something wrong.

I attempt to make an array with encrypted strings, I’m using the EVP API for the encryption. This works fine, but wHen I try to use the encrypt function in a foor loop the console gives me nothing.

Here is my encrypt function:

char *encrypt(char *key, char *iv, char * source){

    //char *target;
    int in_len, out_len;
    EVP_CIPHER_CTX ctx;
    in_len=strlen((const char *)source);
    unsigned char *target = (unsigned char *) malloc(in_len);
        //printf("This is the text before ciphering: %s\n",source);
        //printf("The length of the string is: %d\n",in_len);
        //starting the encryption process
        EVP_CIPHER_CTX_init(&ctx);
        EVP_EncryptInit_ex(&ctx,EVP_aes_128_cbc(),NULL,(unsigned char*) key,(unsigned char*)iv);
        EVP_EncryptUpdate(&ctx,target,&out_len,(unsigned char*)source,in_len);
        EVP_EncryptFinal_ex(&ctx,target,&out_len);
        target[out_len] = '\0';

        //EVP_CIPHER_CTX_cleanup(&ctx);


        return ((char *)target);
}

and in main the loop:

int main(){
    char source[17]="Shahababamamaaaa";
    char key[17]="ahardtobreakkey1";
    char iv[17] = "veryinterestingv";
     int rows = 1280;
     int cols = (3*800)/16;
        char *encrypted=encrypt(key, iv, source);
        printf("encrypted: %s\n", encrypted);
        char *encrypted2;
        encrypted2=encrypt(key, iv, encrypted);
        printf("encrypted2: %s\n", encrypted2);
        char *mx[rows];
        char *in, *temp;
        in = (char *) malloc ( cols * sizeof(char) );
        temp =(char *) malloc ( strlen(encrypted) );
        int i, j;

        for (i=0; i<5; i++){
            strcpy(in,encrypted);
            for(j=0;j<3;j++){
                    printf("in: %s\n", in);
                    strcpy(temp, encrypted2);
                    printf("temp: %s\n", temp);
                    memset(encrypted2,0x00, strlen(encrypted));
                    encrypted2=encrypt(key, iv,temp);
                    printf("encrypted2 nach j=%d : %s\n",j, encrypted2);

                    mx[i]=in;
            }

        }
        printf("Stele 0 Inhalt %s\n",mx[0]);
        printf("Laenge von 1 %d\n", strlen(mx[0]));

        //system ("PAUSE");
        free(in);
        return 0;

     }

What am I missing? Is it imposible to use encrypt2 again?
Thank you very much.

Answer 1

As you said, the main problem is in your encrypt() function, but also how you call it. You are using malloc() to allocate memory inside your function, and never freeing it, which is a memory leak (and malloc is a no-no in c++ anyway). You are also not running the cleanup function for your ctx. And your encrypt_final is overwriting the first part of your output buffer. So, here’s a cleaned up encrypt(), and a matching decrypt():

int encrypt(unsigned char *key, 
        unsigned char *iv, 
        unsigned char * source, 
        unsigned char* target, 
        int in_len) // Need an in length.  Not all input is going to be
                    // zero-terminated, for example if we're reading from a file

{

    int out_len; // Return the output length.  Because it also won't be null
                 // terminated, and may contain null characters inline

    int final_out_len; // So that we don't overwrite out_len with the final call
    EVP_CIPHER_CTX ctx;

    EVP_CIPHER_CTX_init(&ctx);
    EVP_EncryptInit_ex(&ctx,EVP_aes_128_cbc(),NULL,key,iv);
    EVP_EncryptUpdate(&ctx,target,&out_len,source,in_len);
    EVP_EncryptFinal_ex(&ctx,target+out_len,&final_out_len);
    EVP_CIPHER_CTX_cleanup(&ctx);
    return out_len+final_out_len; // need to sum these together, because both
                                  // encrypt calls wrote data
}

And to decrypt:

int decrypt(unsigned char *key, 
        unsigned char *iv, 
        unsigned char * source, 
        unsigned char* target, 
        int in_len)
{

    int out_len=0,final_out_len=0;
    EVP_CIPHER_CTX ctx;
    EVP_CIPHER_CTX_init(&ctx);
    EVP_DecryptInit_ex(&ctx,EVP_aes_128_cbc(),NULL,key,iv);
    EVP_DecryptUpdate(&ctx,target,&out_len,source,in_len);
    EVP_DecryptFinal_ex(&ctx,target+out_len,&final_out_len);
    EVP_CIPHER_CTX_cleanup(&ctx);
    //Just to be nice, we'll add a zero at the end of the decrypted string
    target[out_len+final_out_len] = 0;
    return out_len+final_out_len;
}

Pulling it all together (in a loop, to prove your concept):

int _tmain(int argc, _TCHAR* argv[])
{
    unsigned char key[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
    unsigned char ivec[] = {1,2,3,4,5,6,7,8};
    char *raw_buffer = "This is a test string";
    int raw_count = strlen(raw_buffer);
    for (int i=0; i<5; i++){
        unsigned char *decrypted_buffer = new unsigned char[raw_count+64];
        unsigned char *encrypted_buffer = new unsigned char[raw_count+64];
        int final_len = encrypt(key,ivec,(unsigned char*)raw_buffer,(unsigned char*)encrypted_buffer,raw_count);
        int dec_len = decrypt(key,ivec,(unsigned char*)encrypted_buffer,(unsigned char*)decrypted_buffer,final_len);
        printf("raw_count: %i\nfinal_len: %i\ndec_len: %i\n",raw_count,final_len,dec_len);
        printf("Original str: \n%s\n",raw_buffer);
        printf("Encrypted: \n%s\n", encrypted_buffer);
        printf("Decrypted:\n%s\n\n\n", decrypted_buffer);
        delete[] decrypted_buffer;
        delete[] encrypted_buffer;
    }
    char c;
    c=getchar();
    return 0;
}