bftest.c revision 296465 
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/*
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.
62 */
63
64#include <stdio.h>
65#include <string.h>
66#include <stdlib.h>
67#include <openssl/opensslconf.h> /* To see if OPENSSL_NO_BF is defined */
68
69#include "../e_os.h"
70
71#ifdef OPENSSL_NO_BF
72int main(int argc, char *argv[])
73{
74    printf("No BF support\n");
75    return (0);
76}
77#else
78# include <openssl/blowfish.h>
79
80# ifdef CHARSET_EBCDIC
81#  include <openssl/ebcdic.h>
82# endif
83
84static char *bf_key[2] = {
85    "abcdefghijklmnopqrstuvwxyz",
86    "Who is John Galt?"
87};
88
89/* big endian */
90static BF_LONG bf_plain[2][2] = {
91    {0x424c4f57L, 0x46495348L},
92    {0xfedcba98L, 0x76543210L}
93};
94
95static BF_LONG bf_cipher[2][2] = {
96    {0x324ed0feL, 0xf413a203L},
97    {0xcc91732bL, 0x8022f684L}
98};
99
100/************/
101
102/* Lets use the DES test vectors :-) */
103# define NUM_TESTS 34
104static 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}
139};
140
141static 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}
176};
177
178static 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},
213};
214
215static unsigned char cbc_key[16] = {
216    0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
217    0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87
218};
219static unsigned char cbc_iv[8] =
220    { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
221static char cbc_data[40] = "7654321 Now is the time for ";
222static 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
227};
228
229static 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
234};
235
236static 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
241};
242
243# define KEY_TEST_NUM    25
244static 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,
248    0x88
249};
250
251static unsigned char key_data[8] =
252    { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 };
253
254static 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},
279};
280
281static int test(void);
282static int print_test_data(void);
283int main(int argc, char *argv[])
284{
285    int ret;
286
287    if (argc > 1)
288        ret = print_test_data();
289    else
290        ret = test();
291
292# ifdef OPENSSL_SYS_NETWARE
293    if (ret)
294        printf("ERROR: %d\n", ret);
295# endif
296    EXIT(ret);
297    return (0);
298}
299
300static int print_test_data(void)
301{
302    unsigned int i, j;
303
304    printf("ecb test data\n");
305    printf("key bytes\t\tclear bytes\t\tcipher bytes\n");
306    for (i = 0; i < NUM_TESTS; i++) {
307        for (j = 0; j < 8; j++)
308            printf("%02X", ecb_data[i][j]);
309        printf("\t");
310        for (j = 0; j < 8; j++)
311            printf("%02X", plain_data[i][j]);
312        printf("\t");
313        for (j = 0; j < 8; j++)
314            printf("%02X", cipher_data[i][j]);
315        printf("\n");
316    }
317
318    printf("set_key test data\n");
319    printf("data[8]= ");
320    for (j = 0; j < 8; j++)
321        printf("%02X", key_data[j]);
322    printf("\n");
323    for (i = 0; i < KEY_TEST_NUM - 1; i++) {
324        printf("c=");
325        for (j = 0; j < 8; j++)
326            printf("%02X", key_out[i][j]);
327        printf(" k[%2u]=", i + 1);
328        for (j = 0; j < i + 1; j++)
329            printf("%02X", key_test[j]);
330        printf("\n");
331    }
332
333    printf("\nchaining mode test data\n");
334    printf("key[16]   = ");
335    for (j = 0; j < 16; j++)
336        printf("%02X", cbc_key[j]);
337    printf("\niv[8]     = ");
338    for (j = 0; j < 8; j++)
339        printf("%02X", cbc_iv[j]);
340    printf("\ndata[%d]  = '%s'", (int)strlen(cbc_data) + 1, cbc_data);
341    printf("\ndata[%d]  = ", (int)strlen(cbc_data) + 1);
342    for (j = 0; j < strlen(cbc_data) + 1; j++)
343        printf("%02X", cbc_data[j]);
344    printf("\n");
345    printf("cbc cipher text\n");
346    printf("cipher[%d]= ", 32);
347    for (j = 0; j < 32; j++)
348        printf("%02X", cbc_ok[j]);
349    printf("\n");
350
351    printf("cfb64 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", cfb64_ok[j]);
355    printf("\n");
356
357    printf("ofb64 cipher text\n");
358    printf("cipher[%d]= ", (int)strlen(cbc_data) + 1);
359    for (j = 0; j < strlen(cbc_data) + 1; j++)
360        printf("%02X", ofb64_ok[j]);
361    printf("\n");
362    return (0);
363}
364
365static int test(void)
366{
367    unsigned char cbc_in[40], cbc_out[40], iv[8];
368    int i, n, err = 0;
369    BF_KEY key;
370    BF_LONG data[2];
371    unsigned char out[8];
372    BF_LONG len;
373
374# ifdef CHARSET_EBCDIC
375    ebcdic2ascii(cbc_data, cbc_data, strlen(cbc_data));
376# endif
377
378    printf("testing blowfish in raw ecb mode\n");
379    for (n = 0; n < 2; n++) {
380# ifdef CHARSET_EBCDIC
381        ebcdic2ascii(bf_key[n], bf_key[n], strlen(bf_key[n]));
382# endif
383        BF_set_key(&key, strlen(bf_key[n]), (unsigned char *)bf_key[n]);
384
385        data[0] = bf_plain[n][0];
386        data[1] = bf_plain[n][1];
387        BF_encrypt(data, &key);
388        if (memcmp(&(bf_cipher[n][0]), &(data[0]), 8) != 0) {
389            printf("BF_encrypt error encrypting\n");
390            printf("got     :");
391            for (i = 0; i < 2; i++)
392                printf("%08lX ", (unsigned long)data[i]);
393            printf("\n");
394            printf("expected:");
395            for (i = 0; i < 2; i++)
396                printf("%08lX ", (unsigned long)bf_cipher[n][i]);
397            err = 1;
398            printf("\n");
399        }
400
401        BF_decrypt(&(data[0]), &key);
402        if (memcmp(&(bf_plain[n][0]), &(data[0]), 8) != 0) {
403            printf("BF_encrypt error decrypting\n");
404            printf("got     :");
405            for (i = 0; i < 2; i++)
406                printf("%08lX ", (unsigned long)data[i]);
407            printf("\n");
408            printf("expected:");
409            for (i = 0; i < 2; i++)
410                printf("%08lX ", (unsigned long)bf_plain[n][i]);
411            printf("\n");
412            err = 1;
413        }
414    }
415
416    printf("testing blowfish in ecb mode\n");
417
418    for (n = 0; n < NUM_TESTS; n++) {
419        BF_set_key(&key, 8, ecb_data[n]);
420
421        BF_ecb_encrypt(&(plain_data[n][0]), out, &key, BF_ENCRYPT);
422        if (memcmp(&(cipher_data[n][0]), out, 8) != 0) {
423            printf("BF_ecb_encrypt blowfish error encrypting\n");
424            printf("got     :");
425            for (i = 0; i < 8; i++)
426                printf("%02X ", out[i]);
427            printf("\n");
428            printf("expected:");
429            for (i = 0; i < 8; i++)
430                printf("%02X ", cipher_data[n][i]);
431            err = 1;
432            printf("\n");
433        }
434
435        BF_ecb_encrypt(out, out, &key, BF_DECRYPT);
436        if (memcmp(&(plain_data[n][0]), out, 8) != 0) {
437            printf("BF_ecb_encrypt error decrypting\n");
438            printf("got     :");
439            for (i = 0; i < 8; i++)
440                printf("%02X ", out[i]);
441            printf("\n");
442            printf("expected:");
443            for (i = 0; i < 8; i++)
444                printf("%02X ", plain_data[n][i]);
445            printf("\n");
446            err = 1;
447        }
448    }
449
450    printf("testing blowfish set_key\n");
451    for (n = 1; n < KEY_TEST_NUM; n++) {
452        BF_set_key(&key, n, key_test);
453        BF_ecb_encrypt(key_data, out, &key, BF_ENCRYPT);
454        /* mips-sgi-irix6.5-gcc  vv  -mabi=64 bug workaround */
455        if (memcmp(out, &(key_out[i = n - 1][0]), 8) != 0) {
456            printf("blowfish setkey error\n");
457            err = 1;
458        }
459    }
460
461    printf("testing blowfish in cbc mode\n");
462    len = strlen(cbc_data) + 1;
463
464    BF_set_key(&key, 16, cbc_key);
465    memset(cbc_in, 0, sizeof cbc_in);
466    memset(cbc_out, 0, sizeof cbc_out);
467    memcpy(iv, cbc_iv, sizeof iv);
468    BF_cbc_encrypt((unsigned char *)cbc_data, cbc_out, len,
469                   &key, iv, BF_ENCRYPT);
470    if (memcmp(cbc_out, cbc_ok, 32) != 0) {
471        err = 1;
472        printf("BF_cbc_encrypt encrypt error\n");
473        for (i = 0; i < 32; i++)
474            printf("0x%02X,", cbc_out[i]);
475    }
476    memcpy(iv, cbc_iv, 8);
477    BF_cbc_encrypt(cbc_out, cbc_in, len, &key, iv, BF_DECRYPT);
478    if (memcmp(cbc_in, cbc_data, strlen(cbc_data) + 1) != 0) {
479        printf("BF_cbc_encrypt decrypt error\n");
480        err = 1;
481    }
482
483    printf("testing blowfish in cfb64 mode\n");
484
485    BF_set_key(&key, 16, cbc_key);
486    memset(cbc_in, 0, 40);
487    memset(cbc_out, 0, 40);
488    memcpy(iv, cbc_iv, 8);
489    n = 0;
490    BF_cfb64_encrypt((unsigned char *)cbc_data, cbc_out, (long)13,
491                     &key, iv, &n, BF_ENCRYPT);
492    BF_cfb64_encrypt((unsigned char *)&(cbc_data[13]), &(cbc_out[13]),
493                     len - 13, &key, iv, &n, BF_ENCRYPT);
494    if (memcmp(cbc_out, cfb64_ok, (int)len) != 0) {
495        err = 1;
496        printf("BF_cfb64_encrypt encrypt error\n");
497        for (i = 0; i < (int)len; i++)
498            printf("0x%02X,", cbc_out[i]);
499    }
500    n = 0;
501    memcpy(iv, cbc_iv, 8);
502    BF_cfb64_encrypt(cbc_out, cbc_in, 17, &key, iv, &n, BF_DECRYPT);
503    BF_cfb64_encrypt(&(cbc_out[17]), &(cbc_in[17]), len - 17,
504                     &key, iv, &n, BF_DECRYPT);
505    if (memcmp(cbc_in, cbc_data, (int)len) != 0) {
506        printf("BF_cfb64_encrypt decrypt error\n");
507        err = 1;
508    }
509
510    printf("testing blowfish in ofb64\n");
511
512    BF_set_key(&key, 16, cbc_key);
513    memset(cbc_in, 0, 40);
514    memset(cbc_out, 0, 40);
515    memcpy(iv, cbc_iv, 8);
516    n = 0;
517    BF_ofb64_encrypt((unsigned char *)cbc_data, cbc_out, (long)13, &key, iv,
518                     &n);
519    BF_ofb64_encrypt((unsigned char *)&(cbc_data[13]), &(cbc_out[13]),
520                     len - 13, &key, iv, &n);
521    if (memcmp(cbc_out, ofb64_ok, (int)len) != 0) {
522        err = 1;
523        printf("BF_ofb64_encrypt encrypt error\n");
524        for (i = 0; i < (int)len; i++)
525            printf("0x%02X,", cbc_out[i]);
526    }
527    n = 0;
528    memcpy(iv, cbc_iv, 8);
529    BF_ofb64_encrypt(cbc_out, cbc_in, 17, &key, iv, &n);
530    BF_ofb64_encrypt(&(cbc_out[17]), &(cbc_in[17]), len - 17, &key, iv, &n);
531    if (memcmp(cbc_in, cbc_data, (int)len) != 0) {
532        printf("BF_ofb64_encrypt decrypt error\n");
533        err = 1;
534    }
535
536    return (err);
537}
538#endif
539