2003-07-21 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   static const char *selftest_failed;
573   int i;
574
575   if (! initialized)
576     {
577       initialized = 1;
578       selftest_failed = selftest ();
579
580       if (selftest_failed)
581         log_error ("%s\n", selftest_failed);
582     }
583   if (selftest_failed)
584     return GPG_ERR_SELFTEST_FAILED;
585
586   des_key_schedule (key, ctx->encrypt_subkeys);
587   _gcry_burn_stack (32);
588
589   for(i=0; i<32; i+=2)
590     {
591       ctx->decrypt_subkeys[i]   = ctx->encrypt_subkeys[30-i];
592       ctx->decrypt_subkeys[i+1] = ctx->encrypt_subkeys[31-i];
593     }
594
595   return 0;
596 }
597
598
599
600 /*
601  * Electronic Codebook Mode DES encryption/decryption of data according
602  * to 'mode'.
603  */
604 static int
605 des_ecb_crypt (struct _des_ctx *ctx, const byte * from, byte * to, int mode)
606 {
607   u32 left, right, work;
608   u32 *keys;
609
610   keys = mode ? ctx->decrypt_subkeys : ctx->encrypt_subkeys;
611
612   READ_64BIT_DATA (from, left, right)
613   INITIAL_PERMUTATION (left, work, right)
614
615   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
616   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
617   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
618   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
619   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
620   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
621   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
622   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
623
624   FINAL_PERMUTATION (right, work, left)
625   WRITE_64BIT_DATA (to, right, left)
626
627   return 0;
628 }
629
630
631
632 /*
633  * Fill a Triple-DES context with subkeys calculated from two 64bit keys.
634  * Does not check the parity bits of the keys, but simply ignore them.
635  * Does not check for weak keys.
636  */
637 static int
638 tripledes_set2keys (struct _tripledes_ctx *ctx,
639                     const byte * key1,
640                     const byte * key2)
641 {
642   int i;
643
644   des_key_schedule (key1, ctx->encrypt_subkeys);
645   des_key_schedule (key2, &(ctx->decrypt_subkeys[32]));
646   _gcry_burn_stack (32);
647
648   for(i=0; i<32; i+=2)
649     {
650       ctx->decrypt_subkeys[i]    = ctx->encrypt_subkeys[30-i];
651       ctx->decrypt_subkeys[i+1]  = ctx->encrypt_subkeys[31-i];
652
653       ctx->encrypt_subkeys[i+32] = ctx->decrypt_subkeys[62-i];
654       ctx->encrypt_subkeys[i+33] = ctx->decrypt_subkeys[63-i];
655
656       ctx->encrypt_subkeys[i+64] = ctx->encrypt_subkeys[i];
657       ctx->encrypt_subkeys[i+65] = ctx->encrypt_subkeys[i+1];
658
659       ctx->decrypt_subkeys[i+64] = ctx->decrypt_subkeys[i];
660       ctx->decrypt_subkeys[i+65] = ctx->decrypt_subkeys[i+1];
661     }
662
663   return 0;
664 }
665
666
667
668 /*
669  * Fill a Triple-DES context with subkeys calculated from three 64bit keys.
670  * Does not check the parity bits of the keys, but simply ignore them.
671  * Does not check for weak keys.
672  */
673 static int
674 tripledes_set3keys (struct _tripledes_ctx *ctx,
675                     const byte * key1,
676                     const byte * key2,
677                     const byte * key3)
678 {
679   static const char *selftest_failed;
680   int i;
681
682   if (! initialized)
683     {
684       initialized = 1;
685       selftest_failed = selftest ();
686
687       if (selftest_failed)
688         log_error ("%s\n", selftest_failed);
689     }
690   if (selftest_failed)
691     return GPG_ERR_SELFTEST_FAILED;
692
693   des_key_schedule (key1, ctx->encrypt_subkeys);
694   des_key_schedule (key2, &(ctx->decrypt_subkeys[32]));
695   des_key_schedule (key3, &(ctx->encrypt_subkeys[64]));
696   _gcry_burn_stack (32);
697
698   for(i=0; i<32; i+=2)
699     {
700       ctx->decrypt_subkeys[i]    = ctx->encrypt_subkeys[94-i];
701       ctx->decrypt_subkeys[i+1]  = ctx->encrypt_subkeys[95-i];
702
703       ctx->encrypt_subkeys[i+32] = ctx->decrypt_subkeys[62-i];
704       ctx->encrypt_subkeys[i+33] = ctx->decrypt_subkeys[63-i];
705
706       ctx->decrypt_subkeys[i+64] = ctx->encrypt_subkeys[30-i];
707       ctx->decrypt_subkeys[i+65] = ctx->encrypt_subkeys[31-i];
708      }
709
710   return 0;
711 }
712
713
714
715 /*
716  * Electronic Codebook Mode Triple-DES encryption/decryption of data according to 'mode'.
717  * Sometimes this mode is named 'EDE' mode (Encryption-Decryption-Encryption).
718  */
719 static int
720 tripledes_ecb_crypt (struct _tripledes_ctx *ctx, const byte * from, byte * to, int mode)
721 {
722   u32 left, right, work;
723   u32 *keys;
724
725   keys = mode ? ctx->decrypt_subkeys : ctx->encrypt_subkeys;
726
727   READ_64BIT_DATA (from, left, right)
728   INITIAL_PERMUTATION (left, work, right)
729
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   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
738
739   DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys)
740   DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys)
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
748   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
749   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
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
757   FINAL_PERMUTATION (right, work, left)
758   WRITE_64BIT_DATA (to, right, left)
759
760   return 0;
761 }
762
763
764
765
766
767 /*
768  * Check whether the 8 byte key is weak.
769  * Does not check the parity bits of the key but simple ignore them.
770  */
771 static int
772 is_weak_key ( const byte *key )
773 {
774   byte work[8];
775   int i, left, right, middle, cmp_result;
776
777   /* clear parity bits */
778   for(i=0; i<8; ++i)
779      work[i] = key[i] & 0xfe;
780
781   /* binary search in the weak key table */
782   left = 0;
783   right = 63;
784   while(left <= right)
785     {
786       middle = (left + right) / 2;
787
788       if ( !(cmp_result=working_memcmp(work, weak_keys[middle], 8)) )
789           return -1;
790
791       if ( cmp_result > 0 )
792           left = middle + 1;
793       else
794           right = middle - 1;
795     }
796
797   return 0;
798 }
799
800
801
802 /*
803  * Performs a selftest of this DES/Triple-DES implementation.
804  * Returns an string with the error text on failure.
805  * Returns NULL if all is ok.
806  */
807 static const char *
808 selftest (void)
809 {
810   /*
811    * Check if 'u32' is really 32 bits wide. This DES / 3DES implementation
812    * need this.
813    */
814   if (sizeof (u32) != 4)
815        return "Wrong word size for DES configured.";
816
817   /*
818    * DES Maintenance Test
819    */
820   {
821     int i;
822     byte key[8] =
823     {0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
824     byte input[8] =
825     {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
826     byte result[8] =
827     {0x24, 0x6e, 0x9d, 0xb9, 0xc5, 0x50, 0x38, 0x1a};
828     byte temp1[8], temp2[8], temp3[8];
829     des_ctx des;
830
831     for (i = 0; i < 64; ++i)
832       {
833         des_setkey (des, key);
834         des_ecb_encrypt (des, input, temp1);
835         des_ecb_encrypt (des, temp1, temp2);
836         des_setkey (des, temp2);
837         des_ecb_decrypt (des, temp1, temp3);
838         memcpy (key, temp3, 8);
839         memcpy (input, temp1, 8);
840       }
841     if (memcmp (temp3, result, 8))
842       return "DES maintenance test failed.";
843   }
844
845
846   /*
847    * Self made Triple-DES test  (Does somebody known an official test?)
848    */
849   {
850     int i;
851     byte input[8] =
852     {0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10};
853     byte key1[8] =
854     {0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0};
855     byte key2[8] =
856     {0x11, 0x22, 0x33, 0x44, 0xff, 0xaa, 0xcc, 0xdd};
857     byte result[8] =
858     {0x7b, 0x38, 0x3b, 0x23, 0xa2, 0x7d, 0x26, 0xd3};
859
860     tripledes_ctx des3;
861
862     for (i = 0; i < 16; ++i)
863       {
864         tripledes_set2keys (des3, key1, key2);
865         tripledes_ecb_encrypt (des3, input, key1);
866         tripledes_ecb_decrypt (des3, input, key2);
867         tripledes_set3keys (des3, key1, input, key2);
868         tripledes_ecb_encrypt (des3, input, input);
869       }
870     if (memcmp (input, result, 8))
871       return "Triple-DES test failed.";
872   }
873
874     /*
875      * More Triple-DES test.  These are testvectors as used by SSLeay,
876      * thanks to Jeroen C. van Gelderen.
877      */
878     {   struct { byte key[24]; byte plain[8]; byte cipher[8]; } testdata[] = {
879         { { 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
880             0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
881             0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01  },
882           { 0x95,0xF8,0xA5,0xE5,0xDD,0x31,0xD9,0x00  },
883           { 0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00  }
884         },
885
886         { { 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
887             0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
888             0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01  },
889           { 0x9D,0x64,0x55,0x5A,0x9A,0x10,0xB8,0x52, },
890           { 0x00,0x00,0x00,0x10,0x00,0x00,0x00,0x00  }
891         },
892         { { 0x38,0x49,0x67,0x4C,0x26,0x02,0x31,0x9E,
893             0x38,0x49,0x67,0x4C,0x26,0x02,0x31,0x9E,
894             0x38,0x49,0x67,0x4C,0x26,0x02,0x31,0x9E  },
895           { 0x51,0x45,0x4B,0x58,0x2D,0xDF,0x44,0x0A  },
896           { 0x71,0x78,0x87,0x6E,0x01,0xF1,0x9B,0x2A  }
897         },
898         { { 0x04,0xB9,0x15,0xBA,0x43,0xFE,0xB5,0xB6,
899             0x04,0xB9,0x15,0xBA,0x43,0xFE,0xB5,0xB6,
900             0x04,0xB9,0x15,0xBA,0x43,0xFE,0xB5,0xB6  },
901           { 0x42,0xFD,0x44,0x30,0x59,0x57,0x7F,0xA2  },
902           { 0xAF,0x37,0xFB,0x42,0x1F,0x8C,0x40,0x95  }
903         },
904         { { 0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF,
905             0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF,
906             0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF  },
907           { 0x73,0x6F,0x6D,0x65,0x64,0x61,0x74,0x61  },
908           { 0x3D,0x12,0x4F,0xE2,0x19,0x8B,0xA3,0x18  }
909         },
910         { { 0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF,
911             0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
912             0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF  },
913           { 0x73,0x6F,0x6D,0x65,0x64,0x61,0x74,0x61  },
914           { 0xFB,0xAB,0xA1,0xFF,0x9D,0x05,0xE9,0xB1  }
915         },
916         { { 0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF,
917             0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
918             0xFE,0xDC,0xBA,0x98,0x76,0x54,0x32,0x10  },
919           { 0x73,0x6F,0x6D,0x65,0x64,0x61,0x74,0x61  },
920           { 0x18,0xd7,0x48,0xe5,0x63,0x62,0x05,0x72  }
921         },
922         { { 0x03,0x52,0x02,0x07,0x67,0x20,0x82,0x17,
923             0x86,0x02,0x87,0x66,0x59,0x08,0x21,0x98,
924             0x64,0x05,0x6A,0xBD,0xFE,0xA9,0x34,0x57  },
925           { 0x73,0x71,0x75,0x69,0x67,0x67,0x6C,0x65  },
926           { 0xc0,0x7d,0x2a,0x0f,0xa5,0x66,0xfa,0x30  }
927         },
928         { { 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
929             0x80,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
930             0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x02  },
931           { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00  },
932           { 0xe6,0xe6,0xdd,0x5b,0x7e,0x72,0x29,0x74  }
933         },
934         { { 0x10,0x46,0x10,0x34,0x89,0x98,0x80,0x20,
935             0x91,0x07,0xD0,0x15,0x89,0x19,0x01,0x01,
936             0x19,0x07,0x92,0x10,0x98,0x1A,0x01,0x01  },
937           { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00  },
938           { 0xe1,0xef,0x62,0xc3,0x32,0xfe,0x82,0x5b  }
939         }
940         };
941
942         byte            result[8];
943         int             i;
944         static char     error[80];
945         tripledes_ctx   des3;
946
947         for (i=0; i<sizeof(testdata)/sizeof(*testdata); ++i) {
948             tripledes_set3keys (des3, testdata[i].key, testdata[i].key + 8, testdata[i].key + 16);
949
950             tripledes_ecb_encrypt (des3, testdata[i].plain, result);
951             if (memcmp (testdata[i].cipher, result, 8)) {
952                 sprintf (error, "Triple-DES SSLeay test pattern no. %d failend on encryption.", i+1);
953                 return error;
954             }
955
956             tripledes_ecb_decrypt (des3, testdata[i].cipher, result);
957             if (memcmp (testdata[i].plain, result, 8)) {
958                 sprintf (error, "Triple-DES SSLeay test pattern no. %d failend on decryption.", i+1);
959                 return error;
960             }
961         }
962     }
963
964   /*
965    * Check the weak key detection. We simply assume that the table
966    * with weak keys is ok and check every key in the table if it is
967    * detected... (This test is a little bit stupid)
968    */
969   {
970     int i;
971     unsigned char *p;
972     gcry_md_hd_t h;
973
974     if (gcry_md_open (&h, GCRY_MD_SHA1, 0))
975       return "SHA1 not available";
976
977     for (i = 0; i < 64; ++i)
978       gcry_md_write (h, weak_keys[i], 8);
979     p = gcry_md_read (h, GCRY_MD_SHA1);
980     i = memcmp (p, weak_keys_chksum, 20);
981     gcry_md_close (h);
982     if (i)
983       return "weak key table defect";
984
985     for (i = 0; i < 64; ++i)
986         if (!is_weak_key(weak_keys[i]))
987             return "DES weak key detection failed";
988   }
989
990   return 0;
991 }
992
993
994 static gcry_err_code_t
995 do_tripledes_setkey ( void *context, const byte *key, unsigned keylen )
996 {
997   struct _tripledes_ctx *ctx = (struct _tripledes_ctx *) context;
998
999     if( keylen != 24 )
1000         return GPG_ERR_INV_KEYLEN;
1001
1002     tripledes_set3keys ( ctx, key, key+8, key+16);
1003
1004     if( is_weak_key( key ) || is_weak_key( key+8 ) || is_weak_key( key+16 ) ) {
1005         _gcry_burn_stack (64);
1006         return GPG_ERR_WEAK_KEY;
1007     }
1008     _gcry_burn_stack (64);
1009
1010     return GPG_ERR_NO_ERROR;
1011 }
1012
1013
1014 static void
1015 do_tripledes_encrypt( void *context, byte *outbuf, const byte *inbuf )
1016 {
1017   struct _tripledes_ctx *ctx = (struct _tripledes_ctx *) context;
1018
1019   tripledes_ecb_encrypt ( ctx, inbuf, outbuf );
1020   _gcry_burn_stack (32);
1021 }
1022
1023 static void
1024 do_tripledes_decrypt( void *context, byte *outbuf, const byte *inbuf )
1025 {
1026   struct _tripledes_ctx *ctx = (struct _tripledes_ctx *) context;
1027   tripledes_ecb_decrypt ( ctx, inbuf, outbuf );
1028   _gcry_burn_stack (32);
1029 }
1030
1031 static gcry_err_code_t
1032 do_des_setkey (void *context, const byte *key, unsigned keylen)
1033 {
1034   struct _des_ctx *ctx = (struct _des_ctx *) context;
1035
1036   if (keylen != 8)
1037     return GPG_ERR_INV_KEYLEN;
1038
1039   des_setkey (ctx, key);
1040
1041   if (is_weak_key (key)) {
1042     _gcry_burn_stack (64);
1043     return GPG_ERR_WEAK_KEY;
1044   }
1045   _gcry_burn_stack (64);
1046
1047   return GPG_ERR_NO_ERROR;
1048 }
1049
1050
1051 static void
1052 do_des_encrypt( void *context, byte *outbuf, const byte *inbuf )
1053 {
1054   struct _des_ctx *ctx = (struct _des_ctx *) context;
1055
1056   des_ecb_encrypt ( ctx, inbuf, outbuf );
1057   _gcry_burn_stack (32);
1058 }
1059
1060 static void
1061 do_des_decrypt( void *context, byte *outbuf, const byte *inbuf )
1062 {
1063   struct _des_ctx *ctx = (struct _des_ctx *) context;
1064
1065   des_ecb_decrypt ( ctx, inbuf, outbuf );
1066   _gcry_burn_stack (32);
1067 }
1068
1069 gcry_cipher_spec_t cipher_spec_des =
1070   {
1071     "DES", NULL, NULL, 8, 64, sizeof (struct _des_ctx),
1072     do_des_setkey, do_des_encrypt, do_des_decrypt
1073   };
1074
1075 static gcry_cipher_oid_spec_t oids_tripledes[] =
1076   {
1077     { "1.2.840.113549.3.7", GCRY_CIPHER_MODE_CBC },
1078     /* Teletrust specific OID for 3DES. */
1079     { "1.3.36.3.1.3.2.1",   GCRY_CIPHER_MODE_CBC },
1080     { NULL }
1081   };
1082
1083 gcry_cipher_spec_t cipher_spec_tripledes =
1084   {
1085     "3DES", NULL, oids_tripledes, 8, 192, sizeof (struct _tripledes_ctx),
1086     do_tripledes_setkey, do_tripledes_encrypt, do_tripledes_decrypt
1087   };