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"
24 # include <openssl/blowfish.h>
26 # ifdef CHARSET_EBCDIC
27 # include <openssl/ebcdic.h>
30 static char bf_key[2][30] = {
31 "abcdefghijklmnopqrstuvwxyz",
36 static BF_LONG bf_plain[2][2] = {
37 {0x424c4f57L, 0x46495348L},
38 {0xfedcba98L, 0x76543210L}
41 static BF_LONG bf_cipher[2][2] = {
42 {0x324ed0feL, 0xf413a203L},
43 {0xcc91732bL, 0x8022f684L}
48 /* Lets use the DES test vectors :-) */
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}
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}
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},
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
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
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
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
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,
197 static unsigned char key_data[8] =
198 { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 };
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},
227 static int print_test_data(void)
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]);
237 for (j = 0; j < 8; j++)
238 printf("%02X", plain_data[i][j]);
240 for (j = 0; j < 8; j++)
241 printf("%02X", cipher_data[i][j]);
245 printf("set_key test data\n");
247 for (j = 0; j < 8; j++)
248 printf("%02X", key_data[j]);
250 for (i = 0; i < KEY_TEST_NUM - 1; i++) {
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]);
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]);
272 printf("cbc cipher text\n");
273 printf("cipher[%d]= ", 32);
274 for (j = 0; j < 32; j++)
275 printf("%02X", cbc_ok[j]);
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]);
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]);
292 static int test_bf_ecb_raw(int n)
298 BF_set_key(&key, strlen(bf_key[n]), (unsigned char *)bf_key[n]);
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))
306 BF_decrypt(&(data[0]), &key);
307 if (!TEST_mem_eq(&(bf_plain[n][0]), BF_BLOCK, &(data[0]), BF_BLOCK))
313 static int test_bf_ecb(int n)
317 unsigned char out[8];
319 BF_set_key(&key, 8, ecb_data[n]);
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))
325 BF_ecb_encrypt(out, out, &key, BF_DECRYPT);
326 if (!TEST_mem_eq(&(plain_data[n][0]), BF_BLOCK, out, BF_BLOCK))
332 static int test_bf_set_key(int n)
336 unsigned char out[8];
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))
347 static int test_bf_cbc(void)
349 unsigned char cbc_in[40], cbc_out[40], iv[8];
354 len = strlen(cbc_data) + 1;
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))
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))
373 static int test_bf_cfb64(void)
375 unsigned char cbc_in[40], cbc_out[40], iv[8];
380 len = strlen(cbc_data) + 1;
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);
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))
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))
405 static int test_bf_ofb64(void)
407 unsigned char cbc_in[40], cbc_out[40], iv[8];
412 len = strlen(cbc_data) + 1;
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);
419 BF_ofb64_encrypt((unsigned char *)cbc_data, cbc_out, (long)13, &key, iv,
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))
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))
437 int setup_tests(void)
439 #ifndef OPENSSL_NO_BF
440 # ifdef CHARSET_EBCDIC
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]));
449 if (test_get_argument(0) != NULL) {
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);