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 print_test_data(void)
239 printf("ecb test data\n");
240 printf("key bytes\t\tclear bytes\t\tcipher bytes\n");
241 for (i = 0; i < NUM_TESTS; i++) {
242 for (j = 0; j < 8; j++)
243 printf("%02X", ecb_data[i][j]);
245 for (j = 0; j < 8; j++)
246 printf("%02X", plain_data[i][j]);
248 for (j = 0; j < 8; j++)
249 printf("%02X", cipher_data[i][j]);
253 printf("set_key test data\n");
255 for (j = 0; j < 8; j++)
256 printf("%02X", key_data[j]);
258 for (i = 0; i < KEY_TEST_NUM - 1; i++) {
260 for (j = 0; j < 8; j++)
261 printf("%02X", key_out[i][j]);
262 printf(" k[%2u]=", i + 1);
263 for (j = 0; j < i + 1; j++)
264 printf("%02X", key_test[j]);
268 printf("\nchaining mode test data\n");
269 printf("key[16] = ");
270 for (j = 0; j < 16; j++)
271 printf("%02X", cbc_key[j]);
272 printf("\niv[8] = ");
273 for (j = 0; j < 8; j++)
274 printf("%02X", cbc_iv[j]);
275 printf("\ndata[%d] = '%s'", (int)strlen(cbc_data) + 1, cbc_data);
276 printf("\ndata[%d] = ", (int)strlen(cbc_data) + 1);
277 for (j = 0; j < strlen(cbc_data) + 1; j++)
278 printf("%02X", cbc_data[j]);
280 printf("cbc cipher text\n");
281 printf("cipher[%d]= ", 32);
282 for (j = 0; j < 32; j++)
283 printf("%02X", cbc_ok[j]);
286 printf("cfb64 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", cfb64_ok[j]);
292 printf("ofb64 cipher text\n");
293 printf("cipher[%d]= ", (int)strlen(cbc_data) + 1);
294 for (j = 0; j < strlen(cbc_data) + 1; j++)
295 printf("%02X", ofb64_ok[j]);
300 static int test_bf_ecb_raw(int n)
306 BF_set_key(&key, strlen(bf_key[n]), (unsigned char *)bf_key[n]);
308 data[0] = bf_plain[n][0];
309 data[1] = bf_plain[n][1];
310 BF_encrypt(data, &key);
311 if (!TEST_mem_eq(&(bf_cipher[n][0]), BF_BLOCK, &(data[0]), BF_BLOCK))
314 BF_decrypt(&(data[0]), &key);
315 if (!TEST_mem_eq(&(bf_plain[n][0]), BF_BLOCK, &(data[0]), BF_BLOCK))
321 static int test_bf_ecb(int n)
325 unsigned char out[8];
327 BF_set_key(&key, 8, ecb_data[n]);
329 BF_ecb_encrypt(&(plain_data[n][0]), out, &key, BF_ENCRYPT);
330 if (!TEST_mem_eq(&(cipher_data[n][0]), BF_BLOCK, out, BF_BLOCK))
333 BF_ecb_encrypt(out, out, &key, BF_DECRYPT);
334 if (!TEST_mem_eq(&(plain_data[n][0]), BF_BLOCK, out, BF_BLOCK))
340 static int test_bf_set_key(int n)
344 unsigned char out[8];
346 BF_set_key(&key, n+1, key_test);
347 BF_ecb_encrypt(key_data, out, &key, BF_ENCRYPT);
348 /* mips-sgi-irix6.5-gcc vv -mabi=64 bug workaround */
349 if (!TEST_mem_eq(out, 8, &(key_out[n][0]), 8))
355 static int test_bf_cbc(void)
357 unsigned char cbc_in[40], cbc_out[40], iv[8];
362 len = strlen(cbc_data) + 1;
364 BF_set_key(&key, 16, cbc_key);
365 memset(cbc_in, 0, sizeof(cbc_in));
366 memset(cbc_out, 0, sizeof(cbc_out));
367 memcpy(iv, cbc_iv, sizeof iv);
368 BF_cbc_encrypt((unsigned char *)cbc_data, cbc_out, len,
369 &key, iv, BF_ENCRYPT);
370 if (!TEST_mem_eq(cbc_out, 32, cbc_ok, 32))
373 memcpy(iv, cbc_iv, 8);
374 BF_cbc_encrypt(cbc_out, cbc_in, len, &key, iv, BF_DECRYPT);
375 if (!TEST_mem_eq(cbc_in, len, cbc_data, strlen(cbc_data) + 1))
381 static int test_bf_cfb64(void)
383 unsigned char cbc_in[40], cbc_out[40], iv[8];
388 len = 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))
413 static int test_bf_ofb64(void)
415 unsigned char cbc_in[40], cbc_out[40], iv[8];
420 len = strlen(cbc_data) + 1;
422 BF_set_key(&key, 16, cbc_key);
423 memset(cbc_in, 0, 40);
424 memset(cbc_out, 0, 40);
425 memcpy(iv, cbc_iv, 8);
427 BF_ofb64_encrypt((unsigned char *)cbc_data, cbc_out, (long)13, &key, iv,
429 BF_ofb64_encrypt((unsigned char *)&(cbc_data[13]), &(cbc_out[13]),
430 len - 13, &key, iv, &n);
431 if (!TEST_mem_eq(cbc_out, (int)len, ofb64_ok, (int)len))
435 memcpy(iv, cbc_iv, 8);
436 BF_ofb64_encrypt(cbc_out, cbc_in, 17, &key, iv, &n);
437 BF_ofb64_encrypt(&(cbc_out[17]), &(cbc_in[17]), len - 17, &key, iv, &n);
438 if (!TEST_mem_eq(cbc_in, (int)len, cbc_data, (int)len))
444 int test_main(int argc, char *argv[])
447 # ifdef CHARSET_EBCDIC
450 ebcdic2ascii(cbc_data, cbc_data, strlen(cbc_data));
451 for (n = 0; n < 2; n++) {
452 ebcdic2ascii(bf_key[n], bf_key[n], strlen(bf_key[n]));
456 ADD_ALL_TESTS(test_bf_ecb_raw, 2);
457 ADD_ALL_TESTS(test_bf_ecb, NUM_TESTS);
458 ADD_ALL_TESTS(test_bf_set_key, KEY_TEST_NUM-1);
459 ADD_TEST(test_bf_cbc);
460 ADD_TEST(test_bf_cfb64);
461 ADD_TEST(test_bf_ofb64);
464 ret = print_test_data();
466 ret = run_tests(argv[0]);