2 * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
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
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
20 #ifndef OPENSSL_SYS_MSDOS
21 # if !defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_VMS_DECC)
22 # include OPENSSL_UNISTD
30 int main(int argc, char *argv[])
32 printf("No DES support\n");
36 # include <openssl/des.h>
38 # define crypt(c,s) (DES_crypt((c),(s)))
40 /* tisk tisk - the test keys don't all have odd parity :-( */
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}
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}
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}
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}
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 };
199 * Changed the following text constant to binary so it will work on ebcdic
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,
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
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,
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,
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
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
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
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
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
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
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
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
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
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 };
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[])
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];
316 unsigned char cret[8];
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);
327 DES_ecb_encrypt(&in, &out, &ks, DES_ENCRYPT);
328 DES_ecb_encrypt(&out, &outin, &ks, DES_DECRYPT);
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]),
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));
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);
352 DES_ecb3_encrypt(&in,&out,&ks,&ks2,&ks,DES_ENCRYPT);
353 DES_ecb3_encrypt(&out,&outin,&ks,&ks2,&ks,DES_DECRYPT);
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]),
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));
369 printf("Doing cbc\n");
370 if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
371 printf("Key error %d\n", j);
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,
379 if (memcmp(cbc_out, cbc_ok, 32) != 0) {
380 printf("cbc_encrypt encrypt error\n");
384 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
385 DES_ncbc_encrypt(cbc_out, cbc_in, strlen((char *)cbc_data) + 1, &ks,
387 if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data)) != 0) {
388 printf("cbc_encrypt decrypt error\n");
392 printf("Doing desx cbc\n");
393 if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
394 printf("Key error %d\n", j);
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");
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");
415 printf("Doing ede cbc\n");
416 if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
417 printf("Key error %d\n", j);
420 if ((j = DES_set_key_checked(&cbc2_key, &ks2)) != 0) {
421 printf("Key error %d\n", j);
424 if ((j = DES_set_key_checked(&cbc3_key, &ks3)) != 0) {
425 printf("Key error %d\n", j);
428 memset(cbc_out, 0, 40);
429 memset(cbc_in, 0, 40);
430 i = strlen((char *)cbc_data) + 1;
432 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
434 DES_ede3_cbc_encrypt(cbc_data, cbc_out, 16L, &ks, &ks2, &ks3, &iv3,
436 DES_ede3_cbc_encrypt(&(cbc_data[16]), &(cbc_out[16]), i - 16, &ks, &ks2,
437 &ks3, &iv3, DES_ENCRYPT);
440 (unsigned int)(strlen((char *)cbc_data) + 1 + 7) / 8 * 8) != 0) {
443 printf("des_ede3_cbc_encrypt encrypt error\n");
444 for (n = 0; n < i; ++n)
445 printf(" %02x", cbc_out[n]);
447 for (n = 0; n < i; ++n)
448 printf(" %02x", cbc3_ok[n]);
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) {
458 printf("DES_ede3_cbc_encrypt decrypt error\n");
459 for (n = 0; n < i; ++n)
460 printf(" %02x", cbc_data[n]);
462 for (n = 0; n < i; ++n)
463 printf(" %02x", cbc_in[n]);
468 printf("Doing pcbc\n");
469 if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
470 printf("Key error %d\n", j);
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");
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");
490 err += cfb_test(8, cfb_cipher8);
492 err += cfb_test(16, cfb_cipher16);
494 err += cfb_test(32, cfb_cipher32);
496 err += cfb_test(48, cfb_cipher48);
498 err += cfb_test(64, cfb_cipher64);
501 err += cfb64_test(cfb_cipher64);
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");
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");
521 printf("ede_cfb64() ");
522 err += ede_cfb64_test(cfb_cipher64);
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],
542 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
543 DES_ofb_encrypt(ofb_buf1, ofb_buf2, 64, sizeof(ofb_buf1) / 8, &ks,
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]);
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));
563 for (i = 0; i < sizeof(plain); i++) {
564 DES_ofb64_encrypt(&(plain[i]), &(ofb_buf1[i]), 1, &ks, &ofb_tmp, &num);
566 if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) {
567 printf("ofb64_encrypt encrypt error\n");
570 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
572 DES_ofb64_encrypt(ofb_buf1, ofb_buf2, sizeof(ofb_buf1), &ks, &ofb_tmp,
574 if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) {
575 printf("ofb64_encrypt decrypt error\n");
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));
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);
589 if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) {
590 printf("ede_ofb64_encrypt encrypt error\n");
593 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
595 DES_ede3_ofb64_encrypt(ofb_buf1, ofb_buf2, sizeof(ofb_buf1), &ks, &ks, &ks,
597 if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) {
598 printf("ede_ofb64_encrypt decrypt error\n");
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,
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);
611 if (memcmp(cret, cbc_cksum_data, 8) != 0) {
612 printf("bad cbc_cksum block returned\n");
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",
625 if (lqret[0] != 0x327eba8dL) {
626 printf("quad_cksum error, out[0] %08lx is not %08lx\n",
627 (unsigned long)lqret[0], 0x327eba8dUL);
630 if (lqret[1] != 0x201a49ccL) {
631 printf("quad_cksum error, out[1] %08lx is not %08lx\n",
632 (unsigned long)lqret[1], 0x201a49ccUL);
635 if (lqret[2] != 0x70d7a63aL) {
636 printf("quad_cksum error, out[2] %08lx is not %08lx\n",
637 (unsigned long)lqret[2], 0x70d7a63aUL);
640 if (lqret[3] != 0x501c2c26L) {
641 printf("quad_cksum error, out[3] %08lx is not %08lx\n",
642 (unsigned long)lqret[3], 0x501c2c26UL);
647 printf("input word alignment test");
648 for (i = 0; i < 4; i++) {
650 DES_ncbc_encrypt(&(cbc_out[i]), cbc_in,
651 strlen((char *)cbc_data) + 1, &ks,
652 &cbc_iv, DES_ENCRYPT);
654 printf("\noutput word alignment test");
655 for (i = 0; i < 4; i++) {
657 DES_ncbc_encrypt(cbc_out, &(cbc_in[i]),
658 strlen((char *)cbc_data) + 1, &ks,
659 &cbc_iv, DES_ENCRYPT);
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);
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);
677 static char *pt(unsigned char *p)
679 static char bufs[10][20];
683 static char *f = "0123456789ABCDEF";
685 ret = &(bufs[bnum++][0]);
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];
697 static int cfb_test(int bits, unsigned char *cfb_cipher)
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,
706 if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0) {
708 printf("cfb_encrypt encrypt error\n");
709 for (i = 0; i < 24; i += 8)
710 printf("%s\n", pt(&(cfb_buf1[i])));
712 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
713 DES_cfb_encrypt(cfb_buf1, cfb_buf2, bits, sizeof(plain), &ks, &cfb_tmp,
715 if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
717 printf("cfb_encrypt decrypt error\n");
718 for (i = 0; i < 24; i += 8)
719 printf("%s\n", pt(&(cfb_buf1[i])));
724 static int cfb64_test(unsigned char *cfb_cipher)
729 DES_set_key_checked(&cfb_key, &ks);
730 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
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) {
737 printf("cfb_encrypt encrypt error\n");
738 for (i = 0; i < 24; i += 8)
739 printf("%s\n", pt(&(cfb_buf1[i])));
741 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
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) {
748 printf("cfb_encrypt decrypt error\n");
749 for (i = 0; i < 24; i += 8)
750 printf("%s\n", pt(&(cfb_buf2[i])));
755 static int ede_cfb64_test(unsigned char *cfb_cipher)
760 DES_set_key_checked(&cfb_key, &ks);
761 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
763 DES_ede3_cfb64_encrypt(plain, cfb_buf1, 12, &ks, &ks, &ks, &cfb_tmp, &n,
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) {
770 printf("ede_cfb_encrypt encrypt error\n");
771 for (i = 0; i < 24; i += 8)
772 printf("%s\n", pt(&(cfb_buf1[i])));
774 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
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) {
783 printf("ede_cfb_encrypt decrypt error\n");
784 for (i = 0; i < 24; i += 8)
785 printf("%s\n", pt(&(cfb_buf2[i])));