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