crypto_asdcp.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2004, Matt Beard
 *
 *  This software is provided 'as-is', without any express or implied warranty.
 *  In no event will the authors be held liable for any damages arising from
 *  the use of this software.
 *
 *  Permission is granted to anyone to use this software for any purpose,
 *  including commercial applications, and to alter it and redistribute it
 *  freely, subject to the following restrictions:
 *
 *    1. The origin of this software must not be misrepresented; you must
 *       not claim that you wrote the original software. If you use this
 *       software in a product, an acknowledgment in the product
 *       documentation would be appreciated but is not required.
 *  
 *    2. Altered source versions must be plainly marked as such, and must
 *       not be misrepresented as being the original software.
 *  
 *    3. This notice may not be removed or altered from any source
 *       distribution.
 */

#include <mxflib/mxflib.h>
using namespace mxflib;

#include <stdlib.h>

// Include AES encryption from OpenSSL
#include "openssl/aes.h"
#include "openssl/sha.h"


extern bool Hashing;

extern bool ForceKeyMode;


/*  The hashing key is: 
 *  - trunc( HMAC-SHA-1( CipherKey, 0x00112233445566778899aabbccddeeff ) )
 *  Where trunc(x) is the first 128 bits of x
 */
DataChunkPtr BuildHashKey(size_t Size, const UInt8 *CryptoKey);

/*  The hashing key is: 
 *  - trunc( HMAC-SHA-1( CipherKey, 0x00112233445566778899aabbccddeeff ) )
 *  Where trunc(x) is the first 128 bits of x
 */
inline DataChunkPtr BuildHashKey(DataChunkPtr &CryptoKey) { return BuildHashKey(CryptoKey->Size, CryptoKey->Data); }

/*  The hashing key is: 
 *  - trunc( HMAC-SHA-1( CipherKey, 0x00112233445566778899aabbccddeeff ) )
 *  Where trunc(x) is the first 128 bits of x
 */
inline DataChunkPtr BuildHashKey(DataChunk &CryptoKey) { return BuildHashKey(CryptoKey.Size, CryptoKey.Data); }


// ============================================================================

// ============================================================================

class HashHMACSHA1 : public Hash_Base
{
protected:
    UInt8 KeyBuffer_i[64];                  
    UInt8 KeyBuffer_o[64];                  

    SHA_CTX Context;                        

    bool KeyInited;                         
/*
FileHandle OutFile;
*/

public:
    HashHMACSHA1() : KeyInited(false) {}

    /*  \return True if key is accepted
     */
    bool SetKey(size_t Size, const UInt8 *Key);

    void HashData(size_t Size, const UInt8 *Data);

    DataChunkPtr GetHash(void);
};



// ============================================================================
// ============================================================================
class AESEncrypt : public Encrypt_Base
{
protected:
    AES_KEY CurrentKey;
    UInt8 CurrentIV[16];

public:

    bool SetKey(size_t KeySize, const UInt8 *Key) 
    {
        int Ret = AES_set_encrypt_key(Key, 128, &CurrentKey);

        // Return true only if key setting was OK
        return Ret ? false : true; 
    };


    bool SetIV(size_t IVSize, const UInt8 *IV, bool Force = false) 
    { 
        if(!Force) return false;

        if(IVSize != 16)
        {
            error("IV for AES encryption must by 16 bytes, tried to use IV of size %d\n", IVSize);
            return false;
        }

        memcpy(CurrentIV, IV, 16);

        return true; 
    };


    DataChunkPtr GetIV(void) 
    {
        return new DataChunk(16, CurrentIV);
    }


    bool CanEncryptInPlace(size_t BlockSize = 0) { return false; }


    bool EncryptInPlace(size_t Size, UInt8 *Data) { return false; }


    DataChunkPtr Encrypt(size_t Size, const UInt8 *Data);
};


// ============================================================================
// ============================================================================
class Encrypt_GCReadHandler : public GCReadHandler_Base
{
protected:
    UInt32 OurSID;                                  
    GCWriterPtr Writer;                             
    UUIDPtr ContextID;                              

    DataChunk EncKey;                               

    Length PlaintextOffset;                         

    IndexTablePtr Index;                            
    Position IndexPos;                              

private:
    Encrypt_GCReadHandler();                        

public:
    Encrypt_GCReadHandler(GCWriterPtr Writer, UInt32 BodySID, UUIDPtr &ContextID, DataChunkPtr KeyID, std::string KeyFileName);


    virtual bool HandleData(GCReaderPtr Caller, KLVObjectPtr Object);

    void SetPlaintextOffset(Length Offset) { PlaintextOffset = Offset; }

    void SetIndex(IndexTablePtr Index) { this->Index = Index; }
};



// ============================================================================

// ============================================================================
class Basic_GCFillerHandler : public GCReadHandler_Base
{
protected:
    UInt32 OurSID;                              
    GCWriterPtr Writer;                         

private:
    Basic_GCFillerHandler();                    

public:
    Basic_GCFillerHandler(GCWriterPtr Writer, UInt32 BodySID) : OurSID(BodySID), Writer(Writer)  {};


    virtual bool HandleData(GCReaderPtr Caller, KLVObjectPtr Object) { return true; }
};



// ============================================================================
// ============================================================================
class AESDecrypt : public Decrypt_Base
{
protected:
    AES_KEY CurrentKey;
    UInt8 CurrentIV[16];

public:

    virtual bool SetKey(size_t KeySize, const UInt8 *Key) 
    {
        int Ret = AES_set_decrypt_key(Key, 128, &CurrentKey);

        // Return true only if key setting was OK
        return Ret ? false : true; 
    };


    bool SetIV(size_t IVSize, const UInt8 *IV, bool Force = false)
    { 
        if(!Force) return false;

        if(IVSize != 16)
        {
            error("IV for AES encryption must by 16 bytes, tried to use IV of size %d\n", IVSize);
            return false;
        }

        memcpy(CurrentIV, IV, 16);

        return true; 
    };


    DataChunkPtr GetIV(void)
    {
        return new DataChunk(16, CurrentIV);
    }


    bool CanDecryptInPlace(size_t BlockSize = 0) { return false; }


    bool DecryptInPlace(size_t Size, UInt8 *Data) { return false; }


    DataChunkPtr Decrypt(size_t Size, const UInt8 *Data);
};



// ============================================================================
// ============================================================================
class Decrypt_GCEncryptionHandler : public GCReadHandler_Base
{
protected:
    UInt32 OurSID;                                      

    DataChunk DecKey;                                   

private:
    Decrypt_GCEncryptionHandler();                      

public:
    Decrypt_GCEncryptionHandler(UInt32 BodySID, DataChunkPtr KeyID, std::string KeyFileName);

    virtual bool HandleData(GCReaderPtr Caller, KLVObjectPtr Object);

    bool KeyValid(void) { return (DecKey.Size == 16); }
};


// ============================================================================

// ============================================================================
class Decrypt_GCReadHandler : public GCReadHandler_Base
{
protected:
    UInt32 OurSID;                                      
    GCWriterPtr Writer;                                 

    IndexTablePtr Index;                                
    Position IndexPos;                                  

private:
    Decrypt_GCReadHandler();                            

public:
    Decrypt_GCReadHandler(GCWriterPtr Writer, UInt32 BodySID) : OurSID(BodySID), Writer(Writer), IndexPos(0) {};


    virtual bool HandleData(GCReaderPtr Caller, KLVObjectPtr Object) 
    {
        // Update the index table to the new position
        if(Index)
        {
            Index->Update(IndexPos, (UInt64)Writer->GetStreamOffset());
        }

        // Write the data without further processing
        Writer->WriteRaw(Object);

        // Update the index position count (even if not yet indexing)
        IndexPos++;

        return true;
    }

    void SetIndex(IndexTablePtr Index) { this->Index = Index; }
};

---