crypto.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.
 */
#ifndef MXFLIB__CRYPTO_H
#define MXFLIB__CRYPTO_H


#include <map>
#include <list>


// Forward refs
namespace mxflib
{
}


namespace mxflib
{

    class Encrypt_Base : public RefCount<Encrypt_Base>
    {
    public:
        Encrypt_Base() {};
        virtual ~Encrypt_Base() {};


        bool SetKey(DataChunk &Key) { return SetKey(Key.Size, Key.Data); }


        bool SetKey(DataChunkPtr &Key) { return SetKey(Key->Size, Key->Data); }


        virtual bool SetKey(size_t KeySize, const UInt8 *Key) = 0;


        virtual bool SetIV(size_t IVSize, const UInt8 *IV, bool Force = false) = 0;


        bool SetIV(DataChunk &IV, bool Force = false) { return SetIV(IV.Size, IV.Data, Force); }


        bool SetIV(DataChunkPtr &IV, bool Force = false) { return SetIV(IV->Size, IV->Data, Force); }


        virtual DataChunkPtr GetIV(void) = 0;


        virtual bool CanEncryptInPlace(size_t BlockSize = 0) = 0;


        virtual bool EncryptInPlace(size_t Size, UInt8 *Data) = 0;


        bool EncryptInPlace(DataChunk &Data) { return EncryptInPlace(Data.Size, Data.Data); };


        bool EncryptInPlace(DataChunkPtr &Data) { return EncryptInPlace(Data->Size, Data->Data); };


        virtual DataChunkPtr Encrypt(size_t Size, const UInt8 *Data) = 0;


        DataChunkPtr Encrypt(DataChunk &Data) { return Encrypt(Data.Size, Data.Data); };


        DataChunkPtr Encrypt(DataChunkPtr &Data) { return Encrypt(Data->Size, Data->Data); };
    };

    // Smart pointer to an encryption wrapper object
    typedef SmartPtr<Encrypt_Base> EncryptPtr;



    class Decrypt_Base : public RefCount<Decrypt_Base>
    {
    public:
        Decrypt_Base() {};
        virtual ~Decrypt_Base() {};


        bool SetKey(DataChunk &Key) { return SetKey(Key.Size, Key.Data); }


        bool SetKey(DataChunkPtr &Key) { return SetKey(Key->Size, Key->Data); }


        virtual bool SetKey(size_t KeySize, const UInt8 *Key) = 0;


        virtual bool SetIV(size_t IVSize, const UInt8 *IV, bool Force = false) = 0;


        bool SetIV(DataChunk &IV, bool Force = false) { return SetIV(IV.Size, IV.Data, Force); }


        bool SetIV(DataChunkPtr &IV, bool Force = false) { return SetIV(IV->Size, IV->Data, Force); }


        virtual DataChunkPtr GetIV(void) = 0;


        virtual bool CanDecryptInPlace(size_t BlockSize = 0) = 0;


        virtual bool DecryptInPlace(size_t Size, UInt8 *Data) = 0;


        bool DecryptInPlace(DataChunk &Data) { return DecryptInPlace(Data.Size, Data.Data); };


        bool DecryptInPlace(DataChunkPtr &Data) { return DecryptInPlace(Data->Size, Data->Data); };


        virtual DataChunkPtr Decrypt(size_t Size, const UInt8 *Data) = 0;


        DataChunkPtr Decrypt(DataChunk &Data) { return Decrypt(Data.Size, Data.Data); };


        DataChunkPtr Decrypt(DataChunkPtr &Data) { return Decrypt(Data->Size, Data->Data); };
    };

    // Smart pointer to a decryption wrapper object
    typedef SmartPtr<Decrypt_Base> DecryptPtr;



    class Hash_Base : public RefCount<Hash_Base>
    {
    public:
        Hash_Base() {};

        // Virtual base destructor to allow polymorphic destruction
        virtual ~Hash_Base() {};


        bool SetKey(DataChunk &Key) { return SetKey(Key.Size, Key.Data); }


        bool SetKey(DataChunkPtr &Key) { return SetKey(Key->Size, Key->Data); }


        virtual bool SetKey(size_t Size, const UInt8 *Key) 
        { 
            UNUSED_PARAMETER(Key); 
            UNUSED_PARAMETER(Size); 
            return true;
        };

        void HashData(DataChunk &Data) { HashData(Data.Size, Data.Data); }

        void HashData(DataChunkPtr &Data) { HashData(Data->Size, Data->Data); }

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

        virtual DataChunkPtr GetHash(void) = 0;
    };

    // Smart pointer to a hash function wrapper object
    typedef SmartPtr<Hash_Base> HashPtr;



    class KLVEObject : public KLVObject
    {
    protected:
        /* Some useful constants */
        enum { EncryptionOverhead = 32 };

        enum { EncryptionGranularity = 16 };

        EncryptPtr  Encrypt;                        
        DecryptPtr  Decrypt;                        
        HashPtr WriteHasher;                        
        HashPtr ReadHasher;                         

        bool DataLoaded;                            
        UUIDPtr ContextID;                          
        Length PlaintextOffset;                     

        ULPtr SourceKey;                            
        Length EncryptedLength;                     
        int SourceLengthFormat;                     
        UInt8 IV[16];                               
        UInt8 Check[16];                            
        UUIDPtr TrackFileID;                        
        UInt64 SequenceNumber;                      
        bool HasSequenceNumber;                     
        DataChunkPtr MIC;                           

        size_t DataOffset;                          

        DataChunkPtr EncryptionIV;                  

        Position CurrentReadOffset;                 
        Position CurrentWriteOffset;                

        int PreDecrypted;                           
        UInt8 PreDecryptBuffer[EncryptionGranularity];

        int AwaitingEncryption;                     
        UInt8 AwaitingEncryptionBuffer[EncryptionGranularity];

        UInt32 FooterLength;                        

    public:
        //** KLVEObject Specifics **//

        void SetEncrypt(EncryptPtr NewWrapper) { Encrypt = NewWrapper; };

        void SetDecrypt(DecryptPtr NewWrapper) { Decrypt = NewWrapper; };


        void SetWriteHasher(HashPtr &Hasher) { WriteHasher = Hasher; };


        void SetReadHasher(HashPtr &Hasher) { ReadHasher = Hasher; };



        virtual bool SetEncryptIV(size_t IVSize, const UInt8 *IV, bool Force = false)
        {
            Force = !(!Force);      // Unused parameter

            EncryptionIV = new DataChunk(IVSize, IV);

            return true;
        }


        virtual bool SetDecryptIV(size_t IVSize, const UInt8 *IV, bool Force = false);

        virtual DataChunkPtr GetEncryptIV(void);

        virtual DataChunkPtr GetDecryptIV(void);

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

        Length GetPlaintextOffset(void) { return PlaintextOffset; }

        //** Construction / desctruction **//
        KLVEObject(ULPtr ObjectUL);             
        KLVEObject(KLVObjectPtr &Object);       
        virtual void Init(void);
        virtual ~KLVEObject() {};


        //** KLVObject interfaces **//
        /* DRAGONS: We should prune these and fall back where possible? */

        virtual ULPtr GetUL(void) 
        { 
            // If we are decrypting, ensure we know the proper plaintext UL
            if(Decrypt && (!DataLoaded)) LoadData();

            return TheUL; 
        }

        virtual void SetUL(ULPtr NewUL) { TheUL = NewUL; }


        virtual Int32 GetKLSize(void);

        virtual GCElementKind GetGCElementKind(void);

        virtual UInt32 GetGCTrackNumber(void);

        virtual std::string GetSource(void);


        virtual Int32 ReadKL(void);


        virtual size_t ReadData(size_t Size = static_cast<size_t>(-1)) { return Base_ReadDataFrom(0, Size); }


        virtual size_t ReadDataFrom(Position Offset, size_t Size = static_cast<size_t>(-1));


        virtual Int32 WriteKL(Int32 LenSize = 0);


        virtual size_t WriteData(size_t Size = static_cast<size_t>(-1)) { return WriteDataFromTo(0, 0, Size); }


        virtual size_t WriteDataFrom(Position Start, size_t Size = static_cast<size_t>(-1)) { return WriteDataFromTo(0, Start, Size); }


        virtual size_t WriteDataTo(Position Offset, size_t Size = static_cast<size_t>(-1)) { return WriteDataFromTo(Offset, 0, Size); }


        virtual size_t WriteDataFromTo(Position Offset, Position Start, size_t Size = static_cast<size_t>(-1))
        {
            // Calculate default number of bytes to write
            Length BytesToWrite = Data.Size - Start;

            // Write the requested size (if valid)
            if((Size != static_cast<size_t>(-1)) && (Size < BytesToWrite)) BytesToWrite = Size;

            // Sanity check the size of this chunk
            if((sizeof(size_t) < 8) && (BytesToWrite > 0xffffffff))
            {
                error("Tried to write > 4GBytes, but this platform can only handle <= 4GByte chunks\n");
                return 0;
            }

            return WriteDataTo(&Data.Data[Start], Offset, static_cast<size_t>(BytesToWrite));
        }


        virtual size_t WriteDataTo(const UInt8 *Buffer, Position Offset, size_t Size);

        virtual Length GetLength(void) 
        { 
            return ValueLength;
        }

        virtual void SetLength(Length NewLength) 
        { 
            ValueLength = NewLength; 

            // Update encrypted length to take account of padding
            EncryptedLength = (ValueLength + EncryptionGranularity) / EncryptionGranularity;
            EncryptedLength *= EncryptionGranularity;
        }

        void SetContextID(UUIDPtr &Context) { ContextID = Context; }

        UUIDPtr &GetContextID(void) { return ContextID; }

    protected:

        bool LoadData(void);


        bool ReadFooter(void);


        UInt32 CalcFooterLength(void);


        bool WriteFooter(void);


        size_t ReadCryptoDataFrom(Position Offset, size_t Size = static_cast<size_t>(-1));


        size_t ReadChunkedCryptoDataFrom(Position Offset, size_t Size);
    

        size_t WriteCryptoDataTo(const UInt8 *Buffer, Position Offset, size_t Size);
    };


    class KLVEObjectPtr : public SmartPtr<KLVEObject>
    {
    public:
        KLVEObjectPtr() : SmartPtr<KLVEObject>() {}

        KLVEObjectPtr(IRefCount<KLVObject> * ptr) : SmartPtr<KLVEObject>((IRefCount<KLVEObject>*)ptr) {};

        KLVEObjectPtr & operator = (IRefCount<KLVObject> * ptr) {__Assign((IRefCount<KLVEObject>*)ptr); return *this;}
    };
}


#endif // MXFLIB__CRYPTO_H

---