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