1 /* $NetBSD: t_des.c,v 1.1 2010/08/25 16:46:36 jmmv Exp $ */
2
3 /*
4 * Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) All rights
5 * reserved.
6 *
7 * This package is an SSL implementation written by Eric Young
8 * (eay@cryptsoft.com). The implementation was written so as to conform with
9 * Netscapes SSL.
10 *
11 * This library is free for commercial and non-commercial use as long as the
12 * following conditions are aheared to. The following conditions apply to
13 * all code found in this distribution, be it the RC4, RSA, lhash, DES, etc.,
14 * code; not just the SSL code. The SSL documentation included with this
15 * distribution is covered by the same copyright terms except that the holder
16 * is Tim Hudson (tjh@cryptsoft.com).
17 *
18 * Copyright remains Eric Young's, and as such any Copyright notices in the code
19 * are not to be removed. If this package is used in a product, Eric Young
20 * should be given attribution as the author of the parts of the library
21 * used. This can be in the form of a textual message at program startup or
22 * in documentation (online or textual) provided with the package.
23 *
24 * Redistribution and use in source and binary forms, with or without
25 * modification, are permitted provided that the following conditions are
26 * met: 1. Redistributions of source code must retain the copyright notice,
27 * this list of conditions and the following disclaimer. 2. Redistributions
28 * in binary form must reproduce the above copyright notice, this list of
29 * conditions and the following disclaimer in the documentation and/or other
30 * materials provided with the distribution. 3. All advertising materials
31 * mentioning features or use of this software must display the following
32 * acknowledgement: "This product includes cryptographic software written by
33 * Eric Young (eay@cryptsoft.com)" The word 'cryptographic' can be left out
34 * if the rouines from the library being used are not cryptographic related
35 * :-). 4. If you include any Windows specific code (or a derivative thereof)
36 * from the apps directory (application code) you must include an
37 * acknowledgement: "This product includes software written by Tim Hudson
38 * (tjh@cryptsoft.com)"
39 *
40 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ANY EXPRESS OR IMPLIED
41 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
42 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
43 * NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
44 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
45 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
46 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
47 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
48 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
49 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
50 * SUCH DAMAGE.
51 *
52 * The licence and distribution terms for any publically available version or
53 * derivative of this code cannot be changed. i.e. this code cannot simply
54 * be copied and put under another distribution licence [including the GNU
55 * Public Licence.]
56 */
57
58 #include <atf-c.h>
59 #include <des.h>
60 #include <stdio.h>
61 #include <stdlib.h>
62 #include <string.h>
63 #include <unistd.h>
64
65 #define crypt(c,s) (des_crypt((c),(s)))
66
67 /* tisk tisk - the test keys don't all have odd parity :-( */
68 /* test data */
69 #define NUM_TESTS 34
70 static unsigned char key_data[NUM_TESTS][8] = {
71 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
72 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
73 {0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
74 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
75 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
76 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
77 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
78 {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10},
79 {0x7C, 0xA1, 0x10, 0x45, 0x4A, 0x1A, 0x6E, 0x57},
80 {0x01, 0x31, 0xD9, 0x61, 0x9D, 0xC1, 0x37, 0x6E},
81 {0x07, 0xA1, 0x13, 0x3E, 0x4A, 0x0B, 0x26, 0x86},
82 {0x38, 0x49, 0x67, 0x4C, 0x26, 0x02, 0x31, 0x9E},
83 {0x04, 0xB9, 0x15, 0xBA, 0x43, 0xFE, 0xB5, 0xB6},
84 {0x01, 0x13, 0xB9, 0x70, 0xFD, 0x34, 0xF2, 0xCE},
85 {0x01, 0x70, 0xF1, 0x75, 0x46, 0x8F, 0xB5, 0xE6},
86 {0x43, 0x29, 0x7F, 0xAD, 0x38, 0xE3, 0x73, 0xFE},
87 {0x07, 0xA7, 0x13, 0x70, 0x45, 0xDA, 0x2A, 0x16},
88 {0x04, 0x68, 0x91, 0x04, 0xC2, 0xFD, 0x3B, 0x2F},
89 {0x37, 0xD0, 0x6B, 0xB5, 0x16, 0xCB, 0x75, 0x46},
90 {0x1F, 0x08, 0x26, 0x0D, 0x1A, 0xC2, 0x46, 0x5E},
91 {0x58, 0x40, 0x23, 0x64, 0x1A, 0xBA, 0x61, 0x76},
92 {0x02, 0x58, 0x16, 0x16, 0x46, 0x29, 0xB0, 0x07},
93 {0x49, 0x79, 0x3E, 0xBC, 0x79, 0xB3, 0x25, 0x8F},
94 {0x4F, 0xB0, 0x5E, 0x15, 0x15, 0xAB, 0x73, 0xA7},
95 {0x49, 0xE9, 0x5D, 0x6D, 0x4C, 0xA2, 0x29, 0xBF},
96 {0x01, 0x83, 0x10, 0xDC, 0x40, 0x9B, 0x26, 0xD6},
97 {0x1C, 0x58, 0x7F, 0x1C, 0x13, 0x92, 0x4F, 0xEF},
98 {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
99 {0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E},
100 {0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE},
101 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
102 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
103 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
104 {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}
105 };
106
107 static unsigned char plain_data[NUM_TESTS][8] = {
108 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
109 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
110 {0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
111 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
112 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11},
113 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
114 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
115 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
116 {0x01, 0xA1, 0xD6, 0xD0, 0x39, 0x77, 0x67, 0x42},
117 {0x5C, 0xD5, 0x4C, 0xA8, 0x3D, 0xEF, 0x57, 0xDA},
118 {0x02, 0x48, 0xD4, 0x38, 0x06, 0xF6, 0x71, 0x72},
119 {0x51, 0x45, 0x4B, 0x58, 0x2D, 0xDF, 0x44, 0x0A},
120 {0x42, 0xFD, 0x44, 0x30, 0x59, 0x57, 0x7F, 0xA2},
121 {0x05, 0x9B, 0x5E, 0x08, 0x51, 0xCF, 0x14, 0x3A},
122 {0x07, 0x56, 0xD8, 0xE0, 0x77, 0x47, 0x61, 0xD2},
123 {0x76, 0x25, 0x14, 0xB8, 0x29, 0xBF, 0x48, 0x6A},
124 {0x3B, 0xDD, 0x11, 0x90, 0x49, 0x37, 0x28, 0x02},
125 {0x26, 0x95, 0x5F, 0x68, 0x35, 0xAF, 0x60, 0x9A},
126 {0x16, 0x4D, 0x5E, 0x40, 0x4F, 0x27, 0x52, 0x32},
127 {0x6B, 0x05, 0x6E, 0x18, 0x75, 0x9F, 0x5C, 0xCA},
128 {0x00, 0x4B, 0xD6, 0xEF, 0x09, 0x17, 0x60, 0x62},
129 {0x48, 0x0D, 0x39, 0x00, 0x6E, 0xE7, 0x62, 0xF2},
130 {0x43, 0x75, 0x40, 0xC8, 0x69, 0x8F, 0x3C, 0xFA},
131 {0x07, 0x2D, 0x43, 0xA0, 0x77, 0x07, 0x52, 0x92},
132 {0x02, 0xFE, 0x55, 0x77, 0x81, 0x17, 0xF1, 0x2A},
133 {0x1D, 0x9D, 0x5C, 0x50, 0x18, 0xF7, 0x28, 0xC2},
134 {0x30, 0x55, 0x32, 0x28, 0x6D, 0x6F, 0x29, 0x5A},
135 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
136 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
137 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF},
138 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
139 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
140 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
141 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}
142 };
143
144 static unsigned char cipher_data[NUM_TESTS][8] = {
145 {0x8C, 0xA6, 0x4D, 0xE9, 0xC1, 0xB1, 0x23, 0xA7},
146 {0x73, 0x59, 0xB2, 0x16, 0x3E, 0x4E, 0xDC, 0x58},
147 {0x95, 0x8E, 0x6E, 0x62, 0x7A, 0x05, 0x55, 0x7B},
148 {0xF4, 0x03, 0x79, 0xAB, 0x9E, 0x0E, 0xC5, 0x33},
149 {0x17, 0x66, 0x8D, 0xFC, 0x72, 0x92, 0x53, 0x2D},
150 {0x8A, 0x5A, 0xE1, 0xF8, 0x1A, 0xB8, 0xF2, 0xDD},
151 {0x8C, 0xA6, 0x4D, 0xE9, 0xC1, 0xB1, 0x23, 0xA7},
152 {0xED, 0x39, 0xD9, 0x50, 0xFA, 0x74, 0xBC, 0xC4},
153 {0x69, 0x0F, 0x5B, 0x0D, 0x9A, 0x26, 0x93, 0x9B},
154 {0x7A, 0x38, 0x9D, 0x10, 0x35, 0x4B, 0xD2, 0x71},
155 {0x86, 0x8E, 0xBB, 0x51, 0xCA, 0xB4, 0x59, 0x9A},
156 {0x71, 0x78, 0x87, 0x6E, 0x01, 0xF1, 0x9B, 0x2A},
157 {0xAF, 0x37, 0xFB, 0x42, 0x1F, 0x8C, 0x40, 0x95},
158 {0x86, 0xA5, 0x60, 0xF1, 0x0E, 0xC6, 0xD8, 0x5B},
159 {0x0C, 0xD3, 0xDA, 0x02, 0x00, 0x21, 0xDC, 0x09},
160 {0xEA, 0x67, 0x6B, 0x2C, 0xB7, 0xDB, 0x2B, 0x7A},
161 {0xDF, 0xD6, 0x4A, 0x81, 0x5C, 0xAF, 0x1A, 0x0F},
162 {0x5C, 0x51, 0x3C, 0x9C, 0x48, 0x86, 0xC0, 0x88},
163 {0x0A, 0x2A, 0xEE, 0xAE, 0x3F, 0xF4, 0xAB, 0x77},
164 {0xEF, 0x1B, 0xF0, 0x3E, 0x5D, 0xFA, 0x57, 0x5A},
165 {0x88, 0xBF, 0x0D, 0xB6, 0xD7, 0x0D, 0xEE, 0x56},
166 {0xA1, 0xF9, 0x91, 0x55, 0x41, 0x02, 0x0B, 0x56},
167 {0x6F, 0xBF, 0x1C, 0xAF, 0xCF, 0xFD, 0x05, 0x56},
168 {0x2F, 0x22, 0xE4, 0x9B, 0xAB, 0x7C, 0xA1, 0xAC},
169 {0x5A, 0x6B, 0x61, 0x2C, 0xC2, 0x6C, 0xCE, 0x4A},
170 {0x5F, 0x4C, 0x03, 0x8E, 0xD1, 0x2B, 0x2E, 0x41},
171 {0x63, 0xFA, 0xC0, 0xD0, 0x34, 0xD9, 0xF7, 0x93},
172 {0x61, 0x7B, 0x3A, 0x0C, 0xE8, 0xF0, 0x71, 0x00},
173 {0xDB, 0x95, 0x86, 0x05, 0xF8, 0xC8, 0xC6, 0x06},
174 {0xED, 0xBF, 0xD1, 0xC6, 0x6C, 0x29, 0xCC, 0xC7},
175 {0x35, 0x55, 0x50, 0xB2, 0x15, 0x0E, 0x24, 0x51},
176 {0xCA, 0xAA, 0xAF, 0x4D, 0xEA, 0xF1, 0xDB, 0xAE},
177 {0xD5, 0xD4, 0x4F, 0xF7, 0x20, 0x68, 0x3D, 0x0D},
178 {0x2A, 0x2B, 0xB0, 0x08, 0xDF, 0x97, 0xC2, 0xF2}
179 };
180
181 static unsigned char cipher_ecb2[NUM_TESTS - 1][8] = {
182 {0x92, 0x95, 0xB5, 0x9B, 0xB3, 0x84, 0x73, 0x6E},
183 {0x19, 0x9E, 0x9D, 0x6D, 0xF3, 0x9A, 0xA8, 0x16},
184 {0x2A, 0x4B, 0x4D, 0x24, 0x52, 0x43, 0x84, 0x27},
185 {0x35, 0x84, 0x3C, 0x01, 0x9D, 0x18, 0xC5, 0xB6},
186 {0x4A, 0x5B, 0x2F, 0x42, 0xAA, 0x77, 0x19, 0x25},
187 {0xA0, 0x6B, 0xA9, 0xB8, 0xCA, 0x5B, 0x17, 0x8A},
188 {0xAB, 0x9D, 0xB7, 0xFB, 0xED, 0x95, 0xF2, 0x74},
189 {0x3D, 0x25, 0x6C, 0x23, 0xA7, 0x25, 0x2F, 0xD6},
190 {0xB7, 0x6F, 0xAB, 0x4F, 0xBD, 0xBD, 0xB7, 0x67},
191 {0x8F, 0x68, 0x27, 0xD6, 0x9C, 0xF4, 0x1A, 0x10},
192 {0x82, 0x57, 0xA1, 0xD6, 0x50, 0x5E, 0x81, 0x85},
193 {0xA2, 0x0F, 0x0A, 0xCD, 0x80, 0x89, 0x7D, 0xFA},
194 {0xCD, 0x2A, 0x53, 0x3A, 0xDB, 0x0D, 0x7E, 0xF3},
195 {0xD2, 0xC2, 0xBE, 0x27, 0xE8, 0x1B, 0x68, 0xE3},
196 {0xE9, 0x24, 0xCF, 0x4F, 0x89, 0x3C, 0x5B, 0x0A},
197 {0xA7, 0x18, 0xC3, 0x9F, 0xFA, 0x9F, 0xD7, 0x69},
198 {0x77, 0x2C, 0x79, 0xB1, 0xD2, 0x31, 0x7E, 0xB1},
199 {0x49, 0xAB, 0x92, 0x7F, 0xD0, 0x22, 0x00, 0xB7},
200 {0xCE, 0x1C, 0x6C, 0x7D, 0x85, 0xE3, 0x4A, 0x6F},
201 {0xBE, 0x91, 0xD6, 0xE1, 0x27, 0xB2, 0xE9, 0x87},
202 {0x70, 0x28, 0xAE, 0x8F, 0xD1, 0xF5, 0x74, 0x1A},
203 {0xAA, 0x37, 0x80, 0xBB, 0xF3, 0x22, 0x1D, 0xDE},
204 {0xA6, 0xC4, 0xD2, 0x5E, 0x28, 0x93, 0xAC, 0xB3},
205 {0x22, 0x07, 0x81, 0x5A, 0xE4, 0xB7, 0x1A, 0xAD},
206 {0xDC, 0xCE, 0x05, 0xE7, 0x07, 0xBD, 0xF5, 0x84},
207 {0x26, 0x1D, 0x39, 0x2C, 0xB3, 0xBA, 0xA5, 0x85},
208 {0xB4, 0xF7, 0x0F, 0x72, 0xFB, 0x04, 0xF0, 0xDC},
209 {0x95, 0xBA, 0xA9, 0x4E, 0x87, 0x36, 0xF2, 0x89},
210 {0xD4, 0x07, 0x3A, 0xF1, 0x5A, 0x17, 0x82, 0x0E},
211 {0xEF, 0x6F, 0xAF, 0xA7, 0x66, 0x1A, 0x7E, 0x89},
212 {0xC1, 0x97, 0xF5, 0x58, 0x74, 0x8A, 0x20, 0xE7},
213 {0x43, 0x34, 0xCF, 0xDA, 0x22, 0xC4, 0x86, 0xC8},
214 {0x08, 0xD7, 0xB4, 0xFB, 0x62, 0x9D, 0x08, 0x85}
215 };
216
217 static unsigned char cbc_key[8] = {
218 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
219 };
220 static unsigned char cbc2_key[8] = {
221 0xf1, 0xe0, 0xd3, 0xc2, 0xb5, 0xa4, 0x97, 0x86,
222 };
223 static unsigned char cbc3_key[8] = {
224 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,
225 };
226 static unsigned char cbc_iv[8] = {
227 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,
228 };
229 /*
230 * Changed the following text constant to binary so it will work on ebcdic
231 * machines :-)
232 */
233 /* static char cbc_data[40]="7654321 Now is the time for \0001"; */
234 static unsigned char cbc_data[40] = {
235 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20,
236 0x4E, 0x6F, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74,
237 0x68, 0x65, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x20,
238 0x66, 0x6F, 0x72, 0x20, 0x00, 0x31, 0x00, 0x00,
239 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
240 };
241
242 static unsigned char cbc_ok[32] = {
243 0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4,
244 0xac, 0xd8, 0xae, 0xfd, 0xdf, 0xd8, 0xa1, 0xeb,
245 0x46, 0x8e, 0x91, 0x15, 0x78, 0x88, 0xba, 0x68,
246 0x1d, 0x26, 0x93, 0x97, 0xf7, 0xfe, 0x62, 0xb4,
247 };
248
249 #ifdef SCREW_THE_PARITY
250 #error "SCREW_THE_PARITY is not ment to be defined."
251 #error "Original vectors are preserved for reference only."
252 static unsigned char cbc2_key[8] = {
253 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87,
254 };
255 static unsigned char xcbc_ok[32] = {
256 0x86, 0x74, 0x81, 0x0D, 0x61, 0xA4, 0xA5, 0x48,
257 0xB9, 0x93, 0x03, 0xE1, 0xB8, 0xBB, 0xBD, 0xBD,
258 0x64, 0x30, 0x0B, 0xB9, 0x06, 0x65, 0x81, 0x76,
259 0x04, 0x1D, 0x77, 0x62, 0x17, 0xCA, 0x2B, 0xD2,
260 };
261 #else
262 static unsigned char xcbc_ok[32] = {
263 0x84, 0x6B, 0x29, 0x14, 0x85, 0x1E, 0x9A, 0x29,
264 0x54, 0x73, 0x2F, 0x8A, 0xA0, 0xA6, 0x11, 0xC1,
265 0x15, 0xCD, 0xC2, 0xD7, 0x95, 0x1B, 0x10, 0x53,
266 0xA6, 0x3C, 0x5E, 0x03, 0xB2, 0x1A, 0xA3, 0xC4,
267 };
268 #endif
269
270 static unsigned char cbc3_ok[32] = {
271 0x3F, 0xE3, 0x01, 0xC9, 0x62, 0xAC, 0x01, 0xD0,
272 0x22, 0x13, 0x76, 0x3C, 0x1C, 0xBD, 0x4C, 0xDC,
273 0x79, 0x96, 0x57, 0xC0, 0x64, 0xEC, 0xF5, 0xD4,
274 0x1C, 0x67, 0x38, 0x12, 0xCF, 0xDE, 0x96, 0x75
275 };
276
277 static unsigned char pcbc_ok[32] = {
278 0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4,
279 0x6d, 0xec, 0xb4, 0x70, 0xa0, 0xe5, 0x6b, 0x15,
280 0xae, 0xa6, 0xbf, 0x61, 0xed, 0x7d, 0x9c, 0x9f,
281 0xf7, 0x17, 0x46, 0x3b, 0x8a, 0xb3, 0xcc, 0x88
282 };
283
284 static unsigned char cfb_key[8] = {
285 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
286 };
287 static unsigned char cfb_iv[8] = {
288 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef,
289 };
290 static unsigned char cfb_buf1[40], cfb_buf2[40], cfb_tmp[8];
291 static unsigned char plain[24] =
292 {
293 0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73,
294 0x20, 0x74, 0x68, 0x65, 0x20, 0x74,
295 0x69, 0x6d, 0x65, 0x20, 0x66, 0x6f,
296 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20,
297 };
298 static unsigned char cfb_cipher8[24] = {
299 0xf3, 0x1f, 0xda, 0x07, 0x01, 0x14,
300 0x62, 0xee, 0x18, 0x7f, 0x43, 0xd8,
301 0x0a, 0x7c, 0xd9, 0xb5, 0xb0, 0xd2,
302 0x90, 0xda, 0x6e, 0x5b, 0x9a, 0x87,
303 };
304 static unsigned char cfb_cipher16[24] = {
305 0xF3, 0x09, 0x87, 0x87, 0x7F, 0x57,
306 0xF7, 0x3C, 0x36, 0xB6, 0xDB, 0x70,
307 0xD8, 0xD5, 0x34, 0x19, 0xD3, 0x86,
308 0xB2, 0x23, 0xB7, 0xB2, 0xAD, 0x1B,
309 };
310 static unsigned char cfb_cipher32[24] = {
311 0xF3, 0x09, 0x62, 0x49, 0xA4, 0xDF,
312 0xA4, 0x9F, 0x33, 0xDC, 0x7B, 0xAD,
313 0x4C, 0xC8, 0x9F, 0x64, 0xE4, 0x53,
314 0xE5, 0xEC, 0x67, 0x20, 0xDA, 0xB6,
315 };
316 static unsigned char cfb_cipher48[24] = {
317 0xF3, 0x09, 0x62, 0x49, 0xC7, 0xF4,
318 0x30, 0xB5, 0x15, 0xEC, 0xBB, 0x85,
319 0x97, 0x5A, 0x13, 0x8C, 0x68, 0x60,
320 0xE2, 0x38, 0x34, 0x3C, 0xDC, 0x1F,
321 };
322 static unsigned char cfb_cipher64[24] = {
323 0xF3, 0x09, 0x62, 0x49, 0xC7, 0xF4,
324 0x6E, 0x51, 0xA6, 0x9E, 0x83, 0x9B,
325 0x1A, 0x92, 0xF7, 0x84, 0x03, 0x46,
326 0x71, 0x33, 0x89, 0x8E, 0xA6, 0x22,
327 };
328
329 static unsigned char ofb_key[8] = {
330 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
331 };
332 static unsigned char ofb_iv[8] = {
333 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef,
334 };
335 static unsigned char ofb_buf1[24], ofb_buf2[24], ofb_tmp[8];
336 static unsigned char ofb_cipher[24] =
337 {
338 0xf3, 0x09, 0x62, 0x49, 0xc7, 0xf4, 0x6e, 0x51,
339 0x35, 0xf2, 0x4a, 0x24, 0x2e, 0xeb, 0x3d, 0x3f,
340 0x3d, 0x6d, 0x5b, 0xe3, 0x25, 0x5a, 0xf8, 0xc3
341 };
342
343 static DES_LONG cbc_cksum_ret = 0xB462FEF7L;
344 static unsigned char cbc_cksum_data[8] = {
345 0x1D, 0x26, 0x93, 0x97, 0xf7, 0xfe, 0x62, 0xb4,
346 };
347
348 static char *
pt(unsigned char * p)349 pt(unsigned char *p)
350 {
351 static char bufs[10][20];
352 static int bnum = 0;
353 char *ret;
354 int i;
355 static const char *f = "0123456789ABCDEF";
356
357 ret = &(bufs[bnum++][0]);
358 bnum %= 10;
359 for (i = 0; i < 8; i++) {
360 ret[i * 2] = f[(p[i] >> 4) & 0xf];
361 ret[i * 2 + 1] = f[p[i] & 0xf];
362 }
363 ret[16] = '\0';
364 return (ret);
365 }
366
367 static void
fail_cfb_buf(const char * msg,unsigned char * ptr)368 fail_cfb_buf(const char *msg, unsigned char *ptr)
369 {
370 char buf[1024];
371 int i;
372
373 *buf = '\0';
374 for (i = 0; i < 24; i += 8) {
375 char buf2[128];
376 snprintf(buf2, sizeof(buf2), "%s /", pt(&(cfb_buf1[i])));
377 strlcat(buf, buf2, sizeof(buf));
378 }
379
380 atf_tc_fail_nonfatal("%s: %s", msg, buf);
381 }
382
383 #if !defined(LIBDES_LIT)
384 static void
cfb_test(int bits,unsigned char * cfb_cipher)385 cfb_test(int bits, unsigned char *cfb_cipher)
386 {
387 des_key_schedule ks;
388
389 des_set_key_checked(&cfb_key, ks);
390 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
391 des_cfb_encrypt(plain, cfb_buf1, bits, sizeof(plain), ks, &cfb_tmp,
392 DES_ENCRYPT);
393 if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0)
394 fail_cfb_buf("cfb_encrypt encrypt error", cfb_buf1);
395 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
396 des_cfb_encrypt(cfb_buf1, cfb_buf2, bits, sizeof(plain), ks, &cfb_tmp,
397 DES_DECRYPT);
398 if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0)
399 fail_cfb_buf("cfb_encrypt decrypt error", cfb_buf2);
400 }
401 #endif /* !defined(LIBDES_LIT) */
402
403 #if !defined(LIBDES_LIT)
404 static void
cfb64_test(unsigned char * cfb_cipher)405 cfb64_test(unsigned char *cfb_cipher)
406 {
407 int n;
408 des_key_schedule ks;
409
410 des_set_key_checked(&cfb_key, ks);
411 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
412 n = 0;
413 des_cfb64_encrypt(plain, cfb_buf1, 12, ks, &cfb_tmp, &n, DES_ENCRYPT);
414 des_cfb64_encrypt(&(plain[12]), &(cfb_buf1[12]), sizeof(plain) - 12, ks,
415 &cfb_tmp, &n, DES_ENCRYPT);
416 if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0)
417 fail_cfb_buf("cfb_encrypt encrypt error", cfb_buf1);
418 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
419 n = 0;
420 des_cfb64_encrypt(cfb_buf1, cfb_buf2, 17, ks, &cfb_tmp, &n, DES_DECRYPT);
421 des_cfb64_encrypt(&(cfb_buf1[17]), &(cfb_buf2[17]),
422 sizeof(plain) - 17, ks, &cfb_tmp, &n, DES_DECRYPT);
423 if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0)
424 fail_cfb_buf("cfb_encrypt decrypt error", cfb_buf2);
425 }
426 #endif /* !defined(LIBDES_LIT) */
427
428 #if !defined(LIBDES_LIT)
429 static void
ede_cfb64_test(unsigned char * cfb_cipher)430 ede_cfb64_test(unsigned char *cfb_cipher)
431 {
432 int n;
433 des_key_schedule ks;
434
435 des_set_key_checked(&cfb_key, ks);
436 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
437 n = 0;
438 des_ede3_cfb64_encrypt(plain, cfb_buf1, 12, ks, ks, ks, &cfb_tmp, &n,
439 DES_ENCRYPT);
440 des_ede3_cfb64_encrypt(&(plain[12]), &(cfb_buf1[12]),
441 sizeof(plain) - 12, ks, ks, ks,
442 &cfb_tmp, &n, DES_ENCRYPT);
443 if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0)
444 fail_cfb_buf("ede_cfb_encrypt encrypt error", cfb_buf1);
445 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
446 n = 0;
447 des_ede3_cfb64_encrypt(cfb_buf1, cfb_buf2, (long) 17, ks, ks, ks,
448 &cfb_tmp, &n, DES_DECRYPT);
449 des_ede3_cfb64_encrypt(&(cfb_buf1[17]), &(cfb_buf2[17]),
450 sizeof(plain) - 17, ks, ks, ks,
451 &cfb_tmp, &n, DES_DECRYPT);
452 if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0)
453 fail_cfb_buf("ede_cfb_encrypt decrypt error", cfb_buf2);
454 }
455 #endif /* !defined(LIBDES_LIT) */
456
457 ATF_TC_WITHOUT_HEAD(cbcm);
458 #if defined(NO_DESCBCM)
ATF_TC_BODY(cbcm,tc)459 ATF_TC_BODY(cbcm, tc)
460 {
461 atf_tc_skip("Test program built with NO_DESCBCM");
462 }
463 #else /* defined(NO_DESCBM) */
ATF_TC_BODY(cbcm,tc)464 ATF_TC_BODY(cbcm, tc)
465 {
466 int i, j;
467 des_cblock iv3, iv2;
468 unsigned char cbc_in[40], cbc_out[40];
469 des_key_schedule ks, ks2, ks3;
470
471 if ((j = des_set_key_checked(&cbc_key, ks)) != 0) {
472 atf_tc_fail_nonfatal("Key error %d\n", j);
473 }
474 if ((j = des_set_key_checked(&cbc2_key, ks2)) != 0) {
475 atf_tc_fail_nonfatal("Key error %d\n", j);
476 }
477 if ((j = des_set_key_checked(&cbc3_key, ks3)) != 0) {
478 atf_tc_fail_nonfatal("Key error %d\n", j);
479 }
480 memset(cbc_out, 0, 40);
481 memset(cbc_in, 0, 40);
482 i = strlen((char *) cbc_data) + 1;
483 /* i=((i+7)/8)*8; */
484 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
485 memset(iv2, '\0', sizeof iv2);
486
487 des_ede3_cbcm_encrypt(cbc_data, cbc_out, 16L, ks, ks2, ks3, &iv3, &iv2,
488 DES_ENCRYPT);
489 des_ede3_cbcm_encrypt(&cbc_data[16], &cbc_out[16], i - 16, ks, ks2, ks3,
490 &iv3, &iv2, DES_ENCRYPT);
491 /*
492 * if (memcmp(cbc_out,cbc3_ok, (unsigned int)(strlen((char
493 * *)cbc_data)+1+7)/8*8) != 0) { printf("des_ede3_cbc_encrypt encrypt
494 * error\n"); err=1; }
495 */
496 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
497 memset(iv2, '\0', sizeof iv2);
498 des_ede3_cbcm_encrypt(cbc_out, cbc_in, i, ks, ks2, ks3, &iv3, &iv2,
499 DES_DECRYPT);
500 if (memcmp(cbc_in, cbc_data, strlen((char *) cbc_data) + 1) != 0) {
501 char buf[1024];
502 int n;
503
504 *buf = '\0';
505 for (n = 0; n < i; ++n) {
506 char buf2[16];
507 snprintf(buf2, sizeof(buf2), " %02x", cbc_data[n]);
508 strlcat(buf, buf2, sizeof(buf));
509 }
510 strlcat(buf, ", ", sizeof(buf));
511 for (n = 0; n < i; ++n) {
512 char buf2[16];
513 snprintf(buf2, sizeof(buf2), " %02x", cbc_in[n]);
514 strlcat(buf, buf2, sizeof(buf));
515 }
516
517 atf_tc_fail_nonfatal("des_ede3_cbcm_encrypt decrypt error: %s",
518 buf);
519 }
520 }
521 #endif /* defined(NO_DESCBM) */
522
523 ATF_TC_WITHOUT_HEAD(ecb);
ATF_TC_BODY(ecb,tc)524 ATF_TC_BODY(ecb, tc)
525 {
526 int i;
527 des_cblock in, out, outin;
528 des_key_schedule ks;
529
530 for (i = 0; i < NUM_TESTS; i++) {
531 des_set_key_unchecked(&key_data[i], ks);
532 memcpy(in, plain_data[i], 8);
533 memset(out, 0, 8);
534 memset(outin, 0, 8);
535 des_ecb_encrypt(&in, &out, ks, DES_ENCRYPT);
536 des_ecb_encrypt(&out, &outin, ks, DES_DECRYPT);
537
538 if (memcmp(out, cipher_data[i], 8) != 0) {
539 atf_tc_fail_nonfatal("Encryption error %2d\nk=%s p=%s "
540 "o=%s act=%s\n", i + 1,
541 pt(key_data[i]), pt(in),
542 pt(cipher_data[i]), pt(out));
543 }
544 if (memcmp(in, outin, 8) != 0) {
545 atf_tc_fail_nonfatal("Decryption error %2d\nk=%s p=%s "
546 "o=%s act=%s\n", i + 1,
547 pt(key_data[i]), pt(out), pt(in),
548 pt(outin));
549 }
550 }
551 }
552
553 ATF_TC_WITHOUT_HEAD(ede_ecb);
554 #if defined(LIBDES_LIT)
ATF_TC_BODY(ede_ecb,tc)555 ATF_TC_BODY(ede_ecb, tc)
556 {
557 atf_tc_skip("Test program built with LIBDES_LIT");
558 }
559 #else /* defined(LIBDES_LIT) */
ATF_TC_BODY(ede_ecb,tc)560 ATF_TC_BODY(ede_ecb, tc)
561 {
562 int i;
563 des_cblock in, out, outin;
564 des_key_schedule ks, ks2, ks3;
565
566 for (i = 0; i < (NUM_TESTS - 1); i++) {
567 des_set_key_unchecked(&key_data[i], ks);
568 des_set_key_unchecked(&key_data[i + 1], ks2);
569 des_set_key_unchecked(&key_data[i + 2], ks3);
570 memcpy(in, plain_data[i], 8);
571 memset(out, 0, 8);
572 memset(outin, 0, 8);
573 des_ecb2_encrypt(&in, &out, ks, ks2, DES_ENCRYPT);
574 des_ecb2_encrypt(&out, &outin, ks, ks2, DES_DECRYPT);
575
576 if (memcmp(out, cipher_ecb2[i], 8) != 0) {
577 atf_tc_fail_nonfatal("Encryption error %2d\nk=%s p=%s o=%s act=%s\n",
578 i + 1, pt(key_data[i]), pt(in), pt(cipher_ecb2[i]),
579 pt(out));
580 }
581 if (memcmp(in, outin, 8) != 0) {
582 atf_tc_fail_nonfatal("Decryption error %2d\nk=%s p=%s o=%s act=%s\n",
583 i + 1, pt(key_data[i]), pt(out), pt(in), pt(outin));
584 }
585 }
586 }
587 #endif /* defined(LIBDES_LIT) */
588
589 ATF_TC_WITHOUT_HEAD(cbc);
ATF_TC_BODY(cbc,tc)590 ATF_TC_BODY(cbc, tc)
591 {
592 int j;
593 des_cblock iv3;
594 des_key_schedule ks;
595 unsigned char cbc_in[40], cbc_out[40];
596
597 if ((j = des_set_key_checked(&cbc_key, ks)) != 0)
598 atf_tc_fail_nonfatal("Key error %d\n", j);
599 memset(cbc_out, 0, 40);
600 memset(cbc_in, 0, 40);
601 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
602 des_ncbc_encrypt(cbc_data, cbc_out, strlen((char *) cbc_data) + 1, ks,
603 &iv3, DES_ENCRYPT);
604 if (memcmp(cbc_out, cbc_ok, 32) != 0)
605 atf_tc_fail_nonfatal("cbc_encrypt encrypt error\n");
606 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
607 des_ncbc_encrypt(cbc_out, cbc_in, strlen((char *) cbc_data) + 1, ks,
608 &iv3, DES_DECRYPT);
609 if (memcmp(cbc_in, cbc_data, strlen((char *) cbc_data)) != 0)
610 atf_tc_fail_nonfatal("cbc_encrypt decrypt error\n");
611 }
612
613 ATF_TC_WITHOUT_HEAD(desx_cbc);
614 #if defined(LIBDES_LIT)
ATF_TC_BODY(desx_cbc,tc)615 ATF_TC_BODY(desx_cbc, tc)
616 {
617 atf_tc_skip("Test program built with LIBDES_LIT");
618 }
619 #else /* defined(LIBDES_LIT) */
ATF_TC_BODY(desx_cbc,tc)620 ATF_TC_BODY(desx_cbc, tc)
621 {
622 int j;
623 des_cblock iv3;
624 des_key_schedule ks;
625 unsigned char cbc_in[40], cbc_out[40];
626
627 if ((j = des_set_key_checked(&cbc_key, ks)) != 0) {
628 atf_tc_fail_nonfatal("Key error %d\n", j);
629 }
630 memset(cbc_out, 0, 40);
631 memset(cbc_in, 0, 40);
632 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
633 des_xcbc_encrypt(cbc_data, cbc_out, strlen((char *) cbc_data) + 1, ks,
634 &iv3, &cbc2_key, &cbc3_key, DES_ENCRYPT);
635 if (memcmp(cbc_out, xcbc_ok, 32) != 0) {
636 atf_tc_fail_nonfatal("des_xcbc_encrypt encrypt error\n");
637 }
638 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
639 des_xcbc_encrypt(cbc_out, cbc_in, strlen((char *) cbc_data) + 1, ks,
640 &iv3, &cbc2_key, &cbc3_key, DES_DECRYPT);
641 if (memcmp(cbc_in, cbc_data, strlen((char *) cbc_data) + 1) != 0) {
642 atf_tc_fail_nonfatal("des_xcbc_encrypt decrypt error\n");
643 }
644 }
645 #endif /* defined(LIBDES_LIT) */
646
647 ATF_TC_WITHOUT_HEAD(ede_cbc);
ATF_TC_BODY(ede_cbc,tc)648 ATF_TC_BODY(ede_cbc, tc)
649 {
650 int i, j;
651 des_cblock iv3;
652 des_key_schedule ks, ks2, ks3;
653 unsigned char cbc_in[40], cbc_out[40];
654
655 if ((j = des_set_key_checked(&cbc_key, ks)) != 0)
656 atf_tc_fail_nonfatal("Key error %d\n", j);
657 if ((j = des_set_key_checked(&cbc2_key, ks2)) != 0)
658 atf_tc_fail_nonfatal("Key error %d\n", j);
659 if ((j = des_set_key_checked(&cbc3_key, ks3)) != 0)
660 atf_tc_fail_nonfatal("Key error %d\n", j);
661 memset(cbc_out, 0, 40);
662 memset(cbc_in, 0, 40);
663 i = strlen((char *) cbc_data) + 1;
664 /* i=((i+7)/8)*8; */
665 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
666
667 des_ede3_cbc_encrypt(cbc_data, cbc_out, 16L, ks, ks2, ks3, &iv3,
668 DES_ENCRYPT);
669 des_ede3_cbc_encrypt(&(cbc_data[16]), &(cbc_out[16]), i - 16, ks, ks2,
670 ks3, &iv3, DES_ENCRYPT);
671 if (memcmp(cbc_out, cbc3_ok, (unsigned int)
672 (strlen((char *) cbc_data) + 1 + 7) / 8 * 8) != 0)
673 atf_tc_fail_nonfatal("des_ede3_cbc_encrypt encrypt error\n");
674 memcpy(iv3, cbc_iv, sizeof(cbc_iv));
675 des_ede3_cbc_encrypt(cbc_out, cbc_in, i, ks, ks2, ks3, &iv3,
676 DES_DECRYPT);
677 if (memcmp(cbc_in, cbc_data, strlen((char *) cbc_data) + 1) != 0)
678 atf_tc_fail_nonfatal("des_ede3_cbc_encrypt decrypt error\n");
679 }
680
681 ATF_TC_WITHOUT_HEAD(pcbc);
682 #if defined(LIBDES_LIT)
ATF_TC_BODY(pcbc,tc)683 ATF_TC_BODY(pcbc, tc)
684 {
685 atf_tc_skip("Test program built with LIBDES_LIT");
686 }
687 #else /* defined(LIBDES_LIT) */
ATF_TC_BODY(pcbc,tc)688 ATF_TC_BODY(pcbc, tc)
689 {
690 int j;
691 unsigned char cbc_in[40], cbc_out[40];
692 des_key_schedule ks;
693
694 if ((j = des_set_key_checked(&cbc_key, ks)) != 0) {
695 atf_tc_fail_nonfatal("Key error %d\n", j);
696 }
697 memset(cbc_out, 0, 40);
698 memset(cbc_in, 0, 40);
699 des_pcbc_encrypt(cbc_data, cbc_out, strlen((char *) cbc_data) + 1, ks,
700 &cbc_iv, DES_ENCRYPT);
701 if (memcmp(cbc_out, pcbc_ok, 32) != 0) {
702 atf_tc_fail_nonfatal("pcbc_encrypt encrypt error\n");
703 }
704 des_pcbc_encrypt(cbc_out, cbc_in, strlen((char *) cbc_data) + 1, ks, &cbc_iv,
705 DES_DECRYPT);
706 if (memcmp(cbc_in, cbc_data, strlen((char *) cbc_data) + 1) != 0) {
707 atf_tc_fail_nonfatal("pcbc_encrypt decrypt error\n");
708 }
709 }
710 #endif /* defined(LIBDES_LIT) */
711
712 ATF_TC_WITHOUT_HEAD(cfb);
713 #if defined(LIBDES_LIT)
ATF_TC_BODY(cfb,tc)714 ATF_TC_BODY(cfb, tc)
715 {
716 atf_tc_skip("Test program built with LIBDES_LIT");
717 }
718 #else /* defined(LIBDES_LIT) */
ATF_TC_BODY(cfb,tc)719 ATF_TC_BODY(cfb, tc)
720 {
721 size_t i;
722 des_key_schedule ks;
723
724 printf("cfb8\n");
725 cfb_test(8, cfb_cipher8);
726 printf("cfb16\n");
727 cfb_test(16, cfb_cipher16);
728 printf("cfb32\n");
729 cfb_test(32, cfb_cipher32);
730 printf("cfb48\n");
731 cfb_test(48, cfb_cipher48);
732 printf("cfb64\n");
733 cfb_test(64, cfb_cipher64);
734
735 printf("cfb64()\n");
736 cfb64_test(cfb_cipher64);
737
738 des_set_key_checked(&cfb_key, ks);
739 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
740 for (i = 0; i < sizeof(plain); i++)
741 des_cfb_encrypt(&(plain[i]), &(cfb_buf1[i]),
742 8, 1, ks, &cfb_tmp, DES_ENCRYPT);
743 if (memcmp(cfb_cipher8, cfb_buf1, sizeof(plain)) != 0)
744 atf_tc_fail_nonfatal("cfb_encrypt small encrypt error\n");
745 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv));
746 for (i = 0; i < sizeof(plain); i++)
747 des_cfb_encrypt(&(cfb_buf1[i]), &(cfb_buf2[i]),
748 8, 1, ks, &cfb_tmp, DES_DECRYPT);
749 if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0)
750 atf_tc_fail_nonfatal("cfb_encrypt small decrypt error\n");
751 printf("ede_cfb64()\n");
752 ede_cfb64_test(cfb_cipher64);
753 }
754 #endif /* defined(LIBDES_LIT) */
755
756 ATF_TC_WITHOUT_HEAD(ofb);
757 #if defined(LIBDES_LIT)
ATF_TC_BODY(ofb,tc)758 ATF_TC_BODY(ofb, tc)
759 {
760 atf_tc_skip("Test program built with LIBDES_LIT");
761 }
762 #else /* defined(LIBDES_LIT) */
ATF_TC_BODY(ofb,tc)763 ATF_TC_BODY(ofb, tc)
764 {
765 des_key_schedule ks;
766
767 des_set_key_checked(&ofb_key, ks);
768 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
769 des_ofb_encrypt(plain, ofb_buf1, 64, sizeof(plain) / 8, ks, &ofb_tmp);
770 if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) {
771 atf_tc_fail_nonfatal("ofb_encrypt encrypt error: "
772 "%02X %02X %02X %02X %02X %02X %02X %02X, "
773 "%02X %02X %02X %02X %02X %02X %02X %02X",
774 ofb_buf1[8 + 0], ofb_buf1[8 + 1],
775 ofb_buf1[8 + 2], ofb_buf1[8 + 3],
776 ofb_buf1[8 + 4], ofb_buf1[8 + 5],
777 ofb_buf1[8 + 6], ofb_buf1[8 + 7],
778 ofb_buf1[8 + 0], ofb_cipher[8 + 1],
779 ofb_cipher[8 + 2], ofb_cipher[8 + 3],
780 ofb_buf1[8 + 4], ofb_cipher[8 + 5],
781 ofb_cipher[8 + 6], ofb_cipher[8 + 7]);
782 }
783 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
784 des_ofb_encrypt(ofb_buf1, ofb_buf2, 64, sizeof(ofb_buf1) / 8, ks,
785 &ofb_tmp);
786 if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) {
787 atf_tc_fail_nonfatal("ofb_encrypt decrypt error: "
788 "%02X %02X %02X %02X %02X %02X %02X %02X, "
789 "%02X %02X %02X %02X %02X %02X %02X %02X",
790 ofb_buf2[8 + 0], ofb_buf2[8 + 1],
791 ofb_buf2[8 + 2], ofb_buf2[8 + 3],
792 ofb_buf2[8 + 4], ofb_buf2[8 + 5],
793 ofb_buf2[8 + 6], ofb_buf2[8 + 7],
794 plain[8 + 0], plain[8 + 1],
795 plain[8 + 2], plain[8 + 3],
796 plain[8 + 4], plain[8 + 5],
797 plain[8 + 6], plain[8 + 7]);
798 }
799 }
800 #endif /* defined(LIBDES_LIT) */
801
802 ATF_TC_WITHOUT_HEAD(ofb64);
803 #if defined(LIBDES_LIT)
ATF_TC_BODY(ofb64,tc)804 ATF_TC_BODY(ofb64, tc)
805 {
806 atf_tc_skip("Test program built with LIBDES_LIT");
807 }
808 #else /* defined(LIBDES_LIT) */
ATF_TC_BODY(ofb64,tc)809 ATF_TC_BODY(ofb64, tc)
810 {
811 int num;
812 size_t i;
813 des_key_schedule ks;
814
815 des_set_key_checked(&ofb_key, ks);
816 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
817 memset(ofb_buf1, 0, sizeof(ofb_buf1));
818 memset(ofb_buf2, 0, sizeof(ofb_buf1));
819 num = 0;
820 for (i = 0; i < sizeof(plain); i++) {
821 des_ofb64_encrypt(&(plain[i]), &(ofb_buf1[i]), 1, ks, &ofb_tmp,
822 &num);
823 }
824 if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) {
825 atf_tc_fail_nonfatal("ofb64_encrypt encrypt error\n");
826 }
827 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
828 num = 0;
829 des_ofb64_encrypt(ofb_buf1, ofb_buf2, sizeof(ofb_buf1), ks, &ofb_tmp, &num);
830 if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) {
831 atf_tc_fail_nonfatal("ofb64_encrypt decrypt error\n");
832 }
833 }
834 #endif /* defined(LIBDES_LIT) */
835
836 ATF_TC_WITHOUT_HEAD(ede_ofb64);
837 #if defined(LIBDES_LIT)
ATF_TC_BODY(ede_ofb64,tc)838 ATF_TC_BODY(ede_ofb64, tc)
839 {
840 atf_tc_skip("Test program built with LIBDES_LIT");
841 }
842 #else /* defined(LIBDES_LIT) */
ATF_TC_BODY(ede_ofb64,tc)843 ATF_TC_BODY(ede_ofb64, tc)
844 {
845 int num;
846 size_t i;
847 des_key_schedule ks;
848
849 des_set_key_checked(&ofb_key, ks);
850 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
851 memset(ofb_buf1, 0, sizeof(ofb_buf1));
852 memset(ofb_buf2, 0, sizeof(ofb_buf1));
853 num = 0;
854 for (i = 0; i < sizeof(plain); i++) {
855 des_ede3_ofb64_encrypt(&(plain[i]), &(ofb_buf1[i]), 1, ks, ks, ks,
856 &ofb_tmp, &num);
857 }
858 if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) {
859 atf_tc_fail_nonfatal("ede_ofb64_encrypt encrypt error\n");
860 }
861 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv));
862 num = 0;
863 des_ede3_ofb64_encrypt(ofb_buf1, ofb_buf2, sizeof(ofb_buf1), ks,
864 ks, ks, &ofb_tmp, &num);
865 if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) {
866 atf_tc_fail_nonfatal("ede_ofb64_encrypt decrypt error\n");
867 }
868 }
869 #endif /* defined(LIBDES_LIT) */
870
871 ATF_TC_WITHOUT_HEAD(cbc_cksum);
872 #if defined(LIBDES_LIT)
ATF_TC_BODY(cbc_cksum,tc)873 ATF_TC_BODY(cbc_cksum, tc)
874 {
875 atf_tc_skip("Test program built with LIBDES_LIT");
876 }
877 #else /* defined(LIBDES_LIT) */
ATF_TC_BODY(cbc_cksum,tc)878 ATF_TC_BODY(cbc_cksum, tc)
879 {
880 unsigned char cret[8];
881 des_key_schedule ks;
882 DES_LONG cs;
883
884 des_set_key_checked(&cbc_key, ks);
885 cs = des_cbc_cksum(cbc_data, &cret, strlen((char *) cbc_data), ks, &cbc_iv);
886 if (cs != cbc_cksum_ret) {
887 atf_tc_fail_nonfatal("bad return value (%08lX), should be %08lX\n",
888 (unsigned long) cs, (unsigned long) cbc_cksum_ret);
889 }
890 if (memcmp(cret, cbc_cksum_data, 8) != 0) {
891 atf_tc_fail_nonfatal("bad cbc_cksum block returned\n");
892 }
893 }
894 #endif /* defined(LIBDES_LIT) */
895
896 ATF_TC_WITHOUT_HEAD(quad_cksum);
897 #if defined(LIBDES_LIT)
ATF_TC_BODY(quad_cksum,tc)898 ATF_TC_BODY(quad_cksum, tc)
899 {
900 atf_tc_skip("Test program built with LIBDES_LIT");
901 }
902 #else /* defined(LIBDES_LIT) */
ATF_TC_BODY(quad_cksum,tc)903 ATF_TC_BODY(quad_cksum, tc)
904 {
905 DES_LONG cs, lqret[4];
906
907 cs = quad_cksum(cbc_data, (des_cblock *) lqret,
908 (long) strlen((char *) cbc_data), 2, (des_cblock *) cbc_iv);
909 if (cs != 0x70d7a63aL) {
910 atf_tc_fail_nonfatal("quad_cksum error, ret %08lx should be 70d7a63a\n",
911 (unsigned long) cs);
912 }
913 if (lqret[0] != 0x327eba8dL) {
914 atf_tc_fail_nonfatal("quad_cksum error, out[0] %08lx is not %08lx\n",
915 (unsigned long) lqret[0], 0x327eba8dUL);
916 }
917 if (lqret[1] != 0x201a49ccL) {
918 atf_tc_fail_nonfatal("quad_cksum error, out[1] %08lx is not %08lx\n",
919 (unsigned long) lqret[1], 0x201a49ccUL);
920 }
921 if (lqret[2] != 0x70d7a63aL) {
922 atf_tc_fail_nonfatal("quad_cksum error, out[2] %08lx is not %08lx\n",
923 (unsigned long) lqret[2], 0x70d7a63aUL);
924 }
925 if (lqret[3] != 0x501c2c26L) {
926 atf_tc_fail_nonfatal("quad_cksum error, out[3] %08lx is not %08lx\n",
927 (unsigned long) lqret[3], 0x501c2c26UL);
928 }
929 }
930 #endif /* defined(LIBDES_LIT) */
931
932 ATF_TC_WITHOUT_HEAD(align);
ATF_TC_BODY(align,tc)933 ATF_TC_BODY(align, tc)
934 {
935 int i;
936 unsigned char cbc_in[40], cbc_out[40];
937 des_key_schedule ks;
938
939 printf("input word alignment test");
940 for (i = 0; i < 4; i++) {
941 printf(" %d", i);
942 des_ncbc_encrypt(&(cbc_out[i]), cbc_in,
943 strlen((char *) cbc_data) + 1, ks,
944 &cbc_iv, DES_ENCRYPT);
945 }
946
947 printf("\noutput word alignment test");
948 for (i = 0; i < 4; i++) {
949 printf(" %d", i);
950 des_ncbc_encrypt(cbc_out, &(cbc_in[i]),
951 strlen((char *) cbc_data) + 1, ks,
952 &cbc_iv, DES_ENCRYPT);
953 }
954 }
955
956 ATF_TC_WITHOUT_HEAD(fast_crypt);
ATF_TC_BODY(fast_crypt,tc)957 ATF_TC_BODY(fast_crypt, tc)
958 {
959 char *str;
960
961 str = crypt("testing", "ef");
962 if (strcmp("efGnQx2725bI2", str) != 0)
963 atf_tc_fail_nonfatal("fast crypt error, %s should be efGnQx2725bI2\n", str);
964 str = crypt("bca76;23", "yA");
965 if (strcmp("yA1Rp/1hZXIJk", str) != 0)
966 atf_tc_fail_nonfatal("fast crypt error, %s should be yA1Rp/1hZXIJk\n", str);
967 }
968
ATF_TP_ADD_TCS(tp)969 ATF_TP_ADD_TCS(tp)
970 {
971
972 ATF_TP_ADD_TC(tp, cbcm);
973 ATF_TP_ADD_TC(tp, ecb);
974 ATF_TP_ADD_TC(tp, ede_ecb);
975 ATF_TP_ADD_TC(tp, cbc);
976 ATF_TP_ADD_TC(tp, desx_cbc);
977 ATF_TP_ADD_TC(tp, ede_cbc);
978 ATF_TP_ADD_TC(tp, pcbc);
979 ATF_TP_ADD_TC(tp, cfb);
980 ATF_TP_ADD_TC(tp, ofb);
981 ATF_TP_ADD_TC(tp, ofb64);
982 ATF_TP_ADD_TC(tp, ede_ofb64);
983 ATF_TP_ADD_TC(tp, cbc_cksum);
984 ATF_TP_ADD_TC(tp, quad_cksum);
985 ATF_TP_ADD_TC(tp, align);
986 ATF_TP_ADD_TC(tp, fast_crypt);
987
988 return atf_no_error();
989 }
990