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
26static 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
63static 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
100static 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
137static 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
173static unsigned char cbc_key[8] =
174    { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
175static unsigned char cbc2_key[8] =
176    { 0xf1, 0xe0, 0xd3, 0xc2, 0xb5, 0xa4, 0x97, 0x86 };
177static unsigned char cbc3_key[8] =
178    { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
179static 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"; */
186static 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
194static 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."
204static unsigned char cbc2_key[8] =
205    { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87 };
206static 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
213static 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
221static 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
228static 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
235static unsigned char cfb_key[8] =
236    { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
237static unsigned char cfb_iv[8] =
238    { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef };
239static unsigned char cfb_buf1[40], cfb_buf2[40], cfb_tmp[8];
240static 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
247static 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
252static 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
257static 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
262static 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
267static 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
272static unsigned char ofb_key[8] =
273    { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
274static unsigned char ofb_iv[8] =
275    { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef };
276static unsigned char ofb_buf1[24], ofb_buf2[24], ofb_tmp[8];
277static 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};
282static DES_LONG cbc_cksum_ret = 0xF7FE62B4L;
283static unsigned char cbc_cksum_data[8] =
284    { 0x1D, 0x26, 0x93, 0x97, 0xf7, 0xfe, 0x62, 0xb4 };
285
286static char *pt(const unsigned char *p, char buf[DATA_BUF_SIZE])
287{
288    char *ret;
289    int i;
290    static const 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
301static 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
327static 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
355static 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
379static 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
402static 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
434static 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
449static 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
464static 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
480static 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
500static 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
516static int test_des_cfb8(void)
517{
518    return cfb_test(8, cfb_cipher8);
519}
520
521static int test_des_cfb16(void)
522{
523    return cfb_test(16, cfb_cipher16);
524}
525
526static int test_des_cfb32(void)
527{
528    return cfb_test(32, cfb_cipher32);
529}
530
531static int test_des_cfb48(void)
532{
533    return cfb_test(48, cfb_cipher48);
534}
535
536static 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
575static 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
598static 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
614static 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
637static 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
661static 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
675static 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
696int 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