crypto/bf/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     return (0);
 298 }
 299
 300 static int print_test_data(void)
 301 {
 302     unsigned int i, j;
 303
 304     printf("ecb test data\n");
 305     printf("key bytes\t\tclear bytes\t\tcipher bytes\n");
 306     for (i = 0; i < NUM_TESTS; i++) {
 307         for (j = 0; j < 8; j++)
 308             printf("%02X", ecb_data[i][j]);
 309         printf("\t");
 310         for (j = 0; j < 8; j++)
 311             printf("%02X", plain_data[i][j]);
 312         printf("\t");
 313         for (j = 0; j < 8; j++)
 314             printf("%02X", cipher_data[i][j]);
 315         printf("\n");
 316     }
 317
 318     printf("set_key test data\n");
 319     printf("data[8]= ");
 320     for (j = 0; j < 8; j++)
 321         printf("%02X", key_data[j]);
 322     printf("\n");
 323     for (i = 0; i < KEY_TEST_NUM - 1; i++) {
 324         printf("c=");
 325         for (j = 0; j < 8; j++)
 326             printf("%02X", key_out[i][j]);
 327         printf(" k[%2u]=", i + 1);
 328         for (j = 0; j < i + 1; j++)
 329             printf("%02X", key_test[j]);
 330         printf("\n");
 331     }
 332
 333     printf("\nchaining mode test data\n");
 334     printf("key[16]   = ");
 335     for (j = 0; j < 16; j++)
 336         printf("%02X", cbc_key[j]);
 337     printf("\niv[8]     = ");
 338     for (j = 0; j < 8; j++)
 339         printf("%02X", cbc_iv[j]);
 340     printf("\ndata[%d]  = '%s'", (int)strlen(cbc_data) + 1, cbc_data);
 341     printf("\ndata[%d]  = ", (int)strlen(cbc_data) + 1);
 342     for (j = 0; j < strlen(cbc_data) + 1; j++)
 343         printf("%02X", cbc_data[j]);
 344     printf("\n");
 345     printf("cbc cipher text\n");
 346     printf("cipher[%d]= ", 32);
 347     for (j = 0; j < 32; j++)
 348         printf("%02X", cbc_ok[j]);
 349     printf("\n");
 350
 351     printf("cfb64 cipher text\n");
 352     printf("cipher[%d]= ", (int)strlen(cbc_data) + 1);
 353     for (j = 0; j < strlen(cbc_data) + 1; j++)
 354         printf("%02X", cfb64_ok[j]);
 355     printf("\n");
 356
 357     printf("ofb64 cipher text\n");
 358     printf("cipher[%d]= ", (int)strlen(cbc_data) + 1);
 359     for (j = 0; j < strlen(cbc_data) + 1; j++)
 360         printf("%02X", ofb64_ok[j]);
 361     printf("\n");
 362     return (0);
 363 }
 364
 365 static int test(void)
 366 {
 367     unsigned char cbc_in[40], cbc_out[40], iv[8];
 368     int i, n, err = 0;
 369     BF_KEY key;
 370     BF_LONG data[2];
 371     unsigned char out[8];
 372     BF_LONG len;
 373
 374 # ifdef CHARSET_EBCDIC
 375     ebcdic2ascii(cbc_data, cbc_data, strlen(cbc_data));
 376 # endif
 377
 378     printf("testing blowfish in raw ecb mode\n");
 379     for (n = 0; n < 2; n++) {
 380 # ifdef CHARSET_EBCDIC
 381         ebcdic2ascii(bf_key[n], bf_key[n], strlen(bf_key[n]));
 382 # endif
 383         BF_set_key(&key, strlen(bf_key[n]), (unsigned char *)bf_key[n]);
 384
 385         data[0] = bf_plain[n][0];
 386         data[1] = bf_plain[n][1];
 387         BF_encrypt(data, &key);
 388         if (memcmp(&(bf_cipher[n][0]), &(data[0]), 8) != 0) {
 389             printf("BF_encrypt error encrypting\n");
 390             printf("got     :");
 391             for (i = 0; i < 2; i++)
 392                 printf("%08lX ", (unsigned long)data[i]);
 393             printf("\n");
 394             printf("expected:");
 395             for (i = 0; i < 2; i++)
 396                 printf("%08lX ", (unsigned long)bf_cipher[n][i]);
 397             err = 1;
 398             printf("\n");
 399         }
 400
 401         BF_decrypt(&(data[0]), &key);
 402         if (memcmp(&(bf_plain[n][0]), &(data[0]), 8) != 0) {
 403             printf("BF_encrypt error decrypting\n");
 404             printf("got     :");
 405             for (i = 0; i < 2; i++)
 406                 printf("%08lX ", (unsigned long)data[i]);
 407             printf("\n");
 408             printf("expected:");
 409             for (i = 0; i < 2; i++)
 410                 printf("%08lX ", (unsigned long)bf_plain[n][i]);
 411             printf("\n");
 412             err = 1;
 413         }
 414     }
 415
 416     printf("testing blowfish in ecb mode\n");
 417
 418     for (n = 0; n < NUM_TESTS; n++) {
 419         BF_set_key(&key, 8, ecb_data[n]);
 420
 421         BF_ecb_encrypt(&(plain_data[n][0]), out, &key, BF_ENCRYPT);
 422         if (memcmp(&(cipher_data[n][0]), out, 8) != 0) {
 423             printf("BF_ecb_encrypt blowfish error encrypting\n");
 424             printf("got     :");
 425             for (i = 0; i < 8; i++)
 426                 printf("%02X ", out[i]);
 427             printf("\n");
 428             printf("expected:");
 429             for (i = 0; i < 8; i++)
 430                 printf("%02X ", cipher_data[n][i]);
 431             err = 1;
 432             printf("\n");
 433         }
 434
 435         BF_ecb_encrypt(out, out, &key, BF_DECRYPT);
 436         if (memcmp(&(plain_data[n][0]), out, 8) != 0) {
 437             printf("BF_ecb_encrypt error decrypting\n");
 438             printf("got     :");
 439             for (i = 0; i < 8; i++)
 440                 printf("%02X ", out[i]);
 441             printf("\n");
 442             printf("expected:");
 443             for (i = 0; i < 8; i++)
 444                 printf("%02X ", plain_data[n][i]);
 445             printf("\n");
 446             err = 1;
 447         }
 448     }
 449
 450     printf("testing blowfish set_key\n");
 451     for (n = 1; n < KEY_TEST_NUM; n++) {
 452         BF_set_key(&key, n, key_test);
 453         BF_ecb_encrypt(key_data, out, &key, BF_ENCRYPT);
 454         /* mips-sgi-irix6.5-gcc  vv  -mabi=64 bug workaround */
 455         if (memcmp(out, &(key_out[i = n - 1][0]), 8) != 0) {
 456             printf("blowfish setkey error\n");
 457             err = 1;
 458         }
 459     }
 460
 461     printf("testing blowfish in cbc mode\n");
 462     len = strlen(cbc_data) + 1;
 463
 464     BF_set_key(&key, 16, cbc_key);
 465     memset(cbc_in, 0, sizeof cbc_in);
 466     memset(cbc_out, 0, sizeof cbc_out);
 467     memcpy(iv, cbc_iv, sizeof iv);
 468     BF_cbc_encrypt((unsigned char *)cbc_data, cbc_out, len,
 469                    &key, iv, BF_ENCRYPT);
 470     if (memcmp(cbc_out, cbc_ok, 32) != 0) {
 471         err = 1;
 472         printf("BF_cbc_encrypt encrypt error\n");
 473         for (i = 0; i < 32; i++)
 474             printf("0x%02X,", cbc_out[i]);
 475     }
 476     memcpy(iv, cbc_iv, 8);
 477     BF_cbc_encrypt(cbc_out, cbc_in, len, &key, iv, BF_DECRYPT);
 478     if (memcmp(cbc_in, cbc_data, strlen(cbc_data) + 1) != 0) {
 479         printf("BF_cbc_encrypt decrypt error\n");
 480         err = 1;
 481     }
 482
 483     printf("testing blowfish in cfb64 mode\n");
 484
 485     BF_set_key(&key, 16, cbc_key);
 486     memset(cbc_in, 0, 40);
 487     memset(cbc_out, 0, 40);
 488     memcpy(iv, cbc_iv, 8);
 489     n = 0;
 490     BF_cfb64_encrypt((unsigned char *)cbc_data, cbc_out, (long)13,
 491                      &key, iv, &n, BF_ENCRYPT);
 492     BF_cfb64_encrypt((unsigned char *)&(cbc_data[13]), &(cbc_out[13]),
 493                      len - 13, &key, iv, &n, BF_ENCRYPT);
 494     if (memcmp(cbc_out, cfb64_ok, (int)len) != 0) {
 495         err = 1;
 496         printf("BF_cfb64_encrypt encrypt error\n");
 497         for (i = 0; i < (int)len; i++)
 498             printf("0x%02X,", cbc_out[i]);
 499     }
 500     n = 0;
 501     memcpy(iv, cbc_iv, 8);
 502     BF_cfb64_encrypt(cbc_out, cbc_in, 17, &key, iv, &n, BF_DECRYPT);
 503     BF_cfb64_encrypt(&(cbc_out[17]), &(cbc_in[17]), len - 17,
 504                      &key, iv, &n, BF_DECRYPT);
 505     if (memcmp(cbc_in, cbc_data, (int)len) != 0) {
 506         printf("BF_cfb64_encrypt decrypt error\n");
 507         err = 1;
 508     }
 509
 510     printf("testing blowfish in ofb64\n");
 511
 512     BF_set_key(&key, 16, cbc_key);
 513     memset(cbc_in, 0, 40);
 514     memset(cbc_out, 0, 40);
 515     memcpy(iv, cbc_iv, 8);
 516     n = 0;
 517     BF_ofb64_encrypt((unsigned char *)cbc_data, cbc_out, (long)13, &key, iv,
 518                      &n);
 519     BF_ofb64_encrypt((unsigned char *)&(cbc_data[13]), &(cbc_out[13]),
 520                      len - 13, &key, iv, &n);
 521     if (memcmp(cbc_out, ofb64_ok, (int)len) != 0) {
 522         err = 1;
 523         printf("BF_ofb64_encrypt encrypt error\n");
 524         for (i = 0; i < (int)len; i++)
 525             printf("0x%02X,", cbc_out[i]);
 526     }
 527     n = 0;
 528     memcpy(iv, cbc_iv, 8);
 529     BF_ofb64_encrypt(cbc_out, cbc_in, 17, &key, iv, &n);
 530     BF_ofb64_encrypt(&(cbc_out[17]), &(cbc_in[17]), len - 17, &key, iv, &n);
 531     if (memcmp(cbc_in, cbc_data, (int)len) != 0) {
 532         printf("BF_ofb64_encrypt decrypt error\n");
 533         err = 1;
 534     }
 535
 536     return (err);
 537 }
 538 #endif