978fd582b1ac0654bd3c25b98eec6052752fb18f
[openssl.git] / 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