memcpy: Segfault after second call - c

Question

I am writing a wrapper for Karl Malbrain's AES implementation to work with input files bigger then 16 bytes.
Therefore, I wrote a functions aes_encrypt_block which would split the input buffer (message) into blocks of 16 bytes (chunk / chunk_cipher), calls the encryption/decryption functions and put the encrypted/decrypted 16 bytes back into the result buffer.
This works. However, I need to pad the message before encrypting it. So, the last 16 bytes I encrypt (outside the for-loop) are the padding bytes. When copying these bytes to the output buffer (cipher) I get a segfault. I can't really see what is going wrong.
Do you see the mistake?
Regards
#include "aes.h"
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#define DEBUG 1
void aes_encrypt_block(uint8_t **message, uint8_t **cipher, uint8_t blocks, uint8_t pad_bytes);
void aes_decrypt_block(uint8_t **msg_decrypted, uint8_t **cipher, uint8_t blocks, uint8_t pad_bytes);
unsigned long readFile(char *fileName, uint8_t **buffer);
//unsigned long readFile1(char *fileName, uint8_t *buffer);
uint8_t secret[16] = {0x44, 0x43, 0x45, 0x33, 0x44, 0x03, 0x34, 0x44, 0x43, 0x45, 0x33, 0x44, 0x03, 0x34, 0x03, 0x34};
uint8_t *chunk = NULL;
uint8_t *chunk_cipher = NULL;
uint8_t expanded[176] = {0x00};
uint8_t *buffer = NULL;
uint8_t *cipher = NULL;
uint8_t *msg_decrypted = NULL;
uint8_t mode = -1;
int main(int argc, char *argv[]) {
uint32_t i = 0;
uint8_t blocks = -1, pad_bytes = -1;
unsigned long fileLen;
char* ch = NULL;
if(argc<3) {
printf("Wrong arguments supplied.\n\n%s {0/1} OUT\n\n\t0 - encrypt\n\t1 - decrypt\n\tOUT - file to read from / to write to.\n\n", argv[0]);
return 0;
} else {
mode = atoi(argv[1]);
if(mode<0 || mode>1) {
printf("Wrong arguments supplied.\n\n%s {0/1} OUT\n\n\t0 - encrypt\n\t1 - decrypt\n\tOUT - file to read from / to write to.\n\n", argv[0]);
return 0;
}
}
puts("");
// Read file
fileLen = readFile(argv[2], &buffer);
// Setting up parameters and memory
if(fileLen%16!=0) {
printf("- ");
blocks = fileLen/16+1;
pad_bytes = (blocks*16)-fileLen;
} else {
printf("+ ");
blocks = fileLen/16+1;
pad_bytes = 16;
}
cipher = malloc((blocks*16)*sizeof(int));
if(cipher==NULL) printf("malloc() error!\n");
aes_expand_key(secret, expanded);
if(DEBUG) printf("size: %u, size/16: %d, blocks: %d, padding: %d\n\n", fileLen, fileLen/16, blocks, pad_bytes);
if(!mode) { // We will encrypt
aes_encrypt_block(&buffer, &cipher, blocks, pad_bytes);
free(buffer);
FILE *file_enc;
file_enc = fopen("bla.enc", "wb");
fileLen = fwrite(&cipher, sizeof(uint8_t), 32, file_enc);
printf("\nWrote %ld bytes to %s\n", fileLen, argv[2]);
fclose(file_enc);
} else { // We will decrypt
msg_decrypted = malloc((16*blocks)*sizeof(uint8_t));
// Decrypting blocks
aes_decrypt_block(msg_decrypted, cipher, blocks, pad_bytes);
puts("\nDecrypted message:");
printf("%s\n", msg_decrypted);
puts("");
free(msg_decrypted);
}
return 0;
}
unsigned long readFile(char *fileName, uint8_t **buffer) {
unsigned long fileLen = 0;
uint8_t i;
char* ch = NULL;
FILE *file;
file = fopen (fileName, "rb"); /* open the file for reading */
if(file==NULL) {
perror(fileName);
return 0;
}
fseek(file, 0, SEEK_END);
fileLen=ftell(file);
fseek(file, 0, SEEK_SET);
*buffer=malloc(fileLen+1);
if (!buffer) {
fprintf(stderr, "Memory error!");
fclose(file);
return;
}
fread(*buffer, 1, fileLen, file);
printf( "Source message in hex(%s, %ld bytes):\n", fileName, fileLen );
for (ch = *buffer ; ch < *buffer + fileLen; ++ch) {
printf( "%02X", *ch );
}
puts("\nASCII:\n---------");
for (ch = *buffer ; ch < *buffer + fileLen; ++ch) {
printf( "%c", *ch );
}
puts("");
fclose(file);
return fileLen;
}
void aes_encrypt_block(uint8_t **message, uint8_t **cipher, uint8_t blocks, uint8_t pad_bytes) {
uint8_t i;
chunk = malloc(16*sizeof(uint8_t));
if(chunk==NULL) printf("malloc() error!\n");
chunk_cipher = malloc(16*sizeof(uint8_t));
if(chunk_cipher == NULL) printf("malloc() error!\n");
for(i=0; i<(blocks-1); i++) {
memcpy(chunk, message[i*16], 16*sizeof(uint8_t));
aes_encrypt(chunk, expanded, chunk_cipher);
memcpy(cipher[i*16], chunk_cipher, 16*sizeof(uint8_t));
}
// Padding
memcpy(chunk, message[(blocks-1)*16], (16-pad_bytes)*sizeof(uint8_t));
uint8_t j;
for(j=0; j<=pad_bytes; j++) {
chunk[15-j] = pad_bytes;
}
aes_encrypt(chunk, expanded, chunk_cipher);
memcpy(cipher[i*16], chunk, 16*sizeof(uint8_t));
}
EDIT:
Valgrind output (line 149 in test.c corresponds to: memcpy(cipher[i*16], chunk, 16*sizeof(uint8_t));)
Valgrind outputs:
InvalidWrite: Invalid write of size 4
Call stack:
/usr/lib/valgrind/vgpreload_memcheck-x86-linux.so 0x402E08A: memcpy
/home/dev/aes/test.c|149|0x804A604: aes_encrypt_block
/home/dev/aes/test.c|59|0x8049AFE: main
Address 0x0 is not stack'd, malloc'd or (recently) free'd
Valgrind found 1 errors!

Answer 1

If pad_bytes == 16 then this loop:
for(j=0; j<=pad_bytes; j++) {
chunk[15-j] = pad_bytes;
}
will write into an invalid location before the start of chunk, possibly corrupting your heap.
It should probably be:
for(j=0; j<pad_bytes; j++) {
chunk[15-j] = pad_bytes;
}
Note also that you also appear to have a number of memory leaks where memory allocated via malloc is not beeing freed, e.g. chunk and chunk_cipher in aes_encrypt_block().

Answer 2

I'd say this line
memcpy(cipher[i*16], chunk_cipher, 16*sizeof(uint8_t));
should be
memcpy((*cipher) + i*16, chunk_cipher, 16*sizeof(uint8_t));
(for the 2nd second call of memcpy() apply same to 1st argument)
Or even better change the signature of aes_encrypt_block() from
void aes_encrypt_block(uint8_t **message, uint8_t **cipher, uint8_t blocks, uint8_t pad_bytes)
to
void aes_encrypt_block(uint8_t **message, uint8_t (*cipher)[16], uint8_t blocks, uint8_t pad_bytes)
and do
memcpy(cipher + i, chunk_cipher, sizeof(*cipher));
(for the 2nd second call of memcpy() apply same to 1st argument)