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 */
23 int main(int argc, char *argv[])
25 printf("No BF support\n");
29 # include <openssl/blowfish.h>
31 # ifdef CHARSET_EBCDIC
32 # include <openssl/ebcdic.h>
35 static char bf_key[2][30] = {
36 "abcdefghijklmnopqrstuvwxyz",
41 static BF_LONG bf_plain[2][2] = {
42 {0x424c4f57L, 0x46495348L},
43 {0xfedcba98L, 0x76543210L}
46 static BF_LONG bf_cipher[2][2] = {
47 {0x324ed0feL, 0xf413a203L},
48 {0xcc91732bL, 0x8022f684L}
53 /* Lets use the DES test vectors :-) */
55 static unsigned char ecb_data[NUM_TESTS][8] = {
56 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
57 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
58 {0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
59 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
60 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
61 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
62 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
63 {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10},
64 {0x7C, 0xA1, 0x10, 0x45, 0x4A, 0x1A, 0x6E, 0x57},
65 {0x01, 0x31, 0xD9, 0x61, 0x9D, 0xC1, 0x37, 0x6E},
66 {0x07, 0xA1, 0x13, 0x3E, 0x4A, 0x0B, 0x26, 0x86},
67 {0x38, 0x49, 0x67, 0x4C, 0x26, 0x02, 0x31, 0x9E},
68 {0x04, 0xB9, 0x15, 0xBA, 0x43, 0xFE, 0xB5, 0xB6},
69 {0x01, 0x13, 0xB9, 0x70, 0xFD, 0x34, 0xF2, 0xCE},
70 {0x01, 0x70, 0xF1, 0x75, 0x46, 0x8F, 0xB5, 0xE6},
71 {0x43, 0x29, 0x7F, 0xAD, 0x38, 0xE3, 0x73, 0xFE},
72 {0x07, 0xA7, 0x13, 0x70, 0x45, 0xDA, 0x2A, 0x16},
73 {0x04, 0x68, 0x91, 0x04, 0xC2, 0xFD, 0x3B, 0x2F},
74 {0x37, 0xD0, 0x6B, 0xB5, 0x16, 0xCB, 0x75, 0x46},
75 {0x1F, 0x08, 0x26, 0x0D, 0x1A, 0xC2, 0x46, 0x5E},
76 {0x58, 0x40, 0x23, 0x64, 0x1A, 0xBA, 0x61, 0x76},
77 {0x02, 0x58, 0x16, 0x16, 0x46, 0x29, 0xB0, 0x07},
78 {0x49, 0x79, 0x3E, 0xBC, 0x79, 0xB3, 0x25, 0x8F},
79 {0x4F, 0xB0, 0x5E, 0x15, 0x15, 0xAB, 0x73, 0xA7},
80 {0x49, 0xE9, 0x5D, 0x6D, 0x4C, 0xA2, 0x29, 0xBF},
81 {0x01, 0x83, 0x10, 0xDC, 0x40, 0x9B, 0x26, 0xD6},
82 {0x1C, 0x58, 0x7F, 0x1C, 0x13, 0x92, 0x4F, 0xEF},
83 {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
84 {0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E},
85 {0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE},
86 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
87 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
88 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
89 {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}
92 static unsigned char plain_data[NUM_TESTS][8] = {
93 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
94 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
95 {0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
96 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
97 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
98 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
99 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
100 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
101 {0x01, 0xA1, 0xD6, 0xD0, 0x39, 0x77, 0x67, 0x42},
102 {0x5C, 0xD5, 0x4C, 0xA8, 0x3D, 0xEF, 0x57, 0xDA},
103 {0x02, 0x48, 0xD4, 0x38, 0x06, 0xF6, 0x71, 0x72},
104 {0x51, 0x45, 0x4B, 0x58, 0x2D, 0xDF, 0x44, 0x0A},
105 {0x42, 0xFD, 0x44, 0x30, 0x59, 0x57, 0x7F, 0xA2},
106 {0x05, 0x9B, 0x5E, 0x08, 0x51, 0xCF, 0x14, 0x3A},
107 {0x07, 0x56, 0xD8, 0xE0, 0x77, 0x47, 0x61, 0xD2},
108 {0x76, 0x25, 0x14, 0xB8, 0x29, 0xBF, 0x48, 0x6A},
109 {0x3B, 0xDD, 0x11, 0x90, 0x49, 0x37, 0x28, 0x02},
110 {0x26, 0x95, 0x5F, 0x68, 0x35, 0xAF, 0x60, 0x9A},
111 {0x16, 0x4D, 0x5E, 0x40, 0x4F, 0x27, 0x52, 0x32},
112 {0x6B, 0x05, 0x6E, 0x18, 0x75, 0x9F, 0x5C, 0xCA},
113 {0x00, 0x4B, 0xD6, 0xEF, 0x09, 0x17, 0x60, 0x62},
114 {0x48, 0x0D, 0x39, 0x00, 0x6E, 0xE7, 0x62, 0xF2},
115 {0x43, 0x75, 0x40, 0xC8, 0x69, 0x8F, 0x3C, 0xFA},
116 {0x07, 0x2D, 0x43, 0xA0, 0x77, 0x07, 0x52, 0x92},
117 {0x02, 0xFE, 0x55, 0x77, 0x81, 0x17, 0xF1, 0x2A},
118 {0x1D, 0x9D, 0x5C, 0x50, 0x18, 0xF7, 0x28, 0xC2},
119 {0x30, 0x55, 0x32, 0x28, 0x6D, 0x6F, 0x29, 0x5A},
120 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
121 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
122 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
123 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
124 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
125 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
126 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}
129 static unsigned char cipher_data[NUM_TESTS][8] = {
130 {0x4E, 0xF9, 0x97, 0x45, 0x61, 0x98, 0xDD, 0x78},
131 {0x51, 0x86, 0x6F, 0xD5, 0xB8, 0x5E, 0xCB, 0x8A},
132 {0x7D, 0x85, 0x6F, 0x9A, 0x61, 0x30, 0x63, 0xF2},
133 {0x24, 0x66, 0xDD, 0x87, 0x8B, 0x96, 0x3C, 0x9D},
134 {0x61, 0xF9, 0xC3, 0x80, 0x22, 0x81, 0xB0, 0x96},
135 {0x7D, 0x0C, 0xC6, 0x30, 0xAF, 0xDA, 0x1E, 0xC7},
136 {0x4E, 0xF9, 0x97, 0x45, 0x61, 0x98, 0xDD, 0x78},
137 {0x0A, 0xCE, 0xAB, 0x0F, 0xC6, 0xA0, 0xA2, 0x8D},
138 {0x59, 0xC6, 0x82, 0x45, 0xEB, 0x05, 0x28, 0x2B},
139 {0xB1, 0xB8, 0xCC, 0x0B, 0x25, 0x0F, 0x09, 0xA0},
140 {0x17, 0x30, 0xE5, 0x77, 0x8B, 0xEA, 0x1D, 0xA4},
141 {0xA2, 0x5E, 0x78, 0x56, 0xCF, 0x26, 0x51, 0xEB},
142 {0x35, 0x38, 0x82, 0xB1, 0x09, 0xCE, 0x8F, 0x1A},
143 {0x48, 0xF4, 0xD0, 0x88, 0x4C, 0x37, 0x99, 0x18},
144 {0x43, 0x21, 0x93, 0xB7, 0x89, 0x51, 0xFC, 0x98},
145 {0x13, 0xF0, 0x41, 0x54, 0xD6, 0x9D, 0x1A, 0xE5},
146 {0x2E, 0xED, 0xDA, 0x93, 0xFF, 0xD3, 0x9C, 0x79},
147 {0xD8, 0x87, 0xE0, 0x39, 0x3C, 0x2D, 0xA6, 0xE3},
148 {0x5F, 0x99, 0xD0, 0x4F, 0x5B, 0x16, 0x39, 0x69},
149 {0x4A, 0x05, 0x7A, 0x3B, 0x24, 0xD3, 0x97, 0x7B},
150 {0x45, 0x20, 0x31, 0xC1, 0xE4, 0xFA, 0xDA, 0x8E},
151 {0x75, 0x55, 0xAE, 0x39, 0xF5, 0x9B, 0x87, 0xBD},
152 {0x53, 0xC5, 0x5F, 0x9C, 0xB4, 0x9F, 0xC0, 0x19},
153 {0x7A, 0x8E, 0x7B, 0xFA, 0x93, 0x7E, 0x89, 0xA3},
154 {0xCF, 0x9C, 0x5D, 0x7A, 0x49, 0x86, 0xAD, 0xB5},
155 {0xD1, 0xAB, 0xB2, 0x90, 0x65, 0x8B, 0xC7, 0x78},
156 {0x55, 0xCB, 0x37, 0x74, 0xD1, 0x3E, 0xF2, 0x01},
157 {0xFA, 0x34, 0xEC, 0x48, 0x47, 0xB2, 0x68, 0xB2},
158 {0xA7, 0x90, 0x79, 0x51, 0x08, 0xEA, 0x3C, 0xAE},
159 {0xC3, 0x9E, 0x07, 0x2D, 0x9F, 0xAC, 0x63, 0x1D},
160 {0x01, 0x49, 0x33, 0xE0, 0xCD, 0xAF, 0xF6, 0xE4},
161 {0xF2, 0x1E, 0x9A, 0x77, 0xB7, 0x1C, 0x49, 0xBC},
162 {0x24, 0x59, 0x46, 0x88, 0x57, 0x54, 0x36, 0x9A},
163 {0x6B, 0x5C, 0x5A, 0x9C, 0x5D, 0x9E, 0x0A, 0x5A},
166 static unsigned char cbc_key[16] = {
167 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
168 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87
170 static unsigned char cbc_iv[8] =
171 { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
172 static char cbc_data[40] = "7654321 Now is the time for ";
173 static unsigned char cbc_ok[32] = {
174 0x6B, 0x77, 0xB4, 0xD6, 0x30, 0x06, 0xDE, 0xE6,
175 0x05, 0xB1, 0x56, 0xE2, 0x74, 0x03, 0x97, 0x93,
176 0x58, 0xDE, 0xB9, 0xE7, 0x15, 0x46, 0x16, 0xD9,
177 0x59, 0xF1, 0x65, 0x2B, 0xD5, 0xFF, 0x92, 0xCC
180 static unsigned char cfb64_ok[] = {
181 0xE7, 0x32, 0x14, 0xA2, 0x82, 0x21, 0x39, 0xCA,
182 0xF2, 0x6E, 0xCF, 0x6D, 0x2E, 0xB9, 0xE7, 0x6E,
183 0x3D, 0xA3, 0xDE, 0x04, 0xD1, 0x51, 0x72, 0x00,
184 0x51, 0x9D, 0x57, 0xA6, 0xC3
187 static unsigned char ofb64_ok[] = {
188 0xE7, 0x32, 0x14, 0xA2, 0x82, 0x21, 0x39, 0xCA,
189 0x62, 0xB3, 0x43, 0xCC, 0x5B, 0x65, 0x58, 0x73,
190 0x10, 0xDD, 0x90, 0x8D, 0x0C, 0x24, 0x1B, 0x22,
191 0x63, 0xC2, 0xCF, 0x80, 0xDA
194 # define KEY_TEST_NUM 25
195 static unsigned char key_test[KEY_TEST_NUM] = {
196 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87,
197 0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f,
198 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
202 static unsigned char key_data[8] =
203 { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 };
205 static unsigned char key_out[KEY_TEST_NUM][8] = {
206 {0xF9, 0xAD, 0x59, 0x7C, 0x49, 0xDB, 0x00, 0x5E},
207 {0xE9, 0x1D, 0x21, 0xC1, 0xD9, 0x61, 0xA6, 0xD6},
208 {0xE9, 0xC2, 0xB7, 0x0A, 0x1B, 0xC6, 0x5C, 0xF3},
209 {0xBE, 0x1E, 0x63, 0x94, 0x08, 0x64, 0x0F, 0x05},
210 {0xB3, 0x9E, 0x44, 0x48, 0x1B, 0xDB, 0x1E, 0x6E},
211 {0x94, 0x57, 0xAA, 0x83, 0xB1, 0x92, 0x8C, 0x0D},
212 {0x8B, 0xB7, 0x70, 0x32, 0xF9, 0x60, 0x62, 0x9D},
213 {0xE8, 0x7A, 0x24, 0x4E, 0x2C, 0xC8, 0x5E, 0x82},
214 {0x15, 0x75, 0x0E, 0x7A, 0x4F, 0x4E, 0xC5, 0x77},
215 {0x12, 0x2B, 0xA7, 0x0B, 0x3A, 0xB6, 0x4A, 0xE0},
216 {0x3A, 0x83, 0x3C, 0x9A, 0xFF, 0xC5, 0x37, 0xF6},
217 {0x94, 0x09, 0xDA, 0x87, 0xA9, 0x0F, 0x6B, 0xF2},
218 {0x88, 0x4F, 0x80, 0x62, 0x50, 0x60, 0xB8, 0xB4},
219 {0x1F, 0x85, 0x03, 0x1C, 0x19, 0xE1, 0x19, 0x68},
220 {0x79, 0xD9, 0x37, 0x3A, 0x71, 0x4C, 0xA3, 0x4F},
221 {0x93, 0x14, 0x28, 0x87, 0xEE, 0x3B, 0xE1, 0x5C},
222 {0x03, 0x42, 0x9E, 0x83, 0x8C, 0xE2, 0xD1, 0x4B},
223 {0xA4, 0x29, 0x9E, 0x27, 0x46, 0x9F, 0xF6, 0x7B},
224 {0xAF, 0xD5, 0xAE, 0xD1, 0xC1, 0xBC, 0x96, 0xA8},
225 {0x10, 0x85, 0x1C, 0x0E, 0x38, 0x58, 0xDA, 0x9F},
226 {0xE6, 0xF5, 0x1E, 0xD7, 0x9B, 0x9D, 0xB2, 0x1F},
227 {0x64, 0xA6, 0xE1, 0x4A, 0xFD, 0x36, 0xB4, 0x6F},
228 {0x80, 0xC7, 0xD7, 0xD4, 0x5A, 0x54, 0x79, 0xAD},
229 {0x05, 0x04, 0x4B, 0x62, 0xFA, 0x52, 0xD0, 0x80},
232 static int test(void);
233 static int print_test_data(void);
234 int main(int argc, char *argv[])
239 ret = print_test_data();
246 static int print_test_data(void)
250 printf("ecb test data\n");
251 printf("key bytes\t\tclear bytes\t\tcipher bytes\n");
252 for (i = 0; i < NUM_TESTS; i++) {
253 for (j = 0; j < 8; j++)
254 printf("%02X", ecb_data[i][j]);
256 for (j = 0; j < 8; j++)
257 printf("%02X", plain_data[i][j]);
259 for (j = 0; j < 8; j++)
260 printf("%02X", cipher_data[i][j]);
264 printf("set_key test data\n");
266 for (j = 0; j < 8; j++)
267 printf("%02X", key_data[j]);
269 for (i = 0; i < KEY_TEST_NUM - 1; i++) {
271 for (j = 0; j < 8; j++)
272 printf("%02X", key_out[i][j]);
273 printf(" k[%2u]=", i + 1);
274 for (j = 0; j < i + 1; j++)
275 printf("%02X", key_test[j]);
279 printf("\nchaining mode test data\n");
280 printf("key[16] = ");
281 for (j = 0; j < 16; j++)
282 printf("%02X", cbc_key[j]);
283 printf("\niv[8] = ");
284 for (j = 0; j < 8; j++)
285 printf("%02X", cbc_iv[j]);
286 printf("\ndata[%d] = '%s'", (int)strlen(cbc_data) + 1, cbc_data);
287 printf("\ndata[%d] = ", (int)strlen(cbc_data) + 1);
288 for (j = 0; j < strlen(cbc_data) + 1; j++)
289 printf("%02X", cbc_data[j]);
291 printf("cbc cipher text\n");
292 printf("cipher[%d]= ", 32);
293 for (j = 0; j < 32; j++)
294 printf("%02X", cbc_ok[j]);
297 printf("cfb64 cipher text\n");
298 printf("cipher[%d]= ", (int)strlen(cbc_data) + 1);
299 for (j = 0; j < strlen(cbc_data) + 1; j++)
300 printf("%02X", cfb64_ok[j]);
303 printf("ofb64 cipher text\n");
304 printf("cipher[%d]= ", (int)strlen(cbc_data) + 1);
305 for (j = 0; j < strlen(cbc_data) + 1; j++)
306 printf("%02X", ofb64_ok[j]);
311 static int test(void)
313 unsigned char cbc_in[40], cbc_out[40], iv[8];
317 unsigned char out[8];
320 # ifdef CHARSET_EBCDIC
321 ebcdic2ascii(cbc_data, cbc_data, strlen(cbc_data));
324 printf("testing blowfish in raw ecb mode\n");
325 for (n = 0; n < 2; n++) {
326 # ifdef CHARSET_EBCDIC
327 ebcdic2ascii(bf_key[n], bf_key[n], strlen(bf_key[n]));
329 BF_set_key(&key, strlen(bf_key[n]), (unsigned char *)bf_key[n]);
331 data[0] = bf_plain[n][0];
332 data[1] = bf_plain[n][1];
333 BF_encrypt(data, &key);
334 if (memcmp(&(bf_cipher[n][0]), &(data[0]), 8) != 0) {
335 printf("BF_encrypt error encrypting\n");
337 for (i = 0; i < 2; i++)
338 printf("%08lX ", (unsigned long)data[i]);
341 for (i = 0; i < 2; i++)
342 printf("%08lX ", (unsigned long)bf_cipher[n][i]);
347 BF_decrypt(&(data[0]), &key);
348 if (memcmp(&(bf_plain[n][0]), &(data[0]), 8) != 0) {
349 printf("BF_encrypt error decrypting\n");
351 for (i = 0; i < 2; i++)
352 printf("%08lX ", (unsigned long)data[i]);
355 for (i = 0; i < 2; i++)
356 printf("%08lX ", (unsigned long)bf_plain[n][i]);
362 printf("testing blowfish in ecb mode\n");
364 for (n = 0; n < NUM_TESTS; n++) {
365 BF_set_key(&key, 8, ecb_data[n]);
367 BF_ecb_encrypt(&(plain_data[n][0]), out, &key, BF_ENCRYPT);
368 if (memcmp(&(cipher_data[n][0]), out, 8) != 0) {
369 printf("BF_ecb_encrypt blowfish error encrypting\n");
371 for (i = 0; i < 8; i++)
372 printf("%02X ", out[i]);
375 for (i = 0; i < 8; i++)
376 printf("%02X ", cipher_data[n][i]);
381 BF_ecb_encrypt(out, out, &key, BF_DECRYPT);
382 if (memcmp(&(plain_data[n][0]), out, 8) != 0) {
383 printf("BF_ecb_encrypt error decrypting\n");
385 for (i = 0; i < 8; i++)
386 printf("%02X ", out[i]);
389 for (i = 0; i < 8; i++)
390 printf("%02X ", plain_data[n][i]);
396 printf("testing blowfish set_key\n");
397 for (n = 1; n < KEY_TEST_NUM; n++) {
398 BF_set_key(&key, n, key_test);
399 BF_ecb_encrypt(key_data, out, &key, BF_ENCRYPT);
400 /* mips-sgi-irix6.5-gcc vv -mabi=64 bug workaround */
401 if (memcmp(out, &(key_out[i = n - 1][0]), 8) != 0) {
402 printf("blowfish setkey error\n");
407 printf("testing blowfish in cbc mode\n");
408 len = strlen(cbc_data) + 1;
410 BF_set_key(&key, 16, cbc_key);
411 memset(cbc_in, 0, sizeof(cbc_in));
412 memset(cbc_out, 0, sizeof(cbc_out));
413 memcpy(iv, cbc_iv, sizeof iv);
414 BF_cbc_encrypt((unsigned char *)cbc_data, cbc_out, len,
415 &key, iv, BF_ENCRYPT);
416 if (memcmp(cbc_out, cbc_ok, 32) != 0) {
418 printf("BF_cbc_encrypt encrypt error\n");
419 for (i = 0; i < 32; i++)
420 printf("0x%02X,", cbc_out[i]);
422 memcpy(iv, cbc_iv, 8);
423 BF_cbc_encrypt(cbc_out, cbc_in, len, &key, iv, BF_DECRYPT);
424 if (memcmp(cbc_in, cbc_data, strlen(cbc_data) + 1) != 0) {
425 printf("BF_cbc_encrypt decrypt error\n");
429 printf("testing blowfish in cfb64 mode\n");
431 BF_set_key(&key, 16, cbc_key);
432 memset(cbc_in, 0, 40);
433 memset(cbc_out, 0, 40);
434 memcpy(iv, cbc_iv, 8);
436 BF_cfb64_encrypt((unsigned char *)cbc_data, cbc_out, (long)13,
437 &key, iv, &n, BF_ENCRYPT);
438 BF_cfb64_encrypt((unsigned char *)&(cbc_data[13]), &(cbc_out[13]),
439 len - 13, &key, iv, &n, BF_ENCRYPT);
440 if (memcmp(cbc_out, cfb64_ok, (int)len) != 0) {
442 printf("BF_cfb64_encrypt encrypt error\n");
443 for (i = 0; i < (int)len; i++)
444 printf("0x%02X,", cbc_out[i]);
447 memcpy(iv, cbc_iv, 8);
448 BF_cfb64_encrypt(cbc_out, cbc_in, 17, &key, iv, &n, BF_DECRYPT);
449 BF_cfb64_encrypt(&(cbc_out[17]), &(cbc_in[17]), len - 17,
450 &key, iv, &n, BF_DECRYPT);
451 if (memcmp(cbc_in, cbc_data, (int)len) != 0) {
452 printf("BF_cfb64_encrypt decrypt error\n");
456 printf("testing blowfish in ofb64\n");
458 BF_set_key(&key, 16, cbc_key);
459 memset(cbc_in, 0, 40);
460 memset(cbc_out, 0, 40);
461 memcpy(iv, cbc_iv, 8);
463 BF_ofb64_encrypt((unsigned char *)cbc_data, cbc_out, (long)13, &key, iv,
465 BF_ofb64_encrypt((unsigned char *)&(cbc_data[13]), &(cbc_out[13]),
466 len - 13, &key, iv, &n);
467 if (memcmp(cbc_out, ofb64_ok, (int)len) != 0) {
469 printf("BF_ofb64_encrypt encrypt error\n");
470 for (i = 0; i < (int)len; i++)
471 printf("0x%02X,", cbc_out[i]);
474 memcpy(iv, cbc_iv, 8);
475 BF_ofb64_encrypt(cbc_out, cbc_in, 17, &key, iv, &n);
476 BF_ofb64_encrypt(&(cbc_out[17]), &(cbc_in[17]), len - 17, &key, iv, &n);
477 if (memcmp(cbc_in, cbc_data, (int)len) != 0) {
478 printf("BF_ofb64_encrypt decrypt error\n");