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