1 /* crypto/des/destest.c */
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
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.
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).
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.
23 * Redistribution and use in source and binary forms, with or without
24 * modification, are permitted provided that the following conditions
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)"
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
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.]
62 #include <openssl/e_os2.h>
63 #if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_WIN16) || defined(OPENSSL_SYS_WINDOWS)
64 # ifndef OPENSSL_SYS_MSDOS
65 # define OPENSSL_SYS_MSDOS
69 #ifndef OPENSSL_SYS_MSDOS
70 # if !defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_VMS_DECC)
71 # include OPENSSL_UNISTD
79 int main(int argc, char *argv[])
81 printf("No DES support\n");
85 # include <openssl/des.h>
87 # define crypt(c,s) (DES_crypt((c),(s)))
89 /* tisk tisk - the test keys don't all have odd parity :-( */
92 static unsigned char key_data[NUM_TESTS][8] = {
93 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
94 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
95 {0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
96 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
97 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
98 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
99 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
100 {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10},
101 {0x7C, 0xA1, 0x10, 0x45, 0x4A, 0x1A, 0x6E, 0x57},
102 {0x01, 0x31, 0xD9, 0x61, 0x9D, 0xC1, 0x37, 0x6E},
103 {0x07, 0xA1, 0x13, 0x3E, 0x4A, 0x0B, 0x26, 0x86},
104 {0x38, 0x49, 0x67, 0x4C, 0x26, 0x02, 0x31, 0x9E},
105 {0x04, 0xB9, 0x15, 0xBA, 0x43, 0xFE, 0xB5, 0xB6},
106 {0x01, 0x13, 0xB9, 0x70, 0xFD, 0x34, 0xF2, 0xCE},
107 {0x01, 0x70, 0xF1, 0x75, 0x46, 0x8F, 0xB5, 0xE6},
108 {0x43, 0x29, 0x7F, 0xAD, 0x38, 0xE3, 0x73, 0xFE},
109 {0x07, 0xA7, 0x13, 0x70, 0x45, 0xDA, 0x2A, 0x16},
110 {0x04, 0x68, 0x91, 0x04, 0xC2, 0xFD, 0x3B, 0x2F},
111 {0x37, 0xD0, 0x6B, 0xB5, 0x16, 0xCB, 0x75, 0x46},
112 {0x1F, 0x08, 0x26, 0x0D, 0x1A, 0xC2, 0x46, 0x5E},
113 {0x58, 0x40, 0x23, 0x64, 0x1A, 0xBA, 0x61, 0x76},
114 {0x02, 0x58, 0x16, 0x16, 0x46, 0x29, 0xB0, 0x07},
115 {0x49, 0x79, 0x3E, 0xBC, 0x79, 0xB3, 0x25, 0x8F},
116 {0x4F, 0xB0, 0x5E, 0x15, 0x15, 0xAB, 0x73, 0xA7},
117 {0x49, 0xE9, 0x5D, 0x6D, 0x4C, 0xA2, 0x29, 0xBF},
118 {0x01, 0x83, 0x10, 0xDC, 0x40, 0x9B, 0x26, 0xD6},
119 {0x1C, 0x58, 0x7F, 0x1C, 0x13, 0x92, 0x4F, 0xEF},
120 {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
121 {0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E},
122 {0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE},
123 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
124 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
125 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
126 {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}
129 static unsigned char plain_data[NUM_TESTS][8] = {
130 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
131 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
132 {0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
133 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
134 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
135 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
136 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
137 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
138 {0x01, 0xA1, 0xD6, 0xD0, 0x39, 0x77, 0x67, 0x42},
139 {0x5C, 0xD5, 0x4C, 0xA8, 0x3D, 0xEF, 0x57, 0xDA},
140 {0x02, 0x48, 0xD4, 0x38, 0x06, 0xF6, 0x71, 0x72},
141 {0x51, 0x45, 0x4B, 0x58, 0x2D, 0xDF, 0x44, 0x0A},
142 {0x42, 0xFD, 0x44, 0x30, 0x59, 0x57, 0x7F, 0xA2},
143 {0x05, 0x9B, 0x5E, 0x08, 0x51, 0xCF, 0x14, 0x3A},
144 {0x07, 0x56, 0xD8, 0xE0, 0x77, 0x47, 0x61, 0xD2},
145 {0x76, 0x25, 0x14, 0xB8, 0x29, 0xBF, 0x48, 0x6A},
146 {0x3B, 0xDD, 0x11, 0x90, 0x49, 0x37, 0x28, 0x02},
147 {0x26, 0x95, 0x5F, 0x68, 0x35, 0xAF, 0x60, 0x9A},
148 {0x16, 0x4D, 0x5E, 0x40, 0x4F, 0x27, 0x52, 0x32},
149 {0x6B, 0x05, 0x6E, 0x18, 0x75, 0x9F, 0x5C, 0xCA},
150 {0x00, 0x4B, 0xD6, 0xEF, 0x09, 0x17, 0x60, 0x62},
151 {0x48, 0x0D, 0x39, 0x00, 0x6E, 0xE7, 0x62, 0xF2},
152 {0x43, 0x75, 0x40, 0xC8, 0x69, 0x8F, 0x3C, 0xFA},
153 {0x07, 0x2D, 0x43, 0xA0, 0x77, 0x07, 0x52, 0x92},
154 {0x02, 0xFE, 0x55, 0x77, 0x81, 0x17, 0xF1, 0x2A},
155 {0x1D, 0x9D, 0x5C, 0x50, 0x18, 0xF7, 0x28, 0xC2},
156 {0x30, 0x55, 0x32, 0x28, 0x6D, 0x6F, 0x29, 0x5A},
157 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
158 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
159 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
160 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
161 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
162 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
163 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}
166 static unsigned char cipher_data[NUM_TESTS][8] = {
167 {0x8C, 0xA6, 0x4D, 0xE9, 0xC1, 0xB1, 0x23, 0xA7},
168 {0x73, 0x59, 0xB2, 0x16, 0x3E, 0x4E, 0xDC, 0x58},
169 {0x95, 0x8E, 0x6E, 0x62, 0x7A, 0x05, 0x55, 0x7B},
170 {0xF4, 0x03, 0x79, 0xAB, 0x9E, 0x0E, 0xC5, 0x33},
171 {0x17, 0x66, 0x8D, 0xFC, 0x72, 0x92, 0x53, 0x2D},
172 {0x8A, 0x5A, 0xE1, 0xF8, 0x1A, 0xB8, 0xF2, 0xDD},
173 {0x8C, 0xA6, 0x4D, 0xE9, 0xC1, 0xB1, 0x23, 0xA7},
174 {0xED, 0x39, 0xD9, 0x50, 0xFA, 0x74, 0xBC, 0xC4},
175 {0x69, 0x0F, 0x5B, 0x0D, 0x9A, 0x26, 0x93, 0x9B},
176 {0x7A, 0x38, 0x9D, 0x10, 0x35, 0x4B, 0xD2, 0x71},
177 {0x86, 0x8E, 0xBB, 0x51, 0xCA, 0xB4, 0x59, 0x9A},
178 {0x71, 0x78, 0x87, 0x6E, 0x01, 0xF1, 0x9B, 0x2A},
179 {0xAF, 0x37, 0xFB, 0x42, 0x1F, 0x8C, 0x40, 0x95},
180 {0x86, 0xA5, 0x60, 0xF1, 0x0E, 0xC6, 0xD8, 0x5B},
181 {0x0C, 0xD3, 0xDA, 0x02, 0x00, 0x21, 0xDC, 0x09},
182 {0xEA, 0x67, 0x6B, 0x2C, 0xB7, 0xDB, 0x2B, 0x7A},
183 {0xDF, 0xD6, 0x4A, 0x81, 0x5C, 0xAF, 0x1A, 0x0F},
184 {0x5C, 0x51, 0x3C, 0x9C, 0x48, 0x86, 0xC0, 0x88},
185 {0x0A, 0x2A, 0xEE, 0xAE, 0x3F, 0xF4, 0xAB, 0x77},
186 {0xEF, 0x1B, 0xF0, 0x3E, 0x5D, 0xFA, 0x57, 0x5A},
187 {0x88, 0xBF, 0x0D, 0xB6, 0xD7, 0x0D, 0xEE, 0x56},
188 {0xA1, 0xF9, 0x91, 0x55, 0x41, 0x02, 0x0B, 0x56},
189 {0x6F, 0xBF, 0x1C, 0xAF, 0xCF, 0xFD, 0x05, 0x56},
190 {0x2F, 0x22, 0xE4, 0x9B, 0xAB, 0x7C, 0xA1, 0xAC},
191 {0x5A, 0x6B, 0x61, 0x2C, 0xC2, 0x6C, 0xCE, 0x4A},
192 {0x5F, 0x4C, 0x03, 0x8E, 0xD1, 0x2B, 0x2E, 0x41},
193 {0x63, 0xFA, 0xC0, 0xD0, 0x34, 0xD9, 0xF7, 0x93},
194 {0x61, 0x7B, 0x3A, 0x0C, 0xE8, 0xF0, 0x71, 0x00},
195 {0xDB, 0x95, 0x86, 0x05, 0xF8, 0xC8, 0xC6, 0x06},
196 {0xED, 0xBF, 0xD1, 0xC6, 0x6C, 0x29, 0xCC, 0xC7},
197 {0x35, 0x55, 0x50, 0xB2, 0x15, 0x0E, 0x24, 0x51},
198 {0xCA, 0xAA, 0xAF, 0x4D, 0xEA, 0xF1, 0xDB, 0xAE},
199 {0xD5, 0xD4, 0x4F, 0xF7, 0x20, 0x68, 0x3D, 0x0D},
200 {0x2A, 0x2B, 0xB0, 0x08, 0xDF, 0x97, 0xC2, 0xF2}
203 static unsigned char cipher_ecb2[NUM_TESTS - 1][8] = {
204 {0x92, 0x95, 0xB5, 0x9B, 0xB3, 0x84, 0x73, 0x6E},
205 {0x19, 0x9E, 0x9D, 0x6D, 0xF3, 0x9A, 0xA8, 0x16},
206 {0x2A, 0x4B, 0x4D, 0x24, 0x52, 0x43, 0x84, 0x27},
207 {0x35, 0x84, 0x3C, 0x01, 0x9D, 0x18, 0xC5, 0xB6},
208 {0x4A, 0x5B, 0x2F, 0x42, 0xAA, 0x77, 0x19, 0x25},
209 {0xA0, 0x6B, 0xA9, 0xB8, 0xCA, 0x5B, 0x17, 0x8A},
210 {0xAB, 0x9D, 0xB7, 0xFB, 0xED, 0x95, 0xF2, 0x74},
211 {0x3D, 0x25, 0x6C, 0x23, 0xA7, 0x25, 0x2F, 0xD6},
212 {0xB7, 0x6F, 0xAB, 0x4F, 0xBD, 0xBD, 0xB7, 0x67},
213 {0x8F, 0x68, 0x27, 0xD6, 0x9C, 0xF4, 0x1A, 0x10},
214 {0x82, 0x57, 0xA1, 0xD6, 0x50, 0x5E, 0x81, 0x85},
215 {0xA2, 0x0F, 0x0A, 0xCD, 0x80, 0x89, 0x7D, 0xFA},
216 {0xCD, 0x2A, 0x53, 0x3A, 0xDB, 0x0D, 0x7E, 0xF3},
217 {0xD2, 0xC2, 0xBE, 0x27, 0xE8, 0x1B, 0x68, 0xE3},
218 {0xE9, 0x24, 0xCF, 0x4F, 0x89, 0x3C, 0x5B, 0x0A},
219 {0xA7, 0x18, 0xC3, 0x9F, 0xFA, 0x9F, 0xD7, 0x69},
220 {0x77, 0x2C, 0x79, 0xB1, 0xD2, 0x31, 0x7E, 0xB1},
221 {0x49, 0xAB, 0x92, 0x7F, 0xD0, 0x22, 0x00, 0xB7},
222 {0xCE, 0x1C, 0x6C, 0x7D, 0x85, 0xE3, 0x4A, 0x6F},
223 {0xBE, 0x91, 0xD6, 0xE1, 0x27, 0xB2, 0xE9, 0x87},
224 {0x70, 0x28, 0xAE, 0x8F, 0xD1, 0xF5, 0x74, 0x1A},
225 {0xAA, 0x37, 0x80, 0xBB, 0xF3, 0x22, 0x1D, 0xDE},
226 {0xA6, 0xC4, 0xD2, 0x5E, 0x28, 0x93, 0xAC, 0xB3},
227 {0x22, 0x07, 0x81, 0x5A, 0xE4, 0xB7, 0x1A, 0xAD},
228 {0xDC, 0xCE, 0x05, 0xE7, 0x07, 0xBD, 0xF5, 0x84},
229 {0x26, 0x1D, 0x39, 0x2C, 0xB3, 0xBA, 0xA5, 0x85},
230 {0xB4, 0xF7, 0x0F, 0x72, 0xFB, 0x04, 0xF0, 0xDC},
231 {0x95, 0xBA, 0xA9, 0x4E, 0x87, 0x36, 0xF2, 0x89},
232 {0xD4, 0x07, 0x3A, 0xF1, 0x5A, 0x17, 0x82, 0x0E},
233 {0xEF, 0x6F, 0xAF, 0xA7, 0x66, 0x1A, 0x7E, 0x89},
234 {0xC1, 0x97, 0xF5, 0x58, 0x74, 0x8A, 0x20, 0xE7},
235 {0x43, 0x34, 0xCF, 0xDA, 0x22, 0xC4, 0x86, 0xC8},
236 {0x08, 0xD7, 0xB4, 0xFB, 0x62, 0x9D, 0x08, 0x85}
239 static unsigned char cbc_key[8] =
240 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
241 static unsigned char cbc2_key[8] =
242 { 0xf1, 0xe0, 0xd3, 0xc2, 0xb5, 0xa4, 0x97, 0x86 };
243 static unsigned char cbc3_key[8] =
244 { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
245 static unsigned char cbc_iv[8] =
246 { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
248 * Changed the following text constant to binary so it will work on ebcdic
251 /* static char cbc_data[40]="7654321 Now is the time for \0001"; */
252 static unsigned char cbc_data[40] = {
253 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20,
254 0x4E, 0x6F, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74,
255 0x68, 0x65, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x20,
256 0x66, 0x6F, 0x72, 0x20, 0x00, 0x31, 0x00, 0x00,
257 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
260 static unsigned char cbc_ok[32] = {
261 0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4,
262 0xac, 0xd8, 0xae, 0xfd, 0xdf, 0xd8, 0xa1, 0xeb,
263 0x46, 0x8e, 0x91, 0x15, 0x78, 0x88, 0xba, 0x68,
264 0x1d, 0x26, 0x93, 0x97, 0xf7, 0xfe, 0x62, 0xb4
267 # ifdef SCREW_THE_PARITY
268 # error "SCREW_THE_PARITY is not ment to be defined."
269 # error "Original vectors are preserved for reference only."
270 static unsigned char cbc2_key[8] =
271 { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87 };
272 static unsigned char xcbc_ok[32] = {
273 0x86, 0x74, 0x81, 0x0D, 0x61, 0xA4, 0xA5, 0x48,
274 0xB9, 0x93, 0x03, 0xE1, 0xB8, 0xBB, 0xBD, 0xBD,
275 0x64, 0x30, 0x0B, 0xB9, 0x06, 0x65, 0x81, 0x76,
276 0x04, 0x1D, 0x77, 0x62, 0x17, 0xCA, 0x2B, 0xD2,
279 static unsigned char xcbc_ok[32] = {
280 0x84, 0x6B, 0x29, 0x14, 0x85, 0x1E, 0x9A, 0x29,
281 0x54, 0x73, 0x2F, 0x8A, 0xA0, 0xA6, 0x11, 0xC1,
282 0x15, 0xCD, 0xC2, 0xD7, 0x95, 0x1B, 0x10, 0x53,
283 0xA6, 0x3C, 0x5E, 0x03, 0xB2, 0x1A, 0xA3, 0xC4,
287 static unsigned char cbc3_ok[32] = {
288 0x3F, 0xE3, 0x01, 0xC9, 0x62, 0xAC, 0x01, 0xD0,
289 0x22, 0x13, 0x76, 0x3C, 0x1C, 0xBD, 0x4C, 0xDC,
290 0x79, 0x96, 0x57, 0xC0, 0x64, 0xEC, 0xF5, 0xD4,
291 0x1C, 0x67, 0x38, 0x12, 0xCF, 0xDE, 0x96, 0x75
294 static unsigned char pcbc_ok[32] = {
295 0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4,
296 0x6d, 0xec, 0xb4, 0x70, 0xa0, 0xe5, 0x6b, 0x15,
297 0xae, 0xa6, 0xbf, 0x61, 0xed, 0x7d, 0x9c, 0x9f,
298 0xf7, 0x17, 0x46, 0x3b, 0x8a, 0xb3, 0xcc, 0x88
301 static unsigned char cfb_key[8] =
302 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
303 static unsigned char cfb_iv[8] =
304 { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef };
305 static unsigned char cfb_buf1[40], cfb_buf2[40], cfb_tmp[8];
306 static unsigned char plain[24] = {
307 0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73,
308 0x20, 0x74, 0x68, 0x65, 0x20, 0x74,
309 0x69, 0x6d, 0x65, 0x20, 0x66, 0x6f,
310 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20
313 static unsigned char cfb_cipher8[24] = {
314 0xf3, 0x1f, 0xda, 0x07, 0x01, 0x14, 0x62, 0xee, 0x18, 0x7f, 0x43, 0xd8,
315 0x0a, 0x7c, 0xd9, 0xb5, 0xb0, 0xd2, 0x90, 0xda, 0x6e, 0x5b, 0x9a, 0x87
318 static unsigned char cfb_cipher16[24] = {
319 0xF3, 0x09, 0x87, 0x87, 0x7F, 0x57, 0xF7, 0x3C, 0x36, 0xB6, 0xDB, 0x70,
320 0xD8, 0xD5, 0x34, 0x19, 0xD3, 0x86, 0xB2, 0x23, 0xB7, 0xB2, 0xAD, 0x1B
323 static unsigned char cfb_cipher32[24] = {
324 0xF3, 0x09, 0x62, 0x49, 0xA4, 0xDF, 0xA4, 0x9F, 0x33, 0xDC, 0x7B, 0xAD,
325 0x4C, 0xC8, 0x9F, 0x64, 0xE4, 0x53, 0xE5, 0xEC, 0x67, 0x20, 0xDA, 0xB6
328 static unsigned char cfb_cipher48[24] = {
329 0xF3, 0x09, 0x62, 0x49, 0xC7, 0xF4, 0x30, 0xB5, 0x15, 0xEC, 0xBB, 0x85,
330 0x97, 0x5A, 0x13, 0x8C, 0x68, 0x60, 0xE2, 0x38, 0x34, 0x3C, 0xDC, 0x1F
333 static unsigned char cfb_cipher64[24] = {
334 0xF3, 0x09, 0x62, 0x49, 0xC7, 0xF4, 0x6E, 0x51, 0xA6, 0x9E, 0x83, 0x9B,
335 0x1A, 0x92, 0xF7, 0x84, 0x03, 0x46, 0x71, 0x33, 0x89, 0x8E, 0xA6, 0x22
338 static unsigned char ofb_key[8] =
339 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
340 static unsigned char ofb_iv[8] =
341 { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef };
342 static unsigned char ofb_buf1[24], ofb_buf2[24], ofb_tmp[8];
343 static unsigned char ofb_cipher[24] = {
344 0xf3, 0x09, 0x62, 0x49, 0xc7, 0xf4, 0x6e, 0x51,
345 0x35, 0xf2, 0x4a, 0x24, 0x2e, 0xeb, 0x3d, 0x3f,
346 0x3d, 0x6d, 0x5b, 0xe3, 0x25, 0x5a, 0xf8, 0xc3
350 static DES_LONG cbc_cksum_ret = 0xB462FEF7L;
352 static DES_LONG cbc_cksum_ret = 0xF7FE62B4L;
354 static unsigned char cbc_cksum_data[8] =
355 { 0x1D, 0x26, 0x93, 0x97, 0xf7, 0xfe, 0x62, 0xb4 };
357 static char *pt(unsigned char *p);
358 static int cfb_test(int bits, unsigned char *cfb_cipher);
359 static int cfb64_test(unsigned char *cfb_cipher);
360 static int ede_cfb64_test(unsigned char *cfb_cipher);
361 int main(int argc, char *argv[])
365 des_cblock in, out, outin, iv3, iv2;
366 des_key_schedule ks, ks2, ks3;
367 unsigned char cbc_in[40];
368 unsigned char cbc_out[40];
370 unsigned char cret[8];
382 # ifndef OPENSSL_NO_DESCBCM
383 printf("Doing cbcm\n");
384 if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
385 printf("Key error %d\n", j);
388 if ((j = DES_set_key_checked(&cbc2_key, &ks2)) != 0) {
389 printf("Key error %d\n", j);
392 if ((j = DES_set_key_checked(&cbc3_key, &ks3)) != 0) {
393 printf("Key error %d\n", j);
396 memset(cbc_out, 0, 40);
397 memset(cbc_in, 0, 40);
398 i = strlen((char *)cbc_data) + 1;
400 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
401 memset(iv2, '\0', sizeof(iv2));
403 DES_ede3_cbcm_encrypt(cbc_data, cbc_out, 16L, &ks, &ks2, &ks3, &iv3, &iv2,
405 DES_ede3_cbcm_encrypt(&cbc_data[16], &cbc_out[16], i - 16, &ks, &ks2,
406 &ks3, &iv3, &iv2, DES_ENCRYPT);
407 /*- if (memcmp(cbc_out,cbc3_ok,
408 (unsigned int)(strlen((char *)cbc_data)+1+7)/8*8) != 0)
410 printf("des_ede3_cbc_encrypt encrypt error\n");
414 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
415 memset(iv2, '\0', sizeof(iv2));
416 DES_ede3_cbcm_encrypt(cbc_out, cbc_in, i, &ks, &ks2, &ks3, &iv3, &iv2,
418 if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data) + 1) != 0) {
421 printf("des_ede3_cbcm_encrypt decrypt error\n");
422 for (n = 0; n < i; ++n)
423 printf(" %02x", cbc_data[n]);
425 for (n = 0; n < i; ++n)
426 printf(" %02x", cbc_in[n]);
432 printf("Doing ecb\n");
433 for (i = 0; i < NUM_TESTS; i++) {
434 DES_set_key_unchecked(&key_data[i], &ks);
435 memcpy(in, plain_data[i], 8);
438 des_ecb_encrypt(&in, &out, ks, DES_ENCRYPT);
439 des_ecb_encrypt(&out, &outin, ks, DES_DECRYPT);
441 if (memcmp(out, cipher_data[i], 8) != 0) {
442 printf("Encryption error %2d\nk=%s p=%s o=%s act=%s\n",
443 i + 1, pt(key_data[i]), pt(in), pt(cipher_data[i]),
447 if (memcmp(in, outin, 8) != 0) {
448 printf("Decryption error %2d\nk=%s p=%s o=%s act=%s\n",
449 i + 1, pt(key_data[i]), pt(out), pt(in), pt(outin));
455 printf("Doing ede ecb\n");
456 for (i = 0; i < (NUM_TESTS - 2); i++) {
457 DES_set_key_unchecked(&key_data[i], &ks);
458 DES_set_key_unchecked(&key_data[i + 1], &ks2);
459 DES_set_key_unchecked(&key_data[i + 2], &ks3);
460 memcpy(in, plain_data[i], 8);
463 des_ecb2_encrypt(&in, &out, ks, ks2, DES_ENCRYPT);
464 des_ecb2_encrypt(&out, &outin, ks, ks2, DES_DECRYPT);
466 if (memcmp(out, cipher_ecb2[i], 8) != 0) {
467 printf("Encryption error %2d\nk=%s p=%s o=%s act=%s\n",
468 i + 1, pt(key_data[i]), pt(in), pt(cipher_ecb2[i]),
472 if (memcmp(in, outin, 8) != 0) {
473 printf("Decryption error %2d\nk=%s p=%s o=%s act=%s\n",
474 i + 1, pt(key_data[i]), pt(out), pt(in), pt(outin));
480 printf("Doing cbc\n");
481 if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
482 printf("Key error %d\n", j);
485 memset(cbc_out, 0, 40);
486 memset(cbc_in, 0, 40);
487 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
488 des_ncbc_encrypt(cbc_data, cbc_out, strlen((char *)cbc_data) + 1, ks,
490 if (memcmp(cbc_out, cbc_ok, 32) != 0) {
491 printf("cbc_encrypt encrypt error\n");
495 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
496 des_ncbc_encrypt(cbc_out, cbc_in, strlen((char *)cbc_data) + 1, ks,
498 if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data)) != 0) {
499 printf("cbc_encrypt decrypt error\n");
503 printf("Doing desx cbc\n");
504 if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
505 printf("Key error %d\n", j);
508 memset(cbc_out, 0, 40);
509 memset(cbc_in, 0, 40);
510 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
511 des_xcbc_encrypt(cbc_data, cbc_out, strlen((char *)cbc_data) + 1, ks,
512 &iv3, &cbc2_key, &cbc3_key, DES_ENCRYPT);
513 if (memcmp(cbc_out, xcbc_ok, 32) != 0) {
514 printf("des_xcbc_encrypt encrypt error\n");
517 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
518 des_xcbc_encrypt(cbc_out, cbc_in, strlen((char *)cbc_data) + 1, ks,
519 &iv3, &cbc2_key, &cbc3_key, DES_DECRYPT);
520 if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data) + 1) != 0) {
521 printf("des_xcbc_encrypt decrypt error\n");
526 printf("Doing ede cbc\n");
527 if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
528 printf("Key error %d\n", j);
531 if ((j = DES_set_key_checked(&cbc2_key, &ks2)) != 0) {
532 printf("Key error %d\n", j);
535 if ((j = DES_set_key_checked(&cbc3_key, &ks3)) != 0) {
536 printf("Key error %d\n", j);
539 memset(cbc_out, 0, 40);
540 memset(cbc_in, 0, 40);
541 i = strlen((char *)cbc_data) + 1;
543 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
545 des_ede3_cbc_encrypt(cbc_data, cbc_out, 16L, ks, ks2, ks3, &iv3,
547 des_ede3_cbc_encrypt(&(cbc_data[16]), &(cbc_out[16]), i - 16, ks, ks2,
548 ks3, &iv3, DES_ENCRYPT);
551 (unsigned int)(strlen((char *)cbc_data) + 1 + 7) / 8 * 8) != 0) {
554 printf("des_ede3_cbc_encrypt encrypt error\n");
555 for (n = 0; n < i; ++n)
556 printf(" %02x", cbc_out[n]);
558 for (n = 0; n < i; ++n)
559 printf(" %02x", cbc3_ok[n]);
564 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
565 des_ede3_cbc_encrypt(cbc_out, cbc_in, i, ks, ks2, ks3, &iv3, DES_DECRYPT);
566 if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data) + 1) != 0) {
569 printf("des_ede3_cbc_encrypt decrypt error\n");
570 for (n = 0; n < i; ++n)
571 printf(" %02x", cbc_data[n]);
573 for (n = 0; n < i; ++n)
574 printf(" %02x", cbc_in[n]);
579 printf("Doing pcbc\n");
580 if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
581 printf("Key error %d\n", j);
584 memset(cbc_out, 0, 40);
585 memset(cbc_in, 0, 40);
586 des_pcbc_encrypt(cbc_data, cbc_out, strlen((char *)cbc_data) + 1, ks,
587 &cbc_iv, DES_ENCRYPT);
588 if (memcmp(cbc_out, pcbc_ok, 32) != 0) {
589 printf("pcbc_encrypt encrypt error\n");
592 des_pcbc_encrypt(cbc_out, cbc_in, strlen((char *)cbc_data) + 1, ks,
593 &cbc_iv, DES_DECRYPT);
594 if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data) + 1) != 0) {
595 printf("pcbc_encrypt decrypt error\n");
601 err += cfb_test(8, cfb_cipher8);
603 err += cfb_test(16, cfb_cipher16);
605 err += cfb_test(32, cfb_cipher32);
607 err += cfb_test(48, cfb_cipher48);
609 err += cfb_test(64, cfb_cipher64);
612 err += cfb64_test(cfb_cipher64);
614 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
615 for (i = 0; i < sizeof(plain); i++)
616 des_cfb_encrypt(&(plain[i]), &(cfb_buf1[i]),
617 8, 1, ks, &cfb_tmp, DES_ENCRYPT);
618 if (memcmp(cfb_cipher8, cfb_buf1, sizeof(plain)) != 0) {
619 printf("cfb_encrypt small encrypt error\n");
623 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
624 for (i = 0; i < sizeof(plain); i++)
625 des_cfb_encrypt(&(cfb_buf1[i]), &(cfb_buf2[i]),
626 8, 1, ks, &cfb_tmp, DES_DECRYPT);
627 if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
628 printf("cfb_encrypt small decrypt error\n");
632 printf("ede_cfb64() ");
633 err += ede_cfb64_test(cfb_cipher64);
637 printf("Doing ofb\n");
638 DES_set_key_checked(&ofb_key, &ks);
639 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
640 des_ofb_encrypt(plain, ofb_buf1, 64, sizeof(plain) / 8, ks, &ofb_tmp);
641 if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) {
642 printf("ofb_encrypt encrypt error\n");
643 printf("%02X %02X %02X %02X %02X %02X %02X %02X\n",
644 ofb_buf1[8 + 0], ofb_buf1[8 + 1], ofb_buf1[8 + 2],
645 ofb_buf1[8 + 3], ofb_buf1[8 + 4], ofb_buf1[8 + 5],
646 ofb_buf1[8 + 6], ofb_buf1[8 + 7]);
647 printf("%02X %02X %02X %02X %02X %02X %02X %02X\n", ofb_buf1[8 + 0],
648 ofb_cipher[8 + 1], ofb_cipher[8 + 2], ofb_cipher[8 + 3],
649 ofb_buf1[8 + 4], ofb_cipher[8 + 5], ofb_cipher[8 + 6],
653 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
654 des_ofb_encrypt(ofb_buf1, ofb_buf2, 64, sizeof(ofb_buf1) / 8, ks,
656 if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) {
657 printf("ofb_encrypt decrypt error\n");
658 printf("%02X %02X %02X %02X %02X %02X %02X %02X\n",
659 ofb_buf2[8 + 0], ofb_buf2[8 + 1], ofb_buf2[8 + 2],
660 ofb_buf2[8 + 3], ofb_buf2[8 + 4], ofb_buf2[8 + 5],
661 ofb_buf2[8 + 6], ofb_buf2[8 + 7]);
662 printf("%02X %02X %02X %02X %02X %02X %02X %02X\n", plain[8 + 0],
663 plain[8 + 1], plain[8 + 2], plain[8 + 3], plain[8 + 4],
664 plain[8 + 5], plain[8 + 6], plain[8 + 7]);
668 printf("Doing ofb64\n");
669 DES_set_key_checked(&ofb_key, &ks);
670 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
671 memset(ofb_buf1, 0, sizeof(ofb_buf1));
672 memset(ofb_buf2, 0, sizeof(ofb_buf1));
674 for (i = 0; i < sizeof(plain); i++) {
675 des_ofb64_encrypt(&(plain[i]), &(ofb_buf1[i]), 1, ks, &ofb_tmp, &num);
677 if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) {
678 printf("ofb64_encrypt encrypt error\n");
681 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
683 des_ofb64_encrypt(ofb_buf1, ofb_buf2, sizeof(ofb_buf1), ks, &ofb_tmp,
685 if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) {
686 printf("ofb64_encrypt decrypt error\n");
690 printf("Doing ede_ofb64\n");
691 DES_set_key_checked(&ofb_key, &ks);
692 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
693 memset(ofb_buf1, 0, sizeof(ofb_buf1));
694 memset(ofb_buf2, 0, sizeof(ofb_buf1));
696 for (i = 0; i < sizeof(plain); i++) {
697 des_ede3_ofb64_encrypt(&(plain[i]), &(ofb_buf1[i]), 1, ks, ks,
700 if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) {
701 printf("ede_ofb64_encrypt encrypt error\n");
704 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
706 des_ede3_ofb64_encrypt(ofb_buf1, ofb_buf2, sizeof(ofb_buf1), ks, ks, ks,
708 if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) {
709 printf("ede_ofb64_encrypt decrypt error\n");
713 printf("Doing cbc_cksum\n");
714 DES_set_key_checked(&cbc_key, &ks);
715 cs = des_cbc_cksum(cbc_data, &cret, strlen((char *)cbc_data), ks,
717 if (cs != cbc_cksum_ret) {
718 printf("bad return value (%08lX), should be %08lX\n",
719 (unsigned long)cs, (unsigned long)cbc_cksum_ret);
722 if (memcmp(cret, cbc_cksum_data, 8) != 0) {
723 printf("bad cbc_cksum block returned\n");
727 printf("Doing quad_cksum\n");
728 cs = des_quad_cksum(cbc_data, (des_cblock *)lqret,
729 (long)strlen((char *)cbc_data), 2,
730 (des_cblock *)cbc_iv);
731 if (cs != 0x70d7a63aL) {
732 printf("quad_cksum error, ret %08lx should be 70d7a63a\n",
737 if (lqret[0].a != 0x327eba8dL) {
738 printf("quad_cksum error, out[0] %08lx is not %08lx\n",
739 (unsigned long)lqret[0].a, 0x327eba8dUL);
742 if (lqret[0].b != 0x201a49ccL) {
743 printf("quad_cksum error, out[1] %08lx is not %08lx\n",
744 (unsigned long)lqret[0].b, 0x201a49ccUL);
747 if (lqret[1].a != 0x70d7a63aL) {
748 printf("quad_cksum error, out[2] %08lx is not %08lx\n",
749 (unsigned long)lqret[1].a, 0x70d7a63aUL);
752 if (lqret[1].b != 0x501c2c26L) {
753 printf("quad_cksum error, out[3] %08lx is not %08lx\n",
754 (unsigned long)lqret[1].b, 0x501c2c26UL);
758 if (lqret[0] != 0x327eba8dL) {
759 printf("quad_cksum error, out[0] %08lx is not %08lx\n",
760 (unsigned long)lqret[0], 0x327eba8dUL);
763 if (lqret[1] != 0x201a49ccL) {
764 printf("quad_cksum error, out[1] %08lx is not %08lx\n",
765 (unsigned long)lqret[1], 0x201a49ccUL);
768 if (lqret[2] != 0x70d7a63aL) {
769 printf("quad_cksum error, out[2] %08lx is not %08lx\n",
770 (unsigned long)lqret[2], 0x70d7a63aUL);
773 if (lqret[3] != 0x501c2c26L) {
774 printf("quad_cksum error, out[3] %08lx is not %08lx\n",
775 (unsigned long)lqret[3], 0x501c2c26UL);
781 printf("input word alignment test");
782 for (i = 0; i < 4; i++) {
784 des_ncbc_encrypt(&(cbc_out[i]), cbc_in,
785 strlen((char *)cbc_data) + 1, ks,
786 &cbc_iv, DES_ENCRYPT);
788 printf("\noutput word alignment test");
789 for (i = 0; i < 4; i++) {
791 des_ncbc_encrypt(cbc_out, &(cbc_in[i]),
792 strlen((char *)cbc_data) + 1, ks,
793 &cbc_iv, DES_ENCRYPT);
796 printf("fast crypt test ");
797 str = crypt("testing", "ef");
798 if (strcmp("efGnQx2725bI2", str) != 0) {
799 printf("fast crypt error, %s should be efGnQx2725bI2\n", str);
802 str = crypt("bca76;23", "yA");
803 if (strcmp("yA1Rp/1hZXIJk", str) != 0) {
804 printf("fast crypt error, %s should be yA1Rp/1hZXIJk\n", str);
807 # ifdef OPENSSL_SYS_NETWARE
809 printf("ERROR: %d\n", err);
815 static char *pt(unsigned char *p)
817 static char bufs[10][20];
821 static char *f = "0123456789ABCDEF";
823 ret = &(bufs[bnum++][0]);
825 for (i = 0; i < 8; i++) {
826 ret[i * 2] = f[(p[i] >> 4) & 0xf];
827 ret[i * 2 + 1] = f[p[i] & 0xf];
835 static int cfb_test(int bits, unsigned char *cfb_cipher)
840 DES_set_key_checked(&cfb_key, &ks);
841 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
842 des_cfb_encrypt(plain, cfb_buf1, bits, sizeof(plain), ks, &cfb_tmp,
844 if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0) {
846 printf("cfb_encrypt encrypt error\n");
847 for (i = 0; i < 24; i += 8)
848 printf("%s\n", pt(&(cfb_buf1[i])));
850 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
851 des_cfb_encrypt(cfb_buf1, cfb_buf2, bits, sizeof(plain), ks, &cfb_tmp,
853 if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
855 printf("cfb_encrypt decrypt error\n");
856 for (i = 0; i < 24; i += 8)
857 printf("%s\n", pt(&(cfb_buf1[i])));
862 static int cfb64_test(unsigned char *cfb_cipher)
867 DES_set_key_checked(&cfb_key, &ks);
868 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
870 des_cfb64_encrypt(plain, cfb_buf1, 12, ks, &cfb_tmp, &n, DES_ENCRYPT);
871 des_cfb64_encrypt(&(plain[12]), &(cfb_buf1[12]), sizeof(plain) - 12, ks,
872 &cfb_tmp, &n, DES_ENCRYPT);
873 if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0) {
875 printf("cfb_encrypt encrypt error\n");
876 for (i = 0; i < 24; i += 8)
877 printf("%s\n", pt(&(cfb_buf1[i])));
879 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
881 des_cfb64_encrypt(cfb_buf1, cfb_buf2, 17, ks, &cfb_tmp, &n, DES_DECRYPT);
882 des_cfb64_encrypt(&(cfb_buf1[17]), &(cfb_buf2[17]),
883 sizeof(plain) - 17, ks, &cfb_tmp, &n, DES_DECRYPT);
884 if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
886 printf("cfb_encrypt decrypt error\n");
887 for (i = 0; i < 24; i += 8)
888 printf("%s\n", pt(&(cfb_buf2[i])));
893 static int ede_cfb64_test(unsigned char *cfb_cipher)
898 DES_set_key_checked(&cfb_key, &ks);
899 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
901 des_ede3_cfb64_encrypt(plain, cfb_buf1, 12, ks, ks, ks, &cfb_tmp, &n,
903 des_ede3_cfb64_encrypt(&(plain[12]), &(cfb_buf1[12]),
904 sizeof(plain) - 12, ks, ks, ks,
905 &cfb_tmp, &n, DES_ENCRYPT);
906 if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0) {
908 printf("ede_cfb_encrypt encrypt error\n");
909 for (i = 0; i < 24; i += 8)
910 printf("%s\n", pt(&(cfb_buf1[i])));
912 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
914 des_ede3_cfb64_encrypt(cfb_buf1, cfb_buf2, (long)17, ks, ks, ks,
915 &cfb_tmp, &n, DES_DECRYPT);
916 des_ede3_cfb64_encrypt(&(cfb_buf1[17]), &(cfb_buf2[17]),
917 sizeof(plain) - 17, ks, ks, ks,
918 &cfb_tmp, &n, DES_DECRYPT);
919 if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
921 printf("ede_cfb_encrypt decrypt error\n");
922 for (i = 0; i < 24; i += 8)
923 printf("%s\n", pt(&(cfb_buf2[i])));