b5e6c5144ddaafb07fe81c4f44952eb552caad2c
[openssl.git] / test / bftest.c
1 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
2  * All rights reserved.
3  *
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.
7  *
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).
14  *
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.
21  *
22  * Redistribution and use in source and binary forms, with or without
23  * modification, are permitted provided that the following conditions
24  * are met:
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)"
39  *
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
50  * SUCH DAMAGE.
51  *
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.]
56  */
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
63 #include <stdio.h>
64 #include <string.h>
65 #include <stdlib.h>
66 #include <openssl/opensslconf.h> /* To see if OPENSSL_NO_BF is defined */
67
68 #include "../e_os.h"
69
70 #ifdef OPENSSL_NO_BF
71 int main(int argc, char *argv[])
72 {
73     printf("No BF support\n");
74     return (0);
75 }
76 #else
77 # include <openssl/blowfish.h>
78
79 # ifdef CHARSET_EBCDIC
80 #  include <openssl/ebcdic.h>
81 # endif
82
83 static char *bf_key[2] = {
84     "abcdefghijklmnopqrstuvwxyz",
85     "Who is John Galt?"
86 };
87
88 /* big endian */
89 static BF_LONG bf_plain[2][2] = {
90     {0x424c4f57L, 0x46495348L},
91     {0xfedcba98L, 0x76543210L}
92 };
93
94 static BF_LONG bf_cipher[2][2] = {
95     {0x324ed0feL, 0xf413a203L},
96     {0xcc91732bL, 0x8022f684L}
97 };
98
99 /************/
100
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}
138 };
139
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}
175 };
176
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},
212 };
213
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
217 };
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
226 };
227
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
233 };
234
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
240 };
241
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,
247     0x88
248 };
249
250 static unsigned char key_data[8] =
251     { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 };
252
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},
278 };
279
280 static int test(void);
281 static int print_test_data(void);
282 int main(int argc, char *argv[])
283 {
284     int ret;
285
286     if (argc > 1)
287         ret = print_test_data();
288     else
289         ret = test();
290
291     EXIT(ret);
292 }
293
294 static int print_test_data(void)
295 {
296     unsigned int i, j;
297
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]);
303         printf("\t");
304         for (j = 0; j < 8; j++)
305             printf("%02X", plain_data[i][j]);
306         printf("\t");
307         for (j = 0; j < 8; j++)
308             printf("%02X", cipher_data[i][j]);
309         printf("\n");
310     }
311
312     printf("set_key test data\n");
313     printf("data[8]= ");
314     for (j = 0; j < 8; j++)
315         printf("%02X", key_data[j]);
316     printf("\n");
317     for (i = 0; i < KEY_TEST_NUM - 1; i++) {
318         printf("c=");
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]);
324         printf("\n");
325     }
326
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]);
338     printf("\n");
339     printf("cbc cipher text\n");
340     printf("cipher[%d]= ", 32);
341     for (j = 0; j < 32; j++)
342         printf("%02X", cbc_ok[j]);
343     printf("\n");
344
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]);
349     printf("\n");
350
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]);
355     printf("\n");
356     return (0);
357 }
358
359 static int test(void)
360 {
361     unsigned char cbc_in[40], cbc_out[40], iv[8];
362     int i, n, err = 0;
363     BF_KEY key;
364     BF_LONG data[2];
365     unsigned char out[8];
366     BF_LONG len;
367
368 # ifdef CHARSET_EBCDIC
369     ebcdic2ascii(cbc_data, cbc_data, strlen(cbc_data));
370 # endif
371
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]));
376 # endif
377         BF_set_key(&key, strlen(bf_key[n]), (unsigned char *)bf_key[n]);
378
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");
384             printf("got     :");
385             for (i = 0; i < 2; i++)
386                 printf("%08lX ", (unsigned long)data[i]);
387             printf("\n");
388             printf("expected:");
389             for (i = 0; i < 2; i++)
390                 printf("%08lX ", (unsigned long)bf_cipher[n][i]);
391             err = 1;
392             printf("\n");
393         }
394
395         BF_decrypt(&(data[0]), &key);
396         if (memcmp(&(bf_plain[n][0]), &(data[0]), 8) != 0) {
397             printf("BF_encrypt error decrypting\n");
398             printf("got     :");
399             for (i = 0; i < 2; i++)
400                 printf("%08lX ", (unsigned long)data[i]);
401             printf("\n");
402             printf("expected:");
403             for (i = 0; i < 2; i++)
404                 printf("%08lX ", (unsigned long)bf_plain[n][i]);
405             printf("\n");
406             err = 1;
407         }
408     }
409
410     printf("testing blowfish in ecb mode\n");
411
412     for (n = 0; n < NUM_TESTS; n++) {
413         BF_set_key(&key, 8, ecb_data[n]);
414
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");
418             printf("got     :");
419             for (i = 0; i < 8; i++)
420                 printf("%02X ", out[i]);
421             printf("\n");
422             printf("expected:");
423             for (i = 0; i < 8; i++)
424                 printf("%02X ", cipher_data[n][i]);
425             err = 1;
426             printf("\n");
427         }
428
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");
432             printf("got     :");
433             for (i = 0; i < 8; i++)
434                 printf("%02X ", out[i]);
435             printf("\n");
436             printf("expected:");
437             for (i = 0; i < 8; i++)
438                 printf("%02X ", plain_data[n][i]);
439             printf("\n");
440             err = 1;
441         }
442     }
443
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");
451             err = 1;
452         }
453     }
454
455     printf("testing blowfish in cbc mode\n");
456     len = strlen(cbc_data) + 1;
457
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) {
465         err = 1;
466         printf("BF_cbc_encrypt encrypt error\n");
467         for (i = 0; i < 32; i++)
468             printf("0x%02X,", cbc_out[i]);
469     }
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");
474         err = 1;
475     }
476
477     printf("testing blowfish in cfb64 mode\n");
478
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);
483     n = 0;
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) {
489         err = 1;
490         printf("BF_cfb64_encrypt encrypt error\n");
491         for (i = 0; i < (int)len; i++)
492             printf("0x%02X,", cbc_out[i]);
493     }
494     n = 0;
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");
501         err = 1;
502     }
503
504     printf("testing blowfish in ofb64\n");
505
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);
510     n = 0;
511     BF_ofb64_encrypt((unsigned char *)cbc_data, cbc_out, (long)13, &key, iv,
512                      &n);
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) {
516         err = 1;
517         printf("BF_ofb64_encrypt encrypt error\n");
518         for (i = 0; i < (int)len; i++)
519             printf("0x%02X,", cbc_out[i]);
520     }
521     n = 0;
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");
527         err = 1;
528     }
529
530     return (err);
531 }
532 #endif