/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/* lib/crypto/crypto_tests/aes-test.c */
/*
 * Copyright (C) 2002 by the Massachusetts Institute of Technology.
 * All Rights Reserved.
 *
 * Export of this software from the United States of America may
 *   require a specific license from the United States Government.
 *   It is the responsibility of any person or organization contemplating
 *   export to obtain such a license before exporting.
 *
 * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
 * distribute this software and its documentation for any purpose and
 * without fee is hereby granted, provided that the above copyright
 * notice appear in all copies and that both that copyright notice and
 * this permission notice appear in supporting documentation, and that
 * the name of M.I.T. not be used in advertising or publicity pertaining
 * to distribution of the software without specific, written prior
 * permission.  Furthermore if you modify this software you must label
 * your software as modified software and not distribute it in such a
 * fashion that it might be confused with the original M.I.T. software.
 * M.I.T. makes no representations about the suitability of
 * this software for any purpose.  It is provided "as is" without express
 * or implied warranty.
 */

/*
 * Subset of NIST tests for AES; specifically, the variable-key and
 * variable-text tests for 128- and 256-bit keys.
 */

#include <stdio.h>
#include "crypto_int.h"

static char key[32];
static char plain[16], cipher[16], zero[16];

static krb5_keyblock enc_key;
static krb5_data ivec;
static void init(void)
{
    enc_key.contents = (krb5_octet *)key;
    enc_key.length = 16;
    ivec.data = zero;
    ivec.length = 16;
}
static void enc(void)
{
    krb5_key k;
    krb5_crypto_iov iov;

    memcpy(cipher, plain, 16);
    iov.flags = KRB5_CRYPTO_TYPE_DATA;
    iov.data = make_data(cipher, 16);
    krb5_k_create_key(NULL, &enc_key, &k);
    krb5int_aes_encrypt(k, &ivec, &iov, 1);
    krb5_k_free_key(NULL, k);
}

static void hexdump(const char *label, const char *cp, int len)
{
    printf("%s=", label);
    while (len--) printf("%02X", 0xff & *cp++);
    printf("\n");
}

static void set_bit(char *ptr, int bitnum)
{
    int bytenum;
    bytenum = bitnum / 8;
    bitnum %= 8;
    /* First bit is the high bit! */
    ptr[bytenum] = 1 << (7 - bitnum);
}

/* Variable-Key tests */
static void vk_test_1(int len, krb5_enctype etype)
{
    int i;

    enc_key.length = len;
    enc_key.enctype = etype;
    printf("\nKEYSIZE=%d\n\n", len * 8);
    memset(plain, 0, sizeof(plain));
    hexdump("PT", plain, 16);
    for (i = 0; i < len * 8; i++) {
        memset(key, 0, len);
        set_bit(key, i);
        printf("\nI=%d\n", i+1);
        hexdump("KEY", key, len);
        enc();
        hexdump("CT", cipher, 16);
    }
    printf("\n==========\n");
}
static void vk_test(void)
{
    vk_test_1(16, ENCTYPE_AES128_CTS_HMAC_SHA1_96);
    vk_test_1(32, ENCTYPE_AES256_CTS_HMAC_SHA1_96);
}

/* Variable-Text tests */
static void vt_test_1(int len, krb5_enctype etype)
{
    int i;

    enc_key.length = len;
    enc_key.enctype = etype;
    printf("\nKEYSIZE=%d\n\n", len * 8);
    memset(key, 0, len);
    hexdump("KEY", key, len);
    for (i = 0; i < 16 * 8; i++) {
        memset(plain, 0, sizeof(plain));
        set_bit(plain, i);
        printf("\nI=%d\n", i+1);
        hexdump("PT", plain, 16);
        enc();
        hexdump("CT", cipher, 16);
    }
    printf("\n==========\n");
}
static void vt_test(void)
{
    vt_test_1(16, ENCTYPE_AES128_CTS_HMAC_SHA1_96);
    vt_test_1(32, ENCTYPE_AES256_CTS_HMAC_SHA1_96);
}


int main (int argc, char *argv[])
{
    if (argc > 2 || (argc == 2 && strcmp(argv[1], "-k"))) {
        fprintf(stderr,
                "usage:\t%s -k\tfor variable-key tests\n"
                "   or:\t%s   \tfor variable-plaintext tests\n",
                argv[0], argv[0]);
        return 1;
    }
    init();
    if (argc == 2)
        vk_test();
    else
        vt_test();
    return 0;
}
