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