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