---
Changelog | 1 +
configure | 4 +
doc/general.texi | 2 +-
doc/protocols.texi | 9 ++
libavformat/Makefile | 2 +
libavformat/allformats.c | 2 +
libavformat/rtmpdh.c | 188 ++++++++++++++++++++++++
libavformat/rtmpdh.h | 106 ++++++++++++++
libavformat/rtmpenc.c | 356 ++++++++++++++++++++++++++++++++++++++++++++++
libavformat/rtmpenc.h | 67 +++++++++
libavformat/rtmpproto.c | 103 +++++++++++++-
libavformat/version.h | 2 +-
12 files changed, 834 insertions(+), 8 deletions(-)
create mode 100644 libavformat/rtmpdh.c
create mode 100644 libavformat/rtmpdh.h
create mode 100644 libavformat/rtmpenc.c
create mode 100644 libavformat/rtmpenc.h
diff --git a/Changelog b/Changelog
index 39ad8a3..e58b096 100644
--- a/Changelog
+++ b/Changelog
@@ -31,6 +31,7 @@ version <next>:
- join audio filter
- audio channel mapping filter
- Microsoft ATC Screen decoder
+- RTMPE protocol support
version 0.8:
diff --git a/configure b/configure
index 9f70a36..391a634 100755
--- a/configure
+++ b/configure
@@ -1532,6 +1532,10 @@ mmsh_protocol_select="http_protocol"
mmst_protocol_deps="network"
rtmp_protocol_deps="!librtmp_protocol"
rtmp_protocol_select="tcp_protocol"
+rtmpe_protocol_deps="!librtmp_protocol"
+rtmpe_protocol_select="rtmpenc_protocol"
+rtmpenc_protocol_deps="!librtmp_protocol openssl"
+rtmpenc_protocol_select="tcp_protocol"
rtmphttp_protocol_deps="!librtmp_protocol"
rtmphttp_protocol_select="http_protocol"
rtmpt_protocol_deps="!librtmp_protocol"
diff --git a/doc/general.texi b/doc/general.texi
index 4ea47b4..4b1cb8c 100644
--- a/doc/general.texi
+++ b/doc/general.texi
@@ -831,7 +831,7 @@ performance on systems without hardware floating point
support).
@item MMST @tab X
@item pipe @tab X
@item RTMP @tab X
-@item RTMPE @tab E
+@item RTMPE @tab X
@item RTMPS @tab E
@item RTMPT @tab X
@item RTMPTE @tab E
diff --git a/doc/protocols.texi b/doc/protocols.texi
index e75f108..5f20d8e 100644
--- a/doc/protocols.texi
+++ b/doc/protocols.texi
@@ -255,6 +255,15 @@ The Real-Time Messaging Protocol tunneled through HTTP
(RTMPT) is used
for streaming multimedia content within HTTP requests to traverse
firewalls.
+@section rtmpe
+
+Encrypted Real-Time Messaging Protocol.
+
+The Encrypted Real-Time Messaging Protocol (RTMPE) is used for
+streaming multimedia content within standard cryptographic primitives,
+consisting of Diffie-Hellman key exchange and HMACSHA256, generating
+a pair of RC4 keys.
+
@section rtmp, rtmpe, rtmps, rtmpt, rtmpte
Real-Time Messaging Protocol and its variants supported through
diff --git a/libavformat/Makefile b/libavformat/Makefile
index bf219c2..664f9f4 100644
--- a/libavformat/Makefile
+++ b/libavformat/Makefile
@@ -348,6 +348,8 @@ OBJS-$(CONFIG_MMST_PROTOCOL) += mmst.o mms.o
asf.o
OBJS-$(CONFIG_MD5_PROTOCOL) += md5proto.o
OBJS-$(CONFIG_PIPE_PROTOCOL) += file.o
OBJS-$(CONFIG_RTMP_PROTOCOL) += rtmpproto.o rtmppkt.o
+OBJS-$(CONFIG_RTMPE_PROTOCOL) += rtmpproto.o rtmppkt.o
+OBJS-$(CONFIG_RTMPENC_PROTOCOL) += rtmpenc.o rtmpdh.o
OBJS-$(CONFIG_RTMPHTTP_PROTOCOL) += rtmphttp.o
OBJS-$(CONFIG_RTMPT_PROTOCOL) += rtmpproto.o rtmppkt.o
OBJS-$(CONFIG_RTP_PROTOCOL) += rtpproto.o
diff --git a/libavformat/allformats.c b/libavformat/allformats.c
index 8456398..cd8d752 100644
--- a/libavformat/allformats.c
+++ b/libavformat/allformats.c
@@ -257,6 +257,8 @@ void av_register_all(void)
REGISTER_PROTOCOL (MD5, md5);
REGISTER_PROTOCOL (PIPE, pipe);
REGISTER_PROTOCOL (RTMP, rtmp);
+ REGISTER_PROTOCOL (RTMPE, rtmpe);
+ REGISTER_PROTOCOL (RTMPENC, rtmpenc);
REGISTER_PROTOCOL (RTMPHTTP, rtmphttp);
REGISTER_PROTOCOL (RTMPT, rtmpt);
REGISTER_PROTOCOL (RTP, rtp);
diff --git a/libavformat/rtmpdh.c b/libavformat/rtmpdh.c
new file mode 100644
index 0000000..c256340
--- /dev/null
+++ b/libavformat/rtmpdh.c
@@ -0,0 +1,188 @@
+/*
+ * RTMP Diffie-Hellmann utilities
+ * Copyright (c) 2012 Samuel Pitoiset
+ *
+ * This file is part of Libav.
+ *
+ * Libav is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * Libav is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/**
+ * @file
+ * RTMP Diffie-Hellmann utilities
+ */
+
+#include "rtmpdh.h"
+
+static int dh_is_valid_public_key(FFBigNum y, FFBigNum p, FFBigNum q)
+{
+ FFBigNum bn = NULL;
+ int ret = AVERROR(EINVAL);
+#if CONFIG_OPENSSL
+ BN_CTX *ctx;
+#endif
+
+ ff_bn_new(bn);
+ if (!bn)
+ return AVERROR(ENOMEM);
+
+ /* y must lie in [2, p - 1] */
+ if (!ff_bn_set_word(bn, 1) || !ff_bn_cmp(y, bn))
+ goto fail;
+
+ /* bn = p - 2 */
+ if (!ff_bn_copy(bn, p) || !ff_bn_sub_word(bn, 1) || !ff_bn_cmp(y, bn))
+ goto fail;
+
+ /* Verify with Sophie-Germain prime
+ *
+ * This is a nice test to make sure the public key position is calculated
+ * correctly. This test will fail in about 50% of the cases if applied to
+ * random data.
+ */
+ /* y must fulfill y^q mod p = 1 */
+#if CONFIG_OPENSSL
+ ctx = BN_CTX_new();
+ if (!ctx) {
+ ret = AVERROR(ENOMEM);
+ goto fail;
+ }
+
+ if (!BN_mod_exp(bn, y, q, p, ctx)) {
+ BN_CTX_free(ctx);
+ goto fail;
+ }
+
+ BN_CTX_free(ctx);
+#endif
+
+ if (ff_bn_cmp_1(bn))
+ goto fail;
+
+ ret = 0;
+fail:
+ ff_bn_free(bn);
+
+ return ret;
+}
+
+FF_DH *ff_dh_init(int key_len)
+{
+ FF_DH *dh;
+ int ret;
+
+ if (!(dh = ff_dh_new()))
+ return NULL;
+
+ ff_bn_new(dh->g);
+ if (!dh->g)
+ goto fail;
+
+ ff_bn_hex2bn(dh->p, P1024, ret);
+ if (!ret)
+ goto fail;
+
+ if (!ff_bn_set_word(dh->g, 2))
+ goto fail;
+
+ dh->length = key_len;
+ return dh;
+
+fail:
+ ff_dh_free(dh);
+
+ return NULL;
+}
+
+int ff_dh_generate_public_key(FF_DH *dh)
+{
+ int ret = 0;
+
+ while (!ret) {
+ FFBigNum q1 = NULL;
+
+ if (!ff_dh_generate_key(dh))
+ return AVERROR(EINVAL);
+
+ ff_bn_hex2bn(q1, Q1024, ret);
+ if (!ret)
+ return AVERROR(ENOMEM);
+
+ ret = dh_is_valid_public_key(dh->pub_key, dh->p, q1);
+ ff_bn_free(q1);
+
+ if (!ret) {
+ /* the public key is valid */
+ break;
+ }
+
+ ff_bn_free(dh->pub_key);
+ ff_bn_free(dh->priv_key);
+ }
+
+ return ret;
+}
+
+int ff_dh_write_public_key(FF_DH *dh, uint8_t *pub_key, int pub_key_len)
+{
+ int len;
+
+ /* compute the length of the public key */
+ len = ff_bn_num_bytes(dh->pub_key);
+ if (len <= 0 || len > pub_key_len)
+ return AVERROR(EINVAL);
+
+ /* convert the public key value into big-endian form */
+ memset(pub_key, 0, pub_key_len);
+ if (!ff_bn_bn2bin(dh->pub_key, pub_key + pub_key_len - len, len))
+ return AVERROR(ENOMEM);
+
+ return 0;
+}
+
+int ff_dh_compute_shared_secret_key(FF_DH *dh, const uint8_t *pub_key,
+ int pub_key_len, uint8_t *secret_key)
+{
+ FFBigNum q1 = NULL, pub_key_bn = NULL;
+ int ret;
+
+ /* convert the big-endian form of the public key into a bignum */
+ ff_bn_bin2bn(pub_key_bn, pub_key, pub_key_len);
+ if (!pub_key_bn)
+ return AVERROR(ENOMEM);
+
+ /* convert the string containing a hexadecimal number into a bignum */
+ ff_bn_hex2bn(q1, Q1024, ret);
+ if (!ret) {
+ ret = AVERROR(ENOMEM);
+ goto fail;
+ }
+
+ /* when the public key is valid we have to compute the shared secret key */
+ if ((ret = dh_is_valid_public_key(pub_key_bn, dh->p, q1)) < 0) {
+ goto fail;
+ } else if ((ret = ff_dh_compute_key(secret_key, pub_key_len, pub_key_bn,
+ dh)) < 0) {
+ ret = AVERROR(EINVAL);
+ goto fail;
+ }
+
+fail:
+ ff_bn_free(pub_key_bn);
+ ff_bn_free(q1);
+
+ return ret;
+}
+
diff --git a/libavformat/rtmpdh.h b/libavformat/rtmpdh.h
new file mode 100644
index 0000000..26db393
--- /dev/null
+++ b/libavformat/rtmpdh.h
@@ -0,0 +1,106 @@
+/*
+ * RTMP Diffie-Hellmann utilities
+ * Copyright (c) 2012 Samuel Pitoiset
+ *
+ * This file is part of Libav.
+ *
+ * Libav is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * Libav is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVFORMAT_RTMPDH_H
+#define AVFORMAT_RTMPDH_H
+
+#include "../config.h"
+#include "avformat.h"
+
+#if CONFIG_OPENSSL
+#include <openssl/bn.h>
+#include <openssl/dh.h>
+
+typedef BIGNUM *FFBigNum;
+#define ff_bn_new(m) m = BN_new()
+#define ff_bn_set_word(mpi, w) BN_set_word(mpi, w)
+#define ff_bn_cmp(u, v) BN_cmp(u, v)
+#define ff_bn_copy(u, v) BN_copy(u, v)
+#define ff_bn_sub_word(mpi, w) BN_sub_word(mpi, w)
+#define ff_bn_cmp_1(mpi) BN_cmp(mpi, BN_value_one())
+#define ff_bn_free(mpi) BN_free(mpi)
+#define ff_bn_hex2bn(u, hex, res) res = BN_hex2bn(&u, hex)
+#define ff_bn_num_bytes(u) BN_num_bytes(u)
+#define ff_bn_bn2bin(u, buf, len) BN_bn2bin(u, buf)
+#define ff_bn_bin2bn(u, buf, len) u = BN_bin2bn(buf, len, 0)
+
+#define FF_DH DH
+#define ff_dh_new() DH_new()
+#define ff_dh_free(dh) DH_free(dh)
+#define ff_dh_generate_key(dh) DH_generate_key(dh)
+#define ff_dh_compute_key(secret, seclen, pub, dh) DH_compute_key(secret,
pub, dh)
+#endif
+
+#define P1024 \
+ "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1" \
+ "29024E088A67CC74020BBEA63B139B22514A08798E3404DD" \
+ "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245" \
+ "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED" \
+ "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE65381" \
+ "FFFFFFFFFFFFFFFF"
+
+#define Q1024 \
+ "7FFFFFFFFFFFFFFFE487ED5110B4611A62633145C06E0E68" \
+ "948127044533E63A0105DF531D89CD9128A5043CC71A026E" \
+ "F7CA8CD9E69D218D98158536F92F8A1BA7F09AB6B6A8E122" \
+ "F242DABB312F3F637A262174D31BF6B585FFAE5B7A035BF6" \
+ "F71C35FDAD44CFD2D74F9208BE258FF324943328F67329C0" \
+ "FFFFFFFFFFFFFFFF"
+
+/**
+ * Initialize a Diffie-Hellmann context.
+ *
+ * @param key_len length of keys
+ */
+FF_DH *ff_dh_init(int key_len);
+
+/**
+ * Generate a public key.
+ *
+ * @param dh Diffie-Hellmann context
+ * @return zero on success, negative value otherwise
+ */
+int ff_dh_generate_public_key(FF_DH *dh);
+
+/**
+ * Write the public key into big-endian form.
+ *
+ * @param dh Diffie-Hellmann context
+ * @param pub_key public key
+ * @param pub_key_len length of the public key
+ * @return zero on success, negative value otherwise
+ */
+int ff_dh_write_public_key(FF_DH *dh, uint8_t *pub_key, int pub_key_len);
+
+/**
+ * Compute the shared secret key from the private FF_DH value and the
+ * other party's public value.
+ *
+ * @param dh Diffie-Hellmann context
+ * @param pub_key public key
+ * @param pub_key_len length of the public key
+ * @param secret_key shared secret key
+ * @return length of the shared secret key on success, negative value otherwise
+ */
+int ff_dh_compute_shared_secret_key(FF_DH *dh, const uint8_t *pub_key,
+ int pub_key_len, uint8_t *secret_key);
+
+#endif /* AVFORMAT_RTMPDH_H */
diff --git a/libavformat/rtmpenc.c b/libavformat/rtmpenc.c
new file mode 100644
index 0000000..f7a5243
--- /dev/null
+++ b/libavformat/rtmpenc.c
@@ -0,0 +1,356 @@
+/*
+ * RTMPE network protocol
+ * Copyright (c) 2012 Samuel Pitoiset
+ *
+ * This file is part of Libav.
+ *
+ * Libav is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * Libav is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/**
+ * @file
+ * RTMPE protocol
+ */
+
+#include "libavutil/blowfish.h"
+#include "libavutil/intreadwrite.h"
+#include "libavutil/rc4.h"
+#include "libavutil/xtea.h"
+
+#include "internal.h"
+#include "rtmp.h"
+#include "rtmpdh.h"
+#include "rtmpenc.h"
+#include "url.h"
+
+/* protocol handler context */
+typedef struct RTMPEContext {
+ URLContext *stream; ///< TCP stream
+ FF_DH *dh; ///< Diffie-Hellman context
+ struct AVRC4 key_in; ///< RC4 key used for decrypt data
+ struct AVRC4 key_out; ///< RC4 key used for encrypt data
+ uint8_t *out_data; ///< output buffer
+ int out_size; ///< current output buffer size
+ int out_capacity; ///< current output buffer capacity
+ int handshaked; ///< flag indicating when the handshake
is performed
+} RTMPEContext;
+
+static const uint8_t rtmpe8_keys[16][16] = {
+ { 0xbf, 0xf0, 0x34, 0xb2, 0x11, 0xd9, 0x08, 0x1f,
+ 0xcc, 0xdf, 0xb7, 0x95, 0x74, 0x8d, 0xe7, 0x32 },
+ { 0x08, 0x6a, 0x5e, 0xb6, 0x17, 0x43, 0x09, 0x0e,
+ 0x6e, 0xf0, 0x5a, 0xb8, 0xfe, 0x5a, 0x39, 0xe2 },
+ { 0x7b, 0x10, 0x95, 0x6f, 0x76, 0xce, 0x05, 0x21,
+ 0x23, 0x88, 0xa7, 0x3a, 0x44, 0x01, 0x49, 0xa1 },
+ { 0xa9, 0x43, 0xf3, 0x17, 0xeb, 0xf1, 0x1b, 0xb2,
+ 0xa6, 0x91, 0xa5, 0xee, 0x17, 0xf3, 0x63, 0x39 },
+ { 0x7a, 0x30, 0xe0, 0x0a, 0xb5, 0x29, 0xe2, 0x2c,
+ 0xa0, 0x87, 0xae, 0xa5, 0xc0, 0xcb, 0x79, 0xac },
+ { 0xbd, 0xce, 0x0c, 0x23, 0x2f, 0xeb, 0xde, 0xff,
+ 0x1c, 0xfa, 0xae, 0x16, 0x11, 0x23, 0x23, 0x9d },
+ { 0x55, 0xdd, 0x3f, 0x7b, 0x77, 0xe7, 0xe6, 0x2e,
+ 0x9b, 0xb8, 0xc4, 0x99, 0xc9, 0x48, 0x1e, 0xe4 },
+ { 0x40, 0x7b, 0xb6, 0xb4, 0x71, 0xe8, 0x91, 0x36,
+ 0xa7, 0xae, 0xbf, 0x55, 0xca, 0x33, 0xb8, 0x39 },
+ { 0xfc, 0xf6, 0xbd, 0xc3, 0xb6, 0x3c, 0x36, 0x97,
+ 0x7c, 0xe4, 0xf8, 0x25, 0x04, 0xd9, 0x59, 0xb2 },
+ { 0x28, 0xe0, 0x91, 0xfd, 0x41, 0x95, 0x4c, 0x4c,
+ 0x7f, 0xb7, 0xdb, 0x00, 0xe3, 0xa0, 0x66, 0xf8 },
+ { 0x57, 0x84, 0x5b, 0x76, 0x4f, 0x25, 0x1b, 0x03,
+ 0x46, 0xd4, 0x5b, 0xcd, 0xa2, 0xc3, 0x0d, 0x29 },
+ { 0x0a, 0xcc, 0xee, 0xf8, 0xda, 0x55, 0xb5, 0x46,
+ 0x03, 0x47, 0x34, 0x52, 0x58, 0x63, 0x71, 0x3b },
+ { 0xb8, 0x20, 0x75, 0xdc, 0xa7, 0x5f, 0x1f, 0xee,
+ 0xd8, 0x42, 0x68, 0xe8, 0xa7, 0x2a, 0x44, 0xcc },
+ { 0x07, 0xcf, 0x6e, 0x9e, 0xa1, 0x6d, 0x7b, 0x25,
+ 0x9f, 0xa7, 0xae, 0x6c, 0xd9, 0x2f, 0x56, 0x29 },
+ { 0xfe, 0xb1, 0xea, 0xe4, 0x8c, 0x8c, 0x3c, 0xe1,
+ 0x4e, 0x00, 0x64, 0xa7, 0x6a, 0x38, 0x7c, 0x2a },
+ { 0x89, 0x3a, 0x94, 0x27, 0xcc, 0x30, 0x13, 0xa2,
+ 0xf1, 0x06, 0x38, 0x5b, 0xa8, 0x29, 0xf9, 0x27 }
+};
+
+static const uint8_t rtmpe9_keys[16][24] = {
+ { 0x79, 0x34, 0x77, 0x4c, 0x67, 0xd1, 0x38, 0x3a, 0xdf, 0xb3, 0x56, 0xbe,
+ 0x8b, 0x7b, 0xd0, 0x24, 0x38, 0xe0, 0x73, 0x58, 0x41, 0x5d, 0x69, 0x67,
},
+ { 0x46, 0xf6, 0xb4, 0xcc, 0x01, 0x93, 0xe3, 0xa1, 0x9e, 0x7d, 0x3c, 0x65,
+ 0x55, 0x86, 0xfd, 0x09, 0x8f, 0xf7, 0xb3, 0xc4, 0x6f, 0x41, 0xca, 0x5c,
},
+ { 0x1a, 0xe7, 0xe2, 0xf3, 0xf9, 0x14, 0x79, 0x94, 0xc0, 0xd3, 0x97, 0x43,
+ 0x08, 0x7b, 0xb3, 0x84, 0x43, 0x2f, 0x9d, 0x84, 0x3f, 0x21, 0x01, 0x9b,
},
+ { 0xd3, 0xe3, 0x54, 0xb0, 0xf7, 0x1d, 0xf6, 0x2b, 0x5a, 0x43, 0x4d, 0x04,
+ 0x83, 0x64, 0x3e, 0x0d, 0x59, 0x2f, 0x61, 0xcb, 0xb1, 0x6a, 0x59, 0x0d,
},
+ { 0xc8, 0xc1, 0xe9, 0xb8, 0x16, 0x56, 0x99, 0x21, 0x7b, 0x5b, 0x36, 0xb7,
+ 0xb5, 0x9b, 0xdf, 0x06, 0x49, 0x2c, 0x97, 0xf5, 0x95, 0x48, 0x85, 0x7e,
},
+ { 0xeb, 0xe5, 0xe6, 0x2e, 0xa4, 0xba, 0xd4, 0x2c, 0xf2, 0x16, 0xe0, 0x8f,
+ 0x66, 0x23, 0xa9, 0x43, 0x41, 0xce, 0x38, 0x14, 0x84, 0x95, 0x00, 0x53,
},
+ { 0x66, 0xdb, 0x90, 0xf0, 0x3b, 0x4f, 0xf5, 0x6f, 0xe4, 0x9c, 0x20, 0x89,
+ 0x35, 0x5e, 0xd2, 0xb2, 0xc3, 0x9e, 0x9f, 0x7f, 0x63, 0xb2, 0x28, 0x81,
},
+ { 0xbb, 0x20, 0xac, 0xed, 0x2a, 0x04, 0x6a, 0x19, 0x94, 0x98, 0x9b, 0xc8,
+ 0xff, 0xcd, 0x93, 0xef, 0xc6, 0x0d, 0x56, 0xa7, 0xeb, 0x13, 0xd9, 0x30,
},
+ { 0xbc, 0xf2, 0x43, 0x82, 0x09, 0x40, 0x8a, 0x87, 0x25, 0x43, 0x6d, 0xe6,
+ 0xbb, 0xa4, 0xb9, 0x44, 0x58, 0x3f, 0x21, 0x7c, 0x99, 0xbb, 0x3f, 0x24,
},
+ { 0xec, 0x1a, 0xaa, 0xcd, 0xce, 0xbd, 0x53, 0x11, 0xd2, 0xfb, 0x83, 0xb6,
+ 0xc3, 0xba, 0xab, 0x4f, 0x62, 0x79, 0xe8, 0x65, 0xa9, 0x92, 0x28, 0x76,
},
+ { 0xc6, 0x0c, 0x30, 0x03, 0x91, 0x18, 0x2d, 0x7b, 0x79, 0xda, 0xe1, 0xd5,
+ 0x64, 0x77, 0x9a, 0x12, 0xc5, 0xb1, 0xd7, 0x91, 0x4f, 0x96, 0x4c, 0xa3,
},
+ { 0xd7, 0x7c, 0x2a, 0xbf, 0xa6, 0xe7, 0x85, 0x7c, 0x45, 0xad, 0xff, 0x12,
+ 0x94, 0xd8, 0xde, 0xa4, 0x5c, 0x3d, 0x79, 0xa4, 0x44, 0x02, 0x5d, 0x22,
},
+ { 0x16, 0x19, 0x0d, 0x81, 0x6a, 0x4c, 0xc7, 0xf8, 0xb8, 0xf9, 0x4e, 0xcd,
+ 0x2c, 0x9e, 0x90, 0x84, 0xb2, 0x08, 0x25, 0x60, 0xe1, 0x1e, 0xae, 0x18,
},
+ { 0xe9, 0x7c, 0x58, 0x26, 0x1b, 0x51, 0x9e, 0x49, 0x82, 0x60, 0x61, 0xfc,
+ 0xa0, 0xa0, 0x1b, 0xcd, 0xf5, 0x05, 0xd6, 0xa6, 0x6d, 0x07, 0x88, 0xa3,
},
+ { 0x2b, 0x97, 0x11, 0x8b, 0xd9, 0x4e, 0xd9, 0xdf, 0x20, 0xe3, 0x9c, 0x10,
+ 0xe6, 0xa1, 0x35, 0x21, 0x11, 0xf9, 0x13, 0x0d, 0x0b, 0x24, 0x65, 0xb2,
},
+ { 0x53, 0x6a, 0x4c, 0x54, 0xac, 0x8b, 0x9b, 0xb8, 0x97, 0x29, 0xfc, 0x60,
+ 0x2c, 0x5b, 0x3a, 0x85, 0x68, 0xb5, 0xaa, 0x6a, 0x44, 0xcd, 0x3f, 0xa7,
},
+};
+
+int ff_rtmpe_gen_pub_key(URLContext *h, uint8_t *buf)
+{
+ RTMPEContext *rt = h->priv_data;
+ int offset, ret;
+
+ if (!(rt->dh = ff_dh_init(1024)))
+ return AVERROR(ENOMEM);
+
+ offset = ff_rtmp_calc_digest_pos(buf, 768, 632, 8);
+ if (offset < 0)
+ return offset;
+
+ /* generate a Diffie-Hellmann public key */
+ if ((ret = ff_dh_generate_public_key(rt->dh)) < 0)
+ return ret;
+
+ /* write the public key into the handshake buffer */
+ if ((ret = ff_dh_write_public_key(rt->dh, buf + offset, 128)) < 0)
+ return ret;
+
+ return 0;
+}
+
+int ff_rtmpe_compute_secret_key(URLContext *h, const uint8_t *serverdata,
+ const uint8_t *clientdata)
+{
+ RTMPEContext *rt = h->priv_data;
+ uint8_t secret_key[128], digest[32];
+ int server_pos, client_pos;
+ int ret;
+
+ if ((server_pos = ff_rtmp_calc_digest_pos(serverdata, 768, 632, 8)) < 0)
+ return server_pos;
+
+ if ((client_pos = ff_rtmp_calc_digest_pos(clientdata, 768, 632, 8)) < 0)
+ return client_pos;
+
+ /* compute the shared secret secret in order to compute RC4 keys */
+ if ((ret = ff_dh_compute_shared_secret_key(rt->dh, serverdata + server_pos,
+ 128, secret_key)) < 0)
+ return ret;
+
+ /* set output key */
+ if ((ret = ff_rtmp_calc_digest(serverdata + server_pos, 128, 0, secret_key,
+ 128, digest)) < 0)
+ return ret;
+ av_rc4_init(&rt->key_out, digest, 16 * 8, 1);
+
+ /* set input key */
+ if ((ret = ff_rtmp_calc_digest(clientdata + client_pos, 128, 0, secret_key,
+ 128, digest)) < 0)
+ return ret;
+ av_rc4_init(&rt->key_in, digest, 16 * 8, 1);
+
+ return 0;
+}
+
+static void rtmpe8_sig(const uint8_t *in, uint8_t *out, int key_id)
+{
+ struct AVXTEA ctx;
+
+ av_xtea_init(&ctx, rtmpe8_keys[key_id]);
+ av_xtea_crypt(&ctx, out, in, 1, NULL, 0);
+}
+
+static void rtmpe9_sig(const uint8_t *in, uint8_t *out, int key_id)
+{
+ struct AVBlowfish ctx;
+ uint32_t xl, xr;
+
+ xl = AV_RL32(in);
+ xr = AV_RL32(in + 4);
+
+ av_blowfish_init(&ctx, rtmpe9_keys[key_id], 24);
+ av_blowfish_crypt_ecb(&ctx, &xl, &xr, 0);
+
+ AV_WL32(out, xl);
+ AV_WL32(out + 4, xr);
+}
+
+void ff_rtmpe_encrypt_sig(URLContext *h, uint8_t *sig, const uint8_t *digest,
+ int type)
+{
+ int i;
+
+ for (i = 0; i < 32; i += 8) {
+ if (type == 8) {
+ /* RTMPE type 8 uses XTEA on the signature */
+ rtmpe8_sig(sig + i, sig + i, digest[i] % 15);
+ } else if (type == 9) {
+ /* RTMPE type 9 uses Blowfish on the signature */
+ rtmpe9_sig(sig + i, sig + i, digest[i] % 15);
+ }
+ }
+}
+
+static int rtmpe_send_request(URLContext *h)
+{
+ RTMPEContext *rt = h->priv_data;
+ int ret;
+
+ if (rt->handshaked) {
+ /* encrypt data to send to the server */
+ av_rc4_crypt(&rt->key_out, rt->out_data, rt->out_data, rt->out_size,
+ NULL, 1);
+ }
+
+ if ((ret = ffurl_write(rt->stream, rt->out_data, rt->out_size)) < 0)
+ return ret;
+
+ /* re-init output buffer */
+ rt->out_size = 0;
+
+ return ret;
+}
+
+int ff_rtmpe_update_keystream(URLContext *h)
+{
+ RTMPEContext *rt = h->priv_data;
+ char buf[RTMP_HANDSHAKE_PACKET_SIZE];
+ int ret;
+
+ if (rt->out_size > 0) {
+ /* Before updating the RC4 bytestream, we have to send all
+ * the unencrypted data. */
+ if ((ret = rtmpe_send_request(h)) < 0)
+ return ret;
+ }
+
+ /* skip past 1536 bytes of the RC4 bytestream */
+ av_rc4_crypt(&rt->key_in, buf, NULL, sizeof(buf), NULL, 1);
+ av_rc4_crypt(&rt->key_out, buf, NULL, sizeof(buf), NULL, 1);
+
+ /* the next requests will be encrypted using RC4 keys */
+ rt->handshaked = 1;
+
+ return 0;
+}
+
+static int rtmpe_close(URLContext *h)
+{
+ RTMPEContext *rt = h->priv_data;
+
+ av_freep(&rt->out_data);
+ ff_dh_free(rt->dh);
+ ffurl_close(rt->stream);
+
+ return 0;
+}
+
+static int rtmpe_open(URLContext *h, const char *uri, int flags)
+{
+ RTMPEContext *rt = h->priv_data;
+ char host[256], url[1024];
+ int ret, port;
+
+ av_url_split(NULL, 0, NULL, 0, host, sizeof(host), &port, NULL, 0, uri);
+
+ if (port < 0)
+ port = 1935;
+
+ /* open the tcp connection */
+ ff_url_join(url, sizeof(url), "tcp", NULL, host, port, NULL);
+ if ((ret = ffurl_open(&rt->stream, url, AVIO_FLAG_READ_WRITE,
+ &h->interrupt_callback, NULL)) < 0) {
+ rtmpe_close(h);
+ return ret;
+ }
+
+ return 0;
+}
+
+static int rtmpe_read(URLContext *h, uint8_t *buf, int size)
+{
+ RTMPEContext *rt = h->priv_data;
+ int ret, off = 0;
+
+ /* try to read one byte in nonblocking mode */
+ rt->stream->flags |= AVIO_FLAG_NONBLOCK;
+ ret = ffurl_read_complete(rt->stream, buf, 1);
+ rt->stream->flags &= ~AVIO_FLAG_NONBLOCK;
+
+ if (ret == AVERROR(EAGAIN)) {
+ if (rt->out_size > 0) {
+ /* send a new request when there is no incoming data to handle */
+ if ((ret = rtmpe_send_request(h)) < 0)
+ return ret;
+ }
+ if (h->flags & AVIO_FLAG_NONBLOCK)
+ return AVERROR(EAGAIN);
+ } else if (ret < 0) {
+ return ret;
+ } else if (ret == 1) {
+ off += ret;
+ size -= ret;
+ }
+
+ ret = ffurl_read(rt->stream, buf + off, size);
+ if (ret < 0 && ret != AVERROR_EOF)
+ return ret;
+
+ if (rt->handshaked && ret + off > 0) {
+ /* decrypt data received by the server */
+ av_rc4_crypt(&rt->key_in, buf, buf, ret + off, NULL, 1);
+ }
+
+ return ret + off;
+}
+
+static int rtmpe_write(URLContext *h, const uint8_t *buf, int size)
+{
+ RTMPEContext *rt = h->priv_data;
+ void *ptr;
+
+ if (rt->out_size + size > rt->out_capacity) {
+ rt->out_capacity = (rt->out_size + size) * 2;
+ ptr = av_realloc(rt->out_data, rt->out_capacity);
+ if (!ptr)
+ return AVERROR(ENOMEM);
+ rt->out_data = ptr;
+ }
+
+ memcpy(rt->out_data + rt->out_size, buf, size);
+ rt->out_size += size;
+
+ return size;
+}
+
+URLProtocol ff_rtmpenc_protocol = {
+ .name = "rtmpenc",
+ .url_open = rtmpe_open,
+ .url_read = rtmpe_read,
+ .url_write = rtmpe_write,
+ .url_close = rtmpe_close,
+ .priv_data_size = sizeof(RTMPEContext),
+ .flags = URL_PROTOCOL_FLAG_NETWORK,
+};
diff --git a/libavformat/rtmpenc.h b/libavformat/rtmpenc.h
new file mode 100644
index 0000000..e53b61c
--- /dev/null
+++ b/libavformat/rtmpenc.h
@@ -0,0 +1,67 @@
+/*
+ * RTMPE encryption utilities
+ * Copyright (c) 2012 Samuel Pitoiset
+ *
+ * This file is part of Libav.
+ *
+ * Libav is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * Libav is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVFORMAT_RTMPE_H
+#define AVFORMAT_RTMPE_H
+
+#include <stdint.h>
+#include "url.h"
+
+/**
+ * Initialize the Diffie-Hellmann context and generate the public key.
+ *
+ * @param h an URLContext
+ * @param buf handshake data (1536 bytes)
+ * @return zero on success, negative value otherwise
+ */
+int ff_rtmpe_gen_pub_key(URLContext *h, uint8_t *buf);
+
+/**
+ * Compute the shared secret key and initialize the RC4 encryption.
+ *
+ * @param h an URLContext
+ * @param buf server data (1536 bytes)
+ * @param buf client data (1536 bytes)
+ * @return zero on success, negative value otherwise
+ */
+int ff_rtmpe_compute_secret_key(URLContext *h, const uint8_t *serverdata,
+ const uint8_t *clientdata);
+
+/**
+ * Encrypt the signature.
+ *
+ * @param h an URLContext
+ * @param signature the signature to encrypt
+ * @param digest the digest used for finding the encryption key
+ * @param type type of encryption (8 for XTEA, 9 for Blowfish)
+ */
+void ff_rtmpe_encrypt_sig(URLContext *h, uint8_t *signature,
+ const uint8_t *digest, int type);
+
+/**
+ * Update the keystream and set RC4 keys for encryption.
+ *
+ * @param h an URLContext
+ * @return zero on success, negative value otherwise
+ */
+int ff_rtmpe_update_keystream(URLContext *h);
+
+#endif /* AVFORMAT_RTMPE_H */
diff --git a/libavformat/rtmpproto.c b/libavformat/rtmpproto.c
index 0df4ba8..427590b 100644
--- a/libavformat/rtmpproto.c
+++ b/libavformat/rtmpproto.c
@@ -37,6 +37,7 @@
#include "flv.h"
#include "rtmp.h"
+#include "rtmpenc.h"
#include "rtmppkt.h"
#include "url.h"
@@ -92,6 +93,7 @@ typedef struct RTMPContext {
int server_bw; ///< server bandwidth
int client_buffer_time; ///< client buffer time in ms
int flush_interval; ///< number of packets flushed
in the same request (RTMPT only)
+ int encrypted; ///< use an encrypted connection
(RTMPE only)
} RTMPContext;
#define PLAYER_KEY_OPEN_PART_LEN 30 ///< length of partial key used for
first client digest signing
@@ -649,13 +651,17 @@ int ff_rtmp_calc_digest_pos(const uint8_t *buf, int off,
int mod_val,
* will be stored) into that packet.
*
* @param buf handshake data (1536 bytes)
+ * @param encrypted use an encrypted connection (RTMPE)
* @return offset to the digest inside input data
*/
-static int rtmp_handshake_imprint_with_digest(uint8_t *buf)
+static int rtmp_handshake_imprint_with_digest(uint8_t *buf, int encrypted)
{
int ret, digest_pos;
- digest_pos = ff_rtmp_calc_digest_pos(buf, 8, 728, 12);
+ if (encrypted)
+ digest_pos = ff_rtmp_calc_digest_pos(buf, 772, 728, 776);
+ else
+ digest_pos = ff_rtmp_calc_digest_pos(buf, 8, 728, 12);
ret = ff_rtmp_calc_digest(buf, RTMP_HANDSHAKE_PACKET_SIZE, digest_pos,
rtmp_player_key, PLAYER_KEY_OPEN_PART_LEN,
@@ -712,7 +718,8 @@ static int rtmp_handshake(URLContext *s, RTMPContext *rt)
uint8_t serverdata[RTMP_HANDSHAKE_PACKET_SIZE+1];
int i;
int server_pos, client_pos;
- uint8_t digest[32];
+ uint8_t digest[32], signature[32];
+ int encrypted = rt->encrypted && CONFIG_RTMPE_PROTOCOL;
int ret;
av_log(s, AV_LOG_DEBUG, "Handshaking...\n");
@@ -721,7 +728,24 @@ static int rtmp_handshake(URLContext *s, RTMPContext *rt)
// generate handshake packet - 1536 bytes of pseudorandom data
for (i = 9; i <= RTMP_HANDSHAKE_PACKET_SIZE; i++)
tosend[i] = av_lfg_get(&rnd) >> 24;
- client_pos = rtmp_handshake_imprint_with_digest(tosend + 1);
+
+ if (encrypted) {
+ /* When the client wants to use RTMPE, we have to change the command
+ * byte to 0x06 which means to use encrypted data and we have to set
+ * the flash version to at least 9.0.115.0. */
+ tosend[0] = 6;
+ tosend[5] = 128;
+ tosend[6] = 0;
+ tosend[7] = 3;
+ tosend[8] = 2;
+
+ /* Initialize the Diffie-Hellmann context and generate the public key
+ * to send to the server. */
+ if ((ret = ff_rtmpe_gen_pub_key(rt->stream, tosend + 1)) < 0)
+ return ret;
+ }
+
+ client_pos = rtmp_handshake_imprint_with_digest(tosend + 1, encrypted);
if (client_pos < 0)
return client_pos;
@@ -743,6 +767,7 @@ static int rtmp_handshake(URLContext *s, RTMPContext *rt)
return ret;
}
+ av_log(s, AV_LOG_DEBUG, "Type answer %d\n", serverdata[0]);
av_log(s, AV_LOG_DEBUG, "Server version %d.%d.%d.%d\n",
serverdata[5], serverdata[6], serverdata[7], serverdata[8]);
@@ -769,11 +794,22 @@ static int rtmp_handshake(URLContext *s, RTMPContext *rt)
return ret;
ret = ff_rtmp_calc_digest(clientdata, RTMP_HANDSHAKE_PACKET_SIZE - 32,
- 0, digest, 32, digest);
+ 0, digest, 32, signature);
if (ret < 0)
return ret;
- if (memcmp(digest, clientdata + RTMP_HANDSHAKE_PACKET_SIZE - 32, 32)) {
+ if (encrypted) {
+ /* Compute the shared secret key sent by the server and initialize
+ * the RC4 encryption. */
+ if ((ret = ff_rtmpe_compute_secret_key(rt->stream, serverdata + 1,
+ tosend + 1)) < 0)
+ return ret;
+
+ /* Encrypt the signature received by the server. */
+ ff_rtmpe_encrypt_sig(rt->stream, signature, digest, serverdata[0]);
+ }
+
+ if (memcmp(signature, clientdata + RTMP_HANDSHAKE_PACKET_SIZE - 32,
32)) {
av_log(s, AV_LOG_ERROR, "Signature mismatch\n");
return AVERROR(EIO);
}
@@ -792,14 +828,47 @@ static int rtmp_handshake(URLContext *s, RTMPContext *rt)
if (ret < 0)
return ret;
+ if (encrypted) {
+ /* Encrypt the signature to be send to the server. */
+ ff_rtmpe_encrypt_sig(rt->stream, tosend +
+ RTMP_HANDSHAKE_PACKET_SIZE - 32, digest,
+ serverdata[0]);
+ }
+
// write reply back to the server
if ((ret = ffurl_write(rt->stream, tosend,
RTMP_HANDSHAKE_PACKET_SIZE)) < 0)
return ret;
+
+ if (encrypted) {
+ /* Set RC4 keys for encryption and update the keystreams. */
+ if ((ret = ff_rtmpe_update_keystream(rt->stream)) < 0)
+ return ret;
+ }
} else {
+ if (encrypted) {
+ /* Compute the shared secret key sent by the server and initialize
+ * the RC4 encryption. */
+ if ((ret = ff_rtmpe_compute_secret_key(rt->stream, serverdata + 1,
+ tosend + 1)) < 0)
+ return ret;
+
+ if (serverdata[0] == 9) {
+ /* Encrypt the signature received by the server. */
+ ff_rtmpe_encrypt_sig(rt->stream, signature, digest,
+ serverdata[0]);
+ }
+ }
+
if ((ret = ffurl_write(rt->stream, serverdata + 1,
RTMP_HANDSHAKE_PACKET_SIZE)) < 0)
return ret;
+
+ if (encrypted) {
+ /* Set RC4 keys for encryption and update the keystreams. */
+ if ((ret = ff_rtmpe_update_keystream(rt->stream)) < 0)
+ return ret;
+ }
}
return 0;
@@ -1109,6 +1178,10 @@ static int rtmp_open(URLContext *s, const char *uri, int
flags)
if (!strcmp(proto, "rtmpt")) {
/* open the http tunneling connection */
ff_url_join(buf, sizeof(buf), "rtmphttp", NULL, hostname, port, NULL);
+ } else if (!strcmp(proto, "rtmpe")) {
+ /* open the encrypted connection */
+ ff_url_join(buf, sizeof(buf), "rtmpenc", NULL, hostname, port, NULL);
+ rt->encrypted = 1;
} else {
/* open the tcp connection */
if (port < 0)
@@ -1449,3 +1522,21 @@ URLProtocol ff_rtmpt_protocol = {
.flags = URL_PROTOCOL_FLAG_NETWORK,
.priv_data_class = &rtmpt_class,
};
+
+static const AVClass rtmpe_class = {
+ .class_name = "rtmpe",
+ .item_name = av_default_item_name,
+ .option = rtmp_options,
+ .version = LIBAVUTIL_VERSION_INT,
+};
+
+URLProtocol ff_rtmpe_protocol = {
+ .name = "rtmpe",
+ .url_open = rtmp_open,
+ .url_read = rtmp_read,
+ .url_write = rtmp_write,
+ .url_close = rtmp_close,
+ .priv_data_size = sizeof(RTMPContext),
+ .flags = URL_PROTOCOL_FLAG_NETWORK,
+ .priv_data_class = &rtmpe_class,
+};
diff --git a/libavformat/version.h b/libavformat/version.h
index 0017698..9547bd0 100644
--- a/libavformat/version.h
+++ b/libavformat/version.h
@@ -30,7 +30,7 @@
#include "libavutil/avutil.h"
#define LIBAVFORMAT_VERSION_MAJOR 54
-#define LIBAVFORMAT_VERSION_MINOR 6
+#define LIBAVFORMAT_VERSION_MINOR 7
#define LIBAVFORMAT_VERSION_MICRO 0
#define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \
--
1.7.10.4
_______________________________________________
libav-devel mailing list
[email protected]
https://lists.libav.org/mailman/listinfo/libav-devel
