jeltz/hostap
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Remove unneeded aes_i.h inclusion from number of places

Browse source 
The BLOCK_SIZE define can be made more specific by using AES_ prefix and
by moving it to aes.h. After this, most aes-*.c do not really need to
include anything from the internal aes_i.h header file. In other words,
aes_i.h can now be used only for the code that uses the internal AES
block operation implementation and none of the code that can use AES
implementation from an external library do not need to include this
header file.
This commit is contained in:
Jouni Malinen 2009-08-17 20:27:25 +03:00
parent 04b6b3ed51
commit 1ba787b954
9 changed files with 43 additions and 41 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

28
src/crypto/aes-cbc.c
View file

@ -16,7 +16,7 @@
#include "includes.h"
#include "common.h"
#include "aes_i.h"
#include "aes.h"
/**
* aes_128_cbc_encrypt - AES-128 CBC encryption
@ -29,22 +29,22 @@
int aes_128_cbc_encrypt(const u8 *key, const u8 *iv, u8 *data, size_t data_len)
{
void *ctx;
u8 cbc[BLOCK_SIZE];
u8 cbc[AES_BLOCK_SIZE];
u8 *pos = data;
int i, j, blocks;
ctx = aes_encrypt_init(key, 16);
if (ctx == NULL)
return -1;
os_memcpy(cbc, iv, BLOCK_SIZE);
os_memcpy(cbc, iv, AES_BLOCK_SIZE);
blocks = data_len / BLOCK_SIZE;
blocks = data_len / AES_BLOCK_SIZE;
for (i = 0; i < blocks; i++) {
for (j = 0; j < BLOCK_SIZE; j++)
for (j = 0; j < AES_BLOCK_SIZE; j++)
cbc[j] ^= pos[j];
aes_encrypt(ctx, cbc, cbc);
os_memcpy(pos, cbc, BLOCK_SIZE);
pos += BLOCK_SIZE;
os_memcpy(pos, cbc, AES_BLOCK_SIZE);
pos += AES_BLOCK_SIZE;
}
aes_encrypt_deinit(ctx);
return 0;
@ -62,23 +62,23 @@ int aes_128_cbc_encrypt(const u8 *key, const u8 *iv, u8 *data, size_t data_len)
int aes_128_cbc_decrypt(const u8 *key, const u8 *iv, u8 *data, size_t data_len)
{
void *ctx;
u8 cbc[BLOCK_SIZE], tmp[BLOCK_SIZE];
u8 cbc[AES_BLOCK_SIZE], tmp[AES_BLOCK_SIZE];
u8 *pos = data;
int i, j, blocks;
ctx = aes_decrypt_init(key, 16);
if (ctx == NULL)
return -1;
os_memcpy(cbc, iv, BLOCK_SIZE);
os_memcpy(cbc, iv, AES_BLOCK_SIZE);
blocks = data_len / BLOCK_SIZE;
blocks = data_len / AES_BLOCK_SIZE;
for (i = 0; i < blocks; i++) {
os_memcpy(tmp, pos, BLOCK_SIZE);
os_memcpy(tmp, pos, AES_BLOCK_SIZE);
aes_decrypt(ctx, pos, pos);
for (j = 0; j < BLOCK_SIZE; j++)
for (j = 0; j < AES_BLOCK_SIZE; j++)
pos[j] ^= cbc[j];
os_memcpy(cbc, tmp, BLOCK_SIZE);
pos += BLOCK_SIZE;
os_memcpy(cbc, tmp, AES_BLOCK_SIZE);
pos += AES_BLOCK_SIZE;
}
aes_decrypt_deinit(ctx);
return 0;

10
src/crypto/aes-ctr.c
View file

@ -16,7 +16,7 @@
#include "includes.h"
#include "common.h"
#include "aes_i.h"
#include "aes.h"
/**
* aes_128_ctr_encrypt - AES-128 CTR mode encryption
@ -33,23 +33,23 @@ int aes_128_ctr_encrypt(const u8 *key, const u8 *nonce,
size_t j, len, left = data_len;
int i;
u8 *pos = data;
u8 counter[BLOCK_SIZE], buf[BLOCK_SIZE];
u8 counter[AES_BLOCK_SIZE], buf[AES_BLOCK_SIZE];
ctx = aes_encrypt_init(key, 16);
if (ctx == NULL)
return -1;
os_memcpy(counter, nonce, BLOCK_SIZE);
os_memcpy(counter, nonce, AES_BLOCK_SIZE);
while (left > 0) {
aes_encrypt(ctx, counter, buf);
len = (left < BLOCK_SIZE) ? left : BLOCK_SIZE;
len = (left < AES_BLOCK_SIZE) ? left : AES_BLOCK_SIZE;
for (j = 0; j < len; j++)
pos[j] ^= buf[j];
pos += len;
left -= len;
for (i = BLOCK_SIZE - 1; i >= 0; i--) {
for (i = AES_BLOCK_SIZE - 1; i >= 0; i--) {
counter[i]++;
if (counter[i])
break;

12
src/crypto/aes-eax.c
View file

@ -16,7 +16,7 @@
#include "includes.h"
#include "common.h"
#include "aes_i.h"
#include "aes.h"
#include "aes_wrap.h"
/**
@ -37,7 +37,8 @@ int aes_128_eax_encrypt(const u8 *key, const u8 *nonce, size_t nonce_len,
{
u8 *buf;
size_t buf_len;
u8 nonce_mac[BLOCK_SIZE], hdr_mac[BLOCK_SIZE], data_mac[BLOCK_SIZE];
u8 nonce_mac[AES_BLOCK_SIZE], hdr_mac[AES_BLOCK_SIZE],
data_mac[AES_BLOCK_SIZE];
int i, ret = -1;
if (nonce_len > data_len)
@ -71,7 +72,7 @@ int aes_128_eax_encrypt(const u8 *key, const u8 *nonce, size_t nonce_len,
if (omac1_aes_128(key, buf, 16 + data_len, data_mac))
goto fail;
for (i = 0; i < BLOCK_SIZE; i++)
for (i = 0; i < AES_BLOCK_SIZE; i++)
tag[i] = nonce_mac[i] ^ data_mac[i] ^ hdr_mac[i];
ret = 0;
@ -100,7 +101,8 @@ int aes_128_eax_decrypt(const u8 *key, const u8 *nonce, size_t nonce_len,
{
u8 *buf;
size_t buf_len;
u8 nonce_mac[BLOCK_SIZE], hdr_mac[BLOCK_SIZE], data_mac[BLOCK_SIZE];
u8 nonce_mac[AES_BLOCK_SIZE], hdr_mac[AES_BLOCK_SIZE],
data_mac[AES_BLOCK_SIZE];
int i;
if (nonce_len > data_len)
@ -140,7 +142,7 @@ int aes_128_eax_decrypt(const u8 *key, const u8 *nonce, size_t nonce_len,
os_free(buf);
for (i = 0; i < BLOCK_SIZE; i++) {
for (i = 0; i < AES_BLOCK_SIZE; i++) {
if (tag[i] != (nonce_mac[i] ^ data_mac[i] ^ hdr_mac[i]))
return -2;
}

2
src/crypto/aes-encblock.c
View file

@ -16,7 +16,7 @@
#include "includes.h"
#include "common.h"
#include "aes_i.h"
#include "aes.h"
/**
* aes_128_encrypt_block - Perform one AES 128-bit block operation

24
src/crypto/aes-omac1.c
View file

@ -16,18 +16,18 @@
#include "includes.h"
#include "common.h"
#include "aes_i.h"
#include "aes.h"
static void gf_mulx(u8 *pad)
{
int i, carry;
carry = pad[0] & 0x80;
for (i = 0; i < BLOCK_SIZE - 1; i++)
for (i = 0; i < AES_BLOCK_SIZE - 1; i++)
pad[i] = (pad[i] << 1) | (pad[i + 1] >> 7);
pad[BLOCK_SIZE - 1] <<= 1;
pad[AES_BLOCK_SIZE - 1] <<= 1;
if (carry)
pad[BLOCK_SIZE - 1] ^= 0x87;
pad[AES_BLOCK_SIZE - 1] ^= 0x87;
}
@ -48,14 +48,14 @@ int omac1_aes_128_vector(const u8 *key, size_t num_elem,
const u8 *addr[], const size_t *len, u8 *mac)
{
void *ctx;
u8 cbc[BLOCK_SIZE], pad[BLOCK_SIZE];
u8 cbc[AES_BLOCK_SIZE], pad[AES_BLOCK_SIZE];
const u8 *pos, *end;
size_t i, e, left, total_len;
ctx = aes_encrypt_init(key, 16);
if (ctx == NULL)
return -1;
os_memset(cbc, 0, BLOCK_SIZE);
os_memset(cbc, 0, AES_BLOCK_SIZE);
total_len = 0;
for (e = 0; e < num_elem; e++)
@ -66,8 +66,8 @@ int omac1_aes_128_vector(const u8 *key, size_t num_elem,
pos = addr[0];
end = pos + len[0];
while (left >= BLOCK_SIZE) {
for (i = 0; i < BLOCK_SIZE; i++) {
while (left >= AES_BLOCK_SIZE) {
for (i = 0; i < AES_BLOCK_SIZE; i++) {
cbc[i] ^= *pos++;
if (pos >= end) {
e++;
@ -75,12 +75,12 @@ int omac1_aes_128_vector(const u8 *key, size_t num_elem,
end = pos + len[e];
}
}
if (left > BLOCK_SIZE)
if (left > AES_BLOCK_SIZE)
aes_encrypt(ctx, cbc, cbc);
left -= BLOCK_SIZE;
left -= AES_BLOCK_SIZE;
}
os_memset(pad, 0, BLOCK_SIZE);
os_memset(pad, 0, AES_BLOCK_SIZE);
aes_encrypt(ctx, pad, pad);
gf_mulx(pad);
@ -97,7 +97,7 @@ int omac1_aes_128_vector(const u8 *key, size_t num_elem,
gf_mulx(pad);
}
for (i = 0; i < BLOCK_SIZE; i++)
for (i = 0; i < AES_BLOCK_SIZE; i++)
pad[i] ^= cbc[i];
aes_encrypt(ctx, pad, mac);
aes_encrypt_deinit(ctx);

2
src/crypto/aes-unwrap.c
View file

@ -16,7 +16,7 @@
#include "includes.h"
#include "common.h"
#include "aes_i.h"
#include "aes.h"
/**
* aes_unwrap - Unwrap key with AES Key Wrap Algorithm (128-bit KEK) (RFC3394)

2
src/crypto/aes-wrap.c
View file

@ -16,7 +16,7 @@
#include "includes.h"
#include "common.h"
#include "aes_i.h"
#include "aes.h"
/**
* aes_wrap - Wrap keys with AES Key Wrap Algorithm (128-bit KEK) (RFC3394)

2
src/crypto/aes.h
View file

@ -15,6 +15,8 @@
#ifndef AES_H
#define AES_H
#define AES_BLOCK_SIZE 16
void * aes_encrypt_init(const u8 *key, size_t len);
void aes_encrypt(void *ctx, const u8 *plain, u8 *crypt);
void aes_encrypt_deinit(void *ctx);

2
src/crypto/aes_i.h
View file

@ -17,8 +17,6 @@
#include "aes.h"
#define BLOCK_SIZE 16
/* #define FULL_UNROLL */
#define AES_SMALL_TABLES