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