Ts2Crypto.h

Go to the documentation of this file.

/*****************************************************************
|
|   MPEG2 Transport Stream - Crypto
|
|   $Id: Ts2Crypto.h 296 2014-06-25 11:20:09Z jebaseelir $
|   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_CRYPTO_H_
#define _TS2_CRYPTO_H_

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

/*----------------------------------------------------------------------
|   constants
+---------------------------------------------------------------------*/
#define TS2_AES_BLOCK_SIZE   16
#define TS2_AES_KEY_LENGTH   16
#define TS2_AES_CBC_IV_SIZE  16
#define TS2_SHA1_DIGEST_SIZE 20
#define TS2_SHA1_BLOCK_SIZE  64

/*----------------------------------------------------------------------
|   types
+---------------------------------------------------------------------*/
typedef struct TS2_AesBlockCipher  TS2_AesBlockCipher;
typedef struct TS2_Hmac            TS2_Hmac;
typedef struct TS2_Digest          TS2_Digest;
typedef struct TS2_AesCbcEncrypter TS2_AesCbcEncrypter;
typedef struct TS2_AesCbcDecrypter TS2_AesCbcDecrypter;

typedef enum {
    TS2_CIPHER_DIRECTION_ENCRYPT,
    TS2_CIPHER_DIRECTION_DECRYPT
} TS2_BlockCipherDirection;

typedef enum {
    TS2_DIGEST_SHA1
} TS2_DigestAlgorithm;

#ifdef __cplusplus
extern "C" {
#endif

/*----------------------------------------------------------------------
|   TS2_AesBlockCipher functions
+---------------------------------------------------------------------*/
ATX_Result TS2_AesBlockCipher_Create(const ATX_Byte*          key, 
                                     TS2_BlockCipherDirection direction,
                                     TS2_AesBlockCipher**     cipher);

void TS2_AesBlockCipher_Destroy(TS2_AesBlockCipher* self);

ATX_Result TS2_AesBlockCipher_ProcessBlock(TS2_AesBlockCipher* self,
                                           const ATX_Byte*     input,
                                           ATX_Byte*           output);

/*----------------------------------------------------------------------
|   TS2_Digest functions
+---------------------------------------------------------------------*/
ATX_Result TS2_Digest_Create(TS2_DigestAlgorithm algorithm,
                             TS2_Digest**        digest);

ATX_Result TS2_Digest_Update(TS2_Digest*     self,
                             const ATX_Byte* data,
                             ATX_Size        data_size);

ATX_Size   TS2_Digest_GetDigestSize(const TS2_Digest* self);

ATX_Size   TS2_Digest_GetBlockSize(const TS2_Digest* self);

ATX_Result TS2_Digest_Final(TS2_Digest* self,
                            ATX_Byte*   digest);

void TS2_Digest_Destroy(TS2_Digest* self);

ATX_Result TS2_ComputeDigest(TS2_DigestAlgorithm algorithm,
                             const ATX_Byte*     data,
                             ATX_Size            data_size,
                             ATX_Byte*           digest);

/*----------------------------------------------------------------------
|   TS2_Hmac functions
+---------------------------------------------------------------------*/
ATX_Result TS2_Hmac_Create(TS2_DigestAlgorithm algorithm,
                           const ATX_Byte*     key,
                           ATX_Size            key_size,
                           TS2_Hmac**          hmac);

ATX_Result TS2_Hmac_Update(TS2_Hmac*       self,
                           const ATX_Byte* data,
                           ATX_Size        data_size);
    
ATX_Size TS2_Hmac_GetMacSize(TS2_Hmac* self);

ATX_Result TS2_Hmac_Final(TS2_Hmac* self,
                          ATX_Byte* mac);

void TS2_Hmac_Destroy(TS2_Hmac* self);

ATX_Result TS2_ComputeHmac(TS2_DigestAlgorithm algorithm,
                           const ATX_Byte*     key,
                           ATX_Size            key_size,
                           const ATX_Byte*     data,
                           ATX_Size            data_size,
                           ATX_Byte*           mac);

/*----------------------------------------------------------------------
|   Prng functions
+---------------------------------------------------------------------*/
ATX_Result TS2_GeneratePseudoRandom(ATX_Byte* buffer, ATX_Size  size);
    

/*----------------------------------------------------------------------
|   TS2_AesCbcEncrypter functions
+---------------------------------------------------------------------*/
ATX_Result TS2_AesCbcEncrypter_Create(const ATX_Byte*       key,
                                      const ATX_Byte*       iv,
                                      TS2_AesCbcEncrypter** encrypter);
                                  

ATX_Result TS2_AesCbcEncrypter_Encrypt(TS2_AesCbcEncrypter* self,
                                       const ATX_Byte*      data,
                                       ATX_Size             data_size,
                                       ATX_Byte*            enc_data);


void TS2_AesCbcEncrypter_Destroy(TS2_AesCbcEncrypter* self);
    
ATX_Result TS2_AesCbcEncrypt(const ATX_Byte* key,
                             const ATX_Byte* iv,
                             const ATX_Byte* data,
                             ATX_Size        data_size,
                             ATX_Byte*       enc_data);

/*----------------------------------------------------------------------
|   TS2_AesCbcDecrypter functions
+---------------------------------------------------------------------*/
ATX_Result TS2_AesCbcDecrypter_Create(const ATX_Byte*       key,
                                      const ATX_Byte*       iv,
                                      TS2_AesCbcDecrypter** decrypter);


ATX_Result TS2_AesCbcDecrypter_Decrypt(TS2_AesCbcDecrypter* self,
                                       const ATX_Byte*      enc_data,
                                       ATX_Size             data_size,
                                       ATX_Byte*            dec_data);


void TS2_AesCbcDecrypter_Destroy(TS2_AesCbcDecrypter* self);
    
ATX_Result TS2_AesCbcDecrypt(const ATX_Byte* key,
                             const ATX_Byte* iv,
                             const ATX_Byte* enc_data,
                             ATX_Size        data_size,
                             ATX_Byte*       dec_data);
                             
    
#ifdef __cplusplus
}
#endif



#endif /* _TS2_CRYPTO_H_ */