1 /* des.c --- DES and Triple-DES encryption/decryption Algorithm
2 * Copyright (C) 1998-1999, 2001-2007, 2009-2018 Free Software Foundation, Inc.
4 * This file is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published
6 * by the Free Software Foundation; either version 2, or (at your
7 * option) any later version.
9 * This file is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this file; if not, see <https://www.gnu.org/licenses/>.
19 /* Adapted for gnulib by Simon Josefsson, based on Libgcrypt. */
22 * For a description of triple encryption, see:
23 * Bruce Schneier: Applied Cryptography. Second Edition.
24 * John Wiley & Sons, 1996. ISBN 0-471-12845-7. Pages 358 ff.
25 * This implementation is according to the definition of DES in FIPS
26 * PUB 46-2 from December 1993.
28 * Written by Michael Roth <mroth@nessie.de>, September 1998
35 * For DES or Triple-DES encryption/decryption you must initialize a proper
36 * encryption context with a key.
38 * A DES key is 64bit wide but only 56bits of the key are used. The remaining
39 * bits are parity bits and they will _not_ checked in this implementation, but
42 * For Triple-DES you could use either two 64bit keys or three 64bit keys.
43 * The parity bits will _not_ checked, too.
45 * After initializing a context with a key you could use this context to
46 * encrypt or decrypt data in 64bit blocks in Electronic Codebook Mode.
50 * unsigned char key[8];
51 * unsigned char plaintext[8];
52 * unsigned char ciphertext[8];
53 * unsigned char recoverd[8];
56 * // Fill 'key' and 'plaintext' with some data
59 * // Set up the DES encryption context
60 * gl_des_setkey(&context, key);
62 * // Encrypt the plaintext
63 * des_ecb_encrypt(&context, plaintext, ciphertext);
65 * // To recover the original plaintext from ciphertext use:
66 * des_ecb_decrypt(&context, ciphertext, recoverd);
71 * unsigned char key1[8];
72 * unsigned char key2[8];
73 * unsigned char key3[8];
74 * unsigned char plaintext[8];
75 * unsigned char ciphertext[8];
76 * unsigned char recoverd[8];
77 * gl_3des_ctx context;
79 * // If you would like to use two 64bit keys, fill 'key1' and'key2'
80 * // then setup the encryption context:
81 * gl_3des_set2keys(&context, key1, key2);
83 * // To use three 64bit keys with Triple-DES use:
84 * gl_3des_set3keys(&context, key1, key2, key3);
86 * // Encrypting plaintext with Triple-DES
87 * gl_3des_ecb_encrypt(&context, plaintext, ciphertext);
89 * // Decrypting ciphertext to recover the plaintext with Triple-DES
90 * gl_3des_ecb_decrypt(&context, ciphertext, recoverd);
99 #include <string.h> /* memcpy, memcmp */
102 * The s-box values are permuted according to the 'primitive function P'
103 * and are rotated one bit to the left.
105 static const uint32_t sbox1
[64] = {
106 0x01010400, 0x00000000, 0x00010000, 0x01010404, 0x01010004, 0x00010404,
107 0x00000004, 0x00010000, 0x00000400, 0x01010400, 0x01010404, 0x00000400,
108 0x01000404, 0x01010004, 0x01000000, 0x00000004, 0x00000404, 0x01000400,
109 0x01000400, 0x00010400, 0x00010400, 0x01010000, 0x01010000, 0x01000404,
110 0x00010004, 0x01000004, 0x01000004, 0x00010004, 0x00000000, 0x00000404,
111 0x00010404, 0x01000000, 0x00010000, 0x01010404, 0x00000004, 0x01010000,
112 0x01010400, 0x01000000, 0x01000000, 0x00000400, 0x01010004, 0x00010000,
113 0x00010400, 0x01000004, 0x00000400, 0x00000004, 0x01000404, 0x00010404,
114 0x01010404, 0x00010004, 0x01010000, 0x01000404, 0x01000004, 0x00000404,
115 0x00010404, 0x01010400, 0x00000404, 0x01000400, 0x01000400, 0x00000000,
116 0x00010004, 0x00010400, 0x00000000, 0x01010004
119 static const uint32_t sbox2
[64] = {
120 0x80108020, 0x80008000, 0x00008000, 0x00108020, 0x00100000, 0x00000020,
121 0x80100020, 0x80008020, 0x80000020, 0x80108020, 0x80108000, 0x80000000,
122 0x80008000, 0x00100000, 0x00000020, 0x80100020, 0x00108000, 0x00100020,
123 0x80008020, 0x00000000, 0x80000000, 0x00008000, 0x00108020, 0x80100000,
124 0x00100020, 0x80000020, 0x00000000, 0x00108000, 0x00008020, 0x80108000,
125 0x80100000, 0x00008020, 0x00000000, 0x00108020, 0x80100020, 0x00100000,
126 0x80008020, 0x80100000, 0x80108000, 0x00008000, 0x80100000, 0x80008000,
127 0x00000020, 0x80108020, 0x00108020, 0x00000020, 0x00008000, 0x80000000,
128 0x00008020, 0x80108000, 0x00100000, 0x80000020, 0x00100020, 0x80008020,
129 0x80000020, 0x00100020, 0x00108000, 0x00000000, 0x80008000, 0x00008020,
130 0x80000000, 0x80100020, 0x80108020, 0x00108000
133 static const uint32_t sbox3
[64] = {
134 0x00000208, 0x08020200, 0x00000000, 0x08020008, 0x08000200, 0x00000000,
135 0x00020208, 0x08000200, 0x00020008, 0x08000008, 0x08000008, 0x00020000,
136 0x08020208, 0x00020008, 0x08020000, 0x00000208, 0x08000000, 0x00000008,
137 0x08020200, 0x00000200, 0x00020200, 0x08020000, 0x08020008, 0x00020208,
138 0x08000208, 0x00020200, 0x00020000, 0x08000208, 0x00000008, 0x08020208,
139 0x00000200, 0x08000000, 0x08020200, 0x08000000, 0x00020008, 0x00000208,
140 0x00020000, 0x08020200, 0x08000200, 0x00000000, 0x00000200, 0x00020008,
141 0x08020208, 0x08000200, 0x08000008, 0x00000200, 0x00000000, 0x08020008,
142 0x08000208, 0x00020000, 0x08000000, 0x08020208, 0x00000008, 0x00020208,
143 0x00020200, 0x08000008, 0x08020000, 0x08000208, 0x00000208, 0x08020000,
144 0x00020208, 0x00000008, 0x08020008, 0x00020200
147 static const uint32_t sbox4
[64] = {
148 0x00802001, 0x00002081, 0x00002081, 0x00000080, 0x00802080, 0x00800081,
149 0x00800001, 0x00002001, 0x00000000, 0x00802000, 0x00802000, 0x00802081,
150 0x00000081, 0x00000000, 0x00800080, 0x00800001, 0x00000001, 0x00002000,
151 0x00800000, 0x00802001, 0x00000080, 0x00800000, 0x00002001, 0x00002080,
152 0x00800081, 0x00000001, 0x00002080, 0x00800080, 0x00002000, 0x00802080,
153 0x00802081, 0x00000081, 0x00800080, 0x00800001, 0x00802000, 0x00802081,
154 0x00000081, 0x00000000, 0x00000000, 0x00802000, 0x00002080, 0x00800080,
155 0x00800081, 0x00000001, 0x00802001, 0x00002081, 0x00002081, 0x00000080,
156 0x00802081, 0x00000081, 0x00000001, 0x00002000, 0x00800001, 0x00002001,
157 0x00802080, 0x00800081, 0x00002001, 0x00002080, 0x00800000, 0x00802001,
158 0x00000080, 0x00800000, 0x00002000, 0x00802080
161 static const uint32_t sbox5
[64] = {
162 0x00000100, 0x02080100, 0x02080000, 0x42000100, 0x00080000, 0x00000100,
163 0x40000000, 0x02080000, 0x40080100, 0x00080000, 0x02000100, 0x40080100,
164 0x42000100, 0x42080000, 0x00080100, 0x40000000, 0x02000000, 0x40080000,
165 0x40080000, 0x00000000, 0x40000100, 0x42080100, 0x42080100, 0x02000100,
166 0x42080000, 0x40000100, 0x00000000, 0x42000000, 0x02080100, 0x02000000,
167 0x42000000, 0x00080100, 0x00080000, 0x42000100, 0x00000100, 0x02000000,
168 0x40000000, 0x02080000, 0x42000100, 0x40080100, 0x02000100, 0x40000000,
169 0x42080000, 0x02080100, 0x40080100, 0x00000100, 0x02000000, 0x42080000,
170 0x42080100, 0x00080100, 0x42000000, 0x42080100, 0x02080000, 0x00000000,
171 0x40080000, 0x42000000, 0x00080100, 0x02000100, 0x40000100, 0x00080000,
172 0x00000000, 0x40080000, 0x02080100, 0x40000100
175 static const uint32_t sbox6
[64] = {
176 0x20000010, 0x20400000, 0x00004000, 0x20404010, 0x20400000, 0x00000010,
177 0x20404010, 0x00400000, 0x20004000, 0x00404010, 0x00400000, 0x20000010,
178 0x00400010, 0x20004000, 0x20000000, 0x00004010, 0x00000000, 0x00400010,
179 0x20004010, 0x00004000, 0x00404000, 0x20004010, 0x00000010, 0x20400010,
180 0x20400010, 0x00000000, 0x00404010, 0x20404000, 0x00004010, 0x00404000,
181 0x20404000, 0x20000000, 0x20004000, 0x00000010, 0x20400010, 0x00404000,
182 0x20404010, 0x00400000, 0x00004010, 0x20000010, 0x00400000, 0x20004000,
183 0x20000000, 0x00004010, 0x20000010, 0x20404010, 0x00404000, 0x20400000,
184 0x00404010, 0x20404000, 0x00000000, 0x20400010, 0x00000010, 0x00004000,
185 0x20400000, 0x00404010, 0x00004000, 0x00400010, 0x20004010, 0x00000000,
186 0x20404000, 0x20000000, 0x00400010, 0x20004010
189 static const uint32_t sbox7
[64] = {
190 0x00200000, 0x04200002, 0x04000802, 0x00000000, 0x00000800, 0x04000802,
191 0x00200802, 0x04200800, 0x04200802, 0x00200000, 0x00000000, 0x04000002,
192 0x00000002, 0x04000000, 0x04200002, 0x00000802, 0x04000800, 0x00200802,
193 0x00200002, 0x04000800, 0x04000002, 0x04200000, 0x04200800, 0x00200002,
194 0x04200000, 0x00000800, 0x00000802, 0x04200802, 0x00200800, 0x00000002,
195 0x04000000, 0x00200800, 0x04000000, 0x00200800, 0x00200000, 0x04000802,
196 0x04000802, 0x04200002, 0x04200002, 0x00000002, 0x00200002, 0x04000000,
197 0x04000800, 0x00200000, 0x04200800, 0x00000802, 0x00200802, 0x04200800,
198 0x00000802, 0x04000002, 0x04200802, 0x04200000, 0x00200800, 0x00000000,
199 0x00000002, 0x04200802, 0x00000000, 0x00200802, 0x04200000, 0x00000800,
200 0x04000002, 0x04000800, 0x00000800, 0x00200002
203 static const uint32_t sbox8
[64] = {
204 0x10001040, 0x00001000, 0x00040000, 0x10041040, 0x10000000, 0x10001040,
205 0x00000040, 0x10000000, 0x00040040, 0x10040000, 0x10041040, 0x00041000,
206 0x10041000, 0x00041040, 0x00001000, 0x00000040, 0x10040000, 0x10000040,
207 0x10001000, 0x00001040, 0x00041000, 0x00040040, 0x10040040, 0x10041000,
208 0x00001040, 0x00000000, 0x00000000, 0x10040040, 0x10000040, 0x10001000,
209 0x00041040, 0x00040000, 0x00041040, 0x00040000, 0x10041000, 0x00001000,
210 0x00000040, 0x10040040, 0x00001000, 0x00041040, 0x10001000, 0x00000040,
211 0x10000040, 0x10040000, 0x10040040, 0x10000000, 0x00040000, 0x10001040,
212 0x00000000, 0x10041040, 0x00040040, 0x10000040, 0x10040000, 0x10001000,
213 0x10001040, 0x00000000, 0x10041040, 0x00041000, 0x00041000, 0x00001040,
214 0x00001040, 0x00040040, 0x10000000, 0x10041000
218 * These two tables are part of the 'permuted choice 1' function.
219 * In this implementation several speed improvements are done.
221 static const uint32_t leftkey_swap
[16] = {
222 0x00000000, 0x00000001, 0x00000100, 0x00000101,
223 0x00010000, 0x00010001, 0x00010100, 0x00010101,
224 0x01000000, 0x01000001, 0x01000100, 0x01000101,
225 0x01010000, 0x01010001, 0x01010100, 0x01010101
228 static const uint32_t rightkey_swap
[16] = {
229 0x00000000, 0x01000000, 0x00010000, 0x01010000,
230 0x00000100, 0x01000100, 0x00010100, 0x01010100,
231 0x00000001, 0x01000001, 0x00010001, 0x01010001,
232 0x00000101, 0x01000101, 0x00010101, 0x01010101,
236 * Numbers of left shifts per round for encryption subkeys. To
237 * calculate the decryption subkeys we just reverse the ordering of
238 * the calculated encryption subkeys, so there is no need for a
239 * decryption rotate tab.
241 static const unsigned char encrypt_rotate_tab
[16] = {
242 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
246 * Table with weak DES keys sorted in ascending order. In DES there
247 * are 64 known keys which are weak. They are weak because they
248 * produce only one, two or four different subkeys in the subkey
249 * scheduling process. The keys in this table have all their parity
252 static const unsigned char weak_keys
[64][8] = {
253 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /*w */
254 {0x00, 0x00, 0x1e, 0x1e, 0x00, 0x00, 0x0e, 0x0e},
255 {0x00, 0x00, 0xe0, 0xe0, 0x00, 0x00, 0xf0, 0xf0},
256 {0x00, 0x00, 0xfe, 0xfe, 0x00, 0x00, 0xfe, 0xfe},
257 {0x00, 0x1e, 0x00, 0x1e, 0x00, 0x0e, 0x00, 0x0e}, /*sw */
258 {0x00, 0x1e, 0x1e, 0x00, 0x00, 0x0e, 0x0e, 0x00},
259 {0x00, 0x1e, 0xe0, 0xfe, 0x00, 0x0e, 0xf0, 0xfe},
260 {0x00, 0x1e, 0xfe, 0xe0, 0x00, 0x0e, 0xfe, 0xf0},
261 {0x00, 0xe0, 0x00, 0xe0, 0x00, 0xf0, 0x00, 0xf0}, /*sw */
262 {0x00, 0xe0, 0x1e, 0xfe, 0x00, 0xf0, 0x0e, 0xfe},
263 {0x00, 0xe0, 0xe0, 0x00, 0x00, 0xf0, 0xf0, 0x00},
264 {0x00, 0xe0, 0xfe, 0x1e, 0x00, 0xf0, 0xfe, 0x0e},
265 {0x00, 0xfe, 0x00, 0xfe, 0x00, 0xfe, 0x00, 0xfe}, /*sw */
266 {0x00, 0xfe, 0x1e, 0xe0, 0x00, 0xfe, 0x0e, 0xf0},
267 {0x00, 0xfe, 0xe0, 0x1e, 0x00, 0xfe, 0xf0, 0x0e},
268 {0x00, 0xfe, 0xfe, 0x00, 0x00, 0xfe, 0xfe, 0x00},
269 {0x1e, 0x00, 0x00, 0x1e, 0x0e, 0x00, 0x00, 0x0e},
270 {0x1e, 0x00, 0x1e, 0x00, 0x0e, 0x00, 0x0e, 0x00}, /*sw */
271 {0x1e, 0x00, 0xe0, 0xfe, 0x0e, 0x00, 0xf0, 0xfe},
272 {0x1e, 0x00, 0xfe, 0xe0, 0x0e, 0x00, 0xfe, 0xf0},
273 {0x1e, 0x1e, 0x00, 0x00, 0x0e, 0x0e, 0x00, 0x00},
274 {0x1e, 0x1e, 0x1e, 0x1e, 0x0e, 0x0e, 0x0e, 0x0e}, /*w */
275 {0x1e, 0x1e, 0xe0, 0xe0, 0x0e, 0x0e, 0xf0, 0xf0},
276 {0x1e, 0x1e, 0xfe, 0xfe, 0x0e, 0x0e, 0xfe, 0xfe},
277 {0x1e, 0xe0, 0x00, 0xfe, 0x0e, 0xf0, 0x00, 0xfe},
278 {0x1e, 0xe0, 0x1e, 0xe0, 0x0e, 0xf0, 0x0e, 0xf0}, /*sw */
279 {0x1e, 0xe0, 0xe0, 0x1e, 0x0e, 0xf0, 0xf0, 0x0e},
280 {0x1e, 0xe0, 0xfe, 0x00, 0x0e, 0xf0, 0xfe, 0x00},
281 {0x1e, 0xfe, 0x00, 0xe0, 0x0e, 0xfe, 0x00, 0xf0},
282 {0x1e, 0xfe, 0x1e, 0xfe, 0x0e, 0xfe, 0x0e, 0xfe}, /*sw */
283 {0x1e, 0xfe, 0xe0, 0x00, 0x0e, 0xfe, 0xf0, 0x00},
284 {0x1e, 0xfe, 0xfe, 0x1e, 0x0e, 0xfe, 0xfe, 0x0e},
285 {0xe0, 0x00, 0x00, 0xe0, 0xf0, 0x00, 0x00, 0xf0},
286 {0xe0, 0x00, 0x1e, 0xfe, 0xf0, 0x00, 0x0e, 0xfe},
287 {0xe0, 0x00, 0xe0, 0x00, 0xf0, 0x00, 0xf0, 0x00}, /*sw */
288 {0xe0, 0x00, 0xfe, 0x1e, 0xf0, 0x00, 0xfe, 0x0e},
289 {0xe0, 0x1e, 0x00, 0xfe, 0xf0, 0x0e, 0x00, 0xfe},
290 {0xe0, 0x1e, 0x1e, 0xe0, 0xf0, 0x0e, 0x0e, 0xf0},
291 {0xe0, 0x1e, 0xe0, 0x1e, 0xf0, 0x0e, 0xf0, 0x0e}, /*sw */
292 {0xe0, 0x1e, 0xfe, 0x00, 0xf0, 0x0e, 0xfe, 0x00},
293 {0xe0, 0xe0, 0x00, 0x00, 0xf0, 0xf0, 0x00, 0x00},
294 {0xe0, 0xe0, 0x1e, 0x1e, 0xf0, 0xf0, 0x0e, 0x0e},
295 {0xe0, 0xe0, 0xe0, 0xe0, 0xf0, 0xf0, 0xf0, 0xf0}, /*w */
296 {0xe0, 0xe0, 0xfe, 0xfe, 0xf0, 0xf0, 0xfe, 0xfe},
297 {0xe0, 0xfe, 0x00, 0x1e, 0xf0, 0xfe, 0x00, 0x0e},
298 {0xe0, 0xfe, 0x1e, 0x00, 0xf0, 0xfe, 0x0e, 0x00},
299 {0xe0, 0xfe, 0xe0, 0xfe, 0xf0, 0xfe, 0xf0, 0xfe}, /*sw */
300 {0xe0, 0xfe, 0xfe, 0xe0, 0xf0, 0xfe, 0xfe, 0xf0},
301 {0xfe, 0x00, 0x00, 0xfe, 0xfe, 0x00, 0x00, 0xfe},
302 {0xfe, 0x00, 0x1e, 0xe0, 0xfe, 0x00, 0x0e, 0xf0},
303 {0xfe, 0x00, 0xe0, 0x1e, 0xfe, 0x00, 0xf0, 0x0e},
304 {0xfe, 0x00, 0xfe, 0x00, 0xfe, 0x00, 0xfe, 0x00}, /*sw */
305 {0xfe, 0x1e, 0x00, 0xe0, 0xfe, 0x0e, 0x00, 0xf0},
306 {0xfe, 0x1e, 0x1e, 0xfe, 0xfe, 0x0e, 0x0e, 0xfe},
307 {0xfe, 0x1e, 0xe0, 0x00, 0xfe, 0x0e, 0xf0, 0x00},
308 {0xfe, 0x1e, 0xfe, 0x1e, 0xfe, 0x0e, 0xfe, 0x0e}, /*sw */
309 {0xfe, 0xe0, 0x00, 0x1e, 0xfe, 0xf0, 0x00, 0x0e},
310 {0xfe, 0xe0, 0x1e, 0x00, 0xfe, 0xf0, 0x0e, 0x00},
311 {0xfe, 0xe0, 0xe0, 0xfe, 0xfe, 0xf0, 0xf0, 0xfe},
312 {0xfe, 0xe0, 0xfe, 0xe0, 0xfe, 0xf0, 0xfe, 0xf0}, /*sw */
313 {0xfe, 0xfe, 0x00, 0x00, 0xfe, 0xfe, 0x00, 0x00},
314 {0xfe, 0xfe, 0x1e, 0x1e, 0xfe, 0xfe, 0x0e, 0x0e},
315 {0xfe, 0xfe, 0xe0, 0xe0, 0xfe, 0xfe, 0xf0, 0xf0},
316 {0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe} /*w */
320 gl_des_is_weak_key (const char * key
)
323 int i
, left
, right
, middle
, cmp_result
;
325 /* clear parity bits */
326 for (i
= 0; i
< 8; ++i
)
327 work
[i
] = ((unsigned char)key
[i
]) & 0xfe;
329 /* binary search in the weak key table */
332 while (left
<= right
)
334 middle
= (left
+ right
) / 2;
336 if (!(cmp_result
= memcmp (work
, weak_keys
[middle
], 8)))
349 * Macro to swap bits across two words.
351 #define DO_PERMUTATION(a, temp, b, offset, mask) \
352 temp = ((a>>offset) ^ b) & mask; \
358 * This performs the 'initial permutation' of the data to be encrypted
359 * or decrypted. Additionally the resulting two words are rotated one bit
362 #define INITIAL_PERMUTATION(left, temp, right) \
363 DO_PERMUTATION(left, temp, right, 4, 0x0f0f0f0f) \
364 DO_PERMUTATION(left, temp, right, 16, 0x0000ffff) \
365 DO_PERMUTATION(right, temp, left, 2, 0x33333333) \
366 DO_PERMUTATION(right, temp, left, 8, 0x00ff00ff) \
367 right = (right << 1) | (right >> 31); \
368 temp = (left ^ right) & 0xaaaaaaaa; \
371 left = (left << 1) | (left >> 31);
374 * The 'inverse initial permutation'.
376 #define FINAL_PERMUTATION(left, temp, right) \
377 left = (left << 31) | (left >> 1); \
378 temp = (left ^ right) & 0xaaaaaaaa; \
381 right = (right << 31) | (right >> 1); \
382 DO_PERMUTATION(right, temp, left, 8, 0x00ff00ff) \
383 DO_PERMUTATION(right, temp, left, 2, 0x33333333) \
384 DO_PERMUTATION(left, temp, right, 16, 0x0000ffff) \
385 DO_PERMUTATION(left, temp, right, 4, 0x0f0f0f0f)
389 * A full DES round including 'expansion function', 'sbox substitution'
390 * and 'primitive function P' but without swapping the left and right word.
391 * Please note: The data in 'from' and 'to' is already rotated one bit to
392 * the left, done in the initial permutation.
394 #define DES_ROUND(from, to, work, subkey) \
395 work = from ^ *subkey++; \
396 to ^= sbox8[ work & 0x3f ]; \
397 to ^= sbox6[ (work>>8) & 0x3f ]; \
398 to ^= sbox4[ (work>>16) & 0x3f ]; \
399 to ^= sbox2[ (work>>24) & 0x3f ]; \
400 work = ((from << 28) | (from >> 4)) ^ *subkey++; \
401 to ^= sbox7[ work & 0x3f ]; \
402 to ^= sbox5[ (work>>8) & 0x3f ]; \
403 to ^= sbox3[ (work>>16) & 0x3f ]; \
404 to ^= sbox1[ (work>>24) & 0x3f ];
407 * Macros to convert 8 bytes from/to 32bit words.
409 #define READ_64BIT_DATA(data, left, right) \
410 left = (data[0] << 24) | (data[1] << 16) | (data[2] << 8) | data[3]; \
411 right = (data[4] << 24) | (data[5] << 16) | (data[6] << 8) | data[7];
413 #define WRITE_64BIT_DATA(data, left, right) \
414 data[0] = (left >> 24) &0xff; data[1] = (left >> 16) &0xff; \
415 data[2] = (left >> 8) &0xff; data[3] = left &0xff; \
416 data[4] = (right >> 24) &0xff; data[5] = (right >> 16) &0xff; \
417 data[6] = (right >> 8) &0xff; data[7] = right &0xff;
420 * des_key_schedule(): Calculate 16 subkeys pairs (even/odd) for
421 * 16 encryption rounds.
422 * To calculate subkeys for decryption the caller
423 * have to reorder the generated subkeys.
425 * rawkey: 8 Bytes of key data
426 * subkey: Array of at least 32 uint32_ts. Will be filled
427 * with calculated subkeys.
431 des_key_schedule (const char * _rawkey
, uint32_t * subkey
)
433 const unsigned char *rawkey
= (const unsigned char *) _rawkey
;
434 uint32_t left
, right
, work
;
437 READ_64BIT_DATA (rawkey
, left
, right
)
438 DO_PERMUTATION (right
, work
, left
, 4, 0x0f0f0f0f)
439 DO_PERMUTATION (right
, work
, left
, 0, 0x10101010)
440 left
= ((leftkey_swap
[(left
>> 0) & 0xf] << 3)
441 | (leftkey_swap
[(left
>> 8) & 0xf] << 2)
442 | (leftkey_swap
[(left
>> 16) & 0xf] << 1)
443 | (leftkey_swap
[(left
>> 24) & 0xf])
444 | (leftkey_swap
[(left
>> 5) & 0xf] << 7)
445 | (leftkey_swap
[(left
>> 13) & 0xf] << 6)
446 | (leftkey_swap
[(left
>> 21) & 0xf] << 5)
447 | (leftkey_swap
[(left
>> 29) & 0xf] << 4));
451 right
= ((rightkey_swap
[(right
>> 1) & 0xf] << 3)
452 | (rightkey_swap
[(right
>> 9) & 0xf] << 2)
453 | (rightkey_swap
[(right
>> 17) & 0xf] << 1)
454 | (rightkey_swap
[(right
>> 25) & 0xf])
455 | (rightkey_swap
[(right
>> 4) & 0xf] << 7)
456 | (rightkey_swap
[(right
>> 12) & 0xf] << 6)
457 | (rightkey_swap
[(right
>> 20) & 0xf] << 5)
458 | (rightkey_swap
[(right
>> 28) & 0xf] << 4));
462 for (round
= 0; round
< 16; ++round
)
464 left
= ((left
<< encrypt_rotate_tab
[round
])
465 | (left
>> (28 - encrypt_rotate_tab
[round
]))) & 0x0fffffff;
466 right
= ((right
<< encrypt_rotate_tab
[round
])
467 | (right
>> (28 - encrypt_rotate_tab
[round
]))) & 0x0fffffff;
469 *subkey
++ = (((left
<< 4) & 0x24000000)
470 | ((left
<< 28) & 0x10000000)
471 | ((left
<< 14) & 0x08000000)
472 | ((left
<< 18) & 0x02080000)
473 | ((left
<< 6) & 0x01000000)
474 | ((left
<< 9) & 0x00200000)
475 | ((left
>> 1) & 0x00100000)
476 | ((left
<< 10) & 0x00040000)
477 | ((left
<< 2) & 0x00020000)
478 | ((left
>> 10) & 0x00010000)
479 | ((right
>> 13) & 0x00002000)
480 | ((right
>> 4) & 0x00001000)
481 | ((right
<< 6) & 0x00000800)
482 | ((right
>> 1) & 0x00000400)
483 | ((right
>> 14) & 0x00000200)
484 | (right
& 0x00000100)
485 | ((right
>> 5) & 0x00000020)
486 | ((right
>> 10) & 0x00000010)
487 | ((right
>> 3) & 0x00000008)
488 | ((right
>> 18) & 0x00000004)
489 | ((right
>> 26) & 0x00000002)
490 | ((right
>> 24) & 0x00000001));
492 *subkey
++ = (((left
<< 15) & 0x20000000)
493 | ((left
<< 17) & 0x10000000)
494 | ((left
<< 10) & 0x08000000)
495 | ((left
<< 22) & 0x04000000)
496 | ((left
>> 2) & 0x02000000)
497 | ((left
<< 1) & 0x01000000)
498 | ((left
<< 16) & 0x00200000)
499 | ((left
<< 11) & 0x00100000)
500 | ((left
<< 3) & 0x00080000)
501 | ((left
>> 6) & 0x00040000)
502 | ((left
<< 15) & 0x00020000)
503 | ((left
>> 4) & 0x00010000)
504 | ((right
>> 2) & 0x00002000)
505 | ((right
<< 8) & 0x00001000)
506 | ((right
>> 14) & 0x00000808)
507 | ((right
>> 9) & 0x00000400)
508 | ((right
) & 0x00000200)
509 | ((right
<< 7) & 0x00000100)
510 | ((right
>> 7) & 0x00000020)
511 | ((right
>> 3) & 0x00000011)
512 | ((right
<< 2) & 0x00000004)
513 | ((right
>> 21) & 0x00000002));
518 gl_des_setkey (gl_des_ctx
*ctx
, const char * key
)
522 des_key_schedule (key
, ctx
->encrypt_subkeys
);
524 for (i
= 0; i
< 32; i
+= 2)
526 ctx
->decrypt_subkeys
[i
] = ctx
->encrypt_subkeys
[30 - i
];
527 ctx
->decrypt_subkeys
[i
+ 1] = ctx
->encrypt_subkeys
[31 - i
];
532 gl_des_makekey (gl_des_ctx
*ctx
, const char * key
, size_t keylen
)
537 gl_des_setkey (ctx
, key
);
539 return !gl_des_is_weak_key (key
);
543 gl_des_ecb_crypt (gl_des_ctx
*ctx
, const char * _from
, char * _to
, int mode
)
545 const unsigned char *from
= (const unsigned char *) _from
;
546 unsigned char *to
= (unsigned char *) _to
;
547 uint32_t left
, right
, work
;
550 keys
= mode
? ctx
->decrypt_subkeys
: ctx
->encrypt_subkeys
;
552 READ_64BIT_DATA (from
, left
, right
)
553 INITIAL_PERMUTATION (left
, work
, right
)
554 DES_ROUND (right
, left
, work
, keys
) DES_ROUND (left
, right
, work
, keys
)
555 DES_ROUND (right
, left
, work
, keys
) DES_ROUND (left
, right
, work
, keys
)
556 DES_ROUND (right
, left
, work
, keys
) DES_ROUND (left
, right
, work
, keys
)
557 DES_ROUND (right
, left
, work
, keys
) DES_ROUND (left
, right
, work
, keys
)
558 DES_ROUND (right
, left
, work
, keys
) DES_ROUND (left
, right
, work
, keys
)
559 DES_ROUND (right
, left
, work
, keys
) DES_ROUND (left
, right
, work
, keys
)
560 DES_ROUND (right
, left
, work
, keys
) DES_ROUND (left
, right
, work
, keys
)
561 DES_ROUND (right
, left
, work
, keys
) DES_ROUND (left
, right
, work
, keys
)
562 FINAL_PERMUTATION (right
, work
, left
)
563 WRITE_64BIT_DATA (to
, right
, left
)
567 gl_3des_set2keys (gl_3des_ctx
*ctx
, const char * key1
, const char * key2
)
571 des_key_schedule (key1
, ctx
->encrypt_subkeys
);
572 des_key_schedule (key2
, &(ctx
->decrypt_subkeys
[32]));
574 for (i
= 0; i
< 32; i
+= 2)
576 ctx
->decrypt_subkeys
[i
] = ctx
->encrypt_subkeys
[30 - i
];
577 ctx
->decrypt_subkeys
[i
+ 1] = ctx
->encrypt_subkeys
[31 - i
];
579 ctx
->encrypt_subkeys
[i
+ 32] = ctx
->decrypt_subkeys
[62 - i
];
580 ctx
->encrypt_subkeys
[i
+ 33] = ctx
->decrypt_subkeys
[63 - i
];
582 ctx
->encrypt_subkeys
[i
+ 64] = ctx
->encrypt_subkeys
[i
];
583 ctx
->encrypt_subkeys
[i
+ 65] = ctx
->encrypt_subkeys
[i
+ 1];
585 ctx
->decrypt_subkeys
[i
+ 64] = ctx
->decrypt_subkeys
[i
];
586 ctx
->decrypt_subkeys
[i
+ 65] = ctx
->decrypt_subkeys
[i
+ 1];
591 gl_3des_set3keys (gl_3des_ctx
*ctx
, const char * key1
,
592 const char * key2
, const char * key3
)
596 des_key_schedule (key1
, ctx
->encrypt_subkeys
);
597 des_key_schedule (key2
, &(ctx
->decrypt_subkeys
[32]));
598 des_key_schedule (key3
, &(ctx
->encrypt_subkeys
[64]));
600 for (i
= 0; i
< 32; i
+= 2)
602 ctx
->decrypt_subkeys
[i
] = ctx
->encrypt_subkeys
[94 - i
];
603 ctx
->decrypt_subkeys
[i
+ 1] = ctx
->encrypt_subkeys
[95 - i
];
605 ctx
->encrypt_subkeys
[i
+ 32] = ctx
->decrypt_subkeys
[62 - i
];
606 ctx
->encrypt_subkeys
[i
+ 33] = ctx
->decrypt_subkeys
[63 - i
];
608 ctx
->decrypt_subkeys
[i
+ 64] = ctx
->encrypt_subkeys
[30 - i
];
609 ctx
->decrypt_subkeys
[i
+ 65] = ctx
->encrypt_subkeys
[31 - i
];
614 gl_3des_ecb_crypt (gl_3des_ctx
*ctx
,
616 char * _to
, int mode
)
618 const unsigned char *from
= (const unsigned char *) _from
;
619 unsigned char *to
= (unsigned char *) _to
;
620 uint32_t left
, right
, work
;
623 keys
= mode
? ctx
->decrypt_subkeys
: ctx
->encrypt_subkeys
;
625 READ_64BIT_DATA (from
, left
, right
)
626 INITIAL_PERMUTATION (left
, work
, right
)
627 DES_ROUND (right
, left
, work
, keys
) DES_ROUND (left
, right
, work
, keys
)
628 DES_ROUND (right
, left
, work
, keys
) DES_ROUND (left
, right
, work
, keys
)
629 DES_ROUND (right
, left
, work
, keys
) DES_ROUND (left
, right
, work
, keys
)
630 DES_ROUND (right
, left
, work
, keys
) DES_ROUND (left
, right
, work
, keys
)
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 (left
, right
, work
, keys
) DES_ROUND (right
, left
, work
, keys
)
636 DES_ROUND (left
, right
, work
, keys
) DES_ROUND (right
, left
, work
, keys
)
637 DES_ROUND (left
, right
, work
, keys
) DES_ROUND (right
, left
, work
, keys
)
638 DES_ROUND (left
, right
, work
, keys
) DES_ROUND (right
, left
, work
, keys
)
639 DES_ROUND (left
, right
, work
, keys
) DES_ROUND (right
, left
, work
, keys
)
640 DES_ROUND (left
, right
, work
, keys
) DES_ROUND (right
, left
, work
, keys
)
641 DES_ROUND (left
, right
, work
, keys
) DES_ROUND (right
, left
, work
, keys
)
642 DES_ROUND (left
, right
, work
, keys
) DES_ROUND (right
, left
, work
, keys
)
643 DES_ROUND (right
, left
, work
, keys
) DES_ROUND (left
, right
, work
, keys
)
644 DES_ROUND (right
, left
, work
, keys
) DES_ROUND (left
, right
, work
, keys
)
645 DES_ROUND (right
, left
, work
, keys
) DES_ROUND (left
, right
, work
, keys
)
646 DES_ROUND (right
, left
, work
, keys
) DES_ROUND (left
, right
, work
, keys
)
647 DES_ROUND (right
, left
, work
, keys
) DES_ROUND (left
, right
, work
, keys
)
648 DES_ROUND (right
, left
, work
, keys
) DES_ROUND (left
, right
, work
, keys
)
649 DES_ROUND (right
, left
, work
, keys
) DES_ROUND (left
, right
, work
, keys
)
650 DES_ROUND (right
, left
, work
, keys
) DES_ROUND (left
, right
, work
, keys
)
651 FINAL_PERMUTATION (right
, work
, left
)
652 WRITE_64BIT_DATA (to
, right
, left
)
656 gl_3des_makekey (gl_3des_ctx
*ctx
, const char * key
, size_t keylen
)
661 gl_3des_set3keys (ctx
, key
, key
+ 8, key
+ 16);
663 return !(gl_des_is_weak_key (key
)
664 || gl_des_is_weak_key (key
+ 8)
665 || gl_des_is_weak_key (key
+ 16));