Silence Clang warning about unit'd variable
[openssl.git] / test / bftest.c
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
72 int 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
84 static char *bf_key[2] = {
85     "abcdefghijklmnopqrstuvwxyz",
86     "Who is John Galt?"
87 };
88
89 /* big endian */
90 static BF_LONG bf_plain[2][2] = {
91     {0x424c4f57L, 0x46495348L},
92     {0xfedcba98L, 0x76543210L}
93 };
94
95 static 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
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}
139 };
140
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}
176 };
177
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},
213 };
214
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
218 };
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
227 };
228
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
234 };
235
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
241 };
242
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,
248     0x88
249 };
250
251 static unsigned char key_data[8] =
252     { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 };
253
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},
279 };
280
281 static int test(void);
282 static int print_test_data(void);
283 int 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 }
298
299 static int print_test_data(void)
300 {
301     unsigned int i, j;
302
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]);
308         printf("\t");
309         for (j = 0; j < 8; j++)
310             printf("%02X", plain_data[i][j]);
311         printf("\t");
312         for (j = 0; j < 8; j++)
313             printf("%02X", cipher_data[i][j]);
314         printf("\n");
315     }
316
317     printf("set_key test data\n");
318     printf("data[8]= ");
319     for (j = 0; j < 8; j++)
320         printf("%02X", key_data[j]);
321     printf("\n");
322     for (i = 0; i < KEY_TEST_NUM - 1; i++) {
323         printf("c=");
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]);
329         printf("\n");
330     }
331
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]);
343     printf("\n");
344     printf("cbc cipher text\n");
345     printf("cipher[%d]= ", 32);
346     for (j = 0; j < 32; j++)
347         printf("%02X", cbc_ok[j]);
348     printf("\n");
349
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]);
354     printf("\n");
355
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]);
360     printf("\n");
361     return (0);
362 }
363
364 static int test(void)
365 {
366     unsigned char cbc_in[40], cbc_out[40], iv[8];
367     int i, n, err = 0;
368     BF_KEY key;
369     BF_LONG data[2];
370     unsigned char out[8];
371     BF_LONG len;
372
373 # ifdef CHARSET_EBCDIC
374     ebcdic2ascii(cbc_data, cbc_data, strlen(cbc_data));
375 # endif
376
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]));
381 # endif
382         BF_set_key(&key, strlen(bf_key[n]), (unsigned char *)bf_key[n]);
383
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");
389             printf("got     :");
390             for (i = 0; i < 2; i++)
391                 printf("%08lX ", (unsigned long)data[i]);
392             printf("\n");
393             printf("expected:");
394             for (i = 0; i < 2; i++)
395                 printf("%08lX ", (unsigned long)bf_cipher[n][i]);
396             err = 1;
397             printf("\n");
398         }
399
400         BF_decrypt(&(data[0]), &key);
401         if (memcmp(&(bf_plain[n][0]), &(data[0]), 8) != 0) {
402             printf("BF_encrypt error decrypting\n");
403             printf("got     :");
404             for (i = 0; i < 2; i++)
405                 printf("%08lX ", (unsigned long)data[i]);
406             printf("\n");
407             printf("expected:");
408             for (i = 0; i < 2; i++)
409                 printf("%08lX ", (unsigned long)bf_plain[n][i]);
410             printf("\n");
411             err = 1;
412         }
413     }
414
415     printf("testing blowfish in ecb mode\n");
416
417     for (n = 0; n < NUM_TESTS; n++) {
418         BF_set_key(&key, 8, ecb_data[n]);
419
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");
423             printf("got     :");
424             for (i = 0; i < 8; i++)
425                 printf("%02X ", out[i]);
426             printf("\n");
427             printf("expected:");
428             for (i = 0; i < 8; i++)
429                 printf("%02X ", cipher_data[n][i]);
430             err = 1;
431             printf("\n");
432         }
433
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");
437             printf("got     :");
438             for (i = 0; i < 8; i++)
439                 printf("%02X ", out[i]);
440             printf("\n");
441             printf("expected:");
442             for (i = 0; i < 8; i++)
443                 printf("%02X ", plain_data[n][i]);
444             printf("\n");
445             err = 1;
446         }
447     }
448
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");
456             err = 1;
457         }
458     }
459
460     printf("testing blowfish in cbc mode\n");
461     len = strlen(cbc_data) + 1;
462
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) {
470         err = 1;
471         printf("BF_cbc_encrypt encrypt error\n");
472         for (i = 0; i < 32; i++)
473             printf("0x%02X,", cbc_out[i]);
474     }
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");
479         err = 1;
480     }
481
482     printf("testing blowfish in cfb64 mode\n");
483
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);
488     n = 0;
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) {
494         err = 1;
495         printf("BF_cfb64_encrypt encrypt error\n");
496         for (i = 0; i < (int)len; i++)
497             printf("0x%02X,", cbc_out[i]);
498     }
499     n = 0;
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");
506         err = 1;
507     }
508
509     printf("testing blowfish in ofb64\n");
510
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);
515     n = 0;
516     BF_ofb64_encrypt((unsigned char *)cbc_data, cbc_out, (long)13, &key, iv,
517                      &n);
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) {
521         err = 1;
522         printf("BF_ofb64_encrypt encrypt error\n");
523         for (i = 0; i < (int)len; i++)
524             printf("0x%02X,", cbc_out[i]);
525     }
526     n = 0;
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");
532         err = 1;
533     }
534
535     return (err);
536 }
537 #endif