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