test/bftest.c

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