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

/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 *
 * This library is free for commercial and non-commercial use as long as
 * the following conditions are aheared to.  The following conditions
 * apply to all code found in this distribution, be it the RC4, RSA,
 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
 * included with this distribution is covered by the same copyright terms
 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
 *
 * Copyright remains Eric Young's, and as such any Copyright notices in
 * the code are not to be removed.
 * If this package is used in a product, Eric Young should be given attribution
 * as the author of the parts of the library used.
 * This can be in the form of a textual message at program startup or
 * in documentation (online or textual) provided with the package.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *    "This product includes cryptographic software written by
 *     Eric Young (eay@cryptsoft.com)"
 *    The word 'cryptographic' can be left out if the rouines from the library
 *    being used are not cryptographic related :-).
 * 4. If you include any Windows specific code (or a derivative thereof) from
 *    the apps directory (application code) you must include an acknowledgement:
 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
 *
 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * The licence and distribution terms for any publically available version or
 * derivative of this code cannot be changed.  i.e. this code cannot simply be
 * copied and put under another distribution licence
 * [including the GNU Public Licence.]
 */

/*
 * This has been a quickly hacked 'ideatest.c'.  When I add tests for other
 * RC2 modes, more of the code will be uncommented.
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <openssl/opensslconf.h> /* To see if OPENSSL_NO_BF is defined */

#include "../e_os.h"

#ifdef OPENSSL_NO_BF
int main(int argc, char *argv[])
{
    printf("No BF support\n");
    return (0);
}
#else
# include <openssl/blowfish.h>

# ifdef CHARSET_EBCDIC
#  include <openssl/ebcdic.h>
# endif

static char *bf_key[2] = {
    "abcdefghijklmnopqrstuvwxyz",
    "Who is John Galt?"
};

/* big endian */
static BF_LONG bf_plain[2][2] = {
    {0x424c4f57L, 0x46495348L},
    {0xfedcba98L, 0x76543210L}
};

static BF_LONG bf_cipher[2][2] = {
    {0x324ed0feL, 0xf413a203L},
    {0xcc91732bL, 0x8022f684L}
};

/************/

/* Lets use the DES test vectors :-) */
# define NUM_TESTS 34
static unsigned char ecb_data[NUM_TESTS][8] = {
    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
    {0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
    {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
    {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
    {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
    {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10},
    {0x7C, 0xA1, 0x10, 0x45, 0x4A, 0x1A, 0x6E, 0x57},
    {0x01, 0x31, 0xD9, 0x61, 0x9D, 0xC1, 0x37, 0x6E},
    {0x07, 0xA1, 0x13, 0x3E, 0x4A, 0x0B, 0x26, 0x86},
    {0x38, 0x49, 0x67, 0x4C, 0x26, 0x02, 0x31, 0x9E},
    {0x04, 0xB9, 0x15, 0xBA, 0x43, 0xFE, 0xB5, 0xB6},
    {0x01, 0x13, 0xB9, 0x70, 0xFD, 0x34, 0xF2, 0xCE},
    {0x01, 0x70, 0xF1, 0x75, 0x46, 0x8F, 0xB5, 0xE6},
    {0x43, 0x29, 0x7F, 0xAD, 0x38, 0xE3, 0x73, 0xFE},
    {0x07, 0xA7, 0x13, 0x70, 0x45, 0xDA, 0x2A, 0x16},
    {0x04, 0x68, 0x91, 0x04, 0xC2, 0xFD, 0x3B, 0x2F},
    {0x37, 0xD0, 0x6B, 0xB5, 0x16, 0xCB, 0x75, 0x46},
    {0x1F, 0x08, 0x26, 0x0D, 0x1A, 0xC2, 0x46, 0x5E},
    {0x58, 0x40, 0x23, 0x64, 0x1A, 0xBA, 0x61, 0x76},
    {0x02, 0x58, 0x16, 0x16, 0x46, 0x29, 0xB0, 0x07},
    {0x49, 0x79, 0x3E, 0xBC, 0x79, 0xB3, 0x25, 0x8F},
    {0x4F, 0xB0, 0x5E, 0x15, 0x15, 0xAB, 0x73, 0xA7},
    {0x49, 0xE9, 0x5D, 0x6D, 0x4C, 0xA2, 0x29, 0xBF},
    {0x01, 0x83, 0x10, 0xDC, 0x40, 0x9B, 0x26, 0xD6},
    {0x1C, 0x58, 0x7F, 0x1C, 0x13, 0x92, 0x4F, 0xEF},
    {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
    {0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E},
    {0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE},
    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
    {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
    {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}
};

static unsigned char plain_data[NUM_TESTS][8] = {
    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
    {0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
    {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
    {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
    {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
    {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
    {0x01, 0xA1, 0xD6, 0xD0, 0x39, 0x77, 0x67, 0x42},
    {0x5C, 0xD5, 0x4C, 0xA8, 0x3D, 0xEF, 0x57, 0xDA},
    {0x02, 0x48, 0xD4, 0x38, 0x06, 0xF6, 0x71, 0x72},
    {0x51, 0x45, 0x4B, 0x58, 0x2D, 0xDF, 0x44, 0x0A},
    {0x42, 0xFD, 0x44, 0x30, 0x59, 0x57, 0x7F, 0xA2},
    {0x05, 0x9B, 0x5E, 0x08, 0x51, 0xCF, 0x14, 0x3A},
    {0x07, 0x56, 0xD8, 0xE0, 0x77, 0x47, 0x61, 0xD2},
    {0x76, 0x25, 0x14, 0xB8, 0x29, 0xBF, 0x48, 0x6A},
    {0x3B, 0xDD, 0x11, 0x90, 0x49, 0x37, 0x28, 0x02},
    {0x26, 0x95, 0x5F, 0x68, 0x35, 0xAF, 0x60, 0x9A},
    {0x16, 0x4D, 0x5E, 0x40, 0x4F, 0x27, 0x52, 0x32},
    {0x6B, 0x05, 0x6E, 0x18, 0x75, 0x9F, 0x5C, 0xCA},
    {0x00, 0x4B, 0xD6, 0xEF, 0x09, 0x17, 0x60, 0x62},
    {0x48, 0x0D, 0x39, 0x00, 0x6E, 0xE7, 0x62, 0xF2},
    {0x43, 0x75, 0x40, 0xC8, 0x69, 0x8F, 0x3C, 0xFA},
    {0x07, 0x2D, 0x43, 0xA0, 0x77, 0x07, 0x52, 0x92},
    {0x02, 0xFE, 0x55, 0x77, 0x81, 0x17, 0xF1, 0x2A},
    {0x1D, 0x9D, 0x5C, 0x50, 0x18, 0xF7, 0x28, 0xC2},
    {0x30, 0x55, 0x32, 0x28, 0x6D, 0x6F, 0x29, 0x5A},
    {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
    {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
    {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}
};

static unsigned char cipher_data[NUM_TESTS][8] = {
    {0x4E, 0xF9, 0x97, 0x45, 0x61, 0x98, 0xDD, 0x78},
    {0x51, 0x86, 0x6F, 0xD5, 0xB8, 0x5E, 0xCB, 0x8A},
    {0x7D, 0x85, 0x6F, 0x9A, 0x61, 0x30, 0x63, 0xF2},
    {0x24, 0x66, 0xDD, 0x87, 0x8B, 0x96, 0x3C, 0x9D},
    {0x61, 0xF9, 0xC3, 0x80, 0x22, 0x81, 0xB0, 0x96},
    {0x7D, 0x0C, 0xC6, 0x30, 0xAF, 0xDA, 0x1E, 0xC7},
    {0x4E, 0xF9, 0x97, 0x45, 0x61, 0x98, 0xDD, 0x78},
    {0x0A, 0xCE, 0xAB, 0x0F, 0xC6, 0xA0, 0xA2, 0x8D},
    {0x59, 0xC6, 0x82, 0x45, 0xEB, 0x05, 0x28, 0x2B},
    {0xB1, 0xB8, 0xCC, 0x0B, 0x25, 0x0F, 0x09, 0xA0},
    {0x17, 0x30, 0xE5, 0x77, 0x8B, 0xEA, 0x1D, 0xA4},
    {0xA2, 0x5E, 0x78, 0x56, 0xCF, 0x26, 0x51, 0xEB},
    {0x35, 0x38, 0x82, 0xB1, 0x09, 0xCE, 0x8F, 0x1A},
    {0x48, 0xF4, 0xD0, 0x88, 0x4C, 0x37, 0x99, 0x18},
    {0x43, 0x21, 0x93, 0xB7, 0x89, 0x51, 0xFC, 0x98},
    {0x13, 0xF0, 0x41, 0x54, 0xD6, 0x9D, 0x1A, 0xE5},
    {0x2E, 0xED, 0xDA, 0x93, 0xFF, 0xD3, 0x9C, 0x79},
    {0xD8, 0x87, 0xE0, 0x39, 0x3C, 0x2D, 0xA6, 0xE3},
    {0x5F, 0x99, 0xD0, 0x4F, 0x5B, 0x16, 0x39, 0x69},
    {0x4A, 0x05, 0x7A, 0x3B, 0x24, 0xD3, 0x97, 0x7B},
    {0x45, 0x20, 0x31, 0xC1, 0xE4, 0xFA, 0xDA, 0x8E},
    {0x75, 0x55, 0xAE, 0x39, 0xF5, 0x9B, 0x87, 0xBD},
    {0x53, 0xC5, 0x5F, 0x9C, 0xB4, 0x9F, 0xC0, 0x19},
    {0x7A, 0x8E, 0x7B, 0xFA, 0x93, 0x7E, 0x89, 0xA3},
    {0xCF, 0x9C, 0x5D, 0x7A, 0x49, 0x86, 0xAD, 0xB5},
    {0xD1, 0xAB, 0xB2, 0x90, 0x65, 0x8B, 0xC7, 0x78},
    {0x55, 0xCB, 0x37, 0x74, 0xD1, 0x3E, 0xF2, 0x01},
    {0xFA, 0x34, 0xEC, 0x48, 0x47, 0xB2, 0x68, 0xB2},
    {0xA7, 0x90, 0x79, 0x51, 0x08, 0xEA, 0x3C, 0xAE},
    {0xC3, 0x9E, 0x07, 0x2D, 0x9F, 0xAC, 0x63, 0x1D},
    {0x01, 0x49, 0x33, 0xE0, 0xCD, 0xAF, 0xF6, 0xE4},
    {0xF2, 0x1E, 0x9A, 0x77, 0xB7, 0x1C, 0x49, 0xBC},
    {0x24, 0x59, 0x46, 0x88, 0x57, 0x54, 0x36, 0x9A},
    {0x6B, 0x5C, 0x5A, 0x9C, 0x5D, 0x9E, 0x0A, 0x5A},
};

static unsigned char cbc_key[16] = {
    0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
    0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87
};
static unsigned char cbc_iv[8] =
    { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
static char cbc_data[40] = "7654321 Now is the time for ";
static unsigned char cbc_ok[32] = {
    0x6B, 0x77, 0xB4, 0xD6, 0x30, 0x06, 0xDE, 0xE6,
    0x05, 0xB1, 0x56, 0xE2, 0x74, 0x03, 0x97, 0x93,
    0x58, 0xDE, 0xB9, 0xE7, 0x15, 0x46, 0x16, 0xD9,
    0x59, 0xF1, 0x65, 0x2B, 0xD5, 0xFF, 0x92, 0xCC
};

static unsigned char cfb64_ok[] = {
    0xE7, 0x32, 0x14, 0xA2, 0x82, 0x21, 0x39, 0xCA,
    0xF2, 0x6E, 0xCF, 0x6D, 0x2E, 0xB9, 0xE7, 0x6E,
    0x3D, 0xA3, 0xDE, 0x04, 0xD1, 0x51, 0x72, 0x00,
    0x51, 0x9D, 0x57, 0xA6, 0xC3
};

static unsigned char ofb64_ok[] = {
    0xE7, 0x32, 0x14, 0xA2, 0x82, 0x21, 0x39, 0xCA,
    0x62, 0xB3, 0x43, 0xCC, 0x5B, 0x65, 0x58, 0x73,
    0x10, 0xDD, 0x90, 0x8D, 0x0C, 0x24, 0x1B, 0x22,
    0x63, 0xC2, 0xCF, 0x80, 0xDA
};

# define KEY_TEST_NUM    25
static unsigned char key_test[KEY_TEST_NUM] = {
    0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87,
    0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f,
    0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
    0x88
};

static unsigned char key_data[8] =
    { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 };

static unsigned char key_out[KEY_TEST_NUM][8] = {
    {0xF9, 0xAD, 0x59, 0x7C, 0x49, 0xDB, 0x00, 0x5E},
    {0xE9, 0x1D, 0x21, 0xC1, 0xD9, 0x61, 0xA6, 0xD6},
    {0xE9, 0xC2, 0xB7, 0x0A, 0x1B, 0xC6, 0x5C, 0xF3},
    {0xBE, 0x1E, 0x63, 0x94, 0x08, 0x64, 0x0F, 0x05},
    {0xB3, 0x9E, 0x44, 0x48, 0x1B, 0xDB, 0x1E, 0x6E},
    {0x94, 0x57, 0xAA, 0x83, 0xB1, 0x92, 0x8C, 0x0D},
    {0x8B, 0xB7, 0x70, 0x32, 0xF9, 0x60, 0x62, 0x9D},
    {0xE8, 0x7A, 0x24, 0x4E, 0x2C, 0xC8, 0x5E, 0x82},
    {0x15, 0x75, 0x0E, 0x7A, 0x4F, 0x4E, 0xC5, 0x77},
    {0x12, 0x2B, 0xA7, 0x0B, 0x3A, 0xB6, 0x4A, 0xE0},
    {0x3A, 0x83, 0x3C, 0x9A, 0xFF, 0xC5, 0x37, 0xF6},
    {0x94, 0x09, 0xDA, 0x87, 0xA9, 0x0F, 0x6B, 0xF2},
    {0x88, 0x4F, 0x80, 0x62, 0x50, 0x60, 0xB8, 0xB4},
    {0x1F, 0x85, 0x03, 0x1C, 0x19, 0xE1, 0x19, 0x68},
    {0x79, 0xD9, 0x37, 0x3A, 0x71, 0x4C, 0xA3, 0x4F},
    {0x93, 0x14, 0x28, 0x87, 0xEE, 0x3B, 0xE1, 0x5C},
    {0x03, 0x42, 0x9E, 0x83, 0x8C, 0xE2, 0xD1, 0x4B},
    {0xA4, 0x29, 0x9E, 0x27, 0x46, 0x9F, 0xF6, 0x7B},
    {0xAF, 0xD5, 0xAE, 0xD1, 0xC1, 0xBC, 0x96, 0xA8},
    {0x10, 0x85, 0x1C, 0x0E, 0x38, 0x58, 0xDA, 0x9F},
    {0xE6, 0xF5, 0x1E, 0xD7, 0x9B, 0x9D, 0xB2, 0x1F},
    {0x64, 0xA6, 0xE1, 0x4A, 0xFD, 0x36, 0xB4, 0x6F},
    {0x80, 0xC7, 0xD7, 0xD4, 0x5A, 0x54, 0x79, 0xAD},
    {0x05, 0x04, 0x4B, 0x62, 0xFA, 0x52, 0xD0, 0x80},
};

static int test(void);
static int print_test_data(void);
int main(int argc, char *argv[])
{
    int ret;

    if (argc > 1)
        ret = print_test_data();
    else
        ret = test();

# ifdef OPENSSL_SYS_NETWARE
    if (ret)
        printf("ERROR: %d\n", ret);
# endif
    EXIT(ret);
}

static int print_test_data(void)
{
    unsigned int i, j;

    printf("ecb test data\n");
    printf("key bytes\t\tclear bytes\t\tcipher bytes\n");
    for (i = 0; i < NUM_TESTS; i++) {
        for (j = 0; j < 8; j++)
            printf("%02X", ecb_data[i][j]);
        printf("\t");
        for (j = 0; j < 8; j++)
            printf("%02X", plain_data[i][j]);
        printf("\t");
        for (j = 0; j < 8; j++)
            printf("%02X", cipher_data[i][j]);
        printf("\n");
    }

    printf("set_key test data\n");
    printf("data[8]= ");
    for (j = 0; j < 8; j++)
        printf("%02X", key_data[j]);
    printf("\n");
    for (i = 0; i < KEY_TEST_NUM - 1; i++) {
        printf("c=");
        for (j = 0; j < 8; j++)
            printf("%02X", key_out[i][j]);
        printf(" k[%2u]=", i + 1);
        for (j = 0; j < i + 1; j++)
            printf("%02X", key_test[j]);
        printf("\n");
    }

    printf("\nchaining mode test data\n");
    printf("key[16]   = ");
    for (j = 0; j < 16; j++)
        printf("%02X", cbc_key[j]);
    printf("\niv[8]     = ");
    for (j = 0; j < 8; j++)
        printf("%02X", cbc_iv[j]);
    printf("\ndata[%d]  = '%s'", (int)strlen(cbc_data) + 1, cbc_data);
    printf("\ndata[%d]  = ", (int)strlen(cbc_data) + 1);
    for (j = 0; j < strlen(cbc_data) + 1; j++)
        printf("%02X", cbc_data[j]);
    printf("\n");
    printf("cbc cipher text\n");
    printf("cipher[%d]= ", 32);
    for (j = 0; j < 32; j++)
        printf("%02X", cbc_ok[j]);
    printf("\n");

    printf("cfb64 cipher text\n");
    printf("cipher[%d]= ", (int)strlen(cbc_data) + 1);
    for (j = 0; j < strlen(cbc_data) + 1; j++)
        printf("%02X", cfb64_ok[j]);
    printf("\n");

    printf("ofb64 cipher text\n");
    printf("cipher[%d]= ", (int)strlen(cbc_data) + 1);
    for (j = 0; j < strlen(cbc_data) + 1; j++)
        printf("%02X", ofb64_ok[j]);
    printf("\n");
    return (0);
}

static int test(void)
{
    unsigned char cbc_in[40], cbc_out[40], iv[8];
    int i, n, err = 0;
    BF_KEY key;
    BF_LONG data[2];
    unsigned char out[8];
    BF_LONG len;

# ifdef CHARSET_EBCDIC
    ebcdic2ascii(cbc_data, cbc_data, strlen(cbc_data));
# endif

    printf("testing blowfish in raw ecb mode\n");
    for (n = 0; n < 2; n++) {
# ifdef CHARSET_EBCDIC
        ebcdic2ascii(bf_key[n], bf_key[n], strlen(bf_key[n]));
# endif
        BF_set_key(&key, strlen(bf_key[n]), (unsigned char *)bf_key[n]);

        data[0] = bf_plain[n][0];
        data[1] = bf_plain[n][1];
        BF_encrypt(data, &key);
        if (memcmp(&(bf_cipher[n][0]), &(data[0]), 8) != 0) {
            printf("BF_encrypt error encrypting\n");
            printf("got     :");
            for (i = 0; i < 2; i++)
                printf("%08lX ", (unsigned long)data[i]);
            printf("\n");
            printf("expected:");
            for (i = 0; i < 2; i++)
                printf("%08lX ", (unsigned long)bf_cipher[n][i]);
            err = 1;
            printf("\n");
        }

        BF_decrypt(&(data[0]), &key);
        if (memcmp(&(bf_plain[n][0]), &(data[0]), 8) != 0) {
            printf("BF_encrypt error decrypting\n");
            printf("got     :");
            for (i = 0; i < 2; i++)
                printf("%08lX ", (unsigned long)data[i]);
            printf("\n");
            printf("expected:");
            for (i = 0; i < 2; i++)
                printf("%08lX ", (unsigned long)bf_plain[n][i]);
            printf("\n");
            err = 1;
        }
    }

    printf("testing blowfish in ecb mode\n");

    for (n = 0; n < NUM_TESTS; n++) {
        BF_set_key(&key, 8, ecb_data[n]);

        BF_ecb_encrypt(&(plain_data[n][0]), out, &key, BF_ENCRYPT);
        if (memcmp(&(cipher_data[n][0]), out, 8) != 0) {
            printf("BF_ecb_encrypt blowfish 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 ", cipher_data[n][i]);
            err = 1;
            printf("\n");
        }

        BF_ecb_encrypt(out, out, &key, BF_DECRYPT);
        if (memcmp(&(plain_data[n][0]), out, 8) != 0) {
            printf("BF_ecb_encrypt 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 ", plain_data[n][i]);
            printf("\n");
            err = 1;
        }
    }

    printf("testing blowfish set_key\n");
    for (n = 1; n < KEY_TEST_NUM; n++) {
        BF_set_key(&key, n, key_test);
        BF_ecb_encrypt(key_data, out, &key, BF_ENCRYPT);
        /* mips-sgi-irix6.5-gcc  vv  -mabi=64 bug workaround */
        if (memcmp(out, &(key_out[i = n - 1][0]), 8) != 0) {
            printf("blowfish setkey error\n");
            err = 1;
        }
    }

    printf("testing blowfish in cbc mode\n");
    len = strlen(cbc_data) + 1;

    BF_set_key(&key, 16, cbc_key);
    memset(cbc_in, 0, sizeof(cbc_in));
    memset(cbc_out, 0, sizeof(cbc_out));
    memcpy(iv, cbc_iv, sizeof iv);
    BF_cbc_encrypt((unsigned char *)cbc_data, cbc_out, len,
                   &key, iv, BF_ENCRYPT);
    if (memcmp(cbc_out, cbc_ok, 32) != 0) {
        err = 1;
        printf("BF_cbc_encrypt encrypt error\n");
        for (i = 0; i < 32; i++)
            printf("0x%02X,", cbc_out[i]);
    }
    memcpy(iv, cbc_iv, 8);
    BF_cbc_encrypt(cbc_out, cbc_in, len, &key, iv, BF_DECRYPT);
    if (memcmp(cbc_in, cbc_data, strlen(cbc_data) + 1) != 0) {
        printf("BF_cbc_encrypt decrypt error\n");
        err = 1;
    }

    printf("testing blowfish in cfb64 mode\n");

    BF_set_key(&key, 16, cbc_key);
    memset(cbc_in, 0, 40);
    memset(cbc_out, 0, 40);
    memcpy(iv, cbc_iv, 8);
    n = 0;
    BF_cfb64_encrypt((unsigned char *)cbc_data, cbc_out, (long)13,
                     &key, iv, &n, BF_ENCRYPT);
    BF_cfb64_encrypt((unsigned char *)&(cbc_data[13]), &(cbc_out[13]),
                     len - 13, &key, iv, &n, BF_ENCRYPT);
    if (memcmp(cbc_out, cfb64_ok, (int)len) != 0) {
        err = 1;
        printf("BF_cfb64_encrypt encrypt error\n");
        for (i = 0; i < (int)len; i++)
            printf("0x%02X,", cbc_out[i]);
    }
    n = 0;
    memcpy(iv, cbc_iv, 8);
    BF_cfb64_encrypt(cbc_out, cbc_in, 17, &key, iv, &n, BF_DECRYPT);
    BF_cfb64_encrypt(&(cbc_out[17]), &(cbc_in[17]), len - 17,
                     &key, iv, &n, BF_DECRYPT);
    if (memcmp(cbc_in, cbc_data, (int)len) != 0) {
        printf("BF_cfb64_encrypt decrypt error\n");
        err = 1;
    }

    printf("testing blowfish in ofb64\n");

    BF_set_key(&key, 16, cbc_key);
    memset(cbc_in, 0, 40);
    memset(cbc_out, 0, 40);
    memcpy(iv, cbc_iv, 8);
    n = 0;
    BF_ofb64_encrypt((unsigned char *)cbc_data, cbc_out, (long)13, &key, iv,
                     &n);
    BF_ofb64_encrypt((unsigned char *)&(cbc_data[13]), &(cbc_out[13]),
                     len - 13, &key, iv, &n);
    if (memcmp(cbc_out, ofb64_ok, (int)len) != 0) {
        err = 1;
        printf("BF_ofb64_encrypt encrypt error\n");
        for (i = 0; i < (int)len; i++)
            printf("0x%02X,", cbc_out[i]);
    }
    n = 0;
    memcpy(iv, cbc_iv, 8);
    BF_ofb64_encrypt(cbc_out, cbc_in, 17, &key, iv, &n);
    BF_ofb64_encrypt(&(cbc_out[17]), &(cbc_in[17]), len - 17, &key, iv, &n);
    if (memcmp(cbc_in, cbc_data, (int)len) != 0) {
        printf("BF_ofb64_encrypt decrypt error\n");
        err = 1;
    }

    return (err);
}
#endif
Commit	Line	Data
58964a49	1	/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
d02b48c6 RE	2	* All rights reserved.
	3	*
	4	* This package is an SSL implementation written
	5	* by Eric Young (eay@cryptsoft.com).
	6	* The implementation was written so as to conform with Netscapes SSL.
0f113f3e	7	*
d02b48c6 RE	8	* This library is free for commercial and non-commercial use as long as
	9	* the following conditions are aheared to. The following conditions
	10	* apply to all code found in this distribution, be it the RC4, RSA,
	11	* lhash, DES, etc., code; not just the SSL code. The SSL documentation
	12	* included with this distribution is covered by the same copyright terms
	13	* except that the holder is Tim Hudson (tjh@cryptsoft.com).
0f113f3e	14	*
d02b48c6 RE	15	* Copyright remains Eric Young's, and as such any Copyright notices in
	16	* the code are not to be removed.
	17	* If this package is used in a product, Eric Young should be given attribution
	18	* as the author of the parts of the library used.
	19	* This can be in the form of a textual message at program startup or
	20	* in documentation (online or textual) provided with the package.
0f113f3e	21	*
d02b48c6 RE	22	* Redistribution and use in source and binary forms, with or without
	23	* modification, are permitted provided that the following conditions
	24	* are met:
	25	* 1. Redistributions of source code must retain the copyright
	26	* notice, this list of conditions and the following disclaimer.
	27	* 2. Redistributions in binary form must reproduce the above copyright
	28	* notice, this list of conditions and the following disclaimer in the
	29	* documentation and/or other materials provided with the distribution.
	30	* 3. All advertising materials mentioning features or use of this software
	31	* must display the following acknowledgement:
	32	* "This product includes cryptographic software written by
	33	* Eric Young (eay@cryptsoft.com)"
	34	* The word 'cryptographic' can be left out if the rouines from the library
	35	* being used are not cryptographic related :-).
0f113f3e	36	* 4. If you include any Windows specific code (or a derivative thereof) from
d02b48c6 RE	37	* the apps directory (application code) you must include an acknowledgement:
d02b48c6 RE	38	* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
0f113f3e	39	*
d02b48c6 RE	40	* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
	41	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	42	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	43	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
	44	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	45	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	46	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	47	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	48	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	49	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	50	* SUCH DAMAGE.
0f113f3e	51	*
d02b48c6 RE	52	* The licence and distribution terms for any publically available version or
	53	* derivative of this code cannot be changed. i.e. this code cannot simply be
	54	* copied and put under another distribution licence
	55	* [including the GNU Public Licence.]
	56	*/
	57
0f113f3e MC	58	/*
	59	* This has been a quickly hacked 'ideatest.c'. When I add tests for other
	60	* RC2 modes, more of the code will be uncommented.
	61	*/
d02b48c6 RE	62
	63	#include <stdio.h>
	64	#include <string.h>
	65	#include <stdlib.h>
44deca97	66	#include <openssl/opensslconf.h> /* To see if OPENSSL_NO_BF is defined */
f5d7a031	67
55f78baf RL	68	#include "../e_os.h"
55f78baf RL	69
cf1b7d96	70	#ifdef OPENSSL_NO_BF
f5d7a031 UM	71	int main(int argc, char *argv[])
	72	{
	73	printf("No BF support\n");
0f113f3e	74	return (0);
f5d7a031 UM	75	}
f5d7a031 UM	76	#else
0f113f3e	77	# include <openssl/blowfish.h>
d02b48c6	78
0f113f3e MC	79	# ifdef CHARSET_EBCDIC
	80	# include <openssl/ebcdic.h>
	81	# endif
a53955d8	82
0f113f3e MC	83	static char *bf_key[2] = {
	84	"abcdefghijklmnopqrstuvwxyz",
	85	"Who is John Galt?"
	86	};
d02b48c6 RE	87
d02b48c6 RE	88	/* big endian */
0f113f3e MC	89	static BF_LONG bf_plain[2][2] = {
	90	{0x424c4f57L, 0x46495348L},
	91	{0xfedcba98L, 0x76543210L}
	92	};
	93
	94	static BF_LONG bf_cipher[2][2] = {
	95	{0x324ed0feL, 0xf413a203L},
	96	{0xcc91732bL, 0x8022f684L}
	97	};
	98
d02b48c6 RE	99	/************/
	100
	101	/* Lets use the DES test vectors :-) */
0f113f3e MC	102	# define NUM_TESTS 34
	103	static unsigned char ecb_data[NUM_TESTS][8] = {
	104	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
	105	{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
	106	{0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
	107	{0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
	108	{0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
	109	{0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
	110	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
	111	{0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10},
	112	{0x7C, 0xA1, 0x10, 0x45, 0x4A, 0x1A, 0x6E, 0x57},
	113	{0x01, 0x31, 0xD9, 0x61, 0x9D, 0xC1, 0x37, 0x6E},
	114	{0x07, 0xA1, 0x13, 0x3E, 0x4A, 0x0B, 0x26, 0x86},
	115	{0x38, 0x49, 0x67, 0x4C, 0x26, 0x02, 0x31, 0x9E},
	116	{0x04, 0xB9, 0x15, 0xBA, 0x43, 0xFE, 0xB5, 0xB6},
	117	{0x01, 0x13, 0xB9, 0x70, 0xFD, 0x34, 0xF2, 0xCE},
	118	{0x01, 0x70, 0xF1, 0x75, 0x46, 0x8F, 0xB5, 0xE6},
	119	{0x43, 0x29, 0x7F, 0xAD, 0x38, 0xE3, 0x73, 0xFE},
	120	{0x07, 0xA7, 0x13, 0x70, 0x45, 0xDA, 0x2A, 0x16},
	121	{0x04, 0x68, 0x91, 0x04, 0xC2, 0xFD, 0x3B, 0x2F},
	122	{0x37, 0xD0, 0x6B, 0xB5, 0x16, 0xCB, 0x75, 0x46},
	123	{0x1F, 0x08, 0x26, 0x0D, 0x1A, 0xC2, 0x46, 0x5E},
	124	{0x58, 0x40, 0x23, 0x64, 0x1A, 0xBA, 0x61, 0x76},
	125	{0x02, 0x58, 0x16, 0x16, 0x46, 0x29, 0xB0, 0x07},
	126	{0x49, 0x79, 0x3E, 0xBC, 0x79, 0xB3, 0x25, 0x8F},
	127	{0x4F, 0xB0, 0x5E, 0x15, 0x15, 0xAB, 0x73, 0xA7},
	128	{0x49, 0xE9, 0x5D, 0x6D, 0x4C, 0xA2, 0x29, 0xBF},
	129	{0x01, 0x83, 0x10, 0xDC, 0x40, 0x9B, 0x26, 0xD6},
	130	{0x1C, 0x58, 0x7F, 0x1C, 0x13, 0x92, 0x4F, 0xEF},
	131	{0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
	132	{0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E},
	133	{0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE},
	134	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
	135	{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
	136	{0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
	137	{0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}
	138	};
	139
	140	static unsigned char plain_data[NUM_TESTS][8] = {
	141	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
	142	{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
	143	{0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
	144	{0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
	145	{0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
	146	{0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
	147	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
	148	{0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
	149	{0x01, 0xA1, 0xD6, 0xD0, 0x39, 0x77, 0x67, 0x42},
	150	{0x5C, 0xD5, 0x4C, 0xA8, 0x3D, 0xEF, 0x57, 0xDA},
	151	{0x02, 0x48, 0xD4, 0x38, 0x06, 0xF6, 0x71, 0x72},
	152	{0x51, 0x45, 0x4B, 0x58, 0x2D, 0xDF, 0x44, 0x0A},
	153	{0x42, 0xFD, 0x44, 0x30, 0x59, 0x57, 0x7F, 0xA2},
	154	{0x05, 0x9B, 0x5E, 0x08, 0x51, 0xCF, 0x14, 0x3A},
	155	{0x07, 0x56, 0xD8, 0xE0, 0x77, 0x47, 0x61, 0xD2},
	156	{0x76, 0x25, 0x14, 0xB8, 0x29, 0xBF, 0x48, 0x6A},
	157	{0x3B, 0xDD, 0x11, 0x90, 0x49, 0x37, 0x28, 0x02},
	158	{0x26, 0x95, 0x5F, 0x68, 0x35, 0xAF, 0x60, 0x9A},
	159	{0x16, 0x4D, 0x5E, 0x40, 0x4F, 0x27, 0x52, 0x32},
	160	{0x6B, 0x05, 0x6E, 0x18, 0x75, 0x9F, 0x5C, 0xCA},
	161	{0x00, 0x4B, 0xD6, 0xEF, 0x09, 0x17, 0x60, 0x62},
	162	{0x48, 0x0D, 0x39, 0x00, 0x6E, 0xE7, 0x62, 0xF2},
	163	{0x43, 0x75, 0x40, 0xC8, 0x69, 0x8F, 0x3C, 0xFA},
	164	{0x07, 0x2D, 0x43, 0xA0, 0x77, 0x07, 0x52, 0x92},
	165	{0x02, 0xFE, 0x55, 0x77, 0x81, 0x17, 0xF1, 0x2A},
166	{0x1D, 0x9D, 0x5C, 0x50, 0x18, 0xF7, 0x28, 0xC2},
167	{0x30, 0x55, 0x32, 0x28, 0x6D, 0x6F, 0x29, 0x5A},
168	{0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
169	{0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
170	{0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
171	{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
172	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
173	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
174	{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}
175	};
176
177	static unsigned char cipher_data[NUM_TESTS][8] = {
178	{0x4E, 0xF9, 0x97, 0x45, 0x61, 0x98, 0xDD, 0x78},
179	{0x51, 0x86, 0x6F, 0xD5, 0xB8, 0x5E, 0xCB, 0x8A},
180	{0x7D, 0x85, 0x6F, 0x9A, 0x61, 0x30, 0x63, 0xF2},
181	{0x24, 0x66, 0xDD, 0x87, 0x8B, 0x96, 0x3C, 0x9D},
182	{0x61, 0xF9, 0xC3, 0x80, 0x22, 0x81, 0xB0, 0x96},
183	{0x7D, 0x0C, 0xC6, 0x30, 0xAF, 0xDA, 0x1E, 0xC7},
184	{0x4E, 0xF9, 0x97, 0x45, 0x61, 0x98, 0xDD, 0x78},
185	{0x0A, 0xCE, 0xAB, 0x0F, 0xC6, 0xA0, 0xA2, 0x8D},
186	{0x59, 0xC6, 0x82, 0x45, 0xEB, 0x05, 0x28, 0x2B},
187	{0xB1, 0xB8, 0xCC, 0x0B, 0x25, 0x0F, 0x09, 0xA0},
188	{0x17, 0x30, 0xE5, 0x77, 0x8B, 0xEA, 0x1D, 0xA4},
189	{0xA2, 0x5E, 0x78, 0x56, 0xCF, 0x26, 0x51, 0xEB},
190	{0x35, 0x38, 0x82, 0xB1, 0x09, 0xCE, 0x8F, 0x1A},
191	{0x48, 0xF4, 0xD0, 0x88, 0x4C, 0x37, 0x99, 0x18},
192	{0x43, 0x21, 0x93, 0xB7, 0x89, 0x51, 0xFC, 0x98},
193	{0x13, 0xF0, 0x41, 0x54, 0xD6, 0x9D, 0x1A, 0xE5},
194	{0x2E, 0xED, 0xDA, 0x93, 0xFF, 0xD3, 0x9C, 0x79},
195	{0xD8, 0x87, 0xE0, 0x39, 0x3C, 0x2D, 0xA6, 0xE3},
196	{0x5F, 0x99, 0xD0, 0x4F, 0x5B, 0x16, 0x39, 0x69},
197	{0x4A, 0x05, 0x7A, 0x3B, 0x24, 0xD3, 0x97, 0x7B},
198	{0x45, 0x20, 0x31, 0xC1, 0xE4, 0xFA, 0xDA, 0x8E},
199	{0x75, 0x55, 0xAE, 0x39, 0xF5, 0x9B, 0x87, 0xBD},
200	{0x53, 0xC5, 0x5F, 0x9C, 0xB4, 0x9F, 0xC0, 0x19},
201	{0x7A, 0x8E, 0x7B, 0xFA, 0x93, 0x7E, 0x89, 0xA3},
202	{0xCF, 0x9C, 0x5D, 0x7A, 0x49, 0x86, 0xAD, 0xB5},
203	{0xD1, 0xAB, 0xB2, 0x90, 0x65, 0x8B, 0xC7, 0x78},
204	{0x55, 0xCB, 0x37, 0x74, 0xD1, 0x3E, 0xF2, 0x01},
205	{0xFA, 0x34, 0xEC, 0x48, 0x47, 0xB2, 0x68, 0xB2},
206	{0xA7, 0x90, 0x79, 0x51, 0x08, 0xEA, 0x3C, 0xAE},
207	{0xC3, 0x9E, 0x07, 0x2D, 0x9F, 0xAC, 0x63, 0x1D},
208	{0x01, 0x49, 0x33, 0xE0, 0xCD, 0xAF, 0xF6, 0xE4},
209	{0xF2, 0x1E, 0x9A, 0x77, 0xB7, 0x1C, 0x49, 0xBC},
210	{0x24, 0x59, 0x46, 0x88, 0x57, 0x54, 0x36, 0x9A},
211	{0x6B, 0x5C, 0x5A, 0x9C, 0x5D, 0x9E, 0x0A, 0x5A},
212	};
213
214	static unsigned char cbc_key[16] = {
215	0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
216	0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87
217	};
218	static unsigned char cbc_iv[8] =
219	{ 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
220	static char cbc_data[40] = "7654321 Now is the time for ";
221	static unsigned char cbc_ok[32] = {
222	0x6B, 0x77, 0xB4, 0xD6, 0x30, 0x06, 0xDE, 0xE6,
223	0x05, 0xB1, 0x56, 0xE2, 0x74, 0x03, 0x97, 0x93,
224	0x58, 0xDE, 0xB9, 0xE7, 0x15, 0x46, 0x16, 0xD9,
225	0x59, 0xF1, 0x65, 0x2B, 0xD5, 0xFF, 0x92, 0xCC
226	};
227
228	static unsigned char cfb64_ok[] = {
229	0xE7, 0x32, 0x14, 0xA2, 0x82, 0x21, 0x39, 0xCA,
230	0xF2, 0x6E, 0xCF, 0x6D, 0x2E, 0xB9, 0xE7, 0x6E,
231	0x3D, 0xA3, 0xDE, 0x04, 0xD1, 0x51, 0x72, 0x00,
232	0x51, 0x9D, 0x57, 0xA6, 0xC3
233	};
234
235	static unsigned char ofb64_ok[] = {
236	0xE7, 0x32, 0x14, 0xA2, 0x82, 0x21, 0x39, 0xCA,
237	0x62, 0xB3, 0x43, 0xCC, 0x5B, 0x65, 0x58, 0x73,
238	0x10, 0xDD, 0x90, 0x8D, 0x0C, 0x24, 0x1B, 0x22,
239	0x63, 0xC2, 0xCF, 0x80, 0xDA
240	};
241
242	# define KEY_TEST_NUM 25
243	static unsigned char key_test[KEY_TEST_NUM] = {
244	0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87,
245	0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f,
246	0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
247	0x88
248	};
249
250	static unsigned char key_data[8] =
251	{ 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 };
252
253	static unsigned char key_out[KEY_TEST_NUM][8] = {
254	{0xF9, 0xAD, 0x59, 0x7C, 0x49, 0xDB, 0x00, 0x5E},
255	{0xE9, 0x1D, 0x21, 0xC1, 0xD9, 0x61, 0xA6, 0xD6},
256	{0xE9, 0xC2, 0xB7, 0x0A, 0x1B, 0xC6, 0x5C, 0xF3},
257	{0xBE, 0x1E, 0x63, 0x94, 0x08, 0x64, 0x0F, 0x05},
258	{0xB3, 0x9E, 0x44, 0x48, 0x1B, 0xDB, 0x1E, 0x6E},
259	{0x94, 0x57, 0xAA, 0x83, 0xB1, 0x92, 0x8C, 0x0D},
260	{0x8B, 0xB7, 0x70, 0x32, 0xF9, 0x60, 0x62, 0x9D},
261	{0xE8, 0x7A, 0x24, 0x4E, 0x2C, 0xC8, 0x5E, 0x82},
262	{0x15, 0x75, 0x0E, 0x7A, 0x4F, 0x4E, 0xC5, 0x77},
263	{0x12, 0x2B, 0xA7, 0x0B, 0x3A, 0xB6, 0x4A, 0xE0},
264	{0x3A, 0x83, 0x3C, 0x9A, 0xFF, 0xC5, 0x37, 0xF6},
265	{0x94, 0x09, 0xDA, 0x87, 0xA9, 0x0F, 0x6B, 0xF2},
266	{0x88, 0x4F, 0x80, 0x62, 0x50, 0x60, 0xB8, 0xB4},
267	{0x1F, 0x85, 0x03, 0x1C, 0x19, 0xE1, 0x19, 0x68},
268	{0x79, 0xD9, 0x37, 0x3A, 0x71, 0x4C, 0xA3, 0x4F},
269	{0x93, 0x14, 0x28, 0x87, 0xEE, 0x3B, 0xE1, 0x5C},
270	{0x03, 0x42, 0x9E, 0x83, 0x8C, 0xE2, 0xD1, 0x4B},
271	{0xA4, 0x29, 0x9E, 0x27, 0x46, 0x9F, 0xF6, 0x7B},
272	{0xAF, 0xD5, 0xAE, 0xD1, 0xC1, 0xBC, 0x96, 0xA8},
273	{0x10, 0x85, 0x1C, 0x0E, 0x38, 0x58, 0xDA, 0x9F},
274	{0xE6, 0xF5, 0x1E, 0xD7, 0x9B, 0x9D, 0xB2, 0x1F},
275	{0x64, 0xA6, 0xE1, 0x4A, 0xFD, 0x36, 0xB4, 0x6F},
276	{0x80, 0xC7, 0xD7, 0xD4, 0x5A, 0x54, 0x79, 0xAD},
277	{0x05, 0x04, 0x4B, 0x62, 0xFA, 0x52, 0xD0, 0x80},
278	};
279
280	static int test(void);
281	static int print_test_data(void);
6b691a5c	282	int main(int argc, char *argv[])
0f113f3e MC	283	{
	284	int ret;
	285
	286	if (argc > 1)
	287	ret = print_test_data();
	288	else
	289	ret = test();
	290
	291	# ifdef OPENSSL_SYS_NETWARE
	292	if (ret)
	293	printf("ERROR: %d\n", ret);
	294	# endif
	295	EXIT(ret);
0f113f3e	296	}
d02b48c6	297
6b691a5c	298	static int print_test_data(void)
0f113f3e MC	299	{
	300	unsigned int i, j;
	301
	302	printf("ecb test data\n");
	303	printf("key bytes\t\tclear bytes\t\tcipher bytes\n");
	304	for (i = 0; i < NUM_TESTS; i++) {
	305	for (j = 0; j < 8; j++)
	306	printf("%02X", ecb_data[i][j]);
	307	printf("\t");
	308	for (j = 0; j < 8; j++)
	309	printf("%02X", plain_data[i][j]);
	310	printf("\t");
	311	for (j = 0; j < 8; j++)
	312	printf("%02X", cipher_data[i][j]);
	313	printf("\n");
	314	}
	315
	316	printf("set_key test data\n");
	317	printf("data[8]= ");
	318	for (j = 0; j < 8; j++)
	319	printf("%02X", key_data[j]);
	320	printf("\n");
	321	for (i = 0; i < KEY_TEST_NUM - 1; i++) {
	322	printf("c=");
	323	for (j = 0; j < 8; j++)
	324	printf("%02X", key_out[i][j]);
	325	printf(" k[%2u]=", i + 1);
	326	for (j = 0; j < i + 1; j++)
	327	printf("%02X", key_test[j]);
	328	printf("\n");
	329	}
	330
	331	printf("\nchaining mode test data\n");
	332	printf("key[16] = ");
	333	for (j = 0; j < 16; j++)
	334	printf("%02X", cbc_key[j]);
	335	printf("\niv[8] = ");
	336	for (j = 0; j < 8; j++)
	337	printf("%02X", cbc_iv[j]);
	338	printf("\ndata[%d] = '%s'", (int)strlen(cbc_data) + 1, cbc_data);
	339	printf("\ndata[%d] = ", (int)strlen(cbc_data) + 1);
	340	for (j = 0; j < strlen(cbc_data) + 1; j++)
	341	printf("%02X", cbc_data[j]);
	342	printf("\n");
	343	printf("cbc cipher text\n");
	344	printf("cipher[%d]= ", 32);
	345	for (j = 0; j < 32; j++)
	346	printf("%02X", cbc_ok[j]);
	347	printf("\n");
	348
	349	printf("cfb64 cipher text\n");
	350	printf("cipher[%d]= ", (int)strlen(cbc_data) + 1);
	351	for (j = 0; j < strlen(cbc_data) + 1; j++)
	352	printf("%02X", cfb64_ok[j]);
	353	printf("\n");
	354
	355	printf("ofb64 cipher text\n");
	356	printf("cipher[%d]= ", (int)strlen(cbc_data) + 1);
	357	for (j = 0; j < strlen(cbc_data) + 1; j++)
	358	printf("%02X", ofb64_ok[j]);
	359	printf("\n");
	360	return (0);
	361	}
d02b48c6	362
6b691a5c	363	static int test(void)
0f113f3e MC	364	{
	365	unsigned char cbc_in[40], cbc_out[40], iv[8];
	366	int i, n, err = 0;
	367	BF_KEY key;
	368	BF_LONG data[2];
	369	unsigned char out[8];
	370	BF_LONG len;
	371
	372	# ifdef CHARSET_EBCDIC
	373	ebcdic2ascii(cbc_data, cbc_data, strlen(cbc_data));
	374	# endif
	375
	376	printf("testing blowfish in raw ecb mode\n");
	377	for (n = 0; n < 2; n++) {
	378	# ifdef CHARSET_EBCDIC
	379	ebcdic2ascii(bf_key[n], bf_key[n], strlen(bf_key[n]));
	380	# endif
	381	BF_set_key(&key, strlen(bf_key[n]), (unsigned char *)bf_key[n]);
	382
	383	data[0] = bf_plain[n][0];
	384	data[1] = bf_plain[n][1];
	385	BF_encrypt(data, &key);
	386	if (memcmp(&(bf_cipher[n][0]), &(data[0]), 8) != 0) {
	387	printf("BF_encrypt error encrypting\n");
	388	printf("got :");
	389	for (i = 0; i < 2; i++)
	390	printf("%08lX ", (unsigned long)data[i]);
	391	printf("\n");
	392	printf("expected:");
	393	for (i = 0; i < 2; i++)
	394	printf("%08lX ", (unsigned long)bf_cipher[n][i]);
	395	err = 1;
	396	printf("\n");
	397	}
	398
	399	BF_decrypt(&(data[0]), &key);
	400	if (memcmp(&(bf_plain[n][0]), &(data[0]), 8) != 0) {
	401	printf("BF_encrypt error decrypting\n");
	402	printf("got :");
	403	for (i = 0; i < 2; i++)
	404	printf("%08lX ", (unsigned long)data[i]);
	405	printf("\n");
	406	printf("expected:");
	407	for (i = 0; i < 2; i++)
	408	printf("%08lX ", (unsigned long)bf_plain[n][i]);
	409	printf("\n");
	410	err = 1;
	411	}
	412	}
	413
	414	printf("testing blowfish in ecb mode\n");
	415
	416	for (n = 0; n < NUM_TESTS; n++) {
	417	BF_set_key(&key, 8, ecb_data[n]);
	418
	419	BF_ecb_encrypt(&(plain_data[n][0]), out, &key, BF_ENCRYPT);
	420	if (memcmp(&(cipher_data[n][0]), out, 8) != 0) {
	421	printf("BF_ecb_encrypt blowfish error encrypting\n");
	422	printf("got :");
	423	for (i = 0; i < 8; i++)
	424	printf("%02X ", out[i]);
	425	printf("\n");
	426	printf("expected:");
	427	for (i = 0; i < 8; i++)
428	printf("%02X ", cipher_data[n][i]);
429	err = 1;
430	printf("\n");
431	}
432
433	BF_ecb_encrypt(out, out, &key, BF_DECRYPT);
434	if (memcmp(&(plain_data[n][0]), out, 8) != 0) {
435	printf("BF_ecb_encrypt error decrypting\n");
436	printf("got :");
437	for (i = 0; i < 8; i++)
438	printf("%02X ", out[i]);
439	printf("\n");
440	printf("expected:");
441	for (i = 0; i < 8; i++)
442	printf("%02X ", plain_data[n][i]);
443	printf("\n");
444	err = 1;
445	}
446	}
447
448	printf("testing blowfish set_key\n");
449	for (n = 1; n < KEY_TEST_NUM; n++) {
450	BF_set_key(&key, n, key_test);
451	BF_ecb_encrypt(key_data, out, &key, BF_ENCRYPT);
452	/* mips-sgi-irix6.5-gcc vv -mabi=64 bug workaround */
453	if (memcmp(out, &(key_out[i = n - 1][0]), 8) != 0) {
454	printf("blowfish setkey error\n");
455	err = 1;
456	}
457	}
458
459	printf("testing blowfish in cbc mode\n");
460	len = strlen(cbc_data) + 1;
461
462	BF_set_key(&key, 16, cbc_key);
16f8d4eb RS	463	memset(cbc_in, 0, sizeof(cbc_in));
16f8d4eb RS	464	memset(cbc_out, 0, sizeof(cbc_out));
0f113f3e MC	465	memcpy(iv, cbc_iv, sizeof iv);
	466	BF_cbc_encrypt((unsigned char *)cbc_data, cbc_out, len,
	467	&key, iv, BF_ENCRYPT);
	468	if (memcmp(cbc_out, cbc_ok, 32) != 0) {
	469	err = 1;
	470	printf("BF_cbc_encrypt encrypt error\n");
	471	for (i = 0; i < 32; i++)
	472	printf("0x%02X,", cbc_out[i]);
	473	}
	474	memcpy(iv, cbc_iv, 8);
	475	BF_cbc_encrypt(cbc_out, cbc_in, len, &key, iv, BF_DECRYPT);
	476	if (memcmp(cbc_in, cbc_data, strlen(cbc_data) + 1) != 0) {
	477	printf("BF_cbc_encrypt decrypt error\n");
	478	err = 1;
	479	}
	480
	481	printf("testing blowfish in cfb64 mode\n");
	482
	483	BF_set_key(&key, 16, cbc_key);
	484	memset(cbc_in, 0, 40);
	485	memset(cbc_out, 0, 40);
	486	memcpy(iv, cbc_iv, 8);
	487	n = 0;
	488	BF_cfb64_encrypt((unsigned char *)cbc_data, cbc_out, (long)13,
	489	&key, iv, &n, BF_ENCRYPT);
	490	BF_cfb64_encrypt((unsigned char *)&(cbc_data[13]), &(cbc_out[13]),
	491	len - 13, &key, iv, &n, BF_ENCRYPT);
	492	if (memcmp(cbc_out, cfb64_ok, (int)len) != 0) {
	493	err = 1;
	494	printf("BF_cfb64_encrypt encrypt error\n");
	495	for (i = 0; i < (int)len; i++)
	496	printf("0x%02X,", cbc_out[i]);
	497	}
	498	n = 0;
	499	memcpy(iv, cbc_iv, 8);
	500	BF_cfb64_encrypt(cbc_out, cbc_in, 17, &key, iv, &n, BF_DECRYPT);
	501	BF_cfb64_encrypt(&(cbc_out[17]), &(cbc_in[17]), len - 17,
	502	&key, iv, &n, BF_DECRYPT);
	503	if (memcmp(cbc_in, cbc_data, (int)len) != 0) {
	504	printf("BF_cfb64_encrypt decrypt error\n");
	505	err = 1;
	506	}
	507
	508	printf("testing blowfish in ofb64\n");
	509
	510	BF_set_key(&key, 16, cbc_key);
	511	memset(cbc_in, 0, 40);
	512	memset(cbc_out, 0, 40);
	513	memcpy(iv, cbc_iv, 8);
	514	n = 0;
	515	BF_ofb64_encrypt((unsigned char *)cbc_data, cbc_out, (long)13, &key, iv,
	516	&n);
	517	BF_ofb64_encrypt((unsigned char *)&(cbc_data[13]), &(cbc_out[13]),
	518	len - 13, &key, iv, &n);
	519	if (memcmp(cbc_out, ofb64_ok, (int)len) != 0) {
	520	err = 1;
	521	printf("BF_ofb64_encrypt encrypt error\n");
	522	for (i = 0; i < (int)len; i++)
	523	printf("0x%02X,", cbc_out[i]);
	524	}
	525	n = 0;
	526	memcpy(iv, cbc_iv, 8);
	527	BF_ofb64_encrypt(cbc_out, cbc_in, 17, &key, iv, &n);
	528	BF_ofb64_encrypt(&(cbc_out[17]), &(cbc_in[17]), len - 17, &key, iv, &n);
529	if (memcmp(cbc_in, cbc_data, (int)len) != 0) {
530	printf("BF_ofb64_encrypt decrypt error\n");
531	err = 1;
532	}
533
534	return (err);
535	}
f5d7a031	536	#endif