Commit deeac6c3 authored by Pauli's avatar Pauli Committed by Matt Caswell
Browse files

Update ideatest to use the test infrastructure 



Reviewed-by: default avatarRich Salz <rsalz@openssl.org>
Reviewed-by: default avatarMatt Caswell <matt@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/3172)
parent 7635e5bc

test/build.info

+1 −1
Original line number Diff line number Diff line
@@ -71,7 +71,7 @@ IF[{- !$disabled{tests} -}] 
  INCLUDE[pbelutest]=../include

  DEPEND[pbelutest]=../libcrypto



  SOURCE[ideatest]=ideatest.c

  SOURCE[ideatest]=ideatest.c testutil.c test_main.c

  INCLUDE[ideatest]=../include

  DEPEND[ideatest]=../libcrypto

test/ideatest.c

+40 −99
Original line number Diff line number Diff line 
/*

 * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.

 * Copyright 1995-2017 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
@@ -7,19 +7,13 @@ 
 * https://www.openssl.org/source/license.html

 */



#include <stdio.h>

#include <string.h>

#include <stdlib.h>



#include "../e_os.h"

#include "test_main.h"

#include "testutil.h"



#ifdef OPENSSL_NO_IDEA

int main(int argc, char *argv[])

{

    printf("No IDEA support\n");

    return (0);

}

#else

#ifndef OPENSSL_NO_IDEA

# include <openssl/idea.h>



static const unsigned char k[16] = {
@@ -58,121 +52,68 @@ static const unsigned char cfb_cipher64[CFB_TEST_SIZE] = { 
    0x3D,0x1E,0xAE,0x47,0xFC,0xCF,0x29,0x0B,*/

};



static int cfb64_test(const unsigned char *cfb_cipher);

static char *pt(unsigned char *p);

int main(int argc, char *argv[])

static int test_idea_ecb(void)

{

    int i, err = 0;

    IDEA_KEY_SCHEDULE key, dkey;

    unsigned char iv[8];



    IDEA_set_encrypt_key(k, &key);

    IDEA_ecb_encrypt(in, out, &key);

    if (memcmp(out, c, 8) != 0) {

        printf("ecb idea error encrypting\n");

        printf("got     :");

        for (i = 0; i < 8; i++)

            printf("%02X ", out[i]);

        printf("\n");

        printf("expected:");

        for (i = 0; i < 8; i++)

            printf("%02X ", c[i]);

        err = 20;

        printf("\n");

    }

    if (!TEST_mem_eq(out, IDEA_BLOCK, c, sizeof(c)))

        return 0;



    IDEA_set_decrypt_key(&key, &dkey);

    IDEA_ecb_encrypt(c, out, &dkey);

    if (memcmp(out, in, 8) != 0) {

        printf("ecb idea error decrypting\n");

        printf("got     :");

        for (i = 0; i < 8; i++)

            printf("%02X ", out[i]);

        printf("\n");

        printf("expected:");

        for (i = 0; i < 8; i++)

            printf("%02X ", in[i]);

        printf("\n");

        err = 3;

    return TEST_mem_eq(out, IDEA_BLOCK, in, sizeof(in));

}



    if (err == 0)

        printf("ecb idea ok\n");



    memcpy(iv, k, 8);

    IDEA_cbc_encrypt((unsigned char *)text, out, strlen(text) + 1, &key, iv,

                     1);

    memcpy(iv, k, 8);

    IDEA_cbc_encrypt(out, out, 8, &dkey, iv, 0);

    IDEA_cbc_encrypt(&(out[8]), &(out[8]), strlen(text) + 1 - 8, &dkey, iv,

                     0);

    if (memcmp(text, out, strlen(text) + 1) != 0) {

        printf("cbc idea bad\n");

        err = 4;

    } else

        printf("cbc idea ok\n");



    printf("cfb64 idea ");

    if (cfb64_test(cfb_cipher64)) {

        printf("bad\n");

        err = 5;

    } else

        printf("ok\n");



    EXIT(err);

static int test_idea_cbc(void)

{

    IDEA_KEY_SCHEDULE key, dkey;

    unsigned char iv[IDEA_BLOCK];

    const size_t text_len = sizeof(text);



    IDEA_set_encrypt_key(k, &key);

    IDEA_set_decrypt_key(&key, &dkey);

    memcpy(iv, k, sizeof(iv));

    IDEA_cbc_encrypt((unsigned char *)text, out, text_len, &key, iv, 1);

    memcpy(iv, k, sizeof(iv));

    IDEA_cbc_encrypt(out, out, IDEA_BLOCK, &dkey, iv, 0);

    IDEA_cbc_encrypt(&out[8], &out[8], text_len - 8, &dkey, iv, 0);

    return TEST_mem_eq(text, text_len, out, text_len);

}



static int cfb64_test(const unsigned char *cfb_cipher)

static int test_idea_cfb64(void)

{

    IDEA_KEY_SCHEDULE eks, dks;

    int err = 0, i, n;

    int n;



    IDEA_set_encrypt_key(cfb_key, &eks);

    IDEA_set_decrypt_key(&eks, &dks);

    memcpy(cfb_tmp, cfb_iv, 8);

    memcpy(cfb_tmp, cfb_iv, sizeof(cfb_tmp));

    n = 0;

    IDEA_cfb64_encrypt(plain, cfb_buf1, (long)12, &eks,

                       cfb_tmp, &n, IDEA_ENCRYPT);

    IDEA_cfb64_encrypt(&(plain[12]), &(cfb_buf1[12]),

    IDEA_cfb64_encrypt(&plain[12], &cfb_buf1[12],

                       (long)CFB_TEST_SIZE - 12, &eks,

                       cfb_tmp, &n, IDEA_ENCRYPT);

    if (memcmp(cfb_cipher, cfb_buf1, CFB_TEST_SIZE) != 0) {

        err = 1;

        printf("IDEA_cfb64_encrypt encrypt error\n");

        for (i = 0; i < CFB_TEST_SIZE; i += 8)

            printf("%s\n", pt(&(cfb_buf1[i])));

    }

    memcpy(cfb_tmp, cfb_iv, 8);

    if (!TEST_mem_eq(cfb_cipher64, CFB_TEST_SIZE, cfb_buf1, CFB_TEST_SIZE))

        return 0;

    memcpy(cfb_tmp, cfb_iv, sizeof(cfb_tmp));

    n = 0;

    IDEA_cfb64_encrypt(cfb_buf1, cfb_buf2, (long)13, &eks,

                       cfb_tmp, &n, IDEA_DECRYPT);

    IDEA_cfb64_encrypt(&(cfb_buf1[13]), &(cfb_buf2[13]),

    IDEA_cfb64_encrypt(&cfb_buf1[13], &cfb_buf2[13],

                       (long)CFB_TEST_SIZE - 13, &eks,

                       cfb_tmp, &n, IDEA_DECRYPT);

    if (memcmp(plain, cfb_buf2, CFB_TEST_SIZE) != 0) {

        err = 1;

        printf("IDEA_cfb_encrypt decrypt error\n");

        for (i = 0; i < 24; i += 8)

            printf("%s\n", pt(&(cfb_buf2[i])));

    }

    return (err);

    return TEST_mem_eq(plain, CFB_TEST_SIZE, cfb_buf2, CFB_TEST_SIZE);

}

#endif



static char *pt(unsigned char *p)

void register_tests(void)

{

    static char bufs[10][20];

    static int bnum = 0;

    char *ret;

    int i;

    static char *f = "0123456789ABCDEF";



    ret = &(bufs[bnum++][0]);

    bnum %= 10;

    for (i = 0; i < 8; i++) {

        ret[i * 2] = f[(p[i] >> 4) & 0xf];

        ret[i * 2 + 1] = f[p[i] & 0xf];

    }

    ret[16] = '\0';

    return (ret);

}

#ifndef OPENSSL_NO_IDEA

    ADD_TEST(test_idea_ecb);

    ADD_TEST(test_idea_cbc);

    ADD_TEST(test_idea_cfb64);

#endif

}