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 test_bf(void);
 236
 237 static int print_test_data(void);
 238
 239 int test_main(int argc, char *argv[])
 240 {
 241     int ret;
 242
 243     ADD_TEST(test_bf);
 244
 245     if (argc > 1)
 246         ret = print_test_data();
 247     else
 248         ret = run_tests(argv[0]);
 249
 250     return ret;
 251 }
 252
 253
 254 static int print_test_data(void)
 255 {
 256     unsigned int i, j;
 257
 258     printf("ecb test data\n");
 259     printf("key bytes\t\tclear bytes\t\tcipher bytes\n");
 260     for (i = 0; i < NUM_TESTS; i++) {
 261         for (j = 0; j < 8; j++)
 262             printf("%02X", ecb_data[i][j]);
 263         printf("\t");
 264         for (j = 0; j < 8; j++)
 265             printf("%02X", plain_data[i][j]);
 266         printf("\t");
 267         for (j = 0; j < 8; j++)
 268             printf("%02X", cipher_data[i][j]);
 269         printf("\n");
 270     }
 271
 272     printf("set_key test data\n");
 273     printf("data[8]= ");
 274     for (j = 0; j < 8; j++)
 275         printf("%02X", key_data[j]);
 276     printf("\n");
 277     for (i = 0; i < KEY_TEST_NUM - 1; i++) {
 278         printf("c=");
 279         for (j = 0; j < 8; j++)
 280             printf("%02X", key_out[i][j]);
 281         printf(" k[%2u]=", i + 1);
 282         for (j = 0; j < i + 1; j++)
 283             printf("%02X", key_test[j]);
 284         printf("\n");
 285     }
 286
 287     printf("\nchaining mode test data\n");
 288     printf("key[16]   = ");
 289     for (j = 0; j < 16; j++)
 290         printf("%02X", cbc_key[j]);
 291     printf("\niv[8]     = ");
 292     for (j = 0; j < 8; j++)
 293         printf("%02X", cbc_iv[j]);
 294     printf("\ndata[%d]  = '%s'", (int)strlen(cbc_data) + 1, cbc_data);
 295     printf("\ndata[%d]  = ", (int)strlen(cbc_data) + 1);
 296     for (j = 0; j < strlen(cbc_data) + 1; j++)
 297         printf("%02X", cbc_data[j]);
 298     printf("\n");
 299     printf("cbc cipher text\n");
 300     printf("cipher[%d]= ", 32);
 301     for (j = 0; j < 32; j++)
 302         printf("%02X", cbc_ok[j]);
 303     printf("\n");
 304
 305     printf("cfb64 cipher text\n");
 306     printf("cipher[%d]= ", (int)strlen(cbc_data) + 1);
 307     for (j = 0; j < strlen(cbc_data) + 1; j++)
 308         printf("%02X", cfb64_ok[j]);
 309     printf("\n");
 310
 311     printf("ofb64 cipher text\n");
 312     printf("cipher[%d]= ", (int)strlen(cbc_data) + 1);
 313     for (j = 0; j < strlen(cbc_data) + 1; j++)
 314         printf("%02X", ofb64_ok[j]);
 315     printf("\n");
 316     return (0);
 317 }
 318
 319 static int test_bf(void)
 320 {
 321     unsigned char cbc_in[40], cbc_out[40], iv[8];
 322     int i, n, ret = 1;
 323     BF_KEY key;
 324     BF_LONG data[2];
 325     unsigned char out[8];
 326     BF_LONG len;
 327
 328 # ifdef CHARSET_EBCDIC
 329     ebcdic2ascii(cbc_data, cbc_data, strlen(cbc_data));
 330 # endif
 331
 332     /* Raw ECB Mode */
 333     for (n = 0; n < 2; n++) {
 334 # ifdef CHARSET_EBCDIC
 335         ebcdic2ascii(bf_key[n], bf_key[n], strlen(bf_key[n]));
 336 # endif
 337         BF_set_key(&key, strlen(bf_key[n]), (unsigned char *)bf_key[n]);
 338
 339         data[0] = bf_plain[n][0];
 340         data[1] = bf_plain[n][1];
 341         BF_encrypt(data, &key);
 342         if (!TEST_mem_eq(&(bf_cipher[n][0]), 8, &(data[0]), 8))
 343             ret = 0;
 344
 345         BF_decrypt(&(data[0]), &key);
 346         if (!TEST_mem_eq(&(bf_plain[n][0]), 8, &(data[0]), 8))
 347             ret = 0;
 348     }
 349
 350     /* ECB Mode */
 351     for (n = 0; n < NUM_TESTS; n++) {
 352         BF_set_key(&key, 8, ecb_data[n]);
 353
 354         BF_ecb_encrypt(&(plain_data[n][0]), out, &key, BF_ENCRYPT);
 355         if (!TEST_mem_eq(&(cipher_data[n][0]), 8, out, 8))
 356             ret = 0;
 357
 358         BF_ecb_encrypt(out, out, &key, BF_DECRYPT);
 359         if (!TEST_mem_eq(&(plain_data[n][0]), 8, out, 8))
 360             ret = 0;
 361     }
 362
 363     /* Set key */
 364     for (n = 1; n < KEY_TEST_NUM; n++) {
 365         BF_set_key(&key, n, key_test);
 366         BF_ecb_encrypt(key_data, out, &key, BF_ENCRYPT);
 367         /* mips-sgi-irix6.5-gcc  vv  -mabi=64 bug workaround */
 368         if (!TEST_mem_eq(out, 8, &(key_out[i = n - 1][0]), 8))
 369             ret = 0;
 370     }
 371
 372     /* CBC Mode */
 373     len = strlen(cbc_data) + 1;
 374
 375     BF_set_key(&key, 16, cbc_key);
 376     memset(cbc_in, 0, sizeof(cbc_in));
 377     memset(cbc_out, 0, sizeof(cbc_out));
 378     memcpy(iv, cbc_iv, sizeof iv);
 379     BF_cbc_encrypt((unsigned char *)cbc_data, cbc_out, len,
 380                    &key, iv, BF_ENCRYPT);
 381     if (!TEST_mem_eq(cbc_out, 32, cbc_ok, 32))
 382         ret = 0;
 383
 384     memcpy(iv, cbc_iv, 8);
 385     BF_cbc_encrypt(cbc_out, cbc_in, len, &key, iv, BF_DECRYPT);
 386     if (!TEST_mem_eq(cbc_in, len, cbc_data, strlen(cbc_data) + 1))
 387         ret = 0;
 388
 389     /* CFB64 Mode */
 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     /* OFB64 Mode */
 411     BF_set_key(&key, 16, cbc_key);
 412     memset(cbc_in, 0, 40);
 413     memset(cbc_out, 0, 40);
 414     memcpy(iv, cbc_iv, 8);
 415     n = 0;
 416     BF_ofb64_encrypt((unsigned char *)cbc_data, cbc_out, (long)13, &key, iv,
 417                      &n);
 418     BF_ofb64_encrypt((unsigned char *)&(cbc_data[13]), &(cbc_out[13]),
 419                      len - 13, &key, iv, &n);
 420     if (!TEST_mem_eq(cbc_out, (int)len, ofb64_ok, (int)len))
 421         ret = 0;
 422
 423     n = 0;
 424     memcpy(iv, cbc_iv, 8);
 425     BF_ofb64_encrypt(cbc_out, cbc_in, 17, &key, iv, &n);
 426     BF_ofb64_encrypt(&(cbc_out[17]), &(cbc_in[17]), len - 17, &key, iv, &n);
 427     if (!TEST_mem_eq(cbc_in, (int)len, cbc_data, (int)len))
 428         ret = 0;
 429
 430     return ret;
 431 }
 432 #endif