[thirdparty/openssl.git] / test / igetest.c

/*
 * Copyright 2006-2016 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the OpenSSL license (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#include <openssl/crypto.h>
#include <openssl/aes.h>
#include <openssl/rand.h>
#include <stdio.h>
#include <string.h>
#include "e_os.h"
#include "testutil.h"

#define TEST_SIZE       128
#define BIG_TEST_SIZE 10240

#if BIG_TEST_SIZE < TEST_SIZE
#error BIG_TEST_SIZE is smaller than TEST_SIZE
#endif

static unsigned char rkey[16];
static unsigned char rkey2[16];
static unsigned char plaintext[BIG_TEST_SIZE];
static unsigned char saved_iv[AES_BLOCK_SIZE * 4];

#define MAX_VECTOR_SIZE 64

struct ige_test {
    const unsigned char key[16];
    const unsigned char iv[32];
    const unsigned char in[MAX_VECTOR_SIZE];
    const unsigned char out[MAX_VECTOR_SIZE];
    const size_t length;
    const int encrypt;
};

static struct ige_test const ige_test_vectors[] = {
    {{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
      0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f}, /* key */
     {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
      0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
      0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
      0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f}, /* iv */
     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* in */
     {0x1a, 0x85, 0x19, 0xa6, 0x55, 0x7b, 0xe6, 0x52,
      0xe9, 0xda, 0x8e, 0x43, 0xda, 0x4e, 0xf4, 0x45,
      0x3c, 0xf4, 0x56, 0xb4, 0xca, 0x48, 0x8a, 0xa3,
      0x83, 0xc7, 0x9c, 0x98, 0xb3, 0x47, 0x97, 0xcb}, /* out */
     32, AES_ENCRYPT},          /* test vector 0 */

    {{0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20,
      0x61, 0x6e, 0x20, 0x69, 0x6d, 0x70, 0x6c, 0x65}, /* key */
     {0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f,
      0x6e, 0x20, 0x6f, 0x66, 0x20, 0x49, 0x47, 0x45,
      0x20, 0x6d, 0x6f, 0x64, 0x65, 0x20, 0x66, 0x6f,
      0x72, 0x20, 0x4f, 0x70, 0x65, 0x6e, 0x53, 0x53}, /* iv */
     {0x4c, 0x2e, 0x20, 0x4c, 0x65, 0x74, 0x27, 0x73,
      0x20, 0x68, 0x6f, 0x70, 0x65, 0x20, 0x42, 0x65,
      0x6e, 0x20, 0x67, 0x6f, 0x74, 0x20, 0x69, 0x74,
      0x20, 0x72, 0x69, 0x67, 0x68, 0x74, 0x21, 0x0a}, /* in */
     {0x99, 0x70, 0x64, 0x87, 0xa1, 0xcd, 0xe6, 0x13,
      0xbc, 0x6d, 0xe0, 0xb6, 0xf2, 0x4b, 0x1c, 0x7a,
      0xa4, 0x48, 0xc8, 0xb9, 0xc3, 0x40, 0x3e, 0x34,
      0x67, 0xa8, 0xca, 0xd8, 0x93, 0x40, 0xf5, 0x3b}, /* out */
     32, AES_DECRYPT},          /* test vector 1 */
};

struct bi_ige_test {
    const unsigned char key1[32];
    const unsigned char key2[32];
    const unsigned char iv[64];
    const unsigned char in[MAX_VECTOR_SIZE];
    const unsigned char out[MAX_VECTOR_SIZE];
    const size_t keysize;
    const size_t length;
    const int encrypt;
};

static struct bi_ige_test const bi_ige_test_vectors[] = {
    {{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
      0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f}, /* key1 */
     {0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
      0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f}, /* key2 */
     {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
      0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
      0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
      0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
      0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
      0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
      0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
      0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f}, /* iv */
     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* in */
     {0x14, 0x40, 0x6f, 0xae, 0xa2, 0x79, 0xf2, 0x56,
      0x1f, 0x86, 0xeb, 0x3b, 0x7d, 0xff, 0x53, 0xdc,
      0x4e, 0x27, 0x0c, 0x03, 0xde, 0x7c, 0xe5, 0x16,
      0x6a, 0x9c, 0x20, 0x33, 0x9d, 0x33, 0xfe, 0x12}, /* out */
     16, 32, AES_ENCRYPT},      /* test vector 0 */
    {{0x58, 0x0a, 0x06, 0xe9, 0x97, 0x07, 0x59, 0x5c,
      0x9e, 0x19, 0xd2, 0xa7, 0xbb, 0x40, 0x2b, 0x7a,
      0xc7, 0xd8, 0x11, 0x9e, 0x4c, 0x51, 0x35, 0x75,
      0x64, 0x28, 0x0f, 0x23, 0xad, 0x74, 0xac, 0x37}, /* key1 */
     {0xd1, 0x80, 0xa0, 0x31, 0x47, 0xa3, 0x11, 0x13,
      0x86, 0x26, 0x9e, 0x6d, 0xff, 0xaf, 0x72, 0x74,
      0x5b, 0xa2, 0x35, 0x81, 0xd2, 0xa6, 0x3d, 0x21,
      0x67, 0x7b, 0x58, 0xa8, 0x18, 0xf9, 0x72, 0xe4}, /* key2 */
     {0x80, 0x3d, 0xbd, 0x4c, 0xe6, 0x7b, 0x06, 0xa9,
      0x53, 0x35, 0xd5, 0x7e, 0x71, 0xc1, 0x70, 0x70,
      0x74, 0x9a, 0x00, 0x28, 0x0c, 0xbf, 0x6c, 0x42,
      0x9b, 0xa4, 0xdd, 0x65, 0x11, 0x77, 0x7c, 0x67,
      0xfe, 0x76, 0x0a, 0xf0, 0xd5, 0xc6, 0x6e, 0x6a,
      0xe7, 0x5e, 0x4c, 0xf2, 0x7e, 0x9e, 0xf9, 0x20,
      0x0e, 0x54, 0x6f, 0x2d, 0x8a, 0x8d, 0x7e, 0xbd,
      0x48, 0x79, 0x37, 0x99, 0xff, 0x27, 0x93, 0xa3}, /* iv */
     {0xf1, 0x54, 0x3d, 0xca, 0xfe, 0xb5, 0xef, 0x1c,
      0x4f, 0xa6, 0x43, 0xf6, 0xe6, 0x48, 0x57, 0xf0,
      0xee, 0x15, 0x7f, 0xe3, 0xe7, 0x2f, 0xd0, 0x2f,
      0x11, 0x95, 0x7a, 0x17, 0x00, 0xab, 0xa7, 0x0b,
      0xbe, 0x44, 0x09, 0x9c, 0xcd, 0xac, 0xa8, 0x52,
      0xa1, 0x8e, 0x7b, 0x75, 0xbc, 0xa4, 0x92, 0x5a,
      0xab, 0x46, 0xd3, 0x3a, 0xa0, 0xd5, 0x35, 0x1c,
      0x55, 0xa4, 0xb3, 0xa8, 0x40, 0x81, 0xa5, 0x0b}, /* in */
     {0x42, 0xe5, 0x28, 0x30, 0x31, 0xc2, 0xa0, 0x23,
      0x68, 0x49, 0x4e, 0xb3, 0x24, 0x59, 0x92, 0x79,
      0xc1, 0xa5, 0xcc, 0xe6, 0x76, 0x53, 0xb1, 0xcf,
      0x20, 0x86, 0x23, 0xe8, 0x72, 0x55, 0x99, 0x92,
      0x0d, 0x16, 0x1c, 0x5a, 0x2f, 0xce, 0xcb, 0x51,
      0xe2, 0x67, 0xfa, 0x10, 0xec, 0xcd, 0x3d, 0x67,
      0xa5, 0xe6, 0xf7, 0x31, 0x26, 0xb0, 0x0d, 0x76,
      0x5e, 0x28, 0xdc, 0x7f, 0x01, 0xc5, 0xa5, 0x4c}, /* out */
     32, 64, AES_ENCRYPT},      /* test vector 1 */

};

static int test_ige_vectors(int n)
{
    const struct ige_test *const v = &ige_test_vectors[n];
    AES_KEY key;
    unsigned char buf[MAX_VECTOR_SIZE];
    unsigned char iv[AES_BLOCK_SIZE * 2];
    int testresult = 1;

    if (!TEST_int_le(v->length, MAX_VECTOR_SIZE))
        return 0;

    if (v->encrypt == AES_ENCRYPT)
        AES_set_encrypt_key(v->key, 8 * sizeof v->key, &key);
    else
        AES_set_decrypt_key(v->key, 8 * sizeof v->key, &key);
    memcpy(iv, v->iv, sizeof iv);
    AES_ige_encrypt(v->in, buf, v->length, &key, iv, v->encrypt);

    if (!TEST_mem_eq(v->out, v->length, buf, v->length)) {
        TEST_info("IGE test vector %d failed", n);
        test_output_memory("key", v->key, sizeof v->key);
        test_output_memory("iv", v->iv, sizeof v->iv);
        test_output_memory("in", v->in, v->length);
        testresult = 0;
    }

    /* try with in == out */
    memcpy(iv, v->iv, sizeof iv);
    memcpy(buf, v->in, v->length);
    AES_ige_encrypt(buf, buf, v->length, &key, iv, v->encrypt);

    if (!TEST_mem_eq(v->out, v->length, buf, v->length)) {
        TEST_info("IGE test vector %d failed (with in == out)", n);
        test_output_memory("key", v->key, sizeof v->key);
        test_output_memory("iv", v->iv, sizeof v->iv);
        test_output_memory("in", v->in, v->length);
        testresult = 0;
    }

    return testresult;
}

static int test_bi_ige_vectors(int n)
{
    const struct bi_ige_test *const v = &bi_ige_test_vectors[n];
    AES_KEY key1;
    AES_KEY key2;
    unsigned char buf[MAX_VECTOR_SIZE];

        if (!TEST_int_le(v->length, MAX_VECTOR_SIZE))
            return 0;

    if (v->encrypt == AES_ENCRYPT) {
        AES_set_encrypt_key(v->key1, 8 * v->keysize, &key1);
        AES_set_encrypt_key(v->key2, 8 * v->keysize, &key2);
    } else {
        AES_set_decrypt_key(v->key1, 8 * v->keysize, &key1);
        AES_set_decrypt_key(v->key2, 8 * v->keysize, &key2);
    }

    AES_bi_ige_encrypt(v->in, buf, v->length, &key1, &key2, v->iv,
                       v->encrypt);

    if (!TEST_mem_eq(v->out, v->length, buf, v->length)) {
        test_output_memory("key 1", v->key1, sizeof v->key1);
        test_output_memory("key 2", v->key2, sizeof v->key2);
        test_output_memory("iv", v->iv, sizeof v->iv);
        test_output_memory("in", v->in, v->length);
        return 0;
    }

    return 1;
}

static int test_ige_enc_dec(void)
{
    AES_KEY key;
    unsigned char iv[AES_BLOCK_SIZE * 4];
    unsigned char ciphertext[BIG_TEST_SIZE];
    unsigned char checktext[BIG_TEST_SIZE];

    memcpy(iv, saved_iv, sizeof iv);
    AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
    AES_ige_encrypt(plaintext, ciphertext, TEST_SIZE, &key, iv, AES_ENCRYPT);

    AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
    memcpy(iv, saved_iv, sizeof iv);
    AES_ige_encrypt(ciphertext, checktext, TEST_SIZE, &key, iv, AES_DECRYPT);

    return TEST_mem_eq(checktext, TEST_SIZE, plaintext, TEST_SIZE);
}

static int test_ige_enc_chaining(void)
{
    AES_KEY key;
    unsigned char iv[AES_BLOCK_SIZE * 4];
    unsigned char ciphertext[BIG_TEST_SIZE];
    unsigned char checktext[BIG_TEST_SIZE];

    AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
    memcpy(iv, saved_iv, sizeof iv);
    AES_ige_encrypt(plaintext, ciphertext, TEST_SIZE / 2, &key, iv,
                    AES_ENCRYPT);
    AES_ige_encrypt(plaintext + TEST_SIZE / 2,
                    ciphertext + TEST_SIZE / 2, TEST_SIZE / 2,
                    &key, iv, AES_ENCRYPT);

    AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
    memcpy(iv, saved_iv, sizeof iv);
    AES_ige_encrypt(ciphertext, checktext, TEST_SIZE, &key, iv, AES_DECRYPT);

    return TEST_mem_eq(checktext, TEST_SIZE, plaintext, TEST_SIZE);
}

static int test_ige_dec_chaining(void)
{
    AES_KEY key;
    unsigned char iv[AES_BLOCK_SIZE * 4];
    unsigned char ciphertext[BIG_TEST_SIZE];
    unsigned char checktext[BIG_TEST_SIZE];

    AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
    memcpy(iv, saved_iv, sizeof iv);
    AES_ige_encrypt(plaintext, ciphertext, TEST_SIZE / 2, &key, iv,
                    AES_ENCRYPT);
    AES_ige_encrypt(plaintext + TEST_SIZE / 2,
                    ciphertext + TEST_SIZE / 2, TEST_SIZE / 2,
                    &key, iv, AES_ENCRYPT);

    AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
    memcpy(iv, saved_iv, sizeof iv);
    AES_ige_encrypt(ciphertext, checktext, TEST_SIZE / 2, &key, iv,
                    AES_DECRYPT);
    AES_ige_encrypt(ciphertext + TEST_SIZE / 2,
                    checktext + TEST_SIZE / 2, TEST_SIZE / 2, &key, iv,
                    AES_DECRYPT);

    return TEST_mem_eq(checktext, TEST_SIZE, plaintext, TEST_SIZE);
}

static int test_ige_garble_forwards(void)
{
    AES_KEY key;
    unsigned char iv[AES_BLOCK_SIZE * 4];
    unsigned char ciphertext[BIG_TEST_SIZE];
    unsigned char checktext[BIG_TEST_SIZE];
    unsigned int n;
    int testresult = 1;
    const size_t ctsize = sizeof(checktext);
    size_t matches;

    AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
    memcpy(iv, saved_iv, sizeof iv);
    AES_ige_encrypt(plaintext, ciphertext, sizeof plaintext, &key, iv,
                    AES_ENCRYPT);

    /* corrupt halfway through */
    ++ciphertext[sizeof ciphertext / 2];
    AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
    memcpy(iv, saved_iv, sizeof iv);
    AES_ige_encrypt(ciphertext, checktext, sizeof checktext, &key, iv,
                    AES_DECRYPT);

    matches = 0;
    for (n = 0; n < sizeof checktext; ++n)
        if (checktext[n] == plaintext[n])
            ++matches;

    /* Fail if there is more than 51% matching bytes */
    if (!TEST_size_t_le(matches, ctsize / 2 + ctsize / 100))
        testresult = 0;

    /* Fail if the garble goes backwards */
    if (!TEST_size_t_gt(matches, ctsize / 2))
        testresult = 0;
    return testresult;
}

static int test_bi_ige_enc_dec(void)
{
    AES_KEY key, key2;
    unsigned char iv[AES_BLOCK_SIZE * 4];
    unsigned char ciphertext[BIG_TEST_SIZE];
    unsigned char checktext[BIG_TEST_SIZE];

    memcpy(iv, saved_iv, sizeof iv);
    AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
    AES_set_encrypt_key(rkey2, 8 * sizeof rkey2, &key2);
    AES_bi_ige_encrypt(plaintext, ciphertext, TEST_SIZE, &key, &key2, iv,
                       AES_ENCRYPT);

    AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
    AES_set_decrypt_key(rkey2, 8 * sizeof rkey2, &key2);
    AES_bi_ige_encrypt(ciphertext, checktext, TEST_SIZE, &key, &key2, iv,
                       AES_DECRYPT);

    return TEST_mem_eq(checktext, TEST_SIZE, plaintext, TEST_SIZE);
}

static int test_bi_ige_garble1(void)
{
    AES_KEY key, key2;
    unsigned char iv[AES_BLOCK_SIZE * 4];
    unsigned char ciphertext[BIG_TEST_SIZE];
    unsigned char checktext[BIG_TEST_SIZE];
    unsigned int n;
    size_t matches;

    memcpy(iv, saved_iv, sizeof iv);
    AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
    AES_set_encrypt_key(rkey2, 8 * sizeof rkey2, &key2);
    AES_ige_encrypt(plaintext, ciphertext, sizeof plaintext, &key, iv,
                    AES_ENCRYPT);

    /* corrupt halfway through */
    ++ciphertext[sizeof ciphertext / 2];
    AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
    AES_set_decrypt_key(rkey2, 8 * sizeof rkey2, &key2);
    AES_ige_encrypt(ciphertext, checktext, sizeof checktext, &key, iv,
                    AES_DECRYPT);

    matches = 0;
    for (n = 0; n < sizeof checktext; ++n)
        if (checktext[n] == plaintext[n])
            ++matches;

    /* Fail if there is more than 1% matching bytes */
    return TEST_size_t_le(matches, sizeof checktext / 100);
}

static int test_bi_ige_garble2(void)
{
    AES_KEY key, key2;
    unsigned char iv[AES_BLOCK_SIZE * 4];
    unsigned char ciphertext[BIG_TEST_SIZE];
    unsigned char checktext[BIG_TEST_SIZE];
    unsigned int n;
    size_t matches;

    memcpy(iv, saved_iv, sizeof iv);
    AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
    AES_set_encrypt_key(rkey2, 8 * sizeof rkey2, &key2);
    AES_ige_encrypt(plaintext, ciphertext, sizeof plaintext, &key, iv,
                    AES_ENCRYPT);

    /* corrupt right at the end */
    ++ciphertext[sizeof ciphertext - 1];
    AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
    AES_set_decrypt_key(rkey2, 8 * sizeof rkey2, &key2);
    AES_ige_encrypt(ciphertext, checktext, sizeof checktext, &key, iv,
                    AES_DECRYPT);

    matches = 0;
    for (n = 0; n < sizeof checktext; ++n)
        if (checktext[n] == plaintext[n])
            ++matches;

    /* Fail if there is more than 1% matching bytes */
    return TEST_size_t_le(matches, sizeof checktext / 100);
}

static int test_bi_ige_garble3(void)
{
    AES_KEY key, key2;
    unsigned char iv[AES_BLOCK_SIZE * 4];
    unsigned char ciphertext[BIG_TEST_SIZE];
    unsigned char checktext[BIG_TEST_SIZE];
    unsigned int n;
    size_t matches;

    memcpy(iv, saved_iv, sizeof iv);
    AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
    AES_set_encrypt_key(rkey2, 8 * sizeof rkey2, &key2);
    AES_ige_encrypt(plaintext, ciphertext, sizeof plaintext, &key, iv,
                    AES_ENCRYPT);

    /* corrupt right at the start */
    ++ciphertext[0];
    AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
    AES_set_decrypt_key(rkey2, 8 * sizeof rkey2, &key2);
    AES_ige_encrypt(ciphertext, checktext, sizeof checktext, &key, iv,
                    AES_DECRYPT);

    matches = 0;
    for (n = 0; n < sizeof checktext; ++n)
        if (checktext[n] == plaintext[n])
            ++matches;

    /* Fail if there is more than 1% matching bytes */
    return TEST_size_t_le(matches, sizeof checktext / 100);
}

void register_tests(void)
{
    RAND_bytes(rkey, sizeof rkey);
    RAND_bytes(rkey2, sizeof rkey2);
    RAND_bytes(plaintext, sizeof plaintext);
    RAND_bytes(saved_iv, sizeof saved_iv);

    ADD_TEST(test_ige_enc_dec);
    ADD_TEST(test_ige_enc_chaining);
    ADD_TEST(test_ige_dec_chaining);
    ADD_TEST(test_ige_garble_forwards);
    ADD_TEST(test_bi_ige_enc_dec);
    ADD_TEST(test_bi_ige_garble1);
    ADD_TEST(test_bi_ige_garble2);
    ADD_TEST(test_bi_ige_garble3);
    ADD_ALL_TESTS(test_ige_vectors, OSSL_NELEM(ige_test_vectors));
    ADD_ALL_TESTS(test_bi_ige_vectors, OSSL_NELEM(bi_ige_test_vectors));
}
Commit	Line	Data
440e5d80 RS	1	/*
440e5d80 RS	2	* Copyright 2006-2016 The OpenSSL Project Authors. All Rights Reserved.
aa6d1a0c	3	*
440e5d80 RS	4	* Licensed under the OpenSSL license (the "License"). You may not use
	5	* this file except in compliance with the License. You can obtain a copy
	6	* in the file LICENSE in the source distribution or at
	7	* https://www.openssl.org/source/license.html
aa6d1a0c BL	8	*/
aa6d1a0c BL	9
a3654f05	10	#include <openssl/crypto.h>
aa6d1a0c BL	11	#include <openssl/aes.h>
	12	#include <openssl/rand.h>
	13	#include <stdio.h>
	14	#include <string.h>
bdcb1a2c	15	#include "e_os.h"
0e534337	16	#include "testutil.h"
aa6d1a0c	17
0f113f3e	18	#define TEST_SIZE 128
aa6d1a0c BL	19	#define BIG_TEST_SIZE 10240
aa6d1a0c BL	20
0e534337 P	21	#if BIG_TEST_SIZE < TEST_SIZE
	22	#error BIG_TEST_SIZE is smaller than TEST_SIZE
	23	#endif
	24
	25	static unsigned char rkey[16];
	26	static unsigned char rkey2[16];
	27	static unsigned char plaintext[BIG_TEST_SIZE];
	28	static unsigned char saved_iv[AES_BLOCK_SIZE * 4];
	29
0f113f3e MC	30	#define MAX_VECTOR_SIZE 64
	31
	32	struct ige_test {
	33	const unsigned char key[16];
	34	const unsigned char iv[32];
	35	const unsigned char in[MAX_VECTOR_SIZE];
	36	const unsigned char out[MAX_VECTOR_SIZE];
	37	const size_t length;
	38	const int encrypt;
	39	};
aa6d1a0c BL	40
aa6d1a0c BL	41	static struct ige_test const ige_test_vectors[] = {
0f113f3e MC	42	{{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
	43	0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f}, /* key */
	44	{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
	45	0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
	46	0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
	47	0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f}, /* iv */
	48	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	49	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	50	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	51	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* in */
	52	{0x1a, 0x85, 0x19, 0xa6, 0x55, 0x7b, 0xe6, 0x52,
	53	0xe9, 0xda, 0x8e, 0x43, 0xda, 0x4e, 0xf4, 0x45,
	54	0x3c, 0xf4, 0x56, 0xb4, 0xca, 0x48, 0x8a, 0xa3,
	55	0x83, 0xc7, 0x9c, 0x98, 0xb3, 0x47, 0x97, 0xcb}, /* out */
	56	32, AES_ENCRYPT}, /* test vector 0 */
	57
	58	{{0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20,
	59	0x61, 0x6e, 0x20, 0x69, 0x6d, 0x70, 0x6c, 0x65}, /* key */
	60	{0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f,
	61	0x6e, 0x20, 0x6f, 0x66, 0x20, 0x49, 0x47, 0x45,
	62	0x20, 0x6d, 0x6f, 0x64, 0x65, 0x20, 0x66, 0x6f,
	63	0x72, 0x20, 0x4f, 0x70, 0x65, 0x6e, 0x53, 0x53}, /* iv */
	64	{0x4c, 0x2e, 0x20, 0x4c, 0x65, 0x74, 0x27, 0x73,
	65	0x20, 0x68, 0x6f, 0x70, 0x65, 0x20, 0x42, 0x65,
	66	0x6e, 0x20, 0x67, 0x6f, 0x74, 0x20, 0x69, 0x74,
	67	0x20, 0x72, 0x69, 0x67, 0x68, 0x74, 0x21, 0x0a}, /* in */
	68	{0x99, 0x70, 0x64, 0x87, 0xa1, 0xcd, 0xe6, 0x13,
	69	0xbc, 0x6d, 0xe0, 0xb6, 0xf2, 0x4b, 0x1c, 0x7a,
	70	0xa4, 0x48, 0xc8, 0xb9, 0xc3, 0x40, 0x3e, 0x34,
	71	0x67, 0xa8, 0xca, 0xd8, 0x93, 0x40, 0xf5, 0x3b}, /* out */
	72	32, AES_DECRYPT}, /* test vector 1 */
aa6d1a0c BL	73	};
aa6d1a0c BL	74
0f113f3e MC	75	struct bi_ige_test {
	76	const unsigned char key1[32];
	77	const unsigned char key2[32];
	78	const unsigned char iv[64];
	79	const unsigned char in[MAX_VECTOR_SIZE];
	80	const unsigned char out[MAX_VECTOR_SIZE];
	81	const size_t keysize;
	82	const size_t length;
	83	const int encrypt;
	84	};
aa6d1a0c BL	85
aa6d1a0c BL	86	static struct bi_ige_test const bi_ige_test_vectors[] = {
0f113f3e MC	87	{{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
	88	0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f}, /* key1 */
	89	{0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
	90	0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f}, /* key2 */
	91	{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
	92	0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
	93	0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
	94	0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
	95	0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
	96	0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
	97	0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
	98	0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f}, /* iv */
	99	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	100	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	101	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	102	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* in */
	103	{0x14, 0x40, 0x6f, 0xae, 0xa2, 0x79, 0xf2, 0x56,
	104	0x1f, 0x86, 0xeb, 0x3b, 0x7d, 0xff, 0x53, 0xdc,
	105	0x4e, 0x27, 0x0c, 0x03, 0xde, 0x7c, 0xe5, 0x16,
	106	0x6a, 0x9c, 0x20, 0x33, 0x9d, 0x33, 0xfe, 0x12}, /* out */
	107	16, 32, AES_ENCRYPT}, /* test vector 0 */
	108	{{0x58, 0x0a, 0x06, 0xe9, 0x97, 0x07, 0x59, 0x5c,
	109	0x9e, 0x19, 0xd2, 0xa7, 0xbb, 0x40, 0x2b, 0x7a,
	110	0xc7, 0xd8, 0x11, 0x9e, 0x4c, 0x51, 0x35, 0x75,
	111	0x64, 0x28, 0x0f, 0x23, 0xad, 0x74, 0xac, 0x37}, /* key1 */
	112	{0xd1, 0x80, 0xa0, 0x31, 0x47, 0xa3, 0x11, 0x13,
	113	0x86, 0x26, 0x9e, 0x6d, 0xff, 0xaf, 0x72, 0x74,
	114	0x5b, 0xa2, 0x35, 0x81, 0xd2, 0xa6, 0x3d, 0x21,
	115	0x67, 0x7b, 0x58, 0xa8, 0x18, 0xf9, 0x72, 0xe4}, /* key2 */
	116	{0x80, 0x3d, 0xbd, 0x4c, 0xe6, 0x7b, 0x06, 0xa9,
	117	0x53, 0x35, 0xd5, 0x7e, 0x71, 0xc1, 0x70, 0x70,
	118	0x74, 0x9a, 0x00, 0x28, 0x0c, 0xbf, 0x6c, 0x42,
	119	0x9b, 0xa4, 0xdd, 0x65, 0x11, 0x77, 0x7c, 0x67,
	120	0xfe, 0x76, 0x0a, 0xf0, 0xd5, 0xc6, 0x6e, 0x6a,
	121	0xe7, 0x5e, 0x4c, 0xf2, 0x7e, 0x9e, 0xf9, 0x20,
	122	0x0e, 0x54, 0x6f, 0x2d, 0x8a, 0x8d, 0x7e, 0xbd,
	123	0x48, 0x79, 0x37, 0x99, 0xff, 0x27, 0x93, 0xa3}, /* iv */
	124	{0xf1, 0x54, 0x3d, 0xca, 0xfe, 0xb5, 0xef, 0x1c,
	125	0x4f, 0xa6, 0x43, 0xf6, 0xe6, 0x48, 0x57, 0xf0,
	126	0xee, 0x15, 0x7f, 0xe3, 0xe7, 0x2f, 0xd0, 0x2f,
	127	0x11, 0x95, 0x7a, 0x17, 0x00, 0xab, 0xa7, 0x0b,
	128	0xbe, 0x44, 0x09, 0x9c, 0xcd, 0xac, 0xa8, 0x52,
	129	0xa1, 0x8e, 0x7b, 0x75, 0xbc, 0xa4, 0x92, 0x5a,
	130	0xab, 0x46, 0xd3, 0x3a, 0xa0, 0xd5, 0x35, 0x1c,
	131	0x55, 0xa4, 0xb3, 0xa8, 0x40, 0x81, 0xa5, 0x0b}, /* in */
	132	{0x42, 0xe5, 0x28, 0x30, 0x31, 0xc2, 0xa0, 0x23,
	133	0x68, 0x49, 0x4e, 0xb3, 0x24, 0x59, 0x92, 0x79,
	134	0xc1, 0xa5, 0xcc, 0xe6, 0x76, 0x53, 0xb1, 0xcf,
	135	0x20, 0x86, 0x23, 0xe8, 0x72, 0x55, 0x99, 0x92,
	136	0x0d, 0x16, 0x1c, 0x5a, 0x2f, 0xce, 0xcb, 0x51,
	137	0xe2, 0x67, 0xfa, 0x10, 0xec, 0xcd, 0x3d, 0x67,
	138	0xa5, 0xe6, 0xf7, 0x31, 0x26, 0xb0, 0x0d, 0x76,
	139	0x5e, 0x28, 0xdc, 0x7f, 0x01, 0xc5, 0xa5, 0x4c}, /* out */
	140	32, 64, AES_ENCRYPT}, /* test vector 1 */
aa6d1a0c BL	141
	142	};
	143
0e534337	144	static int test_ige_vectors(int n)
0f113f3e	145	{
0e534337 P	146	const struct ige_test *const v = &ige_test_vectors[n];
	147	AES_KEY key;
	148	unsigned char buf[MAX_VECTOR_SIZE];
	149	unsigned char iv[AES_BLOCK_SIZE * 2];
	150	int testresult = 1;
	151
	152	if (!TEST_int_le(v->length, MAX_VECTOR_SIZE))
	153	return 0;
	154
	155	if (v->encrypt == AES_ENCRYPT)
	156	AES_set_encrypt_key(v->key, 8 * sizeof v->key, &key);
	157	else
	158	AES_set_decrypt_key(v->key, 8 * sizeof v->key, &key);
	159	memcpy(iv, v->iv, sizeof iv);
	160	AES_ige_encrypt(v->in, buf, v->length, &key, iv, v->encrypt);
	161
	162	if (!TEST_mem_eq(v->out, v->length, buf, v->length)) {
	163	TEST_info("IGE test vector %d failed", n);
37916462 P	164	test_output_memory("key", v->key, sizeof v->key);
	165	test_output_memory("iv", v->iv, sizeof v->iv);
	166	test_output_memory("in", v->in, v->length);
0e534337	167	testresult = 0;
0f113f3e MC	168	}
0f113f3e MC	169
0e534337 P	170	/* try with in == out */
	171	memcpy(iv, v->iv, sizeof iv);
	172	memcpy(buf, v->in, v->length);
	173	AES_ige_encrypt(buf, buf, v->length, &key, iv, v->encrypt);
	174
	175	if (!TEST_mem_eq(v->out, v->length, buf, v->length)) {
	176	TEST_info("IGE test vector %d failed (with in == out)", n);
37916462 P	177	test_output_memory("key", v->key, sizeof v->key);
	178	test_output_memory("iv", v->iv, sizeof v->iv);
	179	test_output_memory("in", v->in, v->length);
0e534337	180	testresult = 0;
0f113f3e MC	181	}
0f113f3e MC	182
0e534337	183	return testresult;
0f113f3e	184	}
aa6d1a0c	185
0e534337	186	static int test_bi_ige_vectors(int n)
0f113f3e	187	{
0e534337 P	188	const struct bi_ige_test *const v = &bi_ige_test_vectors[n];
0e534337 P	189	AES_KEY key1;
0f113f3e	190	AES_KEY key2;
0e534337	191	unsigned char buf[MAX_VECTOR_SIZE];
0f113f3e	192
0e534337 P	193	if (!TEST_int_le(v->length, MAX_VECTOR_SIZE))
0e534337 P	194	return 0;
0f113f3e	195
0e534337 P	196	if (v->encrypt == AES_ENCRYPT) {
	197	AES_set_encrypt_key(v->key1, 8 * v->keysize, &key1);
	198	AES_set_encrypt_key(v->key2, 8 * v->keysize, &key2);
	199	} else {
	200	AES_set_decrypt_key(v->key1, 8 * v->keysize, &key1);
	201	AES_set_decrypt_key(v->key2, 8 * v->keysize, &key2);
	202	}
0f113f3e	203
0e534337 P	204	AES_bi_ige_encrypt(v->in, buf, v->length, &key1, &key2, v->iv,
0e534337 P	205	v->encrypt);
0f113f3e	206
0e534337	207	if (!TEST_mem_eq(v->out, v->length, buf, v->length)) {
37916462 P	208	test_output_memory("key 1", v->key1, sizeof v->key1);
	209	test_output_memory("key 2", v->key2, sizeof v->key2);
	210	test_output_memory("iv", v->iv, sizeof v->iv);
	211	test_output_memory("in", v->in, v->length);
0e534337 P	212	return 0;
	213	}
	214
	215	return 1;
	216	}
	217
	218	static int test_ige_enc_dec(void)
	219	{
	220	AES_KEY key;
	221	unsigned char iv[AES_BLOCK_SIZE * 4];
	222	unsigned char ciphertext[BIG_TEST_SIZE];
	223	unsigned char checktext[BIG_TEST_SIZE];
	224
	225	memcpy(iv, saved_iv, sizeof iv);
0f113f3e MC	226	AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
	227	AES_ige_encrypt(plaintext, ciphertext, TEST_SIZE, &key, iv, AES_ENCRYPT);
	228
	229	AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
	230	memcpy(iv, saved_iv, sizeof iv);
	231	AES_ige_encrypt(ciphertext, checktext, TEST_SIZE, &key, iv, AES_DECRYPT);
	232
0e534337 P	233	return TEST_mem_eq(checktext, TEST_SIZE, plaintext, TEST_SIZE);
	234	}
	235
	236	static int test_ige_enc_chaining(void)
	237	{
	238	AES_KEY key;
	239	unsigned char iv[AES_BLOCK_SIZE * 4];
	240	unsigned char ciphertext[BIG_TEST_SIZE];
	241	unsigned char checktext[BIG_TEST_SIZE];
0f113f3e	242
0f113f3e MC	243	AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
	244	memcpy(iv, saved_iv, sizeof iv);
	245	AES_ige_encrypt(plaintext, ciphertext, TEST_SIZE / 2, &key, iv,
	246	AES_ENCRYPT);
	247	AES_ige_encrypt(plaintext + TEST_SIZE / 2,
	248	ciphertext + TEST_SIZE / 2, TEST_SIZE / 2,
	249	&key, iv, AES_ENCRYPT);
	250
	251	AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
	252	memcpy(iv, saved_iv, sizeof iv);
	253	AES_ige_encrypt(ciphertext, checktext, TEST_SIZE, &key, iv, AES_DECRYPT);
	254
0e534337 P	255	return TEST_mem_eq(checktext, TEST_SIZE, plaintext, TEST_SIZE);
	256	}
	257
	258	static int test_ige_dec_chaining(void)
	259	{
	260	AES_KEY key;
	261	unsigned char iv[AES_BLOCK_SIZE * 4];
	262	unsigned char ciphertext[BIG_TEST_SIZE];
	263	unsigned char checktext[BIG_TEST_SIZE];
0f113f3e	264
0f113f3e MC	265	AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
	266	memcpy(iv, saved_iv, sizeof iv);
	267	AES_ige_encrypt(plaintext, ciphertext, TEST_SIZE / 2, &key, iv,
	268	AES_ENCRYPT);
	269	AES_ige_encrypt(plaintext + TEST_SIZE / 2,
	270	ciphertext + TEST_SIZE / 2, TEST_SIZE / 2,
	271	&key, iv, AES_ENCRYPT);
	272
	273	AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
	274	memcpy(iv, saved_iv, sizeof iv);
	275	AES_ige_encrypt(ciphertext, checktext, TEST_SIZE / 2, &key, iv,
	276	AES_DECRYPT);
	277	AES_ige_encrypt(ciphertext + TEST_SIZE / 2,
	278	checktext + TEST_SIZE / 2, TEST_SIZE / 2, &key, iv,
	279	AES_DECRYPT);
	280
0e534337 P	281	return TEST_mem_eq(checktext, TEST_SIZE, plaintext, TEST_SIZE);
	282	}
	283
	284	static int test_ige_garble_forwards(void)
	285	{
	286	AES_KEY key;
	287	unsigned char iv[AES_BLOCK_SIZE * 4];
	288	unsigned char ciphertext[BIG_TEST_SIZE];
	289	unsigned char checktext[BIG_TEST_SIZE];
	290	unsigned int n;
	291	int testresult = 1;
	292	const size_t ctsize = sizeof(checktext);
	293	size_t matches;
0f113f3e	294
0f113f3e MC	295	AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
	296	memcpy(iv, saved_iv, sizeof iv);
	297	AES_ige_encrypt(plaintext, ciphertext, sizeof plaintext, &key, iv,
	298	AES_ENCRYPT);
	299
	300	/* corrupt halfway through */
	301	++ciphertext[sizeof ciphertext / 2];
	302	AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
	303	memcpy(iv, saved_iv, sizeof iv);
	304	AES_ige_encrypt(ciphertext, checktext, sizeof checktext, &key, iv,
	305	AES_DECRYPT);
	306
	307	matches = 0;
	308	for (n = 0; n < sizeof checktext; ++n)
	309	if (checktext[n] == plaintext[n])
	310	++matches;
	311
0e534337 P	312	/* Fail if there is more than 51% matching bytes */
	313	if (!TEST_size_t_le(matches, ctsize / 2 + ctsize / 100))
	314	testresult = 0;
0f113f3e	315
0e534337 P	316	/* Fail if the garble goes backwards */
	317	if (!TEST_size_t_gt(matches, ctsize / 2))
	318	testresult = 0;
	319	return testresult;
	320	}
0f113f3e	321
0e534337 P	322	static int test_bi_ige_enc_dec(void)
	323	{
	324	AES_KEY key, key2;
	325	unsigned char iv[AES_BLOCK_SIZE * 4];
	326	unsigned char ciphertext[BIG_TEST_SIZE];
	327	unsigned char checktext[BIG_TEST_SIZE];
0f113f3e	328
0e534337	329	memcpy(iv, saved_iv, sizeof iv);
0f113f3e MC	330	AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
	331	AES_set_encrypt_key(rkey2, 8 * sizeof rkey2, &key2);
	332	AES_bi_ige_encrypt(plaintext, ciphertext, TEST_SIZE, &key, &key2, iv,
	333	AES_ENCRYPT);
	334
	335	AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
	336	AES_set_decrypt_key(rkey2, 8 * sizeof rkey2, &key2);
	337	AES_bi_ige_encrypt(ciphertext, checktext, TEST_SIZE, &key, &key2, iv,
	338	AES_DECRYPT);
	339
0e534337 P	340	return TEST_mem_eq(checktext, TEST_SIZE, plaintext, TEST_SIZE);
	341	}
	342
	343	static int test_bi_ige_garble1(void)
	344	{
	345	AES_KEY key, key2;
	346	unsigned char iv[AES_BLOCK_SIZE * 4];
	347	unsigned char ciphertext[BIG_TEST_SIZE];
	348	unsigned char checktext[BIG_TEST_SIZE];
	349	unsigned int n;
	350	size_t matches;
0f113f3e	351
de6ac50d	352	memcpy(iv, saved_iv, sizeof iv);
0f113f3e MC	353	AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
	354	AES_set_encrypt_key(rkey2, 8 * sizeof rkey2, &key2);
	355	AES_ige_encrypt(plaintext, ciphertext, sizeof plaintext, &key, iv,
	356	AES_ENCRYPT);
	357
	358	/* corrupt halfway through */
	359	++ciphertext[sizeof ciphertext / 2];
	360	AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
	361	AES_set_decrypt_key(rkey2, 8 * sizeof rkey2, &key2);
	362	AES_ige_encrypt(ciphertext, checktext, sizeof checktext, &key, iv,
	363	AES_DECRYPT);
	364
	365	matches = 0;
	366	for (n = 0; n < sizeof checktext; ++n)
	367	if (checktext[n] == plaintext[n])
	368	++matches;
	369
0e534337 P	370	/* Fail if there is more than 1% matching bytes */
	371	return TEST_size_t_le(matches, sizeof checktext / 100);
	372	}
	373
	374	static int test_bi_ige_garble2(void)
	375	{
	376	AES_KEY key, key2;
	377	unsigned char iv[AES_BLOCK_SIZE * 4];
	378	unsigned char ciphertext[BIG_TEST_SIZE];
	379	unsigned char checktext[BIG_TEST_SIZE];
	380	unsigned int n;
	381	size_t matches;
0f113f3e	382
de6ac50d	383	memcpy(iv, saved_iv, sizeof iv);
0f113f3e MC	384	AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
	385	AES_set_encrypt_key(rkey2, 8 * sizeof rkey2, &key2);
	386	AES_ige_encrypt(plaintext, ciphertext, sizeof plaintext, &key, iv,
	387	AES_ENCRYPT);
	388
	389	/* corrupt right at the end */
	390	++ciphertext[sizeof ciphertext - 1];
	391	AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
	392	AES_set_decrypt_key(rkey2, 8 * sizeof rkey2, &key2);
	393	AES_ige_encrypt(ciphertext, checktext, sizeof checktext, &key, iv,
	394	AES_DECRYPT);
	395
	396	matches = 0;
	397	for (n = 0; n < sizeof checktext; ++n)
	398	if (checktext[n] == plaintext[n])
	399	++matches;
	400
0e534337 P	401	/* Fail if there is more than 1% matching bytes */
	402	return TEST_size_t_le(matches, sizeof checktext / 100);
	403	}
	404
	405	static int test_bi_ige_garble3(void)
	406	{
	407	AES_KEY key, key2;
	408	unsigned char iv[AES_BLOCK_SIZE * 4];
	409	unsigned char ciphertext[BIG_TEST_SIZE];
	410	unsigned char checktext[BIG_TEST_SIZE];
	411	unsigned int n;
	412	size_t matches;
0f113f3e	413
de6ac50d	414	memcpy(iv, saved_iv, sizeof iv);
0f113f3e MC	415	AES_set_encrypt_key(rkey, 8 * sizeof rkey, &key);
	416	AES_set_encrypt_key(rkey2, 8 * sizeof rkey2, &key2);
	417	AES_ige_encrypt(plaintext, ciphertext, sizeof plaintext, &key, iv,
	418	AES_ENCRYPT);
	419
	420	/* corrupt right at the start */
	421	++ciphertext[0];
	422	AES_set_decrypt_key(rkey, 8 * sizeof rkey, &key);
	423	AES_set_decrypt_key(rkey2, 8 * sizeof rkey2, &key2);
	424	AES_ige_encrypt(ciphertext, checktext, sizeof checktext, &key, iv,
	425	AES_DECRYPT);
	426
	427	matches = 0;
	428	for (n = 0; n < sizeof checktext; ++n)
	429	if (checktext[n] == plaintext[n])
	430	++matches;
	431
0e534337 P	432	/* Fail if there is more than 1% matching bytes */
	433	return TEST_size_t_le(matches, sizeof checktext / 100);
	434	}
0f113f3e	435
0e534337 P	436	void register_tests(void)
	437	{
	438	RAND_bytes(rkey, sizeof rkey);
	439	RAND_bytes(rkey2, sizeof rkey2);
	440	RAND_bytes(plaintext, sizeof plaintext);
	441	RAND_bytes(saved_iv, sizeof saved_iv);
	442
	443	ADD_TEST(test_ige_enc_dec);
	444	ADD_TEST(test_ige_enc_chaining);
	445	ADD_TEST(test_ige_dec_chaining);
	446	ADD_TEST(test_ige_garble_forwards);
	447	ADD_TEST(test_bi_ige_enc_dec);
	448	ADD_TEST(test_bi_ige_garble1);
	449	ADD_TEST(test_bi_ige_garble2);
	450	ADD_TEST(test_bi_ige_garble3);
	451	ADD_ALL_TESTS(test_ige_vectors, OSSL_NELEM(ige_test_vectors));
	452	ADD_ALL_TESTS(test_bi_ige_vectors, OSSL_NELEM(bi_ige_test_vectors));
0f113f3e	453	}