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

/*
 * Copyright 2006-2017 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (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
 */

/* The AES_ige_* functions are deprecated, so we suppress warnings about them */
#define OPENSSL_SUPPRESS_DEPRECATED

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

#ifndef OPENSSL_NO_DEPRECATED_3_0

# 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);
}
#endif

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