destest.c revision 1.2 
1/*
2 * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
3 *
4 * Licensed under the OpenSSL license (the "License").  You may not use
5 * this file except in compliance with the License.  You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
8 */
9
10#include <stdio.h>
11#include <stdlib.h>
12
13#include <openssl/e_os2.h>
14#if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_WINDOWS)
15# ifndef OPENSSL_SYS_MSDOS
16#  define OPENSSL_SYS_MSDOS
17# endif
18#endif
19
20#ifndef OPENSSL_SYS_MSDOS
21# if !defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_VMS_DECC)
22#  include OPENSSL_UNISTD
23# endif
24#else
25# include <io.h>
26#endif
27#include <string.h>
28
29#ifdef OPENSSL_NO_DES
30int main(int argc, char *argv[])
31{
32    printf("No DES support\n");
33    return (0);
34}
35#else
36# include <openssl/des.h>
37
38/* tisk tisk - the test keys don't all have odd parity :-( */
39/* test data */
40# define NUM_TESTS 34
41static 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}
76};
77
78static 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}
113};
114
115static 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}
150};
151
152static 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}
186};
187
188static unsigned char cbc_key[8] =
189    { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
190static unsigned char cbc2_key[8] =
191    { 0xf1, 0xe0, 0xd3, 0xc2, 0xb5, 0xa4, 0x97, 0x86 };
192static unsigned char cbc3_key[8] =
193    { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
194static unsigned char cbc_iv[8] =
195    { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
196/*
197 * Changed the following text constant to binary so it will work on ebcdic
198 * machines :-)
199 */
200/* static char cbc_data[40]="7654321 Now is the time for \0001"; */
201static 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,
207};
208
209static 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
214};
215
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."
219static unsigned char cbc2_key[8] =
220    { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87 };
221static 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,
226};
227# else
228static 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,
233};
234# endif
235
236static 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
241};
242
243static 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
248};
249
250static unsigned char cfb_key[8] =
251    { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
252static unsigned char cfb_iv[8] =
253    { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef };
254static unsigned char cfb_buf1[40], cfb_buf2[40], cfb_tmp[8];
255static 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
260};
261
262static 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
265};
266
267static 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
270};
271
272static 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
275};
276
277static 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
280};
281
282static 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
285};
286
287static unsigned char ofb_key[8] =
288    { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
289static unsigned char ofb_iv[8] =
290    { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef };
291static unsigned char ofb_buf1[24], ofb_buf2[24], ofb_tmp[8];
292static 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
296};
297static DES_LONG cbc_cksum_ret = 0xF7FE62B4L;
298static unsigned char cbc_cksum_data[8] =
299    { 0x1D, 0x26, 0x93, 0x97, 0xf7, 0xfe, 0x62, 0xb4 };
300
301static char *pt(unsigned char *p);
302static int cfb_test(int bits, unsigned char *cfb_cipher);
303static int cfb64_test(unsigned char *cfb_cipher);
304static int ede_cfb64_test(unsigned char *cfb_cipher);
305int main(int argc, char *argv[])
306{
307    int j, err = 0;
308    unsigned int i;
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];
313    DES_LONG cs;
314    unsigned char cret[8];
315    DES_LONG lqret[4];
316    int num;
317    char *str;
318
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);
323        memset(out, 0, 8);
324        memset(outin, 0, 8);
325        DES_ecb_encrypt(&in, &out, &ks, DES_ENCRYPT);
326        DES_ecb_encrypt(&out, &outin, &ks, DES_DECRYPT);
327
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]),
331                   pt(out));
332            err = 1;
333        }
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));
337            err = 1;
338        }
339    }
340
341# ifndef LIBDES_LIT
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);
348        memset(out, 0, 8);
349        memset(outin, 0, 8);
350        DES_ecb3_encrypt(&in,&out,&ks,&ks2,&ks,DES_ENCRYPT);
351        DES_ecb3_encrypt(&out,&outin,&ks,&ks2,&ks,DES_DECRYPT);
352
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]),
356                   pt(out));
357            err = 1;
358        }
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));
362            err = 1;
363        }
364    }
365# endif
366
367    printf("Doing cbc\n");
368    if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
369        printf("Key error %d\n", j);
370        err = 1;
371    }
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,
376                     &iv3, DES_ENCRYPT);
377    if (memcmp(cbc_out, cbc_ok, 32) != 0) {
378        printf("cbc_encrypt encrypt error\n");
379        err = 1;
380    }
381
382    memcpy(iv3, cbc_iv, sizeof(cbc_iv));
383    DES_ncbc_encrypt(cbc_out, cbc_in, strlen((char *)cbc_data) + 1, &ks,
384                     &iv3, DES_DECRYPT);
385    if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data)) != 0) {
386        printf("cbc_encrypt decrypt error\n");
387        err = 1;
388    }
389# ifndef LIBDES_LIT
390    printf("Doing desx cbc\n");
391    if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
392        printf("Key error %d\n", j);
393        err = 1;
394    }
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");
402        err = 1;
403    }
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");
409        err = 1;
410    }
411# endif
412
413    printf("Doing ede cbc\n");
414    if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
415        printf("Key error %d\n", j);
416        err = 1;
417    }
418    if ((j = DES_set_key_checked(&cbc2_key, &ks2)) != 0) {
419        printf("Key error %d\n", j);
420        err = 1;
421    }
422    if ((j = DES_set_key_checked(&cbc3_key, &ks3)) != 0) {
423        printf("Key error %d\n", j);
424        err = 1;
425    }
426    memset(cbc_out, 0, 40);
427    memset(cbc_in, 0, 40);
428    i = strlen((char *)cbc_data) + 1;
429    /* i=((i+7)/8)*8; */
430    memcpy(iv3, cbc_iv, sizeof(cbc_iv));
431
432    DES_ede3_cbc_encrypt(cbc_data, cbc_out, 16L, &ks, &ks2, &ks3, &iv3,
433                         DES_ENCRYPT);
434    DES_ede3_cbc_encrypt(&(cbc_data[16]), &(cbc_out[16]), i - 16, &ks, &ks2,
435                         &ks3, &iv3, DES_ENCRYPT);
436    if (memcmp
437        (cbc_out, cbc3_ok,
438         (unsigned int)(strlen((char *)cbc_data) + 1 + 7) / 8 * 8) != 0) {
439        unsigned int n;
440
441        printf("des_ede3_cbc_encrypt encrypt error\n");
442        for (n = 0; n < i; ++n)
443            printf(" %02x", cbc_out[n]);
444        printf("\n");
445        for (n = 0; n < i; ++n)
446            printf(" %02x", cbc3_ok[n]);
447        printf("\n");
448        err = 1;
449    }
450
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) {
454        unsigned int n;
455
456        printf("DES_ede3_cbc_encrypt decrypt error\n");
457        for (n = 0; n < i; ++n)
458            printf(" %02x", cbc_data[n]);
459        printf("\n");
460        for (n = 0; n < i; ++n)
461            printf(" %02x", cbc_in[n]);
462        printf("\n");
463        err = 1;
464    }
465# ifndef LIBDES_LIT
466    printf("Doing pcbc\n");
467    if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) {
468        printf("Key error %d\n", j);
469        err = 1;
470    }
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");
477        err = 1;
478    }
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");
483        err = 1;
484    }
485
486    printf("Doing ");
487    printf("cfb8 ");
488    err += cfb_test(8, cfb_cipher8);
489    printf("cfb16 ");
490    err += cfb_test(16, cfb_cipher16);
491    printf("cfb32 ");
492    err += cfb_test(32, cfb_cipher32);
493    printf("cfb48 ");
494    err += cfb_test(48, cfb_cipher48);
495    printf("cfb64 ");
496    err += cfb_test(64, cfb_cipher64);
497
498    printf("cfb64() ");
499    err += cfb64_test(cfb_cipher64);
500
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");
507        err = 1;
508    }
509
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");
516        err = 1;
517    }
518
519    printf("ede_cfb64() ");
520    err += ede_cfb64_test(cfb_cipher64);
521
522    printf("done\n");
523
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],
537               ofb_cipher[8 + 7]);
538        err = 1;
539    }
540    memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
541    DES_ofb_encrypt(ofb_buf1, ofb_buf2, 64, sizeof(ofb_buf1) / 8, &ks,
542                    &ofb_tmp);
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]);
552        err = 1;
553    }
554
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));
560    num = 0;
561    for (i = 0; i < sizeof(plain); i++) {
562        DES_ofb64_encrypt(&(plain[i]), &(ofb_buf1[i]), 1, &ks, &ofb_tmp, &num);
563    }
564    if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) {
565        printf("ofb64_encrypt encrypt error\n");
566        err = 1;
567    }
568    memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
569    num = 0;
570    DES_ofb64_encrypt(ofb_buf1, ofb_buf2, sizeof(ofb_buf1), &ks, &ofb_tmp,
571                      &num);
572    if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) {
573        printf("ofb64_encrypt decrypt error\n");
574        err = 1;
575    }
576
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));
582    num = 0;
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);
586    }
587    if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) {
588        printf("ede_ofb64_encrypt encrypt error\n");
589        err = 1;
590    }
591    memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
592    num = 0;
593    DES_ede3_ofb64_encrypt(ofb_buf1, ofb_buf2, sizeof(ofb_buf1), &ks, &ks, &ks,
594                           &ofb_tmp, &num);
595    if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) {
596        printf("ede_ofb64_encrypt decrypt error\n");
597        err = 1;
598    }
599
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,
603                       &cbc_iv);
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);
607        err = 1;
608    }
609    if (memcmp(cret, cbc_cksum_data, 8) != 0) {
610        printf("bad cbc_cksum block returned\n");
611        err = 1;
612    }
613
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",
620               (unsigned long)cs);
621        err = 1;
622    }
623    if (lqret[0] != 0x327eba8dL) {
624        printf("quad_cksum error, out[0] %08lx is not %08lx\n",
625               (unsigned long)lqret[0], 0x327eba8dUL);
626        err = 1;
627    }
628    if (lqret[1] != 0x201a49ccL) {
629        printf("quad_cksum error, out[1] %08lx is not %08lx\n",
630               (unsigned long)lqret[1], 0x201a49ccUL);
631        err = 1;
632    }
633    if (lqret[2] != 0x70d7a63aL) {
634        printf("quad_cksum error, out[2] %08lx is not %08lx\n",
635               (unsigned long)lqret[2], 0x70d7a63aUL);
636        err = 1;
637    }
638    if (lqret[3] != 0x501c2c26L) {
639        printf("quad_cksum error, out[3] %08lx is not %08lx\n",
640               (unsigned long)lqret[3], 0x501c2c26UL);
641        err = 1;
642    }
643# endif
644
645    printf("input word alignment test");
646    for (i = 0; i < 4; i++) {
647        printf(" %d", i);
648        DES_ncbc_encrypt(&(cbc_out[i]), cbc_in,
649                         strlen((char *)cbc_data) + 1, &ks,
650                         &cbc_iv, DES_ENCRYPT);
651    }
652    printf("\noutput word alignment test");
653    for (i = 0; i < 4; i++) {
654        printf(" %d", i);
655        DES_ncbc_encrypt(cbc_out, &(cbc_in[i]),
656                         strlen((char *)cbc_data) + 1, &ks,
657                         &cbc_iv, DES_ENCRYPT);
658    }
659    printf("\n");
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);
664        err = 1;
665    }
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);
669        err = 1;
670    }
671    str = DES_crypt("testing", "y\202");
672    if (str != NULL) {
673        printf("salt error only usascii are accepted\n");
674        err = 1;
675    }
676    str = DES_crypt("testing", "\0A");
677    if (str != NULL) {
678        printf("salt error cannot contain null terminator\n");
679        err = 1;
680    }
681    str = DES_crypt("testing", "A");
682    if (str != NULL) {
683        printf("salt error must be at least 2\n");
684        err = 1;
685    }
686    printf("\n");
687    return (err);
688}
689
690static char *pt(unsigned char *p)
691{
692    static char bufs[10][20];
693    static int bnum = 0;
694    char *ret;
695    int i;
696    static const char *f = "0123456789ABCDEF";
697
698    ret = &(bufs[bnum++][0]);
699    bnum %= 10;
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];
703    }
704    ret[16] = '\0';
705    return (ret);
706}
707
708# ifndef LIBDES_LIT
709
710static int cfb_test(int bits, unsigned char *cfb_cipher)
711{
712    DES_key_schedule ks;
713    int i, err = 0;
714
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,
718                    DES_ENCRYPT);
719    if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0) {
720        err = 1;
721        printf("cfb_encrypt encrypt error\n");
722        for (i = 0; i < 24; i += 8)
723            printf("%s\n", pt(&(cfb_buf1[i])));
724    }
725    memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
726    DES_cfb_encrypt(cfb_buf1, cfb_buf2, bits, sizeof(plain), &ks, &cfb_tmp,
727                    DES_DECRYPT);
728    if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) {
729        err = 1;
730        printf("cfb_encrypt decrypt error\n");
731        for (i = 0; i < 24; i += 8)
732            printf("%s\n", pt(&(cfb_buf1[i])));
733    }
734    return (err);
735}
736
737static int cfb64_test(unsigned char *cfb_cipher)
738{
739    DES_key_schedule ks;
740    int err = 0, i, n;
741
742    DES_set_key_checked(&cfb_key, &ks);
743    memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
744    n = 0;
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) {
749        err = 1;
750        printf("cfb_encrypt encrypt error\n");
751        for (i = 0; i < 24; i += 8)
752            printf("%s\n", pt(&(cfb_buf1[i])));
753    }
754    memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
755    n = 0;
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) {
760        err = 1;
761        printf("cfb_encrypt decrypt error\n");
762        for (i = 0; i < 24; i += 8)
763            printf("%s\n", pt(&(cfb_buf2[i])));
764    }
765    return (err);
766}
767
768static int ede_cfb64_test(unsigned char *cfb_cipher)
769{
770    DES_key_schedule ks;
771    int err = 0, i, n;
772
773    DES_set_key_checked(&cfb_key, &ks);
774    memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
775    n = 0;
776    DES_ede3_cfb64_encrypt(plain, cfb_buf1, 12, &ks, &ks, &ks, &cfb_tmp, &n,
777                           DES_ENCRYPT);
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) {
782        err = 1;
783        printf("ede_cfb_encrypt encrypt error\n");
784        for (i = 0; i < 24; i += 8)
785            printf("%s\n", pt(&(cfb_buf1[i])));
786    }
787    memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
788    n = 0;
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) {
795        err = 1;
796        printf("ede_cfb_encrypt decrypt error\n");
797        for (i = 0; i < 24; i += 8)
798            printf("%s\n", pt(&(cfb_buf2[i])));
799    }
800    return (err);
801}
802
803# endif
804#endif
805