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