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