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