test/bftest.c

   1 /*
   2  * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 /*
  11  * This has been a quickly hacked 'ideatest.c'.  When I add tests for other
  12  * RC2 modes, more of the code will be uncommented.
  13  */
  14
  15 #include <stdio.h>
  16 #include <string.h>
  17 #include <stdlib.h>
  18 #include <openssl/opensslconf.h> /* To see if OPENSSL_NO_BF is defined */
  19
  20 #include "../e_os.h"
  21
  22 #ifdef OPENSSL_NO_BF
  23 int main(int argc, char *argv[])
  24 {
  25     printf("No BF support\n");
  26     return (0);
  27 }
  28 #else
  29 # include <openssl/blowfish.h>
  30
  31 # ifdef CHARSET_EBCDIC
  32 #  include <openssl/ebcdic.h>
  33 # endif
  34
  35 static char bf_key[2][30] = {
  36     "abcdefghijklmnopqrstuvwxyz",
  37     "Who is John Galt?"
  38 };
  39
  40 /* big endian */
  41 static BF_LONG bf_plain[2][2] = {
  42     {0x424c4f57L, 0x46495348L},
  43     {0xfedcba98L, 0x76543210L}
  44 };
  45
  46 static BF_LONG bf_cipher[2][2] = {
  47     {0x324ed0feL, 0xf413a203L},
  48     {0xcc91732bL, 0x8022f684L}
  49 };
  50
  51 /************/
  52
  53 /* Lets use the DES test vectors :-) */
  54 # define NUM_TESTS 34
  55 static unsigned char ecb_data[NUM_TESTS][8] = {
  56     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
  57     {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
  58     {0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
  59     {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
  60     {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
  61     {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
  62     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
  63     {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10},
  64     {0x7C, 0xA1, 0x10, 0x45, 0x4A, 0x1A, 0x6E, 0x57},
  65     {0x01, 0x31, 0xD9, 0x61, 0x9D, 0xC1, 0x37, 0x6E},
  66     {0x07, 0xA1, 0x13, 0x3E, 0x4A, 0x0B, 0x26, 0x86},
  67     {0x38, 0x49, 0x67, 0x4C, 0x26, 0x02, 0x31, 0x9E},
  68     {0x04, 0xB9, 0x15, 0xBA, 0x43, 0xFE, 0xB5, 0xB6},
  69     {0x01, 0x13, 0xB9, 0x70, 0xFD, 0x34, 0xF2, 0xCE},
  70     {0x01, 0x70, 0xF1, 0x75, 0x46, 0x8F, 0xB5, 0xE6},
  71     {0x43, 0x29, 0x7F, 0xAD, 0x38, 0xE3, 0x73, 0xFE},
  72     {0x07, 0xA7, 0x13, 0x70, 0x45, 0xDA, 0x2A, 0x16},
  73     {0x04, 0x68, 0x91, 0x04, 0xC2, 0xFD, 0x3B, 0x2F},
  74     {0x37, 0xD0, 0x6B, 0xB5, 0x16, 0xCB, 0x75, 0x46},
  75     {0x1F, 0x08, 0x26, 0x0D, 0x1A, 0xC2, 0x46, 0x5E},
  76     {0x58, 0x40, 0x23, 0x64, 0x1A, 0xBA, 0x61, 0x76},
  77     {0x02, 0x58, 0x16, 0x16, 0x46, 0x29, 0xB0, 0x07},
  78     {0x49, 0x79, 0x3E, 0xBC, 0x79, 0xB3, 0x25, 0x8F},
  79     {0x4F, 0xB0, 0x5E, 0x15, 0x15, 0xAB, 0x73, 0xA7},
  80     {0x49, 0xE9, 0x5D, 0x6D, 0x4C, 0xA2, 0x29, 0xBF},
  81     {0x01, 0x83, 0x10, 0xDC, 0x40, 0x9B, 0x26, 0xD6},
  82     {0x1C, 0x58, 0x7F, 0x1C, 0x13, 0x92, 0x4F, 0xEF},
  83     {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
  84     {0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E},
  85     {0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE},
  86     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
  87     {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
  88     {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
  89     {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}
  90 };
  91
  92 static unsigned char plain_data[NUM_TESTS][8] = {
  93     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
  94     {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
  95     {0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
  96     {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
  97     {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
  98     {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
  99     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 100     {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
 101     {0x01, 0xA1, 0xD6, 0xD0, 0x39, 0x77, 0x67, 0x42},
 102     {0x5C, 0xD5, 0x4C, 0xA8, 0x3D, 0xEF, 0x57, 0xDA},
 103     {0x02, 0x48, 0xD4, 0x38, 0x06, 0xF6, 0x71, 0x72},
 104     {0x51, 0x45, 0x4B, 0x58, 0x2D, 0xDF, 0x44, 0x0A},
 105     {0x42, 0xFD, 0x44, 0x30, 0x59, 0x57, 0x7F, 0xA2},
 106     {0x05, 0x9B, 0x5E, 0x08, 0x51, 0xCF, 0x14, 0x3A},
 107     {0x07, 0x56, 0xD8, 0xE0, 0x77, 0x47, 0x61, 0xD2},
 108     {0x76, 0x25, 0x14, 0xB8, 0x29, 0xBF, 0x48, 0x6A},
 109     {0x3B, 0xDD, 0x11, 0x90, 0x49, 0x37, 0x28, 0x02},
 110     {0x26, 0x95, 0x5F, 0x68, 0x35, 0xAF, 0x60, 0x9A},
 111     {0x16, 0x4D, 0x5E, 0x40, 0x4F, 0x27, 0x52, 0x32},
 112     {0x6B, 0x05, 0x6E, 0x18, 0x75, 0x9F, 0x5C, 0xCA},
 113     {0x00, 0x4B, 0xD6, 0xEF, 0x09, 0x17, 0x60, 0x62},
 114     {0x48, 0x0D, 0x39, 0x00, 0x6E, 0xE7, 0x62, 0xF2},
 115     {0x43, 0x75, 0x40, 0xC8, 0x69, 0x8F, 0x3C, 0xFA},
 116     {0x07, 0x2D, 0x43, 0xA0, 0x77, 0x07, 0x52, 0x92},
 117     {0x02, 0xFE, 0x55, 0x77, 0x81, 0x17, 0xF1, 0x2A},
 118     {0x1D, 0x9D, 0x5C, 0x50, 0x18, 0xF7, 0x28, 0xC2},
 119     {0x30, 0x55, 0x32, 0x28, 0x6D, 0x6F, 0x29, 0x5A},
 120     {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
 121     {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
 122     {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
 123     {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
 124     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 125     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 126     {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}
 127 };
 128
 129 static unsigned char cipher_data[NUM_TESTS][8] = {
 130     {0x4E, 0xF9, 0x97, 0x45, 0x61, 0x98, 0xDD, 0x78},
 131     {0x51, 0x86, 0x6F, 0xD5, 0xB8, 0x5E, 0xCB, 0x8A},
 132     {0x7D, 0x85, 0x6F, 0x9A, 0x61, 0x30, 0x63, 0xF2},
 133     {0x24, 0x66, 0xDD, 0x87, 0x8B, 0x96, 0x3C, 0x9D},
 134     {0x61, 0xF9, 0xC3, 0x80, 0x22, 0x81, 0xB0, 0x96},
 135     {0x7D, 0x0C, 0xC6, 0x30, 0xAF, 0xDA, 0x1E, 0xC7},
 136     {0x4E, 0xF9, 0x97, 0x45, 0x61, 0x98, 0xDD, 0x78},
 137     {0x0A, 0xCE, 0xAB, 0x0F, 0xC6, 0xA0, 0xA2, 0x8D},
 138     {0x59, 0xC6, 0x82, 0x45, 0xEB, 0x05, 0x28, 0x2B},
 139     {0xB1, 0xB8, 0xCC, 0x0B, 0x25, 0x0F, 0x09, 0xA0},
 140     {0x17, 0x30, 0xE5, 0x77, 0x8B, 0xEA, 0x1D, 0xA4},
 141     {0xA2, 0x5E, 0x78, 0x56, 0xCF, 0x26, 0x51, 0xEB},
 142     {0x35, 0x38, 0x82, 0xB1, 0x09, 0xCE, 0x8F, 0x1A},
 143     {0x48, 0xF4, 0xD0, 0x88, 0x4C, 0x37, 0x99, 0x18},
 144     {0x43, 0x21, 0x93, 0xB7, 0x89, 0x51, 0xFC, 0x98},
 145     {0x13, 0xF0, 0x41, 0x54, 0xD6, 0x9D, 0x1A, 0xE5},
 146     {0x2E, 0xED, 0xDA, 0x93, 0xFF, 0xD3, 0x9C, 0x79},
 147     {0xD8, 0x87, 0xE0, 0x39, 0x3C, 0x2D, 0xA6, 0xE3},
 148     {0x5F, 0x99, 0xD0, 0x4F, 0x5B, 0x16, 0x39, 0x69},
 149     {0x4A, 0x05, 0x7A, 0x3B, 0x24, 0xD3, 0x97, 0x7B},
 150     {0x45, 0x20, 0x31, 0xC1, 0xE4, 0xFA, 0xDA, 0x8E},
 151     {0x75, 0x55, 0xAE, 0x39, 0xF5, 0x9B, 0x87, 0xBD},
 152     {0x53, 0xC5, 0x5F, 0x9C, 0xB4, 0x9F, 0xC0, 0x19},
 153     {0x7A, 0x8E, 0x7B, 0xFA, 0x93, 0x7E, 0x89, 0xA3},
 154     {0xCF, 0x9C, 0x5D, 0x7A, 0x49, 0x86, 0xAD, 0xB5},
 155     {0xD1, 0xAB, 0xB2, 0x90, 0x65, 0x8B, 0xC7, 0x78},
 156     {0x55, 0xCB, 0x37, 0x74, 0xD1, 0x3E, 0xF2, 0x01},
 157     {0xFA, 0x34, 0xEC, 0x48, 0x47, 0xB2, 0x68, 0xB2},
 158     {0xA7, 0x90, 0x79, 0x51, 0x08, 0xEA, 0x3C, 0xAE},
 159     {0xC3, 0x9E, 0x07, 0x2D, 0x9F, 0xAC, 0x63, 0x1D},
 160     {0x01, 0x49, 0x33, 0xE0, 0xCD, 0xAF, 0xF6, 0xE4},
 161     {0xF2, 0x1E, 0x9A, 0x77, 0xB7, 0x1C, 0x49, 0xBC},
 162     {0x24, 0x59, 0x46, 0x88, 0x57, 0x54, 0x36, 0x9A},
 163     {0x6B, 0x5C, 0x5A, 0x9C, 0x5D, 0x9E, 0x0A, 0x5A},
 164 };
 165
 166 static unsigned char cbc_key[16] = {
 167     0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
 168     0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87
 169 };
 170 static unsigned char cbc_iv[8] =
 171     { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
 172 static char cbc_data[40] = "7654321 Now is the time for ";
 173 static unsigned char cbc_ok[32] = {
 174     0x6B, 0x77, 0xB4, 0xD6, 0x30, 0x06, 0xDE, 0xE6,
 175     0x05, 0xB1, 0x56, 0xE2, 0x74, 0x03, 0x97, 0x93,
 176     0x58, 0xDE, 0xB9, 0xE7, 0x15, 0x46, 0x16, 0xD9,
 177     0x59, 0xF1, 0x65, 0x2B, 0xD5, 0xFF, 0x92, 0xCC
 178 };
 179
 180 static unsigned char cfb64_ok[] = {
 181     0xE7, 0x32, 0x14, 0xA2, 0x82, 0x21, 0x39, 0xCA,
 182     0xF2, 0x6E, 0xCF, 0x6D, 0x2E, 0xB9, 0xE7, 0x6E,
 183     0x3D, 0xA3, 0xDE, 0x04, 0xD1, 0x51, 0x72, 0x00,
 184     0x51, 0x9D, 0x57, 0xA6, 0xC3
 185 };
 186
 187 static unsigned char ofb64_ok[] = {
 188     0xE7, 0x32, 0x14, 0xA2, 0x82, 0x21, 0x39, 0xCA,
 189     0x62, 0xB3, 0x43, 0xCC, 0x5B, 0x65, 0x58, 0x73,
 190     0x10, 0xDD, 0x90, 0x8D, 0x0C, 0x24, 0x1B, 0x22,
 191     0x63, 0xC2, 0xCF, 0x80, 0xDA
 192 };
 193
 194 # define KEY_TEST_NUM    25
 195 static unsigned char key_test[KEY_TEST_NUM] = {
 196     0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87,
 197     0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f,
 198     0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
 199     0x88
 200 };
 201
 202 static unsigned char key_data[8] =
 203     { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 };
 204
 205 static unsigned char key_out[KEY_TEST_NUM][8] = {
 206     {0xF9, 0xAD, 0x59, 0x7C, 0x49, 0xDB, 0x00, 0x5E},
 207     {0xE9, 0x1D, 0x21, 0xC1, 0xD9, 0x61, 0xA6, 0xD6},
 208     {0xE9, 0xC2, 0xB7, 0x0A, 0x1B, 0xC6, 0x5C, 0xF3},
 209     {0xBE, 0x1E, 0x63, 0x94, 0x08, 0x64, 0x0F, 0x05},
 210     {0xB3, 0x9E, 0x44, 0x48, 0x1B, 0xDB, 0x1E, 0x6E},
 211     {0x94, 0x57, 0xAA, 0x83, 0xB1, 0x92, 0x8C, 0x0D},
 212     {0x8B, 0xB7, 0x70, 0x32, 0xF9, 0x60, 0x62, 0x9D},
 213     {0xE8, 0x7A, 0x24, 0x4E, 0x2C, 0xC8, 0x5E, 0x82},
 214     {0x15, 0x75, 0x0E, 0x7A, 0x4F, 0x4E, 0xC5, 0x77},
 215     {0x12, 0x2B, 0xA7, 0x0B, 0x3A, 0xB6, 0x4A, 0xE0},
 216     {0x3A, 0x83, 0x3C, 0x9A, 0xFF, 0xC5, 0x37, 0xF6},
 217     {0x94, 0x09, 0xDA, 0x87, 0xA9, 0x0F, 0x6B, 0xF2},
 218     {0x88, 0x4F, 0x80, 0x62, 0x50, 0x60, 0xB8, 0xB4},
 219     {0x1F, 0x85, 0x03, 0x1C, 0x19, 0xE1, 0x19, 0x68},
 220     {0x79, 0xD9, 0x37, 0x3A, 0x71, 0x4C, 0xA3, 0x4F},
 221     {0x93, 0x14, 0x28, 0x87, 0xEE, 0x3B, 0xE1, 0x5C},
 222     {0x03, 0x42, 0x9E, 0x83, 0x8C, 0xE2, 0xD1, 0x4B},
 223     {0xA4, 0x29, 0x9E, 0x27, 0x46, 0x9F, 0xF6, 0x7B},
 224     {0xAF, 0xD5, 0xAE, 0xD1, 0xC1, 0xBC, 0x96, 0xA8},
 225     {0x10, 0x85, 0x1C, 0x0E, 0x38, 0x58, 0xDA, 0x9F},
 226     {0xE6, 0xF5, 0x1E, 0xD7, 0x9B, 0x9D, 0xB2, 0x1F},
 227     {0x64, 0xA6, 0xE1, 0x4A, 0xFD, 0x36, 0xB4, 0x6F},
 228     {0x80, 0xC7, 0xD7, 0xD4, 0x5A, 0x54, 0x79, 0xAD},
 229     {0x05, 0x04, 0x4B, 0x62, 0xFA, 0x52, 0xD0, 0x80},
 230 };
 231
 232 static int test(void);
 233 static int print_test_data(void);
 234 int main(int argc, char *argv[])
 235 {
 236     int ret;
 237
 238     if (argc > 1)
 239         ret = print_test_data();
 240     else
 241         ret = test();
 242
 243     EXIT(ret);
 244 }
 245
 246 static int print_test_data(void)
 247 {
 248     unsigned int i, j;
 249
 250     printf("ecb test data\n");
 251     printf("key bytes\t\tclear bytes\t\tcipher bytes\n");
 252     for (i = 0; i < NUM_TESTS; i++) {
 253         for (j = 0; j < 8; j++)
 254             printf("%02X", ecb_data[i][j]);
 255         printf("\t");
 256         for (j = 0; j < 8; j++)
 257             printf("%02X", plain_data[i][j]);
 258         printf("\t");
 259         for (j = 0; j < 8; j++)
 260             printf("%02X", cipher_data[i][j]);
 261         printf("\n");
 262     }
 263
 264     printf("set_key test data\n");
 265     printf("data[8]= ");
 266     for (j = 0; j < 8; j++)
 267         printf("%02X", key_data[j]);
 268     printf("\n");
 269     for (i = 0; i < KEY_TEST_NUM - 1; i++) {
 270         printf("c=");
 271         for (j = 0; j < 8; j++)
 272             printf("%02X", key_out[i][j]);
 273         printf(" k[%2u]=", i + 1);
 274         for (j = 0; j < i + 1; j++)
 275             printf("%02X", key_test[j]);
 276         printf("\n");
 277     }
 278
 279     printf("\nchaining mode test data\n");
 280     printf("key[16]   = ");
 281     for (j = 0; j < 16; j++)
 282         printf("%02X", cbc_key[j]);
 283     printf("\niv[8]     = ");
 284     for (j = 0; j < 8; j++)
 285         printf("%02X", cbc_iv[j]);
 286     printf("\ndata[%d]  = '%s'", (int)strlen(cbc_data) + 1, cbc_data);
 287     printf("\ndata[%d]  = ", (int)strlen(cbc_data) + 1);
 288     for (j = 0; j < strlen(cbc_data) + 1; j++)
 289         printf("%02X", cbc_data[j]);
 290     printf("\n");
 291     printf("cbc cipher text\n");
 292     printf("cipher[%d]= ", 32);
 293     for (j = 0; j < 32; j++)
 294         printf("%02X", cbc_ok[j]);
 295     printf("\n");
 296
 297     printf("cfb64 cipher text\n");
 298     printf("cipher[%d]= ", (int)strlen(cbc_data) + 1);
 299     for (j = 0; j < strlen(cbc_data) + 1; j++)
 300         printf("%02X", cfb64_ok[j]);
 301     printf("\n");
 302
 303     printf("ofb64 cipher text\n");
 304     printf("cipher[%d]= ", (int)strlen(cbc_data) + 1);
 305     for (j = 0; j < strlen(cbc_data) + 1; j++)
 306         printf("%02X", ofb64_ok[j]);
 307     printf("\n");
 308     return (0);
 309 }
 310
 311 static int test(void)
 312 {
 313     unsigned char cbc_in[40], cbc_out[40], iv[8];
 314     int i, n, err = 0;
 315     BF_KEY key;
 316     BF_LONG data[2];
 317     unsigned char out[8];
 318     BF_LONG len;
 319
 320 # ifdef CHARSET_EBCDIC
 321     ebcdic2ascii(cbc_data, cbc_data, strlen(cbc_data));
 322 # endif
 323
 324     printf("testing blowfish in raw ecb mode\n");
 325     for (n = 0; n < 2; n++) {
 326 # ifdef CHARSET_EBCDIC
 327         ebcdic2ascii(bf_key[n], bf_key[n], strlen(bf_key[n]));
 328 # endif
 329         BF_set_key(&key, strlen(bf_key[n]), (unsigned char *)bf_key[n]);
 330
 331         data[0] = bf_plain[n][0];
 332         data[1] = bf_plain[n][1];
 333         BF_encrypt(data, &key);
 334         if (memcmp(&(bf_cipher[n][0]), &(data[0]), 8) != 0) {
 335             printf("BF_encrypt error encrypting\n");
 336             printf("got     :");
 337             for (i = 0; i < 2; i++)
 338                 printf("%08lX ", (unsigned long)data[i]);
 339             printf("\n");
 340             printf("expected:");
 341             for (i = 0; i < 2; i++)
 342                 printf("%08lX ", (unsigned long)bf_cipher[n][i]);
 343             err = 1;
 344             printf("\n");
 345         }
 346
 347         BF_decrypt(&(data[0]), &key);
 348         if (memcmp(&(bf_plain[n][0]), &(data[0]), 8) != 0) {
 349             printf("BF_encrypt error decrypting\n");
 350             printf("got     :");
 351             for (i = 0; i < 2; i++)
 352                 printf("%08lX ", (unsigned long)data[i]);
 353             printf("\n");
 354             printf("expected:");
 355             for (i = 0; i < 2; i++)
 356                 printf("%08lX ", (unsigned long)bf_plain[n][i]);
 357             printf("\n");
 358             err = 1;
 359         }
 360     }
 361
 362     printf("testing blowfish in ecb mode\n");
 363
 364     for (n = 0; n < NUM_TESTS; n++) {
 365         BF_set_key(&key, 8, ecb_data[n]);
 366
 367         BF_ecb_encrypt(&(plain_data[n][0]), out, &key, BF_ENCRYPT);
 368         if (memcmp(&(cipher_data[n][0]), out, 8) != 0) {
 369             printf("BF_ecb_encrypt blowfish error encrypting\n");
 370             printf("got     :");
 371             for (i = 0; i < 8; i++)
 372                 printf("%02X ", out[i]);
 373             printf("\n");
 374             printf("expected:");
 375             for (i = 0; i < 8; i++)
 376                 printf("%02X ", cipher_data[n][i]);
 377             err = 1;
 378             printf("\n");
 379         }
 380
 381         BF_ecb_encrypt(out, out, &key, BF_DECRYPT);
 382         if (memcmp(&(plain_data[n][0]), out, 8) != 0) {
 383             printf("BF_ecb_encrypt error decrypting\n");
 384             printf("got     :");
 385             for (i = 0; i < 8; i++)
 386                 printf("%02X ", out[i]);
 387             printf("\n");
 388             printf("expected:");
 389             for (i = 0; i < 8; i++)
 390                 printf("%02X ", plain_data[n][i]);
 391             printf("\n");
 392             err = 1;
 393         }
 394     }
 395
 396     printf("testing blowfish set_key\n");
 397     for (n = 1; n < KEY_TEST_NUM; n++) {
 398         BF_set_key(&key, n, key_test);
 399         BF_ecb_encrypt(key_data, out, &key, BF_ENCRYPT);
 400         /* mips-sgi-irix6.5-gcc  vv  -mabi=64 bug workaround */
 401         if (memcmp(out, &(key_out[i = n - 1][0]), 8) != 0) {
 402             printf("blowfish setkey error\n");
 403             err = 1;
 404         }
 405     }
 406
 407     printf("testing blowfish in cbc mode\n");
 408     len = strlen(cbc_data) + 1;
 409
 410     BF_set_key(&key, 16, cbc_key);
 411     memset(cbc_in, 0, sizeof(cbc_in));
 412     memset(cbc_out, 0, sizeof(cbc_out));
 413     memcpy(iv, cbc_iv, sizeof iv);
 414     BF_cbc_encrypt((unsigned char *)cbc_data, cbc_out, len,
 415                    &key, iv, BF_ENCRYPT);
 416     if (memcmp(cbc_out, cbc_ok, 32) != 0) {
 417         err = 1;
 418         printf("BF_cbc_encrypt encrypt error\n");
 419         for (i = 0; i < 32; i++)
 420             printf("0x%02X,", cbc_out[i]);
 421     }
 422     memcpy(iv, cbc_iv, 8);
 423     BF_cbc_encrypt(cbc_out, cbc_in, len, &key, iv, BF_DECRYPT);
 424     if (memcmp(cbc_in, cbc_data, strlen(cbc_data) + 1) != 0) {
 425         printf("BF_cbc_encrypt decrypt error\n");
 426         err = 1;
 427     }
 428
 429     printf("testing blowfish in cfb64 mode\n");
 430
 431     BF_set_key(&key, 16, cbc_key);
 432     memset(cbc_in, 0, 40);
 433     memset(cbc_out, 0, 40);
 434     memcpy(iv, cbc_iv, 8);
 435     n = 0;
 436     BF_cfb64_encrypt((unsigned char *)cbc_data, cbc_out, (long)13,
 437                      &key, iv, &n, BF_ENCRYPT);
 438     BF_cfb64_encrypt((unsigned char *)&(cbc_data[13]), &(cbc_out[13]),
 439                      len - 13, &key, iv, &n, BF_ENCRYPT);
 440     if (memcmp(cbc_out, cfb64_ok, (int)len) != 0) {
 441         err = 1;
 442         printf("BF_cfb64_encrypt encrypt error\n");
 443         for (i = 0; i < (int)len; i++)
 444             printf("0x%02X,", cbc_out[i]);
 445     }
 446     n = 0;
 447     memcpy(iv, cbc_iv, 8);
 448     BF_cfb64_encrypt(cbc_out, cbc_in, 17, &key, iv, &n, BF_DECRYPT);
 449     BF_cfb64_encrypt(&(cbc_out[17]), &(cbc_in[17]), len - 17,
 450                      &key, iv, &n, BF_DECRYPT);
 451     if (memcmp(cbc_in, cbc_data, (int)len) != 0) {
 452         printf("BF_cfb64_encrypt decrypt error\n");
 453         err = 1;
 454     }
 455
 456     printf("testing blowfish in ofb64\n");
 457
 458     BF_set_key(&key, 16, cbc_key);
 459     memset(cbc_in, 0, 40);
 460     memset(cbc_out, 0, 40);
 461     memcpy(iv, cbc_iv, 8);
 462     n = 0;
 463     BF_ofb64_encrypt((unsigned char *)cbc_data, cbc_out, (long)13, &key, iv,
 464                      &n);
 465     BF_ofb64_encrypt((unsigned char *)&(cbc_data[13]), &(cbc_out[13]),
 466                      len - 13, &key, iv, &n);
 467     if (memcmp(cbc_out, ofb64_ok, (int)len) != 0) {
 468         err = 1;
 469         printf("BF_ofb64_encrypt encrypt error\n");
 470         for (i = 0; i < (int)len; i++)
 471             printf("0x%02X,", cbc_out[i]);
 472     }
 473     n = 0;
 474     memcpy(iv, cbc_iv, 8);
 475     BF_ofb64_encrypt(cbc_out, cbc_in, 17, &key, iv, &n);
 476     BF_ofb64_encrypt(&(cbc_out[17]), &(cbc_in[17]), len - 17, &key, iv, &n);
 477     if (memcmp(cbc_in, cbc_data, (int)len) != 0) {
 478         printf("BF_ofb64_encrypt decrypt error\n");
 479         err = 1;
 480     }
 481
 482     return (err);
 483 }
 484 #endif