aes.c File Reference

#include <crypto/skcipher.h>
#include <linux/crypto.h>
#include <linux/err.h>
#include <linux/scatterlist.h>
#include <linux/slab.h>
#include "config.h"
#include "crypto.h"
#include "io.h"

Include dependency graph for aes.c:

Go to the source code of this file.

Macros
#define	_(a, b)   ((a) ^ (b))

Functions
static char *	get_key (void)
static char *	get_iv (void)
static int	_load_eas_constants (void)
	Load AES key and IV constants.
static int	add_pkcs7_padding (const char *in, size_t in_len, char **out, size_t *out_len)
	Add PKCS#7 padding to a buffer.
static int	remove_pkcs7_padding (const char *in, size_t in_len, char **out, size_t *out_len)
	Remove PKCS#7 padding from a buffer.
static int	_crypt_buffer (bool encrypt, const char *in, size_t in_len, char **out, size_t *out_len)
	Encrypts or decrypts a buffer using AES-128 in CBC mode.
int	encrypt_buffer (const char *in, size_t in_len, char **out, size_t *out_len)
	Encrypts a buffer using AES-128 in CBC mode.
int	decrypt_buffer (const char *in, size_t in_len, char **out, size_t *out_len)
	Decrypts a buffer using AES-128 in CBC mode.

Variables
static char *	AES_KEY = NULL
static char *	AES_IV = NULL

Macro Definition Documentation

_

#define _	(		a,
			b
	)		((a) ^ (b))

Definition at line 14 of file aes.c.

Function Documentation

_crypt_buffer()

static int _crypt_buffer ( bool  encrypt, const char *  in, size_t  in_len, char **  out, size_t *  out_len  )

static

Encrypts or decrypts a buffer using AES-128 in CBC mode.

Parameters

encrypt	True for encryption, false for decryption.
in	Input buffer to encrypt/decrypt.
in_len	Length of the input buffer.
out	Pointer to the output buffer (allocated within the function).
out_len	Pointer to the length of the output buffer.

Returns

0 on success, negative error code on failure.

Definition at line 186 of file aes.c.

                                                      {
    struct crypto_skcipher *tfm;  // Cipher transformation handle
    struct skcipher_request *req; // Cipher request handle
    struct scatterlist sg;        // Scatterlist for input/output data
    char *buf = NULL;             // Buffer to hold input data (padded if necessary)
    char *padded_in = NULL;       // Buffer for padded input (for encryption)
    size_t padded_len = 0;        // Length of padded input
    int ret = 0;                  // Return value
    char iv[AES_BLOCK_SIZE];      // Initialization vector
 
    // Load AES key and IV if not already loaded
    if (!AES_KEY || !AES_IV) {
        ret = _load_eas_constants();
        if (ret != 0) {
            ERR_MSG("Failed to load AES constants: %d\n", ret);
            return ret;
        }
    }
 
    if (!in || !out || !out_len)
        return -EINVAL;
 
    // Initialize output parameters
    *out = NULL;
    *out_len = 0;
 
    memcpy(iv, AES_IV, AES_BLOCK_SIZE); // Copy IV
 
    if (encrypt) {
        // Add PKCS#7 padding for encryption
        ret = add_pkcs7_padding(in, in_len, &padded_in, &padded_len);
        if (ret != 0)
            return ret;
    }
    else {
        // For decryption, input must be a multiple of block size
        if (in_len % AES_BLOCK_SIZE != 0) {
            ERR_MSG("Decrypt input length must be a multiple of %d\n",
                    AES_BLOCK_SIZE);
            return -EINVAL;
        }
        padded_in = vmalloc(in_len);
        if (!padded_in)
            return -ENOMEM;
        memcpy(padded_in, in, in_len);
        padded_len = in_len;
    }
 
    // Allocate buffer for results
    buf = vmalloc(padded_len);
    if (!buf) {
        vfree(padded_in);
        return -ENOMEM;
    }
 
    // Allocate cipher transformation for AES in CBC mode
    tfm = crypto_alloc_skcipher("cbc(aes)", 0, 0);
    if (IS_ERR(tfm)) {
        ret = PTR_ERR(tfm);
        goto out_free_buffers;
    }
 
    // Allocate cipher request
    req = skcipher_request_alloc(tfm, GFP_KERNEL);
    if (!req) {
        ret = -ENOMEM;
        goto out_free_tfm;
    }
 
    // Set the encryption key
    ret = crypto_skcipher_setkey(tfm, AES_KEY, 16);
    if (ret != 0) {
        pr_err("setkey failed: %d\n", ret);
        goto out_free_req;
    }
 
    // Initialize scatterlist with input and output buffers
    sg_init_one(&sg, padded_in, padded_len);
    skcipher_request_set_crypt(req, &sg, &sg, padded_len, iv);
 
    // Perform encryption or decryption
    if (encrypt)
        ret = crypto_skcipher_encrypt(req);
    else
        ret = crypto_skcipher_decrypt(req);
 
    if (ret) {
        ERR_MSG("%s failed: %d\n", encrypt ? "encrypt" : "decrypt", ret);
        goto out_free_req;
    }
 
    // Copy result
    memcpy(buf, sg_virt(&sg), padded_len);
 
    if (!encrypt) {
        // Remove padding after decryption
        char *unpadded_buf;
        size_t unpadded_len;
 
        ret = remove_pkcs7_padding(buf, padded_len, &unpadded_buf, &unpadded_len);
        if (ret != 0) {
            ERR_MSG("Failed to remove padding: %d\n", ret);
            goto out_free_req;
        }
 
        // Free the original buffer and replace with unpadded one
        vfree(buf);
        buf = unpadded_buf;
        padded_len = unpadded_len;
    }
 
    *out = buf;
    *out_len = padded_len;
    buf = NULL; // Prevent free on success path
 
out_free_req:
    skcipher_request_free(req);
out_free_tfm:
    crypto_free_skcipher(tfm);
out_free_buffers:
    vfree(padded_in);
    vfree(buf);
 
    return ret;
}

_load_eas_constants()

static int _load_eas_constants ( void  )

static

Load AES key and IV constants.

This function initializes the AES key and IV buffers. It retrieves the key and IV from the configuration or hardcoded values. Returns 0 on success, negative error code on failure.

Definition at line 69 of file aes.c.

                                     {
    // Load AES key
    AES_KEY = get_key();
    if (!AES_KEY) {
        ERR_MSG("Failed to load AES key\n");
        return -ENOMEM;
    }
 
    // Load AES IV
    AES_IV = get_iv();
    if (!AES_IV) {
        ERR_MSG("Failed to load AES IV\n");
        return -ENOMEM;
    }
 
    return 0;
}

add_pkcs7_padding()

static int add_pkcs7_padding ( const char *  in, size_t  in_len, char **  out, size_t *  out_len  )

static

Add PKCS#7 padding to a buffer.

Parameters

in	Input buffer
in_len	Length of input buffer
out	Output buffer (allocated within the function)
out_len	Length of output buffer

Returns

0 on success, negative error code on failure

Definition at line 96 of file aes.c.

                                              {
    size_t padding_len;
    size_t padded_len;
    char *padded_buf;
    int i;
 
    // Calculate padding length (1-16 bytes)
    padding_len = AES_BLOCK_SIZE - (in_len % AES_BLOCK_SIZE);
    padded_len = in_len + padding_len;
 
    // Allocate padded buffer
    padded_buf = vmalloc(padded_len);
    if (!padded_buf)
        return -ENOMEM;
 
    // Copy original data
    memcpy(padded_buf, in, in_len);
 
    // Add padding bytes
    for (i = 0; i < padding_len; i++) {
        padded_buf[in_len + i] = (char)padding_len;
    }
 
    *out = padded_buf;
    *out_len = padded_len;
 
    return 0;
}

decrypt_buffer()

int decrypt_buffer	(	const char *	in,
		size_t	in_len,
		char **	out,
		size_t *	out_len
	)

Decrypts a buffer using AES-128 in CBC mode.

Parameters

in	Input buffer to decrypt.
in_len	Length of the input buffer.
out	Pointer to the output buffer (allocated within the function).
out_len	Pointer to the length of the output buffer.

Returns

0 on success, negative error code on failure.

Definition at line 335 of file aes.c.

                                                                               {
    return _crypt_buffer(false, in, in_len, out, out_len);
}

encrypt_buffer()

int encrypt_buffer	(	const char *	in,
		size_t	in_len,
		char **	out,
		size_t *	out_len
	)

Encrypts a buffer using AES-128 in CBC mode.

Parameters

in	Input buffer to encrypt.
in_len	Length of the input buffer.
out	Pointer to the output buffer (allocated within the function).
out_len	Pointer to the length of the output buffer.

Returns

0 on success, negative error code on failure.

Definition at line 322 of file aes.c.

                                                                               {
    return _crypt_buffer(true, in, in_len, out, out_len);
}

get_iv()

static char * get_iv ( void  )

static

Definition at line 39 of file aes.c.

                          {
    static char iv[] = {
        _(0x03, 0x62), // 'a' = 0x61
        _(0x00, 0x62), // 'b' = 0x62
        _(0x02, 0x61), // 'c' = 0x63
        _(0x00, 0x64), // 'd' = 0x64
        _(0x00, 0x65), // 'e' = 0x65
        _(0x00, 0x66), // 'f' = 0x66
        _(0x10, 0x21), // '1' = 0x31
        _(0x13, 0x21), // '2' = 0x33
        _(0x13, 0x20), // '3' = 0x33
        _(0x14, 0x20), // '4' = 0x34
        _(0x15, 0x20), // '5' = 0x35
        _(0x16, 0x20), // '6' = 0x36
        _(0x17, 0x20), // '7' = 0x37
        _(0x18, 0x20), // '8' = 0x38
        _(0x19, 0x20), // '9' = 0x39
        0x30,          // '0'
        0
    };
    return iv;
}

get_key()

static char * get_key ( void  )

static

Definition at line 16 of file aes.c.

                           {
    static char key[] = {
        _(0x10, 0x21), // '1' = 0x31
        _(0x13, 0x21), // '2' = 0x33
        _(0x13, 0x20), // '3' = 0x33
        _(0x14, 0x20), // '4' = 0x34
        _(0x15, 0x20), // '5' = 0x35
        _(0x16, 0x20), // '6' = 0x36
        _(0x17, 0x20), // '7' = 0x37
        _(0x18, 0x20), // '8' = 0x38
        _(0x19, 0x20), // '9' = 0x39
        0x30,          // '0'
        _(0x03, 0x62), // 'a' = 0x61
        _(0x00, 0x62), // 'b' = 0x62
        _(0x02, 0x61), // 'c' = 0x63
        _(0x00, 0x64), // 'd' = 0x64
        _(0x00, 0x65), // 'e' = 0x65
        _(0x00, 0x66), // 'f' = 0x66
        0
    };
    return key;
}

remove_pkcs7_padding()

static int remove_pkcs7_padding ( const char *  in, size_t  in_len, char **  out, size_t *  out_len  )

static

Remove PKCS#7 padding from a buffer.

Parameters

in	Input buffer with padding
in_len	Length of input buffer
out	Output buffer (allocated within the function)
out_len	Length of output buffer

Returns

0 on success, negative error code on failure

Definition at line 135 of file aes.c.

                                                 {
    unsigned char padding_len;
    size_t data_len;
    char *unpadded_buf;
    int i;
 
    // Validate input length
    if (in_len == 0 || in_len % AES_BLOCK_SIZE != 0)
        return -EINVAL;
 
    // Get padding length from the last byte
    padding_len = (unsigned char)in[in_len - 1];
 
    // Validate padding length
    if (padding_len == 0 || padding_len > AES_BLOCK_SIZE || padding_len > in_len)
        return -EINVAL;
 
    // Verify all padding bytes are correct
    for (i = 0; i < padding_len; i++) {
        if ((unsigned char)in[in_len - 1 - i] != padding_len)
            return -EINVAL;
    }
 
    // Calculate data length
    data_len = in_len - padding_len;
 
    // Allocate unpadded buffer
    unpadded_buf = vmalloc(data_len);
    if (!unpadded_buf)
        return -ENOMEM;
 
    // Copy data without padding
    memcpy(unpadded_buf, in, data_len);
 
    *out = unpadded_buf;
    *out_len = data_len;
 
    return 0;
}

Variable Documentation

AES_IV

char* AES_IV = NULL

static

Definition at line 12 of file aes.c.

AES_KEY

char* AES_KEY = NULL

static

Definition at line 11 of file aes.c.