tests: Move all test programs to a subdirectory
[libav.git] / libavutil / des.c
CommitLineData
2e9ad69a
RD
1/*
2 * DES encryption/decryption
3 * Copyright (c) 2007 Reimar Doeffinger
4 *
2912e87a 5 * This file is part of Libav.
2e9ad69a 6 *
2912e87a 7 * Libav is free software; you can redistribute it and/or
2e9ad69a
RD
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 *
2912e87a 12 * Libav is distributed in the hope that it will be useful,
2e9ad69a
RD
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
2912e87a 18 * License along with Libav; if not, write to the Free Software
2e9ad69a
RD
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
43992985
DB
21
22#include <stdint.h>
23
1a534c7f 24#include "avutil.h"
85074d3c 25#include "common.h"
1a534c7f 26#include "intreadwrite.h"
d9e8b47e 27#include "mem.h"
2e9ad69a
RD
28#include "des.h"
29
d9e8b47e
JA
30#if !FF_API_CRYPTO_CONTEXT
31struct AVDES {
32 uint64_t round_keys[3][16];
33 int triple_des;
34};
35#endif
1a534c7f 36
3b08d9d9 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
2e9ad69a
RD
38static 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)
47};
48#undef T
49
bd39c076 50#if CONFIG_SMALL || defined(GENTABLES)
3b08d9d9 51#define T(a, b, c, d) 32 - a, 32 - b, 32 - c, 32 - d
2e9ad69a
RD
52static const uint8_t P_shuffle[] = {
53 T(16, 7, 20, 21),
54 T(29, 12, 28, 17),
55 T( 1, 15, 23, 26),
56 T( 5, 18, 31, 10),
57 T( 2, 8, 24, 14),
58 T(32, 27, 3, 9),
59 T(19, 13, 30, 6),
60 T(22, 11, 4, 25)
61};
62#undef T
91c9aa09 63#endif
2e9ad69a 64
3b08d9d9 65#define T(a, b, c, d, e, f, g) 64 - a, 64 - b, 64 - c, 64 - d, 64 - e, 64 - f, 64 - g
2e9ad69a
RD
66static 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)
75};
76#undef T
77
3b08d9d9 78#define T(a, b, c, d, e, f) 56 - a, 56 - b, 56 - c, 56 - d, 56 - e, 56 - f
2e9ad69a
RD
79static 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)
88};
89#undef T
90
b250f9c6 91#if CONFIG_SMALL
2e9ad69a 92static const uint8_t S_boxes[8][32] = {
3b08d9d9
DB
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,
2e9ad69a
RD
109 }
110};
111#else
112/**
113 * This table contains the results of applying both the S-box and P-shuffle.
a6a750c7 114 * It can be regenerated by compiling tests/des.c with "-DCONFIG_SMALL -DGENTABLES".
2e9ad69a
RD
115 */
116static const uint32_t S_boxes_P_shuffle[8][64] = {
3b08d9d9
DB
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, },
2e9ad69a
RD
181};
182#endif
183
3b08d9d9
DB
184static uint64_t shuffle(uint64_t in, const uint8_t *shuffle, int shuffle_len)
185{
2e9ad69a
RD
186 int i;
187 uint64_t res = 0;
188 for (i = 0; i < shuffle_len; i++)
189 res += res + ((in >> *shuffle++) & 1);
190 return res;
191}
192
3b08d9d9
DB
193static uint64_t shuffle_inv(uint64_t in, const uint8_t *shuffle, int shuffle_len)
194{
2e9ad69a
RD
195 int i;
196 uint64_t res = 0;
197 shuffle += shuffle_len - 1;
198 for (i = 0; i < shuffle_len; i++) {
199 res |= (in & 1) << *shuffle--;
200 in >>= 1;
201 }
202 return res;
203}
204
3b08d9d9
DB
205static uint32_t f_func(uint32_t r, uint64_t k)
206{
2e9ad69a
RD
207 int i;
208 uint32_t out = 0;
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;
b250f9c6 214#if CONFIG_SMALL
2e9ad69a 215 uint8_t v = S_boxes[i][tmp >> 1];
3b08d9d9
DB
216 if (tmp & 1)
217 v >>= 4;
2e9ad69a
RD
218 out = (out >> 4) | (v << 28);
219#else
220 out |= S_boxes_P_shuffle[i][tmp];
221#endif
222 // get next 6 bits of E-shuffle and round key k into the lowest bits
3b08d9d9 223 r = (r >> 4) | (r << 28);
2e9ad69a
RD
224 k >>= 6;
225 }
b250f9c6 226#if CONFIG_SMALL
2e9ad69a
RD
227 out = shuffle(out, P_shuffle, sizeof(P_shuffle));
228#endif
229 return out;
230}
231
232/**
adbfc605 233 * @brief rotate the two halves of the expanded 56 bit key each 1 bit left
2e9ad69a
RD
234 *
235 * Note: the specification calls this "shift", so I kept it although
236 * it is confusing.
237 */
3b08d9d9
DB
238static uint64_t key_shift_left(uint64_t CDn)
239{
2e9ad69a
RD
240 uint64_t carries = (CDn >> 27) & 0x10000001;
241 CDn <<= 1;
3b08d9d9
DB
242 CDn &= ~0x10000001;
243 CDn |= carries;
2e9ad69a
RD
244 return CDn;
245}
246
3b08d9d9
DB
247static void gen_roundkeys(uint64_t K[16], uint64_t key)
248{
2e9ad69a 249 int i;
2e9ad69a
RD
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));
258 }
1a534c7f
RD
259}
260
3b08d9d9
DB
261static uint64_t des_encdec(uint64_t in, uint64_t K[16], int decrypt)
262{
1a534c7f 263 int i;
2e9ad69a
RD
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++) {
269 uint32_t f_res;
270 f_res = f_func(in, K[decrypt ^ i]);
3b08d9d9
DB
271 in = (in << 32) | (in >> 32);
272 in ^= f_res;
2e9ad69a
RD
273 }
274 in = (in << 32) | (in >> 32);
275 // reverse shuffle used to ease hardware implementations
276 in = shuffle_inv(in, IP_shuffle, sizeof(IP_shuffle));
277 return in;
278}
279
d9e8b47e
JA
280AVDES *av_des_alloc(void)
281{
282 return av_mallocz(sizeof(struct AVDES));
283}
284
3b08d9d9
DB
285int av_des_init(AVDES *d, const uint8_t *key, int key_bits, int decrypt)
286{
bc17cc01 287 if (key_bits != 64 && key_bits != 192)
1a534c7f 288 return -1;
bc17cc01 289 d->triple_des = key_bits > 64;
1a534c7f 290 gen_roundkeys(d->round_keys[0], AV_RB64(key));
bc17cc01
RD
291 if (d->triple_des) {
292 gen_roundkeys(d->round_keys[1], AV_RB64(key + 8));
293 gen_roundkeys(d->round_keys[2], AV_RB64(key + 16));
294 }
1a534c7f
RD
295 return 0;
296}
297
3b08d9d9
DB
298static void av_des_crypt_mac(AVDES *d, uint8_t *dst, const uint8_t *src,
299 int count, uint8_t *iv, int decrypt, int mac)
300{
9e52a406 301 uint64_t iv_val = iv ? AV_RB64(iv) : 0;
1a534c7f
RD
302 while (count-- > 0) {
303 uint64_t dst_val;
9e52a406 304 uint64_t src_val = src ? AV_RB64(src) : 0;
1a534c7f 305 if (decrypt) {
551a0c79 306 uint64_t tmp = src_val;
bc17cc01
RD
307 if (d->triple_des) {
308 src_val = des_encdec(src_val, d->round_keys[2], 1);
309 src_val = des_encdec(src_val, d->round_keys[1], 0);
310 }
1a534c7f 311 dst_val = des_encdec(src_val, d->round_keys[0], 1) ^ iv_val;
3b08d9d9 312 iv_val = iv ? tmp : 0;
1a534c7f
RD
313 } else {
314 dst_val = des_encdec(src_val ^ iv_val, d->round_keys[0], 0);
bc17cc01
RD
315 if (d->triple_des) {
316 dst_val = des_encdec(dst_val, d->round_keys[1], 1);
317 dst_val = des_encdec(dst_val, d->round_keys[2], 0);
318 }
1a534c7f
RD
319 iv_val = iv ? dst_val : 0;
320 }
9e52a406 321 AV_WB64(dst, dst_val);
1a534c7f 322 src += 8;
b3e144a7
DG
323 if (!mac)
324 dst += 8;
1a534c7f
RD
325 }
326 if (iv)
9e52a406 327 AV_WB64(iv, iv_val);
1a534c7f
RD
328}
329
3b08d9d9
DB
330void av_des_crypt(AVDES *d, uint8_t *dst, const uint8_t *src,
331 int count, uint8_t *iv, int decrypt)
332{
b3e144a7
DG
333 av_des_crypt_mac(d, dst, src, count, iv, decrypt, 0);
334}
335
3b08d9d9
DB
336void av_des_mac(AVDES *d, uint8_t *dst, const uint8_t *src, int count)
337{
338 av_des_crypt_mac(d, dst, src, count, (uint8_t[8]) { 0 }, 0, 1);
b3e144a7 339}