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