Data encryption/decryption with openssl

Question

I want to encrypt/decrypt data with AES 128 using openssl.

void main(void)
{
    unsigned char key[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,  0x0b, 0x0c, 0x0d, 0x0e, 0x0f};
    AES_KEY enc_key, dec_Key;
    unsigned char text = "Data encryption/ecryption with openssl";
    unsigned char encrtext[64], decrptext[64];

    AES_set_encrypt_key(key, 128, &enc_Key);
    AES_encrypt(text, encrtext, &enc_Key); 

    AES_set_decrypt_key(key,128,&dec_key);
    AES_decrypt(encrtext, decrptext, &dec_Key);

    printf("Data = %s",decrptext);
}

The execution of this program gives

Data = Data encryption/

I see that only 16 characters were encrypted and decrypted.

possible duplicate of [How to do encryption using AES in Openssl](http://stackoverflow.com/questions/9889492/how-to-do-encryption-using-aes-in-openssl) — jww, Feb 28 '14 at 18:07
You should *not* use `AES_encrypt` and friends. You should be using `EVP_*` functions. See [EVP Symmetric Encryption and Decryption](https://wiki.openssl.org/index.php/EVP_Symmetric_Encryption_and_Decryption) on the OpenSSL wiki. In fact, you should probably be using authenticated encryption because it provides *both* confidentiality and authenticity. See [EVP Authenticated Encryption and Decryption](https://wiki.openssl.org/index.php/EVP_Authenticated_Encryption_and_Decryption) on the OpenSSL wiki. — jww, May 15 '15 at 20:48

WhozCraig · Accepted Answer · 2014-02-28T15:45:26.510

OpenSSL supports single-shot encryption provided you set a valid key, feed a proper IV, and invoke the appropriate functions (one of which may seem odd, calling the encrypt function to decrypt, but in reality it is a symmetric algorithm so don't be shocked by that):

Example below. Note the encrypted block is padded properly before the final block is encrypted, and the padding is tossed out during decryption (which is what you want):

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h
#include <openssl/aes.h>
#include <openssl/rand.h>

/* a simple hex-print routine. could be modified to print 16 bytes-per-line */
static void hex_print(const void* pv, size_t len)
{
    const unsigned char * p = (const unsigned char*)pv;
    if (NULL == pv)
        printf("NULL");
    else
    {
        size_t i = 0;
        for (; i<len;++i)
            printf("%02X ", *p++);
    }
    printf("\n");
}

/* main entrypoint */
int main(int argc, char **argv)
{
    int keylength;
    printf("Give a key length [only 128 or 192 or 256!]: ");
    scanf("%d", &keylength);

    /* generate a key with a given length */
    unsigned char aes_key[keylength/8];
    if (!RAND_bytes(aes_key, keylength/8))
        exit(-1);

    size_t inputslength = 0;
    printf("Give an input's length:\n");
    scanf("%lu", &inputslength);

    /* generate input with a given length */
    unsigned char aes_input[inputslength];
    memset(aes_input, 'X', inputslength);

    /* init vector */
    unsigned char iv_enc[AES_BLOCK_SIZE], iv_dec[AES_BLOCK_SIZE];
    RAND_bytes(iv_enc, AES_BLOCK_SIZE);
    memcpy(iv_dec, iv_enc, AES_BLOCK_SIZE);

    /* buffers for encryption and decryption */
    const size_t encslength = ((inputslength + AES_BLOCK_SIZE) / AES_BLOCK_SIZE) * AES_BLOCK_SIZE;
    unsigned char enc_out[encslength];
    unsigned char dec_out[inputslength];
    memset(enc_out, 0, sizeof(enc_out));
    memset(dec_out, 0, sizeof(dec_out));

    /* initialize encryption key, encrypt */
    AES_KEY enc_key, dec_key;
    AES_set_encrypt_key(aes_key, keylength, &enc_key);
    AES_cbc_encrypt(aes_input, enc_out, inputslength, &enc_key, iv_enc, AES_ENCRYPT);

    /* same key and if for decrypt */
    AES_set_decrypt_key(aes_key, keylength, &dec_key);
    AES_cbc_encrypt(enc_out, dec_out, encslength, &dec_key, iv_dec, AES_DECRYPT);

    printf("original:\n");
    hex_print(aes_input, sizeof(aes_input));

    printf("encrypt:\n");
    hex_print(enc_out, sizeof(enc_out));

    printf("decrypt:\n");
    hex_print(dec_out, sizeof(dec_out));

    return 0;
}

Output (obviously your's will vary)

Give a key length [only 128 or 192 or 256!]: 192
Give an input's length:
27
original:
58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 
encrypt:
5F F1 57 AA 3C BC C3 10 49 34 E7 E8 CB 6D 4D B0 AE BB 14 04 C0 26 D6 B7 A4 69 0B 3F 92 84 97 A0 
decrypt:
58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 
Program ended with exit code: 0

score 0 · Answer 2 · answered Feb 28 '14 at 10:14

0

That's expected, AES is a block cipher with a block size of 128 bits, i.e. 16 bytes.

You need to manually feed all blocks of input through the encryption function.

answered Feb 28 '14 at 10:14

unwind

391,730
64
469
606

Should I divide input data to blocks of 16 bytes and then encrypt/decrypt it block by block ? Is there any way to do that with openssl library ? – ARM Feb 28 '14 at 10:16

Data encryption/decryption with openssl

2 Answers2