Specify input string length in AES_encrypt function while decryption

Question

I tried to execute the answer given in the following question - AES (aes-cbc-128, aes-cbc-192, aes-cbc-256) encryption/decryption with openssl C

I might as well post the code here -

#include <stdio.h>
#include <stdlib.h>
#include <string.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!]:\n");
    scanf("%d", &keylength);

    /* generate a key with a given length */
    unsigned char aes_key[keylength/8];
    memset(aes_key, 0, 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));

    // so i can do with this aes-cbc-128 aes-cbc-192 aes-cbc-256
    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);

    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:\t");
    hex_print(aes_input, sizeof(aes_input));

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

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

    return 0;
}

This runs fine but I wanted to encrypt a string once and then decrypt it later, so I won't have the inputslength at hand. Because of this, I won't be able to calculate encslength.

How do I get encslength without knowing the actual string which was encrypted.

encslength is just the length of your encrypted string. There is a computation to get the length after encryption which is a modulo of AES_BLOCK_SIZE because inputslength might need padding. — n0p
You should not use AES_encrypt and friends. You should be using EVP_* functions. See 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 on the OpenSSL wiki. — jww

n0p n0p · Accepted Answer · 2014-07-28T12:31:43

As there is not much activity I'll turn my comment into an answer: You don't need to "compute" encslength: it is the length of the encrypted string you got. If you store your string for later decryption you know its size.

The computation is only needed when you encrypt and must prepare an output buffer: the AES handles blocks with predefined size: if the length of your input string is not a multiple of AES_BLOCK_SIZE, your input will be padded (and you will get a larger output). Anyway, you obtain an output string which must have a size which is a multiple of AES_BLOCK_SIZE. This string will be decrypted into a string with a length that should be smaller or equal to your encrypted message.

Specify input string length in AES_encrypt function while decryption

1 Answers