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