Add PowerPC extra CFLAGS also for chacha20-ppc and crc-ppc
[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 omitted.)
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 original 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 #include "cipher-internal.h"
123 #include "cipher-selftest.h"
124
125
126 #define DES_BLOCKSIZE 8
127
128
129 /* USE_AMD64_ASM indicates whether to use AMD64 assembly code. */
130 #undef USE_AMD64_ASM
131 #if defined(__x86_64__) && (defined(HAVE_COMPATIBLE_GCC_AMD64_PLATFORM_AS) || \
132     defined(HAVE_COMPATIBLE_GCC_WIN64_PLATFORM_AS))
133 # define USE_AMD64_ASM 1
134 #endif
135
136 /* Helper macro to force alignment to 16 bytes.  */
137 #ifdef HAVE_GCC_ATTRIBUTE_ALIGNED
138 # define ATTR_ALIGNED_16  __attribute__ ((aligned (16)))
139 #else
140 # define ATTR_ALIGNED_16
141 #endif
142
143 #if defined(__GNUC__) && defined(__GNU_LIBRARY__)
144 # define working_memcmp memcmp
145 #else
146 /*
147  * According to the SunOS man page, memcmp returns indeterminate sign
148  * depending on whether characters are signed or not.
149  */
150 static int
151 working_memcmp( const void *_a, const void *_b, size_t n )
152 {
153     const char *a = _a;
154     const char *b = _b;
155     for( ; n; n--, a++, b++ )
156         if( *a != *b )
157             return (int)(*(byte*)a) - (int)(*(byte*)b);
158     return 0;
159 }
160 #endif
161
162 /*
163  * Encryption/Decryption context of DES
164  */
165 typedef struct _des_ctx
166   {
167     u32 encrypt_subkeys[32];
168     u32 decrypt_subkeys[32];
169   }
170 des_ctx[1];
171
172 /*
173  * Encryption/Decryption context of Triple-DES
174  */
175 typedef struct _tripledes_ctx
176   {
177     u32 encrypt_subkeys[96];
178     u32 decrypt_subkeys[96];
179     struct {
180       int no_weak_key;
181     } flags;
182   }
183 tripledes_ctx[1];
184
185 static void des_key_schedule (const byte *, u32 *);
186 static int des_setkey (struct _des_ctx *, const byte *);
187 static int des_ecb_crypt (struct _des_ctx *, const byte *, byte *, int);
188 static int tripledes_set2keys (struct _tripledes_ctx *,
189                                const byte *, const byte *);
190 static int tripledes_set3keys (struct _tripledes_ctx *,
191                                const byte *, const byte *, const byte *);
192 static int tripledes_ecb_crypt (struct _tripledes_ctx *,
193                                 const byte *, byte *, int);
194 static int is_weak_key ( const byte *key );
195 static const char *selftest (void);
196 static unsigned int do_tripledes_encrypt(void *context, byte *outbuf,
197                                          const byte *inbuf );
198 static unsigned int do_tripledes_decrypt(void *context, byte *outbuf,
199                                          const byte *inbuf );
200 static gcry_err_code_t do_tripledes_setkey(void *context, const byte *key,
201                                            unsigned keylen,
202                                            gcry_cipher_hd_t hd);
203
204 static int initialized;
205
206
207
208
209 /*
210  * The s-box values are permuted according to the 'primitive function P'
211  * and are rotated one bit to the left.
212  */
213 static u32 sbox1[64] =
214 {
215   0x01010400, 0x00000000, 0x00010000, 0x01010404, 0x01010004, 0x00010404, 0x00000004, 0x00010000,
216   0x00000400, 0x01010400, 0x01010404, 0x00000400, 0x01000404, 0x01010004, 0x01000000, 0x00000004,
217   0x00000404, 0x01000400, 0x01000400, 0x00010400, 0x00010400, 0x01010000, 0x01010000, 0x01000404,
218   0x00010004, 0x01000004, 0x01000004, 0x00010004, 0x00000000, 0x00000404, 0x00010404, 0x01000000,
219   0x00010000, 0x01010404, 0x00000004, 0x01010000, 0x01010400, 0x01000000, 0x01000000, 0x00000400,
220   0x01010004, 0x00010000, 0x00010400, 0x01000004, 0x00000400, 0x00000004, 0x01000404, 0x00010404,
221   0x01010404, 0x00010004, 0x01010000, 0x01000404, 0x01000004, 0x00000404, 0x00010404, 0x01010400,
222   0x00000404, 0x01000400, 0x01000400, 0x00000000, 0x00010004, 0x00010400, 0x00000000, 0x01010004
223 };
224
225 static u32 sbox2[64] =
226 {
227   0x80108020, 0x80008000, 0x00008000, 0x00108020, 0x00100000, 0x00000020, 0x80100020, 0x80008020,
228   0x80000020, 0x80108020, 0x80108000, 0x80000000, 0x80008000, 0x00100000, 0x00000020, 0x80100020,
229   0x00108000, 0x00100020, 0x80008020, 0x00000000, 0x80000000, 0x00008000, 0x00108020, 0x80100000,
230   0x00100020, 0x80000020, 0x00000000, 0x00108000, 0x00008020, 0x80108000, 0x80100000, 0x00008020,
231   0x00000000, 0x00108020, 0x80100020, 0x00100000, 0x80008020, 0x80100000, 0x80108000, 0x00008000,
232   0x80100000, 0x80008000, 0x00000020, 0x80108020, 0x00108020, 0x00000020, 0x00008000, 0x80000000,
233   0x00008020, 0x80108000, 0x00100000, 0x80000020, 0x00100020, 0x80008020, 0x80000020, 0x00100020,
234   0x00108000, 0x00000000, 0x80008000, 0x00008020, 0x80000000, 0x80100020, 0x80108020, 0x00108000
235 };
236
237 static u32 sbox3[64] =
238 {
239   0x00000208, 0x08020200, 0x00000000, 0x08020008, 0x08000200, 0x00000000, 0x00020208, 0x08000200,
240   0x00020008, 0x08000008, 0x08000008, 0x00020000, 0x08020208, 0x00020008, 0x08020000, 0x00000208,
241   0x08000000, 0x00000008, 0x08020200, 0x00000200, 0x00020200, 0x08020000, 0x08020008, 0x00020208,
242   0x08000208, 0x00020200, 0x00020000, 0x08000208, 0x00000008, 0x08020208, 0x00000200, 0x08000000,
243   0x08020200, 0x08000000, 0x00020008, 0x00000208, 0x00020000, 0x08020200, 0x08000200, 0x00000000,
244   0x00000200, 0x00020008, 0x08020208, 0x08000200, 0x08000008, 0x00000200, 0x00000000, 0x08020008,
245   0x08000208, 0x00020000, 0x08000000, 0x08020208, 0x00000008, 0x00020208, 0x00020200, 0x08000008,
246   0x08020000, 0x08000208, 0x00000208, 0x08020000, 0x00020208, 0x00000008, 0x08020008, 0x00020200
247 };
248
249 static u32 sbox4[64] =
250 {
251   0x00802001, 0x00002081, 0x00002081, 0x00000080, 0x00802080, 0x00800081, 0x00800001, 0x00002001,
252   0x00000000, 0x00802000, 0x00802000, 0x00802081, 0x00000081, 0x00000000, 0x00800080, 0x00800001,
253   0x00000001, 0x00002000, 0x00800000, 0x00802001, 0x00000080, 0x00800000, 0x00002001, 0x00002080,
254   0x00800081, 0x00000001, 0x00002080, 0x00800080, 0x00002000, 0x00802080, 0x00802081, 0x00000081,
255   0x00800080, 0x00800001, 0x00802000, 0x00802081, 0x00000081, 0x00000000, 0x00000000, 0x00802000,
256   0x00002080, 0x00800080, 0x00800081, 0x00000001, 0x00802001, 0x00002081, 0x00002081, 0x00000080,
257   0x00802081, 0x00000081, 0x00000001, 0x00002000, 0x00800001, 0x00002001, 0x00802080, 0x00800081,
258   0x00002001, 0x00002080, 0x00800000, 0x00802001, 0x00000080, 0x00800000, 0x00002000, 0x00802080
259 };
260
261 static u32 sbox5[64] =
262 {
263   0x00000100, 0x02080100, 0x02080000, 0x42000100, 0x00080000, 0x00000100, 0x40000000, 0x02080000,
264   0x40080100, 0x00080000, 0x02000100, 0x40080100, 0x42000100, 0x42080000, 0x00080100, 0x40000000,
265   0x02000000, 0x40080000, 0x40080000, 0x00000000, 0x40000100, 0x42080100, 0x42080100, 0x02000100,
266   0x42080000, 0x40000100, 0x00000000, 0x42000000, 0x02080100, 0x02000000, 0x42000000, 0x00080100,
267   0x00080000, 0x42000100, 0x00000100, 0x02000000, 0x40000000, 0x02080000, 0x42000100, 0x40080100,
268   0x02000100, 0x40000000, 0x42080000, 0x02080100, 0x40080100, 0x00000100, 0x02000000, 0x42080000,
269   0x42080100, 0x00080100, 0x42000000, 0x42080100, 0x02080000, 0x00000000, 0x40080000, 0x42000000,
270   0x00080100, 0x02000100, 0x40000100, 0x00080000, 0x00000000, 0x40080000, 0x02080100, 0x40000100
271 };
272
273 static u32 sbox6[64] =
274 {
275   0x20000010, 0x20400000, 0x00004000, 0x20404010, 0x20400000, 0x00000010, 0x20404010, 0x00400000,
276   0x20004000, 0x00404010, 0x00400000, 0x20000010, 0x00400010, 0x20004000, 0x20000000, 0x00004010,
277   0x00000000, 0x00400010, 0x20004010, 0x00004000, 0x00404000, 0x20004010, 0x00000010, 0x20400010,
278   0x20400010, 0x00000000, 0x00404010, 0x20404000, 0x00004010, 0x00404000, 0x20404000, 0x20000000,
279   0x20004000, 0x00000010, 0x20400010, 0x00404000, 0x20404010, 0x00400000, 0x00004010, 0x20000010,
280   0x00400000, 0x20004000, 0x20000000, 0x00004010, 0x20000010, 0x20404010, 0x00404000, 0x20400000,
281   0x00404010, 0x20404000, 0x00000000, 0x20400010, 0x00000010, 0x00004000, 0x20400000, 0x00404010,
282   0x00004000, 0x00400010, 0x20004010, 0x00000000, 0x20404000, 0x20000000, 0x00400010, 0x20004010
283 };
284
285 static u32 sbox7[64] =
286 {
287   0x00200000, 0x04200002, 0x04000802, 0x00000000, 0x00000800, 0x04000802, 0x00200802, 0x04200800,
288   0x04200802, 0x00200000, 0x00000000, 0x04000002, 0x00000002, 0x04000000, 0x04200002, 0x00000802,
289   0x04000800, 0x00200802, 0x00200002, 0x04000800, 0x04000002, 0x04200000, 0x04200800, 0x00200002,
290   0x04200000, 0x00000800, 0x00000802, 0x04200802, 0x00200800, 0x00000002, 0x04000000, 0x00200800,
291   0x04000000, 0x00200800, 0x00200000, 0x04000802, 0x04000802, 0x04200002, 0x04200002, 0x00000002,
292   0x00200002, 0x04000000, 0x04000800, 0x00200000, 0x04200800, 0x00000802, 0x00200802, 0x04200800,
293   0x00000802, 0x04000002, 0x04200802, 0x04200000, 0x00200800, 0x00000000, 0x00000002, 0x04200802,
294   0x00000000, 0x00200802, 0x04200000, 0x00000800, 0x04000002, 0x04000800, 0x00000800, 0x00200002
295 };
296
297 static u32 sbox8[64] =
298 {
299   0x10001040, 0x00001000, 0x00040000, 0x10041040, 0x10000000, 0x10001040, 0x00000040, 0x10000000,
300   0x00040040, 0x10040000, 0x10041040, 0x00041000, 0x10041000, 0x00041040, 0x00001000, 0x00000040,
301   0x10040000, 0x10000040, 0x10001000, 0x00001040, 0x00041000, 0x00040040, 0x10040040, 0x10041000,
302   0x00001040, 0x00000000, 0x00000000, 0x10040040, 0x10000040, 0x10001000, 0x00041040, 0x00040000,
303   0x00041040, 0x00040000, 0x10041000, 0x00001000, 0x00000040, 0x10040040, 0x00001000, 0x00041040,
304   0x10001000, 0x00000040, 0x10000040, 0x10040000, 0x10040040, 0x10000000, 0x00040000, 0x10001040,
305   0x00000000, 0x10041040, 0x00040040, 0x10000040, 0x10040000, 0x10001000, 0x10001040, 0x00000000,
306   0x10041040, 0x00041000, 0x00041000, 0x00001040, 0x00001040, 0x00040040, 0x10000000, 0x10041000
307 };
308
309
310 /*
311  * These two tables are part of the 'permuted choice 1' function.
312  * In this implementation several speed improvements are done.
313  */
314 static u32 leftkey_swap[16] =
315 {
316   0x00000000, 0x00000001, 0x00000100, 0x00000101,
317   0x00010000, 0x00010001, 0x00010100, 0x00010101,
318   0x01000000, 0x01000001, 0x01000100, 0x01000101,
319   0x01010000, 0x01010001, 0x01010100, 0x01010101
320 };
321
322 static u32 rightkey_swap[16] =
323 {
324   0x00000000, 0x01000000, 0x00010000, 0x01010000,
325   0x00000100, 0x01000100, 0x00010100, 0x01010100,
326   0x00000001, 0x01000001, 0x00010001, 0x01010001,
327   0x00000101, 0x01000101, 0x00010101, 0x01010101,
328 };
329
330
331
332 /*
333  * Numbers of left shifts per round for encryption subkeys.
334  * To calculate the decryption subkeys we just reverse the
335  * ordering of the calculated encryption subkeys. So their
336  * is no need for a decryption rotate tab.
337  */
338 static byte encrypt_rotate_tab[16] =
339 {
340   1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
341 };
342
343
344
345 /*
346  * Table with weak DES keys sorted in ascending order.
347  * In DES their are 64 known keys which are weak. They are weak
348  * because they produce only one, two or four different
349  * subkeys in the subkey scheduling process.
350  * The keys in this table have all their parity bits cleared.
351  */
352 static byte weak_keys[64][8] =
353 {
354   { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /*w*/
355   { 0x00, 0x00, 0x1e, 0x1e, 0x00, 0x00, 0x0e, 0x0e },
356   { 0x00, 0x00, 0xe0, 0xe0, 0x00, 0x00, 0xf0, 0xf0 },
357   { 0x00, 0x00, 0xfe, 0xfe, 0x00, 0x00, 0xfe, 0xfe },
358   { 0x00, 0x1e, 0x00, 0x1e, 0x00, 0x0e, 0x00, 0x0e }, /*sw*/
359   { 0x00, 0x1e, 0x1e, 0x00, 0x00, 0x0e, 0x0e, 0x00 },
360   { 0x00, 0x1e, 0xe0, 0xfe, 0x00, 0x0e, 0xf0, 0xfe },
361   { 0x00, 0x1e, 0xfe, 0xe0, 0x00, 0x0e, 0xfe, 0xf0 },
362   { 0x00, 0xe0, 0x00, 0xe0, 0x00, 0xf0, 0x00, 0xf0 }, /*sw*/
363   { 0x00, 0xe0, 0x1e, 0xfe, 0x00, 0xf0, 0x0e, 0xfe },
364   { 0x00, 0xe0, 0xe0, 0x00, 0x00, 0xf0, 0xf0, 0x00 },
365   { 0x00, 0xe0, 0xfe, 0x1e, 0x00, 0xf0, 0xfe, 0x0e },
366   { 0x00, 0xfe, 0x00, 0xfe, 0x00, 0xfe, 0x00, 0xfe }, /*sw*/
367   { 0x00, 0xfe, 0x1e, 0xe0, 0x00, 0xfe, 0x0e, 0xf0 },
368   { 0x00, 0xfe, 0xe0, 0x1e, 0x00, 0xfe, 0xf0, 0x0e },
369   { 0x00, 0xfe, 0xfe, 0x00, 0x00, 0xfe, 0xfe, 0x00 },
370   { 0x1e, 0x00, 0x00, 0x1e, 0x0e, 0x00, 0x00, 0x0e },
371   { 0x1e, 0x00, 0x1e, 0x00, 0x0e, 0x00, 0x0e, 0x00 }, /*sw*/
372   { 0x1e, 0x00, 0xe0, 0xfe, 0x0e, 0x00, 0xf0, 0xfe },
373   { 0x1e, 0x00, 0xfe, 0xe0, 0x0e, 0x00, 0xfe, 0xf0 },
374   { 0x1e, 0x1e, 0x00, 0x00, 0x0e, 0x0e, 0x00, 0x00 },
375   { 0x1e, 0x1e, 0x1e, 0x1e, 0x0e, 0x0e, 0x0e, 0x0e }, /*w*/
376   { 0x1e, 0x1e, 0xe0, 0xe0, 0x0e, 0x0e, 0xf0, 0xf0 },
377   { 0x1e, 0x1e, 0xfe, 0xfe, 0x0e, 0x0e, 0xfe, 0xfe },
378   { 0x1e, 0xe0, 0x00, 0xfe, 0x0e, 0xf0, 0x00, 0xfe },
379   { 0x1e, 0xe0, 0x1e, 0xe0, 0x0e, 0xf0, 0x0e, 0xf0 }, /*sw*/
380   { 0x1e, 0xe0, 0xe0, 0x1e, 0x0e, 0xf0, 0xf0, 0x0e },
381   { 0x1e, 0xe0, 0xfe, 0x00, 0x0e, 0xf0, 0xfe, 0x00 },
382   { 0x1e, 0xfe, 0x00, 0xe0, 0x0e, 0xfe, 0x00, 0xf0 },
383   { 0x1e, 0xfe, 0x1e, 0xfe, 0x0e, 0xfe, 0x0e, 0xfe }, /*sw*/
384   { 0x1e, 0xfe, 0xe0, 0x00, 0x0e, 0xfe, 0xf0, 0x00 },
385   { 0x1e, 0xfe, 0xfe, 0x1e, 0x0e, 0xfe, 0xfe, 0x0e },
386   { 0xe0, 0x00, 0x00, 0xe0, 0xf0, 0x00, 0x00, 0xf0 },
387   { 0xe0, 0x00, 0x1e, 0xfe, 0xf0, 0x00, 0x0e, 0xfe },
388   { 0xe0, 0x00, 0xe0, 0x00, 0xf0, 0x00, 0xf0, 0x00 }, /*sw*/
389   { 0xe0, 0x00, 0xfe, 0x1e, 0xf0, 0x00, 0xfe, 0x0e },
390   { 0xe0, 0x1e, 0x00, 0xfe, 0xf0, 0x0e, 0x00, 0xfe },
391   { 0xe0, 0x1e, 0x1e, 0xe0, 0xf0, 0x0e, 0x0e, 0xf0 },
392   { 0xe0, 0x1e, 0xe0, 0x1e, 0xf0, 0x0e, 0xf0, 0x0e }, /*sw*/
393   { 0xe0, 0x1e, 0xfe, 0x00, 0xf0, 0x0e, 0xfe, 0x00 },
394   { 0xe0, 0xe0, 0x00, 0x00, 0xf0, 0xf0, 0x00, 0x00 },
395   { 0xe0, 0xe0, 0x1e, 0x1e, 0xf0, 0xf0, 0x0e, 0x0e },
396   { 0xe0, 0xe0, 0xe0, 0xe0, 0xf0, 0xf0, 0xf0, 0xf0 }, /*w*/
397   { 0xe0, 0xe0, 0xfe, 0xfe, 0xf0, 0xf0, 0xfe, 0xfe },
398   { 0xe0, 0xfe, 0x00, 0x1e, 0xf0, 0xfe, 0x00, 0x0e },
399   { 0xe0, 0xfe, 0x1e, 0x00, 0xf0, 0xfe, 0x0e, 0x00 },
400   { 0xe0, 0xfe, 0xe0, 0xfe, 0xf0, 0xfe, 0xf0, 0xfe }, /*sw*/
401   { 0xe0, 0xfe, 0xfe, 0xe0, 0xf0, 0xfe, 0xfe, 0xf0 },
402   { 0xfe, 0x00, 0x00, 0xfe, 0xfe, 0x00, 0x00, 0xfe },
403   { 0xfe, 0x00, 0x1e, 0xe0, 0xfe, 0x00, 0x0e, 0xf0 },
404   { 0xfe, 0x00, 0xe0, 0x1e, 0xfe, 0x00, 0xf0, 0x0e },
405   { 0xfe, 0x00, 0xfe, 0x00, 0xfe, 0x00, 0xfe, 0x00 }, /*sw*/
406   { 0xfe, 0x1e, 0x00, 0xe0, 0xfe, 0x0e, 0x00, 0xf0 },
407   { 0xfe, 0x1e, 0x1e, 0xfe, 0xfe, 0x0e, 0x0e, 0xfe },
408   { 0xfe, 0x1e, 0xe0, 0x00, 0xfe, 0x0e, 0xf0, 0x00 },
409   { 0xfe, 0x1e, 0xfe, 0x1e, 0xfe, 0x0e, 0xfe, 0x0e }, /*sw*/
410   { 0xfe, 0xe0, 0x00, 0x1e, 0xfe, 0xf0, 0x00, 0x0e },
411   { 0xfe, 0xe0, 0x1e, 0x00, 0xfe, 0xf0, 0x0e, 0x00 },
412   { 0xfe, 0xe0, 0xe0, 0xfe, 0xfe, 0xf0, 0xf0, 0xfe },
413   { 0xfe, 0xe0, 0xfe, 0xe0, 0xfe, 0xf0, 0xfe, 0xf0 }, /*sw*/
414   { 0xfe, 0xfe, 0x00, 0x00, 0xfe, 0xfe, 0x00, 0x00 },
415   { 0xfe, 0xfe, 0x1e, 0x1e, 0xfe, 0xfe, 0x0e, 0x0e },
416   { 0xfe, 0xfe, 0xe0, 0xe0, 0xfe, 0xfe, 0xf0, 0xf0 },
417   { 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe }  /*w*/
418 };
419 static unsigned char weak_keys_chksum[20] = {
420   0xD0, 0xCF, 0x07, 0x38, 0x93, 0x70, 0x8A, 0x83, 0x7D, 0xD7,
421   0x8A, 0x36, 0x65, 0x29, 0x6C, 0x1F, 0x7C, 0x3F, 0xD3, 0x41
422 };
423
424
425
426 /*
427  * Macro to swap bits across two words.
428  */
429 #define DO_PERMUTATION(a, temp, b, offset, mask)        \
430     temp = ((a>>offset) ^ b) & mask;                    \
431     b ^= temp;                                          \
432     a ^= temp<<offset;
433
434
435 /*
436  * This performs the 'initial permutation' of the data to be encrypted
437  * or decrypted. Additionally the resulting two words are rotated one bit
438  * to the left.
439  */
440 #define INITIAL_PERMUTATION(left, temp, right)          \
441     DO_PERMUTATION(left, temp, right, 4, 0x0f0f0f0f)    \
442     DO_PERMUTATION(left, temp, right, 16, 0x0000ffff)   \
443     DO_PERMUTATION(right, temp, left, 2, 0x33333333)    \
444     DO_PERMUTATION(right, temp, left, 8, 0x00ff00ff)    \
445     right =  (right << 1) | (right >> 31);              \
446     temp  =  (left ^ right) & 0xaaaaaaaa;               \
447     right ^= temp;                                      \
448     left  ^= temp;                                      \
449     left  =  (left << 1) | (left >> 31);
450
451 /*
452  * The 'inverse initial permutation'.
453  */
454 #define FINAL_PERMUTATION(left, temp, right)            \
455     left  =  (left << 31) | (left >> 1);                \
456     temp  =  (left ^ right) & 0xaaaaaaaa;               \
457     left  ^= temp;                                      \
458     right ^= temp;                                      \
459     right  =  (right << 31) | (right >> 1);             \
460     DO_PERMUTATION(right, temp, left, 8, 0x00ff00ff)    \
461     DO_PERMUTATION(right, temp, left, 2, 0x33333333)    \
462     DO_PERMUTATION(left, temp, right, 16, 0x0000ffff)   \
463     DO_PERMUTATION(left, temp, right, 4, 0x0f0f0f0f)
464
465
466 /*
467  * A full DES round including 'expansion function', 'sbox substitution'
468  * and 'primitive function P' but without swapping the left and right word.
469  * Please note: The data in 'from' and 'to' is already rotated one bit to
470  * the left, done in the initial permutation.
471  */
472 #define DES_ROUND(from, to, work, subkey)               \
473     work = from ^ *subkey++;                            \
474     to ^= sbox8[  work      & 0x3f ];                   \
475     to ^= sbox6[ (work>>8)  & 0x3f ];                   \
476     to ^= sbox4[ (work>>16) & 0x3f ];                   \
477     to ^= sbox2[ (work>>24) & 0x3f ];                   \
478     work = ((from << 28) | (from >> 4)) ^ *subkey++;    \
479     to ^= sbox7[  work      & 0x3f ];                   \
480     to ^= sbox5[ (work>>8)  & 0x3f ];                   \
481     to ^= sbox3[ (work>>16) & 0x3f ];                   \
482     to ^= sbox1[ (work>>24) & 0x3f ];
483
484 /*
485  * Macros to convert 8 bytes from/to 32bit words.
486  */
487 #define READ_64BIT_DATA(data, left, right)                                 \
488     left = buf_get_be32(data + 0);                                         \
489     right = buf_get_be32(data + 4);
490
491 #define WRITE_64BIT_DATA(data, left, right)                                \
492     buf_put_be32(data + 0, left);                                          \
493     buf_put_be32(data + 4, right);
494
495 /*
496  * Handy macros for encryption and decryption of data
497  */
498 #define des_ecb_encrypt(ctx, from, to)        des_ecb_crypt(ctx, from, to, 0)
499 #define des_ecb_decrypt(ctx, from, to)        des_ecb_crypt(ctx, from, to, 1)
500 #define tripledes_ecb_encrypt(ctx, from, to) tripledes_ecb_crypt(ctx,from,to,0)
501 #define tripledes_ecb_decrypt(ctx, from, to) tripledes_ecb_crypt(ctx,from,to,1)
502
503
504
505
506
507
508 /*
509  * des_key_schedule():    Calculate 16 subkeys pairs (even/odd) for
510  *                        16 encryption rounds.
511  *                        To calculate subkeys for decryption the caller
512  *                        have to reorder the generated subkeys.
513  *
514  *    rawkey:       8 Bytes of key data
515  *    subkey:       Array of at least 32 u32s. Will be filled
516  *                  with calculated subkeys.
517  *
518  */
519 static void
520 des_key_schedule (const byte * rawkey, u32 * subkey)
521 {
522   u32 left, right, work;
523   int round;
524
525   READ_64BIT_DATA (rawkey, left, right)
526
527   DO_PERMUTATION (right, work, left, 4, 0x0f0f0f0f)
528   DO_PERMUTATION (right, work, left, 0, 0x10101010)
529
530   left = ((leftkey_swap[(left >> 0) & 0xf] << 3)
531           | (leftkey_swap[(left >> 8) & 0xf] << 2)
532           | (leftkey_swap[(left >> 16) & 0xf] << 1)
533           | (leftkey_swap[(left >> 24) & 0xf])
534           | (leftkey_swap[(left >> 5) & 0xf] << 7)
535           | (leftkey_swap[(left >> 13) & 0xf] << 6)
536           | (leftkey_swap[(left >> 21) & 0xf] << 5)
537           | (leftkey_swap[(left >> 29) & 0xf] << 4));
538
539   left &= 0x0fffffff;
540
541   right = ((rightkey_swap[(right >> 1) & 0xf] << 3)
542            | (rightkey_swap[(right >> 9) & 0xf] << 2)
543            | (rightkey_swap[(right >> 17) & 0xf] << 1)
544            | (rightkey_swap[(right >> 25) & 0xf])
545            | (rightkey_swap[(right >> 4) & 0xf] << 7)
546            | (rightkey_swap[(right >> 12) & 0xf] << 6)
547            | (rightkey_swap[(right >> 20) & 0xf] << 5)
548            | (rightkey_swap[(right >> 28) & 0xf] << 4));
549
550   right &= 0x0fffffff;
551
552   for (round = 0; round < 16; ++round)
553     {
554       left = ((left << encrypt_rotate_tab[round])
555               | (left >> (28 - encrypt_rotate_tab[round]))) & 0x0fffffff;
556       right = ((right << encrypt_rotate_tab[round])
557                | (right >> (28 - encrypt_rotate_tab[round]))) & 0x0fffffff;
558
559       *subkey++ = (((left << 4) & 0x24000000)
560                    | ((left << 28) & 0x10000000)
561                    | ((left << 14) & 0x08000000)
562                    | ((left << 18) & 0x02080000)
563                    | ((left << 6) & 0x01000000)
564                    | ((left << 9) & 0x00200000)
565                    | ((left >> 1) & 0x00100000)
566                    | ((left << 10) & 0x00040000)
567                    | ((left << 2) & 0x00020000)
568                    | ((left >> 10) & 0x00010000)
569                    | ((right >> 13) & 0x00002000)
570                    | ((right >> 4) & 0x00001000)
571                    | ((right << 6) & 0x00000800)
572                    | ((right >> 1) & 0x00000400)
573                    | ((right >> 14) & 0x00000200)
574                    | (right & 0x00000100)
575                    | ((right >> 5) & 0x00000020)
576                    | ((right >> 10) & 0x00000010)
577                    | ((right >> 3) & 0x00000008)
578                    | ((right >> 18) & 0x00000004)
579                    | ((right >> 26) & 0x00000002)
580                    | ((right >> 24) & 0x00000001));
581
582       *subkey++ = (((left << 15) & 0x20000000)
583                    | ((left << 17) & 0x10000000)
584                    | ((left << 10) & 0x08000000)
585                    | ((left << 22) & 0x04000000)
586                    | ((left >> 2) & 0x02000000)
587                    | ((left << 1) & 0x01000000)
588                    | ((left << 16) & 0x00200000)
589                    | ((left << 11) & 0x00100000)
590                    | ((left << 3) & 0x00080000)
591                    | ((left >> 6) & 0x00040000)
592                    | ((left << 15) & 0x00020000)
593                    | ((left >> 4) & 0x00010000)
594                    | ((right >> 2) & 0x00002000)
595                    | ((right << 8) & 0x00001000)
596                    | ((right >> 14) & 0x00000808)
597                    | ((right >> 9) & 0x00000400)
598                    | ((right) & 0x00000200)
599                    | ((right << 7) & 0x00000100)
600                    | ((right >> 7) & 0x00000020)
601                    | ((right >> 3) & 0x00000011)
602                    | ((right << 2) & 0x00000004)
603                    | ((right >> 21) & 0x00000002));
604     }
605 }
606
607
608 /*
609  * Fill a DES context with subkeys calculated from a 64bit key.
610  * Does not check parity bits, but simply ignore them.
611  * Does not check for weak keys.
612  */
613 static int
614 des_setkey (struct _des_ctx *ctx, const byte * key)
615 {
616   static const char *selftest_failed;
617   int i;
618
619   if (!fips_mode () && !initialized)
620     {
621       initialized = 1;
622       selftest_failed = selftest ();
623
624       if (selftest_failed)
625         log_error ("%s\n", selftest_failed);
626     }
627   if (selftest_failed)
628     return GPG_ERR_SELFTEST_FAILED;
629
630   des_key_schedule (key, ctx->encrypt_subkeys);
631   _gcry_burn_stack (32);
632
633   for(i=0; i<32; i+=2)
634     {
635       ctx->decrypt_subkeys[i]   = ctx->encrypt_subkeys[30-i];
636       ctx->decrypt_subkeys[i+1] = ctx->encrypt_subkeys[31-i];
637     }
638
639   return 0;
640 }
641
642
643
644 /*
645  * Electronic Codebook Mode DES encryption/decryption of data according
646  * to 'mode'.
647  */
648 static int
649 des_ecb_crypt (struct _des_ctx *ctx, const byte * from, byte * to, int mode)
650 {
651   u32 left, right, work;
652   u32 *keys;
653
654   keys = mode ? ctx->decrypt_subkeys : ctx->encrypt_subkeys;
655
656   READ_64BIT_DATA (from, left, right)
657   INITIAL_PERMUTATION (left, work, right)
658
659   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
660   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
661   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
662   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
663   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
664   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
665   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
666   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
667
668   FINAL_PERMUTATION (right, work, left)
669   WRITE_64BIT_DATA (to, right, left)
670
671   return 0;
672 }
673
674
675
676 /*
677  * Fill a Triple-DES context with subkeys calculated from two 64bit keys.
678  * Does not check the parity bits of the keys, but simply ignore them.
679  * Does not check for weak keys.
680  */
681 static int
682 tripledes_set2keys (struct _tripledes_ctx *ctx,
683                     const byte * key1,
684                     const byte * key2)
685 {
686   int i;
687
688   des_key_schedule (key1, ctx->encrypt_subkeys);
689   des_key_schedule (key2, &(ctx->decrypt_subkeys[32]));
690   _gcry_burn_stack (32);
691
692   for(i=0; i<32; i+=2)
693     {
694       ctx->decrypt_subkeys[i]    = ctx->encrypt_subkeys[30-i];
695       ctx->decrypt_subkeys[i+1]  = ctx->encrypt_subkeys[31-i];
696
697       ctx->encrypt_subkeys[i+32] = ctx->decrypt_subkeys[62-i];
698       ctx->encrypt_subkeys[i+33] = ctx->decrypt_subkeys[63-i];
699
700       ctx->encrypt_subkeys[i+64] = ctx->encrypt_subkeys[i];
701       ctx->encrypt_subkeys[i+65] = ctx->encrypt_subkeys[i+1];
702
703       ctx->decrypt_subkeys[i+64] = ctx->decrypt_subkeys[i];
704       ctx->decrypt_subkeys[i+65] = ctx->decrypt_subkeys[i+1];
705     }
706
707   return 0;
708 }
709
710
711
712 /*
713  * Fill a Triple-DES context with subkeys calculated from three 64bit keys.
714  * Does not check the parity bits of the keys, but simply ignore them.
715  * Does not check for weak keys.
716  */
717 static int
718 tripledes_set3keys (struct _tripledes_ctx *ctx,
719                     const byte * key1,
720                     const byte * key2,
721                     const byte * key3)
722 {
723   static const char *selftest_failed;
724   int i;
725
726   if (!fips_mode () && !initialized)
727     {
728       initialized = 1;
729       selftest_failed = selftest ();
730
731       if (selftest_failed)
732         log_error ("%s\n", selftest_failed);
733     }
734   if (selftest_failed)
735     return GPG_ERR_SELFTEST_FAILED;
736
737   des_key_schedule (key1, ctx->encrypt_subkeys);
738   des_key_schedule (key2, &(ctx->decrypt_subkeys[32]));
739   des_key_schedule (key3, &(ctx->encrypt_subkeys[64]));
740   _gcry_burn_stack (32);
741
742   for(i=0; i<32; i+=2)
743     {
744       ctx->decrypt_subkeys[i]    = ctx->encrypt_subkeys[94-i];
745       ctx->decrypt_subkeys[i+1]  = ctx->encrypt_subkeys[95-i];
746
747       ctx->encrypt_subkeys[i+32] = ctx->decrypt_subkeys[62-i];
748       ctx->encrypt_subkeys[i+33] = ctx->decrypt_subkeys[63-i];
749
750       ctx->decrypt_subkeys[i+64] = ctx->encrypt_subkeys[30-i];
751       ctx->decrypt_subkeys[i+65] = ctx->encrypt_subkeys[31-i];
752      }
753
754   return 0;
755 }
756
757
758
759 #ifdef USE_AMD64_ASM
760
761 /* Assembly implementation of triple-DES. */
762 extern void _gcry_3des_amd64_crypt_block(const void *keys, byte *out,
763                                          const byte *in);
764
765 /* These assembly implementations process three blocks in parallel. */
766 extern void _gcry_3des_amd64_ctr_enc(const void *keys, byte *out,
767                                      const byte *in, byte *ctr);
768
769 extern void _gcry_3des_amd64_cbc_dec(const void *keys, byte *out,
770                                      const byte *in, byte *iv);
771
772 extern void _gcry_3des_amd64_cfb_dec(const void *keys, byte *out,
773                                      const byte *in, byte *iv);
774
775 #define TRIPLEDES_ECB_BURN_STACK (8 * sizeof(void *))
776
777
778 /*
779  * Electronic Codebook Mode Triple-DES encryption/decryption of data
780  * according to 'mode'.  Sometimes this mode is named 'EDE' mode
781  * (Encryption-Decryption-Encryption).
782  */
783 static inline int
784 tripledes_ecb_crypt (struct _tripledes_ctx *ctx, const byte * from,
785                      byte * to, int mode)
786 {
787   u32 *keys;
788
789   keys = mode ? ctx->decrypt_subkeys : ctx->encrypt_subkeys;
790
791   _gcry_3des_amd64_crypt_block(keys, to, from);
792
793   return 0;
794 }
795
796 static inline void
797 tripledes_amd64_ctr_enc(const void *keys, byte *out, const byte *in, byte *ctr)
798 {
799   _gcry_3des_amd64_ctr_enc(keys, out, in, ctr);
800 }
801
802 static inline void
803 tripledes_amd64_cbc_dec(const void *keys, byte *out, const byte *in, byte *iv)
804 {
805   _gcry_3des_amd64_cbc_dec(keys, out, in, iv);
806 }
807
808 static inline void
809 tripledes_amd64_cfb_dec(const void *keys, byte *out, const byte *in, byte *iv)
810 {
811   _gcry_3des_amd64_cfb_dec(keys, out, in, iv);
812 }
813
814 #else /*USE_AMD64_ASM*/
815
816 #define TRIPLEDES_ECB_BURN_STACK 32
817
818 /*
819  * Electronic Codebook Mode Triple-DES encryption/decryption of data
820  * according to 'mode'.  Sometimes this mode is named 'EDE' mode
821  * (Encryption-Decryption-Encryption).
822  */
823 static int
824 tripledes_ecb_crypt (struct _tripledes_ctx *ctx, const byte * from,
825                      byte * to, int mode)
826 {
827   u32 left, right, work;
828   u32 *keys;
829
830   keys = mode ? ctx->decrypt_subkeys : ctx->encrypt_subkeys;
831
832   READ_64BIT_DATA (from, left, right)
833   INITIAL_PERMUTATION (left, work, right)
834
835   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
836   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
837   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
838   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
839   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
840   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
841   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
842   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
843
844   DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys)
845   DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys)
846   DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys)
847   DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys)
848   DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys)
849   DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys)
850   DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys)
851   DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys)
852
853   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
854   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
855   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
856   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
857   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
858   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
859   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
860   DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
861
862   FINAL_PERMUTATION (right, work, left)
863   WRITE_64BIT_DATA (to, right, left)
864
865   return 0;
866 }
867
868 #endif /*!USE_AMD64_ASM*/
869
870
871
872 /* Bulk encryption of complete blocks in CTR mode.  This function is only
873    intended for the bulk encryption feature of cipher.c.  CTR is expected to be
874    of size DES_BLOCKSIZE. */
875 void
876 _gcry_3des_ctr_enc(void *context, unsigned char *ctr, void *outbuf_arg,
877                    const void *inbuf_arg, size_t nblocks)
878 {
879   struct _tripledes_ctx *ctx = context;
880   unsigned char *outbuf = outbuf_arg;
881   const unsigned char *inbuf = inbuf_arg;
882   unsigned char tmpbuf[DES_BLOCKSIZE];
883   int burn_stack_depth = TRIPLEDES_ECB_BURN_STACK;
884
885 #ifdef USE_AMD64_ASM
886   {
887     int asm_burn_depth = 9 * sizeof(void *);
888
889     if (nblocks >= 3 && burn_stack_depth < asm_burn_depth)
890       burn_stack_depth = asm_burn_depth;
891
892     /* Process data in 3 block chunks. */
893     while (nblocks >= 3)
894       {
895         tripledes_amd64_ctr_enc(ctx->encrypt_subkeys, outbuf, inbuf, ctr);
896
897         nblocks -= 3;
898         outbuf += 3 * DES_BLOCKSIZE;
899         inbuf  += 3 * DES_BLOCKSIZE;
900       }
901
902     /* Use generic code to handle smaller chunks... */
903   }
904 #endif
905
906   for ( ;nblocks; nblocks-- )
907     {
908       /* Encrypt the counter. */
909       tripledes_ecb_encrypt (ctx, ctr, tmpbuf);
910       /* XOR the input with the encrypted counter and store in output.  */
911       cipher_block_xor(outbuf, tmpbuf, inbuf, DES_BLOCKSIZE);
912       outbuf += DES_BLOCKSIZE;
913       inbuf  += DES_BLOCKSIZE;
914       /* Increment the counter.  */
915       cipher_block_add(ctr, 1, DES_BLOCKSIZE);
916     }
917
918   wipememory(tmpbuf, sizeof(tmpbuf));
919   _gcry_burn_stack(burn_stack_depth);
920 }
921
922
923 /* Bulk decryption of complete blocks in CBC mode.  This function is only
924    intended for the bulk encryption feature of cipher.c. */
925 void
926 _gcry_3des_cbc_dec(void *context, unsigned char *iv, void *outbuf_arg,
927                    const void *inbuf_arg, size_t nblocks)
928 {
929   struct _tripledes_ctx *ctx = context;
930   unsigned char *outbuf = outbuf_arg;
931   const unsigned char *inbuf = inbuf_arg;
932   unsigned char savebuf[DES_BLOCKSIZE];
933   int burn_stack_depth = TRIPLEDES_ECB_BURN_STACK;
934
935 #ifdef USE_AMD64_ASM
936   {
937     int asm_burn_depth = 10 * sizeof(void *);
938
939     if (nblocks >= 3 && burn_stack_depth < asm_burn_depth)
940       burn_stack_depth = asm_burn_depth;
941
942     /* Process data in 3 block chunks. */
943     while (nblocks >= 3)
944       {
945         tripledes_amd64_cbc_dec(ctx->decrypt_subkeys, outbuf, inbuf, iv);
946
947         nblocks -= 3;
948         outbuf += 3 * DES_BLOCKSIZE;
949         inbuf  += 3 * DES_BLOCKSIZE;
950       }
951
952     /* Use generic code to handle smaller chunks... */
953   }
954 #endif
955
956   for ( ;nblocks; nblocks-- )
957     {
958       /* INBUF is needed later and it may be identical to OUTBUF, so store
959          the intermediate result to SAVEBUF.  */
960       tripledes_ecb_decrypt (ctx, inbuf, savebuf);
961
962       cipher_block_xor_n_copy_2(outbuf, savebuf, iv, inbuf, DES_BLOCKSIZE);
963       inbuf += DES_BLOCKSIZE;
964       outbuf += DES_BLOCKSIZE;
965     }
966
967   wipememory(savebuf, sizeof(savebuf));
968   _gcry_burn_stack(burn_stack_depth);
969 }
970
971
972 /* Bulk decryption of complete blocks in CFB mode.  This function is only
973    intended for the bulk encryption feature of cipher.c. */
974 void
975 _gcry_3des_cfb_dec(void *context, unsigned char *iv, void *outbuf_arg,
976                    const void *inbuf_arg, size_t nblocks)
977 {
978   struct _tripledes_ctx *ctx = context;
979   unsigned char *outbuf = outbuf_arg;
980   const unsigned char *inbuf = inbuf_arg;
981   int burn_stack_depth = TRIPLEDES_ECB_BURN_STACK;
982
983 #ifdef USE_AMD64_ASM
984   {
985     int asm_burn_depth = 9 * sizeof(void *);
986
987     if (nblocks >= 3 && burn_stack_depth < asm_burn_depth)
988       burn_stack_depth = asm_burn_depth;
989
990     /* Process data in 3 block chunks. */
991     while (nblocks >= 3)
992       {
993         tripledes_amd64_cfb_dec(ctx->encrypt_subkeys, outbuf, inbuf, iv);
994
995         nblocks -= 3;
996         outbuf += 3 * DES_BLOCKSIZE;
997         inbuf  += 3 * DES_BLOCKSIZE;
998       }
999
1000     /* Use generic code to handle smaller chunks... */
1001   }
1002 #endif
1003
1004   for ( ;nblocks; nblocks-- )
1005     {
1006       tripledes_ecb_encrypt (ctx, iv, iv);
1007       cipher_block_xor_n_copy(outbuf, iv, inbuf, DES_BLOCKSIZE);
1008       outbuf += DES_BLOCKSIZE;
1009       inbuf  += DES_BLOCKSIZE;
1010     }
1011
1012   _gcry_burn_stack(burn_stack_depth);
1013 }
1014
1015
1016 /*
1017  * Check whether the 8 byte key is weak.
1018  * Does not check the parity bits of the key but simple ignore them.
1019  */
1020 static int
1021 is_weak_key ( const byte *key )
1022 {
1023   byte work[8];
1024   int i, left, right, middle, cmp_result;
1025
1026   /* clear parity bits */
1027   for(i=0; i<8; ++i)
1028      work[i] = key[i] & 0xfe;
1029
1030   /* binary search in the weak key table */
1031   left = 0;
1032   right = 63;
1033   while(left <= right)
1034     {
1035       middle = (left + right) / 2;
1036
1037       if ( !(cmp_result=working_memcmp(work, weak_keys[middle], 8)) )
1038           return -1;
1039
1040       if ( cmp_result > 0 )
1041           left = middle + 1;
1042       else
1043           right = middle - 1;
1044     }
1045
1046   return 0;
1047 }
1048
1049
1050 /* Alternative setkey for selftests; need larger key than default. */
1051 static gcry_err_code_t
1052 bulk_selftest_setkey (void *context, const byte *__key, unsigned __keylen,
1053                       gcry_cipher_hd_t hd)
1054 {
1055   static const unsigned char key[24] ATTR_ALIGNED_16 = {
1056       0x66,0x9A,0x00,0x7F,0xC7,0x6A,0x45,0x9F,
1057       0x98,0xBA,0xF9,0x17,0xFE,0xDF,0x95,0x22,
1058       0x18,0x2A,0x39,0x47,0x5E,0x6F,0x75,0x82
1059     };
1060
1061   (void)hd;
1062   (void)__key;
1063   (void)__keylen;
1064
1065   return do_tripledes_setkey(context, key, sizeof(key), NULL);
1066 }
1067
1068
1069 /* Run the self-tests for DES-CTR, tests IV increment of bulk CTR
1070    encryption.  Returns NULL on success. */
1071 static const char *
1072 selftest_ctr (void)
1073 {
1074   const int nblocks = 3+1;
1075   const int blocksize = DES_BLOCKSIZE;
1076   const int context_size = sizeof(struct _tripledes_ctx);
1077
1078   return _gcry_selftest_helper_ctr("3DES", &bulk_selftest_setkey,
1079            &do_tripledes_encrypt, &_gcry_3des_ctr_enc, nblocks, blocksize,
1080            context_size);
1081 }
1082
1083
1084 /* Run the self-tests for DES-CBC, tests bulk CBC decryption.
1085    Returns NULL on success. */
1086 static const char *
1087 selftest_cbc (void)
1088 {
1089   const int nblocks = 3+2;
1090   const int blocksize = DES_BLOCKSIZE;
1091   const int context_size = sizeof(struct _tripledes_ctx);
1092
1093   return _gcry_selftest_helper_cbc("3DES", &bulk_selftest_setkey,
1094            &do_tripledes_encrypt, &_gcry_3des_cbc_dec, nblocks, blocksize,
1095            context_size);
1096 }
1097
1098
1099 /* Run the self-tests for DES-CFB, tests bulk CBC decryption.
1100    Returns NULL on success. */
1101 static const char *
1102 selftest_cfb (void)
1103 {
1104   const int nblocks = 3+2;
1105   const int blocksize = DES_BLOCKSIZE;
1106   const int context_size = sizeof(struct _tripledes_ctx);
1107
1108   return _gcry_selftest_helper_cfb("3DES", &bulk_selftest_setkey,
1109            &do_tripledes_encrypt, &_gcry_3des_cfb_dec, nblocks, blocksize,
1110            context_size);
1111 }
1112
1113
1114 /*
1115  * Performs a selftest of this DES/Triple-DES implementation.
1116  * Returns an string with the error text on failure.
1117  * Returns NULL if all is ok.
1118  */
1119 static const char *
1120 selftest (void)
1121 {
1122   const char *r;
1123
1124   /*
1125    * Check if 'u32' is really 32 bits wide. This DES / 3DES implementation
1126    * need this.
1127    */
1128   if (sizeof (u32) != 4)
1129     return "Wrong word size for DES configured.";
1130
1131   /*
1132    * DES Maintenance Test
1133    */
1134   {
1135     int i;
1136     byte key[8] =
1137       {0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
1138     byte input[8] =
1139       {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
1140     byte result[8] =
1141       {0x24, 0x6e, 0x9d, 0xb9, 0xc5, 0x50, 0x38, 0x1a};
1142     byte temp1[8], temp2[8], temp3[8];
1143     des_ctx des;
1144
1145     for (i = 0; i < 64; ++i)
1146       {
1147         des_setkey (des, key);
1148         des_ecb_encrypt (des, input, temp1);
1149         des_ecb_encrypt (des, temp1, temp2);
1150         des_setkey (des, temp2);
1151         des_ecb_decrypt (des, temp1, temp3);
1152         memcpy (key, temp3, 8);
1153         memcpy (input, temp1, 8);
1154       }
1155     if (memcmp (temp3, result, 8))
1156       return "DES maintenance test failed.";
1157   }
1158
1159
1160   /*
1161    * Self made Triple-DES test  (Does somebody know an official test?)
1162    */
1163   {
1164     int i;
1165     byte input[8] =
1166       {0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10};
1167     byte key1[8] =
1168       {0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0};
1169     byte key2[8] =
1170       {0x11, 0x22, 0x33, 0x44, 0xff, 0xaa, 0xcc, 0xdd};
1171     byte result[8] =
1172       {0x7b, 0x38, 0x3b, 0x23, 0xa2, 0x7d, 0x26, 0xd3};
1173
1174     tripledes_ctx des3;
1175
1176     for (i = 0; i < 16; ++i)
1177       {
1178         tripledes_set2keys (des3, key1, key2);
1179         tripledes_ecb_encrypt (des3, input, key1);
1180         tripledes_ecb_decrypt (des3, input, key2);
1181         tripledes_set3keys (des3, key1, input, key2);
1182         tripledes_ecb_encrypt (des3, input, input);
1183       }
1184     if (memcmp (input, result, 8))
1185       return "Triple-DES test failed.";
1186   }
1187
1188   /*
1189    * More Triple-DES test.  These are testvectors as used by SSLeay,
1190    * thanks to Jeroen C. van Gelderen.
1191    */
1192   {
1193     static const struct { byte key[24]; byte plain[8]; byte cipher[8]; }
1194       testdata[] = {
1195       { { 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1196           0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1197           0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01  },
1198         { 0x95,0xF8,0xA5,0xE5,0xDD,0x31,0xD9,0x00  },
1199         { 0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00  }
1200       },
1201
1202       { { 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1203           0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1204           0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01  },
1205         { 0x9D,0x64,0x55,0x5A,0x9A,0x10,0xB8,0x52, },
1206         { 0x00,0x00,0x00,0x10,0x00,0x00,0x00,0x00  }
1207       },
1208       { { 0x38,0x49,0x67,0x4C,0x26,0x02,0x31,0x9E,
1209           0x38,0x49,0x67,0x4C,0x26,0x02,0x31,0x9E,
1210           0x38,0x49,0x67,0x4C,0x26,0x02,0x31,0x9E  },
1211         { 0x51,0x45,0x4B,0x58,0x2D,0xDF,0x44,0x0A  },
1212         { 0x71,0x78,0x87,0x6E,0x01,0xF1,0x9B,0x2A  }
1213       },
1214       { { 0x04,0xB9,0x15,0xBA,0x43,0xFE,0xB5,0xB6,
1215           0x04,0xB9,0x15,0xBA,0x43,0xFE,0xB5,0xB6,
1216           0x04,0xB9,0x15,0xBA,0x43,0xFE,0xB5,0xB6  },
1217         { 0x42,0xFD,0x44,0x30,0x59,0x57,0x7F,0xA2  },
1218         { 0xAF,0x37,0xFB,0x42,0x1F,0x8C,0x40,0x95  }
1219       },
1220       { { 0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF,
1221           0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF,
1222           0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF  },
1223         { 0x73,0x6F,0x6D,0x65,0x64,0x61,0x74,0x61  },
1224         { 0x3D,0x12,0x4F,0xE2,0x19,0x8B,0xA3,0x18  }
1225       },
1226       { { 0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF,
1227           0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
1228           0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF  },
1229         { 0x73,0x6F,0x6D,0x65,0x64,0x61,0x74,0x61  },
1230         { 0xFB,0xAB,0xA1,0xFF,0x9D,0x05,0xE9,0xB1  }
1231       },
1232       { { 0x01,0x23,0x45,0x67,0x89,0xAB,0xCD,0xEF,
1233           0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
1234           0xFE,0xDC,0xBA,0x98,0x76,0x54,0x32,0x10  },
1235         { 0x73,0x6F,0x6D,0x65,0x64,0x61,0x74,0x61  },
1236         { 0x18,0xd7,0x48,0xe5,0x63,0x62,0x05,0x72  }
1237       },
1238       { { 0x03,0x52,0x02,0x07,0x67,0x20,0x82,0x17,
1239           0x86,0x02,0x87,0x66,0x59,0x08,0x21,0x98,
1240           0x64,0x05,0x6A,0xBD,0xFE,0xA9,0x34,0x57  },
1241         { 0x73,0x71,0x75,0x69,0x67,0x67,0x6C,0x65  },
1242         { 0xc0,0x7d,0x2a,0x0f,0xa5,0x66,0xfa,0x30  }
1243       },
1244       { { 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1245           0x80,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
1246           0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x02  },
1247         { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00  },
1248         { 0xe6,0xe6,0xdd,0x5b,0x7e,0x72,0x29,0x74  }
1249       },
1250       { { 0x10,0x46,0x10,0x34,0x89,0x98,0x80,0x20,
1251           0x91,0x07,0xD0,0x15,0x89,0x19,0x01,0x01,
1252           0x19,0x07,0x92,0x10,0x98,0x1A,0x01,0x01  },
1253         { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00  },
1254         { 0xe1,0xef,0x62,0xc3,0x32,0xfe,0x82,0x5b  }
1255       }
1256     };
1257
1258     byte                result[8];
1259     int         i;
1260     tripledes_ctx       des3;
1261
1262     for (i=0; i<sizeof(testdata)/sizeof(*testdata); ++i)
1263       {
1264         tripledes_set3keys (des3, testdata[i].key,
1265                             testdata[i].key + 8, testdata[i].key + 16);
1266
1267         tripledes_ecb_encrypt (des3, testdata[i].plain, result);
1268         if (memcmp (testdata[i].cipher, result, 8))
1269           return "Triple-DES SSLeay test failed on encryption.";
1270
1271         tripledes_ecb_decrypt (des3, testdata[i].cipher, result);
1272         if (memcmp (testdata[i].plain, result, 8))
1273           return  "Triple-DES SSLeay test failed on decryption.";;
1274       }
1275   }
1276
1277   /*
1278    * Check the weak key detection. We simply assume that the table
1279    * with weak keys is ok and check every key in the table if it is
1280    * detected... (This test is a little bit stupid).
1281    */
1282   {
1283     int i;
1284     unsigned char *p;
1285     gcry_md_hd_t h;
1286
1287     if (_gcry_md_open (&h, GCRY_MD_SHA1, 0))
1288       return "SHA1 not available";
1289
1290     for (i = 0; i < 64; ++i)
1291       _gcry_md_write (h, weak_keys[i], 8);
1292     p = _gcry_md_read (h, GCRY_MD_SHA1);
1293     i = memcmp (p, weak_keys_chksum, 20);
1294     _gcry_md_close (h);
1295     if (i)
1296       return "weak key table defect";
1297
1298     for (i = 0; i < 64; ++i)
1299       if (!is_weak_key(weak_keys[i]))
1300         return "DES weak key detection failed";
1301   }
1302
1303   if ( (r = selftest_cbc ()) )
1304     return r;
1305
1306   if ( (r = selftest_cfb ()) )
1307     return r;
1308
1309   if ( (r = selftest_ctr ()) )
1310     return r;
1311
1312   return 0;
1313 }
1314
1315
1316 static gcry_err_code_t
1317 do_tripledes_setkey ( void *context, const byte *key, unsigned keylen,
1318                       gcry_cipher_hd_t hd )
1319 {
1320   struct _tripledes_ctx *ctx = (struct _tripledes_ctx *) context;
1321
1322   (void)hd;
1323
1324   if( keylen != 24 )
1325     return GPG_ERR_INV_KEYLEN;
1326
1327   tripledes_set3keys ( ctx, key, key+8, key+16);
1328
1329   if (ctx->flags.no_weak_key)
1330     ; /* Detection has been disabled.  */
1331   else if (is_weak_key (key) || is_weak_key (key+8) || is_weak_key (key+16))
1332     {
1333       _gcry_burn_stack (64);
1334       return GPG_ERR_WEAK_KEY;
1335     }
1336   _gcry_burn_stack (64);
1337
1338   return GPG_ERR_NO_ERROR;
1339 }
1340
1341
1342 static gcry_err_code_t
1343 do_tripledes_set_extra_info (void *context, int what,
1344                              const void *buffer, size_t buflen)
1345 {
1346   struct _tripledes_ctx *ctx = (struct _tripledes_ctx *)context;
1347   gpg_err_code_t ec = 0;
1348
1349   (void)buffer;
1350   (void)buflen;
1351
1352   switch (what)
1353     {
1354     case CIPHER_INFO_NO_WEAK_KEY:
1355       ctx->flags.no_weak_key = 1;
1356       break;
1357
1358     default:
1359       ec = GPG_ERR_INV_OP;
1360       break;
1361     }
1362   return ec;
1363 }
1364
1365
1366 static unsigned int
1367 do_tripledes_encrypt( void *context, byte *outbuf, const byte *inbuf )
1368 {
1369   struct _tripledes_ctx *ctx = (struct _tripledes_ctx *) context;
1370
1371   tripledes_ecb_encrypt ( ctx, inbuf, outbuf );
1372   return /*burn_stack*/ TRIPLEDES_ECB_BURN_STACK;
1373 }
1374
1375 static unsigned int
1376 do_tripledes_decrypt( void *context, byte *outbuf, const byte *inbuf )
1377 {
1378   struct _tripledes_ctx *ctx = (struct _tripledes_ctx *) context;
1379   tripledes_ecb_decrypt ( ctx, inbuf, outbuf );
1380   return /*burn_stack*/ TRIPLEDES_ECB_BURN_STACK;
1381 }
1382
1383 static gcry_err_code_t
1384 do_des_setkey (void *context, const byte *key, unsigned keylen,
1385                gcry_cipher_hd_t hd)
1386 {
1387   struct _des_ctx *ctx = (struct _des_ctx *) context;
1388
1389   (void)hd;
1390
1391   if (keylen != 8)
1392     return GPG_ERR_INV_KEYLEN;
1393
1394   des_setkey (ctx, key);
1395
1396   if (is_weak_key (key)) {
1397     _gcry_burn_stack (64);
1398     return GPG_ERR_WEAK_KEY;
1399   }
1400   _gcry_burn_stack (64);
1401
1402   return GPG_ERR_NO_ERROR;
1403 }
1404
1405
1406 static unsigned int
1407 do_des_encrypt( void *context, byte *outbuf, const byte *inbuf )
1408 {
1409   struct _des_ctx *ctx = (struct _des_ctx *) context;
1410
1411   des_ecb_encrypt ( ctx, inbuf, outbuf );
1412   return /*burn_stack*/ (32);
1413 }
1414
1415 static unsigned int
1416 do_des_decrypt( void *context, byte *outbuf, const byte *inbuf )
1417 {
1418   struct _des_ctx *ctx = (struct _des_ctx *) context;
1419
1420   des_ecb_decrypt ( ctx, inbuf, outbuf );
1421   return /*burn_stack*/ (32);
1422 }
1423
1424
1425
1426 \f
1427 /*
1428      Self-test section.
1429  */
1430
1431
1432 /* Selftest for TripleDES.  */
1433 static gpg_err_code_t
1434 selftest_fips (int extended, selftest_report_func_t report)
1435 {
1436   const char *what;
1437   const char *errtxt;
1438
1439   (void)extended; /* No extended tests available.  */
1440
1441   what = "low-level";
1442   errtxt = selftest ();
1443   if (errtxt)
1444     goto failed;
1445
1446   /* The low-level self-tests are quite extensive and thus we can do
1447      without high level tests.  This is also justified because we have
1448      no custom block code implementation for 3des but always use the
1449      standard high level block code.  */
1450
1451   return 0; /* Succeeded. */
1452
1453  failed:
1454   if (report)
1455     report ("cipher", GCRY_CIPHER_3DES, what, errtxt);
1456   return GPG_ERR_SELFTEST_FAILED;
1457 }
1458
1459
1460
1461 /* Run a full self-test for ALGO and return 0 on success.  */
1462 static gpg_err_code_t
1463 run_selftests (int algo, int extended, selftest_report_func_t report)
1464 {
1465   gpg_err_code_t ec;
1466
1467   switch (algo)
1468     {
1469     case GCRY_CIPHER_3DES:
1470       ec = selftest_fips (extended, report);
1471       break;
1472     default:
1473       ec = GPG_ERR_CIPHER_ALGO;
1474       break;
1475
1476     }
1477   return ec;
1478 }
1479
1480
1481 \f
1482 gcry_cipher_spec_t _gcry_cipher_spec_des =
1483   {
1484     GCRY_CIPHER_DES, {0, 0},
1485     "DES", NULL, NULL, 8, 64, sizeof (struct _des_ctx),
1486     do_des_setkey, do_des_encrypt, do_des_decrypt
1487   };
1488
1489 static gcry_cipher_oid_spec_t oids_tripledes[] =
1490   {
1491     { "1.2.840.113549.3.7", GCRY_CIPHER_MODE_CBC },
1492     /* Teletrust specific OID for 3DES. */
1493     { "1.3.36.3.1.3.2.1",   GCRY_CIPHER_MODE_CBC },
1494     /* pbeWithSHAAnd3_KeyTripleDES_CBC */
1495     { "1.2.840.113549.1.12.1.3", GCRY_CIPHER_MODE_CBC },
1496     { NULL }
1497   };
1498
1499 gcry_cipher_spec_t _gcry_cipher_spec_tripledes =
1500   {
1501     GCRY_CIPHER_3DES, {0, 1},
1502     "3DES", NULL, oids_tripledes, 8, 192, sizeof (struct _tripledes_ctx),
1503     do_tripledes_setkey, do_tripledes_encrypt, do_tripledes_decrypt,
1504     NULL, NULL,
1505     run_selftests,
1506     do_tripledes_set_extra_info
1507   };