Зашифрованное видео в ExoPlayer

Зашифрованное видео в ExoPlayerСвой DataSource на AES/CTR с перемоткой, от ExoPlayer 2 до Media3

Видео хранится на устройстве зашифрованным и расшифровывается прямо во время воспроизведения. Пишем DataSource на AES/CTR, который поддерживает перемотку, и переносим его на Media3.

Раздел
Android
Стек
Kotlinmedia3ExoPlayerAES
Уровень
Продвинутый
Опубликовано
Обновлено
Чтение
9 мин
Коротко
  • Плеер читает байты через DataSource, его и подменяем.
  • AES/CTR позволяет расшифровывать с любого смещения.
  • ExoPlayer 2 заменён на androidx.media3, импорты меняются.
  • Для платного контента клиентский AES не заменяет Widevine.
Как решаем
  1. Зашифруйте файл в AES-CTR, IV запишите в первые 16 байт
  2. Реализуйте DataSource: open() считает блок и сдвигает IV
  3. В read() расшифровывайте через Cipher.update()
  4. Передайте фабрику в ProgressiveMediaSource.Factory
  5. Храните ключ под защитой Android Keystore

Задача: видео лежит на диске, но не должно открываться в галерее#

Типичная ситуация: приложение скачивает уроки или платные ролики для просмотра офлайн, и заказчик просит, чтобы файл нельзя было просто скопировать с устройства и открыть другим плеером. Самый короткий путь: зашифровать файл AES и расшифровывать его на лету прямо при воспроизведении, не создавая временной копии на диске.

ExoPlayer устроен так, что сам он байты не читает: этим занимается DataSource. Плеер вызывает open() с описанием нужного диапазона (DataSpec), потом многократно read(), потом close(). Значит, достаточно подсунуть свой источник, который отдаёт уже расшифрованные байты. Экстракторы MP4, буферизация и рендер ничего не заметят.

Остальные заметки про платформу собраны в разделе Android.

Почему именно AES/CTR#

Плеер не читает файл строго от начала до конца. При открытии MP4 он ищет атом moov (часто он в конце файла), а при перемотке просит данные с произвольного смещения. Поэтому режим шифрования должен позволять начать расшифровку с любого байта.

Режим AESПроизвольный seekРазмер файлаПодходит для видео
ECBдападдинг до блоканет: одинаковые блоки дают одинаковый шифротекст
CBCда, но нужен предыдущий блок как IVпаддинг до блокаможно, но сложнее и с паддингом
CTRда, счётчик считается от номера блокане меняетсяда, это наш вариант
GCMнет без разбиения на куски, тег проверяется в концеплюс 16 байт тегатолько при шифровании кусками

В CTR каждый 16-байтовый блок шифруется независимо: к открытому тексту применяется XOR с зашифрованным значением счётчика, а счётчик равен IV плюс номер блока. Чтобы прочитать байт с позиции p, считаем номер блока p / 16, прибавляем его к IV, переставляем файл на начало блока и выбрасываем p % 16 байт. Паддинга нет, длина зашифрованных данных равна длине видео, поэтому open() легко вычисляет, сколько байт осталось.

Подготовить файл можно на сервере обычным OpenSSL. Его aes-128-ctr увеличивает 128-битный счётчик так же, как Java-реализация, и файлы совместимы:

Shell
# Ключ 128 бит и случайный IV, оба в hex
KEY=$(openssl rand -hex 16)
IV=$(openssl rand -hex 16)

# Шифруем тело файла в режиме CTR (паддинга нет, размер не меняется)
openssl enc -aes-128-ctr -K "$KEY" -iv "$IV" -in clip.mp4 -out body.bin

# Кладём IV в первые 16 байт контейнера: [IV][зашифрованное видео]
printf '%s' "$IV" | xxd -r -p > clip.enc
cat body.bin >> clip.enc && rm body.bin

Вариант для ExoPlayer 2: CipherInputStream#

Первая версия этой заметки была написана под ExoPlayer 2, где интерфейс DataSource состоял из четырёх методов. Решение в лоб: поток файла, обёрнутый в CipherInputStream, плюс пересчёт IV при каждом open():

Java
public final class EncryptedFileDataSource implements DataSource {

    private static final int IV_SIZE = 16;

    private final SecretKeySpec key;
    private Uri uri;
    private FileInputStream fileStream;
    private CipherInputStream cipherStream;
    private long bytesRemaining;

    public EncryptedFileDataSource(byte[] rawKey) {
        this.key = new SecretKeySpec(rawKey, "AES");
    }

    @Override
    public long open(DataSpec dataSpec) throws IOException {
        uri = dataSpec.uri;
        File file = new File(uri.getPath());
        fileStream = new FileInputStream(file);

        byte[] iv = new byte[IV_SIZE];
        if (fileStream.read(iv) != IV_SIZE) throw new EOFException("No IV");

        long position = dataSpec.position;
        long block = position / 16;
        int skip = (int) (position % 16);

        // Переставляем файл на начало нужного блока и сдвигаем счётчик CTR
        fileStream.getChannel().position(IV_SIZE + block * 16);
        try {
            Cipher cipher = Cipher.getInstance("AES/CTR/NoPadding");
            cipher.init(Cipher.DECRYPT_MODE, key, new IvParameterSpec(addToIv(iv, block)));
            cipherStream = new CipherInputStream(fileStream, cipher);
        } catch (GeneralSecurityException e) {
            throw new IOException(e);
        }

        // Остаток внутри блока дочитываем и выбрасываем (skip() здесь не годится)
        byte[] scratch = new byte[skip];
        int done = 0;
        while (done < skip) {
            int n = cipherStream.read(scratch, done, skip - done);
            if (n == -1) throw new EOFException();
            done += n;
        }

        long available = file.length() - IV_SIZE - position;
        bytesRemaining = dataSpec.length != C.LENGTH_UNSET ? dataSpec.length : available;
        return bytesRemaining;
    }

    @Override
    public int read(byte[] buffer, int offset, int readLength) throws IOException {
        if (readLength == 0) return 0;
        if (bytesRemaining == 0) return C.RESULT_END_OF_INPUT;
        int n = cipherStream.read(buffer, offset, (int) Math.min(readLength, bytesRemaining));
        if (n == -1) return C.RESULT_END_OF_INPUT;
        bytesRemaining -= n;
        return n;
    }

    @Override
    public Uri getUri() { return uri; }

    @Override
    public void close() throws IOException {
        uri = null;
        try {
            if (cipherStream != null) cipherStream.close();
            else if (fileStream != null) fileStream.close();
        } finally {
            cipherStream = null;
            fileStream = null;
        }
    }

    static byte[] addToIv(byte[] iv, long blocks) {
        byte[] out = iv.clone();
        long carry = blocks;
        for (int i = 15; i >= 0 && carry != 0; i--) {
            long sum = (out[i] & 0xFFL) + (carry & 0xFFL);
            out[i] = (byte) sum;
            carry = (carry >>> 8) + (sum >>> 8);
        }
        return out;
    }
}

Две детали, на которых спотыкаются чаще всего:

  • Не вызывайте CipherInputStream.skip() для перемотки: он пропускает только то, что уже лежит в его внутреннем буфере, и может вернуть меньше, чем просили. Перемотка делается сдвигом самого файла и пересчётом IV.
  • Возвращайте C.RESULT_END_OF_INPUT, а не -1 по привычке: формально это одно и то же значение, но константа читается однозначно и не сломается при рефакторинге.

Современный вариант: Kotlin и androidx.media3#

Начиная с 2023 года ExoPlayer развивается внутри Jetpack Media3 (пакеты androidx.media3.*), а старая библиотека com.google.android.exoplayer2 больше не получает новых версий. Перенос в основном сводится к смене импортов, но есть смысл сразу сделать источник аккуратнее:

  • наследуемся от BaseDataSource, чтобы корректно уведомлять TransferListener (метрики пропускной способности, аналитика);
  • читаем через RandomAccessFile и вызываем Cipher.update() сами, без буферов CipherInputStream;
  • помечаем класс @OptIn(UnstableApi::class): собственные источники данных в Media3 относятся к нестабильному API.
Kotlin
@OptIn(UnstableApi::class)
class EncryptedFileDataSource(rawKey: ByteArray) : BaseDataSource(/* isNetwork = */ false) {

    private val key = SecretKeySpec(rawKey, "AES")
    private var file: RandomAccessFile? = null
    private var uri: Uri? = null
    private var cipher: Cipher? = null
    private var bytesRemaining = 0L
    private var opened = false
    private var scratch = ByteArray(16 * 1024)

    override fun open(dataSpec: DataSpec): Long {
        uri = dataSpec.uri
        transferInitializing(dataSpec)

        val raf = RandomAccessFile(requireNotNull(dataSpec.uri.path), "r").also { file = it }
        val iv = ByteArray(IV_SIZE).also { raf.readFully(it) }

        val position = dataSpec.position
        val available = raf.length() - IV_SIZE - position
        if (available < 0) throw DataSourceException(PlaybackException.ERROR_CODE_IO_READ_POSITION_OUT_OF_RANGE)

        val block = position / 16
        raf.seek(IV_SIZE + block * 16)
        cipher = Cipher.getInstance("AES/CTR/NoPadding").apply {
            init(Cipher.DECRYPT_MODE, key, IvParameterSpec(addToIv(iv, block)))
        }
        // Прокручиваем счётчик до точной позиции внутри блока
        val skip = (position % 16).toInt()
        if (skip > 0) decrypt(ByteArray(skip), 0, skip)

        bytesRemaining = if (dataSpec.length != C.LENGTH_UNSET.toLong()) dataSpec.length else available
        opened = true
        transferStarted(dataSpec)
        return bytesRemaining
    }

    override fun read(buffer: ByteArray, offset: Int, length: Int): Int {
        if (length == 0) return 0
        if (bytesRemaining == 0L) return C.RESULT_END_OF_INPUT
        val n = decrypt(buffer, offset, minOf(length.toLong(), bytesRemaining).toInt())
        if (n == -1) return C.RESULT_END_OF_INPUT
        bytesRemaining -= n
        bytesTransferred(n)
        return n
    }

    // В режиме CTR update() возвращает ровно столько байт, сколько получил
    private fun decrypt(out: ByteArray, offset: Int, length: Int): Int {
        if (scratch.size < length) scratch = ByteArray(length)
        val n = requireNotNull(file).read(scratch, 0, length)
        if (n <= 0) return -1
        return requireNotNull(cipher).update(scratch, 0, n, out, offset)
    }

    override fun getUri(): Uri? = uri

    override fun close() {
        uri = null
        cipher = null
        try {
            file?.close()
        } finally {
            file = null
            if (opened) {
                opened = false
                transferEnded()
            }
        }
    }

    private companion object {
        const val IV_SIZE = 16

        fun addToIv(iv: ByteArray, blocks: Long): ByteArray {
            val out = iv.copyOf()
            var carry = blocks
            var i = 15
            while (i >= 0 && carry != 0L) {
                val sum = (out[i].toLong() and 0xFF) + (carry and 0xFF)
                out[i] = sum.toByte()
                carry = (carry ushr 8) + (sum ushr 8)
                i--
            }
            return out
        }
    }
}

Подключение к плееру занимает несколько строк. Ключ передаём из защищённого хранилища, а не из констант в коде:

Kotlin
@OptIn(UnstableApi::class)
fun buildPlayer(context: Context, encrypted: File, key: ByteArray): ExoPlayer {
    val factory = DataSource.Factory { EncryptedFileDataSource(key) }
    val mediaSource = ProgressiveMediaSource.Factory(factory)
        .createMediaSource(MediaItem.fromUri(Uri.fromFile(encrypted)))

    return ExoPlayer.Builder(context).build().apply {
        setMediaSource(mediaSource)
        prepare()
    }
}

Если вы показываете ролики в списке с превью, пригодится заметка о том, как получить размеры изображения из ресурса без лишнего декодирования, а для поиска плееров внутри сложного макета есть приём поиска дочерних View по классу.

Что изменилось к 2026 году#

Подход с собственным DataSource по-прежнему рабочий, но вокруг него многое поменялось:

  • Media3 вместо ExoPlayer 2. Новые проекты стартуют только на androidx.media3; там же MediaSession и сервис для фонового воспроизведения.
  • Готовый AesCipherDataSource. В androidx.media3.datasource есть класс-обёртка, который расшифровывает данные из вложенного источника. Он рассчитан на свой формат (парный AesCipherDataSink и счётчик, привязанный к ключу кэша), поэтому для файлов, зашифрованных на сервере, собственный источник из этой заметки обычно проще.
  • Хранение ключа. Ключ в коде или в SharedPreferences извлекается за минуты. Минимум: генерировать ключ на устройстве и заворачивать его ключом из Android Keystore, а серверный ключ получать только после авторизации.
  • Widevine для серьёзной защиты. Если контент действительно платный, нужен DRM: ExoPlayer поддерживает Widevine через MediaItem.DrmConfiguration, а для офлайна есть загрузка и хранение лицензий. На устройствах с аппаратным уровнем защиты ключ не покидает доверенную среду и расшифрованные кадры не видны приложению.

Как проверить, что всё работает#

Ошибки в источнике данных проявляются неочевидно: видео может нормально стартовать, а сломаться только на перемотке или ближе к концу файла. Поэтому мы проверяем три сценария, прежде чем считать задачу закрытой.

  1. Побайтовое сравнение. В инструментальном тесте открываем исходный MP4 и зашифрованный файл, читаем через свой DataSource с нескольких случайных позиций, включая позиции не кратные 16, и сравниваем с оригиналом. Это сразу ловит ошибки в пересчёте IV и в пропуске байт внутри блока.
  2. Перемотка в плеере. Перематываем в начало, середину и последние секунды ролика. Если файл записан с атомом moov в конце, плеер обращается к концу файла уже при открытии, и ошибки смещения проявятся сразу.
  3. Ограниченный диапазон. Проверяем, что при заданном DataSpec.length источник не отдаёт лишних байт и корректно возвращает конец данных. Экстракторы иногда запрашивают небольшие фрагменты, и переполнение здесь приводит к странным ошибкам разбора контейнера.

Если плеер падает с ошибкой разбора контейнера, первым делом проверьте ключ и IV: неверный ключ даёт не исключение, а мусор вместо байтов, и ошибка всплывает уже в экстракторе MP4. Полезно добавить в начало файла короткий заголовок с версией формата, чтобы отличать файлы, зашифрованные разными схемами, и не гадать по симптомам.

Ещё одна мелочь, о которой забывают: close() вызывается даже тогда, когда open() бросил исключение. Поэтому все поля в close() проверяются на null, а transferEnded() вызывается только если передача действительно началась.

Честно об ограничениях клиентского шифрования#

Схема из этой заметки защищает от случайного копирования, но не от целенаправленного взлома. Ключ так или иначе оказывается в памяти процесса, и его можно достать отладчиком или хуком на Cipher.init(). Расшифрованные кадры можно записать с экрана, если не выставить FLAG_SECURE на окне.

  1. Для бесплатных и условно-закрытых материалов AES/CTR плюс ключ в Keystore обычно достаточно.
  2. Для контента, который продаётся за деньги и имеет лицензионные обязательства, выбирайте Widevine.
  3. В любом случае не храните на устройстве незашифрованную копию даже временно: кэш плеера тоже должен быть зашифрован или выключен.
Свой DataSource прячет файл от галереи, но не от человека с отладчиком; для платного контента нужен DRM.
16 байтразмер блока AES и длина IV
0 байтприрост размера файла в режиме CTR
4 методаopen, read, getUri, close в DataSource

«Свой DataSource прячет файл от галереи, но не от человека с отладчиком; для платного контента нужен DRM.»

Главный вывод заметки

Вопросы и ответы

Вопросы и ответы

Почему не зашифровать файл в AES/CBC или GCM?
CBC требует паддинга и предыдущего блока для расшифровки, а GCM проверяет тег только в конце, поэтому перемотка в нём без разбиения файла на куски невозможна. CTR не меняет размер файла и позволяет начать расшифровку с любого байта.
Нужно ли расшифровывать файл во временную копию?
Нет, и делать этого не стоит. Расшифрованная копия на диске сводит защиту на нет. DataSource отдаёт плееру уже расшифрованные байты прямо из памяти, экстракторы и рендер работают как с обычным файлом.
Работает ли этот подход с HLS или DASH?
Для потоковых форматов есть свои механизмы: в HLS сегменты шифруются AES-128 штатно, а DASH обычно используют с Widevine. Свой DataSource уместен прежде всего для одиночных локальных файлов вроде MP4.
Где хранить ключ шифрования?
Не в коде и не в открытом виде в настройках. Получайте ключ с сервера после авторизации и храните его зашифрованным ключом из Android Keystore. Это не делает взлом невозможным, но заметно усложняет его.
Заметка обновлена 12 ноября 2026: код проверен на актуальных версиях, добавлены современные варианты.

Читайте также