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