From 9eb57bfb0e29f3520459b42d915f0e7fc25abb27 Mon Sep 17 00:00:00 2001 From: Christian Suloway Date: Mon, 2 Feb 2015 23:39:13 -0600 Subject: [PATCH] avformat/hlsenc: added HLS encryption Added HLS encryption with -hls_key_info_file option. The first line of key_info_file specifies the key URI written to the playlist. The key URL is used to access the encryption key during playback. The second line specifies the path to the key file used to obtain the key during the encryption process. The key file is read as a single packed array of 16 octets in binary format. The optional third line specifies the initialization vector (IV) as a hexadecimal string to be used instead of the segment sequence number (default) for encryption. Changes to key_info_file will result in segment encryption with the new key/IV and an entry in the playlist for the new key URI/IV. Key info file format: (optional) Example key URIs: http://server/file.key /path/to/file.key file.key Example key file paths: file.key /path/to/file.key Example IV: 0123456789ABCDEF0123456789ABCDEF Example: ffmpeg -f lavfi -i testsrc -c:v h264 -hls_key_info_file file.keyinfo foo.m3u8 file.keyinfo: http://server/file.key /path/to/file.key 0123456789ABCDEF0123456789ABCDEF Signed-off-by: Christian Suloway --- doc/muxers.texi | 44 +++++++++++++++++++ libavformat/hlsenc.c | 121 +++++++++++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 162 insertions(+), 3 deletions(-) diff --git a/doc/muxers.texi b/doc/muxers.texi index b0bed7e..3ab478c 100644 --- a/doc/muxers.texi +++ b/doc/muxers.texi @@ -263,6 +263,50 @@ ffmpeg in.nut -hls_segment_filename 'file%03d.ts' out.m3u8 This example will produce the playlist, @file{out.m3u8}, and segment files: @file{file000.ts}, @file{file001.ts}, @file{file002.ts}, etc. +@item hls_key_info_file @var{key_info_file} +Use in the information in @var{key_info_file} for segment encryption. The first +line of @var{key_info_file} specifies the key URI written to the playlist. The +key URL is used to access the encryption key during playback. The second line +specifies the path to the key file used to obtain the key during the encryption +process. The key file is read as a single packed array of 16 octets in binary +format. The optional third line specifies the initialization vector (IV) as a +hexadecimal string to be used instead of the segment sequence number (default) +for encryption. Changes to @var{key_info_file} will result in segment +encryption with the new key/IV and an entry in the playlist for the new key +URI/IV. + +Key info file format: +@example +@var{key URI} +@var{key file path} +@var{IV} (optional) +@end example + +Example key URIs: +@example +http://server/file.key +/path/to/file.key +file.key +@end example + +Example key file paths: +@example +file.key +/path/to/file.key +@end example + +Example IV: +@example +0123456789ABCDEF0123456789ABCDEF +@end example + +Key info file example: +@example +http://server/file.key +/path/to/file.key +0123456789ABCDEF0123456789ABCDEF +@end example + @item hls_flags single_file If this flag is set, the muxer will store all segments in a single MPEG-TS file, and will use byte ranges in the playlist. HLS playlists generated with diff --git a/libavformat/hlsenc.c b/libavformat/hlsenc.c index 29bf30e..930c501 100644 --- a/libavformat/hlsenc.c +++ b/libavformat/hlsenc.c @@ -37,12 +37,18 @@ #include "internal.h" #include "os_support.h" +#define KEYSIZE 16 +#define LINE_BUFFER_SIZE 1024 + typedef struct HLSSegment { char filename[1024]; double duration; /* in seconds */ int64_t pos; int64_t size; + char key_uri[LINE_BUFFER_SIZE + 1]; + char iv_string[KEYSIZE*2 + 1]; + struct HLSSegment *next; } HLSSegment; @@ -86,6 +92,12 @@ typedef struct HLSContext { char *format_options_str; AVDictionary *format_options; + char *key_info_file; + char key_file[LINE_BUFFER_SIZE + 1]; + char key_uri[LINE_BUFFER_SIZE + 1]; + char key_string[KEYSIZE*2 + 1]; + char iv_string[KEYSIZE*2 + 1]; + AVIOContext *pb; } HLSContext; @@ -154,6 +166,60 @@ fail: return ret; } +static int hls_encryption_start(AVFormatContext *s) +{ + HLSContext *hls = s->priv_data; + int ret; + AVIOContext *pb; + uint8_t key[KEYSIZE]; + + if ((ret = avio_open2(&pb, hls->key_info_file, AVIO_FLAG_READ, + &s->interrupt_callback, NULL)) < 0) { + av_log(hls, AV_LOG_ERROR, + "error opening key info file %s\n", hls->key_info_file); + return ret; + } + + ff_get_line(pb, hls->key_uri, sizeof(hls->key_uri)); + hls->key_uri[strcspn(hls->key_uri, "\r\n")] = '\0'; + + ff_get_line(pb, hls->key_file, sizeof(hls->key_file)); + hls->key_file[strcspn(hls->key_file, "\r\n")] = '\0'; + + ff_get_line(pb, hls->iv_string, sizeof(hls->iv_string)); + hls->iv_string[strcspn(hls->iv_string, "\r\n")] = '\0'; + + avio_close(pb); + + if (!*hls->key_uri) { + av_log(hls, AV_LOG_ERROR, "no key URI specified in key info file\n"); + return AVERROR(EINVAL); + } + + if (!*hls->key_file) { + av_log(hls, AV_LOG_ERROR, "no key file specified in key info file\n"); + return AVERROR(EINVAL); + } + + if ((ret = avio_open2(&pb, hls->key_file, AVIO_FLAG_READ, + &s->interrupt_callback, NULL)) < 0) { + av_log(hls, AV_LOG_ERROR, "error opening key file %s\n", hls->key_file); + return ret; + } + + ret = avio_read(pb, key, sizeof(key)); + avio_close(pb); + if (ret != sizeof(key)) { + av_log(hls, AV_LOG_ERROR, "error reading key file %s\n", hls->key_file); + if (ret >= 0 || ret == AVERROR_EOF) + ret = AVERROR(EINVAL); + return ret; + } + ff_data_to_hex(hls->key_string, key, sizeof(key), 0); + + return 0; +} + static int hls_mux_init(AVFormatContext *s) { HLSContext *hls = s->priv_data; @@ -200,6 +266,11 @@ static int hls_append_segment(HLSContext *hls, double duration, int64_t pos, en->size = size; en->next = NULL; + if (hls->key_info_file) { + av_strlcpy(en->key_uri, hls->key_uri, sizeof(en->key_uri)); + av_strlcpy(en->iv_string, hls->iv_string, sizeof(en->iv_string)); + } + if (!hls->segments) hls->segments = en; else @@ -237,6 +308,14 @@ static void hls_free_segments(HLSSegment *p) } } +static void print_encryption_tag(HLSContext *hls, HLSSegment *en) +{ + avio_printf(hls->pb, "#EXT-X-KEY:METHOD=AES-128,URI=\"%s\"", en->key_uri); + if (*en->iv_string) + avio_printf(hls->pb, ",IV=0x%s", en->iv_string); + avio_printf(hls->pb, "\n"); +} + static int hls_window(AVFormatContext *s, int last) { HLSContext *hls = s->priv_data; @@ -245,6 +324,8 @@ static int hls_window(AVFormatContext *s, int last) int ret = 0; int64_t sequence = FFMAX(hls->start_sequence, hls->sequence - hls->nb_entries); int version = hls->flags & HLS_SINGLE_FILE ? 4 : 3; + char *key_uri = NULL; + char *iv_string = NULL; if ((ret = avio_open2(&hls->pb, s->filename, AVIO_FLAG_WRITE, &s->interrupt_callback, NULL)) < 0) @@ -267,6 +348,13 @@ static int hls_window(AVFormatContext *s, int last) sequence); for (en = hls->segments; en; en = en->next) { + if (hls->key_info_file && (!key_uri || strcmp(en->key_uri, key_uri) || + av_strcasecmp(en->iv_string, iv_string))) { + print_encryption_tag(hls, en); + key_uri = en->key_uri; + iv_string = en->iv_string; + } + avio_printf(hls->pb, "#EXTINF:%f,\n", en->duration); if (hls->flags & HLS_SINGLE_FILE) avio_printf(hls->pb, "#EXT-X-BYTERANGE:%"PRIi64"@%"PRIi64"\n", @@ -288,6 +376,8 @@ static int hls_start(AVFormatContext *s) { HLSContext *c = s->priv_data; AVFormatContext *oc = c->avf; + AVDictionary *options = NULL; + char *filename, iv_string[KEYSIZE*2 + 1]; int err = 0; if (c->flags & HLS_SINGLE_FILE) @@ -301,9 +391,33 @@ static int hls_start(AVFormatContext *s) } c->number++; - if ((err = avio_open2(&oc->pb, oc->filename, AVIO_FLAG_WRITE, - &s->interrupt_callback, NULL)) < 0) - return err; + if (c->key_info_file) { + if ((err = hls_encryption_start(s)) < 0) + return err; + if ((err = av_dict_set(&options, "encryption_key", c->key_string, 0)) + < 0) + return err; + err = av_strlcpy(iv_string, c->iv_string, sizeof(iv_string)); + if (!err) + snprintf(iv_string, sizeof(iv_string), "%032"PRIx64, c->sequence); + if ((err = av_dict_set(&options, "encryption_iv", iv_string, 0)) < 0) + return err; + + filename = av_asprintf("crypto:%s", oc->filename); + if (!filename) { + av_dict_free(&options); + return AVERROR(ENOMEM); + } + err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE, + &s->interrupt_callback, &options); + av_free(filename); + av_dict_free(&options); + if (err < 0) + return err; + } else + if ((err = avio_open2(&oc->pb, oc->filename, AVIO_FLAG_WRITE, + &s->interrupt_callback, NULL)) < 0) + return err; if (oc->oformat->priv_class && oc->priv_data) av_opt_set(oc->priv_data, "mpegts_flags", "resend_headers", 0); @@ -501,6 +615,7 @@ static const AVOption options[] = { {"hls_allow_cache", "explicitly set whether the client MAY (1) or MUST NOT (0) cache media segments", OFFSET(allowcache), AV_OPT_TYPE_INT, {.i64 = -1}, INT_MIN, INT_MAX, E}, {"hls_base_url", "url to prepend to each playlist entry", OFFSET(baseurl), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E}, {"hls_segment_filename", "filename template for segment files", OFFSET(segment_filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E}, + {"hls_key_info_file", "file with key URI and key file path", OFFSET(key_info_file), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E}, {"hls_flags", "set flags affecting HLS playlist and media file generation", OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = 0 }, 0, UINT_MAX, E, "flags"}, {"single_file", "generate a single media file indexed with byte ranges", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_SINGLE_FILE }, 0, UINT_MAX, E, "flags"}, {"delete_segments", "delete segment files that are no longer part of the playlist", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_DELETE_SEGMENTS }, 0, UINT_MAX, E, "flags"}, -- 1.9.3 (Apple Git-50)