rtmpcrypt.c
Go to the documentation of this file.
1 /*
2  * RTMPE network protocol
3  * Copyright (c) 2008-2009 Andrej Stepanchuk
4  * Copyright (c) 2009-2010 Howard Chu
5  * Copyright (c) 2012 Samuel Pitoiset
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23 
24 /**
25  * @file
26  * RTMPE protocol
27  */
28 
29 #include "libavutil/blowfish.h"
30 #include "libavutil/intreadwrite.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/rc4.h"
33 #include "libavutil/xtea.h"
34 
35 #include "internal.h"
36 #include "rtmp.h"
37 #include "rtmpdh.h"
38 #include "rtmpcrypt.h"
39 #include "url.h"
40 
41 /* protocol handler context */
42 typedef struct RTMPEContext {
43  const AVClass *class;
44  URLContext *stream; ///< TCP stream
45  FF_DH *dh; ///< Diffie-Hellman context
46  struct AVRC4 key_in; ///< RC4 key used for decrypt data
47  struct AVRC4 key_out; ///< RC4 key used for encrypt data
48  int handshaked; ///< flag indicating when the handshake is performed
49  int tunneling; ///< use a HTTP connection (RTMPTE)
50 } RTMPEContext;
51 
52 static const uint8_t rtmpe8_keys[16][16] = {
53  { 0xbf, 0xf0, 0x34, 0xb2, 0x11, 0xd9, 0x08, 0x1f,
54  0xcc, 0xdf, 0xb7, 0x95, 0x74, 0x8d, 0xe7, 0x32 },
55  { 0x08, 0x6a, 0x5e, 0xb6, 0x17, 0x43, 0x09, 0x0e,
56  0x6e, 0xf0, 0x5a, 0xb8, 0xfe, 0x5a, 0x39, 0xe2 },
57  { 0x7b, 0x10, 0x95, 0x6f, 0x76, 0xce, 0x05, 0x21,
58  0x23, 0x88, 0xa7, 0x3a, 0x44, 0x01, 0x49, 0xa1 },
59  { 0xa9, 0x43, 0xf3, 0x17, 0xeb, 0xf1, 0x1b, 0xb2,
60  0xa6, 0x91, 0xa5, 0xee, 0x17, 0xf3, 0x63, 0x39 },
61  { 0x7a, 0x30, 0xe0, 0x0a, 0xb5, 0x29, 0xe2, 0x2c,
62  0xa0, 0x87, 0xae, 0xa5, 0xc0, 0xcb, 0x79, 0xac },
63  { 0xbd, 0xce, 0x0c, 0x23, 0x2f, 0xeb, 0xde, 0xff,
64  0x1c, 0xfa, 0xae, 0x16, 0x11, 0x23, 0x23, 0x9d },
65  { 0x55, 0xdd, 0x3f, 0x7b, 0x77, 0xe7, 0xe6, 0x2e,
66  0x9b, 0xb8, 0xc4, 0x99, 0xc9, 0x48, 0x1e, 0xe4 },
67  { 0x40, 0x7b, 0xb6, 0xb4, 0x71, 0xe8, 0x91, 0x36,
68  0xa7, 0xae, 0xbf, 0x55, 0xca, 0x33, 0xb8, 0x39 },
69  { 0xfc, 0xf6, 0xbd, 0xc3, 0xb6, 0x3c, 0x36, 0x97,
70  0x7c, 0xe4, 0xf8, 0x25, 0x04, 0xd9, 0x59, 0xb2 },
71  { 0x28, 0xe0, 0x91, 0xfd, 0x41, 0x95, 0x4c, 0x4c,
72  0x7f, 0xb7, 0xdb, 0x00, 0xe3, 0xa0, 0x66, 0xf8 },
73  { 0x57, 0x84, 0x5b, 0x76, 0x4f, 0x25, 0x1b, 0x03,
74  0x46, 0xd4, 0x5b, 0xcd, 0xa2, 0xc3, 0x0d, 0x29 },
75  { 0x0a, 0xcc, 0xee, 0xf8, 0xda, 0x55, 0xb5, 0x46,
76  0x03, 0x47, 0x34, 0x52, 0x58, 0x63, 0x71, 0x3b },
77  { 0xb8, 0x20, 0x75, 0xdc, 0xa7, 0x5f, 0x1f, 0xee,
78  0xd8, 0x42, 0x68, 0xe8, 0xa7, 0x2a, 0x44, 0xcc },
79  { 0x07, 0xcf, 0x6e, 0x9e, 0xa1, 0x6d, 0x7b, 0x25,
80  0x9f, 0xa7, 0xae, 0x6c, 0xd9, 0x2f, 0x56, 0x29 },
81  { 0xfe, 0xb1, 0xea, 0xe4, 0x8c, 0x8c, 0x3c, 0xe1,
82  0x4e, 0x00, 0x64, 0xa7, 0x6a, 0x38, 0x7c, 0x2a },
83  { 0x89, 0x3a, 0x94, 0x27, 0xcc, 0x30, 0x13, 0xa2,
84  0xf1, 0x06, 0x38, 0x5b, 0xa8, 0x29, 0xf9, 0x27 }
85 };
86 
87 static const uint8_t rtmpe9_keys[16][24] = {
88  { 0x79, 0x34, 0x77, 0x4c, 0x67, 0xd1, 0x38, 0x3a, 0xdf, 0xb3, 0x56, 0xbe,
89  0x8b, 0x7b, 0xd0, 0x24, 0x38, 0xe0, 0x73, 0x58, 0x41, 0x5d, 0x69, 0x67, },
90  { 0x46, 0xf6, 0xb4, 0xcc, 0x01, 0x93, 0xe3, 0xa1, 0x9e, 0x7d, 0x3c, 0x65,
91  0x55, 0x86, 0xfd, 0x09, 0x8f, 0xf7, 0xb3, 0xc4, 0x6f, 0x41, 0xca, 0x5c, },
92  { 0x1a, 0xe7, 0xe2, 0xf3, 0xf9, 0x14, 0x79, 0x94, 0xc0, 0xd3, 0x97, 0x43,
93  0x08, 0x7b, 0xb3, 0x84, 0x43, 0x2f, 0x9d, 0x84, 0x3f, 0x21, 0x01, 0x9b, },
94  { 0xd3, 0xe3, 0x54, 0xb0, 0xf7, 0x1d, 0xf6, 0x2b, 0x5a, 0x43, 0x4d, 0x04,
95  0x83, 0x64, 0x3e, 0x0d, 0x59, 0x2f, 0x61, 0xcb, 0xb1, 0x6a, 0x59, 0x0d, },
96  { 0xc8, 0xc1, 0xe9, 0xb8, 0x16, 0x56, 0x99, 0x21, 0x7b, 0x5b, 0x36, 0xb7,
97  0xb5, 0x9b, 0xdf, 0x06, 0x49, 0x2c, 0x97, 0xf5, 0x95, 0x48, 0x85, 0x7e, },
98  { 0xeb, 0xe5, 0xe6, 0x2e, 0xa4, 0xba, 0xd4, 0x2c, 0xf2, 0x16, 0xe0, 0x8f,
99  0x66, 0x23, 0xa9, 0x43, 0x41, 0xce, 0x38, 0x14, 0x84, 0x95, 0x00, 0x53, },
100  { 0x66, 0xdb, 0x90, 0xf0, 0x3b, 0x4f, 0xf5, 0x6f, 0xe4, 0x9c, 0x20, 0x89,
101  0x35, 0x5e, 0xd2, 0xb2, 0xc3, 0x9e, 0x9f, 0x7f, 0x63, 0xb2, 0x28, 0x81, },
102  { 0xbb, 0x20, 0xac, 0xed, 0x2a, 0x04, 0x6a, 0x19, 0x94, 0x98, 0x9b, 0xc8,
103  0xff, 0xcd, 0x93, 0xef, 0xc6, 0x0d, 0x56, 0xa7, 0xeb, 0x13, 0xd9, 0x30, },
104  { 0xbc, 0xf2, 0x43, 0x82, 0x09, 0x40, 0x8a, 0x87, 0x25, 0x43, 0x6d, 0xe6,
105  0xbb, 0xa4, 0xb9, 0x44, 0x58, 0x3f, 0x21, 0x7c, 0x99, 0xbb, 0x3f, 0x24, },
106  { 0xec, 0x1a, 0xaa, 0xcd, 0xce, 0xbd, 0x53, 0x11, 0xd2, 0xfb, 0x83, 0xb6,
107  0xc3, 0xba, 0xab, 0x4f, 0x62, 0x79, 0xe8, 0x65, 0xa9, 0x92, 0x28, 0x76, },
108  { 0xc6, 0x0c, 0x30, 0x03, 0x91, 0x18, 0x2d, 0x7b, 0x79, 0xda, 0xe1, 0xd5,
109  0x64, 0x77, 0x9a, 0x12, 0xc5, 0xb1, 0xd7, 0x91, 0x4f, 0x96, 0x4c, 0xa3, },
110  { 0xd7, 0x7c, 0x2a, 0xbf, 0xa6, 0xe7, 0x85, 0x7c, 0x45, 0xad, 0xff, 0x12,
111  0x94, 0xd8, 0xde, 0xa4, 0x5c, 0x3d, 0x79, 0xa4, 0x44, 0x02, 0x5d, 0x22, },
112  { 0x16, 0x19, 0x0d, 0x81, 0x6a, 0x4c, 0xc7, 0xf8, 0xb8, 0xf9, 0x4e, 0xcd,
113  0x2c, 0x9e, 0x90, 0x84, 0xb2, 0x08, 0x25, 0x60, 0xe1, 0x1e, 0xae, 0x18, },
114  { 0xe9, 0x7c, 0x58, 0x26, 0x1b, 0x51, 0x9e, 0x49, 0x82, 0x60, 0x61, 0xfc,
115  0xa0, 0xa0, 0x1b, 0xcd, 0xf5, 0x05, 0xd6, 0xa6, 0x6d, 0x07, 0x88, 0xa3, },
116  { 0x2b, 0x97, 0x11, 0x8b, 0xd9, 0x4e, 0xd9, 0xdf, 0x20, 0xe3, 0x9c, 0x10,
117  0xe6, 0xa1, 0x35, 0x21, 0x11, 0xf9, 0x13, 0x0d, 0x0b, 0x24, 0x65, 0xb2, },
118  { 0x53, 0x6a, 0x4c, 0x54, 0xac, 0x8b, 0x9b, 0xb8, 0x97, 0x29, 0xfc, 0x60,
119  0x2c, 0x5b, 0x3a, 0x85, 0x68, 0xb5, 0xaa, 0x6a, 0x44, 0xcd, 0x3f, 0xa7, },
120 };
121 
122 int ff_rtmpe_gen_pub_key(URLContext *h, uint8_t *buf)
123 {
124  RTMPEContext *rt = h->priv_data;
125  int offset, ret;
126 
127  if (!(rt->dh = ff_dh_init(1024)))
128  return AVERROR(ENOMEM);
129 
130  offset = ff_rtmp_calc_digest_pos(buf, 768, 632, 8);
131  if (offset < 0)
132  return offset;
133 
134  /* generate a Diffie-Hellmann public key */
135  if ((ret = ff_dh_generate_public_key(rt->dh)) < 0)
136  return ret;
137 
138  /* write the public key into the handshake buffer */
139  if ((ret = ff_dh_write_public_key(rt->dh, buf + offset, 128)) < 0)
140  return ret;
141 
142  return 0;
143 }
144 
145 int ff_rtmpe_compute_secret_key(URLContext *h, const uint8_t *serverdata,
146  const uint8_t *clientdata, int type)
147 {
148  RTMPEContext *rt = h->priv_data;
149  uint8_t secret_key[128], digest[32];
150  int server_pos, client_pos;
151  int ret;
152 
153  if (type) {
154  if ((server_pos = ff_rtmp_calc_digest_pos(serverdata, 1532, 632, 772)) < 0)
155  return server_pos;
156  } else {
157  if ((server_pos = ff_rtmp_calc_digest_pos(serverdata, 768, 632, 8)) < 0)
158  return server_pos;
159  }
160 
161  if ((client_pos = ff_rtmp_calc_digest_pos(clientdata, 768, 632, 8)) < 0)
162  return client_pos;
163 
164  /* compute the shared secret secret in order to compute RC4 keys */
165  if ((ret = ff_dh_compute_shared_secret_key(rt->dh, serverdata + server_pos,
166  128, secret_key)) < 0)
167  return ret;
168 
169  /* set output key */
170  if ((ret = ff_rtmp_calc_digest(serverdata + server_pos, 128, 0, secret_key,
171  128, digest)) < 0)
172  return ret;
173  av_rc4_init(&rt->key_out, digest, 16 * 8, 1);
174 
175  /* set input key */
176  if ((ret = ff_rtmp_calc_digest(clientdata + client_pos, 128, 0, secret_key,
177  128, digest)) < 0)
178  return ret;
179  av_rc4_init(&rt->key_in, digest, 16 * 8, 1);
180 
181  return 0;
182 }
183 
184 static void rtmpe8_sig(const uint8_t *in, uint8_t *out, int key_id)
185 {
186  struct AVXTEA ctx;
187 
188  av_xtea_init(&ctx, rtmpe8_keys[key_id]);
189  av_xtea_crypt(&ctx, out, in, 1, NULL, 0);
190 }
191 
192 static void rtmpe9_sig(const uint8_t *in, uint8_t *out, int key_id)
193 {
194  struct AVBlowfish ctx;
195  uint32_t xl, xr;
196 
197  xl = AV_RL32(in);
198  xr = AV_RL32(in + 4);
199 
200  av_blowfish_init(&ctx, rtmpe9_keys[key_id], 24);
201  av_blowfish_crypt_ecb(&ctx, &xl, &xr, 0);
202 
203  AV_WL32(out, xl);
204  AV_WL32(out + 4, xr);
205 }
206 
207 void ff_rtmpe_encrypt_sig(URLContext *h, uint8_t *sig, const uint8_t *digest,
208  int type)
209 {
210  int i;
211 
212  for (i = 0; i < 32; i += 8) {
213  if (type == 8) {
214  /* RTMPE type 8 uses XTEA on the signature */
215  rtmpe8_sig(sig + i, sig + i, digest[i] % 15);
216  } else if (type == 9) {
217  /* RTMPE type 9 uses Blowfish on the signature */
218  rtmpe9_sig(sig + i, sig + i, digest[i] % 15);
219  }
220  }
221 }
222 
223 int ff_rtmpe_update_keystream(URLContext *h)
224 {
225  RTMPEContext *rt = h->priv_data;
226  char buf[RTMP_HANDSHAKE_PACKET_SIZE];
227 
228  /* skip past 1536 bytes of the RC4 bytestream */
229  av_rc4_crypt(&rt->key_in, buf, NULL, sizeof(buf), NULL, 1);
230  av_rc4_crypt(&rt->key_out, buf, NULL, sizeof(buf), NULL, 1);
231 
232  /* the next requests will be encrypted using RC4 keys */
233  rt->handshaked = 1;
234 
235  return 0;
236 }
237 
238 static int rtmpe_close(URLContext *h)
239 {
240  RTMPEContext *rt = h->priv_data;
241 
242  ff_dh_free(rt->dh);
243  ffurl_close(rt->stream);
244 
245  return 0;
246 }
247 
248 static int rtmpe_open(URLContext *h, const char *uri, int flags)
249 {
250  RTMPEContext *rt = h->priv_data;
251  char host[256], url[1024];
252  int ret, port;
253 
254  av_url_split(NULL, 0, NULL, 0, host, sizeof(host), &port, NULL, 0, uri);
255 
256  if (rt->tunneling) {
257  if (port < 0)
258  port = 80;
259  ff_url_join(url, sizeof(url), "ffrtmphttp", NULL, host, port, NULL);
260  } else {
261  if (port < 0)
262  port = 1935;
263  ff_url_join(url, sizeof(url), "tcp", NULL, host, port, NULL);
264  }
265 
266  /* open the tcp or ffrtmphttp connection */
267  if ((ret = ffurl_open(&rt->stream, url, AVIO_FLAG_READ_WRITE,
268  &h->interrupt_callback, NULL)) < 0) {
269  rtmpe_close(h);
270  return ret;
271  }
272 
273  return 0;
274 }
275 
276 static int rtmpe_read(URLContext *h, uint8_t *buf, int size)
277 {
278  RTMPEContext *rt = h->priv_data;
279  int ret;
280 
281  rt->stream->flags |= h->flags & AVIO_FLAG_NONBLOCK;
282  ret = ffurl_read(rt->stream, buf, size);
283  rt->stream->flags &= ~AVIO_FLAG_NONBLOCK;
284 
285  if (ret < 0 && ret != AVERROR_EOF)
286  return ret;
287 
288  if (rt->handshaked && ret > 0) {
289  /* decrypt data received by the server */
290  av_rc4_crypt(&rt->key_in, buf, buf, ret, NULL, 1);
291  }
292 
293  return ret;
294 }
295 
296 static int rtmpe_write(URLContext *h, const uint8_t *buf, int size)
297 {
298  RTMPEContext *rt = h->priv_data;
299  int ret;
300 
301  if (rt->handshaked) {
302  /* encrypt data to send to the server */
303  av_rc4_crypt(&rt->key_out, buf, buf, size, NULL, 1);
304  }
305 
306  if ((ret = ffurl_write(rt->stream, buf, size)) < 0)
307  return ret;
308 
309  return size;
310 }
311 
312 #define OFFSET(x) offsetof(RTMPEContext, x)
313 #define DEC AV_OPT_FLAG_DECODING_PARAM
314 
315 static const AVOption ffrtmpcrypt_options[] = {
316  {"ffrtmpcrypt_tunneling", "Use a HTTP tunneling connection (RTMPTE).", OFFSET(tunneling), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, DEC},
317  { NULL },
318 };
319 
320 static const AVClass ffrtmpcrypt_class = {
321  .class_name = "ffrtmpcrypt",
322  .item_name = av_default_item_name,
323  .option = ffrtmpcrypt_options,
324  .version = LIBAVUTIL_VERSION_INT,
325 };
326 
327 URLProtocol ff_ffrtmpcrypt_protocol = {
328  .name = "ffrtmpcrypt",
329  .url_open = rtmpe_open,
330  .url_read = rtmpe_read,
331  .url_write = rtmpe_write,
332  .url_close = rtmpe_close,
333  .priv_data_size = sizeof(RTMPEContext),
334  .flags = URL_PROTOCOL_FLAG_NETWORK,
335  .priv_data_class = &ffrtmpcrypt_class,
336 };
av_url_split
void av_url_split(char *proto, int proto_size, char *authorization, int authorization_size, char *hostname, int hostname_size, int *port_ptr, char *path, int path_size, const char *url)
Split a URL string into components.
Definition: libavformat/utils.c:3830
RTMPEContext::tunneling
int tunneling
use a HTTP connection (RTMPTE)
Definition: rtmpcrypt.c:49
size
int size
Definition: twinvq_data.h:11127
URL_PROTOCOL_FLAG_NETWORK
#define URL_PROTOCOL_FLAG_NETWORK
Definition: url.h:35
AVOption
AVOption.
Definition: opt.h:251
ff_dh_write_public_key
int ff_dh_write_public_key(FF_DH *dh, uint8_t *pub_key, int pub_key_len)
Write the public key into the given buffer.
Definition: rtmpdh.c:290
av_rc4_crypt
void av_rc4_crypt(AVRC4 *r, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt)
Encrypts / decrypts using the RC4 algorithm.
Definition: rc4.c:50
av_default_item_name
av_default_item_name
Definition: libvo-amrwbenc.c:49
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: libavutil/version.h:81
ffurl_write
int ffurl_write(URLContext *h, const unsigned char *buf, int size)
Write size bytes from buf to the resource accessed by h.
Definition: avio.c:317
AV_OPT_TYPE_INT
Definition: opt.h:222
URLContext::interrupt_callback
AVIOInterruptCB interrupt_callback
Definition: url.h:50
rtmpe9_keys
static const uint8_t rtmpe9_keys[16][24]
Definition: rtmpcrypt.c:87
in
About Git write you should know how to use GIT properly Luckily Git comes with excellent documentation git help man git shows you the available git< command > help man git< command > shows information about the subcommand< command > The most comprehensive manual is the website Git Reference visit they are quite exhaustive You do not need a special username or password All you need is to provide a ssh public key to the Git server admin What follows now is a basic introduction to Git and some FFmpeg specific guidelines Read it at least if you are granted commit privileges to the FFmpeg project you are expected to be familiar with these rules I if not You can get git from etc no matter how small Every one of them has been saved from looking like a fool by this many times It s very easy for stray debug output or cosmetic modifications to slip in
Definition: git-howto.txt:5
ff_ffrtmpcrypt_protocol
URLProtocol ff_ffrtmpcrypt_protocol
Definition: rtmpcrypt.c:327
URLContext::flags
int flags
Definition: url.h:46
RTMPEContext::stream
URLContext * stream
TCP stream.
Definition: rtmpcrypt.c:44
ff_url_join
int ff_url_join(char *str, int size, const char *proto, const char *authorization, const char *hostname, int port, const char *fmt,...) av_printf_format(7
Assemble a URL string from components.
AV_WL32
#define AV_WL32(p, darg)
Definition: intreadwrite.h:282
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:55
ff_dh_generate_public_key
int ff_dh_generate_public_key(FF_DH *dh)
Generate a public key.
Definition: rtmpdh.c:264
opt.h
AVOptions.
AVRC4
Definition: rc4.h:26
av_xtea_crypt
void av_xtea_crypt(AVXTEA *ctx, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt)
Encrypt or decrypt a buffer using a previously initialized context.
Definition: xtea.c:158
ff_rtmpe_compute_secret_key
int ff_rtmpe_compute_secret_key(URLContext *h, const uint8_t *serverdata, const uint8_t *clientdata, int type)
Compute the shared secret key and initialize the RC4 encryption.
Definition: rtmpcrypt.c:145
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
ff_rtmpe_gen_pub_key
int ff_rtmpe_gen_pub_key(URLContext *h, uint8_t *buf)
Initialize the Diffie-Hellmann context and generate the public key.
Definition: rtmpcrypt.c:122
ff_rtmp_calc_digest_pos
int ff_rtmp_calc_digest_pos(const uint8_t *buf, int off, int mod_val, int add_val)
Calculate digest position for RTMP handshake packets.
Definition: rtmpproto.c:904
RTMPEContext::handshaked
int handshaked
flag indicating when the handshake is performed
Definition: rtmpcrypt.c:48
av_blowfish_init
void av_blowfish_init(AVBlowfish *ctx, const uint8_t *key, int key_len)
Initialize an AVBlowfish context.
Definition: blowfish.c:304
RTMPEContext
struct RTMPEContext RTMPEContext
OFFSET
#define OFFSET(x)
Definition: rtmpcrypt.c:312
av_xtea_init
void av_xtea_init(AVXTEA *ctx, const uint8_t key[16])
Initialize an AVXTEA context.
Definition: xtea.c:30
rtmpe_read
static int rtmpe_read(URLContext *h, uint8_t *buf, int size)
Definition: rtmpcrypt.c:276
offset
static const uint8_t offset[127][2]
Definition: vf_spp.c:70
rtmpe_write
static int rtmpe_write(URLContext *h, const uint8_t *buf, int size)
Definition: rtmpcrypt.c:296
ret
ret
Definition: avfilter.c:821
ff_dh_free
void ff_dh_free(FF_DH *dh)
Free a Diffie-Hellmann context.
AV_RL32
#define AV_RL32
Definition: avr32/intreadwrite.h:146
av_blowfish_crypt_ecb
void av_blowfish_crypt_ecb(AVBlowfish *ctx, uint32_t *xl, uint32_t *xr, int decrypt)
Encrypt or decrypt a buffer using a previously initialized context.
Definition: blowfish.c:339
NULL
NULL
Definition: eval.c:55
AVIO_FLAG_NONBLOCK
#define AVIO_FLAG_NONBLOCK
Use non-blocking mode.
Definition: avio.h:351
buf
void * buf
Definition: avisynth_c.h:594
URLContext
Definition: url.h:41
ff_rtmpe_encrypt_sig
void ff_rtmpe_encrypt_sig(URLContext *h, uint8_t *sig, const uint8_t *digest, int type)
Encrypt the signature.
Definition: rtmpcrypt.c:207
AVIO_FLAG_READ_WRITE
#define AVIO_FLAG_READ_WRITE
read-write pseudo flag
Definition: avio.h:334
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:50
RTMPEContext::dh
FF_DH * dh
Diffie-Hellman context.
Definition: rtmpcrypt.c:45
i
synthesis window for stochastic i
Definition: code Kat/hpsmodel.m:34
URLContext::priv_data
void * priv_data
Definition: url.h:44
ff_rtmpe_update_keystream
int ff_rtmpe_update_keystream(URLContext *h)
Update the keystream and set RC4 keys for encryption.
Definition: rtmpcrypt.c:223
DEC
#define DEC
Definition: rtmpcrypt.c:313
h
const uint8_t ptrdiff_t int h
Definition: hpel_template.c:97
rtmpe8_sig
static void rtmpe8_sig(const uint8_t *in, uint8_t *out, int key_id)
Definition: rtmpcrypt.c:184
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFilterBuffer 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.Buffer references ownership and permissions
type
#define type
URLProtocol::name
const char * name
Definition: url.h:55
ffrtmpcrypt_options
static const AVOption ffrtmpcrypt_options[]
Definition: rtmpcrypt.c:315
flags
static int flags
Definition: cpu.c:23
ffurl_close
int ffurl_close(URLContext *h)
Definition: avio.c:359
RTMP_HANDSHAKE_PACKET_SIZE
#define RTMP_HANDSHAKE_PACKET_SIZE
Definition: rtmp.h:30
rtmpe_close
static int rtmpe_close(URLContext *h)
Definition: rtmpcrypt.c:238
ff_dh_init
av_cold FF_DH * ff_dh_init(int key_len)
Initialize a Diffie-Hellmann context.
Definition: rtmpdh.c:237
ffurl_open
int ffurl_open(URLContext **puc, const char *filename, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options)
Create an URLContext for accessing to the resource indicated by url, and open it. ...
Definition: avio.c:247
rtmpe8_keys
static const uint8_t rtmpe8_keys[16][16]
Definition: rtmpcrypt.c:52
RTMPEContext::key_in
struct AVRC4 key_in
RC4 key used for decrypt data.
Definition: rtmpcrypt.c:46
ff_rtmp_calc_digest
int ff_rtmp_calc_digest(const uint8_t *src, int len, int gap, const uint8_t *key, int keylen, uint8_t *dst)
Calculate HMAC-SHA2 digest for RTMP handshake packets.
Definition: rtmpproto.c:862
av_rc4_init
int av_rc4_init(AVRC4 *r, const uint8_t *key, int key_bits, int decrypt)
Initializes an AVRC4 context.
Definition: rc4.c:29
rtmpe_open
static int rtmpe_open(URLContext *h, const char *uri, int flags)
Definition: rtmpcrypt.c:248
ffrtmpcrypt_class
static const AVClass ffrtmpcrypt_class
Definition: rtmpcrypt.c:320
RTMPEContext::key_out
struct AVRC4 key_out
RC4 key used for encrypt data.
Definition: rtmpcrypt.c:47
ff_dh_compute_shared_secret_key
int ff_dh_compute_shared_secret_key(FF_DH *dh, const uint8_t *pub_key, int pub_key_len, uint8_t *secret_key)
Compute the shared secret key from the private FF_DH value and the other party&#39;s public value...
Definition: rtmpdh.c:306
url.h
unbuffered private I/O API
AVXTEA
Definition: xtea.h:33
ffurl_read
int ffurl_read(URLContext *h, unsigned char *buf, int size)
Read up to size bytes from the resource accessed by h, and store the read bytes in buf...
Definition: avio.c:303
rtmpe9_sig
static void rtmpe9_sig(const uint8_t *in, uint8_t *out, int key_id)
Definition: rtmpcrypt.c:192
Generated on Tue May 7 2024 06:51:52 for FFmpeg by   doxygen 1.8.11