summaryrefslogtreecommitdiff
path: root/src/lib/libcrypto/bf/bftest.c
diff options
context:
space:
mode:
authorryker <>1998-10-05 20:13:15 +0000
committerryker <>1998-10-05 20:13:15 +0000
commit536c76cbb863bab152f19842ab88772c01e922c7 (patch)
treedfecec371a097b73d605aae665887946d9982219 /src/lib/libcrypto/bf/bftest.c
downloadopenbsd-536c76cbb863bab152f19842ab88772c01e922c7.tar.gz
openbsd-536c76cbb863bab152f19842ab88772c01e922c7.tar.bz2
openbsd-536c76cbb863bab152f19842ab88772c01e922c7.zip
Import of SSLeay-0.9.0b with RSA and IDEA stubbed + OpenBSD build
functionality for shared libs. Note that routines such as sslv2_init and friends that use RSA will not work due to lack of RSA in this library. Needs documentation and help from ports for easy upgrade to full functionality where legally possible.
Diffstat (limited to 'src/lib/libcrypto/bf/bftest.c')
-rw-r--r--src/lib/libcrypto/bf/bftest.c521
1 files changed, 521 insertions, 0 deletions
diff --git a/src/lib/libcrypto/bf/bftest.c b/src/lib/libcrypto/bf/bftest.c
new file mode 100644
index 0000000000..9266cf813a
--- /dev/null
+++ b/src/lib/libcrypto/bf/bftest.c
@@ -0,0 +1,521 @@
1/* crypto/bf/bftest.c */
2/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3 * All rights reserved.
4 *
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.
8 *
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).
15 *
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.
22 *
23 * Redistribution and use in source and binary forms, with or without
24 * modification, are permitted provided that the following conditions
25 * are met:
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)"
40 *
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
51 * SUCH DAMAGE.
52 *
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.]
57 */
58
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. */
61
62#include <stdio.h>
63#include <string.h>
64#include <stdlib.h>
65#include "blowfish.h"
66
67char *bf_key[2]={
68 "abcdefghijklmnopqrstuvwxyz",
69 "Who is John Galt?"
70 };
71
72/* big endian */
73BF_LONG bf_plain[2][2]={
74 {0x424c4f57L,0x46495348L},
75 {0xfedcba98L,0x76543210L}
76 };
77
78BF_LONG bf_cipher[2][2]={
79 {0x324ed0feL,0xf413a203L},
80 {0xcc91732bL,0x8022f684L}
81 };
82/************/
83
84/* Lets use the DES test vectors :-) */
85#define NUM_TESTS 34
86static unsigned char ecb_data[NUM_TESTS][8]={
87 {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
88 {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},
89 {0x30,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
90 {0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11},
91 {0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF},
92 {0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11},
93 {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
94 {0xFE,0xDC,0xBA,0x98,0x76,0x54,0x32,0x10},
95 {0x7C,0xA1,0x10,0x45,0x4A,0x1A,0x6E,0x57},
96 {0x01,0x31,0xD9,0x61,0x9D,0xC1,0x37,0x6E},
97 {0x07,0xA1,0x13,0x3E,0x4A,0x0B,0x26,0x86},
98 {0x38,0x49,0x67,0x4C,0x26,0x02,0x31,0x9E},
99 {0x04,0xB9,0x15,0xBA,0x43,0xFE,0xB5,0xB6},
100 {0x01,0x13,0xB9,0x70,0xFD,0x34,0xF2,0xCE},
101 {0x01,0x70,0xF1,0x75,0x46,0x8F,0xB5,0xE6},
102 {0x43,0x29,0x7F,0xAD,0x38,0xE3,0x73,0xFE},
103 {0x07,0xA7,0x13,0x70,0x45,0xDA,0x2A,0x16},
104 {0x04,0x68,0x91,0x04,0xC2,0xFD,0x3B,0x2F},
105 {0x37,0xD0,0x6B,0xB5,0x16,0xCB,0x75,0x46},
106 {0x1F,0x08,0x26,0x0D,0x1A,0xC2,0x46,0x5E},
107 {0x58,0x40,0x23,0x64,0x1A,0xBA,0x61,0x76},
108 {0x02,0x58,0x16,0x16,0x46,0x29,0xB0,0x07},
109 {0x49,0x79,0x3E,0xBC,0x79,0xB3,0x25,0x8F},
110 {0x4F,0xB0,0x5E,0x15,0x15,0xAB,0x73,0xA7},
111 {0x49,0xE9,0x5D,0x6D,0x4C,0xA2,0x29,0xBF},
112 {0x01,0x83,0x10,0xDC,0x40,0x9B,0x26,0xD6},
113 {0x1C,0x58,0x7F,0x1C,0x13,0x92,0x4F,0xEF},
114 {0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01},
115 {0x1F,0x1F,0x1F,0x1F,0x0E,0x0E,0x0E,0x0E},
116 {0xE0,0xFE,0xE0,0xFE,0xF1,0xFE,0xF1,0xFE},
117 {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
118 {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},
119 {0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF},
120 {0xFE,0xDC,0xBA,0x98,0x76,0x54,0x32,0x10}};
121
122static unsigned char plain_data[NUM_TESTS][8]={
123 {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
124 {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},
125 {0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x01},
126 {0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11},
127 {0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11},
128 {0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF},
129 {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
130 {0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF},
131 {0x01,0xA1,0xD6,0xD0,0x39,0x77,0x67,0x42},
132 {0x5C,0xD5,0x4C,0xA8,0x3D,0xEF,0x57,0xDA},
133 {0x02,0x48,0xD4,0x38,0x06,0xF6,0x71,0x72},
134 {0x51,0x45,0x4B,0x58,0x2D,0xDF,0x44,0x0A},
135 {0x42,0xFD,0x44,0x30,0x59,0x57,0x7F,0xA2},
136 {0x05,0x9B,0x5E,0x08,0x51,0xCF,0x14,0x3A},
137 {0x07,0x56,0xD8,0xE0,0x77,0x47,0x61,0xD2},
138 {0x76,0x25,0x14,0xB8,0x29,0xBF,0x48,0x6A},
139 {0x3B,0xDD,0x11,0x90,0x49,0x37,0x28,0x02},
140 {0x26,0x95,0x5F,0x68,0x35,0xAF,0x60,0x9A},
141 {0x16,0x4D,0x5E,0x40,0x4F,0x27,0x52,0x32},
142 {0x6B,0x05,0x6E,0x18,0x75,0x9F,0x5C,0xCA},
143 {0x00,0x4B,0xD6,0xEF,0x09,0x17,0x60,0x62},
144 {0x48,0x0D,0x39,0x00,0x6E,0xE7,0x62,0xF2},
145 {0x43,0x75,0x40,0xC8,0x69,0x8F,0x3C,0xFA},
146 {0x07,0x2D,0x43,0xA0,0x77,0x07,0x52,0x92},
147 {0x02,0xFE,0x55,0x77,0x81,0x17,0xF1,0x2A},
148 {0x1D,0x9D,0x5C,0x50,0x18,0xF7,0x28,0xC2},
149 {0x30,0x55,0x32,0x28,0x6D,0x6F,0x29,0x5A},
150 {0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF},
151 {0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF},
152 {0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF},
153 {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},
154 {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
155 {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
156 {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF}};
157
158static unsigned char cipher_data[NUM_TESTS][8]={
159 {0x4E,0xF9,0x97,0x45,0x61,0x98,0xDD,0x78},
160 {0x51,0x86,0x6F,0xD5,0xB8,0x5E,0xCB,0x8A},
161 {0x7D,0x85,0x6F,0x9A,0x61,0x30,0x63,0xF2},
162 {0x24,0x66,0xDD,0x87,0x8B,0x96,0x3C,0x9D},
163 {0x61,0xF9,0xC3,0x80,0x22,0x81,0xB0,0x96},
164 {0x7D,0x0C,0xC6,0x30,0xAF,0xDA,0x1E,0xC7},
165 {0x4E,0xF9,0x97,0x45,0x61,0x98,0xDD,0x78},
166 {0x0A,0xCE,0xAB,0x0F,0xC6,0xA0,0xA2,0x8D},
167 {0x59,0xC6,0x82,0x45,0xEB,0x05,0x28,0x2B},
168 {0xB1,0xB8,0xCC,0x0B,0x25,0x0F,0x09,0xA0},
169 {0x17,0x30,0xE5,0x77,0x8B,0xEA,0x1D,0xA4},
170 {0xA2,0x5E,0x78,0x56,0xCF,0x26,0x51,0xEB},
171 {0x35,0x38,0x82,0xB1,0x09,0xCE,0x8F,0x1A},
172 {0x48,0xF4,0xD0,0x88,0x4C,0x37,0x99,0x18},
173 {0x43,0x21,0x93,0xB7,0x89,0x51,0xFC,0x98},
174 {0x13,0xF0,0x41,0x54,0xD6,0x9D,0x1A,0xE5},
175 {0x2E,0xED,0xDA,0x93,0xFF,0xD3,0x9C,0x79},
176 {0xD8,0x87,0xE0,0x39,0x3C,0x2D,0xA6,0xE3},
177 {0x5F,0x99,0xD0,0x4F,0x5B,0x16,0x39,0x69},
178 {0x4A,0x05,0x7A,0x3B,0x24,0xD3,0x97,0x7B},
179 {0x45,0x20,0x31,0xC1,0xE4,0xFA,0xDA,0x8E},
180 {0x75,0x55,0xAE,0x39,0xF5,0x9B,0x87,0xBD},
181 {0x53,0xC5,0x5F,0x9C,0xB4,0x9F,0xC0,0x19},
182 {0x7A,0x8E,0x7B,0xFA,0x93,0x7E,0x89,0xA3},
183 {0xCF,0x9C,0x5D,0x7A,0x49,0x86,0xAD,0xB5},
184 {0xD1,0xAB,0xB2,0x90,0x65,0x8B,0xC7,0x78},
185 {0x55,0xCB,0x37,0x74,0xD1,0x3E,0xF2,0x01},
186 {0xFA,0x34,0xEC,0x48,0x47,0xB2,0x68,0xB2},
187 {0xA7,0x90,0x79,0x51,0x08,0xEA,0x3C,0xAE},
188 {0xC3,0x9E,0x07,0x2D,0x9F,0xAC,0x63,0x1D},
189 {0x01,0x49,0x33,0xE0,0xCD,0xAF,0xF6,0xE4},
190 {0xF2,0x1E,0x9A,0x77,0xB7,0x1C,0x49,0xBC},
191 {0x24,0x59,0x46,0x88,0x57,0x54,0x36,0x9A},
192 {0x6B,0x5C,0x5A,0x9C,0x5D,0x9E,0x0A,0x5A},
193 };
194
195static unsigned char cbc_key [16]={
196 0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef,
197 0xf0,0xe1,0xd2,0xc3,0xb4,0xa5,0x96,0x87};
198static unsigned char cbc_iv [8]={0xfe,0xdc,0xba,0x98,0x76,0x54,0x32,0x10};
199static char cbc_data[40]="7654321 Now is the time for ";
200static unsigned char cbc_ok[32]={
201 0x6B,0x77,0xB4,0xD6,0x30,0x06,0xDE,0xE6,
202 0x05,0xB1,0x56,0xE2,0x74,0x03,0x97,0x93,
203 0x58,0xDE,0xB9,0xE7,0x15,0x46,0x16,0xD9,
204 0x59,0xF1,0x65,0x2B,0xD5,0xFF,0x92,0xCC};
205
206static unsigned char cfb64_ok[]={
207 0xE7,0x32,0x14,0xA2,0x82,0x21,0x39,0xCA,
208 0xF2,0x6E,0xCF,0x6D,0x2E,0xB9,0xE7,0x6E,
209 0x3D,0xA3,0xDE,0x04,0xD1,0x51,0x72,0x00,
210 0x51,0x9D,0x57,0xA6,0xC3};
211
212static unsigned char ofb64_ok[]={
213 0xE7,0x32,0x14,0xA2,0x82,0x21,0x39,0xCA,
214 0x62,0xB3,0x43,0xCC,0x5B,0x65,0x58,0x73,
215 0x10,0xDD,0x90,0x8D,0x0C,0x24,0x1B,0x22,
216 0x63,0xC2,0xCF,0x80,0xDA};
217
218#define KEY_TEST_NUM 25
219unsigned char key_test[KEY_TEST_NUM]={
220 0xf0,0xe1,0xd2,0xc3,0xb4,0xa5,0x96,0x87,
221 0x78,0x69,0x5a,0x4b,0x3c,0x2d,0x1e,0x0f,
222 0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,
223 0x88};
224
225unsigned char key_data[8]=
226 {0xFE,0xDC,0xBA,0x98,0x76,0x54,0x32,0x10};
227
228unsigned char key_out[KEY_TEST_NUM][8]={
229 {0xF9,0xAD,0x59,0x7C,0x49,0xDB,0x00,0x5E},
230 {0xE9,0x1D,0x21,0xC1,0xD9,0x61,0xA6,0xD6},
231 {0xE9,0xC2,0xB7,0x0A,0x1B,0xC6,0x5C,0xF3},
232 {0xBE,0x1E,0x63,0x94,0x08,0x64,0x0F,0x05},
233 {0xB3,0x9E,0x44,0x48,0x1B,0xDB,0x1E,0x6E},
234 {0x94,0x57,0xAA,0x83,0xB1,0x92,0x8C,0x0D},
235 {0x8B,0xB7,0x70,0x32,0xF9,0x60,0x62,0x9D},
236 {0xE8,0x7A,0x24,0x4E,0x2C,0xC8,0x5E,0x82},
237 {0x15,0x75,0x0E,0x7A,0x4F,0x4E,0xC5,0x77},
238 {0x12,0x2B,0xA7,0x0B,0x3A,0xB6,0x4A,0xE0},
239 {0x3A,0x83,0x3C,0x9A,0xFF,0xC5,0x37,0xF6},
240 {0x94,0x09,0xDA,0x87,0xA9,0x0F,0x6B,0xF2},
241 {0x88,0x4F,0x80,0x62,0x50,0x60,0xB8,0xB4},
242 {0x1F,0x85,0x03,0x1C,0x19,0xE1,0x19,0x68},
243 {0x79,0xD9,0x37,0x3A,0x71,0x4C,0xA3,0x4F},
244 {0x93,0x14,0x28,0x87,0xEE,0x3B,0xE1,0x5C},
245 {0x03,0x42,0x9E,0x83,0x8C,0xE2,0xD1,0x4B},
246 {0xA4,0x29,0x9E,0x27,0x46,0x9F,0xF6,0x7B},
247 {0xAF,0xD5,0xAE,0xD1,0xC1,0xBC,0x96,0xA8},
248 {0x10,0x85,0x1C,0x0E,0x38,0x58,0xDA,0x9F},
249 {0xE6,0xF5,0x1E,0xD7,0x9B,0x9D,0xB2,0x1F},
250 {0x64,0xA6,0xE1,0x4A,0xFD,0x36,0xB4,0x6F},
251 {0x80,0xC7,0xD7,0xD4,0x5A,0x54,0x79,0xAD},
252 {0x05,0x04,0x4B,0x62,0xFA,0x52,0xD0,0x80},
253 };
254
255#ifndef NOPROTO
256static int test(void );
257static int print_test_data(void );
258#else
259static int test();
260static int print_test_data();
261#endif
262
263int main(argc,argv)
264int argc;
265char *argv[];
266 {
267 int ret;
268
269 if (argc > 1)
270 ret=print_test_data();
271 else
272 ret=test();
273
274 exit(ret);
275 return(0);
276 }
277
278static int print_test_data()
279 {
280 unsigned int i,j;
281
282 printf("ecb test data\n");
283 printf("key bytes\t\tclear bytes\t\tcipher bytes\n");
284 for (i=0; i<NUM_TESTS; i++)
285 {
286 for (j=0; j<8; j++)
287 printf("%02X",ecb_data[i][j]);
288 printf("\t");
289 for (j=0; j<8; j++)
290 printf("%02X",plain_data[i][j]);
291 printf("\t");
292 for (j=0; j<8; j++)
293 printf("%02X",cipher_data[i][j]);
294 printf("\n");
295 }
296
297 printf("set_key test data\n");
298 printf("data[8]= ");
299 for (j=0; j<8; j++)
300 printf("%02X",key_data[j]);
301 printf("\n");
302 for (i=0; i<KEY_TEST_NUM-1; i++)
303 {
304 printf("c=");
305 for (j=0; j<8; j++)
306 printf("%02X",key_out[i][j]);
307 printf(" k[%2d]=",i+1);
308 for (j=0; j<i+1; j++)
309 printf("%02X",key_test[j]);
310 printf("\n");
311 }
312
313 printf("\nchaining mode test data\n");
314 printf("key[16] = ");
315 for (j=0; j<16; j++)
316 printf("%02X",cbc_key[j]);
317 printf("\niv[8] = ");
318 for (j=0; j<8; j++)
319 printf("%02X",cbc_iv[j]);
320 printf("\ndata[%d] = '%s'",(int)strlen(cbc_data)+1,cbc_data);
321 printf("\ndata[%d] = ",(int)strlen(cbc_data)+1);
322 for (j=0; j<strlen(cbc_data)+1; j++)
323 printf("%02X",cbc_data[j]);
324 printf("\n");
325 printf("cbc cipher text\n");
326 printf("cipher[%d]= ",32);
327 for (j=0; j<32; j++)
328 printf("%02X",cbc_ok[j]);
329 printf("\n");
330
331 printf("cfb64 cipher text\n");
332 printf("cipher[%d]= ",(int)strlen(cbc_data)+1);
333 for (j=0; j<strlen(cbc_data)+1; j++)
334 printf("%02X",cfb64_ok[j]);
335 printf("\n");
336
337 printf("ofb64 cipher text\n");
338 printf("cipher[%d]= ",(int)strlen(cbc_data)+1);
339 for (j=0; j<strlen(cbc_data)+1; j++)
340 printf("%02X",ofb64_ok[j]);
341 printf("\n");
342 return(0);
343 }
344
345static int test()
346 {
347 unsigned char cbc_in[40],cbc_out[40],iv[8];
348 int i,n,err=0;
349 BF_KEY key;
350 BF_LONG data[2];
351 unsigned char out[8];
352 BF_LONG len;
353
354 printf("testing blowfish in raw ecb mode\n");
355 for (n=0; n<2; n++)
356 {
357 BF_set_key(&key,strlen(bf_key[n]),(unsigned char *)bf_key[n]);
358
359 data[0]=bf_plain[n][0];
360 data[1]=bf_plain[n][1];
361 BF_encrypt(data,&key);
362 if (memcmp(&(bf_cipher[n][0]),&(data[0]),8) != 0)
363 {
364 printf("BF_encrypt error encrypting\n");
365 printf("got :");
366 for (i=0; i<2; i++)
367 printf("%08lX ",data[i]);
368 printf("\n");
369 printf("expected:");
370 for (i=0; i<2; i++)
371 printf("%08lX ",bf_cipher[n][i]);
372 err=1;
373 printf("\n");
374 }
375
376 BF_decrypt(&(data[0]),&key);
377 if (memcmp(&(bf_plain[n][0]),&(data[0]),8) != 0)
378 {
379 printf("BF_encrypt error decrypting\n");
380 printf("got :");
381 for (i=0; i<2; i++)
382 printf("%08lX ",data[i]);
383 printf("\n");
384 printf("expected:");
385 for (i=0; i<2; i++)
386 printf("%08lX ",bf_plain[n][i]);
387 printf("\n");
388 err=1;
389 }
390 }
391
392 printf("testing blowfish in ecb mode\n");
393
394 for (n=0; n<NUM_TESTS; n++)
395 {
396 BF_set_key(&key,8,ecb_data[n]);
397
398 BF_ecb_encrypt(&(plain_data[n][0]),out,&key,BF_ENCRYPT);
399 if (memcmp(&(cipher_data[n][0]),out,8) != 0)
400 {
401 printf("BF_ecb_encrypt blowfish error encrypting\n");
402 printf("got :");
403 for (i=0; i<8; i++)
404 printf("%02X ",out[i]);
405 printf("\n");
406 printf("expected:");
407 for (i=0; i<8; i++)
408 printf("%02X ",cipher_data[n][i]);
409 err=1;
410 printf("\n");
411 }
412
413 BF_ecb_encrypt(out,out,&key,BF_DECRYPT);
414 if (memcmp(&(plain_data[n][0]),out,8) != 0)
415 {
416 printf("BF_ecb_encrypt error decrypting\n");
417 printf("got :");
418 for (i=0; i<8; i++)
419 printf("%02X ",out[i]);
420 printf("\n");
421 printf("expected:");
422 for (i=0; i<8; i++)
423 printf("%02X ",plain_data[n][i]);
424 printf("\n");
425 err=1;
426 }
427 }
428
429 printf("testing blowfish set_key\n");
430 for (n=1; n<KEY_TEST_NUM; n++)
431 {
432 BF_set_key(&key,n,key_test);
433 BF_ecb_encrypt(key_data,out,&key,BF_ENCRYPT);
434 if (memcmp(out,&(key_out[n-1][0]),8) != 0)
435 {
436 printf("blowfish setkey error\n");
437 err=1;
438 }
439 }
440
441 printf("testing blowfish in cbc mode\n");
442 len=strlen(cbc_data)+1;
443
444 BF_set_key(&key,16,cbc_key);
445 memset(cbc_in,0,40);
446 memset(cbc_out,0,40);
447 memcpy(iv,cbc_iv,8);
448 BF_cbc_encrypt((unsigned char *)cbc_data,cbc_out,len,
449 &key,iv,BF_ENCRYPT);
450 if (memcmp(cbc_out,cbc_ok,32) != 0)
451 {
452 err=1;
453 printf("BF_cbc_encrypt encrypt error\n");
454 for (i=0; i<32; i++) printf("0x%02X,",cbc_out[i]);
455 }
456 memcpy(iv,cbc_iv,8);
457 BF_cbc_encrypt(cbc_out,cbc_in,len,
458 &key,iv,BF_DECRYPT);
459 if (memcmp(cbc_in,cbc_data,strlen(cbc_data)+1) != 0)
460 {
461 printf("BF_cbc_encrypt decrypt error\n");
462 err=1;
463 }
464
465 printf("testing blowfish in cfb64 mode\n");
466
467 BF_set_key(&key,16,cbc_key);
468 memset(cbc_in,0,40);
469 memset(cbc_out,0,40);
470 memcpy(iv,cbc_iv,8);
471 n=0;
472 BF_cfb64_encrypt((unsigned char *)cbc_data,cbc_out,(long)13,
473 &key,iv,&n,BF_ENCRYPT);
474 BF_cfb64_encrypt((unsigned char *)&(cbc_data[13]),&(cbc_out[13]),len-13,
475 &key,iv,&n,BF_ENCRYPT);
476 if (memcmp(cbc_out,cfb64_ok,(int)len) != 0)
477 {
478 err=1;
479 printf("BF_cfb64_encrypt encrypt error\n");
480 for (i=0; i<(int)len; i++) printf("0x%02X,",cbc_out[i]);
481 }
482 n=0;
483 memcpy(iv,cbc_iv,8);
484 BF_cfb64_encrypt(cbc_out,cbc_in,17,
485 &key,iv,&n,BF_DECRYPT);
486 BF_cfb64_encrypt(&(cbc_out[17]),&(cbc_in[17]),len-17,
487 &key,iv,&n,BF_DECRYPT);
488 if (memcmp(cbc_in,cbc_data,(int)len) != 0)
489 {
490 printf("BF_cfb64_encrypt decrypt error\n");
491 err=1;
492 }
493
494 printf("testing blowfish in ofb64\n");
495
496 BF_set_key(&key,16,cbc_key);
497 memset(cbc_in,0,40);
498 memset(cbc_out,0,40);
499 memcpy(iv,cbc_iv,8);
500 n=0;
501 BF_ofb64_encrypt((unsigned char *)cbc_data,cbc_out,(long)13,&key,iv,&n);
502 BF_ofb64_encrypt((unsigned char *)&(cbc_data[13]),
503 &(cbc_out[13]),len-13,&key,iv,&n);
504 if (memcmp(cbc_out,ofb64_ok,(int)len) != 0)
505 {
506 err=1;
507 printf("BF_ofb64_encrypt encrypt error\n");
508 for (i=0; i<(int)len; i++) printf("0x%02X,",cbc_out[i]);
509 }
510 n=0;
511 memcpy(iv,cbc_iv,8);
512 BF_ofb64_encrypt(cbc_out,cbc_in,17,&key,iv,&n);
513 BF_ofb64_encrypt(&(cbc_out[17]),&(cbc_in[17]),len-17,&key,iv,&n);
514 if (memcmp(cbc_in,cbc_data,(int)len) != 0)
515 {
516 printf("BF_ofb64_encrypt decrypt error\n");
517 err=1;
518 }
519
520 return(err);
521 }
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-04-26 16:53:40 +0000