1 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
4 * This package is an SSL implementation written
5 * by Eric Young (eay@cryptsoft.com).
6 * The implementation was written so as to conform with Netscapes SSL.
8 * This library is free for commercial and non-commercial use as long as
9 * the following conditions are aheared to. The following conditions
10 * apply to all code found in this distribution, be it the RC4, RSA,
11 * lhash, DES, etc., code; not just the SSL code. The SSL documentation
12 * included with this distribution is covered by the same copyright terms
13 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15 * Copyright remains Eric Young's, and as such any Copyright notices in
16 * the code are not to be removed.
17 * If this package is used in a product, Eric Young should be given attribution
18 * as the author of the parts of the library used.
19 * This can be in the form of a textual message at program startup or
20 * in documentation (online or textual) provided with the package.
22 * Redistribution and use in source and binary forms, with or without
23 * modification, are permitted provided that the following conditions
25 * 1. Redistributions of source code must retain the copyright
26 * notice, this list of conditions and the following disclaimer.
27 * 2. Redistributions in binary form must reproduce the above copyright
28 * notice, this list of conditions and the following disclaimer in the
29 * documentation and/or other materials provided with the distribution.
30 * 3. All advertising materials mentioning features or use of this software
31 * must display the following acknowledgement:
32 * "This product includes cryptographic software written by
33 * Eric Young (eay@cryptsoft.com)"
34 * The word 'cryptographic' can be left out if the rouines from the library
35 * being used are not cryptographic related :-).
36 * 4. If you include any Windows specific code (or a derivative thereof) from
37 * the apps directory (application code) you must include an acknowledgement:
38 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
41 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
43 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
44 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
45 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
46 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
48 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
49 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
52 * The licence and distribution terms for any publically available version or
53 * derivative of this code cannot be changed. i.e. this code cannot simply be
54 * copied and put under another distribution licence
55 * [including the GNU Public Licence.]
59 * This has been a quickly hacked 'ideatest.c'. When I add tests for other
60 * RC2 modes, more of the code will be uncommented.
66 #include <openssl/opensslconf.h> /* To see if OPENSSL_NO_BF is defined */
71 int main(int argc, char *argv[])
73 printf("No BF support\n");
77 # include <openssl/blowfish.h>
79 # ifdef CHARSET_EBCDIC
80 # include <openssl/ebcdic.h>
83 static char bf_key[2][30] = {
84 "abcdefghijklmnopqrstuvwxyz",
89 static BF_LONG bf_plain[2][2] = {
90 {0x424c4f57L, 0x46495348L},
91 {0xfedcba98L, 0x76543210L}
94 static BF_LONG bf_cipher[2][2] = {
95 {0x324ed0feL, 0xf413a203L},
96 {0xcc91732bL, 0x8022f684L}
101 /* Lets use the DES test vectors :-) */
102 # define NUM_TESTS 34
103 static unsigned char ecb_data[NUM_TESTS][8] = {
104 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
105 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
106 {0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
107 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
108 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
109 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
110 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
111 {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10},
112 {0x7C, 0xA1, 0x10, 0x45, 0x4A, 0x1A, 0x6E, 0x57},
113 {0x01, 0x31, 0xD9, 0x61, 0x9D, 0xC1, 0x37, 0x6E},
114 {0x07, 0xA1, 0x13, 0x3E, 0x4A, 0x0B, 0x26, 0x86},
115 {0x38, 0x49, 0x67, 0x4C, 0x26, 0x02, 0x31, 0x9E},
116 {0x04, 0xB9, 0x15, 0xBA, 0x43, 0xFE, 0xB5, 0xB6},
117 {0x01, 0x13, 0xB9, 0x70, 0xFD, 0x34, 0xF2, 0xCE},
118 {0x01, 0x70, 0xF1, 0x75, 0x46, 0x8F, 0xB5, 0xE6},
119 {0x43, 0x29, 0x7F, 0xAD, 0x38, 0xE3, 0x73, 0xFE},
120 {0x07, 0xA7, 0x13, 0x70, 0x45, 0xDA, 0x2A, 0x16},
121 {0x04, 0x68, 0x91, 0x04, 0xC2, 0xFD, 0x3B, 0x2F},
122 {0x37, 0xD0, 0x6B, 0xB5, 0x16, 0xCB, 0x75, 0x46},
123 {0x1F, 0x08, 0x26, 0x0D, 0x1A, 0xC2, 0x46, 0x5E},
124 {0x58, 0x40, 0x23, 0x64, 0x1A, 0xBA, 0x61, 0x76},
125 {0x02, 0x58, 0x16, 0x16, 0x46, 0x29, 0xB0, 0x07},
126 {0x49, 0x79, 0x3E, 0xBC, 0x79, 0xB3, 0x25, 0x8F},
127 {0x4F, 0xB0, 0x5E, 0x15, 0x15, 0xAB, 0x73, 0xA7},
128 {0x49, 0xE9, 0x5D, 0x6D, 0x4C, 0xA2, 0x29, 0xBF},
129 {0x01, 0x83, 0x10, 0xDC, 0x40, 0x9B, 0x26, 0xD6},
130 {0x1C, 0x58, 0x7F, 0x1C, 0x13, 0x92, 0x4F, 0xEF},
131 {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
132 {0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E},
133 {0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE},
134 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
135 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
136 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
137 {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}
140 static unsigned char plain_data[NUM_TESTS][8] = {
141 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
142 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
143 {0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
144 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
145 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
146 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
147 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
148 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
149 {0x01, 0xA1, 0xD6, 0xD0, 0x39, 0x77, 0x67, 0x42},
150 {0x5C, 0xD5, 0x4C, 0xA8, 0x3D, 0xEF, 0x57, 0xDA},
151 {0x02, 0x48, 0xD4, 0x38, 0x06, 0xF6, 0x71, 0x72},
152 {0x51, 0x45, 0x4B, 0x58, 0x2D, 0xDF, 0x44, 0x0A},
153 {0x42, 0xFD, 0x44, 0x30, 0x59, 0x57, 0x7F, 0xA2},
154 {0x05, 0x9B, 0x5E, 0x08, 0x51, 0xCF, 0x14, 0x3A},
155 {0x07, 0x56, 0xD8, 0xE0, 0x77, 0x47, 0x61, 0xD2},
156 {0x76, 0x25, 0x14, 0xB8, 0x29, 0xBF, 0x48, 0x6A},
157 {0x3B, 0xDD, 0x11, 0x90, 0x49, 0x37, 0x28, 0x02},
158 {0x26, 0x95, 0x5F, 0x68, 0x35, 0xAF, 0x60, 0x9A},
159 {0x16, 0x4D, 0x5E, 0x40, 0x4F, 0x27, 0x52, 0x32},
160 {0x6B, 0x05, 0x6E, 0x18, 0x75, 0x9F, 0x5C, 0xCA},
161 {0x00, 0x4B, 0xD6, 0xEF, 0x09, 0x17, 0x60, 0x62},
162 {0x48, 0x0D, 0x39, 0x00, 0x6E, 0xE7, 0x62, 0xF2},
163 {0x43, 0x75, 0x40, 0xC8, 0x69, 0x8F, 0x3C, 0xFA},
164 {0x07, 0x2D, 0x43, 0xA0, 0x77, 0x07, 0x52, 0x92},
165 {0x02, 0xFE, 0x55, 0x77, 0x81, 0x17, 0xF1, 0x2A},
166 {0x1D, 0x9D, 0x5C, 0x50, 0x18, 0xF7, 0x28, 0xC2},
167 {0x30, 0x55, 0x32, 0x28, 0x6D, 0x6F, 0x29, 0x5A},
168 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
169 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
170 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
171 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
172 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
173 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
174 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}
177 static unsigned char cipher_data[NUM_TESTS][8] = {
178 {0x4E, 0xF9, 0x97, 0x45, 0x61, 0x98, 0xDD, 0x78},
179 {0x51, 0x86, 0x6F, 0xD5, 0xB8, 0x5E, 0xCB, 0x8A},
180 {0x7D, 0x85, 0x6F, 0x9A, 0x61, 0x30, 0x63, 0xF2},
181 {0x24, 0x66, 0xDD, 0x87, 0x8B, 0x96, 0x3C, 0x9D},
182 {0x61, 0xF9, 0xC3, 0x80, 0x22, 0x81, 0xB0, 0x96},
183 {0x7D, 0x0C, 0xC6, 0x30, 0xAF, 0xDA, 0x1E, 0xC7},
184 {0x4E, 0xF9, 0x97, 0x45, 0x61, 0x98, 0xDD, 0x78},
185 {0x0A, 0xCE, 0xAB, 0x0F, 0xC6, 0xA0, 0xA2, 0x8D},
186 {0x59, 0xC6, 0x82, 0x45, 0xEB, 0x05, 0x28, 0x2B},
187 {0xB1, 0xB8, 0xCC, 0x0B, 0x25, 0x0F, 0x09, 0xA0},
188 {0x17, 0x30, 0xE5, 0x77, 0x8B, 0xEA, 0x1D, 0xA4},
189 {0xA2, 0x5E, 0x78, 0x56, 0xCF, 0x26, 0x51, 0xEB},
190 {0x35, 0x38, 0x82, 0xB1, 0x09, 0xCE, 0x8F, 0x1A},
191 {0x48, 0xF4, 0xD0, 0x88, 0x4C, 0x37, 0x99, 0x18},
192 {0x43, 0x21, 0x93, 0xB7, 0x89, 0x51, 0xFC, 0x98},
193 {0x13, 0xF0, 0x41, 0x54, 0xD6, 0x9D, 0x1A, 0xE5},
194 {0x2E, 0xED, 0xDA, 0x93, 0xFF, 0xD3, 0x9C, 0x79},
195 {0xD8, 0x87, 0xE0, 0x39, 0x3C, 0x2D, 0xA6, 0xE3},
196 {0x5F, 0x99, 0xD0, 0x4F, 0x5B, 0x16, 0x39, 0x69},
197 {0x4A, 0x05, 0x7A, 0x3B, 0x24, 0xD3, 0x97, 0x7B},
198 {0x45, 0x20, 0x31, 0xC1, 0xE4, 0xFA, 0xDA, 0x8E},
199 {0x75, 0x55, 0xAE, 0x39, 0xF5, 0x9B, 0x87, 0xBD},
200 {0x53, 0xC5, 0x5F, 0x9C, 0xB4, 0x9F, 0xC0, 0x19},
201 {0x7A, 0x8E, 0x7B, 0xFA, 0x93, 0x7E, 0x89, 0xA3},
202 {0xCF, 0x9C, 0x5D, 0x7A, 0x49, 0x86, 0xAD, 0xB5},
203 {0xD1, 0xAB, 0xB2, 0x90, 0x65, 0x8B, 0xC7, 0x78},
204 {0x55, 0xCB, 0x37, 0x74, 0xD1, 0x3E, 0xF2, 0x01},
205 {0xFA, 0x34, 0xEC, 0x48, 0x47, 0xB2, 0x68, 0xB2},
206 {0xA7, 0x90, 0x79, 0x51, 0x08, 0xEA, 0x3C, 0xAE},
207 {0xC3, 0x9E, 0x07, 0x2D, 0x9F, 0xAC, 0x63, 0x1D},
208 {0x01, 0x49, 0x33, 0xE0, 0xCD, 0xAF, 0xF6, 0xE4},
209 {0xF2, 0x1E, 0x9A, 0x77, 0xB7, 0x1C, 0x49, 0xBC},
210 {0x24, 0x59, 0x46, 0x88, 0x57, 0x54, 0x36, 0x9A},
211 {0x6B, 0x5C, 0x5A, 0x9C, 0x5D, 0x9E, 0x0A, 0x5A},
214 static unsigned char cbc_key[16] = {
215 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
216 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87
218 static unsigned char cbc_iv[8] =
219 { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
220 static char cbc_data[40] = "7654321 Now is the time for ";
221 static unsigned char cbc_ok[32] = {
222 0x6B, 0x77, 0xB4, 0xD6, 0x30, 0x06, 0xDE, 0xE6,
223 0x05, 0xB1, 0x56, 0xE2, 0x74, 0x03, 0x97, 0x93,
224 0x58, 0xDE, 0xB9, 0xE7, 0x15, 0x46, 0x16, 0xD9,
225 0x59, 0xF1, 0x65, 0x2B, 0xD5, 0xFF, 0x92, 0xCC
228 static unsigned char cfb64_ok[] = {
229 0xE7, 0x32, 0x14, 0xA2, 0x82, 0x21, 0x39, 0xCA,
230 0xF2, 0x6E, 0xCF, 0x6D, 0x2E, 0xB9, 0xE7, 0x6E,
231 0x3D, 0xA3, 0xDE, 0x04, 0xD1, 0x51, 0x72, 0x00,
232 0x51, 0x9D, 0x57, 0xA6, 0xC3
235 static unsigned char ofb64_ok[] = {
236 0xE7, 0x32, 0x14, 0xA2, 0x82, 0x21, 0x39, 0xCA,
237 0x62, 0xB3, 0x43, 0xCC, 0x5B, 0x65, 0x58, 0x73,
238 0x10, 0xDD, 0x90, 0x8D, 0x0C, 0x24, 0x1B, 0x22,
239 0x63, 0xC2, 0xCF, 0x80, 0xDA
242 # define KEY_TEST_NUM 25
243 static unsigned char key_test[KEY_TEST_NUM] = {
244 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87,
245 0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f,
246 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
250 static unsigned char key_data[8] =
251 { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 };
253 static unsigned char key_out[KEY_TEST_NUM][8] = {
254 {0xF9, 0xAD, 0x59, 0x7C, 0x49, 0xDB, 0x00, 0x5E},
255 {0xE9, 0x1D, 0x21, 0xC1, 0xD9, 0x61, 0xA6, 0xD6},
256 {0xE9, 0xC2, 0xB7, 0x0A, 0x1B, 0xC6, 0x5C, 0xF3},
257 {0xBE, 0x1E, 0x63, 0x94, 0x08, 0x64, 0x0F, 0x05},
258 {0xB3, 0x9E, 0x44, 0x48, 0x1B, 0xDB, 0x1E, 0x6E},
259 {0x94, 0x57, 0xAA, 0x83, 0xB1, 0x92, 0x8C, 0x0D},
260 {0x8B, 0xB7, 0x70, 0x32, 0xF9, 0x60, 0x62, 0x9D},
261 {0xE8, 0x7A, 0x24, 0x4E, 0x2C, 0xC8, 0x5E, 0x82},
262 {0x15, 0x75, 0x0E, 0x7A, 0x4F, 0x4E, 0xC5, 0x77},
263 {0x12, 0x2B, 0xA7, 0x0B, 0x3A, 0xB6, 0x4A, 0xE0},
264 {0x3A, 0x83, 0x3C, 0x9A, 0xFF, 0xC5, 0x37, 0xF6},
265 {0x94, 0x09, 0xDA, 0x87, 0xA9, 0x0F, 0x6B, 0xF2},
266 {0x88, 0x4F, 0x80, 0x62, 0x50, 0x60, 0xB8, 0xB4},
267 {0x1F, 0x85, 0x03, 0x1C, 0x19, 0xE1, 0x19, 0x68},
268 {0x79, 0xD9, 0x37, 0x3A, 0x71, 0x4C, 0xA3, 0x4F},
269 {0x93, 0x14, 0x28, 0x87, 0xEE, 0x3B, 0xE1, 0x5C},
270 {0x03, 0x42, 0x9E, 0x83, 0x8C, 0xE2, 0xD1, 0x4B},
271 {0xA4, 0x29, 0x9E, 0x27, 0x46, 0x9F, 0xF6, 0x7B},
272 {0xAF, 0xD5, 0xAE, 0xD1, 0xC1, 0xBC, 0x96, 0xA8},
273 {0x10, 0x85, 0x1C, 0x0E, 0x38, 0x58, 0xDA, 0x9F},
274 {0xE6, 0xF5, 0x1E, 0xD7, 0x9B, 0x9D, 0xB2, 0x1F},
275 {0x64, 0xA6, 0xE1, 0x4A, 0xFD, 0x36, 0xB4, 0x6F},
276 {0x80, 0xC7, 0xD7, 0xD4, 0x5A, 0x54, 0x79, 0xAD},
277 {0x05, 0x04, 0x4B, 0x62, 0xFA, 0x52, 0xD0, 0x80},
280 static int test(void);
281 static int print_test_data(void);
282 int main(int argc, char *argv[])
287 ret = print_test_data();
294 static int print_test_data(void)
298 printf("ecb test data\n");
299 printf("key bytes\t\tclear bytes\t\tcipher bytes\n");
300 for (i = 0; i < NUM_TESTS; i++) {
301 for (j = 0; j < 8; j++)
302 printf("%02X", ecb_data[i][j]);
304 for (j = 0; j < 8; j++)
305 printf("%02X", plain_data[i][j]);
307 for (j = 0; j < 8; j++)
308 printf("%02X", cipher_data[i][j]);
312 printf("set_key test data\n");
314 for (j = 0; j < 8; j++)
315 printf("%02X", key_data[j]);
317 for (i = 0; i < KEY_TEST_NUM - 1; i++) {
319 for (j = 0; j < 8; j++)
320 printf("%02X", key_out[i][j]);
321 printf(" k[%2u]=", i + 1);
322 for (j = 0; j < i + 1; j++)
323 printf("%02X", key_test[j]);
327 printf("\nchaining mode test data\n");
328 printf("key[16] = ");
329 for (j = 0; j < 16; j++)
330 printf("%02X", cbc_key[j]);
331 printf("\niv[8] = ");
332 for (j = 0; j < 8; j++)
333 printf("%02X", cbc_iv[j]);
334 printf("\ndata[%d] = '%s'", (int)strlen(cbc_data) + 1, cbc_data);
335 printf("\ndata[%d] = ", (int)strlen(cbc_data) + 1);
336 for (j = 0; j < strlen(cbc_data) + 1; j++)
337 printf("%02X", cbc_data[j]);
339 printf("cbc cipher text\n");
340 printf("cipher[%d]= ", 32);
341 for (j = 0; j < 32; j++)
342 printf("%02X", cbc_ok[j]);
345 printf("cfb64 cipher text\n");
346 printf("cipher[%d]= ", (int)strlen(cbc_data) + 1);
347 for (j = 0; j < strlen(cbc_data) + 1; j++)
348 printf("%02X", cfb64_ok[j]);
351 printf("ofb64 cipher text\n");
352 printf("cipher[%d]= ", (int)strlen(cbc_data) + 1);
353 for (j = 0; j < strlen(cbc_data) + 1; j++)
354 printf("%02X", ofb64_ok[j]);
359 static int test(void)
361 unsigned char cbc_in[40], cbc_out[40], iv[8];
365 unsigned char out[8];
368 # ifdef CHARSET_EBCDIC
369 ebcdic2ascii(cbc_data, cbc_data, strlen(cbc_data));
372 printf("testing blowfish in raw ecb mode\n");
373 for (n = 0; n < 2; n++) {
374 # ifdef CHARSET_EBCDIC
375 ebcdic2ascii(bf_key[n], bf_key[n], strlen(bf_key[n]));
377 BF_set_key(&key, strlen(bf_key[n]), (unsigned char *)bf_key[n]);
379 data[0] = bf_plain[n][0];
380 data[1] = bf_plain[n][1];
381 BF_encrypt(data, &key);
382 if (memcmp(&(bf_cipher[n][0]), &(data[0]), 8) != 0) {
383 printf("BF_encrypt error encrypting\n");
385 for (i = 0; i < 2; i++)
386 printf("%08lX ", (unsigned long)data[i]);
389 for (i = 0; i < 2; i++)
390 printf("%08lX ", (unsigned long)bf_cipher[n][i]);
395 BF_decrypt(&(data[0]), &key);
396 if (memcmp(&(bf_plain[n][0]), &(data[0]), 8) != 0) {
397 printf("BF_encrypt error decrypting\n");
399 for (i = 0; i < 2; i++)
400 printf("%08lX ", (unsigned long)data[i]);
403 for (i = 0; i < 2; i++)
404 printf("%08lX ", (unsigned long)bf_plain[n][i]);
410 printf("testing blowfish in ecb mode\n");
412 for (n = 0; n < NUM_TESTS; n++) {
413 BF_set_key(&key, 8, ecb_data[n]);
415 BF_ecb_encrypt(&(plain_data[n][0]), out, &key, BF_ENCRYPT);
416 if (memcmp(&(cipher_data[n][0]), out, 8) != 0) {
417 printf("BF_ecb_encrypt blowfish error encrypting\n");
419 for (i = 0; i < 8; i++)
420 printf("%02X ", out[i]);
423 for (i = 0; i < 8; i++)
424 printf("%02X ", cipher_data[n][i]);
429 BF_ecb_encrypt(out, out, &key, BF_DECRYPT);
430 if (memcmp(&(plain_data[n][0]), out, 8) != 0) {
431 printf("BF_ecb_encrypt error decrypting\n");
433 for (i = 0; i < 8; i++)
434 printf("%02X ", out[i]);
437 for (i = 0; i < 8; i++)
438 printf("%02X ", plain_data[n][i]);
444 printf("testing blowfish set_key\n");
445 for (n = 1; n < KEY_TEST_NUM; n++) {
446 BF_set_key(&key, n, key_test);
447 BF_ecb_encrypt(key_data, out, &key, BF_ENCRYPT);
448 /* mips-sgi-irix6.5-gcc vv -mabi=64 bug workaround */
449 if (memcmp(out, &(key_out[i = n - 1][0]), 8) != 0) {
450 printf("blowfish setkey error\n");
455 printf("testing blowfish in cbc mode\n");
456 len = strlen(cbc_data) + 1;
458 BF_set_key(&key, 16, cbc_key);
459 memset(cbc_in, 0, sizeof(cbc_in));
460 memset(cbc_out, 0, sizeof(cbc_out));
461 memcpy(iv, cbc_iv, sizeof iv);
462 BF_cbc_encrypt((unsigned char *)cbc_data, cbc_out, len,
463 &key, iv, BF_ENCRYPT);
464 if (memcmp(cbc_out, cbc_ok, 32) != 0) {
466 printf("BF_cbc_encrypt encrypt error\n");
467 for (i = 0; i < 32; i++)
468 printf("0x%02X,", cbc_out[i]);
470 memcpy(iv, cbc_iv, 8);
471 BF_cbc_encrypt(cbc_out, cbc_in, len, &key, iv, BF_DECRYPT);
472 if (memcmp(cbc_in, cbc_data, strlen(cbc_data) + 1) != 0) {
473 printf("BF_cbc_encrypt decrypt error\n");
477 printf("testing blowfish in cfb64 mode\n");
479 BF_set_key(&key, 16, cbc_key);
480 memset(cbc_in, 0, 40);
481 memset(cbc_out, 0, 40);
482 memcpy(iv, cbc_iv, 8);
484 BF_cfb64_encrypt((unsigned char *)cbc_data, cbc_out, (long)13,
485 &key, iv, &n, BF_ENCRYPT);
486 BF_cfb64_encrypt((unsigned char *)&(cbc_data[13]), &(cbc_out[13]),
487 len - 13, &key, iv, &n, BF_ENCRYPT);
488 if (memcmp(cbc_out, cfb64_ok, (int)len) != 0) {
490 printf("BF_cfb64_encrypt encrypt error\n");
491 for (i = 0; i < (int)len; i++)
492 printf("0x%02X,", cbc_out[i]);
495 memcpy(iv, cbc_iv, 8);
496 BF_cfb64_encrypt(cbc_out, cbc_in, 17, &key, iv, &n, BF_DECRYPT);
497 BF_cfb64_encrypt(&(cbc_out[17]), &(cbc_in[17]), len - 17,
498 &key, iv, &n, BF_DECRYPT);
499 if (memcmp(cbc_in, cbc_data, (int)len) != 0) {
500 printf("BF_cfb64_encrypt decrypt error\n");
504 printf("testing blowfish in ofb64\n");
506 BF_set_key(&key, 16, cbc_key);
507 memset(cbc_in, 0, 40);
508 memset(cbc_out, 0, 40);
509 memcpy(iv, cbc_iv, 8);
511 BF_ofb64_encrypt((unsigned char *)cbc_data, cbc_out, (long)13, &key, iv,
513 BF_ofb64_encrypt((unsigned char *)&(cbc_data[13]), &(cbc_out[13]),
514 len - 13, &key, iv, &n);
515 if (memcmp(cbc_out, ofb64_ok, (int)len) != 0) {
517 printf("BF_ofb64_encrypt encrypt error\n");
518 for (i = 0; i < (int)len; i++)
519 printf("0x%02X,", cbc_out[i]);
522 memcpy(iv, cbc_iv, 8);
523 BF_ofb64_encrypt(cbc_out, cbc_in, 17, &key, iv, &n);
524 BF_ofb64_encrypt(&(cbc_out[17]), &(cbc_in[17]), len - 17, &key, iv, &n);
525 if (memcmp(cbc_in, cbc_data, (int)len) != 0) {
526 printf("BF_ofb64_encrypt decrypt error\n");