int main(void)
{
int i;
unsigned char key1[16], key2[16], tinit[16];
unsigned char *pt, *ct;
printf("aes_xts_128_enc_perf:\n");
pt = malloc(TEST_LEN);
ct = malloc(TEST_LEN);
if (NULL == pt || NULL == ct) {
printf("malloc of testsize failed\n");
return -1;
}
mk_rand_data(key1, key2, tinit, pt, TEST_LEN);
XTS_AES_128_enc(key2, key1, tinit, TEST_LEN, pt, ct);
struct perf start, stop;
perf_start(&start);
for (i = 0; i < TEST_LOOPS; i++) {
XTS_AES_128_enc(key2, key1, tinit, TEST_LEN, pt, ct);
}
perf_stop(&stop);
printf("aes_xts_128_enc" TEST_TYPE_STR ": ");
perf_print(stop, start, (long long)TEST_LEN * i);
return 0;
}
int main(void)
{
// Temporary array for the calculated vectors
uint8_t *ct_test;
uint8_t *pt_test;
int i, j;
// --- Encryption test ---
// Loop over the vectors
for (i = 0; i < NVEC; i++) {
// Allocate space for the calculated ciphertext
ct_test = malloc(vlist[i].ptlen);
if (ct_test == NULL) {
fprintf(stderr, "Can't allocate ciphertext memory\n");
return -1;
}
XTS_AES_128_enc(vlist[i].key2, vlist[i].key1, vlist[i].TW,
vlist[i].ptlen, vlist[i].PTX, ct_test);
// Carry out comparison of the calculated ciphertext with
// the reference
for (j = 0; j < vlist[i].ptlen; j++) {
if (ct_test[j] != vlist[i].CTX[j]) {
// Vectors 1-10 and 15-19 are for the 128 bit code
printf("\nXTS_AES_128_enc: Vector %d: ",
i < 9 ? i + 1 : i + 6);
printf("failed at byte %d! \n", j);
return -1;
}
}
printf(".");
}
// --- Decryption test ---
// Loop over the vectors
for (i = 0; i < NVEC; i++) {
// Allocate space for the calculated ciphertext
pt_test = malloc(vlist[i].ptlen);
if (pt_test == NULL) {
fprintf(stderr, "Can't allocate plaintext memory\n");
return -1;
}
XTS_AES_128_dec(vlist[i].key2, vlist[i].key1, vlist[i].TW,
vlist[i].ptlen, vlist[i].CTX, pt_test);
for (j = 0; j < vlist[i].ptlen; j++) {
if (pt_test[j] != vlist[i].PTX[j]) {
// Carry out comparison of the calculated ciphertext with
// the reference
printf("\nXTS_AES_128_enc: Vector %d: ",
i < 9 ? i + 1 : i + 6);
printf(" failed at byte %d! \n", j);
return -1;
}
}
printf(".");
}
printf("Pass\n");
return 0;
}
int main(void)
{
int i;
unsigned char key1[16], key2[16], tinit[16];
unsigned char *pt, *ct, *refct;
struct perf start, stop;
unsigned char keyssl[32]; /* SSL takes both keys together */
/* Initialise our cipher context, which can use same input vectors */
EVP_CIPHER_CTX *ctx;
ctx = EVP_CIPHER_CTX_new();
printf("aes_xts_128_enc_perf:\n");
pt = malloc(TEST_LEN);
ct = malloc(TEST_LEN);
refct = malloc(TEST_LEN);
if (NULL == pt || NULL == ct || NULL == refct) {
printf("malloc of testsize failed\n");
return -1;
}
xts128_mk_rand_data(key1, key2, tinit, pt, TEST_LEN);
/* Set up key for the SSL engine */
for (i = 0; i < 16; i++) {
keyssl[i] = key1[i];
keyssl[i + 16] = key2[i];
}
/* Encrypt and compare output */
XTS_AES_128_enc(key2, key1, tinit, TEST_LEN, pt, ct);
openssl_aes_128_xts_enc(ctx, keyssl, tinit, TEST_LEN, pt, refct);
if (memcmp(ct, refct, TEST_LEN)) {
printf("ISA-L and OpenSSL results don't match\n");
return -1;
}
/* Time ISA-L encryption */
perf_start(&start);
for (i = 0; i < TEST_LOOPS; i++)
XTS_AES_128_enc(key2, key1, tinit, TEST_LEN, pt, ct);
perf_stop(&stop);
printf("aes_xts_128_enc" TEST_TYPE_STR ": ");
perf_print(stop, start, (long long)TEST_LEN * i);
/* Time OpenSSL encryption */
perf_start(&start);
for (i = 0; i < TEST_LOOPS; i++)
openssl_aes_128_xts_enc(ctx, keyssl, tinit, TEST_LEN, pt, refct);
perf_stop(&stop);
printf("aes_xts_128_openssl_enc" TEST_TYPE_STR ": ");
perf_print(stop, start, (long long)TEST_LEN * i);
EVP_CIPHER_CTX_free(ctx);
return 0;
}
int main(void)
{
int t, n;
unsigned char key1[16], key2[16], tinit[16];
unsigned char *pt, *ct, *dt;
int align, size, min_size;
unsigned char *efence_pt;
unsigned char *efence_ct;
unsigned char *efence_dt;
unsigned char *origin_pt;
unsigned char *origin_ct;
unsigned char *origin_dt;
unsigned char key1_exp_enc[16 * 11], key1_exp_dec[16 * 11];
unsigned char key2_exp_tw[16 * 11];
int i;
printf("aes_xts_128 enc/dec rand test, %d sets of %d max: ", RANDOMS, TEST_LEN);
pt = malloc(TEST_LEN);
ct = malloc(TEST_LEN);
dt = malloc(TEST_LEN);
if (NULL == pt || NULL == ct || NULL == dt) {
printf("malloc of testsize failed\n");
return -1;
}
mk_rand_data(key1, key2, tinit, pt, TEST_LEN);
XTS_AES_128_enc(key2, key1, tinit, TEST_LEN, pt, ct);
XTS_AES_128_dec(key2, key1, tinit, TEST_LEN, ct, dt);
if (memcmp(pt, dt, TEST_LEN)) {
printf("fail\n");
return -1;
}
putchar('.');
// Do tests with random data, keys and message size
for (t = 0; t < RANDOMS; t++) {
n = rand() % (TEST_LEN);
if (n < 17)
continue;
mk_rand_data(key1, key2, tinit, pt, n);
XTS_AES_128_enc(key2, key1, tinit, n, pt, ct);
XTS_AES_128_dec(key2, key1, tinit, n, ct, dt);
if (memcmp(pt, dt, n)) {
printf("fail rand %d, size %d\n", t, n);
return -1;
}
putchar('.');
fflush(0);
}
// Run tests at end of buffer for Electric Fence
align = 1;
min_size = 16;
for (size = 0; size <= TEST_SIZE - min_size; size += align) {
// Line up TEST_SIZE from end
efence_pt = pt + TEST_LEN - TEST_SIZE + size;
efence_ct = ct + TEST_LEN - TEST_SIZE + size;
efence_dt = dt + TEST_LEN - TEST_SIZE + size;
mk_rand_data(key1, key2, tinit, efence_pt, TEST_SIZE - size);
XTS_AES_128_enc(key2, key1, tinit, TEST_SIZE - size, efence_pt, efence_ct);
XTS_AES_128_dec(key2, key1, tinit, TEST_SIZE - size, efence_ct, efence_dt);
if (memcmp(efence_pt, efence_dt, TEST_SIZE - size)) {
printf("efence: fail size %d\n", TEST_SIZE - size);
return -1;
}
putchar('.');
fflush(0);
}
origin_pt = malloc(TEST_LEN);
origin_ct = malloc(TEST_LEN);
origin_dt = malloc(TEST_LEN);
if (NULL == origin_pt || NULL == origin_ct || NULL == origin_dt) {
printf("malloc of testsize failed\n");
return -1;
}
// For data lengths from 0 to 15 bytes, the functions return without any error
// codes, without reading or writing any data.
for (size = TEST_SIZE - min_size + align; size <= TEST_SIZE; size += align) {
// Line up TEST_SIZE from end
efence_pt = pt + TEST_LEN - TEST_SIZE + size;
efence_ct = ct + TEST_LEN - TEST_SIZE + size;
efence_dt = dt + TEST_LEN - TEST_SIZE + size;
mk_rand_data(key1, key2, tinit, efence_pt, TEST_SIZE - size);
memcpy(efence_ct, efence_pt, TEST_SIZE - size);
memcpy(efence_dt, efence_pt, TEST_SIZE - size);
memcpy(origin_pt, efence_pt, TEST_SIZE - size);
memcpy(origin_ct, efence_ct, TEST_SIZE - size);
memcpy(origin_dt, efence_dt, TEST_SIZE - size);
XTS_AES_128_enc(key2, key1, tinit, TEST_SIZE - size, efence_pt, efence_ct);
XTS_AES_128_dec(key2, key1, tinit, TEST_SIZE - size, efence_ct, efence_dt);
if (memcmp(efence_pt, origin_pt, TEST_SIZE - size)) {
printf("efence_pt: fail size %d\n", TEST_SIZE - size);
return -1;
}
if (memcmp(efence_ct, origin_ct, TEST_SIZE - size)) {
printf("efence_ct: fail size %d\n", TEST_SIZE - size);
return -1;
}
if (memcmp(efence_dt, origin_dt, TEST_SIZE - size)) {
printf("efence_dt: fail size %d\n", TEST_SIZE - size);
return -1;
}
putchar('.');
fflush(0);
}
for (i = 0; i < 16 * 11; i++) {
key2_exp_tw[i] = rand();
}
for (size = 0; size <= TEST_SIZE - min_size; size += align) {
// Line up TEST_SIZE from end
efence_pt = pt + TEST_LEN - TEST_SIZE + size;
efence_ct = ct + TEST_LEN - TEST_SIZE + size;
efence_dt = dt + TEST_LEN - TEST_SIZE + size;
mk_rand_data(key1, key2, tinit, efence_pt, TEST_SIZE - size);
aes_keyexp_128(key1, key1_exp_enc, key1_exp_dec);
XTS_AES_128_enc_expanded_key(key2_exp_tw, key1_exp_enc, tinit,
TEST_SIZE - size, efence_pt, efence_ct);
XTS_AES_128_dec_expanded_key(key2_exp_tw, key1_exp_dec, tinit,
TEST_SIZE - size, efence_ct, efence_dt);
if (memcmp(efence_pt, efence_dt, TEST_SIZE - size)) {
printf("efence_expanded_key: fail size %d\n", TEST_SIZE - size);
return -1;
}
putchar('.');
fflush(0);
}
// For data lengths from 0 to 15 bytes, the functions return without any error
// codes, without reading or writing any data.
for (size = TEST_SIZE - min_size + align; size <= TEST_SIZE; size += align) {
// Line up TEST_SIZE from end
efence_pt = pt + TEST_LEN - TEST_SIZE + size;
efence_ct = ct + TEST_LEN - TEST_SIZE + size;
efence_dt = dt + TEST_LEN - TEST_SIZE + size;
mk_rand_data(key1, key2, tinit, efence_pt, TEST_SIZE - size);
memcpy(efence_ct, efence_pt, TEST_SIZE - size);
memcpy(efence_dt, efence_pt, TEST_SIZE - size);
memcpy(origin_pt, efence_pt, TEST_SIZE - size);
memcpy(origin_ct, efence_ct, TEST_SIZE - size);
memcpy(origin_dt, efence_dt, TEST_SIZE - size);
aes_keyexp_128(key1, key1_exp_enc, key1_exp_dec);
XTS_AES_128_enc_expanded_key(key2_exp_tw, key1_exp_enc, tinit,
TEST_SIZE - size, efence_pt, efence_ct);
XTS_AES_128_dec_expanded_key(key2_exp_tw, key1_exp_dec, tinit,
TEST_SIZE - size, efence_ct, efence_dt);
if (memcmp(efence_pt, origin_pt, TEST_SIZE - size)) {
printf("efence_expanded_key for pt: fail size %d\n", TEST_SIZE - size);
return -1;
}
if (memcmp(efence_ct, origin_ct, TEST_SIZE - size)) {
printf("efence_expanded_key for ct: fail size %d\n", TEST_SIZE - size);
return -1;
}
if (memcmp(efence_dt, origin_dt, TEST_SIZE - size)) {
printf("efence_expanded_key for dt: fail size %d\n", TEST_SIZE - size);
return -1;
}
putchar('.');
fflush(0);
}
printf("Pass\n");
return 0;
}
