Add a test to verify the ClientHello version is the same in a reneg
[openssl.git] / test / bftest.c
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
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 int 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 }