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