test/bftest.c

   1 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   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.
   7  *
   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).
  14  *
  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.
  21  *
  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 :-).
  36  * 4. If you include any Windows specific code (or a derivative thereof) from
  37  *    the apps directory (application code) you must include an acknowledgement:
  38  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  39  *
  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.
  51  *
  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
  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  */
  62
  63 #include <stdio.h>
  64 #include <string.h>
  65 #include <stdlib.h>
  66 #include <openssl/opensslconf.h> /* To see if OPENSSL_NO_BF is defined */
  67
  68 #include "../e_os.h"
  69
  70 #ifdef OPENSSL_NO_BF
  71 int main(int argc, char *argv[])
  72 {
  73     printf("No BF support\n");
  74     return (0);
  75 }
  76 #else
  77 # include <openssl/blowfish.h>
  78
  79 # ifdef CHARSET_EBCDIC
  80 #  include <openssl/ebcdic.h>
  81 # endif
  82
  83 static char *bf_key[2] = {
  84     "abcdefghijklmnopqrstuvwxyz",
  85     "Who is John Galt?"
  86 };
  87
  88 /* big endian */
  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
  99 /************/
 100
 101 /* Lets use the DES test vectors :-) */
 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);
 282 int main(int argc, char *argv[])
 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);
 296 }
 297
 298 static int print_test_data(void)
 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 }
 362
 363 static int test(void)
 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);
 463     memset(cbc_in, 0, sizeof(cbc_in));
 464     memset(cbc_out, 0, sizeof(cbc_out));
 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 }
 536 #endif