crypto_params.h

// Copyright 2017 Google Inc. All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd
 
#ifndef PACKAGER_MEDIA_PUBLIC_CRYPTO_PARAMS_H_
#define PACKAGER_MEDIA_PUBLIC_CRYPTO_PARAMS_H_
 
#include <functional>
#include <map>
#include <string>
#include <vector>
 
#include "packager/status.h"
 
namespace shaka {
 
enum class KeyProvider {
  kNone,
  kRawKey,
  kWidevine,
  kPlayReady,
};
 
enum class ProtectionSystem : uint16_t {
  kNone = 0,
  kCommon = (1 << 0),
  kWidevine = (1 << 1),
  kPlayReady = (1 << 2),
  kFairPlay = (1 << 3),
  kMarlin = (1 << 4),
};
 
inline ProtectionSystem operator|(ProtectionSystem a, ProtectionSystem b) {
  return static_cast<ProtectionSystem>(static_cast<uint16_t>(a) |
                                       static_cast<uint16_t>(b));
}
inline ProtectionSystem& operator|=(ProtectionSystem& a, ProtectionSystem b) {
  return a = a | b;
}
inline ProtectionSystem operator&(ProtectionSystem a, ProtectionSystem b) {
  return static_cast<ProtectionSystem>(static_cast<uint16_t>(a) &
                                       static_cast<uint16_t>(b));
}
inline ProtectionSystem& operator&=(ProtectionSystem& a, ProtectionSystem b) {
  return a = a & b;
}
inline ProtectionSystem operator~(ProtectionSystem a) {
  return static_cast<ProtectionSystem>(~static_cast<uint16_t>(a));
}
inline bool has_flag(ProtectionSystem value, ProtectionSystem flag) {
  return (value & flag) == flag;
}
 
struct WidevineSigner {
  std::string signer_name;
 
  enum class SigningKeyType {
    kNone,
    kAes,
    kRsa,
  };
  SigningKeyType signing_key_type = SigningKeyType::kNone;
  struct {
    std::vector<uint8_t> key;
    std::vector<uint8_t> iv;
  } aes;
  struct {
    std::string key;
  } rsa;
};
 
struct WidevineEncryptionParams {
  std::string key_server_url;
  std::vector<uint8_t> content_id;
  std::string policy;
  WidevineSigner signer;
  std::vector<uint8_t> group_id;
  bool enable_entitlement_license;
};
 
struct PlayReadyEncryptionParams {
  std::string key_server_url;
  std::string program_identifier;
  std::string ca_file;
  std::string client_cert_file;
  std::string client_cert_private_key_file;
  std::string client_cert_private_key_password;
};
 
struct RawKeyParams {
  std::vector<uint8_t> iv;
  std::vector<uint8_t> pssh;
 
  using StreamLabel = std::string;
  struct KeyInfo {
    std::vector<uint8_t> key_id;
    std::vector<uint8_t> key;
    std::vector<uint8_t> iv;
  };
  std::map<StreamLabel, KeyInfo> key_map;
};
 
struct EncryptionParams {
  KeyProvider key_provider = KeyProvider::kNone;
  // Only one of the three fields is valid.
  WidevineEncryptionParams widevine;
  PlayReadyEncryptionParams playready;
  RawKeyParams raw_key;
 
  ProtectionSystem protection_systems;
  std::string playready_extra_header_data;
 
  double clear_lead_in_seconds = 0;
  static constexpr uint32_t kProtectionSchemeCenc = 0x63656E63;
  static constexpr uint32_t kProtectionSchemeCbc1 = 0x63626331;
  static constexpr uint32_t kProtectionSchemeCens = 0x63656E73;
  static constexpr uint32_t kProtectionSchemeCbcs = 0x63626373;
  uint32_t protection_scheme = kProtectionSchemeCenc;
  uint8_t crypt_byte_block = 1;
  uint8_t skip_byte_block = 9;
  static constexpr double kNoKeyRotation = 0;
  double crypto_period_duration_in_seconds = kNoKeyRotation;
  bool vp9_subsample_encryption = true;
 
  struct EncryptedStreamAttributes {
    enum StreamType {
      kUnknown,
      kVideo,
      kAudio,
    };
 
    StreamType stream_type = kUnknown;
    union OneOf {
      OneOf() {}
 
      struct {
        int width = 0;
        int height = 0;
        float frame_rate = 0;
        int bit_depth = 0;
      } video;
 
      struct {
        int number_of_channels = 0;
      } audio;
    } oneof;
  };
  std::function<std::string(const EncryptedStreamAttributes& stream_attributes)>
      stream_label_func;
};
 
struct WidevineDecryptionParams {
  std::string key_server_url;
  WidevineSigner signer;
};
 
struct DecryptionParams {
  KeyProvider key_provider = KeyProvider::kNone;
  // Only one of the two fields is valid.
  WidevineDecryptionParams widevine;
  RawKeyParams raw_key;
};
 
}  // namespace shaka
 
#endif  // PACKAGER_MEDIA_PUBLIC_CRYPTO_PARAMS_H_