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