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_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
348 static DES_LONG cbc_cksum_ret = 0xF7FE62B4L;
349 static unsigned char cbc_cksum_data[8] =
350 { 0x1D, 0x26, 0x93, 0x97, 0xf7, 0xfe, 0x62, 0xb4 };
352 static char *pt(unsigned char *p);
353 static int cfb_test(int bits, unsigned char *cfb_cipher);
354 static int cfb64_test(unsigned char *cfb_cipher);
355 static int ede_cfb64_test(unsigned char *cfb_cipher);
356 int main(int argc, char *argv[])
360 DES_cblock in, out, outin, iv3;
361 DES_key_schedule ks, ks2, ks3;
362 unsigned char cbc_in[40];
363 unsigned char cbc_out[40];
365 unsigned char cret[8];
370 printf("Doing ecb\n");
371 for (i = 0; i < NUM_TESTS; i++) {
372 DES_set_key_unchecked(&key_data[i], &ks);
373 memcpy(in, plain_data[i], 8);
376 DES_ecb_encrypt(&in, &out, &ks, DES_ENCRYPT);
377 DES_ecb_encrypt(&out, &outin, &ks, DES_DECRYPT);
379 if (memcmp(out, cipher_data[i], 8) != 0) {
380 printf("Encryption error %2d\nk=%s p=%s o=%s act=%s\n",
381 i + 1, pt(key_data[i]), pt(in), pt(cipher_data[i]),
385 if (memcmp(in, outin, 8) != 0) {
386 printf("Decryption error %2d\nk=%s p=%s o=%s act=%s\n",
387 i + 1, pt(key_data[i]), pt(out), pt(in), pt(outin));
393 printf("Doing ede ecb\n");
394 for (i = 0; i < (NUM_TESTS - 2); i++) {
395 DES_set_key_unchecked(&key_data[i], &ks);
396 DES_set_key_unchecked(&key_data[i + 1], &ks2);
397 DES_set_key_unchecked(&key_data[i + 2], &ks3);
398 memcpy(in, plain_data[i], 8);
401 DES_ecb3_encrypt(&in,&out,&ks,&ks2,&ks,DES_ENCRYPT);
402 DES_ecb3_encrypt(&out,&outin,&ks,&ks2,&ks,DES_DECRYPT);
404 if (memcmp(out, cipher_ecb2[i], 8) != 0) {
405 printf("Encryption error %2d\nk=%s p=%s o=%s act=%s\n",
406 i + 1, pt(key_data[i]), pt(in), pt(cipher_ecb2[i]),
410 if (memcmp(in, outin, 8) != 0) {
411 printf("Decryption error %2d\nk=%s p=%s o=%s act=%s\n",
412 i + 1, pt(key_data[i]), pt(out), pt(in), pt(outin));
418 printf("Doing cbc\n");
419 if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
420 printf("Key error %d\n", j);
423 memset(cbc_out, 0, 40);
424 memset(cbc_in, 0, 40);
425 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
426 DES_ncbc_encrypt(cbc_data, cbc_out, strlen((char *)cbc_data) + 1, &ks,
428 if (memcmp(cbc_out, cbc_ok, 32) != 0) {
429 printf("cbc_encrypt encrypt error\n");
433 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
434 DES_ncbc_encrypt(cbc_out, cbc_in, strlen((char *)cbc_data) + 1, &ks,
436 if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data)) != 0) {
437 printf("cbc_encrypt decrypt error\n");
441 printf("Doing desx cbc\n");
442 if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
443 printf("Key error %d\n", j);
446 memset(cbc_out, 0, 40);
447 memset(cbc_in, 0, 40);
448 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
449 DES_xcbc_encrypt(cbc_data, cbc_out, strlen((char *)cbc_data) + 1, &ks,
450 &iv3, &cbc2_key, &cbc3_key, DES_ENCRYPT);
451 if (memcmp(cbc_out, xcbc_ok, 32) != 0) {
452 printf("des_xcbc_encrypt encrypt error\n");
455 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
456 DES_xcbc_encrypt(cbc_out, cbc_in, strlen((char *)cbc_data) + 1, &ks,
457 &iv3, &cbc2_key, &cbc3_key, DES_DECRYPT);
458 if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data) + 1) != 0) {
459 printf("des_xcbc_encrypt decrypt error\n");
464 printf("Doing ede cbc\n");
465 if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
466 printf("Key error %d\n", j);
469 if ((j = DES_set_key_checked(&cbc2_key, &ks2)) != 0) {
470 printf("Key error %d\n", j);
473 if ((j = DES_set_key_checked(&cbc3_key, &ks3)) != 0) {
474 printf("Key error %d\n", j);
477 memset(cbc_out, 0, 40);
478 memset(cbc_in, 0, 40);
479 i = strlen((char *)cbc_data) + 1;
481 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
483 DES_ede3_cbc_encrypt(cbc_data, cbc_out, 16L, &ks, &ks2, &ks3, &iv3,
485 DES_ede3_cbc_encrypt(&(cbc_data[16]), &(cbc_out[16]), i - 16, &ks, &ks2,
486 &ks3, &iv3, DES_ENCRYPT);
489 (unsigned int)(strlen((char *)cbc_data) + 1 + 7) / 8 * 8) != 0) {
492 printf("des_ede3_cbc_encrypt encrypt error\n");
493 for (n = 0; n < i; ++n)
494 printf(" %02x", cbc_out[n]);
496 for (n = 0; n < i; ++n)
497 printf(" %02x", cbc3_ok[n]);
502 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
503 DES_ede3_cbc_encrypt(cbc_out, cbc_in, i, &ks, &ks2, &ks3, &iv3, DES_DECRYPT);
504 if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data) + 1) != 0) {
507 printf("DES_ede3_cbc_encrypt decrypt error\n");
508 for (n = 0; n < i; ++n)
509 printf(" %02x", cbc_data[n]);
511 for (n = 0; n < i; ++n)
512 printf(" %02x", cbc_in[n]);
517 printf("Doing pcbc\n");
518 if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
519 printf("Key error %d\n", j);
522 memset(cbc_out, 0, 40);
523 memset(cbc_in, 0, 40);
524 DES_pcbc_encrypt(cbc_data, cbc_out, strlen((char *)cbc_data) + 1, &ks,
525 &cbc_iv, DES_ENCRYPT);
526 if (memcmp(cbc_out, pcbc_ok, 32) != 0) {
527 printf("pcbc_encrypt encrypt error\n");
530 DES_pcbc_encrypt(cbc_out, cbc_in, strlen((char *)cbc_data) + 1, &ks,
531 &cbc_iv, DES_DECRYPT);
532 if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data) + 1) != 0) {
533 printf("pcbc_encrypt decrypt error\n");
539 err += cfb_test(8, cfb_cipher8);
541 err += cfb_test(16, cfb_cipher16);
543 err += cfb_test(32, cfb_cipher32);
545 err += cfb_test(48, cfb_cipher48);
547 err += cfb_test(64, cfb_cipher64);
550 err += cfb64_test(cfb_cipher64);
552 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
553 for (i = 0; i < sizeof(plain); i++)
554 DES_cfb_encrypt(&(plain[i]), &(cfb_buf1[i]),
555 8, 1, &ks, &cfb_tmp, DES_ENCRYPT);
556 if (memcmp(cfb_cipher8, cfb_buf1, sizeof(plain)) != 0) {
557 printf("cfb_encrypt small encrypt error\n");
561 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
562 for (i = 0; i < sizeof(plain); i++)
563 DES_cfb_encrypt(&(cfb_buf1[i]), &(cfb_buf2[i]),
564 8, 1, &ks, &cfb_tmp, DES_DECRYPT);
565 if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
566 printf("cfb_encrypt small decrypt error\n");
570 printf("ede_cfb64() ");
571 err += ede_cfb64_test(cfb_cipher64);
575 printf("Doing ofb\n");
576 DES_set_key_checked(&ofb_key, &ks);
577 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
578 DES_ofb_encrypt(plain, ofb_buf1, 64, sizeof(plain) / 8, &ks, &ofb_tmp);
579 if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) {
580 printf("ofb_encrypt encrypt error\n");
581 printf("%02X %02X %02X %02X %02X %02X %02X %02X\n",
582 ofb_buf1[8 + 0], ofb_buf1[8 + 1], ofb_buf1[8 + 2],
583 ofb_buf1[8 + 3], ofb_buf1[8 + 4], ofb_buf1[8 + 5],
584 ofb_buf1[8 + 6], ofb_buf1[8 + 7]);
585 printf("%02X %02X %02X %02X %02X %02X %02X %02X\n", ofb_buf1[8 + 0],
586 ofb_cipher[8 + 1], ofb_cipher[8 + 2], ofb_cipher[8 + 3],
587 ofb_buf1[8 + 4], ofb_cipher[8 + 5], ofb_cipher[8 + 6],
591 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
592 DES_ofb_encrypt(ofb_buf1, ofb_buf2, 64, sizeof(ofb_buf1) / 8, &ks,
594 if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) {
595 printf("ofb_encrypt decrypt error\n");
596 printf("%02X %02X %02X %02X %02X %02X %02X %02X\n",
597 ofb_buf2[8 + 0], ofb_buf2[8 + 1], ofb_buf2[8 + 2],
598 ofb_buf2[8 + 3], ofb_buf2[8 + 4], ofb_buf2[8 + 5],
599 ofb_buf2[8 + 6], ofb_buf2[8 + 7]);
600 printf("%02X %02X %02X %02X %02X %02X %02X %02X\n", plain[8 + 0],
601 plain[8 + 1], plain[8 + 2], plain[8 + 3], plain[8 + 4],
602 plain[8 + 5], plain[8 + 6], plain[8 + 7]);
606 printf("Doing ofb64\n");
607 DES_set_key_checked(&ofb_key, &ks);
608 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
609 memset(ofb_buf1, 0, sizeof(ofb_buf1));
610 memset(ofb_buf2, 0, sizeof(ofb_buf1));
612 for (i = 0; i < sizeof(plain); i++) {
613 DES_ofb64_encrypt(&(plain[i]), &(ofb_buf1[i]), 1, &ks, &ofb_tmp, &num);
615 if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) {
616 printf("ofb64_encrypt encrypt error\n");
619 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
621 DES_ofb64_encrypt(ofb_buf1, ofb_buf2, sizeof(ofb_buf1), &ks, &ofb_tmp,
623 if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) {
624 printf("ofb64_encrypt decrypt error\n");
628 printf("Doing ede_ofb64\n");
629 DES_set_key_checked(&ofb_key, &ks);
630 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
631 memset(ofb_buf1, 0, sizeof(ofb_buf1));
632 memset(ofb_buf2, 0, sizeof(ofb_buf1));
634 for (i = 0; i < sizeof(plain); i++) {
635 DES_ede3_ofb64_encrypt(&(plain[i]), &(ofb_buf1[i]), 1, &ks, &ks,
636 &ks, &ofb_tmp, &num);
638 if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) {
639 printf("ede_ofb64_encrypt encrypt error\n");
642 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
644 DES_ede3_ofb64_encrypt(ofb_buf1, ofb_buf2, sizeof(ofb_buf1), &ks, &ks, &ks,
646 if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) {
647 printf("ede_ofb64_encrypt decrypt error\n");
651 printf("Doing cbc_cksum\n");
652 DES_set_key_checked(&cbc_key, &ks);
653 cs = DES_cbc_cksum(cbc_data, &cret, strlen((char *)cbc_data), &ks,
655 if (cs != cbc_cksum_ret) {
656 printf("bad return value (%08lX), should be %08lX\n",
657 (unsigned long)cs, (unsigned long)cbc_cksum_ret);
660 if (memcmp(cret, cbc_cksum_data, 8) != 0) {
661 printf("bad cbc_cksum block returned\n");
665 printf("Doing quad_cksum\n");
666 cs = DES_quad_cksum(cbc_data, (DES_cblock *)lqret,
667 (long)strlen((char *)cbc_data), 2,
668 (DES_cblock *)cbc_iv);
669 if (cs != 0x70d7a63aL) {
670 printf("quad_cksum error, ret %08lx should be 70d7a63a\n",
674 if (lqret[0] != 0x327eba8dL) {
675 printf("quad_cksum error, out[0] %08lx is not %08lx\n",
676 (unsigned long)lqret[0], 0x327eba8dUL);
679 if (lqret[1] != 0x201a49ccL) {
680 printf("quad_cksum error, out[1] %08lx is not %08lx\n",
681 (unsigned long)lqret[1], 0x201a49ccUL);
684 if (lqret[2] != 0x70d7a63aL) {
685 printf("quad_cksum error, out[2] %08lx is not %08lx\n",
686 (unsigned long)lqret[2], 0x70d7a63aUL);
689 if (lqret[3] != 0x501c2c26L) {
690 printf("quad_cksum error, out[3] %08lx is not %08lx\n",
691 (unsigned long)lqret[3], 0x501c2c26UL);
696 printf("input word alignment test");
697 for (i = 0; i < 4; i++) {
699 DES_ncbc_encrypt(&(cbc_out[i]), cbc_in,
700 strlen((char *)cbc_data) + 1, &ks,
701 &cbc_iv, DES_ENCRYPT);
703 printf("\noutput word alignment test");
704 for (i = 0; i < 4; i++) {
706 DES_ncbc_encrypt(cbc_out, &(cbc_in[i]),
707 strlen((char *)cbc_data) + 1, &ks,
708 &cbc_iv, DES_ENCRYPT);
711 printf("fast crypt test ");
712 str = crypt("testing", "ef");
713 if (strcmp("efGnQx2725bI2", str) != 0) {
714 printf("fast crypt error, %s should be efGnQx2725bI2\n", str);
717 str = crypt("bca76;23", "yA");
718 if (strcmp("yA1Rp/1hZXIJk", str) != 0) {
719 printf("fast crypt error, %s should be yA1Rp/1hZXIJk\n", str);
722 # ifdef OPENSSL_SYS_NETWARE
724 printf("ERROR: %d\n", err);
730 static char *pt(unsigned char *p)
732 static char bufs[10][20];
736 static char *f = "0123456789ABCDEF";
738 ret = &(bufs[bnum++][0]);
740 for (i = 0; i < 8; i++) {
741 ret[i * 2] = f[(p[i] >> 4) & 0xf];
742 ret[i * 2 + 1] = f[p[i] & 0xf];
750 static int cfb_test(int bits, unsigned char *cfb_cipher)
755 DES_set_key_checked(&cfb_key, &ks);
756 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
757 DES_cfb_encrypt(plain, cfb_buf1, bits, sizeof(plain), &ks, &cfb_tmp,
759 if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0) {
761 printf("cfb_encrypt encrypt error\n");
762 for (i = 0; i < 24; i += 8)
763 printf("%s\n", pt(&(cfb_buf1[i])));
765 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
766 DES_cfb_encrypt(cfb_buf1, cfb_buf2, bits, sizeof(plain), &ks, &cfb_tmp,
768 if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
770 printf("cfb_encrypt decrypt error\n");
771 for (i = 0; i < 24; i += 8)
772 printf("%s\n", pt(&(cfb_buf1[i])));
777 static int cfb64_test(unsigned char *cfb_cipher)
782 DES_set_key_checked(&cfb_key, &ks);
783 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
785 DES_cfb64_encrypt(plain, cfb_buf1, 12, &ks, &cfb_tmp, &n, DES_ENCRYPT);
786 DES_cfb64_encrypt(&(plain[12]), &(cfb_buf1[12]), sizeof(plain) - 12, &ks,
787 &cfb_tmp, &n, DES_ENCRYPT);
788 if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0) {
790 printf("cfb_encrypt encrypt error\n");
791 for (i = 0; i < 24; i += 8)
792 printf("%s\n", pt(&(cfb_buf1[i])));
794 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
796 DES_cfb64_encrypt(cfb_buf1, cfb_buf2, 17, &ks, &cfb_tmp, &n, DES_DECRYPT);
797 DES_cfb64_encrypt(&(cfb_buf1[17]), &(cfb_buf2[17]),
798 sizeof(plain) - 17, &ks, &cfb_tmp, &n, DES_DECRYPT);
799 if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
801 printf("cfb_encrypt decrypt error\n");
802 for (i = 0; i < 24; i += 8)
803 printf("%s\n", pt(&(cfb_buf2[i])));
808 static int ede_cfb64_test(unsigned char *cfb_cipher)
813 DES_set_key_checked(&cfb_key, &ks);
814 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
816 DES_ede3_cfb64_encrypt(plain, cfb_buf1, 12, &ks, &ks, &ks, &cfb_tmp, &n,
818 DES_ede3_cfb64_encrypt(&(plain[12]), &(cfb_buf1[12]),
819 sizeof(plain) - 12, &ks, &ks, &ks,
820 &cfb_tmp, &n, DES_ENCRYPT);
821 if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0) {
823 printf("ede_cfb_encrypt encrypt error\n");
824 for (i = 0; i < 24; i += 8)
825 printf("%s\n", pt(&(cfb_buf1[i])));
827 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
829 DES_ede3_cfb64_encrypt(cfb_buf1, cfb_buf2, (long)17, &ks, &ks, &ks,
830 &cfb_tmp, &n, DES_DECRYPT);
831 DES_ede3_cfb64_encrypt(&(cfb_buf1[17]), &(cfb_buf2[17]),
832 sizeof(plain) - 17, &ks, &ks, &ks,
833 &cfb_tmp, &n, DES_DECRYPT);
834 if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
836 printf("ede_cfb_encrypt decrypt error\n");
837 for (i = 0; i < 24; i += 8)
838 printf("%s\n", pt(&(cfb_buf2[i])));