Merge commit '52385410b7de012c2562fb5ba8f07a4e1112c4e7'
[ffmpeg.git] / libavutil / des.c
1 /*
2  * DES encryption/decryption
3  * Copyright (c) 2007 Reimar Doeffinger
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg 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.
11  *
12  * FFmpeg 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.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 #include <inttypes.h>
22 #include "avutil.h"
23 #include "common.h"
24 #include "intreadwrite.h"
25 #include "mem.h"
26 #include "des.h"
27
28 #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
29 static const uint8_t IP_shuffle[] = {
30     T(58, 50, 42, 34, 26, 18, 10, 2),
31     T(60, 52, 44, 36, 28, 20, 12, 4),
32     T(62, 54, 46, 38, 30, 22, 14, 6),
33     T(64, 56, 48, 40, 32, 24, 16, 8),
34     T(57, 49, 41, 33, 25, 17,  9, 1),
35     T(59, 51, 43, 35, 27, 19, 11, 3),
36     T(61, 53, 45, 37, 29, 21, 13, 5),
37     T(63, 55, 47, 39, 31, 23, 15, 7)
38 };
39 #undef T
40
41 #if CONFIG_SMALL || defined(GENTABLES)
42 #define T(a, b, c, d) 32-a,32-b,32-c,32-d
43 static const uint8_t P_shuffle[] = {
44     T(16,  7, 20, 21),
45     T(29, 12, 28, 17),
46     T( 1, 15, 23, 26),
47     T( 5, 18, 31, 10),
48     T( 2,  8, 24, 14),
49     T(32, 27,  3,  9),
50     T(19, 13, 30,  6),
51     T(22, 11,  4, 25)
52 };
53 #undef T
54 #endif
55
56 #define T(a, b, c, d, e, f, g) 64-a,64-b,64-c,64-d,64-e,64-f,64-g
57 static const uint8_t PC1_shuffle[] = {
58     T(57, 49, 41, 33, 25, 17,  9),
59     T( 1, 58, 50, 42, 34, 26, 18),
60     T(10,  2, 59, 51, 43, 35, 27),
61     T(19, 11,  3, 60, 52, 44, 36),
62     T(63, 55, 47, 39, 31, 23, 15),
63     T( 7, 62, 54, 46, 38, 30, 22),
64     T(14,  6, 61, 53, 45, 37, 29),
65     T(21, 13,  5, 28, 20, 12,  4)
66 };
67 #undef T
68
69 #define T(a, b, c, d, e, f) 56-a,56-b,56-c,56-d,56-e,56-f
70 static const uint8_t PC2_shuffle[] = {
71     T(14, 17, 11, 24,  1,  5),
72     T( 3, 28, 15,  6, 21, 10),
73     T(23, 19, 12,  4, 26,  8),
74     T(16,  7, 27, 20, 13,  2),
75     T(41, 52, 31, 37, 47, 55),
76     T(30, 40, 51, 45, 33, 48),
77     T(44, 49, 39, 56, 34, 53),
78     T(46, 42, 50, 36, 29, 32)
79 };
80 #undef T
81
82 #if CONFIG_SMALL
83 static const uint8_t S_boxes[8][32] = {
84     {
85     0x0e, 0xf4, 0x7d, 0x41, 0xe2, 0x2f, 0xdb, 0x18, 0xa3, 0x6a, 0xc6, 0xbc, 0x95, 0x59, 0x30, 0x87,
86     0xf4, 0xc1, 0x8e, 0x28, 0x4d, 0x96, 0x12, 0x7b, 0x5f, 0xbc, 0x39, 0xe7, 0xa3, 0x0a, 0x65, 0xd0,
87     }, {
88     0x3f, 0xd1, 0x48, 0x7e, 0xf6, 0x2b, 0x83, 0xe4, 0xc9, 0x07, 0x12, 0xad, 0x6c, 0x90, 0xb5, 0x5a,
89     0xd0, 0x8e, 0xa7, 0x1b, 0x3a, 0xf4, 0x4d, 0x21, 0xb5, 0x68, 0x7c, 0xc6, 0x09, 0x53, 0xe2, 0x9f,
90     }, {
91     0xda, 0x70, 0x09, 0x9e, 0x36, 0x43, 0x6f, 0xa5, 0x21, 0x8d, 0x5c, 0xe7, 0xcb, 0xb4, 0xf2, 0x18,
92     0x1d, 0xa6, 0xd4, 0x09, 0x68, 0x9f, 0x83, 0x70, 0x4b, 0xf1, 0xe2, 0x3c, 0xb5, 0x5a, 0x2e, 0xc7,
93     }, {
94     0xd7, 0x8d, 0xbe, 0x53, 0x60, 0xf6, 0x09, 0x3a, 0x41, 0x72, 0x28, 0xc5, 0x1b, 0xac, 0xe4, 0x9f,
95     0x3a, 0xf6, 0x09, 0x60, 0xac, 0x1b, 0xd7, 0x8d, 0x9f, 0x41, 0x53, 0xbe, 0xc5, 0x72, 0x28, 0xe4,
96     }, {
97     0xe2, 0xbc, 0x24, 0xc1, 0x47, 0x7a, 0xdb, 0x16, 0x58, 0x05, 0xf3, 0xaf, 0x3d, 0x90, 0x8e, 0x69,
98     0xb4, 0x82, 0xc1, 0x7b, 0x1a, 0xed, 0x27, 0xd8, 0x6f, 0xf9, 0x0c, 0x95, 0xa6, 0x43, 0x50, 0x3e,
99     }, {
100     0xac, 0xf1, 0x4a, 0x2f, 0x79, 0xc2, 0x96, 0x58, 0x60, 0x1d, 0xd3, 0xe4, 0x0e, 0xb7, 0x35, 0x8b,
101     0x49, 0x3e, 0x2f, 0xc5, 0x92, 0x58, 0xfc, 0xa3, 0xb7, 0xe0, 0x14, 0x7a, 0x61, 0x0d, 0x8b, 0xd6,
102     }, {
103     0xd4, 0x0b, 0xb2, 0x7e, 0x4f, 0x90, 0x18, 0xad, 0xe3, 0x3c, 0x59, 0xc7, 0x25, 0xfa, 0x86, 0x61,
104     0x61, 0xb4, 0xdb, 0x8d, 0x1c, 0x43, 0xa7, 0x7e, 0x9a, 0x5f, 0x06, 0xf8, 0xe0, 0x25, 0x39, 0xc2,
105     }, {
106     0x1d, 0xf2, 0xd8, 0x84, 0xa6, 0x3f, 0x7b, 0x41, 0xca, 0x59, 0x63, 0xbe, 0x05, 0xe0, 0x9c, 0x27,
107     0x27, 0x1b, 0xe4, 0x71, 0x49, 0xac, 0x8e, 0xd2, 0xf0, 0xc6, 0x9a, 0x0d, 0x3f, 0x53, 0x65, 0xb8,
108     }
109 };
110 #else
111 /**
112  * This table contains the results of applying both the S-box and P-shuffle.
113  * It can be regenerated by compiling this file with -DCONFIG_SMALL -DTEST -DGENTABLES
114  */
115 static const uint32_t S_boxes_P_shuffle[8][64] = {
116     {
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     },
126     {
127     0x40084010, 0x40004000, 0x00004000, 0x00084010, 0x00080000, 0x00000010, 0x40080010, 0x40004010,
128     0x40000010, 0x40084010, 0x40084000, 0x40000000, 0x40004000, 0x00080000, 0x00000010, 0x40080010,
129     0x00084000, 0x00080010, 0x40004010, 0x00000000, 0x40000000, 0x00004000, 0x00084010, 0x40080000,
130     0x00080010, 0x40000010, 0x00000000, 0x00084000, 0x00004010, 0x40084000, 0x40080000, 0x00004010,
131     0x00000000, 0x00084010, 0x40080010, 0x00080000, 0x40004010, 0x40080000, 0x40084000, 0x00004000,
132     0x40080000, 0x40004000, 0x00000010, 0x40084010, 0x00084010, 0x00000010, 0x00004000, 0x40000000,
133     0x00004010, 0x40084000, 0x00080000, 0x40000010, 0x00080010, 0x40004010, 0x40000010, 0x00080010,
134     0x00084000, 0x00000000, 0x40004000, 0x00004010, 0x40000000, 0x40080010, 0x40084010, 0x00084000,
135     },
136     {
137     0x00000104, 0x04010100, 0x00000000, 0x04010004, 0x04000100, 0x00000000, 0x00010104, 0x04000100,
138     0x00010004, 0x04000004, 0x04000004, 0x00010000, 0x04010104, 0x00010004, 0x04010000, 0x00000104,
139     0x04000000, 0x00000004, 0x04010100, 0x00000100, 0x00010100, 0x04010000, 0x04010004, 0x00010104,
140     0x04000104, 0x00010100, 0x00010000, 0x04000104, 0x00000004, 0x04010104, 0x00000100, 0x04000000,
141     0x04010100, 0x04000000, 0x00010004, 0x00000104, 0x00010000, 0x04010100, 0x04000100, 0x00000000,
142     0x00000100, 0x00010004, 0x04010104, 0x04000100, 0x04000004, 0x00000100, 0x00000000, 0x04010004,
143     0x04000104, 0x00010000, 0x04000000, 0x04010104, 0x00000004, 0x00010104, 0x00010100, 0x04000004,
144     0x04010000, 0x04000104, 0x00000104, 0x04010000, 0x00010104, 0x00000004, 0x04010004, 0x00010100,
145     },
146     {
147     0x80401000, 0x80001040, 0x80001040, 0x00000040, 0x00401040, 0x80400040, 0x80400000, 0x80001000,
148     0x00000000, 0x00401000, 0x00401000, 0x80401040, 0x80000040, 0x00000000, 0x00400040, 0x80400000,
149     0x80000000, 0x00001000, 0x00400000, 0x80401000, 0x00000040, 0x00400000, 0x80001000, 0x00001040,
150     0x80400040, 0x80000000, 0x00001040, 0x00400040, 0x00001000, 0x00401040, 0x80401040, 0x80000040,
151     0x00400040, 0x80400000, 0x00401000, 0x80401040, 0x80000040, 0x00000000, 0x00000000, 0x00401000,
152     0x00001040, 0x00400040, 0x80400040, 0x80000000, 0x80401000, 0x80001040, 0x80001040, 0x00000040,
153     0x80401040, 0x80000040, 0x80000000, 0x00001000, 0x80400000, 0x80001000, 0x00401040, 0x80400040,
154     0x80001000, 0x00001040, 0x00400000, 0x80401000, 0x00000040, 0x00400000, 0x00001000, 0x00401040,
155     },
156     {
157     0x00000080, 0x01040080, 0x01040000, 0x21000080, 0x00040000, 0x00000080, 0x20000000, 0x01040000,
158     0x20040080, 0x00040000, 0x01000080, 0x20040080, 0x21000080, 0x21040000, 0x00040080, 0x20000000,
159     0x01000000, 0x20040000, 0x20040000, 0x00000000, 0x20000080, 0x21040080, 0x21040080, 0x01000080,
160     0x21040000, 0x20000080, 0x00000000, 0x21000000, 0x01040080, 0x01000000, 0x21000000, 0x00040080,
161     0x00040000, 0x21000080, 0x00000080, 0x01000000, 0x20000000, 0x01040000, 0x21000080, 0x20040080,
162     0x01000080, 0x20000000, 0x21040000, 0x01040080, 0x20040080, 0x00000080, 0x01000000, 0x21040000,
163     0x21040080, 0x00040080, 0x21000000, 0x21040080, 0x01040000, 0x00000000, 0x20040000, 0x21000000,
164     0x00040080, 0x01000080, 0x20000080, 0x00040000, 0x00000000, 0x20040000, 0x01040080, 0x20000080,
165     },
166     {
167     0x10000008, 0x10200000, 0x00002000, 0x10202008, 0x10200000, 0x00000008, 0x10202008, 0x00200000,
168     0x10002000, 0x00202008, 0x00200000, 0x10000008, 0x00200008, 0x10002000, 0x10000000, 0x00002008,
169     0x00000000, 0x00200008, 0x10002008, 0x00002000, 0x00202000, 0x10002008, 0x00000008, 0x10200008,
170     0x10200008, 0x00000000, 0x00202008, 0x10202000, 0x00002008, 0x00202000, 0x10202000, 0x10000000,
171     0x10002000, 0x00000008, 0x10200008, 0x00202000, 0x10202008, 0x00200000, 0x00002008, 0x10000008,
172     0x00200000, 0x10002000, 0x10000000, 0x00002008, 0x10000008, 0x10202008, 0x00202000, 0x10200000,
173     0x00202008, 0x10202000, 0x00000000, 0x10200008, 0x00000008, 0x00002000, 0x10200000, 0x00202008,
174     0x00002000, 0x00200008, 0x10002008, 0x00000000, 0x10202000, 0x10000000, 0x00200008, 0x10002008,
175     },
176     {
177     0x00100000, 0x02100001, 0x02000401, 0x00000000, 0x00000400, 0x02000401, 0x00100401, 0x02100400,
178     0x02100401, 0x00100000, 0x00000000, 0x02000001, 0x00000001, 0x02000000, 0x02100001, 0x00000401,
179     0x02000400, 0x00100401, 0x00100001, 0x02000400, 0x02000001, 0x02100000, 0x02100400, 0x00100001,
180     0x02100000, 0x00000400, 0x00000401, 0x02100401, 0x00100400, 0x00000001, 0x02000000, 0x00100400,
181     0x02000000, 0x00100400, 0x00100000, 0x02000401, 0x02000401, 0x02100001, 0x02100001, 0x00000001,
182     0x00100001, 0x02000000, 0x02000400, 0x00100000, 0x02100400, 0x00000401, 0x00100401, 0x02100400,
183     0x00000401, 0x02000001, 0x02100401, 0x02100000, 0x00100400, 0x00000000, 0x00000001, 0x02100401,
184     0x00000000, 0x00100401, 0x02100000, 0x00000400, 0x02000001, 0x02000400, 0x00000400, 0x00100001,
185     },
186     {
187     0x08000820, 0x00000800, 0x00020000, 0x08020820, 0x08000000, 0x08000820, 0x00000020, 0x08000000,
188     0x00020020, 0x08020000, 0x08020820, 0x00020800, 0x08020800, 0x00020820, 0x00000800, 0x00000020,
189     0x08020000, 0x08000020, 0x08000800, 0x00000820, 0x00020800, 0x00020020, 0x08020020, 0x08020800,
190     0x00000820, 0x00000000, 0x00000000, 0x08020020, 0x08000020, 0x08000800, 0x00020820, 0x00020000,
191     0x00020820, 0x00020000, 0x08020800, 0x00000800, 0x00000020, 0x08020020, 0x00000800, 0x00020820,
192     0x08000800, 0x00000020, 0x08000020, 0x08020000, 0x08020020, 0x08000000, 0x00020000, 0x08000820,
193     0x00000000, 0x08020820, 0x00020020, 0x08000020, 0x08020000, 0x08000800, 0x08000820, 0x00000000,
194     0x08020820, 0x00020800, 0x00020800, 0x00000820, 0x00000820, 0x00020020, 0x08000000, 0x08020800,
195     },
196 };
197 #endif
198
199 static uint64_t shuffle(uint64_t in, const uint8_t *shuffle, int shuffle_len) {
200     int i;
201     uint64_t res = 0;
202     for (i = 0; i < shuffle_len; i++)
203         res += res + ((in >> *shuffle++) & 1);
204     return res;
205 }
206
207 static uint64_t shuffle_inv(uint64_t in, const uint8_t *shuffle, int shuffle_len) {
208     int i;
209     uint64_t res = 0;
210     shuffle += shuffle_len - 1;
211     for (i = 0; i < shuffle_len; i++) {
212         res |= (in & 1) << *shuffle--;
213         in >>= 1;
214     }
215     return res;
216 }
217
218 static uint32_t f_func(uint32_t r, uint64_t k) {
219     int i;
220     uint32_t out = 0;
221     // rotate to get first part of E-shuffle in the lowest 6 bits
222     r = (r << 1) | (r >> 31);
223     // apply S-boxes, those compress the data again from 8 * 6 to 8 * 4 bits
224     for (i = 7; i >= 0; i--) {
225         uint8_t tmp = (r ^ k) & 0x3f;
226 #if CONFIG_SMALL
227         uint8_t v = S_boxes[i][tmp >> 1];
228         if (tmp & 1) v >>= 4;
229         out = (out >> 4) | (v << 28);
230 #else
231         out |= S_boxes_P_shuffle[i][tmp];
232 #endif
233         // get next 6 bits of E-shuffle and round key k into the lowest bits
234         r = (r >> 4) | (r << 28);
235         k >>= 6;
236     }
237 #if CONFIG_SMALL
238     out = shuffle(out, P_shuffle, sizeof(P_shuffle));
239 #endif
240     return out;
241 }
242
243 /**
244  * @brief rotate the two halves of the expanded 56 bit key each 1 bit left
245  *
246  * Note: the specification calls this "shift", so I kept it although
247  * it is confusing.
248  */
249 static uint64_t key_shift_left(uint64_t CDn) {
250     uint64_t carries = (CDn >> 27) & 0x10000001;
251     CDn <<= 1;
252     CDn &= ~0x10000001;
253     CDn |= carries;
254     return CDn;
255 }
256
257 static void gen_roundkeys(uint64_t K[16], uint64_t key) {
258     int i;
259     // discard parity bits from key and shuffle it into C and D parts
260     uint64_t CDn = shuffle(key, PC1_shuffle, sizeof(PC1_shuffle));
261     // generate round keys
262     for (i = 0; i < 16; i++) {
263         CDn = key_shift_left(CDn);
264         if (i > 1 && i != 8 && i != 15)
265             CDn = key_shift_left(CDn);
266         K[i] = shuffle(CDn, PC2_shuffle, sizeof(PC2_shuffle));
267     }
268 }
269
270 static uint64_t des_encdec(uint64_t in, uint64_t K[16], int decrypt) {
271     int i;
272     // used to apply round keys in reverse order for decryption
273     decrypt = decrypt ? 15 : 0;
274     // shuffle irrelevant to security but to ease hardware implementations
275     in = shuffle(in, IP_shuffle, sizeof(IP_shuffle));
276     for (i = 0; i < 16; i++) {
277         uint32_t f_res;
278         f_res = f_func(in, K[decrypt ^ i]);
279         in = (in << 32) | (in >> 32);
280         in ^= f_res;
281     }
282     in = (in << 32) | (in >> 32);
283     // reverse shuffle used to ease hardware implementations
284     in = shuffle_inv(in, IP_shuffle, sizeof(IP_shuffle));
285     return in;
286 }
287
288 AVDES *av_des_alloc(void)
289 {
290     return av_mallocz(sizeof(struct AVDES));
291 }
292
293 int av_des_init(AVDES *d, const uint8_t *key, int key_bits, av_unused int decrypt) {
294     if (key_bits != 64 && key_bits != 192)
295         return AVERROR(EINVAL);
296     d->triple_des = key_bits > 64;
297     gen_roundkeys(d->round_keys[0], AV_RB64(key));
298     if (d->triple_des) {
299         gen_roundkeys(d->round_keys[1], AV_RB64(key +  8));
300         gen_roundkeys(d->round_keys[2], AV_RB64(key + 16));
301     }
302     return 0;
303 }
304
305 static void av_des_crypt_mac(AVDES *d, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt, int mac) {
306     uint64_t iv_val = iv ? AV_RB64(iv) : 0;
307     while (count-- > 0) {
308         uint64_t dst_val;
309         uint64_t src_val = src ? AV_RB64(src) : 0;
310         if (decrypt) {
311             uint64_t tmp = src_val;
312             if (d->triple_des) {
313                 src_val = des_encdec(src_val, d->round_keys[2], 1);
314                 src_val = des_encdec(src_val, d->round_keys[1], 0);
315             }
316             dst_val = des_encdec(src_val, d->round_keys[0], 1) ^ iv_val;
317             iv_val = iv ? tmp : 0;
318         } else {
319             dst_val = des_encdec(src_val ^ iv_val, d->round_keys[0], 0);
320             if (d->triple_des) {
321                 dst_val = des_encdec(dst_val, d->round_keys[1], 1);
322                 dst_val = des_encdec(dst_val, d->round_keys[2], 0);
323             }
324             iv_val = iv ? dst_val : 0;
325         }
326         AV_WB64(dst, dst_val);
327         src += 8;
328         if (!mac)
329             dst += 8;
330     }
331     if (iv)
332         AV_WB64(iv, iv_val);
333 }
334
335 void av_des_crypt(AVDES *d, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt) {
336     av_des_crypt_mac(d, dst, src, count, iv, decrypt, 0);
337 }
338
339 void av_des_mac(AVDES *d, uint8_t *dst, const uint8_t *src, int count) {
340     av_des_crypt_mac(d, dst, src, count, (uint8_t[8]){0}, 0, 1);
341 }
342
343 #ifdef TEST
344 #include <stdlib.h>
345 #include <stdio.h>
346
347 #include "time.h"
348
349 static uint64_t rand64(void) {
350     uint64_t r = rand();
351     r = (r << 32) | rand();
352     return r;
353 }
354
355 static const uint8_t test_key[] = {0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0};
356 static const DECLARE_ALIGNED(8, uint8_t, plain)[] = {0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10};
357 static const DECLARE_ALIGNED(8, uint8_t, crypt)[] = {0x4a, 0xb6, 0x5b, 0x3d, 0x4b, 0x06, 0x15, 0x18};
358 static DECLARE_ALIGNED(8, uint8_t, tmp)[8];
359 static DECLARE_ALIGNED(8, uint8_t, large_buffer)[10002][8];
360 static const uint8_t cbc_key[] = {
361     0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
362     0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x01,
363     0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x01, 0x23
364 };
365
366 static int run_test(int cbc, int decrypt) {
367     AVDES d;
368     int delay = cbc && !decrypt ? 2 : 1;
369     uint64_t res;
370     AV_WB64(large_buffer[0], 0x4e6f772069732074ULL);
371     AV_WB64(large_buffer[1], 0x1234567890abcdefULL);
372     AV_WB64(tmp,             0x1234567890abcdefULL);
373     av_des_init(&d, cbc_key, 192, decrypt);
374     av_des_crypt(&d, large_buffer[delay], large_buffer[0], 10000, cbc ? tmp : NULL, decrypt);
375     res = AV_RB64(large_buffer[9999 + delay]);
376     if (cbc) {
377         if (decrypt)
378             return res == 0xc5cecf63ecec514cULL;
379         else
380             return res == 0xcb191f85d1ed8439ULL;
381     } else {
382         if (decrypt)
383             return res == 0x8325397644091a0aULL;
384         else
385             return res == 0xdd17e8b8b437d232ULL;
386     }
387 }
388
389 int main(void) {
390     AVDES d;
391     int i;
392     uint64_t key[3];
393     uint64_t data;
394     uint64_t ct;
395     uint64_t roundkeys[16];
396     srand(av_gettime());
397     key[0] = AV_RB64(test_key);
398     data = AV_RB64(plain);
399     gen_roundkeys(roundkeys, key[0]);
400     if (des_encdec(data, roundkeys, 0) != AV_RB64(crypt)) {
401         printf("Test 1 failed\n");
402         return 1;
403     }
404     av_des_init(&d, test_key, 64, 0);
405     av_des_crypt(&d, tmp, plain, 1, NULL, 0);
406     if (memcmp(tmp, crypt, sizeof(crypt))) {
407         printf("Public API decryption failed\n");
408         return 1;
409     }
410     if (!run_test(0, 0) || !run_test(0, 1) || !run_test(1, 0) || !run_test(1, 1)) {
411         printf("Partial Monte-Carlo test failed\n");
412         return 1;
413     }
414     for (i = 0; i < 1000; i++) {
415         key[0] = rand64(); key[1] = rand64(); key[2] = rand64();
416         data = rand64();
417         av_des_init(&d, (uint8_t*)key, 192, 0);
418         av_des_crypt(&d, (uint8_t*)&ct, (uint8_t*)&data, 1, NULL, 0);
419         av_des_init(&d, (uint8_t*)key, 192, 1);
420         av_des_crypt(&d, (uint8_t*)&ct, (uint8_t*)&ct, 1, NULL, 1);
421         if (ct != data) {
422             printf("Test 2 failed\n");
423             return 1;
424         }
425     }
426 #ifdef GENTABLES
427     printf("static const uint32_t S_boxes_P_shuffle[8][64] = {\n");
428     for (i = 0; i < 8; i++) {
429         int j;
430         printf("    {");
431         for (j = 0; j < 64; j++) {
432             uint32_t v = S_boxes[i][j >> 1];
433             v = j & 1 ? v >> 4 : v & 0xf;
434             v <<= 28 - 4 * i;
435             v = shuffle(v, P_shuffle, sizeof(P_shuffle));
436             printf((j & 7) == 0 ? "\n    " : " ");
437             printf("0x%08X,", v);
438         }
439         printf("\n    },\n");
440     }
441     printf("};\n");
442 #endif
443     return 0;
444 }
445 #endif