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
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];
375 # ifndef OPENSSL_NO_DESCBCM
376 printf("Doing cbcm\n");
377 if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
378 printf("Key error %d\n", j);
381 if ((j = DES_set_key_checked(&cbc2_key, &ks2)) != 0) {
382 printf("Key error %d\n", j);
385 if ((j = DES_set_key_checked(&cbc3_key, &ks3)) != 0) {
386 printf("Key error %d\n", j);
389 memset(cbc_out, 0, 40);
390 memset(cbc_in, 0, 40);
391 i = strlen((char *)cbc_data) + 1;
393 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
394 memset(iv2, '\0', sizeof iv2);
396 DES_ede3_cbcm_encrypt(cbc_data, cbc_out, 16L, &ks, &ks2, &ks3, &iv3, &iv2,
398 DES_ede3_cbcm_encrypt(&cbc_data[16], &cbc_out[16], i - 16, &ks, &ks2,
399 &ks3, &iv3, &iv2, DES_ENCRYPT);
400 /*- if (memcmp(cbc_out,cbc3_ok,
401 (unsigned int)(strlen((char *)cbc_data)+1+7)/8*8) != 0)
403 printf("des_ede3_cbc_encrypt encrypt error\n");
407 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
408 memset(iv2, '\0', sizeof iv2);
409 DES_ede3_cbcm_encrypt(cbc_out, cbc_in, i, &ks, &ks2, &ks3, &iv3, &iv2,
411 if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data) + 1) != 0) {
414 printf("des_ede3_cbcm_encrypt decrypt error\n");
415 for (n = 0; n < i; ++n)
416 printf(" %02x", cbc_data[n]);
418 for (n = 0; n < i; ++n)
419 printf(" %02x", cbc_in[n]);
425 printf("Doing ecb\n");
426 for (i = 0; i < NUM_TESTS; i++) {
427 DES_set_key_unchecked(&key_data[i], &ks);
428 memcpy(in, plain_data[i], 8);
431 des_ecb_encrypt(&in, &out, ks, DES_ENCRYPT);
432 des_ecb_encrypt(&out, &outin, ks, DES_DECRYPT);
434 if (memcmp(out, cipher_data[i], 8) != 0) {
435 printf("Encryption error %2d\nk=%s p=%s o=%s act=%s\n",
436 i + 1, pt(key_data[i]), pt(in), pt(cipher_data[i]),
440 if (memcmp(in, outin, 8) != 0) {
441 printf("Decryption error %2d\nk=%s p=%s o=%s act=%s\n",
442 i + 1, pt(key_data[i]), pt(out), pt(in), pt(outin));
448 printf("Doing ede ecb\n");
449 for (i = 0; i < (NUM_TESTS - 2); i++) {
450 DES_set_key_unchecked(&key_data[i], &ks);
451 DES_set_key_unchecked(&key_data[i + 1], &ks2);
452 DES_set_key_unchecked(&key_data[i + 2], &ks3);
453 memcpy(in, plain_data[i], 8);
456 des_ecb2_encrypt(&in, &out, ks, ks2, DES_ENCRYPT);
457 des_ecb2_encrypt(&out, &outin, ks, ks2, DES_DECRYPT);
459 if (memcmp(out, cipher_ecb2[i], 8) != 0) {
460 printf("Encryption error %2d\nk=%s p=%s o=%s act=%s\n",
461 i + 1, pt(key_data[i]), pt(in), pt(cipher_ecb2[i]),
465 if (memcmp(in, outin, 8) != 0) {
466 printf("Decryption error %2d\nk=%s p=%s o=%s act=%s\n",
467 i + 1, pt(key_data[i]), pt(out), pt(in), pt(outin));
473 printf("Doing cbc\n");
474 if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
475 printf("Key error %d\n", j);
478 memset(cbc_out, 0, 40);
479 memset(cbc_in, 0, 40);
480 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
481 des_ncbc_encrypt(cbc_data, cbc_out, strlen((char *)cbc_data) + 1, ks,
483 if (memcmp(cbc_out, cbc_ok, 32) != 0) {
484 printf("cbc_encrypt encrypt error\n");
488 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
489 des_ncbc_encrypt(cbc_out, cbc_in, strlen((char *)cbc_data) + 1, ks,
491 if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data)) != 0) {
492 printf("cbc_encrypt decrypt error\n");
496 printf("Doing desx cbc\n");
497 if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
498 printf("Key error %d\n", j);
501 memset(cbc_out, 0, 40);
502 memset(cbc_in, 0, 40);
503 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
504 des_xcbc_encrypt(cbc_data, cbc_out, strlen((char *)cbc_data) + 1, ks,
505 &iv3, &cbc2_key, &cbc3_key, DES_ENCRYPT);
506 if (memcmp(cbc_out, xcbc_ok, 32) != 0) {
507 printf("des_xcbc_encrypt encrypt error\n");
510 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
511 des_xcbc_encrypt(cbc_out, cbc_in, strlen((char *)cbc_data) + 1, ks,
512 &iv3, &cbc2_key, &cbc3_key, DES_DECRYPT);
513 if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data) + 1) != 0) {
514 printf("des_xcbc_encrypt decrypt error\n");
519 printf("Doing ede cbc\n");
520 if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
521 printf("Key error %d\n", j);
524 if ((j = DES_set_key_checked(&cbc2_key, &ks2)) != 0) {
525 printf("Key error %d\n", j);
528 if ((j = DES_set_key_checked(&cbc3_key, &ks3)) != 0) {
529 printf("Key error %d\n", j);
532 memset(cbc_out, 0, 40);
533 memset(cbc_in, 0, 40);
534 i = strlen((char *)cbc_data) + 1;
536 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
538 des_ede3_cbc_encrypt(cbc_data, cbc_out, 16L, ks, ks2, ks3, &iv3,
540 des_ede3_cbc_encrypt(&(cbc_data[16]), &(cbc_out[16]), i - 16, ks, ks2,
541 ks3, &iv3, DES_ENCRYPT);
544 (unsigned int)(strlen((char *)cbc_data) + 1 + 7) / 8 * 8) != 0) {
547 printf("des_ede3_cbc_encrypt encrypt error\n");
548 for (n = 0; n < i; ++n)
549 printf(" %02x", cbc_out[n]);
551 for (n = 0; n < i; ++n)
552 printf(" %02x", cbc3_ok[n]);
557 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
558 des_ede3_cbc_encrypt(cbc_out, cbc_in, i, ks, ks2, ks3, &iv3, DES_DECRYPT);
559 if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data) + 1) != 0) {
562 printf("des_ede3_cbc_encrypt decrypt error\n");
563 for (n = 0; n < i; ++n)
564 printf(" %02x", cbc_data[n]);
566 for (n = 0; n < i; ++n)
567 printf(" %02x", cbc_in[n]);
572 printf("Doing pcbc\n");
573 if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
574 printf("Key error %d\n", j);
577 memset(cbc_out, 0, 40);
578 memset(cbc_in, 0, 40);
579 des_pcbc_encrypt(cbc_data, cbc_out, strlen((char *)cbc_data) + 1, ks,
580 &cbc_iv, DES_ENCRYPT);
581 if (memcmp(cbc_out, pcbc_ok, 32) != 0) {
582 printf("pcbc_encrypt encrypt error\n");
585 des_pcbc_encrypt(cbc_out, cbc_in, strlen((char *)cbc_data) + 1, ks,
586 &cbc_iv, DES_DECRYPT);
587 if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data) + 1) != 0) {
588 printf("pcbc_encrypt decrypt error\n");
594 err += cfb_test(8, cfb_cipher8);
596 err += cfb_test(16, cfb_cipher16);
598 err += cfb_test(32, cfb_cipher32);
600 err += cfb_test(48, cfb_cipher48);
602 err += cfb_test(64, cfb_cipher64);
605 err += cfb64_test(cfb_cipher64);
607 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
608 for (i = 0; i < sizeof(plain); i++)
609 des_cfb_encrypt(&(plain[i]), &(cfb_buf1[i]),
610 8, 1, ks, &cfb_tmp, DES_ENCRYPT);
611 if (memcmp(cfb_cipher8, cfb_buf1, sizeof(plain)) != 0) {
612 printf("cfb_encrypt small encrypt error\n");
616 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
617 for (i = 0; i < sizeof(plain); i++)
618 des_cfb_encrypt(&(cfb_buf1[i]), &(cfb_buf2[i]),
619 8, 1, ks, &cfb_tmp, DES_DECRYPT);
620 if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
621 printf("cfb_encrypt small decrypt error\n");
625 printf("ede_cfb64() ");
626 err += ede_cfb64_test(cfb_cipher64);
630 printf("Doing ofb\n");
631 DES_set_key_checked(&ofb_key, &ks);
632 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
633 des_ofb_encrypt(plain, ofb_buf1, 64, sizeof(plain) / 8, ks, &ofb_tmp);
634 if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) {
635 printf("ofb_encrypt encrypt error\n");
636 printf("%02X %02X %02X %02X %02X %02X %02X %02X\n",
637 ofb_buf1[8 + 0], ofb_buf1[8 + 1], ofb_buf1[8 + 2],
638 ofb_buf1[8 + 3], ofb_buf1[8 + 4], ofb_buf1[8 + 5],
639 ofb_buf1[8 + 6], ofb_buf1[8 + 7]);
640 printf("%02X %02X %02X %02X %02X %02X %02X %02X\n", ofb_buf1[8 + 0],
641 ofb_cipher[8 + 1], ofb_cipher[8 + 2], ofb_cipher[8 + 3],
642 ofb_buf1[8 + 4], ofb_cipher[8 + 5], ofb_cipher[8 + 6],
646 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
647 des_ofb_encrypt(ofb_buf1, ofb_buf2, 64, sizeof(ofb_buf1) / 8, ks,
649 if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) {
650 printf("ofb_encrypt decrypt error\n");
651 printf("%02X %02X %02X %02X %02X %02X %02X %02X\n",
652 ofb_buf2[8 + 0], ofb_buf2[8 + 1], ofb_buf2[8 + 2],
653 ofb_buf2[8 + 3], ofb_buf2[8 + 4], ofb_buf2[8 + 5],
654 ofb_buf2[8 + 6], ofb_buf2[8 + 7]);
655 printf("%02X %02X %02X %02X %02X %02X %02X %02X\n", plain[8 + 0],
656 plain[8 + 1], plain[8 + 2], plain[8 + 3], plain[8 + 4],
657 plain[8 + 5], plain[8 + 6], plain[8 + 7]);
661 printf("Doing ofb64\n");
662 DES_set_key_checked(&ofb_key, &ks);
663 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
664 memset(ofb_buf1, 0, sizeof(ofb_buf1));
665 memset(ofb_buf2, 0, sizeof(ofb_buf1));
667 for (i = 0; i < sizeof(plain); i++) {
668 des_ofb64_encrypt(&(plain[i]), &(ofb_buf1[i]), 1, ks, &ofb_tmp, &num);
670 if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) {
671 printf("ofb64_encrypt encrypt error\n");
674 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
676 des_ofb64_encrypt(ofb_buf1, ofb_buf2, sizeof(ofb_buf1), ks, &ofb_tmp,
678 if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) {
679 printf("ofb64_encrypt decrypt error\n");
683 printf("Doing ede_ofb64\n");
684 DES_set_key_checked(&ofb_key, &ks);
685 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
686 memset(ofb_buf1, 0, sizeof(ofb_buf1));
687 memset(ofb_buf2, 0, sizeof(ofb_buf1));
689 for (i = 0; i < sizeof(plain); i++) {
690 des_ede3_ofb64_encrypt(&(plain[i]), &(ofb_buf1[i]), 1, ks, ks,
693 if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) {
694 printf("ede_ofb64_encrypt encrypt error\n");
697 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
699 des_ede3_ofb64_encrypt(ofb_buf1, ofb_buf2, sizeof(ofb_buf1), ks, ks, ks,
701 if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) {
702 printf("ede_ofb64_encrypt decrypt error\n");
706 printf("Doing cbc_cksum\n");
707 DES_set_key_checked(&cbc_key, &ks);
708 cs = des_cbc_cksum(cbc_data, &cret, strlen((char *)cbc_data), ks,
710 if (cs != cbc_cksum_ret) {
711 printf("bad return value (%08lX), should be %08lX\n",
712 (unsigned long)cs, (unsigned long)cbc_cksum_ret);
715 if (memcmp(cret, cbc_cksum_data, 8) != 0) {
716 printf("bad cbc_cksum block returned\n");
720 printf("Doing quad_cksum\n");
721 cs = des_quad_cksum(cbc_data, (des_cblock *)lqret,
722 (long)strlen((char *)cbc_data), 2,
723 (des_cblock *)cbc_iv);
724 if (cs != 0x70d7a63aL) {
725 printf("quad_cksum error, ret %08lx should be 70d7a63a\n",
729 if (lqret[0] != 0x327eba8dL) {
730 printf("quad_cksum error, out[0] %08lx is not %08lx\n",
731 (unsigned long)lqret[0], 0x327eba8dUL);
734 if (lqret[1] != 0x201a49ccL) {
735 printf("quad_cksum error, out[1] %08lx is not %08lx\n",
736 (unsigned long)lqret[1], 0x201a49ccUL);
739 if (lqret[2] != 0x70d7a63aL) {
740 printf("quad_cksum error, out[2] %08lx is not %08lx\n",
741 (unsigned long)lqret[2], 0x70d7a63aUL);
744 if (lqret[3] != 0x501c2c26L) {
745 printf("quad_cksum error, out[3] %08lx is not %08lx\n",
746 (unsigned long)lqret[3], 0x501c2c26UL);
751 printf("input word alignment test");
752 for (i = 0; i < 4; i++) {
754 des_ncbc_encrypt(&(cbc_out[i]), cbc_in,
755 strlen((char *)cbc_data) + 1, ks,
756 &cbc_iv, DES_ENCRYPT);
758 printf("\noutput word alignment test");
759 for (i = 0; i < 4; i++) {
761 des_ncbc_encrypt(cbc_out, &(cbc_in[i]),
762 strlen((char *)cbc_data) + 1, ks,
763 &cbc_iv, DES_ENCRYPT);
766 printf("fast crypt test ");
767 str = crypt("testing", "ef");
768 if (strcmp("efGnQx2725bI2", str) != 0) {
769 printf("fast crypt error, %s should be efGnQx2725bI2\n", str);
772 str = crypt("bca76;23", "yA");
773 if (strcmp("yA1Rp/1hZXIJk", str) != 0) {
774 printf("fast crypt error, %s should be yA1Rp/1hZXIJk\n", str);
777 # ifdef OPENSSL_SYS_NETWARE
779 printf("ERROR: %d\n", err);
785 static char *pt(unsigned char *p)
787 static char bufs[10][20];
791 static char *f = "0123456789ABCDEF";
793 ret = &(bufs[bnum++][0]);
795 for (i = 0; i < 8; i++) {
796 ret[i * 2] = f[(p[i] >> 4) & 0xf];
797 ret[i * 2 + 1] = f[p[i] & 0xf];
805 static int cfb_test(int bits, unsigned char *cfb_cipher)
810 DES_set_key_checked(&cfb_key, &ks);
811 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
812 des_cfb_encrypt(plain, cfb_buf1, bits, sizeof(plain), ks, &cfb_tmp,
814 if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0) {
816 printf("cfb_encrypt encrypt error\n");
817 for (i = 0; i < 24; i += 8)
818 printf("%s\n", pt(&(cfb_buf1[i])));
820 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
821 des_cfb_encrypt(cfb_buf1, cfb_buf2, bits, sizeof(plain), ks, &cfb_tmp,
823 if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
825 printf("cfb_encrypt decrypt error\n");
826 for (i = 0; i < 24; i += 8)
827 printf("%s\n", pt(&(cfb_buf1[i])));
832 static int cfb64_test(unsigned char *cfb_cipher)
837 DES_set_key_checked(&cfb_key, &ks);
838 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
840 des_cfb64_encrypt(plain, cfb_buf1, 12, ks, &cfb_tmp, &n, DES_ENCRYPT);
841 des_cfb64_encrypt(&(plain[12]), &(cfb_buf1[12]), sizeof(plain) - 12, ks,
842 &cfb_tmp, &n, DES_ENCRYPT);
843 if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0) {
845 printf("cfb_encrypt encrypt error\n");
846 for (i = 0; i < 24; i += 8)
847 printf("%s\n", pt(&(cfb_buf1[i])));
849 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
851 des_cfb64_encrypt(cfb_buf1, cfb_buf2, 17, ks, &cfb_tmp, &n, DES_DECRYPT);
852 des_cfb64_encrypt(&(cfb_buf1[17]), &(cfb_buf2[17]),
853 sizeof(plain) - 17, ks, &cfb_tmp, &n, DES_DECRYPT);
854 if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
856 printf("cfb_encrypt decrypt error\n");
857 for (i = 0; i < 24; i += 8)
858 printf("%s\n", pt(&(cfb_buf2[i])));
863 static int ede_cfb64_test(unsigned char *cfb_cipher)
868 DES_set_key_checked(&cfb_key, &ks);
869 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
871 des_ede3_cfb64_encrypt(plain, cfb_buf1, 12, ks, ks, ks, &cfb_tmp, &n,
873 des_ede3_cfb64_encrypt(&(plain[12]), &(cfb_buf1[12]),
874 sizeof(plain) - 12, ks, ks, ks,
875 &cfb_tmp, &n, DES_ENCRYPT);
876 if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0) {
878 printf("ede_cfb_encrypt encrypt error\n");
879 for (i = 0; i < 24; i += 8)
880 printf("%s\n", pt(&(cfb_buf1[i])));
882 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
884 des_ede3_cfb64_encrypt(cfb_buf1, cfb_buf2, (long)17, ks, ks, ks,
885 &cfb_tmp, &n, DES_DECRYPT);
886 des_ede3_cfb64_encrypt(&(cfb_buf1[17]), &(cfb_buf2[17]),
887 sizeof(plain) - 17, ks, ks, ks,
888 &cfb_tmp, &n, DES_DECRYPT);
889 if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
891 printf("ede_cfb_encrypt decrypt error\n");
892 for (i = 0; i < 24; i += 8)
893 printf("%s\n", pt(&(cfb_buf2[i])));