FFmpeg
des.c
Go to the documentation of this file.
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 
22 #include <stdint.h>
23 
24 #include "avutil.h"
25 #include "common.h"
26 #include "intreadwrite.h"
27 #include "mem.h"
28 #include "des.h"
29 
30 #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
31 static const uint8_t IP_shuffle[] = {
32  T(58, 50, 42, 34, 26, 18, 10, 2),
33  T(60, 52, 44, 36, 28, 20, 12, 4),
34  T(62, 54, 46, 38, 30, 22, 14, 6),
35  T(64, 56, 48, 40, 32, 24, 16, 8),
36  T(57, 49, 41, 33, 25, 17, 9, 1),
37  T(59, 51, 43, 35, 27, 19, 11, 3),
38  T(61, 53, 45, 37, 29, 21, 13, 5),
39  T(63, 55, 47, 39, 31, 23, 15, 7)
40 };
41 #undef T
42 
43 #if CONFIG_SMALL || defined(GENTABLES)
44 #define T(a, b, c, d) 32 - a, 32 - b, 32 - c, 32 - d
45 static const uint8_t P_shuffle[] = {
46  T(16, 7, 20, 21),
47  T(29, 12, 28, 17),
48  T( 1, 15, 23, 26),
49  T( 5, 18, 31, 10),
50  T( 2, 8, 24, 14),
51  T(32, 27, 3, 9),
52  T(19, 13, 30, 6),
53  T(22, 11, 4, 25)
54 };
55 #undef T
56 #endif
57 
58 #define T(a, b, c, d, e, f, g) 64 - a, 64 - b, 64 - c, 64 - d, 64 - e, 64 - f, 64 - g
59 static const uint8_t PC1_shuffle[] = {
60  T(57, 49, 41, 33, 25, 17, 9),
61  T( 1, 58, 50, 42, 34, 26, 18),
62  T(10, 2, 59, 51, 43, 35, 27),
63  T(19, 11, 3, 60, 52, 44, 36),
64  T(63, 55, 47, 39, 31, 23, 15),
65  T( 7, 62, 54, 46, 38, 30, 22),
66  T(14, 6, 61, 53, 45, 37, 29),
67  T(21, 13, 5, 28, 20, 12, 4)
68 };
69 #undef T
70 
71 #define T(a, b, c, d, e, f) 56 - a, 56 - b, 56 - c, 56 - d, 56 - e, 56 - f
72 static const uint8_t PC2_shuffle[] = {
73  T(14, 17, 11, 24, 1, 5),
74  T( 3, 28, 15, 6, 21, 10),
75  T(23, 19, 12, 4, 26, 8),
76  T(16, 7, 27, 20, 13, 2),
77  T(41, 52, 31, 37, 47, 55),
78  T(30, 40, 51, 45, 33, 48),
79  T(44, 49, 39, 56, 34, 53),
80  T(46, 42, 50, 36, 29, 32)
81 };
82 #undef T
83 
84 #if CONFIG_SMALL
85 static const uint8_t S_boxes[8][32] = {
86  { 0x0e, 0xf4, 0x7d, 0x41, 0xe2, 0x2f, 0xdb, 0x18, 0xa3, 0x6a, 0xc6, 0xbc, 0x95, 0x59, 0x30, 0x87,
87  0xf4, 0xc1, 0x8e, 0x28, 0x4d, 0x96, 0x12, 0x7b, 0x5f, 0xbc, 0x39, 0xe7, 0xa3, 0x0a, 0x65, 0xd0, },
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  { 0xda, 0x70, 0x09, 0x9e, 0x36, 0x43, 0x6f, 0xa5, 0x21, 0x8d, 0x5c, 0xe7, 0xcb, 0xb4, 0xf2, 0x18,
91  0x1d, 0xa6, 0xd4, 0x09, 0x68, 0x9f, 0x83, 0x70, 0x4b, 0xf1, 0xe2, 0x3c, 0xb5, 0x5a, 0x2e, 0xc7, },
92  { 0xd7, 0x8d, 0xbe, 0x53, 0x60, 0xf6, 0x09, 0x3a, 0x41, 0x72, 0x28, 0xc5, 0x1b, 0xac, 0xe4, 0x9f,
93  0x3a, 0xf6, 0x09, 0x60, 0xac, 0x1b, 0xd7, 0x8d, 0x9f, 0x41, 0x53, 0xbe, 0xc5, 0x72, 0x28, 0xe4, },
94  { 0xe2, 0xbc, 0x24, 0xc1, 0x47, 0x7a, 0xdb, 0x16, 0x58, 0x05, 0xf3, 0xaf, 0x3d, 0x90, 0x8e, 0x69,
95  0xb4, 0x82, 0xc1, 0x7b, 0x1a, 0xed, 0x27, 0xd8, 0x6f, 0xf9, 0x0c, 0x95, 0xa6, 0x43, 0x50, 0x3e, },
96  { 0xac, 0xf1, 0x4a, 0x2f, 0x79, 0xc2, 0x96, 0x58, 0x60, 0x1d, 0xd3, 0xe4, 0x0e, 0xb7, 0x35, 0x8b,
97  0x49, 0x3e, 0x2f, 0xc5, 0x92, 0x58, 0xfc, 0xa3, 0xb7, 0xe0, 0x14, 0x7a, 0x61, 0x0d, 0x8b, 0xd6, },
98  { 0xd4, 0x0b, 0xb2, 0x7e, 0x4f, 0x90, 0x18, 0xad, 0xe3, 0x3c, 0x59, 0xc7, 0x25, 0xfa, 0x86, 0x61,
99  0x61, 0xb4, 0xdb, 0x8d, 0x1c, 0x43, 0xa7, 0x7e, 0x9a, 0x5f, 0x06, 0xf8, 0xe0, 0x25, 0x39, 0xc2, },
100  { 0x1d, 0xf2, 0xd8, 0x84, 0xa6, 0x3f, 0x7b, 0x41, 0xca, 0x59, 0x63, 0xbe, 0x05, 0xe0, 0x9c, 0x27,
101  0x27, 0x1b, 0xe4, 0x71, 0x49, 0xac, 0x8e, 0xd2, 0xf0, 0xc6, 0x9a, 0x0d, 0x3f, 0x53, 0x65, 0xb8,
102  }
103 };
104 #else
105 /**
106  * This table contains the results of applying both the S-box and P-shuffle.
107  * It can be regenerated by compiling tests/des.c with "-DCONFIG_SMALL -DGENTABLES".
108  */
109 static const uint32_t S_boxes_P_shuffle[8][64] = {
110  { 0x00808200, 0x00000000, 0x00008000, 0x00808202, 0x00808002, 0x00008202, 0x00000002, 0x00008000,
111  0x00000200, 0x00808200, 0x00808202, 0x00000200, 0x00800202, 0x00808002, 0x00800000, 0x00000002,
112  0x00000202, 0x00800200, 0x00800200, 0x00008200, 0x00008200, 0x00808000, 0x00808000, 0x00800202,
113  0x00008002, 0x00800002, 0x00800002, 0x00008002, 0x00000000, 0x00000202, 0x00008202, 0x00800000,
114  0x00008000, 0x00808202, 0x00000002, 0x00808000, 0x00808200, 0x00800000, 0x00800000, 0x00000200,
115  0x00808002, 0x00008000, 0x00008200, 0x00800002, 0x00000200, 0x00000002, 0x00800202, 0x00008202,
116  0x00808202, 0x00008002, 0x00808000, 0x00800202, 0x00800002, 0x00000202, 0x00008202, 0x00808200,
117  0x00000202, 0x00800200, 0x00800200, 0x00000000, 0x00008002, 0x00008200, 0x00000000, 0x00808002, },
118  { 0x40084010, 0x40004000, 0x00004000, 0x00084010, 0x00080000, 0x00000010, 0x40080010, 0x40004010,
119  0x40000010, 0x40084010, 0x40084000, 0x40000000, 0x40004000, 0x00080000, 0x00000010, 0x40080010,
120  0x00084000, 0x00080010, 0x40004010, 0x00000000, 0x40000000, 0x00004000, 0x00084010, 0x40080000,
121  0x00080010, 0x40000010, 0x00000000, 0x00084000, 0x00004010, 0x40084000, 0x40080000, 0x00004010,
122  0x00000000, 0x00084010, 0x40080010, 0x00080000, 0x40004010, 0x40080000, 0x40084000, 0x00004000,
123  0x40080000, 0x40004000, 0x00000010, 0x40084010, 0x00084010, 0x00000010, 0x00004000, 0x40000000,
124  0x00004010, 0x40084000, 0x00080000, 0x40000010, 0x00080010, 0x40004010, 0x40000010, 0x00080010,
125  0x00084000, 0x00000000, 0x40004000, 0x00004010, 0x40000000, 0x40080010, 0x40084010, 0x00084000, },
126  { 0x00000104, 0x04010100, 0x00000000, 0x04010004, 0x04000100, 0x00000000, 0x00010104, 0x04000100,
127  0x00010004, 0x04000004, 0x04000004, 0x00010000, 0x04010104, 0x00010004, 0x04010000, 0x00000104,
128  0x04000000, 0x00000004, 0x04010100, 0x00000100, 0x00010100, 0x04010000, 0x04010004, 0x00010104,
129  0x04000104, 0x00010100, 0x00010000, 0x04000104, 0x00000004, 0x04010104, 0x00000100, 0x04000000,
130  0x04010100, 0x04000000, 0x00010004, 0x00000104, 0x00010000, 0x04010100, 0x04000100, 0x00000000,
131  0x00000100, 0x00010004, 0x04010104, 0x04000100, 0x04000004, 0x00000100, 0x00000000, 0x04010004,
132  0x04000104, 0x00010000, 0x04000000, 0x04010104, 0x00000004, 0x00010104, 0x00010100, 0x04000004,
133  0x04010000, 0x04000104, 0x00000104, 0x04010000, 0x00010104, 0x00000004, 0x04010004, 0x00010100, },
134  { 0x80401000, 0x80001040, 0x80001040, 0x00000040, 0x00401040, 0x80400040, 0x80400000, 0x80001000,
135  0x00000000, 0x00401000, 0x00401000, 0x80401040, 0x80000040, 0x00000000, 0x00400040, 0x80400000,
136  0x80000000, 0x00001000, 0x00400000, 0x80401000, 0x00000040, 0x00400000, 0x80001000, 0x00001040,
137  0x80400040, 0x80000000, 0x00001040, 0x00400040, 0x00001000, 0x00401040, 0x80401040, 0x80000040,
138  0x00400040, 0x80400000, 0x00401000, 0x80401040, 0x80000040, 0x00000000, 0x00000000, 0x00401000,
139  0x00001040, 0x00400040, 0x80400040, 0x80000000, 0x80401000, 0x80001040, 0x80001040, 0x00000040,
140  0x80401040, 0x80000040, 0x80000000, 0x00001000, 0x80400000, 0x80001000, 0x00401040, 0x80400040,
141  0x80001000, 0x00001040, 0x00400000, 0x80401000, 0x00000040, 0x00400000, 0x00001000, 0x00401040, },
142  { 0x00000080, 0x01040080, 0x01040000, 0x21000080, 0x00040000, 0x00000080, 0x20000000, 0x01040000,
143  0x20040080, 0x00040000, 0x01000080, 0x20040080, 0x21000080, 0x21040000, 0x00040080, 0x20000000,
144  0x01000000, 0x20040000, 0x20040000, 0x00000000, 0x20000080, 0x21040080, 0x21040080, 0x01000080,
145  0x21040000, 0x20000080, 0x00000000, 0x21000000, 0x01040080, 0x01000000, 0x21000000, 0x00040080,
146  0x00040000, 0x21000080, 0x00000080, 0x01000000, 0x20000000, 0x01040000, 0x21000080, 0x20040080,
147  0x01000080, 0x20000000, 0x21040000, 0x01040080, 0x20040080, 0x00000080, 0x01000000, 0x21040000,
148  0x21040080, 0x00040080, 0x21000000, 0x21040080, 0x01040000, 0x00000000, 0x20040000, 0x21000000,
149  0x00040080, 0x01000080, 0x20000080, 0x00040000, 0x00000000, 0x20040000, 0x01040080, 0x20000080, },
150  { 0x10000008, 0x10200000, 0x00002000, 0x10202008, 0x10200000, 0x00000008, 0x10202008, 0x00200000,
151  0x10002000, 0x00202008, 0x00200000, 0x10000008, 0x00200008, 0x10002000, 0x10000000, 0x00002008,
152  0x00000000, 0x00200008, 0x10002008, 0x00002000, 0x00202000, 0x10002008, 0x00000008, 0x10200008,
153  0x10200008, 0x00000000, 0x00202008, 0x10202000, 0x00002008, 0x00202000, 0x10202000, 0x10000000,
154  0x10002000, 0x00000008, 0x10200008, 0x00202000, 0x10202008, 0x00200000, 0x00002008, 0x10000008,
155  0x00200000, 0x10002000, 0x10000000, 0x00002008, 0x10000008, 0x10202008, 0x00202000, 0x10200000,
156  0x00202008, 0x10202000, 0x00000000, 0x10200008, 0x00000008, 0x00002000, 0x10200000, 0x00202008,
157  0x00002000, 0x00200008, 0x10002008, 0x00000000, 0x10202000, 0x10000000, 0x00200008, 0x10002008, },
158  { 0x00100000, 0x02100001, 0x02000401, 0x00000000, 0x00000400, 0x02000401, 0x00100401, 0x02100400,
159  0x02100401, 0x00100000, 0x00000000, 0x02000001, 0x00000001, 0x02000000, 0x02100001, 0x00000401,
160  0x02000400, 0x00100401, 0x00100001, 0x02000400, 0x02000001, 0x02100000, 0x02100400, 0x00100001,
161  0x02100000, 0x00000400, 0x00000401, 0x02100401, 0x00100400, 0x00000001, 0x02000000, 0x00100400,
162  0x02000000, 0x00100400, 0x00100000, 0x02000401, 0x02000401, 0x02100001, 0x02100001, 0x00000001,
163  0x00100001, 0x02000000, 0x02000400, 0x00100000, 0x02100400, 0x00000401, 0x00100401, 0x02100400,
164  0x00000401, 0x02000001, 0x02100401, 0x02100000, 0x00100400, 0x00000000, 0x00000001, 0x02100401,
165  0x00000000, 0x00100401, 0x02100000, 0x00000400, 0x02000001, 0x02000400, 0x00000400, 0x00100001, },
166  { 0x08000820, 0x00000800, 0x00020000, 0x08020820, 0x08000000, 0x08000820, 0x00000020, 0x08000000,
167  0x00020020, 0x08020000, 0x08020820, 0x00020800, 0x08020800, 0x00020820, 0x00000800, 0x00000020,
168  0x08020000, 0x08000020, 0x08000800, 0x00000820, 0x00020800, 0x00020020, 0x08020020, 0x08020800,
169  0x00000820, 0x00000000, 0x00000000, 0x08020020, 0x08000020, 0x08000800, 0x00020820, 0x00020000,
170  0x00020820, 0x00020000, 0x08020800, 0x00000800, 0x00000020, 0x08020020, 0x00000800, 0x00020820,
171  0x08000800, 0x00000020, 0x08000020, 0x08020000, 0x08020020, 0x08000000, 0x00020000, 0x08000820,
172  0x00000000, 0x08020820, 0x00020020, 0x08000020, 0x08020000, 0x08000800, 0x08000820, 0x00000000,
173  0x08020820, 0x00020800, 0x00020800, 0x00000820, 0x00000820, 0x00020020, 0x08000000, 0x08020800, },
174 };
175 #endif
176 
177 static uint64_t shuffle(uint64_t in, const uint8_t *shuffle, int shuffle_len)
178 {
179  int i;
180  uint64_t res = 0;
181  for (i = 0; i < shuffle_len; i++)
182  res += res + ((in >> *shuffle++) & 1);
183  return res;
184 }
185 
186 static uint64_t shuffle_inv(uint64_t in, const uint8_t *shuffle, int shuffle_len)
187 {
188  int i;
189  uint64_t res = 0;
190  shuffle += shuffle_len - 1;
191  for (i = 0; i < shuffle_len; i++) {
192  res |= (in & 1) << *shuffle--;
193  in >>= 1;
194  }
195  return res;
196 }
197 
198 static uint32_t f_func(uint32_t r, uint64_t k)
199 {
200  int i;
201  uint32_t out = 0;
202  // rotate to get first part of E-shuffle in the lowest 6 bits
203  r = (r << 1) | (r >> 31);
204  // apply S-boxes, those compress the data again from 8 * 6 to 8 * 4 bits
205  for (i = 7; i >= 0; i--) {
206  uint8_t tmp = (r ^ k) & 0x3f;
207 #if CONFIG_SMALL
208  uint8_t v = S_boxes[i][tmp >> 1];
209  if (tmp & 1)
210  v >>= 4;
211  out = (out >> 4) | (v << 28);
212 #else
213  out |= S_boxes_P_shuffle[i][tmp];
214 #endif
215  // get next 6 bits of E-shuffle and round key k into the lowest bits
216  r = (r >> 4) | (r << 28);
217  k >>= 6;
218  }
219 #if CONFIG_SMALL
220  out = shuffle(out, P_shuffle, sizeof(P_shuffle));
221 #endif
222  return out;
223 }
224 
225 /**
226  * @brief rotate the two halves of the expanded 56 bit key each 1 bit left
227  *
228  * Note: the specification calls this "shift", so I kept it although
229  * it is confusing.
230  */
231 static uint64_t key_shift_left(uint64_t CDn)
232 {
233  uint64_t carries = (CDn >> 27) & 0x10000001;
234  CDn <<= 1;
235  CDn &= ~0x10000001;
236  CDn |= carries;
237  return CDn;
238 }
239 
240 static void gen_roundkeys(uint64_t K[16], uint64_t key)
241 {
242  int i;
243  // discard parity bits from key and shuffle it into C and D parts
244  uint64_t CDn = shuffle(key, PC1_shuffle, sizeof(PC1_shuffle));
245  // generate round keys
246  for (i = 0; i < 16; i++) {
247  CDn = key_shift_left(CDn);
248  if (i > 1 && i != 8 && i != 15)
249  CDn = key_shift_left(CDn);
250  K[i] = shuffle(CDn, PC2_shuffle, sizeof(PC2_shuffle));
251  }
252 }
253 
254 static uint64_t des_encdec(uint64_t in, uint64_t K[16], int decrypt)
255 {
256  int i;
257  // used to apply round keys in reverse order for decryption
258  decrypt = decrypt ? 15 : 0;
259  // shuffle irrelevant to security but to ease hardware implementations
260  in = shuffle(in, IP_shuffle, sizeof(IP_shuffle));
261  for (i = 0; i < 16; i++) {
262  uint32_t f_res;
263  f_res = f_func(in, K[decrypt ^ i]);
264  in = (in << 32) | (in >> 32);
265  in ^= f_res;
266  }
267  in = (in << 32) | (in >> 32);
268  // reverse shuffle used to ease hardware implementations
269  in = shuffle_inv(in, IP_shuffle, sizeof(IP_shuffle));
270  return in;
271 }
272 
274 {
275  return av_mallocz(sizeof(struct AVDES));
276 }
277 
278 int av_des_init(AVDES *d, const uint8_t *key, int key_bits, av_unused int decrypt) {
279  if (key_bits != 64 && key_bits != 192)
280  return AVERROR(EINVAL);
281  d->triple_des = key_bits > 64;
283  if (d->triple_des) {
284  gen_roundkeys(d->round_keys[1], AV_RB64(key + 8));
285  gen_roundkeys(d->round_keys[2], AV_RB64(key + 16));
286  }
287  return 0;
288 }
289 
290 static void av_des_crypt_mac(AVDES *d, uint8_t *dst, const uint8_t *src,
291  int count, uint8_t *iv, int decrypt, int mac)
292 {
293  uint64_t iv_val = iv ? AV_RB64(iv) : 0;
294  while (count-- > 0) {
295  uint64_t dst_val;
296  uint64_t src_val = src ? AV_RB64(src) : 0;
297  if (decrypt) {
298  uint64_t tmp = src_val;
299  if (d->triple_des) {
300  src_val = des_encdec(src_val, d->round_keys[2], 1);
301  src_val = des_encdec(src_val, d->round_keys[1], 0);
302  }
303  dst_val = des_encdec(src_val, d->round_keys[0], 1) ^ iv_val;
304  iv_val = iv ? tmp : 0;
305  } else {
306  dst_val = des_encdec(src_val ^ iv_val, d->round_keys[0], 0);
307  if (d->triple_des) {
308  dst_val = des_encdec(dst_val, d->round_keys[1], 1);
309  dst_val = des_encdec(dst_val, d->round_keys[2], 0);
310  }
311  iv_val = iv ? dst_val : 0;
312  }
313  AV_WB64(dst, dst_val);
314  src += 8;
315  if (!mac)
316  dst += 8;
317  }
318  if (iv)
319  AV_WB64(iv, iv_val);
320 }
321 
322 void av_des_crypt(AVDES *d, uint8_t *dst, const uint8_t *src,
323  int count, uint8_t *iv, int decrypt)
324 {
325  av_des_crypt_mac(d, dst, src, count, iv, decrypt, 0);
326 }
327 
328 void av_des_mac(AVDES *d, uint8_t *dst, const uint8_t *src, int count)
329 {
330  av_des_crypt_mac(d, dst, src, count, (uint8_t[8]) { 0 }, 0, 1);
331 }
T
#define T(a, b, c, d, e, f, g, h)
Definition: des.c:71
av_des_init
int av_des_init(AVDES *d, const uint8_t *key, int key_bits, av_unused int decrypt)
Definition: des.c:278
r
const char * r
Definition: vf_curves.c:116
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
out
FILE * out
Definition: movenc.c:54
av_des_crypt_mac
static void av_des_crypt_mac(AVDES *d, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt, int mac)
Definition: des.c:290
shuffle_inv
static uint64_t shuffle_inv(uint64_t in, const uint8_t *shuffle, int shuffle_len)
Definition: des.c:186
av_des_crypt
void av_des_crypt(AVDES *d, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt)
Encrypts / decrypts using the DES algorithm.
Definition: des.c:322
av_unused
#define av_unused
Definition: attributes.h:131
AV_WB64
#define AV_WB64(p, v)
Definition: intreadwrite.h:433
AVDES::triple_des
int triple_des
Definition: des.h:35
gen_roundkeys
static void gen_roundkeys(uint64_t K[16], uint64_t key)
Definition: des.c:240
PC1_shuffle
static const uint8_t PC1_shuffle[]
Definition: des.c:59
IP_shuffle
static const uint8_t IP_shuffle[]
Definition: des.c:31
intreadwrite.h
av_des_mac
void av_des_mac(AVDES *d, uint8_t *dst, const uint8_t *src, int count)
Calculates CBC-MAC using the DES algorithm.
Definition: des.c:328
key
const char * key
Definition: hwcontext_opencl.c:168
tmp
static uint8_t tmp[8]
Definition: des.c:41
AVDES::round_keys
uint64_t round_keys[3][16]
Definition: des.h:34
src
#define src
Definition: vp8dsp.c:255
des.h
PC2_shuffle
static const uint8_t PC2_shuffle[]
Definition: des.c:72
S_boxes_P_shuffle
static const uint32_t S_boxes_P_shuffle[8][64]
This table contains the results of applying both the S-box and P-shuffle.
Definition: des.c:109
f_func
static uint32_t f_func(uint32_t r, uint64_t k)
Definition: des.c:198
av_des_alloc
AVDES * av_des_alloc(void)
Allocate an AVDES context.
Definition: des.c:273
in
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
Definition: audio_convert.c:326
i
int i
Definition: input.c:407
key_shift_left
static uint64_t key_shift_left(uint64_t CDn)
rotate the two halves of the expanded 56 bit key each 1 bit left
Definition: des.c:231
common.h
uint8_t
uint8_t
Definition: audio_convert.c:194
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
des_encdec
static uint64_t des_encdec(uint64_t in, uint64_t K[16], int decrypt)
Definition: des.c:254
AVDES
Definition: des.h:33
avutil.h
mem.h
shuffle
static uint64_t shuffle(uint64_t in, const uint8_t *shuffle, int shuffle_len)
Definition: des.c:177
AV_RB64
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_RB64
Definition: bytestream.h:95