2 * DES encryption/decryption
3 * Copyright (c) 2007 Reimar Doeffinger
5 * This file is part of Libav.
7 * Libav is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * Libav 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 GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "intreadwrite.h"
30 #if !FF_API_CRYPTO_CONTEXT
32 uint64_t round_keys[3][16];
37 #define T(a, b, c, d, e, f, g, h) 64 - a, 64 - b, 64 - c, 64 - d, 64 - e, 64 - f, 64 - g, 64 - h
38 static const uint8_t IP_shuffle[] = {
39 T(58, 50, 42, 34, 26, 18, 10, 2),
40 T(60, 52, 44, 36, 28, 20, 12, 4),
41 T(62, 54, 46, 38, 30, 22, 14, 6),
42 T(64, 56, 48, 40, 32, 24, 16, 8),
43 T(57, 49, 41, 33, 25, 17, 9, 1),
44 T(59, 51, 43, 35, 27, 19, 11, 3),
45 T(61, 53, 45, 37, 29, 21, 13, 5),
46 T(63, 55, 47, 39, 31, 23, 15, 7)
50 #if CONFIG_SMALL || defined(GENTABLES)
51 #define T(a, b, c, d) 32 - a, 32 - b, 32 - c, 32 - d
52 static const uint8_t P_shuffle[] = {
65 #define T(a, b, c, d, e, f, g) 64 - a, 64 - b, 64 - c, 64 - d, 64 - e, 64 - f, 64 - g
66 static const uint8_t PC1_shuffle[] = {
67 T(57, 49, 41, 33, 25, 17, 9),
68 T( 1, 58, 50, 42, 34, 26, 18),
69 T(10, 2, 59, 51, 43, 35, 27),
70 T(19, 11, 3, 60, 52, 44, 36),
71 T(63, 55, 47, 39, 31, 23, 15),
72 T( 7, 62, 54, 46, 38, 30, 22),
73 T(14, 6, 61, 53, 45, 37, 29),
74 T(21, 13, 5, 28, 20, 12, 4)
78 #define T(a, b, c, d, e, f) 56 - a, 56 - b, 56 - c, 56 - d, 56 - e, 56 - f
79 static const uint8_t PC2_shuffle[] = {
80 T(14, 17, 11, 24, 1, 5),
81 T( 3, 28, 15, 6, 21, 10),
82 T(23, 19, 12, 4, 26, 8),
83 T(16, 7, 27, 20, 13, 2),
84 T(41, 52, 31, 37, 47, 55),
85 T(30, 40, 51, 45, 33, 48),
86 T(44, 49, 39, 56, 34, 53),
87 T(46, 42, 50, 36, 29, 32)
92 static const uint8_t S_boxes[8][32] = {
93 { 0x0e, 0xf4, 0x7d, 0x41, 0xe2, 0x2f, 0xdb, 0x18, 0xa3, 0x6a, 0xc6, 0xbc, 0x95, 0x59, 0x30, 0x87,
94 0xf4, 0xc1, 0x8e, 0x28, 0x4d, 0x96, 0x12, 0x7b, 0x5f, 0xbc, 0x39, 0xe7, 0xa3, 0x0a, 0x65, 0xd0, },
95 { 0x3f, 0xd1, 0x48, 0x7e, 0xf6, 0x2b, 0x83, 0xe4, 0xc9, 0x07, 0x12, 0xad, 0x6c, 0x90, 0xb5, 0x5a,
96 0xd0, 0x8e, 0xa7, 0x1b, 0x3a, 0xf4, 0x4d, 0x21, 0xb5, 0x68, 0x7c, 0xc6, 0x09, 0x53, 0xe2, 0x9f, },
97 { 0xda, 0x70, 0x09, 0x9e, 0x36, 0x43, 0x6f, 0xa5, 0x21, 0x8d, 0x5c, 0xe7, 0xcb, 0xb4, 0xf2, 0x18,
98 0x1d, 0xa6, 0xd4, 0x09, 0x68, 0x9f, 0x83, 0x70, 0x4b, 0xf1, 0xe2, 0x3c, 0xb5, 0x5a, 0x2e, 0xc7, },
99 { 0xd7, 0x8d, 0xbe, 0x53, 0x60, 0xf6, 0x09, 0x3a, 0x41, 0x72, 0x28, 0xc5, 0x1b, 0xac, 0xe4, 0x9f,
100 0x3a, 0xf6, 0x09, 0x60, 0xac, 0x1b, 0xd7, 0x8d, 0x9f, 0x41, 0x53, 0xbe, 0xc5, 0x72, 0x28, 0xe4, },
101 { 0xe2, 0xbc, 0x24, 0xc1, 0x47, 0x7a, 0xdb, 0x16, 0x58, 0x05, 0xf3, 0xaf, 0x3d, 0x90, 0x8e, 0x69,
102 0xb4, 0x82, 0xc1, 0x7b, 0x1a, 0xed, 0x27, 0xd8, 0x6f, 0xf9, 0x0c, 0x95, 0xa6, 0x43, 0x50, 0x3e, },
103 { 0xac, 0xf1, 0x4a, 0x2f, 0x79, 0xc2, 0x96, 0x58, 0x60, 0x1d, 0xd3, 0xe4, 0x0e, 0xb7, 0x35, 0x8b,
104 0x49, 0x3e, 0x2f, 0xc5, 0x92, 0x58, 0xfc, 0xa3, 0xb7, 0xe0, 0x14, 0x7a, 0x61, 0x0d, 0x8b, 0xd6, },
105 { 0xd4, 0x0b, 0xb2, 0x7e, 0x4f, 0x90, 0x18, 0xad, 0xe3, 0x3c, 0x59, 0xc7, 0x25, 0xfa, 0x86, 0x61,
106 0x61, 0xb4, 0xdb, 0x8d, 0x1c, 0x43, 0xa7, 0x7e, 0x9a, 0x5f, 0x06, 0xf8, 0xe0, 0x25, 0x39, 0xc2, },
107 { 0x1d, 0xf2, 0xd8, 0x84, 0xa6, 0x3f, 0x7b, 0x41, 0xca, 0x59, 0x63, 0xbe, 0x05, 0xe0, 0x9c, 0x27,
108 0x27, 0x1b, 0xe4, 0x71, 0x49, 0xac, 0x8e, 0xd2, 0xf0, 0xc6, 0x9a, 0x0d, 0x3f, 0x53, 0x65, 0xb8,
113 * This table contains the results of applying both the S-box and P-shuffle.
114 * It can be regenerated by compiling tests/des.c with "-DCONFIG_SMALL -DGENTABLES".
116 static const uint32_t S_boxes_P_shuffle[8][64] = {
117 { 0x00808200, 0x00000000, 0x00008000, 0x00808202, 0x00808002, 0x00008202, 0x00000002, 0x00008000,
118 0x00000200, 0x00808200, 0x00808202, 0x00000200, 0x00800202, 0x00808002, 0x00800000, 0x00000002,
119 0x00000202, 0x00800200, 0x00800200, 0x00008200, 0x00008200, 0x00808000, 0x00808000, 0x00800202,
120 0x00008002, 0x00800002, 0x00800002, 0x00008002, 0x00000000, 0x00000202, 0x00008202, 0x00800000,
121 0x00008000, 0x00808202, 0x00000002, 0x00808000, 0x00808200, 0x00800000, 0x00800000, 0x00000200,
122 0x00808002, 0x00008000, 0x00008200, 0x00800002, 0x00000200, 0x00000002, 0x00800202, 0x00008202,
123 0x00808202, 0x00008002, 0x00808000, 0x00800202, 0x00800002, 0x00000202, 0x00008202, 0x00808200,
124 0x00000202, 0x00800200, 0x00800200, 0x00000000, 0x00008002, 0x00008200, 0x00000000, 0x00808002, },
125 { 0x40084010, 0x40004000, 0x00004000, 0x00084010, 0x00080000, 0x00000010, 0x40080010, 0x40004010,
126 0x40000010, 0x40084010, 0x40084000, 0x40000000, 0x40004000, 0x00080000, 0x00000010, 0x40080010,
127 0x00084000, 0x00080010, 0x40004010, 0x00000000, 0x40000000, 0x00004000, 0x00084010, 0x40080000,
128 0x00080010, 0x40000010, 0x00000000, 0x00084000, 0x00004010, 0x40084000, 0x40080000, 0x00004010,
129 0x00000000, 0x00084010, 0x40080010, 0x00080000, 0x40004010, 0x40080000, 0x40084000, 0x00004000,
130 0x40080000, 0x40004000, 0x00000010, 0x40084010, 0x00084010, 0x00000010, 0x00004000, 0x40000000,
131 0x00004010, 0x40084000, 0x00080000, 0x40000010, 0x00080010, 0x40004010, 0x40000010, 0x00080010,
132 0x00084000, 0x00000000, 0x40004000, 0x00004010, 0x40000000, 0x40080010, 0x40084010, 0x00084000, },
133 { 0x00000104, 0x04010100, 0x00000000, 0x04010004, 0x04000100, 0x00000000, 0x00010104, 0x04000100,
134 0x00010004, 0x04000004, 0x04000004, 0x00010000, 0x04010104, 0x00010004, 0x04010000, 0x00000104,
135 0x04000000, 0x00000004, 0x04010100, 0x00000100, 0x00010100, 0x04010000, 0x04010004, 0x00010104,
136 0x04000104, 0x00010100, 0x00010000, 0x04000104, 0x00000004, 0x04010104, 0x00000100, 0x04000000,
137 0x04010100, 0x04000000, 0x00010004, 0x00000104, 0x00010000, 0x04010100, 0x04000100, 0x00000000,
138 0x00000100, 0x00010004, 0x04010104, 0x04000100, 0x04000004, 0x00000100, 0x00000000, 0x04010004,
139 0x04000104, 0x00010000, 0x04000000, 0x04010104, 0x00000004, 0x00010104, 0x00010100, 0x04000004,
140 0x04010000, 0x04000104, 0x00000104, 0x04010000, 0x00010104, 0x00000004, 0x04010004, 0x00010100, },
141 { 0x80401000, 0x80001040, 0x80001040, 0x00000040, 0x00401040, 0x80400040, 0x80400000, 0x80001000,
142 0x00000000, 0x00401000, 0x00401000, 0x80401040, 0x80000040, 0x00000000, 0x00400040, 0x80400000,
143 0x80000000, 0x00001000, 0x00400000, 0x80401000, 0x00000040, 0x00400000, 0x80001000, 0x00001040,
144 0x80400040, 0x80000000, 0x00001040, 0x00400040, 0x00001000, 0x00401040, 0x80401040, 0x80000040,
145 0x00400040, 0x80400000, 0x00401000, 0x80401040, 0x80000040, 0x00000000, 0x00000000, 0x00401000,
146 0x00001040, 0x00400040, 0x80400040, 0x80000000, 0x80401000, 0x80001040, 0x80001040, 0x00000040,
147 0x80401040, 0x80000040, 0x80000000, 0x00001000, 0x80400000, 0x80001000, 0x00401040, 0x80400040,
148 0x80001000, 0x00001040, 0x00400000, 0x80401000, 0x00000040, 0x00400000, 0x00001000, 0x00401040, },
149 { 0x00000080, 0x01040080, 0x01040000, 0x21000080, 0x00040000, 0x00000080, 0x20000000, 0x01040000,
150 0x20040080, 0x00040000, 0x01000080, 0x20040080, 0x21000080, 0x21040000, 0x00040080, 0x20000000,
151 0x01000000, 0x20040000, 0x20040000, 0x00000000, 0x20000080, 0x21040080, 0x21040080, 0x01000080,
152 0x21040000, 0x20000080, 0x00000000, 0x21000000, 0x01040080, 0x01000000, 0x21000000, 0x00040080,
153 0x00040000, 0x21000080, 0x00000080, 0x01000000, 0x20000000, 0x01040000, 0x21000080, 0x20040080,
154 0x01000080, 0x20000000, 0x21040000, 0x01040080, 0x20040080, 0x00000080, 0x01000000, 0x21040000,
155 0x21040080, 0x00040080, 0x21000000, 0x21040080, 0x01040000, 0x00000000, 0x20040000, 0x21000000,
156 0x00040080, 0x01000080, 0x20000080, 0x00040000, 0x00000000, 0x20040000, 0x01040080, 0x20000080, },
157 { 0x10000008, 0x10200000, 0x00002000, 0x10202008, 0x10200000, 0x00000008, 0x10202008, 0x00200000,
158 0x10002000, 0x00202008, 0x00200000, 0x10000008, 0x00200008, 0x10002000, 0x10000000, 0x00002008,
159 0x00000000, 0x00200008, 0x10002008, 0x00002000, 0x00202000, 0x10002008, 0x00000008, 0x10200008,
160 0x10200008, 0x00000000, 0x00202008, 0x10202000, 0x00002008, 0x00202000, 0x10202000, 0x10000000,
161 0x10002000, 0x00000008, 0x10200008, 0x00202000, 0x10202008, 0x00200000, 0x00002008, 0x10000008,
162 0x00200000, 0x10002000, 0x10000000, 0x00002008, 0x10000008, 0x10202008, 0x00202000, 0x10200000,
163 0x00202008, 0x10202000, 0x00000000, 0x10200008, 0x00000008, 0x00002000, 0x10200000, 0x00202008,
164 0x00002000, 0x00200008, 0x10002008, 0x00000000, 0x10202000, 0x10000000, 0x00200008, 0x10002008, },
165 { 0x00100000, 0x02100001, 0x02000401, 0x00000000, 0x00000400, 0x02000401, 0x00100401, 0x02100400,
166 0x02100401, 0x00100000, 0x00000000, 0x02000001, 0x00000001, 0x02000000, 0x02100001, 0x00000401,
167 0x02000400, 0x00100401, 0x00100001, 0x02000400, 0x02000001, 0x02100000, 0x02100400, 0x00100001,
168 0x02100000, 0x00000400, 0x00000401, 0x02100401, 0x00100400, 0x00000001, 0x02000000, 0x00100400,
169 0x02000000, 0x00100400, 0x00100000, 0x02000401, 0x02000401, 0x02100001, 0x02100001, 0x00000001,
170 0x00100001, 0x02000000, 0x02000400, 0x00100000, 0x02100400, 0x00000401, 0x00100401, 0x02100400,
171 0x00000401, 0x02000001, 0x02100401, 0x02100000, 0x00100400, 0x00000000, 0x00000001, 0x02100401,
172 0x00000000, 0x00100401, 0x02100000, 0x00000400, 0x02000001, 0x02000400, 0x00000400, 0x00100001, },
173 { 0x08000820, 0x00000800, 0x00020000, 0x08020820, 0x08000000, 0x08000820, 0x00000020, 0x08000000,
174 0x00020020, 0x08020000, 0x08020820, 0x00020800, 0x08020800, 0x00020820, 0x00000800, 0x00000020,
175 0x08020000, 0x08000020, 0x08000800, 0x00000820, 0x00020800, 0x00020020, 0x08020020, 0x08020800,
176 0x00000820, 0x00000000, 0x00000000, 0x08020020, 0x08000020, 0x08000800, 0x00020820, 0x00020000,
177 0x00020820, 0x00020000, 0x08020800, 0x00000800, 0x00000020, 0x08020020, 0x00000800, 0x00020820,
178 0x08000800, 0x00000020, 0x08000020, 0x08020000, 0x08020020, 0x08000000, 0x00020000, 0x08000820,
179 0x00000000, 0x08020820, 0x00020020, 0x08000020, 0x08020000, 0x08000800, 0x08000820, 0x00000000,
180 0x08020820, 0x00020800, 0x00020800, 0x00000820, 0x00000820, 0x00020020, 0x08000000, 0x08020800, },
184 static uint64_t shuffle(uint64_t in, const uint8_t *shuffle, int shuffle_len)
188 for (i = 0; i < shuffle_len; i++)
189 res += res + ((in >> *shuffle++) & 1);
193 static uint64_t shuffle_inv(uint64_t in, const uint8_t *shuffle, int shuffle_len)
197 shuffle += shuffle_len - 1;
198 for (i = 0; i < shuffle_len; i++) {
199 res |= (in & 1) << *shuffle--;
205 static uint32_t f_func(uint32_t r, uint64_t k)
209 // rotate to get first part of E-shuffle in the lowest 6 bits
210 r = (r << 1) | (r >> 31);
211 // apply S-boxes, those compress the data again from 8 * 6 to 8 * 4 bits
212 for (i = 7; i >= 0; i--) {
213 uint8_t tmp = (r ^ k) & 0x3f;
215 uint8_t v = S_boxes[i][tmp >> 1];
218 out = (out >> 4) | (v << 28);
220 out |= S_boxes_P_shuffle[i][tmp];
222 // get next 6 bits of E-shuffle and round key k into the lowest bits
223 r = (r >> 4) | (r << 28);
227 out = shuffle(out, P_shuffle, sizeof(P_shuffle));
233 * @brief rotate the two halves of the expanded 56 bit key each 1 bit left
235 * Note: the specification calls this "shift", so I kept it although
238 static uint64_t key_shift_left(uint64_t CDn)
240 uint64_t carries = (CDn >> 27) & 0x10000001;
247 static void gen_roundkeys(uint64_t K[16], uint64_t key)
250 // discard parity bits from key and shuffle it into C and D parts
251 uint64_t CDn = shuffle(key, PC1_shuffle, sizeof(PC1_shuffle));
252 // generate round keys
253 for (i = 0; i < 16; i++) {
254 CDn = key_shift_left(CDn);
255 if (i > 1 && i != 8 && i != 15)
256 CDn = key_shift_left(CDn);
257 K[i] = shuffle(CDn, PC2_shuffle, sizeof(PC2_shuffle));
261 static uint64_t des_encdec(uint64_t in, uint64_t K[16], int decrypt)
264 // used to apply round keys in reverse order for decryption
265 decrypt = decrypt ? 15 : 0;
266 // shuffle irrelevant to security but to ease hardware implementations
267 in = shuffle(in, IP_shuffle, sizeof(IP_shuffle));
268 for (i = 0; i < 16; i++) {
270 f_res = f_func(in, K[decrypt ^ i]);
271 in = (in << 32) | (in >> 32);
274 in = (in << 32) | (in >> 32);
275 // reverse shuffle used to ease hardware implementations
276 in = shuffle_inv(in, IP_shuffle, sizeof(IP_shuffle));
280 AVDES *av_des_alloc(void)
282 return av_mallocz(sizeof(struct AVDES));
285 int av_des_init(AVDES *d, const uint8_t *key, int key_bits, int decrypt)
287 if (key_bits != 64 && key_bits != 192)
289 d->triple_des = key_bits > 64;
290 gen_roundkeys(d->round_keys[0], AV_RB64(key));
292 gen_roundkeys(d->round_keys[1], AV_RB64(key + 8));
293 gen_roundkeys(d->round_keys[2], AV_RB64(key + 16));
298 static void av_des_crypt_mac(AVDES *d, uint8_t *dst, const uint8_t *src,
299 int count, uint8_t *iv, int decrypt, int mac)
301 uint64_t iv_val = iv ? AV_RB64(iv) : 0;
302 while (count-- > 0) {
304 uint64_t src_val = src ? AV_RB64(src) : 0;
306 uint64_t tmp = src_val;
308 src_val = des_encdec(src_val, d->round_keys[2], 1);
309 src_val = des_encdec(src_val, d->round_keys[1], 0);
311 dst_val = des_encdec(src_val, d->round_keys[0], 1) ^ iv_val;
312 iv_val = iv ? tmp : 0;
314 dst_val = des_encdec(src_val ^ iv_val, d->round_keys[0], 0);
316 dst_val = des_encdec(dst_val, d->round_keys[1], 1);
317 dst_val = des_encdec(dst_val, d->round_keys[2], 0);
319 iv_val = iv ? dst_val : 0;
321 AV_WB64(dst, dst_val);
330 void av_des_crypt(AVDES *d, uint8_t *dst, const uint8_t *src,
331 int count, uint8_t *iv, int decrypt)
333 av_des_crypt_mac(d, dst, src, count, iv, decrypt, 0);
336 void av_des_mac(AVDES *d, uint8_t *dst, const uint8_t *src, int count)
338 av_des_crypt_mac(d, dst, src, count, (uint8_t[8]) { 0 }, 0, 1);