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