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