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 /* tisk tisk - the test keys don't all have odd parity :-( */
41 static unsigned char key_data[NUM_TESTS][8] = {
42 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
43 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
44 {0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
45 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
46 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
47 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
48 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
49 {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10},
50 {0x7C, 0xA1, 0x10, 0x45, 0x4A, 0x1A, 0x6E, 0x57},
51 {0x01, 0x31, 0xD9, 0x61, 0x9D, 0xC1, 0x37, 0x6E},
52 {0x07, 0xA1, 0x13, 0x3E, 0x4A, 0x0B, 0x26, 0x86},
53 {0x38, 0x49, 0x67, 0x4C, 0x26, 0x02, 0x31, 0x9E},
54 {0x04, 0xB9, 0x15, 0xBA, 0x43, 0xFE, 0xB5, 0xB6},
55 {0x01, 0x13, 0xB9, 0x70, 0xFD, 0x34, 0xF2, 0xCE},
56 {0x01, 0x70, 0xF1, 0x75, 0x46, 0x8F, 0xB5, 0xE6},
57 {0x43, 0x29, 0x7F, 0xAD, 0x38, 0xE3, 0x73, 0xFE},
58 {0x07, 0xA7, 0x13, 0x70, 0x45, 0xDA, 0x2A, 0x16},
59 {0x04, 0x68, 0x91, 0x04, 0xC2, 0xFD, 0x3B, 0x2F},
60 {0x37, 0xD0, 0x6B, 0xB5, 0x16, 0xCB, 0x75, 0x46},
61 {0x1F, 0x08, 0x26, 0x0D, 0x1A, 0xC2, 0x46, 0x5E},
62 {0x58, 0x40, 0x23, 0x64, 0x1A, 0xBA, 0x61, 0x76},
63 {0x02, 0x58, 0x16, 0x16, 0x46, 0x29, 0xB0, 0x07},
64 {0x49, 0x79, 0x3E, 0xBC, 0x79, 0xB3, 0x25, 0x8F},
65 {0x4F, 0xB0, 0x5E, 0x15, 0x15, 0xAB, 0x73, 0xA7},
66 {0x49, 0xE9, 0x5D, 0x6D, 0x4C, 0xA2, 0x29, 0xBF},
67 {0x01, 0x83, 0x10, 0xDC, 0x40, 0x9B, 0x26, 0xD6},
68 {0x1C, 0x58, 0x7F, 0x1C, 0x13, 0x92, 0x4F, 0xEF},
69 {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
70 {0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E},
71 {0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE},
72 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
73 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
74 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
75 {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}
78 static unsigned char plain_data[NUM_TESTS][8] = {
79 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
80 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
81 {0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
82 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
83 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
84 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
85 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
86 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
87 {0x01, 0xA1, 0xD6, 0xD0, 0x39, 0x77, 0x67, 0x42},
88 {0x5C, 0xD5, 0x4C, 0xA8, 0x3D, 0xEF, 0x57, 0xDA},
89 {0x02, 0x48, 0xD4, 0x38, 0x06, 0xF6, 0x71, 0x72},
90 {0x51, 0x45, 0x4B, 0x58, 0x2D, 0xDF, 0x44, 0x0A},
91 {0x42, 0xFD, 0x44, 0x30, 0x59, 0x57, 0x7F, 0xA2},
92 {0x05, 0x9B, 0x5E, 0x08, 0x51, 0xCF, 0x14, 0x3A},
93 {0x07, 0x56, 0xD8, 0xE0, 0x77, 0x47, 0x61, 0xD2},
94 {0x76, 0x25, 0x14, 0xB8, 0x29, 0xBF, 0x48, 0x6A},
95 {0x3B, 0xDD, 0x11, 0x90, 0x49, 0x37, 0x28, 0x02},
96 {0x26, 0x95, 0x5F, 0x68, 0x35, 0xAF, 0x60, 0x9A},
97 {0x16, 0x4D, 0x5E, 0x40, 0x4F, 0x27, 0x52, 0x32},
98 {0x6B, 0x05, 0x6E, 0x18, 0x75, 0x9F, 0x5C, 0xCA},
99 {0x00, 0x4B, 0xD6, 0xEF, 0x09, 0x17, 0x60, 0x62},
100 {0x48, 0x0D, 0x39, 0x00, 0x6E, 0xE7, 0x62, 0xF2},
101 {0x43, 0x75, 0x40, 0xC8, 0x69, 0x8F, 0x3C, 0xFA},
102 {0x07, 0x2D, 0x43, 0xA0, 0x77, 0x07, 0x52, 0x92},
103 {0x02, 0xFE, 0x55, 0x77, 0x81, 0x17, 0xF1, 0x2A},
104 {0x1D, 0x9D, 0x5C, 0x50, 0x18, 0xF7, 0x28, 0xC2},
105 {0x30, 0x55, 0x32, 0x28, 0x6D, 0x6F, 0x29, 0x5A},
106 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
107 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
108 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
109 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
110 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
111 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
112 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}
115 static unsigned char cipher_data[NUM_TESTS][8] = {
116 {0x8C, 0xA6, 0x4D, 0xE9, 0xC1, 0xB1, 0x23, 0xA7},
117 {0x73, 0x59, 0xB2, 0x16, 0x3E, 0x4E, 0xDC, 0x58},
118 {0x95, 0x8E, 0x6E, 0x62, 0x7A, 0x05, 0x55, 0x7B},
119 {0xF4, 0x03, 0x79, 0xAB, 0x9E, 0x0E, 0xC5, 0x33},
120 {0x17, 0x66, 0x8D, 0xFC, 0x72, 0x92, 0x53, 0x2D},
121 {0x8A, 0x5A, 0xE1, 0xF8, 0x1A, 0xB8, 0xF2, 0xDD},
122 {0x8C, 0xA6, 0x4D, 0xE9, 0xC1, 0xB1, 0x23, 0xA7},
123 {0xED, 0x39, 0xD9, 0x50, 0xFA, 0x74, 0xBC, 0xC4},
124 {0x69, 0x0F, 0x5B, 0x0D, 0x9A, 0x26, 0x93, 0x9B},
125 {0x7A, 0x38, 0x9D, 0x10, 0x35, 0x4B, 0xD2, 0x71},
126 {0x86, 0x8E, 0xBB, 0x51, 0xCA, 0xB4, 0x59, 0x9A},
127 {0x71, 0x78, 0x87, 0x6E, 0x01, 0xF1, 0x9B, 0x2A},
128 {0xAF, 0x37, 0xFB, 0x42, 0x1F, 0x8C, 0x40, 0x95},
129 {0x86, 0xA5, 0x60, 0xF1, 0x0E, 0xC6, 0xD8, 0x5B},
130 {0x0C, 0xD3, 0xDA, 0x02, 0x00, 0x21, 0xDC, 0x09},
131 {0xEA, 0x67, 0x6B, 0x2C, 0xB7, 0xDB, 0x2B, 0x7A},
132 {0xDF, 0xD6, 0x4A, 0x81, 0x5C, 0xAF, 0x1A, 0x0F},
133 {0x5C, 0x51, 0x3C, 0x9C, 0x48, 0x86, 0xC0, 0x88},
134 {0x0A, 0x2A, 0xEE, 0xAE, 0x3F, 0xF4, 0xAB, 0x77},
135 {0xEF, 0x1B, 0xF0, 0x3E, 0x5D, 0xFA, 0x57, 0x5A},
136 {0x88, 0xBF, 0x0D, 0xB6, 0xD7, 0x0D, 0xEE, 0x56},
137 {0xA1, 0xF9, 0x91, 0x55, 0x41, 0x02, 0x0B, 0x56},
138 {0x6F, 0xBF, 0x1C, 0xAF, 0xCF, 0xFD, 0x05, 0x56},
139 {0x2F, 0x22, 0xE4, 0x9B, 0xAB, 0x7C, 0xA1, 0xAC},
140 {0x5A, 0x6B, 0x61, 0x2C, 0xC2, 0x6C, 0xCE, 0x4A},
141 {0x5F, 0x4C, 0x03, 0x8E, 0xD1, 0x2B, 0x2E, 0x41},
142 {0x63, 0xFA, 0xC0, 0xD0, 0x34, 0xD9, 0xF7, 0x93},
143 {0x61, 0x7B, 0x3A, 0x0C, 0xE8, 0xF0, 0x71, 0x00},
144 {0xDB, 0x95, 0x86, 0x05, 0xF8, 0xC8, 0xC6, 0x06},
145 {0xED, 0xBF, 0xD1, 0xC6, 0x6C, 0x29, 0xCC, 0xC7},
146 {0x35, 0x55, 0x50, 0xB2, 0x15, 0x0E, 0x24, 0x51},
147 {0xCA, 0xAA, 0xAF, 0x4D, 0xEA, 0xF1, 0xDB, 0xAE},
148 {0xD5, 0xD4, 0x4F, 0xF7, 0x20, 0x68, 0x3D, 0x0D},
149 {0x2A, 0x2B, 0xB0, 0x08, 0xDF, 0x97, 0xC2, 0xF2}
152 static unsigned char cipher_ecb2[NUM_TESTS - 1][8] = {
153 {0x92, 0x95, 0xB5, 0x9B, 0xB3, 0x84, 0x73, 0x6E},
154 {0x19, 0x9E, 0x9D, 0x6D, 0xF3, 0x9A, 0xA8, 0x16},
155 {0x2A, 0x4B, 0x4D, 0x24, 0x52, 0x43, 0x84, 0x27},
156 {0x35, 0x84, 0x3C, 0x01, 0x9D, 0x18, 0xC5, 0xB6},
157 {0x4A, 0x5B, 0x2F, 0x42, 0xAA, 0x77, 0x19, 0x25},
158 {0xA0, 0x6B, 0xA9, 0xB8, 0xCA, 0x5B, 0x17, 0x8A},
159 {0xAB, 0x9D, 0xB7, 0xFB, 0xED, 0x95, 0xF2, 0x74},
160 {0x3D, 0x25, 0x6C, 0x23, 0xA7, 0x25, 0x2F, 0xD6},
161 {0xB7, 0x6F, 0xAB, 0x4F, 0xBD, 0xBD, 0xB7, 0x67},
162 {0x8F, 0x68, 0x27, 0xD6, 0x9C, 0xF4, 0x1A, 0x10},
163 {0x82, 0x57, 0xA1, 0xD6, 0x50, 0x5E, 0x81, 0x85},
164 {0xA2, 0x0F, 0x0A, 0xCD, 0x80, 0x89, 0x7D, 0xFA},
165 {0xCD, 0x2A, 0x53, 0x3A, 0xDB, 0x0D, 0x7E, 0xF3},
166 {0xD2, 0xC2, 0xBE, 0x27, 0xE8, 0x1B, 0x68, 0xE3},
167 {0xE9, 0x24, 0xCF, 0x4F, 0x89, 0x3C, 0x5B, 0x0A},
168 {0xA7, 0x18, 0xC3, 0x9F, 0xFA, 0x9F, 0xD7, 0x69},
169 {0x77, 0x2C, 0x79, 0xB1, 0xD2, 0x31, 0x7E, 0xB1},
170 {0x49, 0xAB, 0x92, 0x7F, 0xD0, 0x22, 0x00, 0xB7},
171 {0xCE, 0x1C, 0x6C, 0x7D, 0x85, 0xE3, 0x4A, 0x6F},
172 {0xBE, 0x91, 0xD6, 0xE1, 0x27, 0xB2, 0xE9, 0x87},
173 {0x70, 0x28, 0xAE, 0x8F, 0xD1, 0xF5, 0x74, 0x1A},
174 {0xAA, 0x37, 0x80, 0xBB, 0xF3, 0x22, 0x1D, 0xDE},
175 {0xA6, 0xC4, 0xD2, 0x5E, 0x28, 0x93, 0xAC, 0xB3},
176 {0x22, 0x07, 0x81, 0x5A, 0xE4, 0xB7, 0x1A, 0xAD},
177 {0xDC, 0xCE, 0x05, 0xE7, 0x07, 0xBD, 0xF5, 0x84},
178 {0x26, 0x1D, 0x39, 0x2C, 0xB3, 0xBA, 0xA5, 0x85},
179 {0xB4, 0xF7, 0x0F, 0x72, 0xFB, 0x04, 0xF0, 0xDC},
180 {0x95, 0xBA, 0xA9, 0x4E, 0x87, 0x36, 0xF2, 0x89},
181 {0xD4, 0x07, 0x3A, 0xF1, 0x5A, 0x17, 0x82, 0x0E},
182 {0xEF, 0x6F, 0xAF, 0xA7, 0x66, 0x1A, 0x7E, 0x89},
183 {0xC1, 0x97, 0xF5, 0x58, 0x74, 0x8A, 0x20, 0xE7},
184 {0x43, 0x34, 0xCF, 0xDA, 0x22, 0xC4, 0x86, 0xC8},
185 {0x08, 0xD7, 0xB4, 0xFB, 0x62, 0x9D, 0x08, 0x85}
188 static unsigned char cbc_key[8] =
189 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
190 static unsigned char cbc2_key[8] =
191 { 0xf1, 0xe0, 0xd3, 0xc2, 0xb5, 0xa4, 0x97, 0x86 };
192 static unsigned char cbc3_key[8] =
193 { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
194 static unsigned char cbc_iv[8] =
195 { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
197 * Changed the following text constant to binary so it will work on ebcdic
200 /* static char cbc_data[40]="7654321 Now is the time for \0001"; */
201 static unsigned char cbc_data[40] = {
202 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20,
203 0x4E, 0x6F, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74,
204 0x68, 0x65, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x20,
205 0x66, 0x6F, 0x72, 0x20, 0x00, 0x31, 0x00, 0x00,
206 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
209 static unsigned char cbc_ok[32] = {
210 0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4,
211 0xac, 0xd8, 0xae, 0xfd, 0xdf, 0xd8, 0xa1, 0xeb,
212 0x46, 0x8e, 0x91, 0x15, 0x78, 0x88, 0xba, 0x68,
213 0x1d, 0x26, 0x93, 0x97, 0xf7, 0xfe, 0x62, 0xb4
216 # ifdef SCREW_THE_PARITY
217 # error "SCREW_THE_PARITY is not meant to be defined."
218 # error "Original vectors are preserved for reference only."
219 static unsigned char cbc2_key[8] =
220 { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87 };
221 static unsigned char xcbc_ok[32] = {
222 0x86, 0x74, 0x81, 0x0D, 0x61, 0xA4, 0xA5, 0x48,
223 0xB9, 0x93, 0x03, 0xE1, 0xB8, 0xBB, 0xBD, 0xBD,
224 0x64, 0x30, 0x0B, 0xB9, 0x06, 0x65, 0x81, 0x76,
225 0x04, 0x1D, 0x77, 0x62, 0x17, 0xCA, 0x2B, 0xD2,
228 static unsigned char xcbc_ok[32] = {
229 0x84, 0x6B, 0x29, 0x14, 0x85, 0x1E, 0x9A, 0x29,
230 0x54, 0x73, 0x2F, 0x8A, 0xA0, 0xA6, 0x11, 0xC1,
231 0x15, 0xCD, 0xC2, 0xD7, 0x95, 0x1B, 0x10, 0x53,
232 0xA6, 0x3C, 0x5E, 0x03, 0xB2, 0x1A, 0xA3, 0xC4,
236 static unsigned char cbc3_ok[32] = {
237 0x3F, 0xE3, 0x01, 0xC9, 0x62, 0xAC, 0x01, 0xD0,
238 0x22, 0x13, 0x76, 0x3C, 0x1C, 0xBD, 0x4C, 0xDC,
239 0x79, 0x96, 0x57, 0xC0, 0x64, 0xEC, 0xF5, 0xD4,
240 0x1C, 0x67, 0x38, 0x12, 0xCF, 0xDE, 0x96, 0x75
243 static unsigned char pcbc_ok[32] = {
244 0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4,
245 0x6d, 0xec, 0xb4, 0x70, 0xa0, 0xe5, 0x6b, 0x15,
246 0xae, 0xa6, 0xbf, 0x61, 0xed, 0x7d, 0x9c, 0x9f,
247 0xf7, 0x17, 0x46, 0x3b, 0x8a, 0xb3, 0xcc, 0x88
250 static unsigned char cfb_key[8] =
251 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
252 static unsigned char cfb_iv[8] =
253 { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef };
254 static unsigned char cfb_buf1[40], cfb_buf2[40], cfb_tmp[8];
255 static unsigned char plain[24] = {
256 0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73,
257 0x20, 0x74, 0x68, 0x65, 0x20, 0x74,
258 0x69, 0x6d, 0x65, 0x20, 0x66, 0x6f,
259 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20
262 static unsigned char cfb_cipher8[24] = {
263 0xf3, 0x1f, 0xda, 0x07, 0x01, 0x14, 0x62, 0xee, 0x18, 0x7f, 0x43, 0xd8,
264 0x0a, 0x7c, 0xd9, 0xb5, 0xb0, 0xd2, 0x90, 0xda, 0x6e, 0x5b, 0x9a, 0x87
267 static unsigned char cfb_cipher16[24] = {
268 0xF3, 0x09, 0x87, 0x87, 0x7F, 0x57, 0xF7, 0x3C, 0x36, 0xB6, 0xDB, 0x70,
269 0xD8, 0xD5, 0x34, 0x19, 0xD3, 0x86, 0xB2, 0x23, 0xB7, 0xB2, 0xAD, 0x1B
272 static unsigned char cfb_cipher32[24] = {
273 0xF3, 0x09, 0x62, 0x49, 0xA4, 0xDF, 0xA4, 0x9F, 0x33, 0xDC, 0x7B, 0xAD,
274 0x4C, 0xC8, 0x9F, 0x64, 0xE4, 0x53, 0xE5, 0xEC, 0x67, 0x20, 0xDA, 0xB6
277 static unsigned char cfb_cipher48[24] = {
278 0xF3, 0x09, 0x62, 0x49, 0xC7, 0xF4, 0x30, 0xB5, 0x15, 0xEC, 0xBB, 0x85,
279 0x97, 0x5A, 0x13, 0x8C, 0x68, 0x60, 0xE2, 0x38, 0x34, 0x3C, 0xDC, 0x1F
282 static unsigned char cfb_cipher64[24] = {
283 0xF3, 0x09, 0x62, 0x49, 0xC7, 0xF4, 0x6E, 0x51, 0xA6, 0x9E, 0x83, 0x9B,
284 0x1A, 0x92, 0xF7, 0x84, 0x03, 0x46, 0x71, 0x33, 0x89, 0x8E, 0xA6, 0x22
287 static unsigned char ofb_key[8] =
288 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
289 static unsigned char ofb_iv[8] =
290 { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef };
291 static unsigned char ofb_buf1[24], ofb_buf2[24], ofb_tmp[8];
292 static unsigned char ofb_cipher[24] = {
293 0xf3, 0x09, 0x62, 0x49, 0xc7, 0xf4, 0x6e, 0x51,
294 0x35, 0xf2, 0x4a, 0x24, 0x2e, 0xeb, 0x3d, 0x3f,
295 0x3d, 0x6d, 0x5b, 0xe3, 0x25, 0x5a, 0xf8, 0xc3
297 static DES_LONG cbc_cksum_ret = 0xF7FE62B4L;
298 static unsigned char cbc_cksum_data[8] =
299 { 0x1D, 0x26, 0x93, 0x97, 0xf7, 0xfe, 0x62, 0xb4 };
301 static char *pt(unsigned char *p);
302 static int cfb_test(int bits, unsigned char *cfb_cipher);
303 static int cfb64_test(unsigned char *cfb_cipher);
304 static int ede_cfb64_test(unsigned char *cfb_cipher);
305 int main(int argc, char *argv[])
309 DES_cblock in, out, outin, iv3;
310 DES_key_schedule ks, ks2, ks3;
311 unsigned char cbc_in[40];
312 unsigned char cbc_out[40];
314 unsigned char cret[8];
319 printf("Doing ecb\n");
320 for (i = 0; i < NUM_TESTS; i++) {
321 DES_set_key_unchecked(&key_data[i], &ks);
322 memcpy(in, plain_data[i], 8);
325 DES_ecb_encrypt(&in, &out, &ks, DES_ENCRYPT);
326 DES_ecb_encrypt(&out, &outin, &ks, DES_DECRYPT);
328 if (memcmp(out, cipher_data[i], 8) != 0) {
329 printf("Encryption error %2d\nk=%s p=%s o=%s act=%s\n",
330 i + 1, pt(key_data[i]), pt(in), pt(cipher_data[i]),
334 if (memcmp(in, outin, 8) != 0) {
335 printf("Decryption error %2d\nk=%s p=%s o=%s act=%s\n",
336 i + 1, pt(key_data[i]), pt(out), pt(in), pt(outin));
342 printf("Doing ede ecb\n");
343 for (i = 0; i < (NUM_TESTS - 2); i++) {
344 DES_set_key_unchecked(&key_data[i], &ks);
345 DES_set_key_unchecked(&key_data[i + 1], &ks2);
346 DES_set_key_unchecked(&key_data[i + 2], &ks3);
347 memcpy(in, plain_data[i], 8);
350 DES_ecb3_encrypt(&in,&out,&ks,&ks2,&ks,DES_ENCRYPT);
351 DES_ecb3_encrypt(&out,&outin,&ks,&ks2,&ks,DES_DECRYPT);
353 if (memcmp(out, cipher_ecb2[i], 8) != 0) {
354 printf("Encryption error %2d\nk=%s p=%s o=%s act=%s\n",
355 i + 1, pt(key_data[i]), pt(in), pt(cipher_ecb2[i]),
359 if (memcmp(in, outin, 8) != 0) {
360 printf("Decryption error %2d\nk=%s p=%s o=%s act=%s\n",
361 i + 1, pt(key_data[i]), pt(out), pt(in), pt(outin));
367 printf("Doing cbc\n");
368 if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
369 printf("Key error %d\n", j);
372 memset(cbc_out, 0, 40);
373 memset(cbc_in, 0, 40);
374 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
375 DES_ncbc_encrypt(cbc_data, cbc_out, strlen((char *)cbc_data) + 1, &ks,
377 if (memcmp(cbc_out, cbc_ok, 32) != 0) {
378 printf("cbc_encrypt encrypt error\n");
382 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
383 DES_ncbc_encrypt(cbc_out, cbc_in, strlen((char *)cbc_data) + 1, &ks,
385 if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data)) != 0) {
386 printf("cbc_encrypt decrypt error\n");
390 printf("Doing desx cbc\n");
391 if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
392 printf("Key error %d\n", j);
395 memset(cbc_out, 0, 40);
396 memset(cbc_in, 0, 40);
397 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
398 DES_xcbc_encrypt(cbc_data, cbc_out, strlen((char *)cbc_data) + 1, &ks,
399 &iv3, &cbc2_key, &cbc3_key, DES_ENCRYPT);
400 if (memcmp(cbc_out, xcbc_ok, 32) != 0) {
401 printf("des_xcbc_encrypt encrypt error\n");
404 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
405 DES_xcbc_encrypt(cbc_out, cbc_in, strlen((char *)cbc_data) + 1, &ks,
406 &iv3, &cbc2_key, &cbc3_key, DES_DECRYPT);
407 if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data) + 1) != 0) {
408 printf("des_xcbc_encrypt decrypt error\n");
413 printf("Doing ede cbc\n");
414 if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
415 printf("Key error %d\n", j);
418 if ((j = DES_set_key_checked(&cbc2_key, &ks2)) != 0) {
419 printf("Key error %d\n", j);
422 if ((j = DES_set_key_checked(&cbc3_key, &ks3)) != 0) {
423 printf("Key error %d\n", j);
426 memset(cbc_out, 0, 40);
427 memset(cbc_in, 0, 40);
428 i = strlen((char *)cbc_data) + 1;
430 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
432 DES_ede3_cbc_encrypt(cbc_data, cbc_out, 16L, &ks, &ks2, &ks3, &iv3,
434 DES_ede3_cbc_encrypt(&(cbc_data[16]), &(cbc_out[16]), i - 16, &ks, &ks2,
435 &ks3, &iv3, DES_ENCRYPT);
438 (unsigned int)(strlen((char *)cbc_data) + 1 + 7) / 8 * 8) != 0) {
441 printf("des_ede3_cbc_encrypt encrypt error\n");
442 for (n = 0; n < i; ++n)
443 printf(" %02x", cbc_out[n]);
445 for (n = 0; n < i; ++n)
446 printf(" %02x", cbc3_ok[n]);
451 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
452 DES_ede3_cbc_encrypt(cbc_out, cbc_in, i, &ks, &ks2, &ks3, &iv3, DES_DECRYPT);
453 if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data) + 1) != 0) {
456 printf("DES_ede3_cbc_encrypt decrypt error\n");
457 for (n = 0; n < i; ++n)
458 printf(" %02x", cbc_data[n]);
460 for (n = 0; n < i; ++n)
461 printf(" %02x", cbc_in[n]);
466 printf("Doing pcbc\n");
467 if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
468 printf("Key error %d\n", j);
471 memset(cbc_out, 0, 40);
472 memset(cbc_in, 0, 40);
473 DES_pcbc_encrypt(cbc_data, cbc_out, strlen((char *)cbc_data) + 1, &ks,
474 &cbc_iv, DES_ENCRYPT);
475 if (memcmp(cbc_out, pcbc_ok, 32) != 0) {
476 printf("pcbc_encrypt encrypt error\n");
479 DES_pcbc_encrypt(cbc_out, cbc_in, strlen((char *)cbc_data) + 1, &ks,
480 &cbc_iv, DES_DECRYPT);
481 if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data) + 1) != 0) {
482 printf("pcbc_encrypt decrypt error\n");
488 err += cfb_test(8, cfb_cipher8);
490 err += cfb_test(16, cfb_cipher16);
492 err += cfb_test(32, cfb_cipher32);
494 err += cfb_test(48, cfb_cipher48);
496 err += cfb_test(64, cfb_cipher64);
499 err += cfb64_test(cfb_cipher64);
501 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
502 for (i = 0; i < sizeof(plain); i++)
503 DES_cfb_encrypt(&(plain[i]), &(cfb_buf1[i]),
504 8, 1, &ks, &cfb_tmp, DES_ENCRYPT);
505 if (memcmp(cfb_cipher8, cfb_buf1, sizeof(plain)) != 0) {
506 printf("cfb_encrypt small encrypt error\n");
510 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
511 for (i = 0; i < sizeof(plain); i++)
512 DES_cfb_encrypt(&(cfb_buf1[i]), &(cfb_buf2[i]),
513 8, 1, &ks, &cfb_tmp, DES_DECRYPT);
514 if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
515 printf("cfb_encrypt small decrypt error\n");
519 printf("ede_cfb64() ");
520 err += ede_cfb64_test(cfb_cipher64);
524 printf("Doing ofb\n");
525 DES_set_key_checked(&ofb_key, &ks);
526 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
527 DES_ofb_encrypt(plain, ofb_buf1, 64, sizeof(plain) / 8, &ks, &ofb_tmp);
528 if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) {
529 printf("ofb_encrypt encrypt error\n");
530 printf("%02X %02X %02X %02X %02X %02X %02X %02X\n",
531 ofb_buf1[8 + 0], ofb_buf1[8 + 1], ofb_buf1[8 + 2],
532 ofb_buf1[8 + 3], ofb_buf1[8 + 4], ofb_buf1[8 + 5],
533 ofb_buf1[8 + 6], ofb_buf1[8 + 7]);
534 printf("%02X %02X %02X %02X %02X %02X %02X %02X\n", ofb_buf1[8 + 0],
535 ofb_cipher[8 + 1], ofb_cipher[8 + 2], ofb_cipher[8 + 3],
536 ofb_buf1[8 + 4], ofb_cipher[8 + 5], ofb_cipher[8 + 6],
540 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
541 DES_ofb_encrypt(ofb_buf1, ofb_buf2, 64, sizeof(ofb_buf1) / 8, &ks,
543 if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) {
544 printf("ofb_encrypt decrypt error\n");
545 printf("%02X %02X %02X %02X %02X %02X %02X %02X\n",
546 ofb_buf2[8 + 0], ofb_buf2[8 + 1], ofb_buf2[8 + 2],
547 ofb_buf2[8 + 3], ofb_buf2[8 + 4], ofb_buf2[8 + 5],
548 ofb_buf2[8 + 6], ofb_buf2[8 + 7]);
549 printf("%02X %02X %02X %02X %02X %02X %02X %02X\n", plain[8 + 0],
550 plain[8 + 1], plain[8 + 2], plain[8 + 3], plain[8 + 4],
551 plain[8 + 5], plain[8 + 6], plain[8 + 7]);
555 printf("Doing ofb64\n");
556 DES_set_key_checked(&ofb_key, &ks);
557 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
558 memset(ofb_buf1, 0, sizeof(ofb_buf1));
559 memset(ofb_buf2, 0, sizeof(ofb_buf1));
561 for (i = 0; i < sizeof(plain); i++) {
562 DES_ofb64_encrypt(&(plain[i]), &(ofb_buf1[i]), 1, &ks, &ofb_tmp, &num);
564 if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) {
565 printf("ofb64_encrypt encrypt error\n");
568 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
570 DES_ofb64_encrypt(ofb_buf1, ofb_buf2, sizeof(ofb_buf1), &ks, &ofb_tmp,
572 if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) {
573 printf("ofb64_encrypt decrypt error\n");
577 printf("Doing ede_ofb64\n");
578 DES_set_key_checked(&ofb_key, &ks);
579 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
580 memset(ofb_buf1, 0, sizeof(ofb_buf1));
581 memset(ofb_buf2, 0, sizeof(ofb_buf1));
583 for (i = 0; i < sizeof(plain); i++) {
584 DES_ede3_ofb64_encrypt(&(plain[i]), &(ofb_buf1[i]), 1, &ks, &ks,
585 &ks, &ofb_tmp, &num);
587 if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) {
588 printf("ede_ofb64_encrypt encrypt error\n");
591 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
593 DES_ede3_ofb64_encrypt(ofb_buf1, ofb_buf2, sizeof(ofb_buf1), &ks, &ks, &ks,
595 if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) {
596 printf("ede_ofb64_encrypt decrypt error\n");
600 printf("Doing cbc_cksum\n");
601 DES_set_key_checked(&cbc_key, &ks);
602 cs = DES_cbc_cksum(cbc_data, &cret, strlen((char *)cbc_data), &ks,
604 if (cs != cbc_cksum_ret) {
605 printf("bad return value (%08lX), should be %08lX\n",
606 (unsigned long)cs, (unsigned long)cbc_cksum_ret);
609 if (memcmp(cret, cbc_cksum_data, 8) != 0) {
610 printf("bad cbc_cksum block returned\n");
614 printf("Doing quad_cksum\n");
615 cs = DES_quad_cksum(cbc_data, (DES_cblock *)lqret,
616 (long)strlen((char *)cbc_data), 2,
617 (DES_cblock *)cbc_iv);
618 if (cs != 0x70d7a63aL) {
619 printf("quad_cksum error, ret %08lx should be 70d7a63a\n",
623 if (lqret[0] != 0x327eba8dL) {
624 printf("quad_cksum error, out[0] %08lx is not %08lx\n",
625 (unsigned long)lqret[0], 0x327eba8dUL);
628 if (lqret[1] != 0x201a49ccL) {
629 printf("quad_cksum error, out[1] %08lx is not %08lx\n",
630 (unsigned long)lqret[1], 0x201a49ccUL);
633 if (lqret[2] != 0x70d7a63aL) {
634 printf("quad_cksum error, out[2] %08lx is not %08lx\n",
635 (unsigned long)lqret[2], 0x70d7a63aUL);
638 if (lqret[3] != 0x501c2c26L) {
639 printf("quad_cksum error, out[3] %08lx is not %08lx\n",
640 (unsigned long)lqret[3], 0x501c2c26UL);
645 printf("input word alignment test");
646 for (i = 0; i < 4; i++) {
648 DES_ncbc_encrypt(&(cbc_out[i]), cbc_in,
649 strlen((char *)cbc_data) + 1, &ks,
650 &cbc_iv, DES_ENCRYPT);
652 printf("\noutput word alignment test");
653 for (i = 0; i < 4; i++) {
655 DES_ncbc_encrypt(cbc_out, &(cbc_in[i]),
656 strlen((char *)cbc_data) + 1, &ks,
657 &cbc_iv, DES_ENCRYPT);
660 printf("fast crypt test ");
661 str = DES_crypt("testing", "ef");
662 if (strcmp("efGnQx2725bI2", str) != 0) {
663 printf("fast crypt error, %s should be efGnQx2725bI2\n", str);
666 str = DES_crypt("bca76;23", "yA");
667 if (strcmp("yA1Rp/1hZXIJk", str) != 0) {
668 printf("fast crypt error, %s should be yA1Rp/1hZXIJk\n", str);
671 str = DES_crypt("testing", "y\202");
673 printf("salt error only usascii are accepted\n");
676 str = DES_crypt("testing", "\0A");
678 printf("salt error cannot contain null terminator\n");
681 str = DES_crypt("testing", "A");
683 printf("salt error must be at least 2\n");
690 static char *pt(unsigned char *p)
692 static char bufs[10][20];
696 static char *f = "0123456789ABCDEF";
698 ret = &(bufs[bnum++][0]);
700 for (i = 0; i < 8; i++) {
701 ret[i * 2] = f[(p[i] >> 4) & 0xf];
702 ret[i * 2 + 1] = f[p[i] & 0xf];
710 static int cfb_test(int bits, unsigned char *cfb_cipher)
715 DES_set_key_checked(&cfb_key, &ks);
716 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
717 DES_cfb_encrypt(plain, cfb_buf1, bits, sizeof(plain), &ks, &cfb_tmp,
719 if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0) {
721 printf("cfb_encrypt encrypt error\n");
722 for (i = 0; i < 24; i += 8)
723 printf("%s\n", pt(&(cfb_buf1[i])));
725 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
726 DES_cfb_encrypt(cfb_buf1, cfb_buf2, bits, sizeof(plain), &ks, &cfb_tmp,
728 if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
730 printf("cfb_encrypt decrypt error\n");
731 for (i = 0; i < 24; i += 8)
732 printf("%s\n", pt(&(cfb_buf1[i])));
737 static int cfb64_test(unsigned char *cfb_cipher)
742 DES_set_key_checked(&cfb_key, &ks);
743 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
745 DES_cfb64_encrypt(plain, cfb_buf1, 12, &ks, &cfb_tmp, &n, DES_ENCRYPT);
746 DES_cfb64_encrypt(&(plain[12]), &(cfb_buf1[12]), sizeof(plain) - 12, &ks,
747 &cfb_tmp, &n, DES_ENCRYPT);
748 if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0) {
750 printf("cfb_encrypt encrypt error\n");
751 for (i = 0; i < 24; i += 8)
752 printf("%s\n", pt(&(cfb_buf1[i])));
754 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
756 DES_cfb64_encrypt(cfb_buf1, cfb_buf2, 17, &ks, &cfb_tmp, &n, DES_DECRYPT);
757 DES_cfb64_encrypt(&(cfb_buf1[17]), &(cfb_buf2[17]),
758 sizeof(plain) - 17, &ks, &cfb_tmp, &n, DES_DECRYPT);
759 if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
761 printf("cfb_encrypt decrypt error\n");
762 for (i = 0; i < 24; i += 8)
763 printf("%s\n", pt(&(cfb_buf2[i])));
768 static int ede_cfb64_test(unsigned char *cfb_cipher)
773 DES_set_key_checked(&cfb_key, &ks);
774 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
776 DES_ede3_cfb64_encrypt(plain, cfb_buf1, 12, &ks, &ks, &ks, &cfb_tmp, &n,
778 DES_ede3_cfb64_encrypt(&(plain[12]), &(cfb_buf1[12]),
779 sizeof(plain) - 12, &ks, &ks, &ks,
780 &cfb_tmp, &n, DES_ENCRYPT);
781 if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0) {
783 printf("ede_cfb_encrypt encrypt error\n");
784 for (i = 0; i < 24; i += 8)
785 printf("%s\n", pt(&(cfb_buf1[i])));
787 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
789 DES_ede3_cfb64_encrypt(cfb_buf1, cfb_buf2, (long)17, &ks, &ks, &ks,
790 &cfb_tmp, &n, DES_DECRYPT);
791 DES_ede3_cfb64_encrypt(&(cfb_buf1[17]), &(cfb_buf2[17]),
792 sizeof(plain) - 17, &ks, &ks, &ks,
793 &cfb_tmp, &n, DES_DECRYPT);
794 if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
796 printf("ede_cfb_encrypt decrypt error\n");
797 for (i = 0; i < 24; i += 8)
798 printf("%s\n", pt(&(cfb_buf2[i])));