6611fd3b88e3858ecc9351dc998fefdd2ef52d56
[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     static const struct { byte key[24]; byte plain[8]; byte cipher[8]; }
897       testdata[] = {
898       { { 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
899           0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
900           0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01  },
901         { 0x95,0xF8,0xA5,0xE5,0xDD,0x31,0xD9,0x00  },
902         { 0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00  }
903       },
904
905       { { 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
906           0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
907           0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01  },
908         { 0x9D,0x64,0x55,0x5A,0x9A,0x10,0xB8,0x52, },
909         { 0x00,0x00,0x00,0x10,0x00,0x00,0x00,0x00  }
910       },
911       { { 0x38,0x49,0x67,0x4C,0x26,0x02,0x31,0x9E,
912           0x38,0x49,0x67,0x4C,0x26,0x02,0x31,0x9E,
913           0x38,0x49,0x67,0x4C,0x26,0x02,0x31,0x9E  },
914         { 0x51,0x45,0x4B,0x58,0x2D,0xDF,0x44,0x0A  },
915         { 0x71,0x78,0x87,0x6E,0x01,0xF1,0x9B,0x2A  }
916       },
917       { { 0x04,0xB9,0x15,0xBA,0x43,0xFE,0xB5,0xB6,
918           0x04,0xB9,0x15,0xBA,0x43,0xFE,0xB5,0xB6,
919           0x04,0xB9,0x15,0xBA,0x43,0xFE,0xB5,0xB6  },
920         { 0x42,0xFD,0x44,0x30,0x59,0x57,0x7F,0xA2  },
921         { 0xAF,0x37,0xFB,0x42,0x1F,0x8C,0x40,0x95  }
922       },
923       { { 0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF,
924           0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF,
925           0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF  },
926         { 0x73,0x6F,0x6D,0x65,0x64,0x61,0x74,0x61  },
927         { 0x3D,0x12,0x4F,0xE2,0x19,0x8B,0xA3,0x18  }
928       },
929       { { 0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF,
930           0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
931           0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF  },
932         { 0x73,0x6F,0x6D,0x65,0x64,0x61,0x74,0x61  },
933         { 0xFB,0xAB,0xA1,0xFF,0x9D,0x05,0xE9,0xB1  }
934       },
935       { { 0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF,
936           0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
937           0xFE,0xDC,0xBA,0x98,0x76,0x54,0x32,0x10  },
938         { 0x73,0x6F,0x6D,0x65,0x64,0x61,0x74,0x61  },
939         { 0x18,0xd7,0x48,0xe5,0x63,0x62,0x05,0x72  }
940       },
941       { { 0x03,0x52,0x02,0x07,0x67,0x20,0x82,0x17,
942           0x86,0x02,0x87,0x66,0x59,0x08,0x21,0x98,
943           0x64,0x05,0x6A,0xBD,0xFE,0xA9,0x34,0x57  },
944         { 0x73,0x71,0x75,0x69,0x67,0x67,0x6C,0x65  },
945         { 0xc0,0x7d,0x2a,0x0f,0xa5,0x66,0xfa,0x30  }
946       },
947       { { 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
948           0x80,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
949           0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x02  },
950         { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00  },
951         { 0xe6,0xe6,0xdd,0x5b,0x7e,0x72,0x29,0x74  }
952       },
953       { { 0x10,0x46,0x10,0x34,0x89,0x98,0x80,0x20,
954           0x91,0x07,0xD0,0x15,0x89,0x19,0x01,0x01,
955           0x19,0x07,0x92,0x10,0x98,0x1A,0x01,0x01  },
956         { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00  },
957         { 0xe1,0xef,0x62,0xc3,0x32,0xfe,0x82,0x5b  }
958       }
959     };
960
961     byte                result[8];
962     int         i;
963     tripledes_ctx       des3;
964
965     for (i=0; i<sizeof(testdata)/sizeof(*testdata); ++i)
966       {
967         tripledes_set3keys (des3, testdata[i].key,
968                             testdata[i].key + 8, testdata[i].key + 16);
969
970         tripledes_ecb_encrypt (des3, testdata[i].plain, result);
971         if (memcmp (testdata[i].cipher, result, 8))
972           return "Triple-DES SSLeay test failed on encryption.";
973
974         tripledes_ecb_decrypt (des3, testdata[i].cipher, result);
975         if (memcmp (testdata[i].plain, result, 8))
976           return  "Triple-DES SSLeay test failed on decryption.";;
977       }
978   }
979
980   /*
981    * Check the weak key detection. We simply assume that the table
982    * with weak keys is ok and check every key in the table if it is
983    * detected... (This test is a little bit stupid).
984    */
985   {
986     int i;
987     unsigned char *p;
988     gcry_md_hd_t h;
989
990     if (_gcry_md_open (&h, GCRY_MD_SHA1, 0))
991       return "SHA1 not available";
992
993     for (i = 0; i < 64; ++i)
994       _gcry_md_write (h, weak_keys[i], 8);
995     p = _gcry_md_read (h, GCRY_MD_SHA1);
996     i = memcmp (p, weak_keys_chksum, 20);
997     _gcry_md_close (h);
998     if (i)
999       return "weak key table defect";
1000
1001     for (i = 0; i < 64; ++i)
1002       if (!is_weak_key(weak_keys[i]))
1003         return "DES weak key detection failed";
1004   }
1005
1006   return 0;
1007 }
1008
1009
1010 static gcry_err_code_t
1011 do_tripledes_setkey ( void *context, const byte *key, unsigned keylen )
1012 {
1013   struct _tripledes_ctx *ctx = (struct _tripledes_ctx *) context;
1014
1015   if( keylen != 24 )
1016     return GPG_ERR_INV_KEYLEN;
1017
1018   tripledes_set3keys ( ctx, key, key+8, key+16);
1019
1020   if (ctx->flags.no_weak_key)
1021     ; /* Detection has been disabled.  */
1022   else if (is_weak_key (key) || is_weak_key (key+8) || is_weak_key (key+16))
1023     {
1024       _gcry_burn_stack (64);
1025       return GPG_ERR_WEAK_KEY;
1026     }
1027   _gcry_burn_stack (64);
1028
1029   return GPG_ERR_NO_ERROR;
1030 }
1031
1032
1033 static gcry_err_code_t
1034 do_tripledes_set_extra_info (void *context, int what,
1035                              const void *buffer, size_t buflen)
1036 {
1037   struct _tripledes_ctx *ctx = (struct _tripledes_ctx *)context;
1038   gpg_err_code_t ec = 0;
1039
1040   (void)buffer;
1041   (void)buflen;
1042
1043   switch (what)
1044     {
1045     case CIPHER_INFO_NO_WEAK_KEY:
1046       ctx->flags.no_weak_key = 1;
1047       break;
1048
1049     default:
1050       ec = GPG_ERR_INV_OP;
1051       break;
1052     }
1053   return ec;
1054 }
1055
1056
1057 static unsigned int
1058 do_tripledes_encrypt( void *context, byte *outbuf, const byte *inbuf )
1059 {
1060   struct _tripledes_ctx *ctx = (struct _tripledes_ctx *) context;
1061
1062   tripledes_ecb_encrypt ( ctx, inbuf, outbuf );
1063   return /*burn_stack*/ (32);
1064 }
1065
1066 static unsigned int
1067 do_tripledes_decrypt( void *context, byte *outbuf, const byte *inbuf )
1068 {
1069   struct _tripledes_ctx *ctx = (struct _tripledes_ctx *) context;
1070   tripledes_ecb_decrypt ( ctx, inbuf, outbuf );
1071   return /*burn_stack*/ (32);
1072 }
1073
1074 static gcry_err_code_t
1075 do_des_setkey (void *context, const byte *key, unsigned keylen)
1076 {
1077   struct _des_ctx *ctx = (struct _des_ctx *) context;
1078
1079   if (keylen != 8)
1080     return GPG_ERR_INV_KEYLEN;
1081
1082   des_setkey (ctx, key);
1083
1084   if (is_weak_key (key)) {
1085     _gcry_burn_stack (64);
1086     return GPG_ERR_WEAK_KEY;
1087   }
1088   _gcry_burn_stack (64);
1089
1090   return GPG_ERR_NO_ERROR;
1091 }
1092
1093
1094 static unsigned int
1095 do_des_encrypt( void *context, byte *outbuf, const byte *inbuf )
1096 {
1097   struct _des_ctx *ctx = (struct _des_ctx *) context;
1098
1099   des_ecb_encrypt ( ctx, inbuf, outbuf );
1100   return /*burn_stack*/ (32);
1101 }
1102
1103 static unsigned int
1104 do_des_decrypt( void *context, byte *outbuf, const byte *inbuf )
1105 {
1106   struct _des_ctx *ctx = (struct _des_ctx *) context;
1107
1108   des_ecb_decrypt ( ctx, inbuf, outbuf );
1109   return /*burn_stack*/ (32);
1110 }
1111
1112
1113
1114 \f
1115 /*
1116      Self-test section.
1117  */
1118
1119
1120 /* Selftest for TripleDES.  */
1121 static gpg_err_code_t
1122 selftest_fips (int extended, selftest_report_func_t report)
1123 {
1124   const char *what;
1125   const char *errtxt;
1126
1127   (void)extended; /* No extended tests available.  */
1128
1129   what = "low-level";
1130   errtxt = selftest ();
1131   if (errtxt)
1132     goto failed;
1133
1134   /* The low-level self-tests are quite extensive and thus we can do
1135      without high level tests.  This is also justified because we have
1136      no custom block code implementation for 3des but always use the
1137      standard high level block code.  */
1138
1139   return 0; /* Succeeded. */
1140
1141  failed:
1142   if (report)
1143     report ("cipher", GCRY_CIPHER_3DES, what, errtxt);
1144   return GPG_ERR_SELFTEST_FAILED;
1145 }
1146
1147
1148
1149 /* Run a full self-test for ALGO and return 0 on success.  */
1150 static gpg_err_code_t
1151 run_selftests (int algo, int extended, selftest_report_func_t report)
1152 {
1153   gpg_err_code_t ec;
1154
1155   switch (algo)
1156     {
1157     case GCRY_CIPHER_3DES:
1158       ec = selftest_fips (extended, report);
1159       break;
1160     default:
1161       ec = GPG_ERR_CIPHER_ALGO;
1162       break;
1163
1164     }
1165   return ec;
1166 }
1167
1168
1169 \f
1170 gcry_cipher_spec_t _gcry_cipher_spec_des =
1171   {
1172     GCRY_CIPHER_DES, {0, 0},
1173     "DES", NULL, NULL, 8, 64, sizeof (struct _des_ctx),
1174     do_des_setkey, do_des_encrypt, do_des_decrypt
1175   };
1176
1177 static gcry_cipher_oid_spec_t oids_tripledes[] =
1178   {
1179     { "1.2.840.113549.3.7", GCRY_CIPHER_MODE_CBC },
1180     /* Teletrust specific OID for 3DES. */
1181     { "1.3.36.3.1.3.2.1",   GCRY_CIPHER_MODE_CBC },
1182     /* pbeWithSHAAnd3_KeyTripleDES_CBC */
1183     { "1.2.840.113549.1.12.1.3", GCRY_CIPHER_MODE_CBC },
1184     { NULL }
1185   };
1186
1187 gcry_cipher_spec_t _gcry_cipher_spec_tripledes =
1188   {
1189     GCRY_CIPHER_3DES, {0, 1},
1190     "3DES", NULL, oids_tripledes, 8, 192, sizeof (struct _tripledes_ctx),
1191     do_tripledes_setkey, do_tripledes_encrypt, do_tripledes_decrypt,
1192     NULL, NULL,
1193     run_selftests,
1194     do_tripledes_set_extra_info
1195   };