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