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