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
23#ifndef OPENSSL_NO_BF
24# include <openssl/blowfish.h>
25
26# ifdef CHARSET_EBCDIC
27#  include <openssl/ebcdic.h>
28# endif
29
30static char bf_key[2][30] = {
31    "abcdefghijklmnopqrstuvwxyz",
32    "Who is John Galt?"
33};
34
35/* big endian */
36static BF_LONG bf_plain[2][2] = {
37    {0x424c4f57L, 0x46495348L},
38    {0xfedcba98L, 0x76543210L}
39};
40
41static 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
50static 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
87static 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
124static 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
161static unsigned char cbc_key[16] = {
162    0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
163    0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87
164};
165static unsigned char cbc_iv[8] =
166    { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
167static char cbc_data[40] = "7654321 Now is the time for ";
168static 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
175static 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
182static 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
190static 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
197static unsigned char key_data[8] =
198    { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 };
199
200static 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
227static 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
292static 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
313static 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
332static 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
347static 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
373static 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
405static 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
437int setup_tests(void)
438{
439#ifndef OPENSSL_NO_BF
440# ifdef CHARSET_EBCDIC
441    int n;
442
443    ebcdic2ascii(cbc_data, cbc_data, strlen(cbc_data));
444    for (n = 0; n < 2; n++) {
445        ebcdic2ascii(bf_key[n], bf_key[n], strlen(bf_key[n]));
446    }
447# endif
448
449    if (test_get_argument(0) != NULL) {
450        print_test_data();
451    } else {
452        ADD_ALL_TESTS(test_bf_ecb_raw, 2);
453        ADD_ALL_TESTS(test_bf_ecb, NUM_TESTS);
454        ADD_ALL_TESTS(test_bf_set_key, KEY_TEST_NUM-1);
455        ADD_TEST(test_bf_cbc);
456        ADD_TEST(test_bf_cfb64);
457        ADD_TEST(test_bf_ofb64);
458    }
459#endif
460    return 1;
461}
462