Struct hls_m3u8::types::DecryptionKey

#[non_exhaustive]
pub struct DecryptionKey<'a> {
    pub method: EncryptionMethod,
    pub iv: InitializationVector,
    pub format: Option<KeyFormat>,
    pub versions: Option<KeyFormatVersions>,
    // some fields omitted
}

Specifies how to decrypt encrypted data from the server.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

method: EncryptionMethod

The encryption method, which has been used to encrypt the data.

An EncryptionMethod::Aes128 signals that the data is encrypted using the Advanced Encryption Standard (AES) with a 128-bit key, Cipher Block Chaining (CBC), and Public-Key Cryptography Standards #7 (PKCS7) padding. CBC is restarted on each segment boundary, using either the DecryptionKey::iv field or the MediaSegment::number as the IV.

An EncryptionMethod::SampleAes means that the MediaSegments contain media samples, such as audio or video, that are encrypted using the Advanced Encryption Standard (Aes128). How these media streams are encrypted and encapsulated in a segment depends on the media encoding and the media format of the segment.

Note

This field is required.

iv: InitializationVector

An initialization vector (IV) is a fixed size input that can be used along with a secret key for data encryption.

Note

This field is optional and an absent value indicates that MediaSegment::number should be used instead.

format: Option<KeyFormat>

A server may offer multiple ways to retrieve a key by providing multiple DecryptionKeys with different KeyFormat values.

An EncryptionMethod::Aes128 uses 16-octet (16 byte/128 bit) keys. If the format is KeyFormat::Identity, the key file is a single packed array of 16 octets (16 byte/128 bit) in binary format.

Note

This field is optional.

versions: Option<KeyFormatVersions>

A list of numbers that can be used to indicate which version(s) this instance complies with, if more than one version of a particular KeyFormat is defined.

Note

This field is optional.

Implementations

impl<'a> DecryptionKey<'a>

pub fn uri(&self) -> &Cow<'a, str>

This uri points to a key file, which contains the cipher key.

Note

This field is required.

pub fn set_uri<VALUE: Into<Cow<'a, str>>>(&mut self, value: VALUE) -> &mut Self

This uri points to a key file, which contains the cipher key.

Note

This field is required.

impl<'a> DecryptionKey<'a>

pub fn new<I: Into<Cow<'a, str>>>(method: EncryptionMethod, uri: I) -> Self

Creates a new DecryptionKey from an uri pointing to the key data and an EncryptionMethod.

Example

use hls_m3u8::types::EncryptionMethod;

let key = DecryptionKey::new(EncryptionMethod::Aes128, "https://www.example.uri/key");

pub fn builder() -> DecryptionKeyBuilder<'a>

Returns a builder for a DecryptionKey.

Example

use hls_m3u8::types::{EncryptionMethod, KeyFormat};

let key = DecryptionKey::builder()
    .method(EncryptionMethod::Aes128)
    .uri("https://www.example.com/")
    .iv([
        16, 239, 143, 117, 140, 165, 85, 17, 85, 132, 187, 91, 60, 104, 127, 82,
    ])
    .format(KeyFormat::Identity)
    .versions(&[1, 2, 3, 4, 5])
    .build()?;

pub fn into_owned(self) -> DecryptionKey<'static>

Makes the struct independent of its lifetime, by taking ownership of all internal Cows.

Note

This is a relatively expensive operation.

Trait Implementations

impl<'a> AsMut<DecryptionKey<'a>> for ExtXSessionKey<'a>

fn as_mut(&mut self) -> &mut DecryptionKey<'a>

Performs the conversion.

impl<'a> AsRef<DecryptionKey<'a>> for ExtXSessionKey<'a>

fn as_ref(&self) -> &DecryptionKey<'a>

Performs the conversion.

impl<'a> Clone for DecryptionKey<'a>

fn clone(&self) -> DecryptionKey<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for DecryptionKey<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Display for DecryptionKey<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> From<DecryptionKey<'a>> for ExtXSessionKey<'a>

fn from(original: DecryptionKey<'a>) -> ExtXSessionKey<'a>

Performs the conversion.

impl<'a> From<DecryptionKey<'a>> for ExtXKey<'a>

fn from(value: DecryptionKey<'a>) -> Self

Performs the conversion.

impl<'a> Hash for DecryptionKey<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<'a> Ord for DecryptionKey<'a>

fn cmp(&self, other: &DecryptionKey<'a>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<'a> PartialEq<DecryptionKey<'a>> for DecryptionKey<'a>

fn eq(&self, other: &DecryptionKey<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &DecryptionKey<'a>) -> bool

This method tests for !=.

impl<'a> PartialOrd<DecryptionKey<'a>> for DecryptionKey<'a>

fn partial_cmp(&self, other: &DecryptionKey<'a>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> TryFrom<&'a str> for DecryptionKey<'a>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(input: &'a str) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> Eq for DecryptionKey<'a>

impl<'a> StructuralEq for DecryptionKey<'a>

impl<'a> StructuralPartialEq for DecryptionKey<'a>