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