WsbEcmDecrypter.h

Go to the documentation of this file.

/*****************************************************************
|
|   Wasabi - ECM Decrypter Module
|
|   $Id$
|   Original author: Edin Hodzic ([email protected])
|
|   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 _WSB_ECM_DECRYPTER_H_
#define _WSB_ECM_DECRYPTER_H_

/*----------------------------------------------------------------------
|   includes
+---------------------------------------------------------------------*/
#include "WsbTypes.h"
#include "WsbMediaFile.h"
#include "WsbKeyManager.h"

/*----------------------------------------------------------------------
|   prototypes
+---------------------------------------------------------------------*/
/*----------------------------------------------------------------------
|   types
+---------------------------------------------------------------------*/

typedef struct WSB_EcmDecrypter WSB_EcmDecrypter;

typedef enum { 
    WSB_MP2TS_KEY_EVEN, /* <- even MPEG-2 TS key */
    WSB_MP2TS_KEY_ODD   /* <- odd  MPEG-2 TS key */
} WSB_Mpeg2TsTrafficKey_Parity;

typedef enum {
    WSB_NO_TRAFFIC_PROTECTION,
    WSB_UNSUPPORTED_TRAFFIC_PROTECTION,
    WSB_MPEG2TS_CRYPT_AES_CBC_PROTECTION,
    WSB_MPEG2TS_CRYPT_AES_CBC_BBTS20_PROTECTION,
    WSB_MPEG2TS_CRYPT_DVB_CSA_PROTECTION
} WSB_Mpeg2TsTrafficKey_ProtectionSystem;


typedef enum {
    WSB_MP2TS_KEY_FORMAT_CLEAR,

    WSB_MP2TS_KEY_FORMAT_SKB
} WSB_Mpeg2TsTrafficKey_Format;

typedef enum {
    WSB_KIF_CURRENT_KEY  = (1<<0),
    WSB_KIF_CURRENT_IV   = (1<<1),
    WSB_KIF_NEXT_KEY     = (1<<2),
    WSB_KIF_NEXT_IV      = (1<<3),
    WSB_KIF_ACCESS_CRIT  = (1<<4),
    WSB_KIF_TIMESTAMP    = (1<<5),
    WSB_KIF_KEY_LIFETIME = (1<<6),
    WSB_KIF_PERMCATEGORY = (1<<7)
} WSB_KsmInfoFlag;

typedef struct {
    WSB_UInt32                               present_mask;

    WSB_Mpeg2TsTrafficKey_Format             format;
    const void*                              format_params;

    WSB_Mpeg2TsTrafficKey_Parity             current_key_parity;

    const WSB_Byte*                          current_key;
    WSB_Size                                 current_key_size;
    const WSB_Byte*                          current_iv;
    WSB_Size                                 current_iv_size;

    const WSB_Byte*                          next_key;
    WSB_Size                                 next_key_size;
    const WSB_Byte*                          next_iv;
    WSB_Size                                 next_iv_size;

    WSB_Byte*                                access_criteria;
    WSB_Size                                 access_criteria_count;
    WSB_UInt64                               timestamp;
    WSB_UInt8                                key_lifetime;
    WSB_UInt8                                permissions_category;
    WSB_Mpeg2TsTrafficKey_ProtectionSystem   protection;
} WSB_KsmInfo;

typedef struct {
    
    void* instance;

    WSB_Result (*OnNewMediaFile)(void*           instance, 
                                 WSB_MediaFile*  media_file,
                                 WSB_KeyManager* key_manager);

    void (*OnKsmInfoChange)(void*              instance, 
                            const WSB_KsmInfo* key_info,
                            WSB_UInt32         change_mask);

} WSB_EcmDecrypter_Listener;

/*----------------------------------------------------------------------
|   functions
+---------------------------------------------------------------------*/
#if defined(__cplusplus)
extern "C" {
#endif

WSB_EXPORT WSB_Result
WSB_EcmDecrypter_Create(const WSB_EcmDecrypter_Listener  listener, 
                        WSB_Mpeg2TsTrafficKey_Format     key_format,
                        const void*                      key_format_params,
                        /* returns */ WSB_EcmDecrypter** ecm_decrypter);

WSB_EXPORT WSB_Result
WSB_EcmDecrypter_Destroy(WSB_EcmDecrypter* ecm_decrypter);

WSB_EXPORT WSB_Result
WSB_EcmDecrypter_UpdatePmt(WSB_EcmDecrypter* ecm_decrypter,
                           const WSB_Byte*   pmt_table, 
                           WSB_Size          pmt_len,
                           /* returns */ 
                           WSB_UInt16*       ecm_pid);

WSB_EXPORT WSB_Result
WSB_EcmDecrypter_UpdateCat(WSB_EcmDecrypter* ecm_decrypter,
                           const WSB_Byte*   cat_table, 
                           WSB_Size          cat_len,
                           /* returns */ 
                           WSB_UInt16*       mrt_pid);

WSB_EXPORT WSB_Result
WSB_EcmDecrypter_UpdateEcm(WSB_EcmDecrypter* ecm_decrypter,
                           const WSB_Byte*   ecm_table, 
                           WSB_Size          ecm_len);

WSB_EXPORT WSB_Result
WSB_EcmDecrypter_UpdateMrt(WSB_EcmDecrypter* ecm_decrypter,
                           const WSB_Byte*   mr_table, 
                           WSB_Size          mrt_len);

#ifdef __cplusplus
}
#endif

#endif /* _WSB_ECM_DECRYPTER_H_ */