EncryptsHLSSegments::onNewEncryptionKey() - Code Metrics - Inspection of "Encrypted HLS" - protonemedia/laravel-ffmpeg - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#262)

by Pascal
created 2020-12-21 20:30 UTC
EncryptsHLSSegments::onNewEncryptionKey() A

↳ Parent: EncryptsHLSSegments
Complexity

Conditions	1
Paths	1
Size

Total Lines	5
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	2
nc	1
nop	1
dl	0
loc	5
rs	10
c	0
b	0
f	0
<?php

namespace ProtoneMedia\LaravelFFMpeg\Exporters;

use Closure;
use Illuminate\Support\Collection;
use Illuminate\Support\Str;
use ProtoneMedia\LaravelFFMpeg\FFMpeg\StdListener;
use ProtoneMedia\LaravelFFMpeg\Filesystem\Disk;

trait EncryptsHLSSegments
{
    /**
     * The encryption key.
     *
     * @var string
     */
    private $encryptionKey;

    /**
     * Gets called whenever a new encryption key is set.
     *
     * @var callable
     */
    private $onNewEncryptionKey;

    /**
     * Disk to store the secrets.
     *
     * @var \ProtoneMedia\LaravelFFMpeg\Filesystem\Disk
     */
    private $encryptionSecretsDisk;

    /**
     * Encryption IV
     *
     * @var string
     */
    private $encryptionIV;

    /**
     * Wether to rotate the key on every segment.
     *
     * @var boolean
     */
    private $rotateEncryptiongKey = false;

    /**
     * Creates a new encryption key.
     *
     * @return string
     */
    public static function generateEncryptionKey(): string
    {
        return random_bytes(16);
    }

    /**
     * Sets the encryption key with the given value or generates a new one.
     *
     * @param string $key
     * @return string
     */
    private function setEncryptionKey($key = null): string
    {
        return $this->encryptionKey = $key ?: static::generateEncryptionKey();
    }

    /**
     * Initialises the disk, info and IV for encryption and sets the key.
     *
     * @param string $key
     * @return self
     */
    public function withEncryptionKey($key = null): self
    {
        $this->encryptionSecretsDisk = Disk::makeTemporaryDisk();
        $this->encryptionIV          = bin2hex(static::generateEncryptionKey());

        $this->setEncryptionKey($key);

        return $this;
    }

    /**
     * Enables encryption with rotating keys.
     *
     * @return self
     */
    public function withRotatingEncryptionKey(): self
    {
        $this->rotateEncryptiongKey = true;

        return $this->withEncryptionKey();
    }

    /**
     * A callable for each key that is generated.
     *
     * @param Closure $callback
     * @return self
     */
    public function onNewEncryptionKey(Closure $callback): self
    {
        $this->onNewEncryptionKey = $callback;

        return $this;
    }

    /**
     * Rotates the key and returns the absolute path to the info file.
     *
     * @return string
     */
    private function rotateEncryptionKey(): string
    {
        // randomize the encryption key
        $this->encryptionSecretsDisk->put(
                                      put(
            $keyFilename = uniqid() . '.key',
            $encryptionKey = $this->setEncryptionKey()
        );

        // get the absolute path to the encryption key
        $keyPath = $this->encryptionSecretsDisk->makeMedia($keyFilename)->getLocalPath();

        // generate an info file with a reference to the encryption key and IV
        $this->encryptionSecretsDisk->put(
            HLSExporter::HLS_KEY_INFO_FILENAME,
            implode(PHP_EOL, [
                $keyPath, $keyPath, $this->encryptionIV,
            ])
        );

        // call the callback
        if ($this->onNewEncryptionKey) {
            call_user_func($this->onNewEncryptionKey, $keyFilename, $encryptionKey);
        }

        // return the absolute path to the info file
        return $this->encryptionSecretsDisk
            ->makeMedia(HLSExporter::HLS_KEY_INFO_FILENAME)
            ->getLocalPath();
    }

    /**
     * Returns an array with the encryption parameters.
     *
     * @return array
     */
    private function getEncrypedHLSParameters(): array
    {
        if (!$this->encryptionKey) {
            return [];
        }

        $keyInfoPath = $this->rotateEncryptionKey();
        $parameters  = ['-hls_key_info_file', $keyInfoPath];

        if ($this->rotateEncryptiongKey) {
            $parameters[] = '-hls_flags';
            $parameters[] = 'periodic_rekey';
        }

        return $parameters;
    }

    /**
     * Adds a listener and handler to rotate the key on
     * every new HLS segment.
     *
     * @return void
     */
    private function addHandlerToRotateEncryptionKey()
    {
        if (!$this->rotateEncryptiongKey) {
            return;
        }

        $this->addListener(new StdListener)->onEvent('listen', function ($line) {
               addListener(new StdListener)->onEvent('listen', function ($line) {
            $opensEncryptedSegment = Str::contains($line, "Opening 'crypto:/")
                && Str::contains($line, ".ts' for writing");

            if ($opensEncryptedSegment) {
                $this->rotateEncryptionKey();
            }
        });
    }

    private function replaceAbsolutePathsHLSEncryption(Collection $playlistMedia)
    {
        if (!$this->encryptionSecretsDisk) {
            return;
        }

        $playlistMedia->each(function ($playlistMedia) {
            $disk = $playlistMedia->getDisk();
            $path = $playlistMedia->getPath();

            $prefix = '#EXT-X-KEY:METHOD=AES-128,URI="';

            $content = str_replace(
                $prefix . $this->encryptionSecretsDisk->path(''),
                $prefix . $this->encryptionSecretsDisk->/** @scrutinizer ignore-call */ path(''),
                $prefix,
                $disk->get($path)
            );

            $disk->put($path, $content);
        });
    }

    /**
     * Removes the encryption keys from the temporary disk.
     *
     * @return void
     */
    private function cleanupHLSEncryption()
    {
        if (!$this->encryptionSecretsDisk) {
            return;
        }

        $paths = $this->encryptionSecretsDisk->allFiles();
        $paths = $this->encryptionSecretsDisk->allFiles();

        foreach ($paths as $path) {
            $this->encryptionSecretsDisk->delete($path);
                                          delete($path);
        }
    }
}

protonemedia / laravel-ffmpeg

Pull Request — master (#262)

EncryptsHLSSegments::onNewEncryptionKey() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
