strciphr.h

Go to the documentation of this file.

// strciphr.h - originally written and placed in the public domain by Wei Dai
 
 
#ifndef CRYPTOPP_STRCIPHR_H
#define CRYPTOPP_STRCIPHR_H
 
#include "config.h"
 
#if CRYPTOPP_MSC_VERSION
# pragma warning(push)
# pragma warning(disable: 4127 4189 4231 4275)
#endif
 
#include "cryptlib.h"
#include "seckey.h"
#include "secblock.h"
#include "argnames.h"
 
NAMESPACE_BEGIN(CryptoPP)
 
 
template <class POLICY_INTERFACE, class BASE = Empty>
class CRYPTOPP_NO_VTABLE AbstractPolicyHolder : public BASE
{
public:
        typedef POLICY_INTERFACE PolicyInterface;
        virtual ~AbstractPolicyHolder() {}
 
protected:
        virtual const POLICY_INTERFACE & GetPolicy() const =0;
        virtual POLICY_INTERFACE & AccessPolicy() =0;
};
 
template <class POLICY, class BASE, class POLICY_INTERFACE = typename BASE::PolicyInterface>
class ConcretePolicyHolder : public BASE, protected POLICY
{
public:
        virtual ~ConcretePolicyHolder() {}
protected:
        const POLICY_INTERFACE & GetPolicy() const {return *this;}
        POLICY_INTERFACE & AccessPolicy() {return *this;}
};
 
enum KeystreamOperationFlags {
        OUTPUT_ALIGNED=1,
        INPUT_ALIGNED=2,
        INPUT_NULL = 4
};
 
enum KeystreamOperation {
        WRITE_KEYSTREAM                         = INPUT_NULL,
        WRITE_KEYSTREAM_ALIGNED         = INPUT_NULL | OUTPUT_ALIGNED,
        XOR_KEYSTREAM                           = 0,
        XOR_KEYSTREAM_INPUT_ALIGNED = INPUT_ALIGNED,
        XOR_KEYSTREAM_OUTPUT_ALIGNED= OUTPUT_ALIGNED,
        XOR_KEYSTREAM_BOTH_ALIGNED      = OUTPUT_ALIGNED | INPUT_ALIGNED
};
 
struct CRYPTOPP_DLL CRYPTOPP_NO_VTABLE AdditiveCipherAbstractPolicy
{
        virtual ~AdditiveCipherAbstractPolicy() {}
 
        virtual unsigned int GetAlignment() const {return 1;}
 
        virtual unsigned int GetBytesPerIteration() const =0;
 
        virtual unsigned int GetOptimalBlockSize() const {return GetBytesPerIteration();}
 
        virtual unsigned int GetIterationsToBuffer() const =0;
 
        virtual void WriteKeystream(byte *keystream, size_t iterationCount)
                {OperateKeystream(KeystreamOperation(INPUT_NULL | static_cast<KeystreamOperationFlags>(IsAlignedOn(keystream, GetAlignment()))), keystream, NULLPTR, iterationCount);}
 
        virtual bool CanOperateKeystream() const {return false;}
 
        virtual void OperateKeystream(KeystreamOperation operation, byte *output, const byte *input, size_t iterationCount)
                {CRYPTOPP_UNUSED(operation); CRYPTOPP_UNUSED(output); CRYPTOPP_UNUSED(input);
                CRYPTOPP_UNUSED(iterationCount); CRYPTOPP_ASSERT(false);}
 
        virtual void CipherSetKey(const NameValuePairs &params, const byte *key, size_t length) =0;
 
        virtual void CipherResynchronize(byte *keystreamBuffer, const byte *iv, size_t length)
                {CRYPTOPP_UNUSED(keystreamBuffer); CRYPTOPP_UNUSED(iv); CRYPTOPP_UNUSED(length);
                throw NotImplemented("SimpleKeyingInterface: this object doesn't support resynchronization");}
 
        virtual bool CipherIsRandomAccess() const =0;
 
        virtual void SeekToIteration(lword iterationCount)
                {CRYPTOPP_UNUSED(iterationCount); CRYPTOPP_ASSERT(!CipherIsRandomAccess());
                throw NotImplemented("StreamTransformation: this object doesn't support random access");}
 
        virtual std::string AlgorithmProvider() const { return "C++"; }
};
 
template <typename WT, unsigned int W, unsigned int X = 1, class BASE = AdditiveCipherAbstractPolicy>
struct CRYPTOPP_NO_VTABLE AdditiveCipherConcretePolicy : public BASE
{
        typedef WT WordType;
 
        CRYPTOPP_CONSTANT(BYTES_PER_ITERATION = sizeof(WordType) * W);
 
        virtual ~AdditiveCipherConcretePolicy() {}
 
        unsigned int GetAlignment() const {return GetAlignmentOf<WordType>();}
 
        unsigned int GetBytesPerIteration() const {return BYTES_PER_ITERATION;}
 
        unsigned int GetIterationsToBuffer() const {return X;}
 
        bool CanOperateKeystream() const {return true;}
 
        virtual void OperateKeystream(KeystreamOperation operation, byte *output, const byte *input, size_t iterationCount) =0;
};
 
#define CRYPTOPP_KEYSTREAM_OUTPUT_WORD(x, b, i, a)      \
        PutWord(((x & OUTPUT_ALIGNED) != 0), b, output+i*sizeof(WordType), (x & INPUT_NULL) ? (a) : (a) ^ GetWord<WordType>(((x & INPUT_ALIGNED) != 0), b, input+i*sizeof(WordType)));
 
#define CRYPTOPP_KEYSTREAM_OUTPUT_XMM(x, i, a)  {\
        __m128i t = (x & INPUT_NULL) ? a : _mm_xor_si128(a, (x & INPUT_ALIGNED) ? _mm_load_si128((__m128i *)input+i) : _mm_loadu_si128((__m128i *)input+i));\
        if (x & OUTPUT_ALIGNED) _mm_store_si128((__m128i *)output+i, t);\
        else _mm_storeu_si128((__m128i *)output+i, t);}
 
#define CRYPTOPP_KEYSTREAM_OUTPUT_SWITCH(x, y)          \
        switch (operation)                                                              \
        {                                                                                               \
                case WRITE_KEYSTREAM:                                           \
                        x(EnumToInt(WRITE_KEYSTREAM))   \
                        break;                                                                  \
                case XOR_KEYSTREAM:                                                     \
                        x(EnumToInt(XOR_KEYSTREAM))             \
                        input += y;                                                             \
                        break;                                                                  \
                case XOR_KEYSTREAM_INPUT_ALIGNED:                       \
                        x(EnumToInt(XOR_KEYSTREAM_INPUT_ALIGNED))               \
                        input += y;                                                             \
                        break;                                                                  \
                case XOR_KEYSTREAM_OUTPUT_ALIGNED:                      \
                        x(EnumToInt(XOR_KEYSTREAM_OUTPUT_ALIGNED))              \
                        input += y;                                                             \
                        break;                                                                  \
                case WRITE_KEYSTREAM_ALIGNED:                           \
                        x(EnumToInt(WRITE_KEYSTREAM_ALIGNED))                   \
                        break;                                                                  \
                case XOR_KEYSTREAM_BOTH_ALIGNED:                        \
                        x(EnumToInt(XOR_KEYSTREAM_BOTH_ALIGNED))                \
                        input += y;                                                             \
                        break;                                                                  \
        }                                                                                               \
        output += y;
 
template <class BASE = AbstractPolicyHolder<AdditiveCipherAbstractPolicy, SymmetricCipher> >
class CRYPTOPP_NO_VTABLE AdditiveCipherTemplate : public BASE, public RandomNumberGenerator
{
public:
        virtual ~AdditiveCipherTemplate() {}
        AdditiveCipherTemplate() : m_leftOver(0) {}
 
        void GenerateBlock(byte *output, size_t size);
 
        void ProcessData(byte *outString, const byte *inString, size_t length);
 
        void Resynchronize(const byte *iv, int length=-1);
 
        unsigned int OptimalBlockSize() const {return this->GetPolicy().GetOptimalBlockSize();}
 
        unsigned int GetOptimalNextBlockSize() const {return (unsigned int)this->m_leftOver;}
 
        unsigned int OptimalDataAlignment() const {return this->GetPolicy().GetAlignment();}
 
        bool IsSelfInverting() const {return true;}
 
        bool IsForwardTransformation() const {return true;}
 
        bool IsRandomAccess() const {return this->GetPolicy().CipherIsRandomAccess();}
 
        void Seek(lword position);
 
        std::string AlgorithmProvider() const { return this->GetPolicy().AlgorithmProvider(); }
 
        typedef typename BASE::PolicyInterface PolicyInterface;
 
protected:
        void UncheckedSetKey(const byte *key, unsigned int length, const NameValuePairs &params);
 
        unsigned int GetBufferByteSize(const PolicyInterface &policy) const {return policy.GetBytesPerIteration() * policy.GetIterationsToBuffer();}
 
        inline byte * KeystreamBufferBegin() {return this->m_buffer.data();}
        inline byte * KeystreamBufferEnd() {return (PtrAdd(this->m_buffer.data(), this->m_buffer.size()));}
 
        AlignedSecByteBlock m_buffer;
        size_t m_leftOver;
};
 
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CFB_CipherAbstractPolicy
{
public:
        virtual ~CFB_CipherAbstractPolicy() {}
 
        virtual unsigned int GetAlignment() const =0;
 
        virtual unsigned int GetBytesPerIteration() const =0;
 
        virtual byte * GetRegisterBegin() =0;
 
        virtual void TransformRegister() =0;
 
        virtual bool CanIterate() const {return false;}
 
        virtual void Iterate(byte *output, const byte *input, CipherDir dir, size_t iterationCount)
                {CRYPTOPP_UNUSED(output); CRYPTOPP_UNUSED(input); CRYPTOPP_UNUSED(dir);
                CRYPTOPP_UNUSED(iterationCount); CRYPTOPP_ASSERT(false);
                throw Exception(Exception::OTHER_ERROR, "SimpleKeyingInterface: unexpected error");}
 
        virtual void CipherSetKey(const NameValuePairs &params, const byte *key, size_t length) =0;
 
        virtual void CipherResynchronize(const byte *iv, size_t length)
                {CRYPTOPP_UNUSED(iv); CRYPTOPP_UNUSED(length);
                throw NotImplemented("SimpleKeyingInterface: this object doesn't support resynchronization");}
 
        virtual std::string AlgorithmProvider() const { return "C++"; }
};
 
template <typename WT, unsigned int W, class BASE = CFB_CipherAbstractPolicy>
struct CRYPTOPP_NO_VTABLE CFB_CipherConcretePolicy : public BASE
{
        typedef WT WordType;
 
        virtual ~CFB_CipherConcretePolicy() {}
 
        unsigned int GetAlignment() const {return sizeof(WordType);}
 
        unsigned int GetBytesPerIteration() const {return sizeof(WordType) * W;}
 
        bool CanIterate() const {return true;}
 
        void TransformRegister() {this->Iterate(NULLPTR, NULLPTR, ENCRYPTION, 1);}
 
        template <class B>
        struct RegisterOutput
        {
                RegisterOutput(byte *output, const byte *input, CipherDir dir)
                        : m_output(output), m_input(input), m_dir(dir) {}
 
                inline RegisterOutput& operator()(WordType &registerWord)
                {
                        //CRYPTOPP_ASSERT(IsAligned<WordType>(m_output));
                        //CRYPTOPP_ASSERT(IsAligned<WordType>(m_input));
 
                        if (!NativeByteOrderIs(B::ToEnum()))
                                registerWord = ByteReverse(registerWord);
 
                        if (m_dir == ENCRYPTION)
                        {
                                if (m_input == NULLPTR)
                                {
                                        CRYPTOPP_ASSERT(m_output == NULLPTR);
                                }
                                else
                                {
                                        // WordType ct = *(const WordType *)m_input ^ registerWord;
                                        WordType ct = GetWord<WordType>(false, NativeByteOrder::ToEnum(), m_input) ^ registerWord;
                                        registerWord = ct;
 
                                        // *(WordType*)m_output = ct;
                                        PutWord<WordType>(false, NativeByteOrder::ToEnum(), m_output, ct);
 
                                        m_input += sizeof(WordType);
                                        m_output += sizeof(WordType);
                                }
                        }
                        else
                        {
                                // WordType ct = *(const WordType *)m_input;
                                WordType ct = GetWord<WordType>(false, NativeByteOrder::ToEnum(), m_input);
 
                                // *(WordType*)m_output = registerWord ^ ct;
                                PutWord<WordType>(false, NativeByteOrder::ToEnum(), m_output, registerWord ^ ct);
                                registerWord = ct;
 
                                m_input += sizeof(WordType);
                                m_output += sizeof(WordType);
                        }
 
                        // registerWord is left unreversed so it can be xor-ed with further input
 
                        return *this;
                }
 
                byte *m_output;
                const byte *m_input;
                CipherDir m_dir;
        };
};
 
template <class BASE>
class CRYPTOPP_NO_VTABLE CFB_CipherTemplate : public BASE
{
public:
        virtual ~CFB_CipherTemplate() {}
        CFB_CipherTemplate() : m_leftOver(0) {}
 
        void ProcessData(byte *outString, const byte *inString, size_t length);
 
        void Resynchronize(const byte *iv, int length=-1);
 
        unsigned int OptimalBlockSize() const {return this->GetPolicy().GetBytesPerIteration();}
 
        unsigned int GetOptimalNextBlockSize() const {return (unsigned int)m_leftOver;}
 
        unsigned int OptimalDataAlignment() const {return this->GetPolicy().GetAlignment();}
 
        bool IsRandomAccess() const {return false;}
 
        bool IsSelfInverting() const {return false;}
 
        std::string AlgorithmProvider() const { return this->GetPolicy().AlgorithmProvider(); }
 
        typedef typename BASE::PolicyInterface PolicyInterface;
 
protected:
        virtual void CombineMessageAndShiftRegister(byte *output, byte *reg, const byte *message, size_t length) =0;
 
        void UncheckedSetKey(const byte *key, unsigned int length, const NameValuePairs &params);
 
        size_t m_leftOver;
};
 
template <class BASE = AbstractPolicyHolder<CFB_CipherAbstractPolicy, SymmetricCipher> >
class CRYPTOPP_NO_VTABLE CFB_EncryptionTemplate : public CFB_CipherTemplate<BASE>
{
        bool IsForwardTransformation() const {return true;}
        void CombineMessageAndShiftRegister(byte *output, byte *reg, const byte *message, size_t length);
};
 
template <class BASE = AbstractPolicyHolder<CFB_CipherAbstractPolicy, SymmetricCipher> >
class CRYPTOPP_NO_VTABLE CFB_DecryptionTemplate : public CFB_CipherTemplate<BASE>
{
        bool IsForwardTransformation() const {return false;}
        void CombineMessageAndShiftRegister(byte *output, byte *reg, const byte *message, size_t length);
};
 
template <class BASE>
class CFB_RequireFullDataBlocks : public BASE
{
public:
        unsigned int MandatoryBlockSize() const {return this->OptimalBlockSize();}
};
 
template <class BASE, class INFO = BASE>
class SymmetricCipherFinal : public AlgorithmImpl<SimpleKeyingInterfaceImpl<BASE, INFO>, INFO>
{
public:
        virtual ~SymmetricCipherFinal() {}
 
        SymmetricCipherFinal() {}
 
        SymmetricCipherFinal(const byte *key)
                {this->SetKey(key, this->DEFAULT_KEYLENGTH);}
 
        SymmetricCipherFinal(const byte *key, size_t length)
                {this->SetKey(key, length);}
 
        SymmetricCipherFinal(const byte *key, size_t length, const byte *iv)
                {this->SetKeyWithIV(key, length, iv);}
 
        Clonable * Clone() const {return static_cast<SymmetricCipher *>(new SymmetricCipherFinal<BASE, INFO>(*this));}
};
 
NAMESPACE_END
 
// Used by dll.cpp to ensure objects are in dll.o, and not strciphr.o.
#ifdef CRYPTOPP_MANUALLY_INSTANTIATE_TEMPLATES
# include "strciphr.cpp"
#endif
 
NAMESPACE_BEGIN(CryptoPP)
 
CRYPTOPP_DLL_TEMPLATE_CLASS AbstractPolicyHolder<AdditiveCipherAbstractPolicy, SymmetricCipher>;
CRYPTOPP_DLL_TEMPLATE_CLASS AdditiveCipherTemplate<AbstractPolicyHolder<AdditiveCipherAbstractPolicy, SymmetricCipher> >;
 
CRYPTOPP_DLL_TEMPLATE_CLASS CFB_CipherTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, SymmetricCipher> >;
CRYPTOPP_DLL_TEMPLATE_CLASS CFB_EncryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, SymmetricCipher> >;
CRYPTOPP_DLL_TEMPLATE_CLASS CFB_DecryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, SymmetricCipher> >;
 
NAMESPACE_END
 
#if CRYPTOPP_MSC_VERSION
# pragma warning(pop)
#endif
 
#endif