/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include namespace Aws { namespace Utils { namespace Json { class JsonValue; class JsonView; } // namespace Json } // namespace Utils namespace ElasticTranscoder { namespace Model { /** *

The encryption settings, if any, that are used for decrypting your input * files or encrypting your output files. If your input file is encrypted, you must * specify the mode that Elastic Transcoder uses to decrypt your file, otherwise * you must specify the mode you want Elastic Transcoder to use to encrypt your * output files.

See Also:

AWS * API Reference

*/ class Encryption { public: AWS_ELASTICTRANSCODER_API Encryption(); AWS_ELASTICTRANSCODER_API Encryption(Aws::Utils::Json::JsonView jsonValue); AWS_ELASTICTRANSCODER_API Encryption& operator=(Aws::Utils::Json::JsonView jsonValue); AWS_ELASTICTRANSCODER_API Aws::Utils::Json::JsonValue Jsonize() const; /** *

The specific server-side encryption mode that you want Elastic Transcoder to * use when decrypting your input files or encrypting your output files. Elastic * Transcoder supports the following options:

  • s3: Amazon * S3 creates and manages the keys used for encrypting your files.

  • *

    s3-aws-kms: Amazon S3 calls the Amazon Key Management Service, which * creates and manages the keys that are used for encrypting your files. If you * specify s3-aws-kms and you don't want to use the default key, you * must add the AWS-KMS key that you want to use to your pipeline.

  • *

    aes-cbc-pkcs7: A padded cipher-block mode of operation originally * used for HLS files.

  • aes-ctr: AES Counter Mode.

    *

  • aes-gcm: AES Galois Counter Mode, a mode of operation that * is an authenticated encryption format, meaning that a file, key, or * initialization vector that has been tampered with fails the decryption * process.

For all three AES options, you must provide the * following settings, which must be base64-encoded:

  • Key *

  • Key MD5

  • Initialization * Vector

For the AES modes, your private * encryption keys and your unencrypted data are never stored by AWS; therefore, it * is important that you safely manage your encryption keys. If you lose them, you * won't be able to unencrypt your data.

*/ inline const Aws::String& GetMode() const{ return m_mode; } /** *

The specific server-side encryption mode that you want Elastic Transcoder to * use when decrypting your input files or encrypting your output files. Elastic * Transcoder supports the following options:

  • s3: Amazon * S3 creates and manages the keys used for encrypting your files.

  • *

    s3-aws-kms: Amazon S3 calls the Amazon Key Management Service, which * creates and manages the keys that are used for encrypting your files. If you * specify s3-aws-kms and you don't want to use the default key, you * must add the AWS-KMS key that you want to use to your pipeline.

  • *

    aes-cbc-pkcs7: A padded cipher-block mode of operation originally * used for HLS files.

  • aes-ctr: AES Counter Mode.

    *

  • aes-gcm: AES Galois Counter Mode, a mode of operation that * is an authenticated encryption format, meaning that a file, key, or * initialization vector that has been tampered with fails the decryption * process.

For all three AES options, you must provide the * following settings, which must be base64-encoded:

  • Key *

  • Key MD5

  • Initialization * Vector

For the AES modes, your private * encryption keys and your unencrypted data are never stored by AWS; therefore, it * is important that you safely manage your encryption keys. If you lose them, you * won't be able to unencrypt your data.

*/ inline bool ModeHasBeenSet() const { return m_modeHasBeenSet; } /** *

The specific server-side encryption mode that you want Elastic Transcoder to * use when decrypting your input files or encrypting your output files. Elastic * Transcoder supports the following options:

  • s3: Amazon * S3 creates and manages the keys used for encrypting your files.

  • *

    s3-aws-kms: Amazon S3 calls the Amazon Key Management Service, which * creates and manages the keys that are used for encrypting your files. If you * specify s3-aws-kms and you don't want to use the default key, you * must add the AWS-KMS key that you want to use to your pipeline.

  • *

    aes-cbc-pkcs7: A padded cipher-block mode of operation originally * used for HLS files.

  • aes-ctr: AES Counter Mode.

    *

  • aes-gcm: AES Galois Counter Mode, a mode of operation that * is an authenticated encryption format, meaning that a file, key, or * initialization vector that has been tampered with fails the decryption * process.

For all three AES options, you must provide the * following settings, which must be base64-encoded:

  • Key *

  • Key MD5

  • Initialization * Vector

For the AES modes, your private * encryption keys and your unencrypted data are never stored by AWS; therefore, it * is important that you safely manage your encryption keys. If you lose them, you * won't be able to unencrypt your data.

*/ inline void SetMode(const Aws::String& value) { m_modeHasBeenSet = true; m_mode = value; } /** *

The specific server-side encryption mode that you want Elastic Transcoder to * use when decrypting your input files or encrypting your output files. Elastic * Transcoder supports the following options:

  • s3: Amazon * S3 creates and manages the keys used for encrypting your files.

  • *

    s3-aws-kms: Amazon S3 calls the Amazon Key Management Service, which * creates and manages the keys that are used for encrypting your files. If you * specify s3-aws-kms and you don't want to use the default key, you * must add the AWS-KMS key that you want to use to your pipeline.

  • *

    aes-cbc-pkcs7: A padded cipher-block mode of operation originally * used for HLS files.

  • aes-ctr: AES Counter Mode.

    *

  • aes-gcm: AES Galois Counter Mode, a mode of operation that * is an authenticated encryption format, meaning that a file, key, or * initialization vector that has been tampered with fails the decryption * process.

For all three AES options, you must provide the * following settings, which must be base64-encoded:

  • Key *

  • Key MD5

  • Initialization * Vector

For the AES modes, your private * encryption keys and your unencrypted data are never stored by AWS; therefore, it * is important that you safely manage your encryption keys. If you lose them, you * won't be able to unencrypt your data.

*/ inline void SetMode(Aws::String&& value) { m_modeHasBeenSet = true; m_mode = std::move(value); } /** *

The specific server-side encryption mode that you want Elastic Transcoder to * use when decrypting your input files or encrypting your output files. Elastic * Transcoder supports the following options:

  • s3: Amazon * S3 creates and manages the keys used for encrypting your files.

  • *

    s3-aws-kms: Amazon S3 calls the Amazon Key Management Service, which * creates and manages the keys that are used for encrypting your files. If you * specify s3-aws-kms and you don't want to use the default key, you * must add the AWS-KMS key that you want to use to your pipeline.

  • *

    aes-cbc-pkcs7: A padded cipher-block mode of operation originally * used for HLS files.

  • aes-ctr: AES Counter Mode.

    *

  • aes-gcm: AES Galois Counter Mode, a mode of operation that * is an authenticated encryption format, meaning that a file, key, or * initialization vector that has been tampered with fails the decryption * process.

For all three AES options, you must provide the * following settings, which must be base64-encoded:

  • Key *

  • Key MD5

  • Initialization * Vector

For the AES modes, your private * encryption keys and your unencrypted data are never stored by AWS; therefore, it * is important that you safely manage your encryption keys. If you lose them, you * won't be able to unencrypt your data.

*/ inline void SetMode(const char* value) { m_modeHasBeenSet = true; m_mode.assign(value); } /** *

The specific server-side encryption mode that you want Elastic Transcoder to * use when decrypting your input files or encrypting your output files. Elastic * Transcoder supports the following options:

  • s3: Amazon * S3 creates and manages the keys used for encrypting your files.

  • *

    s3-aws-kms: Amazon S3 calls the Amazon Key Management Service, which * creates and manages the keys that are used for encrypting your files. If you * specify s3-aws-kms and you don't want to use the default key, you * must add the AWS-KMS key that you want to use to your pipeline.

  • *

    aes-cbc-pkcs7: A padded cipher-block mode of operation originally * used for HLS files.

  • aes-ctr: AES Counter Mode.

    *

  • aes-gcm: AES Galois Counter Mode, a mode of operation that * is an authenticated encryption format, meaning that a file, key, or * initialization vector that has been tampered with fails the decryption * process.

For all three AES options, you must provide the * following settings, which must be base64-encoded:

  • Key *

  • Key MD5

  • Initialization * Vector

For the AES modes, your private * encryption keys and your unencrypted data are never stored by AWS; therefore, it * is important that you safely manage your encryption keys. If you lose them, you * won't be able to unencrypt your data.

*/ inline Encryption& WithMode(const Aws::String& value) { SetMode(value); return *this;} /** *

The specific server-side encryption mode that you want Elastic Transcoder to * use when decrypting your input files or encrypting your output files. Elastic * Transcoder supports the following options:

  • s3: Amazon * S3 creates and manages the keys used for encrypting your files.

  • *

    s3-aws-kms: Amazon S3 calls the Amazon Key Management Service, which * creates and manages the keys that are used for encrypting your files. If you * specify s3-aws-kms and you don't want to use the default key, you * must add the AWS-KMS key that you want to use to your pipeline.

  • *

    aes-cbc-pkcs7: A padded cipher-block mode of operation originally * used for HLS files.

  • aes-ctr: AES Counter Mode.

    *

  • aes-gcm: AES Galois Counter Mode, a mode of operation that * is an authenticated encryption format, meaning that a file, key, or * initialization vector that has been tampered with fails the decryption * process.

For all three AES options, you must provide the * following settings, which must be base64-encoded:

  • Key *

  • Key MD5

  • Initialization * Vector

For the AES modes, your private * encryption keys and your unencrypted data are never stored by AWS; therefore, it * is important that you safely manage your encryption keys. If you lose them, you * won't be able to unencrypt your data.

*/ inline Encryption& WithMode(Aws::String&& value) { SetMode(std::move(value)); return *this;} /** *

The specific server-side encryption mode that you want Elastic Transcoder to * use when decrypting your input files or encrypting your output files. Elastic * Transcoder supports the following options:

  • s3: Amazon * S3 creates and manages the keys used for encrypting your files.

  • *

    s3-aws-kms: Amazon S3 calls the Amazon Key Management Service, which * creates and manages the keys that are used for encrypting your files. If you * specify s3-aws-kms and you don't want to use the default key, you * must add the AWS-KMS key that you want to use to your pipeline.

  • *

    aes-cbc-pkcs7: A padded cipher-block mode of operation originally * used for HLS files.

  • aes-ctr: AES Counter Mode.

    *

  • aes-gcm: AES Galois Counter Mode, a mode of operation that * is an authenticated encryption format, meaning that a file, key, or * initialization vector that has been tampered with fails the decryption * process.

For all three AES options, you must provide the * following settings, which must be base64-encoded:

  • Key *

  • Key MD5

  • Initialization * Vector

For the AES modes, your private * encryption keys and your unencrypted data are never stored by AWS; therefore, it * is important that you safely manage your encryption keys. If you lose them, you * won't be able to unencrypt your data.

*/ inline Encryption& WithMode(const char* value) { SetMode(value); return *this;} /** *

The data encryption key that you want Elastic Transcoder to use to encrypt * your output file, or that was used to encrypt your input file. The key must be * base64-encoded and it must be one of the following bit lengths before being * base64-encoded:

128, 192, or 256. *

The key must also be encrypted by using the Amazon Key Management * Service.

*/ inline const Aws::String& GetKey() const{ return m_key; } /** *

The data encryption key that you want Elastic Transcoder to use to encrypt * your output file, or that was used to encrypt your input file. The key must be * base64-encoded and it must be one of the following bit lengths before being * base64-encoded:

128, 192, or 256. *

The key must also be encrypted by using the Amazon Key Management * Service.

*/ inline bool KeyHasBeenSet() const { return m_keyHasBeenSet; } /** *

The data encryption key that you want Elastic Transcoder to use to encrypt * your output file, or that was used to encrypt your input file. The key must be * base64-encoded and it must be one of the following bit lengths before being * base64-encoded:

128, 192, or 256. *

The key must also be encrypted by using the Amazon Key Management * Service.

*/ inline void SetKey(const Aws::String& value) { m_keyHasBeenSet = true; m_key = value; } /** *

The data encryption key that you want Elastic Transcoder to use to encrypt * your output file, or that was used to encrypt your input file. The key must be * base64-encoded and it must be one of the following bit lengths before being * base64-encoded:

128, 192, or 256. *

The key must also be encrypted by using the Amazon Key Management * Service.

*/ inline void SetKey(Aws::String&& value) { m_keyHasBeenSet = true; m_key = std::move(value); } /** *

The data encryption key that you want Elastic Transcoder to use to encrypt * your output file, or that was used to encrypt your input file. The key must be * base64-encoded and it must be one of the following bit lengths before being * base64-encoded:

128, 192, or 256. *

The key must also be encrypted by using the Amazon Key Management * Service.

*/ inline void SetKey(const char* value) { m_keyHasBeenSet = true; m_key.assign(value); } /** *

The data encryption key that you want Elastic Transcoder to use to encrypt * your output file, or that was used to encrypt your input file. The key must be * base64-encoded and it must be one of the following bit lengths before being * base64-encoded:

128, 192, or 256. *

The key must also be encrypted by using the Amazon Key Management * Service.

*/ inline Encryption& WithKey(const Aws::String& value) { SetKey(value); return *this;} /** *

The data encryption key that you want Elastic Transcoder to use to encrypt * your output file, or that was used to encrypt your input file. The key must be * base64-encoded and it must be one of the following bit lengths before being * base64-encoded:

128, 192, or 256. *

The key must also be encrypted by using the Amazon Key Management * Service.

*/ inline Encryption& WithKey(Aws::String&& value) { SetKey(std::move(value)); return *this;} /** *

The data encryption key that you want Elastic Transcoder to use to encrypt * your output file, or that was used to encrypt your input file. The key must be * base64-encoded and it must be one of the following bit lengths before being * base64-encoded:

128, 192, or 256. *

The key must also be encrypted by using the Amazon Key Management * Service.

*/ inline Encryption& WithKey(const char* value) { SetKey(value); return *this;} /** *

The MD5 digest of the key that you used to encrypt your input file, or that * you want Elastic Transcoder to use to encrypt your output file. Elastic * Transcoder uses the key digest as a checksum to make sure your key was not * corrupted in transit. The key MD5 must be base64-encoded, and it must be exactly * 16 bytes long before being base64-encoded.

*/ inline const Aws::String& GetKeyMd5() const{ return m_keyMd5; } /** *

The MD5 digest of the key that you used to encrypt your input file, or that * you want Elastic Transcoder to use to encrypt your output file. Elastic * Transcoder uses the key digest as a checksum to make sure your key was not * corrupted in transit. The key MD5 must be base64-encoded, and it must be exactly * 16 bytes long before being base64-encoded.

*/ inline bool KeyMd5HasBeenSet() const { return m_keyMd5HasBeenSet; } /** *

The MD5 digest of the key that you used to encrypt your input file, or that * you want Elastic Transcoder to use to encrypt your output file. Elastic * Transcoder uses the key digest as a checksum to make sure your key was not * corrupted in transit. The key MD5 must be base64-encoded, and it must be exactly * 16 bytes long before being base64-encoded.

*/ inline void SetKeyMd5(const Aws::String& value) { m_keyMd5HasBeenSet = true; m_keyMd5 = value; } /** *

The MD5 digest of the key that you used to encrypt your input file, or that * you want Elastic Transcoder to use to encrypt your output file. Elastic * Transcoder uses the key digest as a checksum to make sure your key was not * corrupted in transit. The key MD5 must be base64-encoded, and it must be exactly * 16 bytes long before being base64-encoded.

*/ inline void SetKeyMd5(Aws::String&& value) { m_keyMd5HasBeenSet = true; m_keyMd5 = std::move(value); } /** *

The MD5 digest of the key that you used to encrypt your input file, or that * you want Elastic Transcoder to use to encrypt your output file. Elastic * Transcoder uses the key digest as a checksum to make sure your key was not * corrupted in transit. The key MD5 must be base64-encoded, and it must be exactly * 16 bytes long before being base64-encoded.

*/ inline void SetKeyMd5(const char* value) { m_keyMd5HasBeenSet = true; m_keyMd5.assign(value); } /** *

The MD5 digest of the key that you used to encrypt your input file, or that * you want Elastic Transcoder to use to encrypt your output file. Elastic * Transcoder uses the key digest as a checksum to make sure your key was not * corrupted in transit. The key MD5 must be base64-encoded, and it must be exactly * 16 bytes long before being base64-encoded.

*/ inline Encryption& WithKeyMd5(const Aws::String& value) { SetKeyMd5(value); return *this;} /** *

The MD5 digest of the key that you used to encrypt your input file, or that * you want Elastic Transcoder to use to encrypt your output file. Elastic * Transcoder uses the key digest as a checksum to make sure your key was not * corrupted in transit. The key MD5 must be base64-encoded, and it must be exactly * 16 bytes long before being base64-encoded.

*/ inline Encryption& WithKeyMd5(Aws::String&& value) { SetKeyMd5(std::move(value)); return *this;} /** *

The MD5 digest of the key that you used to encrypt your input file, or that * you want Elastic Transcoder to use to encrypt your output file. Elastic * Transcoder uses the key digest as a checksum to make sure your key was not * corrupted in transit. The key MD5 must be base64-encoded, and it must be exactly * 16 bytes long before being base64-encoded.

*/ inline Encryption& WithKeyMd5(const char* value) { SetKeyMd5(value); return *this;} /** *

The series of random bits created by a random bit generator, unique for every * encryption operation, that you used to encrypt your input files or that you want * Elastic Transcoder to use to encrypt your output files. The initialization * vector must be base64-encoded, and it must be exactly 16 bytes long before being * base64-encoded.

*/ inline const Aws::String& GetInitializationVector() const{ return m_initializationVector; } /** *

The series of random bits created by a random bit generator, unique for every * encryption operation, that you used to encrypt your input files or that you want * Elastic Transcoder to use to encrypt your output files. The initialization * vector must be base64-encoded, and it must be exactly 16 bytes long before being * base64-encoded.

*/ inline bool InitializationVectorHasBeenSet() const { return m_initializationVectorHasBeenSet; } /** *

The series of random bits created by a random bit generator, unique for every * encryption operation, that you used to encrypt your input files or that you want * Elastic Transcoder to use to encrypt your output files. The initialization * vector must be base64-encoded, and it must be exactly 16 bytes long before being * base64-encoded.

*/ inline void SetInitializationVector(const Aws::String& value) { m_initializationVectorHasBeenSet = true; m_initializationVector = value; } /** *

The series of random bits created by a random bit generator, unique for every * encryption operation, that you used to encrypt your input files or that you want * Elastic Transcoder to use to encrypt your output files. The initialization * vector must be base64-encoded, and it must be exactly 16 bytes long before being * base64-encoded.

*/ inline void SetInitializationVector(Aws::String&& value) { m_initializationVectorHasBeenSet = true; m_initializationVector = std::move(value); } /** *

The series of random bits created by a random bit generator, unique for every * encryption operation, that you used to encrypt your input files or that you want * Elastic Transcoder to use to encrypt your output files. The initialization * vector must be base64-encoded, and it must be exactly 16 bytes long before being * base64-encoded.

*/ inline void SetInitializationVector(const char* value) { m_initializationVectorHasBeenSet = true; m_initializationVector.assign(value); } /** *

The series of random bits created by a random bit generator, unique for every * encryption operation, that you used to encrypt your input files or that you want * Elastic Transcoder to use to encrypt your output files. The initialization * vector must be base64-encoded, and it must be exactly 16 bytes long before being * base64-encoded.

*/ inline Encryption& WithInitializationVector(const Aws::String& value) { SetInitializationVector(value); return *this;} /** *

The series of random bits created by a random bit generator, unique for every * encryption operation, that you used to encrypt your input files or that you want * Elastic Transcoder to use to encrypt your output files. The initialization * vector must be base64-encoded, and it must be exactly 16 bytes long before being * base64-encoded.

*/ inline Encryption& WithInitializationVector(Aws::String&& value) { SetInitializationVector(std::move(value)); return *this;} /** *

The series of random bits created by a random bit generator, unique for every * encryption operation, that you used to encrypt your input files or that you want * Elastic Transcoder to use to encrypt your output files. The initialization * vector must be base64-encoded, and it must be exactly 16 bytes long before being * base64-encoded.

*/ inline Encryption& WithInitializationVector(const char* value) { SetInitializationVector(value); return *this;} private: Aws::String m_mode; bool m_modeHasBeenSet = false; Aws::String m_key; bool m_keyHasBeenSet = false; Aws::String m_keyMd5; bool m_keyMd5HasBeenSet = false; Aws::String m_initializationVector; bool m_initializationVectorHasBeenSet = false; }; } // namespace Model } // namespace ElasticTranscoder } // namespace Aws