2 * Copyright 1995-2017 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
10 #include <openssl/e_os2.h>
13 #include "test_main.h"
16 #ifndef OPENSSL_NO_DES
17 # include <openssl/des.h>
19 /* In case any platform doesn't use unsigned int for its checksums */
20 # define TEST_cs_eq TEST_uint_eq
22 # define DATA_BUF_SIZE 20
24 /* tisk tisk - the test keys don't all have odd parity :-( */
27 static unsigned char key_data[NUM_TESTS][8] = {
28 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
29 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
30 {0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
31 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
32 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
33 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
34 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
35 {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10},
36 {0x7C, 0xA1, 0x10, 0x45, 0x4A, 0x1A, 0x6E, 0x57},
37 {0x01, 0x31, 0xD9, 0x61, 0x9D, 0xC1, 0x37, 0x6E},
38 {0x07, 0xA1, 0x13, 0x3E, 0x4A, 0x0B, 0x26, 0x86},
39 {0x38, 0x49, 0x67, 0x4C, 0x26, 0x02, 0x31, 0x9E},
40 {0x04, 0xB9, 0x15, 0xBA, 0x43, 0xFE, 0xB5, 0xB6},
41 {0x01, 0x13, 0xB9, 0x70, 0xFD, 0x34, 0xF2, 0xCE},
42 {0x01, 0x70, 0xF1, 0x75, 0x46, 0x8F, 0xB5, 0xE6},
43 {0x43, 0x29, 0x7F, 0xAD, 0x38, 0xE3, 0x73, 0xFE},
44 {0x07, 0xA7, 0x13, 0x70, 0x45, 0xDA, 0x2A, 0x16},
45 {0x04, 0x68, 0x91, 0x04, 0xC2, 0xFD, 0x3B, 0x2F},
46 {0x37, 0xD0, 0x6B, 0xB5, 0x16, 0xCB, 0x75, 0x46},
47 {0x1F, 0x08, 0x26, 0x0D, 0x1A, 0xC2, 0x46, 0x5E},
48 {0x58, 0x40, 0x23, 0x64, 0x1A, 0xBA, 0x61, 0x76},
49 {0x02, 0x58, 0x16, 0x16, 0x46, 0x29, 0xB0, 0x07},
50 {0x49, 0x79, 0x3E, 0xBC, 0x79, 0xB3, 0x25, 0x8F},
51 {0x4F, 0xB0, 0x5E, 0x15, 0x15, 0xAB, 0x73, 0xA7},
52 {0x49, 0xE9, 0x5D, 0x6D, 0x4C, 0xA2, 0x29, 0xBF},
53 {0x01, 0x83, 0x10, 0xDC, 0x40, 0x9B, 0x26, 0xD6},
54 {0x1C, 0x58, 0x7F, 0x1C, 0x13, 0x92, 0x4F, 0xEF},
55 {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
56 {0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E},
57 {0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE},
58 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
59 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
60 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
61 {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}
64 static unsigned char plain_data[NUM_TESTS][8] = {
65 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
66 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
67 {0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
68 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
69 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
70 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
71 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
72 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
73 {0x01, 0xA1, 0xD6, 0xD0, 0x39, 0x77, 0x67, 0x42},
74 {0x5C, 0xD5, 0x4C, 0xA8, 0x3D, 0xEF, 0x57, 0xDA},
75 {0x02, 0x48, 0xD4, 0x38, 0x06, 0xF6, 0x71, 0x72},
76 {0x51, 0x45, 0x4B, 0x58, 0x2D, 0xDF, 0x44, 0x0A},
77 {0x42, 0xFD, 0x44, 0x30, 0x59, 0x57, 0x7F, 0xA2},
78 {0x05, 0x9B, 0x5E, 0x08, 0x51, 0xCF, 0x14, 0x3A},
79 {0x07, 0x56, 0xD8, 0xE0, 0x77, 0x47, 0x61, 0xD2},
80 {0x76, 0x25, 0x14, 0xB8, 0x29, 0xBF, 0x48, 0x6A},
81 {0x3B, 0xDD, 0x11, 0x90, 0x49, 0x37, 0x28, 0x02},
82 {0x26, 0x95, 0x5F, 0x68, 0x35, 0xAF, 0x60, 0x9A},
83 {0x16, 0x4D, 0x5E, 0x40, 0x4F, 0x27, 0x52, 0x32},
84 {0x6B, 0x05, 0x6E, 0x18, 0x75, 0x9F, 0x5C, 0xCA},
85 {0x00, 0x4B, 0xD6, 0xEF, 0x09, 0x17, 0x60, 0x62},
86 {0x48, 0x0D, 0x39, 0x00, 0x6E, 0xE7, 0x62, 0xF2},
87 {0x43, 0x75, 0x40, 0xC8, 0x69, 0x8F, 0x3C, 0xFA},
88 {0x07, 0x2D, 0x43, 0xA0, 0x77, 0x07, 0x52, 0x92},
89 {0x02, 0xFE, 0x55, 0x77, 0x81, 0x17, 0xF1, 0x2A},
90 {0x1D, 0x9D, 0x5C, 0x50, 0x18, 0xF7, 0x28, 0xC2},
91 {0x30, 0x55, 0x32, 0x28, 0x6D, 0x6F, 0x29, 0x5A},
92 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
93 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
94 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
95 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
96 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
97 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
98 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}
101 static unsigned char cipher_data[NUM_TESTS][8] = {
102 {0x8C, 0xA6, 0x4D, 0xE9, 0xC1, 0xB1, 0x23, 0xA7},
103 {0x73, 0x59, 0xB2, 0x16, 0x3E, 0x4E, 0xDC, 0x58},
104 {0x95, 0x8E, 0x6E, 0x62, 0x7A, 0x05, 0x55, 0x7B},
105 {0xF4, 0x03, 0x79, 0xAB, 0x9E, 0x0E, 0xC5, 0x33},
106 {0x17, 0x66, 0x8D, 0xFC, 0x72, 0x92, 0x53, 0x2D},
107 {0x8A, 0x5A, 0xE1, 0xF8, 0x1A, 0xB8, 0xF2, 0xDD},
108 {0x8C, 0xA6, 0x4D, 0xE9, 0xC1, 0xB1, 0x23, 0xA7},
109 {0xED, 0x39, 0xD9, 0x50, 0xFA, 0x74, 0xBC, 0xC4},
110 {0x69, 0x0F, 0x5B, 0x0D, 0x9A, 0x26, 0x93, 0x9B},
111 {0x7A, 0x38, 0x9D, 0x10, 0x35, 0x4B, 0xD2, 0x71},
112 {0x86, 0x8E, 0xBB, 0x51, 0xCA, 0xB4, 0x59, 0x9A},
113 {0x71, 0x78, 0x87, 0x6E, 0x01, 0xF1, 0x9B, 0x2A},
114 {0xAF, 0x37, 0xFB, 0x42, 0x1F, 0x8C, 0x40, 0x95},
115 {0x86, 0xA5, 0x60, 0xF1, 0x0E, 0xC6, 0xD8, 0x5B},
116 {0x0C, 0xD3, 0xDA, 0x02, 0x00, 0x21, 0xDC, 0x09},
117 {0xEA, 0x67, 0x6B, 0x2C, 0xB7, 0xDB, 0x2B, 0x7A},
118 {0xDF, 0xD6, 0x4A, 0x81, 0x5C, 0xAF, 0x1A, 0x0F},
119 {0x5C, 0x51, 0x3C, 0x9C, 0x48, 0x86, 0xC0, 0x88},
120 {0x0A, 0x2A, 0xEE, 0xAE, 0x3F, 0xF4, 0xAB, 0x77},
121 {0xEF, 0x1B, 0xF0, 0x3E, 0x5D, 0xFA, 0x57, 0x5A},
122 {0x88, 0xBF, 0x0D, 0xB6, 0xD7, 0x0D, 0xEE, 0x56},
123 {0xA1, 0xF9, 0x91, 0x55, 0x41, 0x02, 0x0B, 0x56},
124 {0x6F, 0xBF, 0x1C, 0xAF, 0xCF, 0xFD, 0x05, 0x56},
125 {0x2F, 0x22, 0xE4, 0x9B, 0xAB, 0x7C, 0xA1, 0xAC},
126 {0x5A, 0x6B, 0x61, 0x2C, 0xC2, 0x6C, 0xCE, 0x4A},
127 {0x5F, 0x4C, 0x03, 0x8E, 0xD1, 0x2B, 0x2E, 0x41},
128 {0x63, 0xFA, 0xC0, 0xD0, 0x34, 0xD9, 0xF7, 0x93},
129 {0x61, 0x7B, 0x3A, 0x0C, 0xE8, 0xF0, 0x71, 0x00},
130 {0xDB, 0x95, 0x86, 0x05, 0xF8, 0xC8, 0xC6, 0x06},
131 {0xED, 0xBF, 0xD1, 0xC6, 0x6C, 0x29, 0xCC, 0xC7},
132 {0x35, 0x55, 0x50, 0xB2, 0x15, 0x0E, 0x24, 0x51},
133 {0xCA, 0xAA, 0xAF, 0x4D, 0xEA, 0xF1, 0xDB, 0xAE},
134 {0xD5, 0xD4, 0x4F, 0xF7, 0x20, 0x68, 0x3D, 0x0D},
135 {0x2A, 0x2B, 0xB0, 0x08, 0xDF, 0x97, 0xC2, 0xF2}
138 static unsigned char cipher_ecb2[NUM_TESTS - 1][8] = {
139 {0x92, 0x95, 0xB5, 0x9B, 0xB3, 0x84, 0x73, 0x6E},
140 {0x19, 0x9E, 0x9D, 0x6D, 0xF3, 0x9A, 0xA8, 0x16},
141 {0x2A, 0x4B, 0x4D, 0x24, 0x52, 0x43, 0x84, 0x27},
142 {0x35, 0x84, 0x3C, 0x01, 0x9D, 0x18, 0xC5, 0xB6},
143 {0x4A, 0x5B, 0x2F, 0x42, 0xAA, 0x77, 0x19, 0x25},
144 {0xA0, 0x6B, 0xA9, 0xB8, 0xCA, 0x5B, 0x17, 0x8A},
145 {0xAB, 0x9D, 0xB7, 0xFB, 0xED, 0x95, 0xF2, 0x74},
146 {0x3D, 0x25, 0x6C, 0x23, 0xA7, 0x25, 0x2F, 0xD6},
147 {0xB7, 0x6F, 0xAB, 0x4F, 0xBD, 0xBD, 0xB7, 0x67},
148 {0x8F, 0x68, 0x27, 0xD6, 0x9C, 0xF4, 0x1A, 0x10},
149 {0x82, 0x57, 0xA1, 0xD6, 0x50, 0x5E, 0x81, 0x85},
150 {0xA2, 0x0F, 0x0A, 0xCD, 0x80, 0x89, 0x7D, 0xFA},
151 {0xCD, 0x2A, 0x53, 0x3A, 0xDB, 0x0D, 0x7E, 0xF3},
152 {0xD2, 0xC2, 0xBE, 0x27, 0xE8, 0x1B, 0x68, 0xE3},
153 {0xE9, 0x24, 0xCF, 0x4F, 0x89, 0x3C, 0x5B, 0x0A},
154 {0xA7, 0x18, 0xC3, 0x9F, 0xFA, 0x9F, 0xD7, 0x69},
155 {0x77, 0x2C, 0x79, 0xB1, 0xD2, 0x31, 0x7E, 0xB1},
156 {0x49, 0xAB, 0x92, 0x7F, 0xD0, 0x22, 0x00, 0xB7},
157 {0xCE, 0x1C, 0x6C, 0x7D, 0x85, 0xE3, 0x4A, 0x6F},
158 {0xBE, 0x91, 0xD6, 0xE1, 0x27, 0xB2, 0xE9, 0x87},
159 {0x70, 0x28, 0xAE, 0x8F, 0xD1, 0xF5, 0x74, 0x1A},
160 {0xAA, 0x37, 0x80, 0xBB, 0xF3, 0x22, 0x1D, 0xDE},
161 {0xA6, 0xC4, 0xD2, 0x5E, 0x28, 0x93, 0xAC, 0xB3},
162 {0x22, 0x07, 0x81, 0x5A, 0xE4, 0xB7, 0x1A, 0xAD},
163 {0xDC, 0xCE, 0x05, 0xE7, 0x07, 0xBD, 0xF5, 0x84},
164 {0x26, 0x1D, 0x39, 0x2C, 0xB3, 0xBA, 0xA5, 0x85},
165 {0xB4, 0xF7, 0x0F, 0x72, 0xFB, 0x04, 0xF0, 0xDC},
166 {0x95, 0xBA, 0xA9, 0x4E, 0x87, 0x36, 0xF2, 0x89},
167 {0xD4, 0x07, 0x3A, 0xF1, 0x5A, 0x17, 0x82, 0x0E},
168 {0xEF, 0x6F, 0xAF, 0xA7, 0x66, 0x1A, 0x7E, 0x89},
169 {0xC1, 0x97, 0xF5, 0x58, 0x74, 0x8A, 0x20, 0xE7},
170 {0x43, 0x34, 0xCF, 0xDA, 0x22, 0xC4, 0x86, 0xC8},
171 {0x08, 0xD7, 0xB4, 0xFB, 0x62, 0x9D, 0x08, 0x85}
174 static unsigned char cbc_key[8] =
175 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
176 static unsigned char cbc2_key[8] =
177 { 0xf1, 0xe0, 0xd3, 0xc2, 0xb5, 0xa4, 0x97, 0x86 };
178 static unsigned char cbc3_key[8] =
179 { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
180 static unsigned char cbc_iv[8] =
181 { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
183 * Changed the following text constant to binary so it will work on ebcdic
186 /* static char cbc_data[40]="7654321 Now is the time for \0001"; */
187 static unsigned char cbc_data[40] = {
188 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20,
189 0x4E, 0x6F, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74,
190 0x68, 0x65, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x20,
191 0x66, 0x6F, 0x72, 0x20, 0x00, 0x31, 0x00, 0x00,
192 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
195 static unsigned char cbc_ok[32] = {
196 0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4,
197 0xac, 0xd8, 0xae, 0xfd, 0xdf, 0xd8, 0xa1, 0xeb,
198 0x46, 0x8e, 0x91, 0x15, 0x78, 0x88, 0xba, 0x68,
199 0x1d, 0x26, 0x93, 0x97, 0xf7, 0xfe, 0x62, 0xb4
202 # ifdef SCREW_THE_PARITY
203 # error "SCREW_THE_PARITY is not meant to be defined."
204 # error "Original vectors are preserved for reference only."
205 static unsigned char cbc2_key[8] =
206 { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87 };
207 static unsigned char xcbc_ok[32] = {
208 0x86, 0x74, 0x81, 0x0D, 0x61, 0xA4, 0xA5, 0x48,
209 0xB9, 0x93, 0x03, 0xE1, 0xB8, 0xBB, 0xBD, 0xBD,
210 0x64, 0x30, 0x0B, 0xB9, 0x06, 0x65, 0x81, 0x76,
211 0x04, 0x1D, 0x77, 0x62, 0x17, 0xCA, 0x2B, 0xD2,
214 static unsigned char xcbc_ok[32] = {
215 0x84, 0x6B, 0x29, 0x14, 0x85, 0x1E, 0x9A, 0x29,
216 0x54, 0x73, 0x2F, 0x8A, 0xA0, 0xA6, 0x11, 0xC1,
217 0x15, 0xCD, 0xC2, 0xD7, 0x95, 0x1B, 0x10, 0x53,
218 0xA6, 0x3C, 0x5E, 0x03, 0xB2, 0x1A, 0xA3, 0xC4,
222 static unsigned char cbc3_ok[32] = {
223 0x3F, 0xE3, 0x01, 0xC9, 0x62, 0xAC, 0x01, 0xD0,
224 0x22, 0x13, 0x76, 0x3C, 0x1C, 0xBD, 0x4C, 0xDC,
225 0x79, 0x96, 0x57, 0xC0, 0x64, 0xEC, 0xF5, 0xD4,
226 0x1C, 0x67, 0x38, 0x12, 0xCF, 0xDE, 0x96, 0x75
229 static unsigned char pcbc_ok[32] = {
230 0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4,
231 0x6d, 0xec, 0xb4, 0x70, 0xa0, 0xe5, 0x6b, 0x15,
232 0xae, 0xa6, 0xbf, 0x61, 0xed, 0x7d, 0x9c, 0x9f,
233 0xf7, 0x17, 0x46, 0x3b, 0x8a, 0xb3, 0xcc, 0x88
236 static unsigned char cfb_key[8] =
237 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
238 static unsigned char cfb_iv[8] =
239 { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef };
240 static unsigned char cfb_buf1[40], cfb_buf2[40], cfb_tmp[8];
241 static unsigned char plain[24] = {
242 0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73,
243 0x20, 0x74, 0x68, 0x65, 0x20, 0x74,
244 0x69, 0x6d, 0x65, 0x20, 0x66, 0x6f,
245 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20
248 static unsigned char cfb_cipher8[24] = {
249 0xf3, 0x1f, 0xda, 0x07, 0x01, 0x14, 0x62, 0xee, 0x18, 0x7f, 0x43, 0xd8,
250 0x0a, 0x7c, 0xd9, 0xb5, 0xb0, 0xd2, 0x90, 0xda, 0x6e, 0x5b, 0x9a, 0x87
253 static unsigned char cfb_cipher16[24] = {
254 0xF3, 0x09, 0x87, 0x87, 0x7F, 0x57, 0xF7, 0x3C, 0x36, 0xB6, 0xDB, 0x70,
255 0xD8, 0xD5, 0x34, 0x19, 0xD3, 0x86, 0xB2, 0x23, 0xB7, 0xB2, 0xAD, 0x1B
258 static unsigned char cfb_cipher32[24] = {
259 0xF3, 0x09, 0x62, 0x49, 0xA4, 0xDF, 0xA4, 0x9F, 0x33, 0xDC, 0x7B, 0xAD,
260 0x4C, 0xC8, 0x9F, 0x64, 0xE4, 0x53, 0xE5, 0xEC, 0x67, 0x20, 0xDA, 0xB6
263 static unsigned char cfb_cipher48[24] = {
264 0xF3, 0x09, 0x62, 0x49, 0xC7, 0xF4, 0x30, 0xB5, 0x15, 0xEC, 0xBB, 0x85,
265 0x97, 0x5A, 0x13, 0x8C, 0x68, 0x60, 0xE2, 0x38, 0x34, 0x3C, 0xDC, 0x1F
268 static unsigned char cfb_cipher64[24] = {
269 0xF3, 0x09, 0x62, 0x49, 0xC7, 0xF4, 0x6E, 0x51, 0xA6, 0x9E, 0x83, 0x9B,
270 0x1A, 0x92, 0xF7, 0x84, 0x03, 0x46, 0x71, 0x33, 0x89, 0x8E, 0xA6, 0x22
273 static unsigned char ofb_key[8] =
274 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
275 static unsigned char ofb_iv[8] =
276 { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef };
277 static unsigned char ofb_buf1[24], ofb_buf2[24], ofb_tmp[8];
278 static unsigned char ofb_cipher[24] = {
279 0xf3, 0x09, 0x62, 0x49, 0xc7, 0xf4, 0x6e, 0x51,
280 0x35, 0xf2, 0x4a, 0x24, 0x2e, 0xeb, 0x3d, 0x3f,
281 0x3d, 0x6d, 0x5b, 0xe3, 0x25, 0x5a, 0xf8, 0xc3
283 static DES_LONG cbc_cksum_ret = 0xF7FE62B4L;
284 static unsigned char cbc_cksum_data[8] =
285 { 0x1D, 0x26, 0x93, 0x97, 0xf7, 0xfe, 0x62, 0xb4 };
287 static char *pt(const unsigned char *p, char buf[DATA_BUF_SIZE])
291 static char *f = "0123456789ABCDEF";
294 for (i = 0; i < 8; i++) {
295 ret[i * 2] = f[(p[i] >> 4) & 0xf];
296 ret[i * 2 + 1] = f[p[i] & 0xf];
302 static int test_des_ecb(int i)
305 DES_cblock in, out, outin;
306 char b1[DATA_BUF_SIZE], b2[DATA_BUF_SIZE];
308 DES_set_key_unchecked(&key_data[i], &ks);
309 memcpy(in, plain_data[i], 8);
312 DES_ecb_encrypt(&in, &out, &ks, DES_ENCRYPT);
313 DES_ecb_encrypt(&out, &outin, &ks, DES_DECRYPT);
315 if (!TEST_mem_eq(out, 8, cipher_data[i], 8)) {
316 TEST_info("Encryption error %2d k=%s p=%s", i + 1,
317 pt(key_data[i], b1), pt(in, b2));
320 if (!TEST_mem_eq(in, 8, outin, 8)) {
321 TEST_info("Decryption error %2d k=%s p=%s", i + 1,
322 pt(key_data[i], b1), pt(out, b2));
328 static int test_des_ede_ecb(int i)
330 DES_cblock in, out, outin;
331 DES_key_schedule ks, ks2, ks3;
332 char b1[DATA_BUF_SIZE], b2[DATA_BUF_SIZE];
334 DES_set_key_unchecked(&key_data[i], &ks);
335 DES_set_key_unchecked(&key_data[i + 1], &ks2);
336 DES_set_key_unchecked(&key_data[i + 2], &ks3);
337 memcpy(in, plain_data[i], 8);
340 DES_ecb3_encrypt(&in, &out, &ks, &ks2, &ks, DES_ENCRYPT);
341 DES_ecb3_encrypt(&out, &outin, &ks, &ks2, &ks, DES_DECRYPT);
343 if (!TEST_mem_eq(out, 8, cipher_ecb2[i], 8)) {
344 TEST_info("Encryption error %2d k=%s p=%s", i + 1,
345 pt(key_data[i], b1), pt(in, b2));
348 if (!TEST_mem_eq(in, 8, outin, 8)) {
349 TEST_info("Decryption error %2d k=%s p=%s ", i + 1,
350 pt(key_data[i], b1), pt(out, b2));
356 static int test_des_cbc(void)
358 unsigned char cbc_in[40];
359 unsigned char cbc_out[40];
362 const size_t cbc_data_len = strlen((char *)cbc_data);
364 if (!TEST_int_eq(DES_set_key_checked(&cbc_key, &ks), 0))
366 memset(cbc_out, 0, sizeof(cbc_out));
367 memset(cbc_in, 0, sizeof(cbc_in));
368 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
369 DES_ncbc_encrypt(cbc_data, cbc_out, cbc_data_len + 1, &ks,
371 if (!TEST_mem_eq(cbc_out, 32, cbc_ok, 32))
374 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
375 DES_ncbc_encrypt(cbc_out, cbc_in, cbc_data_len + 1, &ks,
377 return TEST_mem_eq(cbc_in, cbc_data_len, cbc_data, cbc_data_len);
380 static int test_des_ede_cbc(void)
384 unsigned char cbc_in[40];
385 unsigned char cbc_out[40];
386 const size_t n = strlen((char *)cbc_data) + 1;
388 if (!TEST_int_eq(DES_set_key_checked(&cbc_key, &ks), 0))
390 memset(cbc_out, 0, sizeof(cbc_out));
391 memset(cbc_in, 0, sizeof(cbc_in));
392 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
393 DES_xcbc_encrypt(cbc_data, cbc_out, n, &ks, &iv3, &cbc2_key, &cbc3_key,
395 if (!TEST_mem_eq(cbc_out, sizeof(xcbc_ok), xcbc_ok, sizeof(xcbc_ok)))
397 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
398 DES_xcbc_encrypt(cbc_out, cbc_in, n, &ks, &iv3, &cbc2_key, &cbc3_key,
400 return TEST_mem_eq(cbc_data, n, cbc_data, n);
403 static int test_ede_cbc(void)
406 DES_key_schedule ks, ks2, ks3;
407 unsigned char cbc_in[40];
408 unsigned char cbc_out[40];
409 const size_t i = strlen((char *)cbc_data) + 1;
410 const size_t n = (i + 7) / 8 * 8;
412 if (!TEST_int_eq(DES_set_key_checked(&cbc_key, &ks), 0))
414 if (!TEST_int_eq(DES_set_key_checked(&cbc2_key, &ks2), 0))
416 if (!TEST_int_eq(DES_set_key_checked(&cbc3_key, &ks3), 0))
418 memset(cbc_out, 0, sizeof(cbc_out));
419 memset(cbc_in, 0, sizeof(cbc_in));
420 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
422 DES_ede3_cbc_encrypt(cbc_data, cbc_out, 16L, &ks, &ks2, &ks3, &iv3,
424 DES_ede3_cbc_encrypt(&cbc_data[16], &cbc_out[16], i - 16, &ks, &ks2,
425 &ks3, &iv3, DES_ENCRYPT);
426 if (!TEST_mem_eq(cbc_out, n, cbc3_ok, n))
429 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
430 DES_ede3_cbc_encrypt(cbc_out, cbc_in, i, &ks, &ks2, &ks3, &iv3,
432 return TEST_mem_eq(cbc_in, i, cbc_data, i);
435 static int test_input_align(int i)
437 unsigned char cbc_out[40];
440 const size_t n = strlen(i + (char *)cbc_data) + 1;
442 memset(cbc_out, 0, sizeof(cbc_out));
443 memcpy(iv, cbc_iv, sizeof(cbc_iv));
444 if (!TEST_int_eq(DES_set_key_checked(&cbc_key, &ks), 0))
446 DES_ncbc_encrypt(&cbc_data[i], cbc_out, n, &ks, &iv, DES_ENCRYPT);
450 static int test_output_align(int i)
452 unsigned char cbc_out[40];
455 const size_t n = strlen((char *)cbc_data) + 1;
457 memset(cbc_out, 0, sizeof(cbc_out));
458 memcpy(iv, cbc_iv, sizeof(cbc_iv));
459 if (!TEST_int_eq(DES_set_key_checked(&cbc_key, &ks), 0))
461 DES_ncbc_encrypt(cbc_data, &cbc_out[i], n, &ks, &iv, DES_ENCRYPT);
465 static int test_des_crypt(void)
467 if (!TEST_str_eq("efGnQx2725bI2", DES_crypt("testing", "ef")))
469 if (!TEST_str_eq("yA1Rp/1hZXIJk", DES_crypt("bca76;23", "yA")))
472 if (!TEST_ptr_null(DES_crypt("testing", "y\202")))
474 if (!TEST_ptr_null(DES_crypt("testing", "\0A")))
476 if (!TEST_ptr_null(DES_crypt("testing", "A")))
481 static int test_des_pcbc(void)
483 unsigned char cbc_in[40];
484 unsigned char cbc_out[40];
486 const int n = strlen((char *)cbc_data) + 1;
488 if (!TEST_int_eq(DES_set_key_checked(&cbc_key, &ks), 0))
490 memset(cbc_out, 0, sizeof(cbc_out));
491 memset(cbc_in, 0, sizeof(cbc_in));
492 DES_pcbc_encrypt(cbc_data, cbc_out, n, &ks,
493 &cbc_iv, DES_ENCRYPT);
494 if (!TEST_mem_eq(cbc_out, sizeof(pcbc_ok), pcbc_ok, sizeof(pcbc_ok)))
496 DES_pcbc_encrypt(cbc_out, cbc_in, n, &ks,
497 &cbc_iv, DES_DECRYPT);
498 return TEST_mem_eq(cbc_in, n, cbc_data, n);
501 static int cfb_test(int bits, unsigned char *cfb_cipher)
505 DES_set_key_checked(&cfb_key, &ks);
506 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
507 DES_cfb_encrypt(plain, cfb_buf1, bits, sizeof(plain), &ks, &cfb_tmp,
509 if (!TEST_mem_eq(cfb_cipher, sizeof(plain), cfb_buf1, sizeof(plain)))
511 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
512 DES_cfb_encrypt(cfb_buf1, cfb_buf2, bits, sizeof(plain), &ks, &cfb_tmp,
514 return TEST_mem_eq(plain, sizeof(plain), cfb_buf2, sizeof(plain));
517 static int test_des_cfb8(void)
519 return cfb_test(8, cfb_cipher8);
522 static int test_des_cfb16(void)
524 return cfb_test(16, cfb_cipher16);
527 static int test_des_cfb32(void)
529 return cfb_test(32, cfb_cipher32);
532 static int test_des_cfb48(void)
534 return cfb_test(48, cfb_cipher48);
537 static int test_des_cfb64(void)
543 if (!cfb_test(64, cfb_cipher64))
546 DES_set_key_checked(&cfb_key, &ks);
547 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
549 DES_cfb64_encrypt(plain, cfb_buf1, 12, &ks, &cfb_tmp, &n, DES_ENCRYPT);
550 DES_cfb64_encrypt(&plain[12], &cfb_buf1[12], sizeof(plain) - 12, &ks,
551 &cfb_tmp, &n, DES_ENCRYPT);
552 if (!TEST_mem_eq(cfb_cipher64, sizeof(plain), cfb_buf1, sizeof(plain)))
554 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
556 DES_cfb64_encrypt(cfb_buf1, cfb_buf2, 17, &ks, &cfb_tmp, &n, DES_DECRYPT);
557 DES_cfb64_encrypt(&cfb_buf1[17], &cfb_buf2[17],
558 sizeof(plain) - 17, &ks, &cfb_tmp, &n, DES_DECRYPT);
559 if (!TEST_mem_eq(plain, sizeof(plain), cfb_buf2, sizeof(plain)))
562 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
563 for (i = 0; i < sizeof(plain); i++)
564 DES_cfb_encrypt(&plain[i], &cfb_buf1[i], 8, 1, &ks, &cfb_tmp,
566 if (!TEST_mem_eq(cfb_cipher8, sizeof(plain), cfb_buf1, sizeof(plain)))
569 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
570 for (i = 0; i < sizeof(plain); i++)
571 DES_cfb_encrypt(&cfb_buf1[i], &cfb_buf2[i], 8, 1, &ks, &cfb_tmp,
573 return TEST_mem_eq(plain, sizeof(plain), cfb_buf2, sizeof(plain));
576 static int test_des_ede_cfb64(void)
581 DES_set_key_checked(&cfb_key, &ks);
582 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
584 DES_ede3_cfb64_encrypt(plain, cfb_buf1, 12, &ks, &ks, &ks, &cfb_tmp, &n,
586 DES_ede3_cfb64_encrypt(&plain[12], &cfb_buf1[12], sizeof(plain) - 12, &ks,
587 &ks, &ks, &cfb_tmp, &n, DES_ENCRYPT);
588 if (!TEST_mem_eq(cfb_cipher64, sizeof(plain), cfb_buf1, sizeof(plain)))
590 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
592 DES_ede3_cfb64_encrypt(cfb_buf1, cfb_buf2, (long)17, &ks, &ks, &ks,
593 &cfb_tmp, &n, DES_DECRYPT);
594 DES_ede3_cfb64_encrypt(&cfb_buf1[17], &cfb_buf2[17], sizeof(plain) - 17,
595 &ks, &ks, &ks, &cfb_tmp, &n, DES_DECRYPT);
596 return TEST_mem_eq(plain, sizeof(plain), cfb_buf2, sizeof(plain));
599 static int test_des_ofb(void)
603 DES_set_key_checked(&ofb_key, &ks);
604 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
605 DES_ofb_encrypt(plain, ofb_buf1, 64, sizeof(plain) / 8, &ks, &ofb_tmp);
606 if (!TEST_mem_eq(ofb_cipher, sizeof(ofb_buf1), ofb_buf1, sizeof(ofb_buf1)))
609 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
610 DES_ofb_encrypt(ofb_buf1, ofb_buf2, 64, sizeof(ofb_buf1) / 8, &ks,
612 return TEST_mem_eq(plain, sizeof(ofb_buf2), ofb_buf2, sizeof(ofb_buf2));
615 static int test_des_ofb64(void)
621 DES_set_key_checked(&ofb_key, &ks);
622 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
623 memset(ofb_buf1, 0, sizeof(ofb_buf1));
624 memset(ofb_buf2, 0, sizeof(ofb_buf1));
626 for (i = 0; i < sizeof(plain); i++) {
627 DES_ofb64_encrypt(&plain[i], &ofb_buf1[i], 1, &ks, &ofb_tmp, &num);
629 if (!TEST_mem_eq(ofb_cipher, sizeof(ofb_buf1), ofb_buf1, sizeof(ofb_buf1)))
631 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
633 DES_ofb64_encrypt(ofb_buf1, ofb_buf2, sizeof(ofb_buf1), &ks, &ofb_tmp,
635 return TEST_mem_eq(plain, sizeof(ofb_buf2), ofb_buf2, sizeof(ofb_buf2));
638 static int test_des_ede_ofb64(void)
644 DES_set_key_checked(&ofb_key, &ks);
645 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
646 memset(ofb_buf1, 0, sizeof(ofb_buf1));
647 memset(ofb_buf2, 0, sizeof(ofb_buf1));
649 for (i = 0; i < sizeof(plain); i++) {
650 DES_ede3_ofb64_encrypt(&plain[i], &ofb_buf1[i], 1, &ks, &ks,
651 &ks, &ofb_tmp, &num);
653 if (!TEST_mem_eq(ofb_cipher, sizeof(ofb_buf1), ofb_buf1, sizeof(ofb_buf1)))
655 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
657 DES_ede3_ofb64_encrypt(ofb_buf1, ofb_buf2, sizeof(ofb_buf1), &ks, &ks, &ks,
659 return TEST_mem_eq(plain, sizeof(ofb_buf2), ofb_buf2, sizeof(ofb_buf2));
662 static int test_des_cbc_cksum(void)
666 unsigned char cret[8];
668 DES_set_key_checked(&cbc_key, &ks);
669 cs = DES_cbc_cksum(cbc_data, &cret, strlen((char *)cbc_data), &ks,
671 if (!TEST_cs_eq(cs, cbc_cksum_ret))
673 return TEST_mem_eq(cret, 8, cbc_cksum_data, 8);
676 static int test_des_quad_cksum(void)
678 DES_LONG cs, lqret[4];
680 cs = DES_quad_cksum(cbc_data, (DES_cblock *)lqret,
681 (long)strlen((char *)cbc_data), 2,
682 (DES_cblock *)cbc_iv);
683 if (!TEST_cs_eq(cs, 0x70d7a63aL))
685 if (!TEST_cs_eq(lqret[0], 0x327eba8dL))
687 if (!TEST_cs_eq(lqret[1], 0x201a49ccL))
689 if (!TEST_cs_eq(lqret[2], 0x70d7a63aL))
691 if (!TEST_cs_eq(lqret[3], 0x501c2c26L))
697 void register_tests(void)
699 #ifndef OPENSSL_NO_DES
700 ADD_ALL_TESTS(test_des_ecb, NUM_TESTS);
701 ADD_TEST(test_des_cbc);
702 ADD_TEST(test_ede_cbc);
703 ADD_ALL_TESTS(test_des_ede_ecb, NUM_TESTS - 2);
704 ADD_TEST(test_des_ede_cbc);
705 ADD_TEST(test_des_pcbc);
706 ADD_TEST(test_des_cfb8);
707 ADD_TEST(test_des_cfb16);
708 ADD_TEST(test_des_cfb32);
709 ADD_TEST(test_des_cfb48);
710 ADD_TEST(test_des_cfb64);
711 ADD_TEST(test_des_ede_cfb64);
712 ADD_TEST(test_des_ofb);
713 ADD_TEST(test_des_ofb64);
714 ADD_TEST(test_des_ede_ofb64);
715 ADD_TEST(test_des_cbc_cksum);
716 ADD_TEST(test_des_quad_cksum);
717 ADD_TEST(test_des_crypt);
718 ADD_ALL_TESTS(test_input_align, 4);
719 ADD_ALL_TESTS(test_output_align, 4);