]> 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
Create provider errors and use them
[thirdparty/openssl.git] / test / destest.c
CommitLineData
440e5d80 1/*
c491a399 2 * Copyright 1995-2017 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
a5bc1e85 10#include <openssl/e_os2.h>
d02b48c6 11#include <string.h>
f5d7a031 12
c491a399
P		 13#include "testutil.h"
14
15#ifndef OPENSSL_NO_DES
0f113f3e 16# include <openssl/des.h>
d02b48c6 17
c491a399
P		 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
d02b48c6
RE		 23/* tisk tisk - the test keys don't all have odd parity :-( */
24/* test data */
0f113f3e
MC		 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 */
58964a49 185/* static char cbc_data[40]="7654321 Now is the time for \0001"; */
0f113f3e
MC		 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
60250017 202# error "SCREW_THE_PARITY is not meant to be defined."
0f113f3e
MC		 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};
0f113f3e 282static DES_LONG cbc_cksum_ret = 0xF7FE62B4L;
0f113f3e
MC		 283static unsigned char cbc_cksum_data[8] =
284 { 0x1D, 0x26, 0x93, 0x97, 0xf7, 0xfe, 0x62, 0xb4 };
d02b48c6 285
c491a399 286static char *pt(const unsigned char *p, char buf[DATA_BUF_SIZE])
0f113f3e 287{
c491a399
P		 288 char *ret;
289 int i;
4b6ae3c3 290 static const char *f = "0123456789ABCDEF";
c491a399
P		 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}
bd91e3c8 300
c491a399
P		 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;
24956ca0 330 DES_key_schedule ks, ks2, ks3;
c491a399
P		 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{
0f113f3e
MC		 357 unsigned char cbc_in[40];
358 unsigned char cbc_out[40];
c491a399
P		 359 DES_cblock iv3;
360 DES_key_schedule ks;
361 const size_t cbc_data_len = strlen((char *)cbc_data);
0f113f3e 362
c491a399
P		 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));
0f113f3e 367 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
c491a399 368 DES_ncbc_encrypt(cbc_data, cbc_out, cbc_data_len + 1, &ks,
0f113f3e 369 &iv3, DES_ENCRYPT);
c491a399
P		 370 if (!TEST_mem_eq(cbc_out, 32, cbc_ok, 32))
371 return 0;
0f113f3e
MC		 372
373 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
c491a399 374 DES_ncbc_encrypt(cbc_out, cbc_in, cbc_data_len + 1, &ks,
0f113f3e 375 &iv3, DES_DECRYPT);
c491a399
P		 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));
0f113f3e 391 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
c491a399
P		 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;
0f113f3e 396 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
c491a399
P		 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}
0f113f3e 401
c491a399
P		 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));
0f113f3e
MC		 419 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
420
24956ca0 421 DES_ede3_cbc_encrypt(cbc_data, cbc_out, 16L, &ks, &ks2, &ks3, &iv3,
0f113f3e 422 DES_ENCRYPT);
c491a399 423 DES_ede3_cbc_encrypt(&cbc_data[16], &cbc_out[16], i - 16, &ks, &ks2,
24956ca0 424 &ks3, &iv3, DES_ENCRYPT);
c491a399
P		 425 if (!TEST_mem_eq(cbc_out, n, cbc3_ok, n))
426 return 0;
0f113f3e
MC		 427
428 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
c491a399
P		 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,
0f113f3e 492 &cbc_iv, DES_ENCRYPT);
c491a399
P		 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,
0f113f3e 496 &cbc_iv, DES_DECRYPT);
c491a399
P		 497 return TEST_mem_eq(cbc_in, n, cbc_data, n);
498}
0f113f3e 499
c491a399
P		 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;
0f113f3e
MC		 560
561 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
562 for (i = 0; i < sizeof(plain); i++)
c491a399
P		 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;
0f113f3e
MC		 567
568 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
569 for (i = 0; i < sizeof(plain); i++)
c491a399
P		 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}
0f113f3e 574
c491a399
P		 575static int test_des_ede_cfb64(void)
576{
577 DES_key_schedule ks;
578 int n;
0f113f3e 579
c491a399
P		 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;
0f113f3e 601
0f113f3e
MC		 602 DES_set_key_checked(&ofb_key, &ks);
603 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
24956ca0 604 DES_ofb_encrypt(plain, ofb_buf1, 64, sizeof(plain) / 8, &ks, &ofb_tmp);
c491a399
P		 605 if (!TEST_mem_eq(ofb_cipher, sizeof(ofb_buf1), ofb_buf1, sizeof(ofb_buf1)))
606 return 0;
607
0f113f3e 608 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
24956ca0 609 DES_ofb_encrypt(ofb_buf1, ofb_buf2, 64, sizeof(ofb_buf1) / 8, &ks,
0f113f3e 610 &ofb_tmp);
c491a399
P		 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;
0f113f3e 619
0f113f3e
MC		 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++) {
c491a399 626 DES_ofb64_encrypt(&plain[i], &ofb_buf1[i], 1, &ks, &ofb_tmp, &num);
0f113f3e 627 }
c491a399
P		 628 if (!TEST_mem_eq(ofb_cipher, sizeof(ofb_buf1), ofb_buf1, sizeof(ofb_buf1)))
629 return 0;
0f113f3e
MC		 630 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
631 num = 0;
24956ca0 632 DES_ofb64_encrypt(ofb_buf1, ofb_buf2, sizeof(ofb_buf1), &ks, &ofb_tmp,
0f113f3e 633 &num);
c491a399
P		 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;
0f113f3e 642
0f113f3e
MC		 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++) {
c491a399 649 DES_ede3_ofb64_encrypt(&plain[i], &ofb_buf1[i], 1, &ks, &ks,
24956ca0 650 &ks, &ofb_tmp, &num);
0f113f3e 651 }
c491a399
P		 652 if (!TEST_mem_eq(ofb_cipher, sizeof(ofb_buf1), ofb_buf1, sizeof(ofb_buf1)))
653 return 0;
0f113f3e
MC		 654 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
655 num = 0;
24956ca0 656 DES_ede3_ofb64_encrypt(ofb_buf1, ofb_buf2, sizeof(ofb_buf1), &ks, &ks, &ks,
0f113f3e 657 &ofb_tmp, &num);
c491a399 658 return TEST_mem_eq(plain, sizeof(ofb_buf2), ofb_buf2, sizeof(ofb_buf2));
0f113f3e
MC		 659}
660
c491a399 661static int test_des_cbc_cksum(void)
0f113f3e 662{
c491a399 663 DES_LONG cs;
24956ca0 664 DES_key_schedule ks;
c491a399 665 unsigned char cret[8];
0f113f3e 666
c491a399
P		 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);
0f113f3e 673}
d02b48c6 674
c491a399 675static int test_des_quad_cksum(void)
0f113f3e 676{
c491a399 677 DES_LONG cs, lqret[4];
0f113f3e 678
c491a399
P		 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;
0f113f3e 693}
c491a399 694#endif
d02b48c6 695
ad887416 696int setup_tests(void)
0f113f3e 697{
c491a399
P		 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);
f5d7a031 719#endif
ad887416 720 return 1;
c491a399 721}
A mirror of the official openssl repository