bn/asm/rsaz-avx2.pl: constant-time gather procedure.
[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 # ifdef OPENSSL_SYS_NETWARE
292     if (ret)
293         printf("ERROR: %d\n", ret);
294 # endif
295     EXIT(ret);
296 }
297
298 static int print_test_data(void)
299 {
300     unsigned int i, j;
301
302     printf("ecb test data\n");
303     printf("key bytes\t\tclear bytes\t\tcipher bytes\n");
304     for (i = 0; i < NUM_TESTS; i++) {
305         for (j = 0; j < 8; j++)
306             printf("%02X", ecb_data[i][j]);
307         printf("\t");
308         for (j = 0; j < 8; j++)
309             printf("%02X", plain_data[i][j]);
310         printf("\t");
311         for (j = 0; j < 8; j++)
312             printf("%02X", cipher_data[i][j]);
313         printf("\n");
314     }
315
316     printf("set_key test data\n");
317     printf("data[8]= ");
318     for (j = 0; j < 8; j++)
319         printf("%02X", key_data[j]);
320     printf("\n");
321     for (i = 0; i < KEY_TEST_NUM - 1; i++) {
322         printf("c=");
323         for (j = 0; j < 8; j++)
324             printf("%02X", key_out[i][j]);
325         printf(" k[%2u]=", i + 1);
326         for (j = 0; j < i + 1; j++)
327             printf("%02X", key_test[j]);
328         printf("\n");
329     }
330
331     printf("\nchaining mode test data\n");
332     printf("key[16]   = ");
333     for (j = 0; j < 16; j++)
334         printf("%02X", cbc_key[j]);
335     printf("\niv[8]     = ");
336     for (j = 0; j < 8; j++)
337         printf("%02X", cbc_iv[j]);
338     printf("\ndata[%d]  = '%s'", (int)strlen(cbc_data) + 1, cbc_data);
339     printf("\ndata[%d]  = ", (int)strlen(cbc_data) + 1);
340     for (j = 0; j < strlen(cbc_data) + 1; j++)
341         printf("%02X", cbc_data[j]);
342     printf("\n");
343     printf("cbc cipher text\n");
344     printf("cipher[%d]= ", 32);
345     for (j = 0; j < 32; j++)
346         printf("%02X", cbc_ok[j]);
347     printf("\n");
348
349     printf("cfb64 cipher text\n");
350     printf("cipher[%d]= ", (int)strlen(cbc_data) + 1);
351     for (j = 0; j < strlen(cbc_data) + 1; j++)
352         printf("%02X", cfb64_ok[j]);
353     printf("\n");
354
355     printf("ofb64 cipher text\n");
356     printf("cipher[%d]= ", (int)strlen(cbc_data) + 1);
357     for (j = 0; j < strlen(cbc_data) + 1; j++)
358         printf("%02X", ofb64_ok[j]);
359     printf("\n");
360     return (0);
361 }
362
363 static int test(void)
364 {
365     unsigned char cbc_in[40], cbc_out[40], iv[8];
366     int i, n, err = 0;
367     BF_KEY key;
368     BF_LONG data[2];
369     unsigned char out[8];
370     BF_LONG len;
371
372 # ifdef CHARSET_EBCDIC
373     ebcdic2ascii(cbc_data, cbc_data, strlen(cbc_data));
374 # endif
375
376     printf("testing blowfish in raw ecb mode\n");
377     for (n = 0; n < 2; n++) {
378 # ifdef CHARSET_EBCDIC
379         ebcdic2ascii(bf_key[n], bf_key[n], strlen(bf_key[n]));
380 # endif
381         BF_set_key(&key, strlen(bf_key[n]), (unsigned char *)bf_key[n]);
382
383         data[0] = bf_plain[n][0];
384         data[1] = bf_plain[n][1];
385         BF_encrypt(data, &key);
386         if (memcmp(&(bf_cipher[n][0]), &(data[0]), 8) != 0) {
387             printf("BF_encrypt error encrypting\n");
388             printf("got     :");
389             for (i = 0; i < 2; i++)
390                 printf("%08lX ", (unsigned long)data[i]);
391             printf("\n");
392             printf("expected:");
393             for (i = 0; i < 2; i++)
394                 printf("%08lX ", (unsigned long)bf_cipher[n][i]);
395             err = 1;
396             printf("\n");
397         }
398
399         BF_decrypt(&(data[0]), &key);
400         if (memcmp(&(bf_plain[n][0]), &(data[0]), 8) != 0) {
401             printf("BF_encrypt error decrypting\n");
402             printf("got     :");
403             for (i = 0; i < 2; i++)
404                 printf("%08lX ", (unsigned long)data[i]);
405             printf("\n");
406             printf("expected:");
407             for (i = 0; i < 2; i++)
408                 printf("%08lX ", (unsigned long)bf_plain[n][i]);
409             printf("\n");
410             err = 1;
411         }
412     }
413
414     printf("testing blowfish in ecb mode\n");
415
416     for (n = 0; n < NUM_TESTS; n++) {
417         BF_set_key(&key, 8, ecb_data[n]);
418
419         BF_ecb_encrypt(&(plain_data[n][0]), out, &key, BF_ENCRYPT);
420         if (memcmp(&(cipher_data[n][0]), out, 8) != 0) {
421             printf("BF_ecb_encrypt blowfish error encrypting\n");
422             printf("got     :");
423             for (i = 0; i < 8; i++)
424                 printf("%02X ", out[i]);
425             printf("\n");
426             printf("expected:");
427             for (i = 0; i < 8; i++)
428                 printf("%02X ", cipher_data[n][i]);
429             err = 1;
430             printf("\n");
431         }
432
433         BF_ecb_encrypt(out, out, &key, BF_DECRYPT);
434         if (memcmp(&(plain_data[n][0]), out, 8) != 0) {
435             printf("BF_ecb_encrypt error decrypting\n");
436             printf("got     :");
437             for (i = 0; i < 8; i++)
438                 printf("%02X ", out[i]);
439             printf("\n");
440             printf("expected:");
441             for (i = 0; i < 8; i++)
442                 printf("%02X ", plain_data[n][i]);
443             printf("\n");
444             err = 1;
445         }
446     }
447
448     printf("testing blowfish set_key\n");
449     for (n = 1; n < KEY_TEST_NUM; n++) {
450         BF_set_key(&key, n, key_test);
451         BF_ecb_encrypt(key_data, out, &key, BF_ENCRYPT);
452         /* mips-sgi-irix6.5-gcc  vv  -mabi=64 bug workaround */
453         if (memcmp(out, &(key_out[i = n - 1][0]), 8) != 0) {
454             printf("blowfish setkey error\n");
455             err = 1;
456         }
457     }
458
459     printf("testing blowfish in cbc mode\n");
460     len = strlen(cbc_data) + 1;
461
462     BF_set_key(&key, 16, cbc_key);
463     memset(cbc_in, 0, sizeof(cbc_in));
464     memset(cbc_out, 0, sizeof(cbc_out));
465     memcpy(iv, cbc_iv, sizeof iv);
466     BF_cbc_encrypt((unsigned char *)cbc_data, cbc_out, len,
467                    &key, iv, BF_ENCRYPT);
468     if (memcmp(cbc_out, cbc_ok, 32) != 0) {
469         err = 1;
470         printf("BF_cbc_encrypt encrypt error\n");
471         for (i = 0; i < 32; i++)
472             printf("0x%02X,", cbc_out[i]);
473     }
474     memcpy(iv, cbc_iv, 8);
475     BF_cbc_encrypt(cbc_out, cbc_in, len, &key, iv, BF_DECRYPT);
476     if (memcmp(cbc_in, cbc_data, strlen(cbc_data) + 1) != 0) {
477         printf("BF_cbc_encrypt decrypt error\n");
478         err = 1;
479     }
480
481     printf("testing blowfish in cfb64 mode\n");
482
483     BF_set_key(&key, 16, cbc_key);
484     memset(cbc_in, 0, 40);
485     memset(cbc_out, 0, 40);
486     memcpy(iv, cbc_iv, 8);
487     n = 0;
488     BF_cfb64_encrypt((unsigned char *)cbc_data, cbc_out, (long)13,
489                      &key, iv, &n, BF_ENCRYPT);
490     BF_cfb64_encrypt((unsigned char *)&(cbc_data[13]), &(cbc_out[13]),
491                      len - 13, &key, iv, &n, BF_ENCRYPT);
492     if (memcmp(cbc_out, cfb64_ok, (int)len) != 0) {
493         err = 1;
494         printf("BF_cfb64_encrypt encrypt error\n");
495         for (i = 0; i < (int)len; i++)
496             printf("0x%02X,", cbc_out[i]);
497     }
498     n = 0;
499     memcpy(iv, cbc_iv, 8);
500     BF_cfb64_encrypt(cbc_out, cbc_in, 17, &key, iv, &n, BF_DECRYPT);
501     BF_cfb64_encrypt(&(cbc_out[17]), &(cbc_in[17]), len - 17,
502                      &key, iv, &n, BF_DECRYPT);
503     if (memcmp(cbc_in, cbc_data, (int)len) != 0) {
504         printf("BF_cfb64_encrypt decrypt error\n");
505         err = 1;
506     }
507
508     printf("testing blowfish in ofb64\n");
509
510     BF_set_key(&key, 16, cbc_key);
511     memset(cbc_in, 0, 40);
512     memset(cbc_out, 0, 40);
513     memcpy(iv, cbc_iv, 8);
514     n = 0;
515     BF_ofb64_encrypt((unsigned char *)cbc_data, cbc_out, (long)13, &key, iv,
516                      &n);
517     BF_ofb64_encrypt((unsigned char *)&(cbc_data[13]), &(cbc_out[13]),
518                      len - 13, &key, iv, &n);
519     if (memcmp(cbc_out, ofb64_ok, (int)len) != 0) {
520         err = 1;
521         printf("BF_ofb64_encrypt encrypt error\n");
522         for (i = 0; i < (int)len; i++)
523             printf("0x%02X,", cbc_out[i]);
524     }
525     n = 0;
526     memcpy(iv, cbc_iv, 8);
527     BF_ofb64_encrypt(cbc_out, cbc_in, 17, &key, iv, &n);
528     BF_ofb64_encrypt(&(cbc_out[17]), &(cbc_in[17]), len - 17, &key, iv, &n);
529     if (memcmp(cbc_in, cbc_data, (int)len) != 0) {
530         printf("BF_ofb64_encrypt decrypt error\n");
531         err = 1;
532     }
533
534     return (err);
535 }
536 #endif