2003-02-23 Moritz Schulte <moritz@g10code.com>
[libgcrypt.git] / cipher / des.c
1 /* des.c - DES and Triple-DES encryption/decryption Algorithm
2  *      Copyright (C) 1998, 1999, 2001, 2002, 2003 Free Software Foundation, Inc.
3  *
4  * This file is part of Libgcrypt.
5  *
6  * Libgcrypt is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU Lesser general Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * Libgcrypt is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  *
20  * For a description of triple encryption, see:
21  *   Bruce Schneier: Applied Cryptography. Second Edition.
22  *   John Wiley & Sons, 1996. ISBN 0-471-12845-7. Pages 358 ff.
23  * This implementation is according to the definition of DES in FIPS
24  * PUB 46-2 from December 1993. 
25  */
26
27
28 /*
29  * Written by Michael Roth <mroth@nessie.de>, September 1998
30  */
31
32
33 /*
34  *  U S A G E
35  * ===========
36  *
37  * For DES or Triple-DES encryption/decryption you must initialize a proper
38  * encryption context with a key.
39  *
40  * A DES key is 64bit wide but only 56bits of the key are used. The remaining
41  * bits are parity bits and they will _not_ checked in this implementation, but
42  * simply ignored.
43  *
44  * For Triple-DES you could use either two 64bit keys or three 64bit keys.
45  * The parity bits will _not_ checked, too.
46  *
47  * After initializing a context with a key you could use this context to
48  * encrypt or decrypt data in 64bit blocks in Electronic Codebook Mode.
49  *
50  * (In the examples below the slashes at the beginning and ending of comments
51  * are omited.)
52  *
53  * DES Example
54  * -----------
55  *     unsigned char key[8];
56  *     unsigned char plaintext[8];
57  *     unsigned char ciphertext[8];
58  *     unsigned char recoverd[8];
59  *     des_ctx context;
60  *
61  *     * Fill 'key' and 'plaintext' with some data *
62  *     ....
63  *
64  *     * Set up the DES encryption context *
65  *     des_setkey(context, key);
66  *
67  *     * Encrypt the plaintext *
68  *     des_ecb_encrypt(context, plaintext, ciphertext);
69  *
70  *     * To recover the orginal plaintext from ciphertext use: *
71  *     des_ecb_decrypt(context, ciphertext, recoverd);
72  *
73  *
74  * Triple-DES Example
75  * ------------------
76  *     unsigned char key1[8];
77  *     unsigned char key2[8];
78  *     unsigned char key3[8];
79  *     unsigned char plaintext[8];
80  *     unsigned char ciphertext[8];
81  *     unsigned char recoverd[8];
82  *     tripledes_ctx context;
83  *
84  *     * If you would like to use two 64bit keys, fill 'key1' and'key2'
85  *       then setup the encryption context: *
86  *     tripledes_set2keys(context, key1, key2);
87  *
88  *     * To use three 64bit keys with Triple-DES use: *
89  *     tripledes_set3keys(context, key1, key2, key3);
90  *
91  *     * Encrypting plaintext with Triple-DES *
92  *     tripledes_ecb_encrypt(context, plaintext, ciphertext);
93  *
94  *     * Decrypting ciphertext to recover the plaintext with Triple-DES *
95  *     tripledes_ecb_decrypt(context, ciphertext, recoverd);
96  *
97  *
98  * Selftest
99  * --------
100  *     char *error_msg;
101  *
102  *     * To perform a selftest of this DES/Triple-DES implementation use the
103  *       function selftest(). It will return an error string if their are
104  *       some problems with this library. *
105  *
106  *     if ( (error_msg = selftest()) )
107  *     {
108  *         fprintf(stderr, "An error in the DES/Tripple-DES implementation occured: %s\n", error_msg);
109  *         abort();
110  *     }
111  */
112
113
114 #include <config.h>
115 #include <stdio.h>
116 #include <string.h>            /* memcpy, memcmp */
117 #include "types.h"             /* for byte and u32 typedefs */
118 #include "g10lib.h"
119 #include "des.h"
120
121 #if defined(__GNUC__) && defined(__GNU_LIBRARY__)
122 #define working_memcmp memcmp
123 #else
124 /*
125  * According to the SunOS man page, memcmp returns indeterminate sign
126  * depending on whether characters are signed or not.
127  */
128 static int
129 working_memcmp( const char *a, const char *b, size_t n )
130 {
131     for( ; n; n--, a++, b++ )
132         if( *a != *b )
133             return (int)(*(byte*)a) - (int)(*(byte*)b);
134     return 0;
135 }
136 #endif
137
138
139 /* Some defines/checks to support standalone modules */
140
141 #ifndef GCRY_CIPHER_3DES
142 # define CIPHER_ALGO_3DES 2
143 #elif GCRY_CIPHER_3DES != 2
144 # error CIPHER_ALGO_3DES is defined to a wrong value.
145 #endif
146
147 #ifndef GCRY_CIPHER_DES
148 # define CIPHER_ALGO_DES 302
149 #elif GCRY_CIPHER_DES != 302
150 # error CIPHER_ALGO_DES is defined to a wrong value.
151 #endif
152
153
154 /* Macros used by the info function. */
155 #define FNCCAST_SETKEY(f)  ((int(*)(void*, byte*, unsigned))(f))
156 #define FNCCAST_CRYPT(f)   ((void(*)(void*, byte*, byte*))(f))
157
158
159 /*
160  * Encryption/Decryption context of DES
161  */
162 typedef struct _des_ctx
163   {
164     u32 encrypt_subkeys[32];
165     u32 decrypt_subkeys[32];
166   }
167 des_ctx[1];
168
169 /*
170  * Encryption/Decryption context of Triple-DES
171  */
172 typedef struct _tripledes_ctx
173   {
174     u32 encrypt_subkeys[96];
175     u32 decrypt_subkeys[96];
176   }
177 tripledes_ctx[1];
178
179 static const char *selftest_failed;
180
181 static void des_key_schedule (const byte *, u32 *);
182 static int des_setkey (struct _des_ctx *, const byte *);
183 static int des_ecb_crypt (struct _des_ctx *, const byte *, byte *, int);
184 static int tripledes_set2keys (struct _tripledes_ctx *, const byte *, const byte *);
185 static int tripledes_set3keys (struct _tripledes_ctx *, const byte *, const byte *, const byte *);
186 static int tripledes_ecb_crypt (struct _tripledes_ctx *, const byte *, byte *, int);
187 static int is_weak_key ( const byte *key );
188 static const char *selftest (void);
189
190
191
192
193
194
195 /*
196  * The s-box values are permuted according to the 'primitive function P'
197  * and are rotated one bit to the left.
198  */
199 static u32 sbox1[64] =
200 {
201   0x01010400, 0x00000000, 0x00010000, 0x01010404, 0x01010004, 0x00010404, 0x00000004, 0x00010000,
202   0x00000400, 0x01010400, 0x01010404, 0x00000400, 0x01000404, 0x01010004, 0x01000000, 0x00000004,
203   0x00000404, 0x01000400, 0x01000400, 0x00010400, 0x00010400, 0x01010000, 0x01010000, 0x01000404,
204   0x00010004, 0x01000004, 0x01000004, 0x00010004, 0x00000000, 0x00000404, 0x00010404, 0x01000000,
205   0x00010000, 0x01010404, 0x00000004, 0x01010000, 0x01010400, 0x01000000, 0x01000000, 0x00000400,
206   0x01010004, 0x00010000, 0x00010400, 0x01000004, 0x00000400, 0x00000004, 0x01000404, 0x00010404,
207   0x01010404, 0x00010004, 0x01010000, 0x01000404, 0x01000004, 0x00000404, 0x00010404, 0x01010400,
208   0x00000404, 0x01000400, 0x01000400, 0x00000000, 0x00010004, 0x00010400, 0x00000000, 0x01010004
209 };
210
211 static u32 sbox2[64] =
212 {
213   0x80108020, 0x80008000, 0x00008000, 0x00108020, 0x00100000, 0x00000020, 0x80100020, 0x80008020,
214   0x80000020, 0x80108020, 0x80108000, 0x80000000, 0x80008000, 0x00100000, 0x00000020, 0x80100020,
215   0x00108000, 0x00100020, 0x80008020, 0x00000000, 0x80000000, 0x00008000, 0x00108020, 0x80100000,
216   0x00100020, 0x80000020, 0x00000000, 0x00108000, 0x00008020, 0x80108000, 0x80100000, 0x00008020,
217   0x00000000, 0x00108020, 0x80100020, 0x00100000, 0x80008020, 0x80100000, 0x80108000, 0x00008000,
218   0x80100000, 0x80008000, 0x00000020, 0x80108020, 0x00108020, 0x00000020, 0x00008000, 0x80000000,
219   0x00008020, 0x80108000, 0x00100000, 0x80000020, 0x00100020, 0x80008020, 0x80000020, 0x00100020,
220   0x00108000, 0x00000000, 0x80008000, 0x00008020, 0x80000000, 0x80100020, 0x80108020, 0x00108000
221 };
222
223 static u32 sbox3[64] =
224 {
225   0x00000208, 0x08020200, 0x00000000, 0x08020008, 0x08000200, 0x00000000, 0x00020208, 0x08000200,
226   0x00020008, 0x08000008, 0x08000008, 0x00020000, 0x08020208, 0x00020008, 0x08020000, 0x00000208,
227   0x08000000, 0x00000008, 0x08020200, 0x00000200, 0x00020200, 0x08020000, 0x08020008, 0x00020208,
228   0x08000208, 0x00020200, 0x00020000, 0x08000208, 0x00000008, 0x08020208, 0x00000200, 0x08000000,
229   0x08020200, 0x08000000, 0x00020008, 0x00000208, 0x00020000, 0x08020200, 0x08000200, 0x00000000,
230   0x00000200, 0x00020008, 0x08020208, 0x08000200, 0x08000008, 0x00000200, 0x00000000, 0x08020008,
231   0x08000208, 0x00020000, 0x08000000, 0x08020208, 0x00000008, 0x00020208, 0x00020200, 0x08000008,
232   0x08020000, 0x08000208, 0x00000208, 0x08020000, 0x00020208, 0x00000008, 0x08020008, 0x00020200
233 };
234
235 static u32 sbox4[64] =
236 {
237   0x00802001, 0x00002081, 0x00002081, 0x00000080, 0x00802080, 0x00800081, 0x00800001, 0x00002001,
238   0x00000000, 0x00802000, 0x00802000, 0x00802081, 0x00000081, 0x00000000, 0x00800080, 0x00800001,
239   0x00000001, 0x00002000, 0x00800000, 0x00802001, 0x00000080, 0x00800000, 0x00002001, 0x00002080,
240   0x00800081, 0x00000001, 0x00002080, 0x00800080, 0x00002000, 0x00802080, 0x00802081, 0x00000081,
241   0x00800080, 0x00800001, 0x00802000, 0x00802081, 0x00000081, 0x00000000, 0x00000000, 0x00802000,
242   0x00002080, 0x00800080, 0x00800081, 0x00000001, 0x00802001, 0x00002081, 0x00002081, 0x00000080,
243   0x00802081, 0x00000081, 0x00000001, 0x00002000, 0x00800001, 0x00002001, 0x00802080, 0x00800081,
244   0x00002001, 0x00002080, 0x00800000, 0x00802001, 0x00000080, 0x00800000, 0x00002000, 0x00802080
245 };
246
247 static u32 sbox5[64] =
248 {
249   0x00000100, 0x02080100, 0x02080000, 0x42000100, 0x00080000, 0x00000100, 0x40000000, 0x02080000,
250   0x40080100, 0x00080000, 0x02000100, 0x40080100, 0x42000100, 0x42080000, 0x00080100, 0x40000000,
251   0x02000000, 0x40080000, 0x40080000, 0x00000000, 0x40000100, 0x42080100, 0x42080100, 0x02000100,
252   0x42080000, 0x40000100, 0x00000000, 0x42000000, 0x02080100, 0x02000000, 0x42000000, 0x00080100,
253   0x00080000, 0x42000100, 0x00000100, 0x02000000, 0x40000000, 0x02080000, 0x42000100, 0x40080100,
254   0x02000100, 0x40000000, 0x42080000, 0x02080100, 0x40080100, 0x00000100, 0x02000000, 0x42080000,
255   0x42080100, 0x00080100, 0x42000000, 0x42080100, 0x02080000, 0x00000000, 0x40080000, 0x42000000,
256   0x00080100, 0x02000100, 0x40000100, 0x00080000, 0x00000000, 0x40080000, 0x02080100, 0x40000100
257 };
258
259 static u32 sbox6[64] =
260 {
261   0x20000010, 0x20400000, 0x00004000, 0x20404010, 0x20400000, 0x00000010, 0x20404010, 0x00400000,
262   0x20004000, 0x00404010, 0x00400000, 0x20000010, 0x00400010, 0x20004000, 0x20000000, 0x00004010,
263   0x00000000, 0x00400010, 0x20004010, 0x00004000, 0x00404000, 0x20004010, 0x00000010, 0x20400010,
264   0x20400010, 0x00000000, 0x00404010, 0x20404000, 0x00004010, 0x00404000, 0x20404000, 0x20000000,
265   0x20004000, 0x00000010, 0x20400010, 0x00404000, 0x20404010, 0x00400000, 0x00004010, 0x20000010,
266   0x00400000, 0x20004000, 0x20000000, 0x00004010, 0x20000010, 0x20404010, 0x00404000, 0x20400000,
267   0x00404010, 0x20404000, 0x00000000, 0x20400010, 0x00000010, 0x00004000, 0x20400000, 0x00404010,
268   0x00004000, 0x00400010, 0x20004010, 0x00000000, 0x20404000, 0x20000000, 0x00400010, 0x20004010
269 };
270
271 static u32 sbox7[64] =
272 {
273   0x00200000, 0x04200002, 0x04000802, 0x00000000, 0x00000800, 0x04000802, 0x00200802, 0x04200800,
274   0x04200802, 0x00200000, 0x00000000, 0x04000002, 0x00000002, 0x04000000, 0x04200002, 0x00000802,
275   0x04000800, 0x00200802, 0x00200002, 0x04000800, 0x04000002, 0x04200000, 0x04200800, 0x00200002,
276   0x04200000, 0x00000800, 0x00000802, 0x04200802, 0x00200800, 0x00000002, 0x04000000, 0x00200800,
277   0x04000000, 0x00200800, 0x00200000, 0x04000802, 0x04000802, 0x04200002, 0x04200002, 0x00000002,
278   0x00200002, 0x04000000, 0x04000800, 0x00200000, 0x04200800, 0x00000802, 0x00200802, 0x04200800,
279   0x00000802, 0x04000002, 0x04200802, 0x04200000, 0x00200800, 0x00000000, 0x00000002, 0x04200802,
280   0x00000000, 0x00200802, 0x04200000, 0x00000800, 0x04000002, 0x04000800, 0x00000800, 0x00200002
281 };
282
283 static u32 sbox8[64] =
284 {
285   0x10001040, 0x00001000, 0x00040000, 0x10041040, 0x10000000, 0x10001040, 0x00000040, 0x10000000,
286   0x00040040, 0x10040000, 0x10041040, 0x00041000, 0x10041000, 0x00041040, 0x00001000, 0x00000040,
287   0x10040000, 0x10000040, 0x10001000, 0x00001040, 0x00041000, 0x00040040, 0x10040040, 0x10041000,
288   0x00001040, 0x00000000, 0x00000000, 0x10040040, 0x10000040, 0x10001000, 0x00041040, 0x00040000,
289   0x00041040, 0x00040000, 0x10041000, 0x00001000, 0x00000040, 0x10040040, 0x00001000, 0x00041040,
290   0x10001000, 0x00000040, 0x10000040, 0x10040000, 0x10040040, 0x10000000, 0x00040000, 0x10001040,
291   0x00000000, 0x10041040, 0x00040040, 0x10000040, 0x10040000, 0x10001000, 0x10001040, 0x00000000,
292   0x10041040, 0x00041000, 0x00041000, 0x00001040, 0x00001040, 0x00040040, 0x10000000, 0x10041000
293 };
294
295
296 /*
297  * These two tables are part of the 'permuted choice 1' function.
298  * In this implementation several speed improvements are done.
299  */
300 static u32 leftkey_swap[16] =
301 {
302   0x00000000, 0x00000001, 0x00000100, 0x00000101,
303   0x00010000, 0x00010001, 0x00010100, 0x00010101,
304   0x01000000, 0x01000001, 0x01000100, 0x01000101,
305   0x01010000, 0x01010001, 0x01010100, 0x01010101
306 };
307
308 static u32 rightkey_swap[16] =
309 {
310   0x00000000, 0x01000000, 0x00010000, 0x01010000,
311   0x00000100, 0x01000100, 0x00010100, 0x01010100,
312   0x00000001, 0x01000001, 0x00010001, 0x01010001,
313   0x00000101, 0x01000101, 0x00010101, 0x01010101,
314 };
315
316
317
318 /*
319  * Numbers of left shifts per round for encryption subkeys.
320  * To calculate the decryption subkeys we just reverse the
321  * ordering of the calculated encryption subkeys. So their
322  * is no need for a decryption rotate tab.
323  */
324 static byte encrypt_rotate_tab[16] =
325 {
326   1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
327 };
328
329
330
331 /*
332  * Table with weak DES keys sorted in ascending order.
333  * In DES their are 64 known keys wich are weak. They are weak
334  * because they produce only one, two or four different
335  * subkeys in the subkey scheduling process.
336  * The keys in this table have all their parity bits cleared.
337  */
338 static byte weak_keys[64][8] =
339 {
340   { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /*w*/
341   { 0x00, 0x00, 0x1e, 0x1e, 0x00, 0x00, 0x0e, 0x0e },
342   { 0x00, 0x00, 0xe0, 0xe0, 0x00, 0x00, 0xf0, 0xf0 },
343   { 0x00, 0x00, 0xfe, 0xfe, 0x00, 0x00, 0xfe, 0xfe },
344   { 0x00, 0x1e, 0x00, 0x1e, 0x00, 0x0e, 0x00, 0x0e }, /*sw*/
345   { 0x00, 0x1e, 0x1e, 0x00, 0x00, 0x0e, 0x0e, 0x00 },
346   { 0x00, 0x1e, 0xe0, 0xfe, 0x00, 0x0e, 0xf0, 0xfe },
347   { 0x00, 0x1e, 0xfe, 0xe0, 0x00, 0x0e, 0xfe, 0xf0 },
348   { 0x00, 0xe0, 0x00, 0xe0, 0x00, 0xf0, 0x00, 0xf0 }, /*sw*/
349   { 0x00, 0xe0, 0x1e, 0xfe, 0x00, 0xf0, 0x0e, 0xfe },
350   { 0x00, 0xe0, 0xe0, 0x00, 0x00, 0xf0, 0xf0, 0x00 },
351   { 0x00, 0xe0, 0xfe, 0x1e, 0x00, 0xf0, 0xfe, 0x0e },
352   { 0x00, 0xfe, 0x00, 0xfe, 0x00, 0xfe, 0x00, 0xfe }, /*sw*/
353   { 0x00, 0xfe, 0x1e, 0xe0, 0x00, 0xfe, 0x0e, 0xf0 },
354   { 0x00, 0xfe, 0xe0, 0x1e, 0x00, 0xfe, 0xf0, 0x0e },
355   { 0x00, 0xfe, 0xfe, 0x00, 0x00, 0xfe, 0xfe, 0x00 },
356   { 0x1e, 0x00, 0x00, 0x1e, 0x0e, 0x00, 0x00, 0x0e },
357   { 0x1e, 0x00, 0x1e, 0x00, 0x0e, 0x00, 0x0e, 0x00 }, /*sw*/
358   { 0x1e, 0x00, 0xe0, 0xfe, 0x0e, 0x00, 0xf0, 0xfe },
359   { 0x1e, 0x00, 0xfe, 0xe0, 0x0e, 0x00, 0xfe, 0xf0 },
360   { 0x1e, 0x1e, 0x00, 0x00, 0x0e, 0x0e, 0x00, 0x00 },
361   { 0x1e, 0x1e, 0x1e, 0x1e, 0x0e, 0x0e, 0x0e, 0x0e }, /*w*/
362   { 0x1e, 0x1e, 0xe0, 0xe0, 0x0e, 0x0e, 0xf0, 0xf0 },
363   { 0x1e, 0x1e, 0xfe, 0xfe, 0x0e, 0x0e, 0xfe, 0xfe },
364   { 0x1e, 0xe0, 0x00, 0xfe, 0x0e, 0xf0, 0x00, 0xfe },
365   { 0x1e, 0xe0, 0x1e, 0xe0, 0x0e, 0xf0, 0x0e, 0xf0 }, /*sw*/
366   { 0x1e, 0xe0, 0xe0, 0x1e, 0x0e, 0xf0, 0xf0, 0x0e },
367   { 0x1e, 0xe0, 0xfe, 0x00, 0x0e, 0xf0, 0xfe, 0x00 },
368   { 0x1e, 0xfe, 0x00, 0xe0, 0x0e, 0xfe, 0x00, 0xf0 },
369   { 0x1e, 0xfe, 0x1e, 0xfe, 0x0e, 0xfe, 0x0e, 0xfe }, /*sw*/
370   { 0x1e, 0xfe, 0xe0, 0x00, 0x0e, 0xfe, 0xf0, 0x00 },
371   { 0x1e, 0xfe, 0xfe, 0x1e, 0x0e, 0xfe, 0xfe, 0x0e },
372   { 0xe0, 0x00, 0x00, 0xe0, 0xf0, 0x00, 0x00, 0xf0 },
373   { 0xe0, 0x00, 0x1e, 0xfe, 0xf0, 0x00, 0x0e, 0xfe },
374   { 0xe0, 0x00, 0xe0, 0x00, 0xf0, 0x00, 0xf0, 0x00 }, /*sw*/
375   { 0xe0, 0x00, 0xfe, 0x1e, 0xf0, 0x00, 0xfe, 0x0e },
376   { 0xe0, 0x1e, 0x00, 0xfe, 0xf0, 0x0e, 0x00, 0xfe },
377   { 0xe0, 0x1e, 0x1e, 0xe0, 0xf0, 0x0e, 0x0e, 0xf0 },
378   { 0xe0, 0x1e, 0xe0, 0x1e, 0xf0, 0x0e, 0xf0, 0x0e }, /*sw*/
379   { 0xe0, 0x1e, 0xfe, 0x00, 0xf0, 0x0e, 0xfe, 0x00 },
380   { 0xe0, 0xe0, 0x00, 0x00, 0xf0, 0xf0, 0x00, 0x00 },
381   { 0xe0, 0xe0, 0x1e, 0x1e, 0xf0, 0xf0, 0x0e, 0x0e },
382   { 0xe0, 0xe0, 0xe0, 0xe0, 0xf0, 0xf0, 0xf0, 0xf0 }, /*w*/
383   { 0xe0, 0xe0, 0xfe, 0xfe, 0xf0, 0xf0, 0xfe, 0xfe },
384   { 0xe0, 0xfe, 0x00, 0x1e, 0xf0, 0xfe, 0x00, 0x0e },
385   { 0xe0, 0xfe, 0x1e, 0x00, 0xf0, 0xfe, 0x0e, 0x00 },
386   { 0xe0, 0xfe, 0xe0, 0xfe, 0xf0, 0xfe, 0xf0, 0xfe }, /*sw*/
387   { 0xe0, 0xfe, 0xfe, 0xe0, 0xf0, 0xfe, 0xfe, 0xf0 },
388   { 0xfe, 0x00, 0x00, 0xfe, 0xfe, 0x00, 0x00, 0xfe },
389   { 0xfe, 0x00, 0x1e, 0xe0, 0xfe, 0x00, 0x0e, 0xf0 },
390   { 0xfe, 0x00, 0xe0, 0x1e, 0xfe, 0x00, 0xf0, 0x0e },
391   { 0xfe, 0x00, 0xfe, 0x00, 0xfe, 0x00, 0xfe, 0x00 }, /*sw*/
392   { 0xfe, 0x1e, 0x00, 0xe0, 0xfe, 0x0e, 0x00, 0xf0 },
393   { 0xfe, 0x1e, 0x1e, 0xfe, 0xfe, 0x0e, 0x0e, 0xfe },
394   { 0xfe, 0x1e, 0xe0, 0x00, 0xfe, 0x0e, 0xf0, 0x00 },
395   { 0xfe, 0x1e, 0xfe, 0x1e, 0xfe, 0x0e, 0xfe, 0x0e }, /*sw*/
396   { 0xfe, 0xe0, 0x00, 0x1e, 0xfe, 0xf0, 0x00, 0x0e },
397   { 0xfe, 0xe0, 0x1e, 0x00, 0xfe, 0xf0, 0x0e, 0x00 },
398   { 0xfe, 0xe0, 0xe0, 0xfe, 0xfe, 0xf0, 0xf0, 0xfe },
399   { 0xfe, 0xe0, 0xfe, 0xe0, 0xfe, 0xf0, 0xfe, 0xf0 }, /*sw*/
400   { 0xfe, 0xfe, 0x00, 0x00, 0xfe, 0xfe, 0x00, 0x00 },
401   { 0xfe, 0xfe, 0x1e, 0x1e, 0xfe, 0xfe, 0x0e, 0x0e },
402   { 0xfe, 0xfe, 0xe0, 0xe0, 0xfe, 0xfe, 0xf0, 0xf0 },
403   { 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe }  /*w*/
404 };
405 static unsigned char weak_keys_chksum[20] = {
406   0xD0, 0xCF, 0x07, 0x38, 0x93, 0x70, 0x8A, 0x83, 0x7D, 0xD7,
407   0x8A, 0x36, 0x65, 0x29, 0x6C, 0x1F, 0x7C, 0x3F, 0xD3, 0x41 
408 };
409
410
411
412 /*
413  * Macro to swap bits across two words.
414  */
415 #define DO_PERMUTATION(a, temp, b, offset, mask)        \
416     temp = ((a>>offset) ^ b) & mask;                    \
417     b ^= temp;                                          \
418     a ^= temp<<offset;
419
420
421 /*
422  * This performs the 'initial permutation' of the data to be encrypted
423  * or decrypted. Additionally the resulting two words are rotated one bit
424  * to the left.
425  */
426 #define INITIAL_PERMUTATION(left, temp, right)          \
427     DO_PERMUTATION(left, temp, right, 4, 0x0f0f0f0f)    \
428     DO_PERMUTATION(left, temp, right, 16, 0x0000ffff)   \
429     DO_PERMUTATION(right, temp, left, 2, 0x33333333)    \
430     DO_PERMUTATION(right, temp, left, 8, 0x00ff00ff)    \
431     right =  (right << 1) | (right >> 31);              \
432     temp  =  (left ^ right) & 0xaaaaaaaa;               \
433     right ^= temp;                                      \
434     left  ^= temp;                                      \
435     left  =  (left << 1) | (left >> 31);
436
437 /*
438  * The 'inverse initial permutation'.
439  */
440 #define FINAL_PERMUTATION(left, temp, right)            \
441     left  =  (left << 31) | (left >> 1);                \
442     temp  =  (left ^ right) & 0xaaaaaaaa;               \
443     left  ^= temp;                                      \
444     right ^= temp;                                      \
445     right  =  (right << 31) | (right >> 1);             \
446     DO_PERMUTATION(right, temp, left, 8, 0x00ff00ff)    \
447     DO_PERMUTATION(right, temp, left, 2, 0x33333333)    \
448     DO_PERMUTATION(left, temp, right, 16, 0x0000ffff)   \
449     DO_PERMUTATION(left, temp, right, 4, 0x0f0f0f0f)
450
451
452 /*
453  * A full DES round including 'expansion function', 'sbox substitution'
454  * and 'primitive function P' but without swapping the left and right word.
455  * Please note: The data in 'from' and 'to' is already rotated one bit to
456  * the left, done in the initial permutation.
457  */
458 #define DES_ROUND(from, to, work, subkey)               \
459     work = from ^ *subkey++;                            \
460     to ^= sbox8[  work      & 0x3f ];                   \
461     to ^= sbox6[ (work>>8)  & 0x3f ];                   \
462     to ^= sbox4[ (work>>16) & 0x3f ];                   \
463     to ^= sbox2[ (work>>24) & 0x3f ];                   \
464     work = ((from << 28) | (from >> 4)) ^ *subkey++;    \
465     to ^= sbox7[  work      & 0x3f ];                   \
466     to ^= sbox5[ (work>>8)  & 0x3f ];                   \
467     to ^= sbox3[ (work>>16) & 0x3f ];                   \
468     to ^= sbox1[ (work>>24) & 0x3f ];
469
470 /*
471  * Macros to convert 8 bytes from/to 32bit words.
472  */
473 #define READ_64BIT_DATA(data, left, right)                                      \
474     left  = (data[0] << 24) | (data[1] << 16) | (data[2] << 8) | data[3];       \
475     right = (data[4] << 24) | (data[5] << 16) | (data[6] << 8) | data[7];
476
477 #define WRITE_64BIT_DATA(data, left, right)                                     \
478     data[0] = (left >> 24) &0xff; data[1] = (left >> 16) &0xff;                 \
479     data[2] = (left >> 8) &0xff; data[3] = left &0xff;                          \
480     data[4] = (right >> 24) &0xff; data[5] = (right >> 16) &0xff;               \
481     data[6] = (right >> 8) &0xff; data[7] = right &0xff;
482
483 /*
484  * Handy macros for encryption and decryption of data
485  */
486 #define des_ecb_encrypt(ctx, from, to)          des_ecb_crypt(ctx, from, to, 0)
487 #define des_ecb_decrypt(ctx, from, to)          des_ecb_crypt(ctx, from, to, 1)
488 #define tripledes_ecb_encrypt(ctx, from, to)    tripledes_ecb_crypt(ctx, from, to, 0)
489 #define tripledes_ecb_decrypt(ctx, from, to)    tripledes_ecb_crypt(ctx, from, to, 1)
490
491
492
493
494
495
496 /*
497  * des_key_schedule():    Calculate 16 subkeys pairs (even/odd) for
498  *                        16 encryption rounds.
499  *                        To calculate subkeys for decryption the caller
500  *                        have to reorder the generated subkeys.
501  *
502  *    rawkey:       8 Bytes of key data
503  *    subkey:       Array of at least 32 u32s. Will be filled
504  *                  with calculated subkeys.
505  *
506  */
507 static void
508 des_key_schedule (const byte * rawkey, u32 * subkey)
509 {
510   u32 left, right, work;
511   int round;
512
513   READ_64BIT_DATA (rawkey, left, right)
514
515   DO_PERMUTATION (right, work, left, 4, 0x0f0f0f0f)
516   DO_PERMUTATION (right, work, left, 0, 0x10101010)
517
518   left = (leftkey_swap[(left >> 0) & 0xf] << 3) | (leftkey_swap[(left >> 8) & 0xf] << 2)
519     | (leftkey_swap[(left >> 16) & 0xf] << 1) | (leftkey_swap[(left >> 24) & 0xf])
520     | (leftkey_swap[(left >> 5) & 0xf] << 7) | (leftkey_swap[(left >> 13) & 0xf] << 6)
521     | (leftkey_swap[(left >> 21) & 0xf] << 5) | (leftkey_swap[(left >> 29) & 0xf] << 4);
522
523   left &= 0x0fffffff;
524
525   right = (rightkey_swap[(right >> 1) & 0xf] << 3) | (rightkey_swap[(right >> 9) & 0xf] << 2)
526     | (rightkey_swap[(right >> 17) & 0xf] << 1) | (rightkey_swap[(right >> 25) & 0xf])
527     | (rightkey_swap[(right >> 4) & 0xf] << 7) | (rightkey_swap[(right >> 12) & 0xf] << 6)
528     | (rightkey_swap[(right >> 20) & 0xf] << 5) | (rightkey_swap[(right >> 28) & 0xf] << 4);
529
530   right &= 0x0fffffff;
531
532   for (round = 0; round < 16; ++round)
533     {
534       left = ((left << encrypt_rotate_tab[round]) | (left >> (28 - encrypt_rotate_tab[round]))) & 0x0fffffff;
535       right = ((right << encrypt_rotate_tab[round]) | (right >> (28 - encrypt_rotate_tab[round]))) & 0x0fffffff;
536
537       *subkey++ = ((left << 4) & 0x24000000)
538         | ((left << 28) & 0x10000000)
539         | ((left << 14) & 0x08000000)
540         | ((left << 18) & 0x02080000)
541         | ((left << 6) & 0x01000000)
542         | ((left << 9) & 0x00200000)
543         | ((left >> 1) & 0x00100000)
544         | ((left << 10) & 0x00040000)
545         | ((left << 2) & 0x00020000)
546         | ((left >> 10) & 0x00010000)
547         | ((right >> 13) & 0x00002000)
548         | ((right >> 4) & 0x00001000)
549         | ((right << 6) & 0x00000800)
550         | ((right >> 1) & 0x00000400)
551         | ((right >> 14) & 0x00000200)
552         | (right & 0x00000100)
553         | ((right >> 5) & 0x00000020)
554         | ((right >> 10) & 0x00000010)
555         | ((right >> 3) & 0x00000008)
556         | ((right >> 18) & 0x00000004)
557         | ((right >> 26) & 0x00000002)
558         | ((right >> 24) & 0x00000001);
559
560       *subkey++ = ((left << 15) & 0x20000000)
561         | ((left << 17) & 0x10000000)
562         | ((left << 10) & 0x08000000)
563         | ((left << 22) & 0x04000000)
564         | ((left >> 2) & 0x02000000)
565         | ((left << 1) & 0x01000000)
566         | ((left << 16) & 0x00200000)
567         | ((left << 11) & 0x00100000)
568         | ((left << 3) & 0x00080000)
569         | ((left >> 6) & 0x00040000)
570         | ((left << 15) & 0x00020000)
571         | ((left >> 4) & 0x00010000)
572         | ((right >> 2) & 0x00002000)
573         | ((right << 8) & 0x00001000)
574         | ((right >> 14) & 0x00000808)
575         | ((right >> 9) & 0x00000400)
576         | ((right) & 0x00000200)
577         | ((right << 7) & 0x00000100)
578         | ((right >> 7) & 0x00000020)
579         | ((right >> 3) & 0x00000011)
580         | ((right << 2) & 0x00000004)
581         | ((right >> 21) & 0x00000002);
582     }
583 }
584
585
586
587 /*
588  * Fill a DES context with subkeys calculated from a 64bit key.
589  * Does not check parity bits, but simply ignore them.
590  * Does not check for weak keys.
591  */
592 static int
593 des_setkey (struct _des_ctx *ctx, const byte * key)
594 {
595   int i;
596
597   if( selftest_failed )
598     return GCRYERR_SELFTEST;
599
600   des_key_schedule (key, ctx->encrypt_subkeys);
601   _gcry_burn_stack (32);
602
603   for(i=0; i<32; i+=2)
604     {
605       ctx->decrypt_subkeys[i]   = ctx->encrypt_subkeys[30-i];
606       ctx->decrypt_subkeys[i+1] = ctx->encrypt_subkeys[31-i];
607     }
608
609   return 0;
610 }
611
612
613
614 /*
615  * Electronic Codebook Mode DES encryption/decryption of data according
616  * to 'mode'.
617  */
618 static int
619 des_ecb_crypt (struct _des_ctx *ctx, const byte * from, byte * to, int mode)
620 {
621   u32 left, right, work;
622   u32 *keys;
623
624   keys = mode ? ctx->decrypt_subkeys : ctx->encrypt_subkeys;
625
626   READ_64BIT_DATA (from, left, right)
627   INITIAL_PERMUTATION (left, work, right)
628
629   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
630   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
631   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
632   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
633   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
634   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
635   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
636   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
637
638   FINAL_PERMUTATION (right, work, left)
639   WRITE_64BIT_DATA (to, right, left)
640
641   return 0;
642 }
643
644
645
646 /*
647  * Fill a Triple-DES context with subkeys calculated from two 64bit keys.
648  * Does not check the parity bits of the keys, but simply ignore them.
649  * Does not check for weak keys.
650  */
651 static int
652 tripledes_set2keys (struct _tripledes_ctx *ctx,
653                     const byte * key1,
654                     const byte * key2)
655 {
656   int i;
657
658   des_key_schedule (key1, ctx->encrypt_subkeys);
659   des_key_schedule (key2, &(ctx->decrypt_subkeys[32]));
660   _gcry_burn_stack (32);
661
662   for(i=0; i<32; i+=2)
663     {
664       ctx->decrypt_subkeys[i]    = ctx->encrypt_subkeys[30-i];
665       ctx->decrypt_subkeys[i+1]  = ctx->encrypt_subkeys[31-i];
666
667       ctx->encrypt_subkeys[i+32] = ctx->decrypt_subkeys[62-i];
668       ctx->encrypt_subkeys[i+33] = ctx->decrypt_subkeys[63-i];
669
670       ctx->encrypt_subkeys[i+64] = ctx->encrypt_subkeys[i];
671       ctx->encrypt_subkeys[i+65] = ctx->encrypt_subkeys[i+1];
672
673       ctx->decrypt_subkeys[i+64] = ctx->decrypt_subkeys[i];
674       ctx->decrypt_subkeys[i+65] = ctx->decrypt_subkeys[i+1];
675     }
676
677   return 0;
678 }
679
680
681
682 /*
683  * Fill a Triple-DES context with subkeys calculated from three 64bit keys.
684  * Does not check the parity bits of the keys, but simply ignore them.
685  * Does not check for weak keys.
686  */
687 static int
688 tripledes_set3keys (struct _tripledes_ctx *ctx,
689                     const byte * key1,
690                     const byte * key2,
691                     const byte * key3)
692 {
693   int i;
694
695   des_key_schedule (key1, ctx->encrypt_subkeys);
696   des_key_schedule (key2, &(ctx->decrypt_subkeys[32]));
697   des_key_schedule (key3, &(ctx->encrypt_subkeys[64]));
698   _gcry_burn_stack (32);
699
700   for(i=0; i<32; i+=2)
701     {
702       ctx->decrypt_subkeys[i]    = ctx->encrypt_subkeys[94-i];
703       ctx->decrypt_subkeys[i+1]  = ctx->encrypt_subkeys[95-i];
704
705       ctx->encrypt_subkeys[i+32] = ctx->decrypt_subkeys[62-i];
706       ctx->encrypt_subkeys[i+33] = ctx->decrypt_subkeys[63-i];
707
708       ctx->decrypt_subkeys[i+64] = ctx->encrypt_subkeys[30-i];
709       ctx->decrypt_subkeys[i+65] = ctx->encrypt_subkeys[31-i];
710     }
711
712   return 0;
713 }
714
715
716
717 /*
718  * Electronic Codebook Mode Triple-DES encryption/decryption of data according to 'mode'.
719  * Sometimes this mode is named 'EDE' mode (Encryption-Decryption-Encryption).
720  */
721 static int
722 tripledes_ecb_crypt (struct _tripledes_ctx *ctx, const byte * from, byte * to, int mode)
723 {
724   u32 left, right, work;
725   u32 *keys;
726
727   keys = mode ? ctx->decrypt_subkeys : ctx->encrypt_subkeys;
728
729   READ_64BIT_DATA (from, left, right)
730   INITIAL_PERMUTATION (left, work, right)
731
732   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
733   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
734   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
735   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
736   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
737   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
738   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
739   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
740
741   DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys)
742   DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys)
743   DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys)
744   DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys)
745   DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys)
746   DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys)
747   DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys)
748   DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys)
749
750   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
751   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
752   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
753   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
754   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
755   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
756   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
757   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
758
759   FINAL_PERMUTATION (right, work, left)
760   WRITE_64BIT_DATA (to, right, left)
761
762   return 0;
763 }
764
765
766
767
768
769 /*
770  * Check whether the 8 byte key is weak.
771  * Does not check the parity bits of the key but simple ignore them.
772  */
773 static int
774 is_weak_key ( const byte *key )
775 {
776   byte work[8];
777   int i, left, right, middle, cmp_result;
778
779   /* clear parity bits */
780   for(i=0; i<8; ++i)
781      work[i] = key[i] & 0xfe;
782
783   /* binary search in the weak key table */
784   left = 0;
785   right = 63;
786   while(left <= right)
787     {
788       middle = (left + right) / 2;
789
790       if ( !(cmp_result=working_memcmp(work, weak_keys[middle], 8)) )
791           return -1;
792
793       if ( cmp_result > 0 )
794           left = middle + 1;
795       else
796           right = middle - 1;
797     }
798
799   return 0;
800 }
801
802
803
804 /*
805  * Performs a selftest of this DES/Triple-DES implementation.
806  * Returns an string with the error text on failure.
807  * Returns NULL if all is ok.
808  */
809 static const char *
810 selftest (void)
811 {
812   /*
813    * Check if 'u32' is really 32 bits wide. This DES / 3DES implementation
814    * need this.
815    */
816   if (sizeof (u32) != 4)
817        return "Wrong word size for DES configured.";
818
819   /*
820    * DES Maintenance Test
821    */
822   {
823     int i;
824     byte key[8] =
825     {0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
826     byte input[8] =
827     {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
828     byte result[8] =
829     {0x24, 0x6e, 0x9d, 0xb9, 0xc5, 0x50, 0x38, 0x1a};
830     byte temp1[8], temp2[8], temp3[8];
831     des_ctx des;
832
833     for (i = 0; i < 64; ++i)
834       {
835         des_setkey (des, key);
836         des_ecb_encrypt (des, input, temp1);
837         des_ecb_encrypt (des, temp1, temp2);
838         des_setkey (des, temp2);
839         des_ecb_decrypt (des, temp1, temp3);
840         memcpy (key, temp3, 8);
841         memcpy (input, temp1, 8);
842       }
843     if (memcmp (temp3, result, 8))
844       return "DES maintenance test failed.";
845   }
846
847
848   /*
849    * Self made Triple-DES test  (Does somebody known an official test?)
850    */
851   {
852     int i;
853     byte input[8] =
854     {0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10};
855     byte key1[8] =
856     {0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0};
857     byte key2[8] =
858     {0x11, 0x22, 0x33, 0x44, 0xff, 0xaa, 0xcc, 0xdd};
859     byte result[8] =
860     {0x7b, 0x38, 0x3b, 0x23, 0xa2, 0x7d, 0x26, 0xd3};
861
862     tripledes_ctx des3;
863
864     for (i = 0; i < 16; ++i)
865       {
866         tripledes_set2keys (des3, key1, key2);
867         tripledes_ecb_encrypt (des3, input, key1);
868         tripledes_ecb_decrypt (des3, input, key2);
869         tripledes_set3keys (des3, key1, input, key2);
870         tripledes_ecb_encrypt (des3, input, input);
871       }
872     if (memcmp (input, result, 8))
873       return "Triple-DES test failed.";
874   }
875
876     /*
877      * More Triple-DES test.  These are testvectors as used by SSLeay,
878      * thanks to Jeroen C. van Gelderen.
879      */
880     {   struct { byte key[24]; byte plain[8]; byte cipher[8]; } testdata[] = {
881         { { 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
882             0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
883             0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01  },
884           { 0x95,0xF8,0xA5,0xE5,0xDD,0x31,0xD9,0x00  },
885           { 0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00  }
886         },
887
888         { { 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
889             0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
890             0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01  },
891           { 0x9D,0x64,0x55,0x5A,0x9A,0x10,0xB8,0x52, },
892           { 0x00,0x00,0x00,0x10,0x00,0x00,0x00,0x00  }
893         },
894         { { 0x38,0x49,0x67,0x4C,0x26,0x02,0x31,0x9E,
895             0x38,0x49,0x67,0x4C,0x26,0x02,0x31,0x9E,
896             0x38,0x49,0x67,0x4C,0x26,0x02,0x31,0x9E  },
897           { 0x51,0x45,0x4B,0x58,0x2D,0xDF,0x44,0x0A  },
898           { 0x71,0x78,0x87,0x6E,0x01,0xF1,0x9B,0x2A  }
899         },
900         { { 0x04,0xB9,0x15,0xBA,0x43,0xFE,0xB5,0xB6,
901             0x04,0xB9,0x15,0xBA,0x43,0xFE,0xB5,0xB6,
902             0x04,0xB9,0x15,0xBA,0x43,0xFE,0xB5,0xB6  },
903           { 0x42,0xFD,0x44,0x30,0x59,0x57,0x7F,0xA2  },
904           { 0xAF,0x37,0xFB,0x42,0x1F,0x8C,0x40,0x95  }
905         },
906         { { 0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF,
907             0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF,
908             0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF  },
909           { 0x73,0x6F,0x6D,0x65,0x64,0x61,0x74,0x61  },
910           { 0x3D,0x12,0x4F,0xE2,0x19,0x8B,0xA3,0x18  }
911         },
912         { { 0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF,
913             0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
914             0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF  },
915           { 0x73,0x6F,0x6D,0x65,0x64,0x61,0x74,0x61  },
916           { 0xFB,0xAB,0xA1,0xFF,0x9D,0x05,0xE9,0xB1  }
917         },
918         { { 0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF,
919             0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
920             0xFE,0xDC,0xBA,0x98,0x76,0x54,0x32,0x10  },
921           { 0x73,0x6F,0x6D,0x65,0x64,0x61,0x74,0x61  },
922           { 0x18,0xd7,0x48,0xe5,0x63,0x62,0x05,0x72  }
923         },
924         { { 0x03,0x52,0x02,0x07,0x67,0x20,0x82,0x17,
925             0x86,0x02,0x87,0x66,0x59,0x08,0x21,0x98,
926             0x64,0x05,0x6A,0xBD,0xFE,0xA9,0x34,0x57  },
927           { 0x73,0x71,0x75,0x69,0x67,0x67,0x6C,0x65  },
928           { 0xc0,0x7d,0x2a,0x0f,0xa5,0x66,0xfa,0x30  }
929         },
930         { { 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
931             0x80,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
932             0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x02  },
933           { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00  },
934           { 0xe6,0xe6,0xdd,0x5b,0x7e,0x72,0x29,0x74  }
935         },
936         { { 0x10,0x46,0x10,0x34,0x89,0x98,0x80,0x20,
937             0x91,0x07,0xD0,0x15,0x89,0x19,0x01,0x01,
938             0x19,0x07,0x92,0x10,0x98,0x1A,0x01,0x01  },
939           { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00  },
940           { 0xe1,0xef,0x62,0xc3,0x32,0xfe,0x82,0x5b  }
941         }
942         };
943
944         byte            result[8];
945         int             i;
946         static char     error[80];
947         tripledes_ctx   des3;
948
949         for (i=0; i<sizeof(testdata)/sizeof(*testdata); ++i) {
950             tripledes_set3keys (des3, testdata[i].key, testdata[i].key + 8, testdata[i].key + 16);
951
952             tripledes_ecb_encrypt (des3, testdata[i].plain, result);
953             if (memcmp (testdata[i].cipher, result, 8)) {
954                 sprintf (error, "Triple-DES SSLeay test pattern no. %d failend on encryption.", i+1);
955                 return error;
956             }
957
958             tripledes_ecb_decrypt (des3, testdata[i].cipher, result);
959             if (memcmp (testdata[i].plain, result, 8)) {
960                 sprintf (error, "Triple-DES SSLeay test pattern no. %d failend on decryption.", i+1);
961                 return error;
962             }
963         }
964     }
965
966   /*
967    * Check the weak key detection. We simply assume that the table
968    * with weak keys is ok and check every key in the table if it is
969    * detected... (This test is a little bit stupid)
970    */
971   {
972     int i;
973     unsigned char *p;
974
975     GCRY_MD_HD h = gcry_md_open (GCRY_MD_SHA1, 0);
976
977     if (!h)
978       return "SHA1 not available";
979     for (i = 0; i < 64; ++i)
980       gcry_md_write (h, weak_keys[i], 8);
981     p = gcry_md_read (h, GCRY_MD_SHA1);
982     i = memcmp (p, weak_keys_chksum, 20);
983     gcry_md_close (h);
984     if (i)
985       return "weak key table defect";
986
987     for (i = 0; i < 64; ++i)
988         if (!is_weak_key(weak_keys[i]))
989             return "DES weak key detection failed";
990   }
991
992   return 0;
993 }
994
995
996 static int
997 do_tripledes_setkey ( struct _tripledes_ctx *ctx, byte *key, unsigned keylen )
998 {
999     if( selftest_failed )
1000         return GCRYERR_SELFTEST;
1001     if( keylen != 24 )
1002         return GCRYERR_INV_KEYLEN;
1003
1004     tripledes_set3keys ( ctx, key, key+8, key+16);
1005
1006     if( is_weak_key( key ) || is_weak_key( key+8 ) || is_weak_key( key+16 ) ) {
1007         _gcry_burn_stack (64);
1008         return GCRYERR_WEAK_KEY;
1009     }
1010     _gcry_burn_stack (64);
1011
1012     return 0;
1013 }
1014
1015
1016 static void
1017 do_tripledes_encrypt( struct _tripledes_ctx *ctx, byte *outbuf, byte *inbuf )
1018 {
1019     tripledes_ecb_encrypt ( ctx, inbuf, outbuf );
1020     _gcry_burn_stack (32);
1021 }
1022
1023 static void
1024 do_tripledes_decrypt( struct _tripledes_ctx *ctx, byte *outbuf, byte *inbuf )
1025 {
1026     tripledes_ecb_decrypt ( ctx, inbuf, outbuf );
1027     _gcry_burn_stack (32);
1028 }
1029
1030
1031
1032
1033 static int
1034 do_des_setkey ( struct _des_ctx *ctx, byte *key, unsigned keylen )
1035 {
1036     if( selftest_failed )
1037         return GCRYERR_SELFTEST;
1038     if( keylen != 8 )
1039         return GCRYERR_INV_KEYLEN;
1040
1041     des_setkey (ctx, key);
1042
1043     if( is_weak_key( key ) ) {
1044         _gcry_burn_stack (64);
1045         return GCRYERR_WEAK_KEY;
1046     }
1047     _gcry_burn_stack (64);
1048
1049     return 0;
1050 }
1051
1052
1053 static void
1054 do_des_encrypt( struct _des_ctx *ctx, byte *outbuf, byte *inbuf )
1055 {
1056     des_ecb_encrypt ( ctx, inbuf, outbuf );
1057     _gcry_burn_stack (32);
1058 }
1059
1060 static void
1061 do_des_decrypt( struct _des_ctx *ctx, byte *outbuf, byte *inbuf )
1062 {
1063     des_ecb_decrypt ( ctx, inbuf, outbuf );
1064     _gcry_burn_stack (32);
1065 }
1066
1067
1068 /****************
1069  * Return some information about the algorithm.  We need algo here to
1070  * distinguish different flavors of the algorithm.
1071  * Returns: A pointer to string describing the algorithm or NULL if
1072  *          the ALGO is invalid.
1073  */
1074 const char *
1075 _gcry_des_get_info( int algo, size_t *keylen,
1076                    size_t *blocksize, size_t *contextsize,
1077                    int  (**r_setkey)( void *c, byte *key, unsigned keylen ),
1078                    void (**r_encrypt)( void *c, byte *outbuf, byte *inbuf ),
1079                    void (**r_decrypt)( void *c, byte *outbuf, byte *inbuf )
1080                  )
1081 {
1082     static int did_selftest = 0;
1083
1084     if( !did_selftest ) {
1085         const char *s = selftest();
1086         did_selftest = 1;
1087         if( s ) {
1088             log_error ("%s\n", s );
1089             selftest_failed = s;
1090             return NULL;
1091         }
1092     }
1093
1094
1095     if( algo == GCRY_CIPHER_3DES ) {
1096         *keylen = 192;
1097         *blocksize = 8;
1098         *contextsize = sizeof(struct _tripledes_ctx);
1099         *(int  (**)(struct _tripledes_ctx*, byte*, unsigned))r_setkey
1100                                                         = do_tripledes_setkey;
1101         *(void (**)(struct _tripledes_ctx*, byte*, byte*))r_encrypt
1102                                                         = do_tripledes_encrypt;
1103         *(void (**)(struct _tripledes_ctx*, byte*, byte*))r_decrypt
1104                                                         = do_tripledes_decrypt;
1105         return "3DES";
1106     }
1107     else if( algo == GCRY_CIPHER_DES ) {
1108         *keylen = 64;
1109         *blocksize = 8;
1110         *contextsize = sizeof(struct _des_ctx);
1111         *(int  (**)(struct _des_ctx*, byte*, unsigned))r_setkey
1112                                                         = do_des_setkey;
1113         *(void (**)(struct _des_ctx*, byte*, byte*))r_encrypt
1114                                                         = do_des_encrypt;
1115         *(void (**)(struct _des_ctx*, byte*, byte*))r_decrypt
1116                                                         = do_des_decrypt;
1117         return "DES";
1118     }
1119     return NULL;
1120 }
1121