test/bftest.c

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