external/srs
1
0
Fork 0
mirror of https://github.com/ossrs/srs.git synced 2025-03-09 15:49:59 +00:00
Code Issues Releases Wiki Activity

For #1109, Support without ssl for HLS key.

Browse source
This commit is contained in:
winlin 2018-08-25 21:15:26 +08:00
parent 522fba99aa
commit ee068cf120
6 changed files with 188 additions and 157 deletions
Download patch file Download diff file Expand all files Collapse all files

122
trunk/src/kernel/srs_kernel_ts.cpp
View file

@ -34,15 +34,21 @@
#include <sstream>
using namespace std;
#ifdef SRS_AUTO_SSL
#include <openssl/aes.h>
#include <cstring>
#endif
#include <srs_kernel_log.hpp>
#include <srs_kernel_error.hpp>
#include <srs_kernel_file.hpp>
#include <srs_kernel_codec.hpp>
#include <srs_kernel_stream.hpp>
#include <srs_kernel_utility.hpp>
#include <srs_kernel_buffer.hpp>
#include <srs_core_autofree.hpp>
#define HLS_AES_ENCRYPT_BLOCK_LENGTH SRS_TS_PACKET_SIZE * 4
// in ms, for HLS aac sync time.
#define SRS_CONF_DEFAULT_AAC_SYNC 100
@ -2610,64 +2616,94 @@ SrsVideoCodecId SrsTsContextWriter::video_codec()
return vcodec;
}
srs_error_t SrsEncFileWriter::write(void* buf, size_t count, ssize_t* pnwrite)
#ifdef SRS_AUTO_SSL
SrsEncFileWriter::SrsEncFileWriter()
{
memset(iv,0,16);
buf = new char[HLS_AES_ENCRYPT_BLOCK_LENGTH];
memset(buf, 0, HLS_AES_ENCRYPT_BLOCK_LENGTH);
nb_buf = 0;
key = (unsigned char*)new AES_KEY();
}
SrsEncFileWriter::~SrsEncFileWriter()
{
srs_freepa(buf);
AES_KEY* k = (AES_KEY*)key;
srs_freep(k);
}
srs_error_t SrsEncFileWriter::write(void* data, size_t count, ssize_t* pnwrite)
{
srs_error_t err = srs_success;
srs_assert(count == SRS_TS_PACKET_SIZE);
srs_error_t err = srs_success;
if(buflength != HLS_AES_ENCRYPT_BLOCK_LENGTH)
{
memcpy(tmpbuf+buflength,(char*)buf,SRS_TS_PACKET_SIZE);
buflength += SRS_TS_PACKET_SIZE;
if (nb_buf < HLS_AES_ENCRYPT_BLOCK_LENGTH) {
memcpy(buf + nb_buf, (char*)data, SRS_TS_PACKET_SIZE);
nb_buf += SRS_TS_PACKET_SIZE;
}
if(buflength == HLS_AES_ENCRYPT_BLOCK_LENGTH)
{
unsigned char encryptedbuf[HLS_AES_ENCRYPT_BLOCK_LENGTH];
memset(encryptedbuf,0,HLS_AES_ENCRYPT_BLOCK_LENGTH);
AES_cbc_encrypt((unsigned char *)tmpbuf, (unsigned char *)encryptedbuf, HLS_AES_ENCRYPT_BLOCK_LENGTH, &key, iv, AES_ENCRYPT);
buflength = 0;
memset(tmpbuf,0,HLS_AES_ENCRYPT_BLOCK_LENGTH);
return SrsFileWriter::write(encryptedbuf,HLS_AES_ENCRYPT_BLOCK_LENGTH,pnwrite);
}
else
{
return err;
}
};
srs_error_t SrsEncFileWriter::SetEncCfg(unsigned char* keyval,unsigned char *ivval)
{
srs_error_t err = srs_success;
if (AES_set_encrypt_key(keyval, 16*8, &key))
{
return srs_error_new(ERROR_SYSTEM_FILE_WRITE, "set aes key failed");
}
if (nb_buf == HLS_AES_ENCRYPT_BLOCK_LENGTH) {
nb_buf = 0;
char* cipher = new char[HLS_AES_ENCRYPT_BLOCK_LENGTH];
SrsAutoFreeA(char, cipher);
AES_KEY* k = (AES_KEY*)key;
AES_cbc_encrypt((unsigned char *)buf, (unsigned char *)cipher, HLS_AES_ENCRYPT_BLOCK_LENGTH, k, iv, AES_ENCRYPT);
if ((err = SrsFileWriter::write(cipher, HLS_AES_ENCRYPT_BLOCK_LENGTH, pnwrite)) != srs_success) {
return srs_error_wrap(err, "write cipher");
}
}
return err;
}
memcpy(iv,ivval,16);
srs_error_t SrsEncFileWriter::config_cipher(unsigned char* key, unsigned char* iv)
{
srs_error_t err = srs_success;
memcpy(this->iv, iv, 16);
AES_KEY* k = (AES_KEY*)this->key;
if (AES_set_encrypt_key(key, 16 * 8, k)) {
return srs_error_new(ERROR_SYSTEM_FILE_WRITE, "set aes key failed");
}
return err;
}
void SrsEncFileWriter::close()
{
if(buflength > 0)
{
int addBytes = 16 - buflength % 16;
memset(tmpbuf + buflength, addBytes, addBytes);
unsigned char encryptedbuf[buflength+addBytes];
memset(encryptedbuf,0,buflength+addBytes);
AES_cbc_encrypt((unsigned char *)tmpbuf, (unsigned char *)encryptedbuf, buflength+addBytes, &key, iv, AES_ENCRYPT);
SrsFileWriter::write(encryptedbuf,buflength+addBytes,NULL);
if(nb_buf > 0) {
int nb_padding = 16 - (nb_buf % 16);
if (nb_padding > 0) {
memset(buf + nb_buf, nb_padding, nb_padding);
}
char* cipher = new char[nb_buf + nb_padding];
SrsAutoFreeA(char, cipher);
AES_KEY* k = (AES_KEY*)key;
AES_cbc_encrypt((unsigned char *)buf, (unsigned char *)cipher, nb_buf + nb_padding, k, iv, AES_ENCRYPT);
srs_error_t err = srs_success;
if ((err = SrsFileWriter::write(cipher, nb_buf + nb_padding, NULL)) != srs_success) {
srs_warn("ignore err %s", srs_error_desc(err).c_str());
srs_error_reset(err);
}
buflength = 0;
memset(tmpbuf,0,HLS_AES_ENCRYPT_BLOCK_LENGTH);
nb_buf = 0;
}
SrsFileWriter::close();
}
#endif
SrsTsMessageCache::SrsTsMessageCache()
{