test/bftest.c

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