Remove Netware and OS/2
[openssl.git] / test / destest.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 #include <stdio.h>
59 #include <stdlib.h>
60
61 #include <openssl/e_os2.h>
62 #if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_WINDOWS)
63 # ifndef OPENSSL_SYS_MSDOS
64 #  define OPENSSL_SYS_MSDOS
65 # endif
66 #endif
67
68 #ifndef OPENSSL_SYS_MSDOS
69 # if !defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_VMS_DECC)
70 #  include OPENSSL_UNISTD
71 # endif
72 #else
73 # include <io.h>
74 #endif
75 #include <string.h>
76
77 #ifdef OPENSSL_NO_DES
78 int main(int argc, char *argv[])
79 {
80     printf("No DES support\n");
81     return (0);
82 }
83 #else
84 # include <openssl/des.h>
85
86 # define crypt(c,s) (DES_crypt((c),(s)))
87
88 /* tisk tisk - the test keys don't all have odd parity :-( */
89 /* test data */
90 # define NUM_TESTS 34
91 static unsigned char key_data[NUM_TESTS][8] = {
92     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
93     {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
94     {0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
95     {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
96     {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
97     {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
98     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
99     {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10},
100     {0x7C, 0xA1, 0x10, 0x45, 0x4A, 0x1A, 0x6E, 0x57},
101     {0x01, 0x31, 0xD9, 0x61, 0x9D, 0xC1, 0x37, 0x6E},
102     {0x07, 0xA1, 0x13, 0x3E, 0x4A, 0x0B, 0x26, 0x86},
103     {0x38, 0x49, 0x67, 0x4C, 0x26, 0x02, 0x31, 0x9E},
104     {0x04, 0xB9, 0x15, 0xBA, 0x43, 0xFE, 0xB5, 0xB6},
105     {0x01, 0x13, 0xB9, 0x70, 0xFD, 0x34, 0xF2, 0xCE},
106     {0x01, 0x70, 0xF1, 0x75, 0x46, 0x8F, 0xB5, 0xE6},
107     {0x43, 0x29, 0x7F, 0xAD, 0x38, 0xE3, 0x73, 0xFE},
108     {0x07, 0xA7, 0x13, 0x70, 0x45, 0xDA, 0x2A, 0x16},
109     {0x04, 0x68, 0x91, 0x04, 0xC2, 0xFD, 0x3B, 0x2F},
110     {0x37, 0xD0, 0x6B, 0xB5, 0x16, 0xCB, 0x75, 0x46},
111     {0x1F, 0x08, 0x26, 0x0D, 0x1A, 0xC2, 0x46, 0x5E},
112     {0x58, 0x40, 0x23, 0x64, 0x1A, 0xBA, 0x61, 0x76},
113     {0x02, 0x58, 0x16, 0x16, 0x46, 0x29, 0xB0, 0x07},
114     {0x49, 0x79, 0x3E, 0xBC, 0x79, 0xB3, 0x25, 0x8F},
115     {0x4F, 0xB0, 0x5E, 0x15, 0x15, 0xAB, 0x73, 0xA7},
116     {0x49, 0xE9, 0x5D, 0x6D, 0x4C, 0xA2, 0x29, 0xBF},
117     {0x01, 0x83, 0x10, 0xDC, 0x40, 0x9B, 0x26, 0xD6},
118     {0x1C, 0x58, 0x7F, 0x1C, 0x13, 0x92, 0x4F, 0xEF},
119     {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
120     {0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E},
121     {0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE},
122     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
123     {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
124     {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
125     {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}
126 };
127
128 static unsigned char plain_data[NUM_TESTS][8] = {
129     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
130     {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
131     {0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
132     {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
133     {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
134     {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
135     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
136     {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
137     {0x01, 0xA1, 0xD6, 0xD0, 0x39, 0x77, 0x67, 0x42},
138     {0x5C, 0xD5, 0x4C, 0xA8, 0x3D, 0xEF, 0x57, 0xDA},
139     {0x02, 0x48, 0xD4, 0x38, 0x06, 0xF6, 0x71, 0x72},
140     {0x51, 0x45, 0x4B, 0x58, 0x2D, 0xDF, 0x44, 0x0A},
141     {0x42, 0xFD, 0x44, 0x30, 0x59, 0x57, 0x7F, 0xA2},
142     {0x05, 0x9B, 0x5E, 0x08, 0x51, 0xCF, 0x14, 0x3A},
143     {0x07, 0x56, 0xD8, 0xE0, 0x77, 0x47, 0x61, 0xD2},
144     {0x76, 0x25, 0x14, 0xB8, 0x29, 0xBF, 0x48, 0x6A},
145     {0x3B, 0xDD, 0x11, 0x90, 0x49, 0x37, 0x28, 0x02},
146     {0x26, 0x95, 0x5F, 0x68, 0x35, 0xAF, 0x60, 0x9A},
147     {0x16, 0x4D, 0x5E, 0x40, 0x4F, 0x27, 0x52, 0x32},
148     {0x6B, 0x05, 0x6E, 0x18, 0x75, 0x9F, 0x5C, 0xCA},
149     {0x00, 0x4B, 0xD6, 0xEF, 0x09, 0x17, 0x60, 0x62},
150     {0x48, 0x0D, 0x39, 0x00, 0x6E, 0xE7, 0x62, 0xF2},
151     {0x43, 0x75, 0x40, 0xC8, 0x69, 0x8F, 0x3C, 0xFA},
152     {0x07, 0x2D, 0x43, 0xA0, 0x77, 0x07, 0x52, 0x92},
153     {0x02, 0xFE, 0x55, 0x77, 0x81, 0x17, 0xF1, 0x2A},
154     {0x1D, 0x9D, 0x5C, 0x50, 0x18, 0xF7, 0x28, 0xC2},
155     {0x30, 0x55, 0x32, 0x28, 0x6D, 0x6F, 0x29, 0x5A},
156     {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
157     {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
158     {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
159     {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
160     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
161     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
162     {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}
163 };
164
165 static unsigned char cipher_data[NUM_TESTS][8] = {
166     {0x8C, 0xA6, 0x4D, 0xE9, 0xC1, 0xB1, 0x23, 0xA7},
167     {0x73, 0x59, 0xB2, 0x16, 0x3E, 0x4E, 0xDC, 0x58},
168     {0x95, 0x8E, 0x6E, 0x62, 0x7A, 0x05, 0x55, 0x7B},
169     {0xF4, 0x03, 0x79, 0xAB, 0x9E, 0x0E, 0xC5, 0x33},
170     {0x17, 0x66, 0x8D, 0xFC, 0x72, 0x92, 0x53, 0x2D},
171     {0x8A, 0x5A, 0xE1, 0xF8, 0x1A, 0xB8, 0xF2, 0xDD},
172     {0x8C, 0xA6, 0x4D, 0xE9, 0xC1, 0xB1, 0x23, 0xA7},
173     {0xED, 0x39, 0xD9, 0x50, 0xFA, 0x74, 0xBC, 0xC4},
174     {0x69, 0x0F, 0x5B, 0x0D, 0x9A, 0x26, 0x93, 0x9B},
175     {0x7A, 0x38, 0x9D, 0x10, 0x35, 0x4B, 0xD2, 0x71},
176     {0x86, 0x8E, 0xBB, 0x51, 0xCA, 0xB4, 0x59, 0x9A},
177     {0x71, 0x78, 0x87, 0x6E, 0x01, 0xF1, 0x9B, 0x2A},
178     {0xAF, 0x37, 0xFB, 0x42, 0x1F, 0x8C, 0x40, 0x95},
179     {0x86, 0xA5, 0x60, 0xF1, 0x0E, 0xC6, 0xD8, 0x5B},
180     {0x0C, 0xD3, 0xDA, 0x02, 0x00, 0x21, 0xDC, 0x09},
181     {0xEA, 0x67, 0x6B, 0x2C, 0xB7, 0xDB, 0x2B, 0x7A},
182     {0xDF, 0xD6, 0x4A, 0x81, 0x5C, 0xAF, 0x1A, 0x0F},
183     {0x5C, 0x51, 0x3C, 0x9C, 0x48, 0x86, 0xC0, 0x88},
184     {0x0A, 0x2A, 0xEE, 0xAE, 0x3F, 0xF4, 0xAB, 0x77},
185     {0xEF, 0x1B, 0xF0, 0x3E, 0x5D, 0xFA, 0x57, 0x5A},
186     {0x88, 0xBF, 0x0D, 0xB6, 0xD7, 0x0D, 0xEE, 0x56},
187     {0xA1, 0xF9, 0x91, 0x55, 0x41, 0x02, 0x0B, 0x56},
188     {0x6F, 0xBF, 0x1C, 0xAF, 0xCF, 0xFD, 0x05, 0x56},
189     {0x2F, 0x22, 0xE4, 0x9B, 0xAB, 0x7C, 0xA1, 0xAC},
190     {0x5A, 0x6B, 0x61, 0x2C, 0xC2, 0x6C, 0xCE, 0x4A},
191     {0x5F, 0x4C, 0x03, 0x8E, 0xD1, 0x2B, 0x2E, 0x41},
192     {0x63, 0xFA, 0xC0, 0xD0, 0x34, 0xD9, 0xF7, 0x93},
193     {0x61, 0x7B, 0x3A, 0x0C, 0xE8, 0xF0, 0x71, 0x00},
194     {0xDB, 0x95, 0x86, 0x05, 0xF8, 0xC8, 0xC6, 0x06},
195     {0xED, 0xBF, 0xD1, 0xC6, 0x6C, 0x29, 0xCC, 0xC7},
196     {0x35, 0x55, 0x50, 0xB2, 0x15, 0x0E, 0x24, 0x51},
197     {0xCA, 0xAA, 0xAF, 0x4D, 0xEA, 0xF1, 0xDB, 0xAE},
198     {0xD5, 0xD4, 0x4F, 0xF7, 0x20, 0x68, 0x3D, 0x0D},
199     {0x2A, 0x2B, 0xB0, 0x08, 0xDF, 0x97, 0xC2, 0xF2}
200 };
201
202 static unsigned char cipher_ecb2[NUM_TESTS - 1][8] = {
203     {0x92, 0x95, 0xB5, 0x9B, 0xB3, 0x84, 0x73, 0x6E},
204     {0x19, 0x9E, 0x9D, 0x6D, 0xF3, 0x9A, 0xA8, 0x16},
205     {0x2A, 0x4B, 0x4D, 0x24, 0x52, 0x43, 0x84, 0x27},
206     {0x35, 0x84, 0x3C, 0x01, 0x9D, 0x18, 0xC5, 0xB6},
207     {0x4A, 0x5B, 0x2F, 0x42, 0xAA, 0x77, 0x19, 0x25},
208     {0xA0, 0x6B, 0xA9, 0xB8, 0xCA, 0x5B, 0x17, 0x8A},
209     {0xAB, 0x9D, 0xB7, 0xFB, 0xED, 0x95, 0xF2, 0x74},
210     {0x3D, 0x25, 0x6C, 0x23, 0xA7, 0x25, 0x2F, 0xD6},
211     {0xB7, 0x6F, 0xAB, 0x4F, 0xBD, 0xBD, 0xB7, 0x67},
212     {0x8F, 0x68, 0x27, 0xD6, 0x9C, 0xF4, 0x1A, 0x10},
213     {0x82, 0x57, 0xA1, 0xD6, 0x50, 0x5E, 0x81, 0x85},
214     {0xA2, 0x0F, 0x0A, 0xCD, 0x80, 0x89, 0x7D, 0xFA},
215     {0xCD, 0x2A, 0x53, 0x3A, 0xDB, 0x0D, 0x7E, 0xF3},
216     {0xD2, 0xC2, 0xBE, 0x27, 0xE8, 0x1B, 0x68, 0xE3},
217     {0xE9, 0x24, 0xCF, 0x4F, 0x89, 0x3C, 0x5B, 0x0A},
218     {0xA7, 0x18, 0xC3, 0x9F, 0xFA, 0x9F, 0xD7, 0x69},
219     {0x77, 0x2C, 0x79, 0xB1, 0xD2, 0x31, 0x7E, 0xB1},
220     {0x49, 0xAB, 0x92, 0x7F, 0xD0, 0x22, 0x00, 0xB7},
221     {0xCE, 0x1C, 0x6C, 0x7D, 0x85, 0xE3, 0x4A, 0x6F},
222     {0xBE, 0x91, 0xD6, 0xE1, 0x27, 0xB2, 0xE9, 0x87},
223     {0x70, 0x28, 0xAE, 0x8F, 0xD1, 0xF5, 0x74, 0x1A},
224     {0xAA, 0x37, 0x80, 0xBB, 0xF3, 0x22, 0x1D, 0xDE},
225     {0xA6, 0xC4, 0xD2, 0x5E, 0x28, 0x93, 0xAC, 0xB3},
226     {0x22, 0x07, 0x81, 0x5A, 0xE4, 0xB7, 0x1A, 0xAD},
227     {0xDC, 0xCE, 0x05, 0xE7, 0x07, 0xBD, 0xF5, 0x84},
228     {0x26, 0x1D, 0x39, 0x2C, 0xB3, 0xBA, 0xA5, 0x85},
229     {0xB4, 0xF7, 0x0F, 0x72, 0xFB, 0x04, 0xF0, 0xDC},
230     {0x95, 0xBA, 0xA9, 0x4E, 0x87, 0x36, 0xF2, 0x89},
231     {0xD4, 0x07, 0x3A, 0xF1, 0x5A, 0x17, 0x82, 0x0E},
232     {0xEF, 0x6F, 0xAF, 0xA7, 0x66, 0x1A, 0x7E, 0x89},
233     {0xC1, 0x97, 0xF5, 0x58, 0x74, 0x8A, 0x20, 0xE7},
234     {0x43, 0x34, 0xCF, 0xDA, 0x22, 0xC4, 0x86, 0xC8},
235     {0x08, 0xD7, 0xB4, 0xFB, 0x62, 0x9D, 0x08, 0x85}
236 };
237
238 static unsigned char cbc_key[8] =
239     { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
240 static unsigned char cbc2_key[8] =
241     { 0xf1, 0xe0, 0xd3, 0xc2, 0xb5, 0xa4, 0x97, 0x86 };
242 static unsigned char cbc3_key[8] =
243     { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
244 static unsigned char cbc_iv[8] =
245     { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
246 /*
247  * Changed the following text constant to binary so it will work on ebcdic
248  * machines :-)
249  */
250 /* static char cbc_data[40]="7654321 Now is the time for \0001"; */
251 static unsigned char cbc_data[40] = {
252     0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20,
253     0x4E, 0x6F, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74,
254     0x68, 0x65, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x20,
255     0x66, 0x6F, 0x72, 0x20, 0x00, 0x31, 0x00, 0x00,
256     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
257 };
258
259 static unsigned char cbc_ok[32] = {
260     0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4,
261     0xac, 0xd8, 0xae, 0xfd, 0xdf, 0xd8, 0xa1, 0xeb,
262     0x46, 0x8e, 0x91, 0x15, 0x78, 0x88, 0xba, 0x68,
263     0x1d, 0x26, 0x93, 0x97, 0xf7, 0xfe, 0x62, 0xb4
264 };
265
266 # ifdef SCREW_THE_PARITY
267 #  error "SCREW_THE_PARITY is not ment to be defined."
268 #  error "Original vectors are preserved for reference only."
269 static unsigned char cbc2_key[8] =
270     { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87 };
271 static unsigned char xcbc_ok[32] = {
272     0x86, 0x74, 0x81, 0x0D, 0x61, 0xA4, 0xA5, 0x48,
273     0xB9, 0x93, 0x03, 0xE1, 0xB8, 0xBB, 0xBD, 0xBD,
274     0x64, 0x30, 0x0B, 0xB9, 0x06, 0x65, 0x81, 0x76,
275     0x04, 0x1D, 0x77, 0x62, 0x17, 0xCA, 0x2B, 0xD2,
276 };
277 # else
278 static unsigned char xcbc_ok[32] = {
279     0x84, 0x6B, 0x29, 0x14, 0x85, 0x1E, 0x9A, 0x29,
280     0x54, 0x73, 0x2F, 0x8A, 0xA0, 0xA6, 0x11, 0xC1,
281     0x15, 0xCD, 0xC2, 0xD7, 0x95, 0x1B, 0x10, 0x53,
282     0xA6, 0x3C, 0x5E, 0x03, 0xB2, 0x1A, 0xA3, 0xC4,
283 };
284 # endif
285
286 static unsigned char cbc3_ok[32] = {
287     0x3F, 0xE3, 0x01, 0xC9, 0x62, 0xAC, 0x01, 0xD0,
288     0x22, 0x13, 0x76, 0x3C, 0x1C, 0xBD, 0x4C, 0xDC,
289     0x79, 0x96, 0x57, 0xC0, 0x64, 0xEC, 0xF5, 0xD4,
290     0x1C, 0x67, 0x38, 0x12, 0xCF, 0xDE, 0x96, 0x75
291 };
292
293 static unsigned char pcbc_ok[32] = {
294     0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4,
295     0x6d, 0xec, 0xb4, 0x70, 0xa0, 0xe5, 0x6b, 0x15,
296     0xae, 0xa6, 0xbf, 0x61, 0xed, 0x7d, 0x9c, 0x9f,
297     0xf7, 0x17, 0x46, 0x3b, 0x8a, 0xb3, 0xcc, 0x88
298 };
299
300 static unsigned char cfb_key[8] =
301     { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
302 static unsigned char cfb_iv[8] =
303     { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef };
304 static unsigned char cfb_buf1[40], cfb_buf2[40], cfb_tmp[8];
305 static unsigned char plain[24] = {
306     0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73,
307     0x20, 0x74, 0x68, 0x65, 0x20, 0x74,
308     0x69, 0x6d, 0x65, 0x20, 0x66, 0x6f,
309     0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20
310 };
311
312 static unsigned char cfb_cipher8[24] = {
313     0xf3, 0x1f, 0xda, 0x07, 0x01, 0x14, 0x62, 0xee, 0x18, 0x7f, 0x43, 0xd8,
314     0x0a, 0x7c, 0xd9, 0xb5, 0xb0, 0xd2, 0x90, 0xda, 0x6e, 0x5b, 0x9a, 0x87
315 };
316
317 static unsigned char cfb_cipher16[24] = {
318     0xF3, 0x09, 0x87, 0x87, 0x7F, 0x57, 0xF7, 0x3C, 0x36, 0xB6, 0xDB, 0x70,
319     0xD8, 0xD5, 0x34, 0x19, 0xD3, 0x86, 0xB2, 0x23, 0xB7, 0xB2, 0xAD, 0x1B
320 };
321
322 static unsigned char cfb_cipher32[24] = {
323     0xF3, 0x09, 0x62, 0x49, 0xA4, 0xDF, 0xA4, 0x9F, 0x33, 0xDC, 0x7B, 0xAD,
324     0x4C, 0xC8, 0x9F, 0x64, 0xE4, 0x53, 0xE5, 0xEC, 0x67, 0x20, 0xDA, 0xB6
325 };
326
327 static unsigned char cfb_cipher48[24] = {
328     0xF3, 0x09, 0x62, 0x49, 0xC7, 0xF4, 0x30, 0xB5, 0x15, 0xEC, 0xBB, 0x85,
329     0x97, 0x5A, 0x13, 0x8C, 0x68, 0x60, 0xE2, 0x38, 0x34, 0x3C, 0xDC, 0x1F
330 };
331
332 static unsigned char cfb_cipher64[24] = {
333     0xF3, 0x09, 0x62, 0x49, 0xC7, 0xF4, 0x6E, 0x51, 0xA6, 0x9E, 0x83, 0x9B,
334     0x1A, 0x92, 0xF7, 0x84, 0x03, 0x46, 0x71, 0x33, 0x89, 0x8E, 0xA6, 0x22
335 };
336
337 static unsigned char ofb_key[8] =
338     { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
339 static unsigned char ofb_iv[8] =
340     { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef };
341 static unsigned char ofb_buf1[24], ofb_buf2[24], ofb_tmp[8];
342 static unsigned char ofb_cipher[24] = {
343     0xf3, 0x09, 0x62, 0x49, 0xc7, 0xf4, 0x6e, 0x51,
344     0x35, 0xf2, 0x4a, 0x24, 0x2e, 0xeb, 0x3d, 0x3f,
345     0x3d, 0x6d, 0x5b, 0xe3, 0x25, 0x5a, 0xf8, 0xc3
346 };
347 static DES_LONG cbc_cksum_ret = 0xF7FE62B4L;
348 static unsigned char cbc_cksum_data[8] =
349     { 0x1D, 0x26, 0x93, 0x97, 0xf7, 0xfe, 0x62, 0xb4 };
350
351 static char *pt(unsigned char *p);
352 static int cfb_test(int bits, unsigned char *cfb_cipher);
353 static int cfb64_test(unsigned char *cfb_cipher);
354 static int ede_cfb64_test(unsigned char *cfb_cipher);
355 int main(int argc, char *argv[])
356 {
357     int j, err = 0;
358     unsigned int i;
359     DES_cblock in, out, outin, iv3;
360     DES_key_schedule ks, ks2, ks3;
361     unsigned char cbc_in[40];
362     unsigned char cbc_out[40];
363     DES_LONG cs;
364     unsigned char cret[8];
365     DES_LONG lqret[4];
366     int num;
367     char *str;
368
369     printf("Doing ecb\n");
370     for (i = 0; i < NUM_TESTS; i++) {
371         DES_set_key_unchecked(&key_data[i], &ks);
372         memcpy(in, plain_data[i], 8);
373         memset(out, 0, 8);
374         memset(outin, 0, 8);
375         DES_ecb_encrypt(&in, &out, &ks, DES_ENCRYPT);
376         DES_ecb_encrypt(&out, &outin, &ks, DES_DECRYPT);
377
378         if (memcmp(out, cipher_data[i], 8) != 0) {
379             printf("Encryption error %2d\nk=%s p=%s o=%s act=%s\n",
380                    i + 1, pt(key_data[i]), pt(in), pt(cipher_data[i]),
381                    pt(out));
382             err = 1;
383         }
384         if (memcmp(in, outin, 8) != 0) {
385             printf("Decryption error %2d\nk=%s p=%s o=%s act=%s\n",
386                    i + 1, pt(key_data[i]), pt(out), pt(in), pt(outin));
387             err = 1;
388         }
389     }
390
391 # ifndef LIBDES_LIT
392     printf("Doing ede ecb\n");
393     for (i = 0; i < (NUM_TESTS - 2); i++) {
394         DES_set_key_unchecked(&key_data[i], &ks);
395         DES_set_key_unchecked(&key_data[i + 1], &ks2);
396         DES_set_key_unchecked(&key_data[i + 2], &ks3);
397         memcpy(in, plain_data[i], 8);
398         memset(out, 0, 8);
399         memset(outin, 0, 8);
400         DES_ecb3_encrypt(&in,&out,&ks,&ks2,&ks,DES_ENCRYPT);
401         DES_ecb3_encrypt(&out,&outin,&ks,&ks2,&ks,DES_DECRYPT);
402
403         if (memcmp(out, cipher_ecb2[i], 8) != 0) {
404             printf("Encryption error %2d\nk=%s p=%s o=%s act=%s\n",
405                    i + 1, pt(key_data[i]), pt(in), pt(cipher_ecb2[i]),
406                    pt(out));
407             err = 1;
408         }
409         if (memcmp(in, outin, 8) != 0) {
410             printf("Decryption error %2d\nk=%s p=%s o=%s act=%s\n",
411                    i + 1, pt(key_data[i]), pt(out), pt(in), pt(outin));
412             err = 1;
413         }
414     }
415 # endif
416
417     printf("Doing cbc\n");
418     if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
419         printf("Key error %d\n", j);
420         err = 1;
421     }
422     memset(cbc_out, 0, 40);
423     memset(cbc_in, 0, 40);
424     memcpy(iv3, cbc_iv, sizeof(cbc_iv));
425     DES_ncbc_encrypt(cbc_data, cbc_out, strlen((char *)cbc_data) + 1, &ks,
426                      &iv3, DES_ENCRYPT);
427     if (memcmp(cbc_out, cbc_ok, 32) != 0) {
428         printf("cbc_encrypt encrypt error\n");
429         err = 1;
430     }
431
432     memcpy(iv3, cbc_iv, sizeof(cbc_iv));
433     DES_ncbc_encrypt(cbc_out, cbc_in, strlen((char *)cbc_data) + 1, &ks,
434                      &iv3, DES_DECRYPT);
435     if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data)) != 0) {
436         printf("cbc_encrypt decrypt error\n");
437         err = 1;
438     }
439 # ifndef LIBDES_LIT
440     printf("Doing desx cbc\n");
441     if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
442         printf("Key error %d\n", j);
443         err = 1;
444     }
445     memset(cbc_out, 0, 40);
446     memset(cbc_in, 0, 40);
447     memcpy(iv3, cbc_iv, sizeof(cbc_iv));
448     DES_xcbc_encrypt(cbc_data, cbc_out, strlen((char *)cbc_data) + 1, &ks,
449                      &iv3, &cbc2_key, &cbc3_key, DES_ENCRYPT);
450     if (memcmp(cbc_out, xcbc_ok, 32) != 0) {
451         printf("des_xcbc_encrypt encrypt error\n");
452         err = 1;
453     }
454     memcpy(iv3, cbc_iv, sizeof(cbc_iv));
455     DES_xcbc_encrypt(cbc_out, cbc_in, strlen((char *)cbc_data) + 1, &ks,
456                      &iv3, &cbc2_key, &cbc3_key, DES_DECRYPT);
457     if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data) + 1) != 0) {
458         printf("des_xcbc_encrypt decrypt error\n");
459         err = 1;
460     }
461 # endif
462
463     printf("Doing ede cbc\n");
464     if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
465         printf("Key error %d\n", j);
466         err = 1;
467     }
468     if ((j = DES_set_key_checked(&cbc2_key, &ks2)) != 0) {
469         printf("Key error %d\n", j);
470         err = 1;
471     }
472     if ((j = DES_set_key_checked(&cbc3_key, &ks3)) != 0) {
473         printf("Key error %d\n", j);
474         err = 1;
475     }
476     memset(cbc_out, 0, 40);
477     memset(cbc_in, 0, 40);
478     i = strlen((char *)cbc_data) + 1;
479     /* i=((i+7)/8)*8; */
480     memcpy(iv3, cbc_iv, sizeof(cbc_iv));
481
482     DES_ede3_cbc_encrypt(cbc_data, cbc_out, 16L, &ks, &ks2, &ks3, &iv3,
483                          DES_ENCRYPT);
484     DES_ede3_cbc_encrypt(&(cbc_data[16]), &(cbc_out[16]), i - 16, &ks, &ks2,
485                          &ks3, &iv3, DES_ENCRYPT);
486     if (memcmp
487         (cbc_out, cbc3_ok,
488          (unsigned int)(strlen((char *)cbc_data) + 1 + 7) / 8 * 8) != 0) {
489         unsigned int n;
490
491         printf("des_ede3_cbc_encrypt encrypt error\n");
492         for (n = 0; n < i; ++n)
493             printf(" %02x", cbc_out[n]);
494         printf("\n");
495         for (n = 0; n < i; ++n)
496             printf(" %02x", cbc3_ok[n]);
497         printf("\n");
498         err = 1;
499     }
500
501     memcpy(iv3, cbc_iv, sizeof(cbc_iv));
502     DES_ede3_cbc_encrypt(cbc_out, cbc_in, i, &ks, &ks2, &ks3, &iv3, DES_DECRYPT);
503     if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data) + 1) != 0) {
504         unsigned int n;
505
506         printf("DES_ede3_cbc_encrypt decrypt error\n");
507         for (n = 0; n < i; ++n)
508             printf(" %02x", cbc_data[n]);
509         printf("\n");
510         for (n = 0; n < i; ++n)
511             printf(" %02x", cbc_in[n]);
512         printf("\n");
513         err = 1;
514     }
515 # ifndef LIBDES_LIT
516     printf("Doing pcbc\n");
517     if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
518         printf("Key error %d\n", j);
519         err = 1;
520     }
521     memset(cbc_out, 0, 40);
522     memset(cbc_in, 0, 40);
523     DES_pcbc_encrypt(cbc_data, cbc_out, strlen((char *)cbc_data) + 1, &ks,
524                      &cbc_iv, DES_ENCRYPT);
525     if (memcmp(cbc_out, pcbc_ok, 32) != 0) {
526         printf("pcbc_encrypt encrypt error\n");
527         err = 1;
528     }
529     DES_pcbc_encrypt(cbc_out, cbc_in, strlen((char *)cbc_data) + 1, &ks,
530                      &cbc_iv, DES_DECRYPT);
531     if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data) + 1) != 0) {
532         printf("pcbc_encrypt decrypt error\n");
533         err = 1;
534     }
535
536     printf("Doing ");
537     printf("cfb8 ");
538     err += cfb_test(8, cfb_cipher8);
539     printf("cfb16 ");
540     err += cfb_test(16, cfb_cipher16);
541     printf("cfb32 ");
542     err += cfb_test(32, cfb_cipher32);
543     printf("cfb48 ");
544     err += cfb_test(48, cfb_cipher48);
545     printf("cfb64 ");
546     err += cfb_test(64, cfb_cipher64);
547
548     printf("cfb64() ");
549     err += cfb64_test(cfb_cipher64);
550
551     memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
552     for (i = 0; i < sizeof(plain); i++)
553         DES_cfb_encrypt(&(plain[i]), &(cfb_buf1[i]),
554                         8, 1, &ks, &cfb_tmp, DES_ENCRYPT);
555     if (memcmp(cfb_cipher8, cfb_buf1, sizeof(plain)) != 0) {
556         printf("cfb_encrypt small encrypt error\n");
557         err = 1;
558     }
559
560     memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
561     for (i = 0; i < sizeof(plain); i++)
562         DES_cfb_encrypt(&(cfb_buf1[i]), &(cfb_buf2[i]),
563                         8, 1, &ks, &cfb_tmp, DES_DECRYPT);
564     if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
565         printf("cfb_encrypt small decrypt error\n");
566         err = 1;
567     }
568
569     printf("ede_cfb64() ");
570     err += ede_cfb64_test(cfb_cipher64);
571
572     printf("done\n");
573
574     printf("Doing ofb\n");
575     DES_set_key_checked(&ofb_key, &ks);
576     memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
577     DES_ofb_encrypt(plain, ofb_buf1, 64, sizeof(plain) / 8, &ks, &ofb_tmp);
578     if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) {
579         printf("ofb_encrypt encrypt error\n");
580         printf("%02X %02X %02X %02X %02X %02X %02X %02X\n",
581                ofb_buf1[8 + 0], ofb_buf1[8 + 1], ofb_buf1[8 + 2],
582                ofb_buf1[8 + 3], ofb_buf1[8 + 4], ofb_buf1[8 + 5],
583                ofb_buf1[8 + 6], ofb_buf1[8 + 7]);
584         printf("%02X %02X %02X %02X %02X %02X %02X %02X\n", ofb_buf1[8 + 0],
585                ofb_cipher[8 + 1], ofb_cipher[8 + 2], ofb_cipher[8 + 3],
586                ofb_buf1[8 + 4], ofb_cipher[8 + 5], ofb_cipher[8 + 6],
587                ofb_cipher[8 + 7]);
588         err = 1;
589     }
590     memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
591     DES_ofb_encrypt(ofb_buf1, ofb_buf2, 64, sizeof(ofb_buf1) / 8, &ks,
592                     &ofb_tmp);
593     if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) {
594         printf("ofb_encrypt decrypt error\n");
595         printf("%02X %02X %02X %02X %02X %02X %02X %02X\n",
596                ofb_buf2[8 + 0], ofb_buf2[8 + 1], ofb_buf2[8 + 2],
597                ofb_buf2[8 + 3], ofb_buf2[8 + 4], ofb_buf2[8 + 5],
598                ofb_buf2[8 + 6], ofb_buf2[8 + 7]);
599         printf("%02X %02X %02X %02X %02X %02X %02X %02X\n", plain[8 + 0],
600                plain[8 + 1], plain[8 + 2], plain[8 + 3], plain[8 + 4],
601                plain[8 + 5], plain[8 + 6], plain[8 + 7]);
602         err = 1;
603     }
604
605     printf("Doing ofb64\n");
606     DES_set_key_checked(&ofb_key, &ks);
607     memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
608     memset(ofb_buf1, 0, sizeof(ofb_buf1));
609     memset(ofb_buf2, 0, sizeof(ofb_buf1));
610     num = 0;
611     for (i = 0; i < sizeof(plain); i++) {
612         DES_ofb64_encrypt(&(plain[i]), &(ofb_buf1[i]), 1, &ks, &ofb_tmp, &num);
613     }
614     if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) {
615         printf("ofb64_encrypt encrypt error\n");
616         err = 1;
617     }
618     memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
619     num = 0;
620     DES_ofb64_encrypt(ofb_buf1, ofb_buf2, sizeof(ofb_buf1), &ks, &ofb_tmp,
621                       &num);
622     if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) {
623         printf("ofb64_encrypt decrypt error\n");
624         err = 1;
625     }
626
627     printf("Doing ede_ofb64\n");
628     DES_set_key_checked(&ofb_key, &ks);
629     memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
630     memset(ofb_buf1, 0, sizeof(ofb_buf1));
631     memset(ofb_buf2, 0, sizeof(ofb_buf1));
632     num = 0;
633     for (i = 0; i < sizeof(plain); i++) {
634         DES_ede3_ofb64_encrypt(&(plain[i]), &(ofb_buf1[i]), 1, &ks, &ks,
635                                &ks, &ofb_tmp, &num);
636     }
637     if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) {
638         printf("ede_ofb64_encrypt encrypt error\n");
639         err = 1;
640     }
641     memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
642     num = 0;
643     DES_ede3_ofb64_encrypt(ofb_buf1, ofb_buf2, sizeof(ofb_buf1), &ks, &ks, &ks,
644                            &ofb_tmp, &num);
645     if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) {
646         printf("ede_ofb64_encrypt decrypt error\n");
647         err = 1;
648     }
649
650     printf("Doing cbc_cksum\n");
651     DES_set_key_checked(&cbc_key, &ks);
652     cs = DES_cbc_cksum(cbc_data, &cret, strlen((char *)cbc_data), &ks,
653                        &cbc_iv);
654     if (cs != cbc_cksum_ret) {
655         printf("bad return value (%08lX), should be %08lX\n",
656                (unsigned long)cs, (unsigned long)cbc_cksum_ret);
657         err = 1;
658     }
659     if (memcmp(cret, cbc_cksum_data, 8) != 0) {
660         printf("bad cbc_cksum block returned\n");
661         err = 1;
662     }
663
664     printf("Doing quad_cksum\n");
665     cs = DES_quad_cksum(cbc_data, (DES_cblock *)lqret,
666                         (long)strlen((char *)cbc_data), 2,
667                         (DES_cblock *)cbc_iv);
668     if (cs != 0x70d7a63aL) {
669         printf("quad_cksum error, ret %08lx should be 70d7a63a\n",
670                (unsigned long)cs);
671         err = 1;
672     }
673     if (lqret[0] != 0x327eba8dL) {
674         printf("quad_cksum error, out[0] %08lx is not %08lx\n",
675                (unsigned long)lqret[0], 0x327eba8dUL);
676         err = 1;
677     }
678     if (lqret[1] != 0x201a49ccL) {
679         printf("quad_cksum error, out[1] %08lx is not %08lx\n",
680                (unsigned long)lqret[1], 0x201a49ccUL);
681         err = 1;
682     }
683     if (lqret[2] != 0x70d7a63aL) {
684         printf("quad_cksum error, out[2] %08lx is not %08lx\n",
685                (unsigned long)lqret[2], 0x70d7a63aUL);
686         err = 1;
687     }
688     if (lqret[3] != 0x501c2c26L) {
689         printf("quad_cksum error, out[3] %08lx is not %08lx\n",
690                (unsigned long)lqret[3], 0x501c2c26UL);
691         err = 1;
692     }
693 # endif
694
695     printf("input word alignment test");
696     for (i = 0; i < 4; i++) {
697         printf(" %d", i);
698         DES_ncbc_encrypt(&(cbc_out[i]), cbc_in,
699                          strlen((char *)cbc_data) + 1, &ks,
700                          &cbc_iv, DES_ENCRYPT);
701     }
702     printf("\noutput word alignment test");
703     for (i = 0; i < 4; i++) {
704         printf(" %d", i);
705         DES_ncbc_encrypt(cbc_out, &(cbc_in[i]),
706                          strlen((char *)cbc_data) + 1, &ks,
707                          &cbc_iv, DES_ENCRYPT);
708     }
709     printf("\n");
710     printf("fast crypt test ");
711     str = crypt("testing", "ef");
712     if (strcmp("efGnQx2725bI2", str) != 0) {
713         printf("fast crypt error, %s should be efGnQx2725bI2\n", str);
714         err = 1;
715     }
716     str = crypt("bca76;23", "yA");
717     if (strcmp("yA1Rp/1hZXIJk", str) != 0) {
718         printf("fast crypt error, %s should be yA1Rp/1hZXIJk\n", str);
719         err = 1;
720     }
721     printf("\n");
722     return (err);
723 }
724
725 static char *pt(unsigned char *p)
726 {
727     static char bufs[10][20];
728     static int bnum = 0;
729     char *ret;
730     int i;
731     static char *f = "0123456789ABCDEF";
732
733     ret = &(bufs[bnum++][0]);
734     bnum %= 10;
735     for (i = 0; i < 8; i++) {
736         ret[i * 2] = f[(p[i] >> 4) & 0xf];
737         ret[i * 2 + 1] = f[p[i] & 0xf];
738     }
739     ret[16] = '\0';
740     return (ret);
741 }
742
743 # ifndef LIBDES_LIT
744
745 static int cfb_test(int bits, unsigned char *cfb_cipher)
746 {
747     DES_key_schedule ks;
748     int i, err = 0;
749
750     DES_set_key_checked(&cfb_key, &ks);
751     memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
752     DES_cfb_encrypt(plain, cfb_buf1, bits, sizeof(plain), &ks, &cfb_tmp,
753                     DES_ENCRYPT);
754     if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0) {
755         err = 1;
756         printf("cfb_encrypt encrypt error\n");
757         for (i = 0; i < 24; i += 8)
758             printf("%s\n", pt(&(cfb_buf1[i])));
759     }
760     memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
761     DES_cfb_encrypt(cfb_buf1, cfb_buf2, bits, sizeof(plain), &ks, &cfb_tmp,
762                     DES_DECRYPT);
763     if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
764         err = 1;
765         printf("cfb_encrypt decrypt error\n");
766         for (i = 0; i < 24; i += 8)
767             printf("%s\n", pt(&(cfb_buf1[i])));
768     }
769     return (err);
770 }
771
772 static int cfb64_test(unsigned char *cfb_cipher)
773 {
774     DES_key_schedule ks;
775     int err = 0, i, n;
776
777     DES_set_key_checked(&cfb_key, &ks);
778     memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
779     n = 0;
780     DES_cfb64_encrypt(plain, cfb_buf1, 12, &ks, &cfb_tmp, &n, DES_ENCRYPT);
781     DES_cfb64_encrypt(&(plain[12]), &(cfb_buf1[12]), sizeof(plain) - 12, &ks,
782                       &cfb_tmp, &n, DES_ENCRYPT);
783     if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0) {
784         err = 1;
785         printf("cfb_encrypt encrypt error\n");
786         for (i = 0; i < 24; i += 8)
787             printf("%s\n", pt(&(cfb_buf1[i])));
788     }
789     memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
790     n = 0;
791     DES_cfb64_encrypt(cfb_buf1, cfb_buf2, 17, &ks, &cfb_tmp, &n, DES_DECRYPT);
792     DES_cfb64_encrypt(&(cfb_buf1[17]), &(cfb_buf2[17]),
793                       sizeof(plain) - 17, &ks, &cfb_tmp, &n, DES_DECRYPT);
794     if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
795         err = 1;
796         printf("cfb_encrypt decrypt error\n");
797         for (i = 0; i < 24; i += 8)
798             printf("%s\n", pt(&(cfb_buf2[i])));
799     }
800     return (err);
801 }
802
803 static int ede_cfb64_test(unsigned char *cfb_cipher)
804 {
805     DES_key_schedule ks;
806     int err = 0, i, n;
807
808     DES_set_key_checked(&cfb_key, &ks);
809     memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
810     n = 0;
811     DES_ede3_cfb64_encrypt(plain, cfb_buf1, 12, &ks, &ks, &ks, &cfb_tmp, &n,
812                            DES_ENCRYPT);
813     DES_ede3_cfb64_encrypt(&(plain[12]), &(cfb_buf1[12]),
814                            sizeof(plain) - 12, &ks, &ks, &ks,
815                            &cfb_tmp, &n, DES_ENCRYPT);
816     if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0) {
817         err = 1;
818         printf("ede_cfb_encrypt encrypt error\n");
819         for (i = 0; i < 24; i += 8)
820             printf("%s\n", pt(&(cfb_buf1[i])));
821     }
822     memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
823     n = 0;
824     DES_ede3_cfb64_encrypt(cfb_buf1, cfb_buf2, (long)17, &ks, &ks, &ks,
825                            &cfb_tmp, &n, DES_DECRYPT);
826     DES_ede3_cfb64_encrypt(&(cfb_buf1[17]), &(cfb_buf2[17]),
827                            sizeof(plain) - 17, &ks, &ks, &ks,
828                            &cfb_tmp, &n, DES_DECRYPT);
829     if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
830         err = 1;
831         printf("ede_cfb_encrypt decrypt error\n");
832         for (i = 0; i < 24; i += 8)
833             printf("%s\n", pt(&(cfb_buf2[i])));
834     }
835     return (err);
836 }
837
838 # endif
839 #endif