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