Ts2Protection.h

Go to the documentation of this file.

/*****************************************************************
|
|   MPEG2 Transport Stream - Protection
|
|   $Id: Ts2Protection.h 354 2018-06-28 00:42:39Z pgirish $
|   Original author:  Julien Boeuf
|
|   This software is provided to you pursuant to your agreement 
|   with Intertrust Technologies Corporation ("Intertrust"). 
|   This software may be used only in accordance with the terms 
|   of the agreement.
|      
|   Copyright (c) 2010-2014 by Intertrust. All rights reserved. 
|
****************************************************************/

#ifndef _TS2_PROTECTION_H_
#define _TS2_PROTECTION_H_

/*----------------------------------------------------------------------
|   includes
+---------------------------------------------------------------------*/
#include "Atomix.h"
#include "Ts2Packet.h"
#include "Ts2Iec62455.h"
#include "Ts2Crypto.h"

/*----------------------------------------------------------------------
|   constants
+---------------------------------------------------------------------*/
#define TS2_PROTECTION_KEY_LENGTH 16

/*----------------------------------------------------------------------
|   types
+---------------------------------------------------------------------*/
typedef struct TS2_PacketEncrypter  TS2_PacketEncrypter;
typedef struct TS2_PacketDecrypter  TS2_PacketDecrypter;
typedef struct TS2_ProtectionKeyMap TS2_ProtectionKeyMap;

typedef struct TS2_Secret TS2_Secret;

typedef struct {
    void* instance;

    ATX_Result (*GetDrmKey)(void*       instance, 
                            const char* content_id,
                            ATX_Byte*   drm_key,
                            ATX_Size*   drm_key_len);
} TS2_DrmKeyResolver;

typedef enum {
    TS2_KEYFORMAT_CLEAR,   /* <- clear traffic key (can be disabled at build time) */
    TS2_KEYFORMAT_SKB      /* <- SecureKeyBox exported traffic key */
} TS2_TrafficKeyFormat;

typedef struct {
    void* instance;
    ATX_Result (*Decrypt)(void*           instance,
                          const ATX_Byte* enc_data,
                          ATX_Size        data_size,
                          ATX_Byte*       dec_data);
    void (*Destroy)(void* instance);
} TS2_SecretAesCbcDecrypter;

#define TS2_SecretAesCbcDecrypter_Decrypt(self,a,b,c) \
    self->Decrypt(self->instance,a,b,c)

#define TS2_SecretAesCbcDecrypter_Destroy(self) \
    self->Destroy(self)


typedef struct {
    void* instance;

    ATX_Result  (*GetDrmKey)(void*              instance, 
                             const char*        content_id,
                             /* returns */
                             const TS2_Secret** drm_key);

    ATX_Result (*TruncatedSha1)(void*               instance,
                                const TS2_Secret*   in_key,
                                /* returns */
                                const TS2_Secret** out_key);

    ATX_Result (*ExportSecret)(void*             instance,
                               const TS2_Secret* key,
                               /* returns */
                               ATX_Byte*         key_data,
                               ATX_Size*         key_data_size);


    ATX_Result (*GetKeyFormat)(void*                 instance, 
                               TS2_TrafficKeyFormat* key_format,
                               const void**          parameters);


    ATX_Result (*EqualSecret)(void*             instance,
                              const TS2_Secret* key_a,
                              const TS2_Secret* key_b, 
                              /*returns*/
                              ATX_Boolean*      equal);

    void        (*ReleaseSecret)(void*             instance,
                                 const TS2_Secret* secret);

    ATX_Result  (*UnwrapSecret)(void*              instance,
                                const TS2_Secret*  key,
                                const ATX_Byte*    wrapped_key,
                                ATX_Size           wrapped_key_size,
                                /* returns */
                                const TS2_Secret** unwrapped_key);

    ATX_Result  (*GetMacKey)(void*               instance,
                             const TS2_Secret*   mac_key,
                             const ATX_Byte*     data,
                             ATX_Size            data_size,
                             /* returns */
                             ATX_Byte            mac_key_output[TS2_SHA1_DIGEST_SIZE]);
    
    
    ATX_Result (*CreateSecretAesCbcDecrypter)(void*                         instance,
                                              const ATX_Byte*               key,
                                              ATX_Size                      key_size,
                                              const ATX_Byte*               iv,
                                              TS2_SecretAesCbcDecrypter**   decrypter);
} TS2_CryptoInterface;


#define TS2_Crypto_GetDrmKey(self,a,b) \
    self.GetDrmKey(self.instance,a,b)

#define TS2_Crypto_TruncatedSha1(self,in_key,out_key) \
    self.TruncatedSha1(self.instance,in_key,out_key)

#define TS2_Crypto_ExportSecret(self,a,b,c) \
    self.ExportSecret(self.instance,a,b,c)

#define TS2_Crypto_GetKeyFormat(self,a,b) \
    self.GetKeyFormat(self.instance,a,b)

#define TS2_Crypto_EqualSecret(self,a,b,c)       \
    self.EqualSecret(self.instance,a,b,c)

#define TS2_Crypto_ReleaseSecret(self,a) \
    self.ReleaseSecret(self.instance,a)

#define TS2_Crypto_UnwrapSecret(self,a,b,c,d) \
    self.UnwrapSecret(self.instance,a,b,c,d)

#define TS2_Crypto_GetMacKey(self,a,b,c,d)       \
    self.GetMacKey(self.instance,a,b,c,d)

#define TS2_Crypto_CreateSecretAesCbcDecrypter(self,a,b,c,d) \
    self.CreateSecretAesCbcDecrypter(self.instance,a,b,c,d)

typedef enum {
    TS2_NO_TRAFFIC_PROTECTION,
    TS2_UNSUPPORTED_TRAFFIC_PROTECTION,
    TS2_MPEG2TS_CRYPT_AES_CBC_PROTECTION,
    TS2_MPEG2TS_CRYPT_AES_CBC_BBTS20_PROTECTION,
    TS2_MPEG2TS_CRYPT_DVB_CSA_PROTECTION
} TS2_TrafficProtectionSystem;

#ifdef __cplusplus
extern "C" {
#elif 0
}
#endif /* __cplusplus */

/*----------------------------------------------------------------------
|   TS2_PacketEncrypter functions
+---------------------------------------------------------------------*/
ATX_Result 
TS2_PacketEncrypter_Create(TS2_TrafficProtectionSystem protection,
                           const ATX_Byte*             drm_key,
                           const ATX_Byte*             cid_extension,
                           ATX_Boolean                 is_service,
                           ATX_UInt32                  crypto_period,
                           const ATX_Byte*             traffic_seed,
                           ATX_Size                    seed_size,
                           ATX_UInt32                  segment_start_index,
                           const ATX_Byte*             common_iv,
                           ATX_Boolean                 single_key_layer,
                           TS2_KSMT*                   ksmt, /* doesn't take ownership */
                           const ATX_Byte*             access_criteria,
                           ATX_Size                    access_criteria_size,
                           TS2_PacketEncrypter**       encrypter);

ATX_Result 
TS2_PacketEncrypter_ResetDrm(TS2_PacketEncrypter* self,
                             const ATX_Byte*      drm_key,
                             const ATX_Byte*      cid_extension,
                             ATX_Boolean          is_service,
                             const ATX_Byte*      access_criteria,
                             ATX_Size             access_criteria_size);
    
ATX_Result 
TS2_PacketEncrypter_UpdateKSMT(TS2_PacketEncrypter* self);

void
TS2_PacketEncrypter_IncrementSegmentIndex(TS2_PacketEncrypter* self);

ATX_Result 
TS2_PacketEncrypter_Encrypt(TS2_PacketEncrypter* self,
                            TS2_Packet*          packet);

void 
TS2_PacketEncrypter_Destroy(TS2_PacketEncrypter* self);

/*----------------------------------------------------------------------
|   TS2_KsmDecrypter functions
+---------------------------------------------------------------------*/
typedef enum { 
    TS2_KEYPARITY_EVEN,
    TS2_KEYPARITY_ODD
} TS2_TrafficKeyParity;

typedef struct {
    ATX_Byte  tag;
    ATX_Byte  length;
    ATX_Byte* value;
} TS2_TagLengthValue;

typedef enum {
    TS2_KIF_CURRENT_KEY  = (1<<0),
    TS2_KIF_CURRENT_IV   = (1<<1),
    TS2_KIF_NEXT_KEY     = (1<<2),
    TS2_KIF_NEXT_IV      = (1<<3),
    TS2_KIF_ACCESS_CRIT  = (1<<4),
    TS2_KIF_TIMESTAMP    = (1<<5),
    TS2_KIF_KEY_LIFETIME = (1<<6),
    TS2_KIF_PERMCATEGORY = (1<<7)
} TS2_KsmInfoFlag;

typedef struct {
    ATX_UInt32                  present_mask; /* from TS2_KsmInfoFlag */

    TS2_TrafficKeyFormat        format;
    const void*                 format_params;
    TS2_TrafficKeyParity        current_key_parity;
    const ATX_Byte*             current_key;
    ATX_Size                    current_key_size;
    const ATX_Byte*             current_iv;
    ATX_Size                    current_iv_size;
    const ATX_Byte*             next_key;
    ATX_Size                    next_key_size;
    const ATX_Byte*             next_iv;
    ATX_Size                    next_iv_size;
    ATX_Byte*                   access_criteria;
    ATX_Size                    access_criteria_count;
    ATX_UInt64                  timestamp;
    ATX_UInt8                   key_lifetime;
    ATX_UInt8                   permissions_category;
    TS2_TrafficProtectionSystem protection;
} TS2_KsmInfo;

typedef struct {
    void *instance;
    void (*OnKsmInfoChange)(void *instance, 
                            const TS2_KsmInfo* ksm_info, 
                            ATX_UInt32 change_mask /* from TS2_KsmInfoFlag */);
} TS2_KsmDecrypterListener;

typedef struct TS2_KsmDecrypter TS2_KsmDecrypter;

ATX_Result 
TS2_KsmDecrypter_Create(const char*                 cid_base,
                        TS2_CryptoInterface         crypto,
                        TS2_KsmDecrypterListener    listener,
                        TS2_TrafficProtectionSystem protection,
                        ATX_UInt32                  kdf_type,
                        TS2_KsmDecrypter**          decrypter);

ATX_Result 
TS2_KsmDecrypter_UpdateKSM(TS2_KsmDecrypter* self,
                           const TS2_KSM*    ksm);

void 
TS2_KsmDecrypter_Destroy(TS2_KsmDecrypter* self);


/*----------------------------------------------------------------------
|   TS2_PacketDecrypter functions
+---------------------------------------------------------------------*/
ATX_Result 
TS2_PacketDecrypter_Create(TS2_TrafficProtectionSystem protection,
                           ATX_UInt32                  kdf_type,
                           const char*                 cid_base,
                           TS2_DrmKeyResolver          key_resolver,
                           TS2_CryptoInterface*        crypto,
                           TS2_PacketDecrypter**       decrypter);

ATX_Result 
TS2_PacketDecrypter_UpdateKSM(TS2_PacketDecrypter* self,
                              const TS2_KSM*       ksm);

ATX_Result 
TS2_PacketDecrypter_Decrypt(TS2_PacketDecrypter* self,
                            TS2_Packet*          packet);

void 
TS2_PacketDecrypter_Destroy(TS2_PacketDecrypter* self);

/*----------------------------------------------------------------------
|   TS2_ProtectionKeyMap functions
+---------------------------------------------------------------------*/
ATX_Result 
TS2_ProtectionKeyMap_Create(TS2_ProtectionKeyMap** key_map);
    
ATX_Result 
TS2_ProtectionKeyMap_SetKey(TS2_ProtectionKeyMap* self,
                            const char*           content_id,
                            const ATX_Byte*       key);
    
const ATX_Byte* 
TS2_ProtectionKeyMap_GetKey(const TS2_ProtectionKeyMap* self,
                            const char*                 content_id);

TS2_DrmKeyResolver 
TS2_ProtectionKeyMap_GetResolver(TS2_ProtectionKeyMap* self);

void 
TS2_ProtectionKeyMap_Destroy(TS2_ProtectionKeyMap* self);
    
/*----------------------------------------------------------------------
|   Key Material Generation functions
+---------------------------------------------------------------------*/
ATX_Result 
TS2_GenerateTrafficKey(const ATX_Byte* seed,
                       ATX_Size        seed_size,
                       ATX_UInt32      index,
                       ATX_Byte*       traffic_key);

ATX_Result
TS2_GenerateInitializationVector(const ATX_Byte* seed,
                                 ATX_Size        seed_size,
                                 ATX_UInt32      index,
                                 ATX_Byte*       iv);

#ifdef __cplusplus
}
#endif /* __cplusplus */


#endif /* _TS2_PROTECTION_H_ */