← Back to branch summary

~hamo/ubuntu/precise/grub2/grub2.hi_res

« back to all changes in this revision

Viewing changes to lib/libgcrypt/cipher/des.c

  • Committer: Bazaar Package Importer
  • Author(s): Colin Watson, Colin Watson, Evan Broder, Mario Limonciello
  • Date: 2010-11-24 13:59:55 UTC
  • mfrom: (1.17.6 upstream) (17.6.15 experimental)
  • Revision ID: james.westby@ubuntu.com-20101124135955-r6ii5sepayr7jt53
Tags: 1.99~20101124-1ubuntu1
https://launchpad.net/bugs/677758
[ Colin Watson ]
* Resynchronise with Debian experimental.  Remaining changes:
  - Adjust for default Ubuntu boot options ("quiet splash").
  - Default to hiding the menu; holding down Shift at boot will show it.
  - Set a monochromatic theme for Ubuntu.
  - Apply Ubuntu GRUB Legacy changes to legacy update-grub script: title,
    recovery mode, quiet option, tweak how memtest86+ is displayed, and
    use UUIDs where appropriate.
  - Fix backslash-escaping in merge_debconf_into_conf.
  - Remove "GNU/Linux" from default distributor string.
  - Add crashkernel= options if kdump and makedumpfile are available.
  - If other operating systems are installed, then automatically unhide
    the menu.  Otherwise, if GRUB_HIDDEN_TIMEOUT is 0, then use keystatus
    if available to check whether Shift is pressed.  If it is, show the
    menu, otherwise boot immediately.  If keystatus is not available, then
    fall back to a short delay interruptible with Escape.
  - Allow Shift to interrupt 'sleep --interruptible'.
  - Don't display introductory message about line editing unless we're
    actually offering a shell prompt.  Don't clear the screen just before
    booting if we never drew the menu in the first place.
  - Remove some verbose messages printed before reading the configuration
    file.
  - Suppress progress messages as the kernel and initrd load for
    non-recovery kernel menu entries.
  - Change prepare_grub_to_access_device to handle filesystems
    loop-mounted on file images.
  - Ignore devices loop-mounted from files in 10_linux.
  - Show the boot menu if the previous boot failed, that is if it failed
    to get to the end of one of the normal runlevels.
  - Don't generate /boot/grub/device.map during grub-install or
    grub-mkconfig by default.
  - Adjust upgrade version checks for Ubuntu.
  - Don't display "GRUB loading" unless Shift is held down.
  - Adjust versions of grub-doc and grub-legacy-doc conflicts to tolerate
    our backport of the grub-doc split.
  - Fix LVM/RAID probing in the absence of /boot/grub/device.map.
  - Look for .mo files in /usr/share/locale-langpack as well, in
    preference.
  - Make sure GRUB_TIMEOUT isn't quoted unnecessarily.
  - Probe all devices in 'grub-probe --target=drive' if
    /boot/grub/device.map is missing.
  - Build-depend on qemu-kvm rather than qemu-system for grub-pc tests.
  - Use qemu rather than qemu-system-i386.
  - Program vesafb on BIOS systems rather than efifb.
  - Add a grub-rescue-efi-amd64 package containing a rescue CD-ROM image
    for EFI-AMD64.
  - On Wubi, don't ask for an install device, but just update wubildr
    using the diverted grub-install.
  - When embedding the core image in a post-MBR gap, check for and avoid
    sectors matching any of a list of known signatures.
  - Disable video_bochs and video_cirrus on PC BIOS systems, as probing
    PCI space seems to break on some systems.
* Downgrade "ACPI shutdown failed" error to a debug message, since it can
  cause spurious test failures.

[ Evan Broder ]
* Enable lua from grub-extras.
* Incorporate the bitop library into lua.
* Add enum_pci function to grub module in lua.
* Switch back to gfxpayload=keep by default, unless the video hardware
  is known to not support it.

[ Mario Limonciello ]
* Built part_msdos and vfat into bootx64.efi (LP: #677758)

Show diffs side-by-side

added added

removed removed

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