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