2 * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
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
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.
18 #include <openssl/opensslconf.h> /* To see if OPENSSL_NO_BF is defined */
20 #include "test_main_custom.h"
26 int main(int argc, char *argv[])
28 printf("No BF support\n");
32 # include <openssl/blowfish.h>
34 # ifdef CHARSET_EBCDIC
35 # include <openssl/ebcdic.h>
38 static char bf_key[2][30] = {
39 "abcdefghijklmnopqrstuvwxyz",
44 static BF_LONG bf_plain[2][2] = {
45 {0x424c4f57L, 0x46495348L},
46 {0xfedcba98L, 0x76543210L}
49 static BF_LONG bf_cipher[2][2] = {
50 {0x324ed0feL, 0xf413a203L},
51 {0xcc91732bL, 0x8022f684L}
56 /* Lets use the DES test vectors :-) */
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}
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}
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},
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
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
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
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
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,
205 static unsigned char key_data[8] =
206 { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 };
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},
235 static int test_bf(void);
237 static int print_test_data(void);
239 int test_main(int argc, char *argv[])
246 ret = print_test_data();
248 ret = run_tests(argv[0]);
254 static int print_test_data(void)
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]);
264 for (j = 0; j < 8; j++)
265 printf("%02X", plain_data[i][j]);
267 for (j = 0; j < 8; j++)
268 printf("%02X", cipher_data[i][j]);
272 printf("set_key test data\n");
274 for (j = 0; j < 8; j++)
275 printf("%02X", key_data[j]);
277 for (i = 0; i < KEY_TEST_NUM - 1; i++) {
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]);
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]);
299 printf("cbc cipher text\n");
300 printf("cipher[%d]= ", 32);
301 for (j = 0; j < 32; j++)
302 printf("%02X", cbc_ok[j]);
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]);
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]);
319 static int test_bf(void)
321 unsigned char cbc_in[40], cbc_out[40], iv[8];
325 unsigned char out[8];
328 # ifdef CHARSET_EBCDIC
329 ebcdic2ascii(cbc_data, cbc_data, strlen(cbc_data));
333 for (n = 0; n < 2; n++) {
334 # ifdef CHARSET_EBCDIC
335 ebcdic2ascii(bf_key[n], bf_key[n], strlen(bf_key[n]));
337 BF_set_key(&key, strlen(bf_key[n]), (unsigned char *)bf_key[n]);
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))
345 BF_decrypt(&(data[0]), &key);
346 if (!TEST_mem_eq(&(bf_plain[n][0]), 8, &(data[0]), 8))
351 for (n = 0; n < NUM_TESTS; n++) {
352 BF_set_key(&key, 8, ecb_data[n]);
354 BF_ecb_encrypt(&(plain_data[n][0]), out, &key, BF_ENCRYPT);
355 if (!TEST_mem_eq(&(cipher_data[n][0]), 8, out, 8))
358 BF_ecb_encrypt(out, out, &key, BF_DECRYPT);
359 if (!TEST_mem_eq(&(plain_data[n][0]), 8, out, 8))
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))
373 len = strlen(cbc_data) + 1;
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))
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))
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);
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))
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))
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);
416 BF_ofb64_encrypt((unsigned char *)cbc_data, cbc_out, (long)13, &key, iv,
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))
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))