Generate encrypted data with size not multiple of 16

Question

I want to develop functions for encrypt and decrypt. the key size should be at least 128 bits (16 bytes).

I used the AES* api functions from the OpenSSL. but there is some restriction in the AES* functions: the input data buffers should be multiple of 16!

Here after my functions:

unsigned char encrypt_aes_key[]={0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,0x99,0xAA,0xBB,0xCC,0xDD,0xEE,0xFF};

static inline int enc_array_decrypt(unsigned char *encarray, unsigned char *decarray, int size)
{
    int i;
    AES_KEY dec_key;
    unsigned char apibuf[512] = {0};
    unsigned char iv[AES_BLOCK_SIZE];
    memset(iv, 0x00, AES_BLOCK_SIZE);

    AES_set_decrypt_key(encrypt_aes_key, sizeof(encrypt_aes_key)*8, &dec_key); // Size of key is in bits
    AES_cbc_encrypt(encarray, apibuf, size, &dec_key, iv, AES_DECRYPT);
    memcpy(decarray, apibuf, size);

    return 0;
}

static inline int enc_array_encrypt(unsigned char *array, unsigned char *encarray, int size)
{
    int i;
    AES_KEY enc_key;
    unsigned char apibuf[512] = {0};
    unsigned char iv[AES_BLOCK_SIZE];
    memset(iv, 0x00, AES_BLOCK_SIZE);

    AES_set_encrypt_key(encrypt_aes_key, sizeof(encrypt_aes_key)*8, &enc_key); // Size of key is in bits
    AES_cbc_encrypt((unsigned char *)array, apibuf, size, &enc_key, iv, AES_ENCRYPT);
    memcpy(encarray, apibuf, size);

    return 0;
}

if I call my functions with buffer size 9 for example, the functions will return wron output

example:

int main(int argc, char *argv[] )
{
    char buf[9] = {0}, encbuf[9] = {0}, decbuf[9] = {0};
    strcpy(buf, argv[1]);

    enc_array_encrypt(buf, encbuf, 9);
    enc_array_decrypt(encbuf, decbuf, 9);

    printf("%s  \n%s\n", buf, decbuf);

    return 0;
}

The program returns:

$ ./myprogram any
any  
2�����S�

How I can fix that?

by the way I can not force the buffer to be 16x multiplier size. because I will integrate my functions in a big source code (SDK) in which I will call my functions in many places with different input buffer sizes.

I m open to use any other kind of encryption (other than AES), but should support key of 128 bits length. The input buffer and the encrypted buffer should have the same size

Answer 1

It's generally not recommended to use the AES* function directly in OpenSSL. It's better to use the EVP family of functions. These will allow you to give an input buffer of any length.

void log_ssl_err(const char *mes)
{
    unsigned long err;
    char errstr[1000];

    while ((err = ERR_get_error())) {
        ERR_error_string(err, errstr);
        printf("%s: %s", mes, errstr);
    }
}

int encrypt_block(const unsigned char *IV, const unsigned char *key,
                  const unsigned char *src, unsigned int srclen,
                  unsigned char *dest, unsigned int *destlen)
{
    EVP_CIPHER_CTX ctx;
    const EVP_CIPHER *cipher = EVP_get_cipherbyname("AES-256-CBC");
    int mode, len;

    if (cipher == NULL) {
        printf("Invalid keytype");
        return 0;
    }
    mode = EVP_CIPHER_mode(cipher);
    EVP_CIPHER_CTX_init(&ctx);
    if (!EVP_EncryptInit_ex(&ctx, cipher, NULL, NULL, NULL)) {
        log_ssl_err("EncryptInit for cipher failed");
        return 0;
    }
    if (!EVP_EncryptInit_ex(&ctx, NULL, NULL, key, IV)) {
        log_ssl_err("EncryptInit for key/IV failed");
        return 0;
    }
    len = 0;
    if (!EVP_EncryptUpdate(&ctx, dest, &len, src, srclen)) {
        log_ssl_err("EncryptUpdate for data failed");
        EVP_CIPHER_CTX_cleanup(&ctx);
        return 0;
    }
    *destlen = len;
    if (!EVP_EncryptFinal_ex(&ctx, dest + *destlen, &len)) {
        log_ssl_err("EncryptFinal failed");
        EVP_CIPHER_CTX_cleanup(&ctx);
        return 0;
    }
    *destlen += len;
    EVP_CIPHER_CTX_cleanup(&ctx);

    return 1;
}

int decrypt_block(const unsigned char *IV, const unsigned char *key,
                  unsigned char *src, unsigned int srclen,
                  unsigned char *dest, unsigned int *destlen)
{
    EVP_CIPHER_CTX ctx;
    const EVP_CIPHER *cipher = EVP_get_cipherbyname("AES-256-CBC");
    int mode, len;

    if (cipher == NULL) {
        printf("Invalid keytype");
        return 0;
    }
    mode = EVP_CIPHER_mode(cipher);
    EVP_CIPHER_CTX_init(&ctx);
    if (!EVP_DecryptInit_ex(&ctx, cipher, NULL, NULL, NULL)) {
        log_ssl_err("DecryptInit for cipher failed");
        return 0;
    }
    if (!EVP_DecryptUpdate(&ctx, dest, &len, src, srclen)) {
        log_ssl_err("DecryptUpdate for data failed");
        EVP_CIPHER_CTX_cleanup(&ctx);
        return 0;
    }
    *destlen = len;
    if (!EVP_DecryptFinal_ex(&ctx, dest + *destlen, &len)) {
        log_ssl_err("DecryptFinal failed");
        EVP_CIPHER_CTX_cleanup(&ctx);
        return 0;
    }
    *destlen += len;
    EVP_CIPHER_CTX_cleanup(&ctx);

    return 1;
}