default.h

Go to the documentation of this file.

// default.h - written and placed in the public domain by Wei Dai


#ifndef CRYPTOPP_DEFAULT_H
#define CRYPTOPP_DEFAULT_H

#include "sha.h"
#include "hmac.h"
#include "aes.h"
#include "des.h"
#include "modes.h"
#include "filters.h"
#include "smartptr.h"

NAMESPACE_BEGIN(CryptoPP)

typedef DES_EDE2 LegacyBlockCipher;
typedef SHA LegacyHashModule;
typedef HMAC<LegacyHashModule> LegacyMAC;

typedef AES DefaultBlockCipher;
typedef SHA256 DefaultHashModule;
typedef HMAC<DefaultHashModule> DefaultMAC;

class DataDecryptorErr : public Exception
{
public:
        DataDecryptorErr(const std::string &s)
                : Exception(DATA_INTEGRITY_CHECK_FAILED, s) {}
};

class KeyBadErr : public DataDecryptorErr
{
        public: KeyBadErr()
                : DataDecryptorErr("DataDecryptor: cannot decrypt message with this passphrase") {}
};

class MACBadErr : public DataDecryptorErr
{
        public: MACBadErr()
                : DataDecryptorErr("DataDecryptorWithMAC: MAC check failed") {}
};

template <unsigned int BlockSize, unsigned int KeyLength, unsigned int DigestSize, unsigned int SaltSize, unsigned int Iterations>
struct DataParametersInfo
{
        CRYPTOPP_CONSTANT(BLOCKSIZE  = BlockSize)
        CRYPTOPP_CONSTANT(KEYLENGTH  = KeyLength)
        CRYPTOPP_CONSTANT(SALTLENGTH = SaltSize)
        CRYPTOPP_CONSTANT(DIGESTSIZE = DigestSize)
        CRYPTOPP_CONSTANT(ITERATIONS = Iterations)
};

typedef DataParametersInfo<LegacyBlockCipher::BLOCKSIZE, LegacyBlockCipher::DEFAULT_KEYLENGTH, LegacyHashModule::DIGESTSIZE, 8, 200> LegacyParametersInfo;
typedef DataParametersInfo<DefaultBlockCipher::BLOCKSIZE, DefaultBlockCipher::DEFAULT_KEYLENGTH, DefaultHashModule::DIGESTSIZE, 8, 2500> DefaultParametersInfo;

template <class BC, class H, class Info>
class DataEncryptor : public ProxyFilter, public Info
{
public:
        CRYPTOPP_CONSTANT(BLOCKSIZE  = Info::BLOCKSIZE)
        CRYPTOPP_CONSTANT(KEYLENGTH  = Info::KEYLENGTH)
        CRYPTOPP_CONSTANT(SALTLENGTH = Info::SALTLENGTH)
        CRYPTOPP_CONSTANT(DIGESTSIZE = Info::DIGESTSIZE)
        CRYPTOPP_CONSTANT(ITERATIONS = Info::ITERATIONS)

        
        DataEncryptor(const char *passphrase, BufferedTransformation *attachment = NULL);

        DataEncryptor(const byte *passphrase, size_t passphraseLength, BufferedTransformation *attachment = NULL);

protected:
        void FirstPut(const byte *);
        void LastPut(const byte *inString, size_t length);

private:
        SecByteBlock m_passphrase;
        typename CBC_Mode<BC>::Encryption m_cipher;
};

template <class BC, class H, class Info>
class DataDecryptor : public ProxyFilter, public Info
{
public:
        CRYPTOPP_CONSTANT(BLOCKSIZE  = Info::BLOCKSIZE)
        CRYPTOPP_CONSTANT(KEYLENGTH  = Info::KEYLENGTH)
        CRYPTOPP_CONSTANT(SALTLENGTH = Info::SALTLENGTH)
        CRYPTOPP_CONSTANT(DIGESTSIZE = Info::DIGESTSIZE)
        CRYPTOPP_CONSTANT(ITERATIONS = Info::ITERATIONS)

        
        DataDecryptor(const char *passphrase, BufferedTransformation *attachment = NULL, bool throwException=true);

        DataDecryptor(const byte *passphrase, size_t passphraseLength, BufferedTransformation *attachment = NULL, bool throwException=true);

        enum State {WAITING_FOR_KEYCHECK, KEY_GOOD, KEY_BAD};
        State CurrentState() const {return m_state;}

protected:
        void FirstPut(const byte *inString);
        void LastPut(const byte *inString, size_t length);

        State m_state;

private:
        void CheckKey(const byte *salt, const byte *keyCheck);

        SecByteBlock m_passphrase;
        typename CBC_Mode<BC>::Decryption m_cipher;
        member_ptr<FilterWithBufferedInput> m_decryptor;
        bool m_throwException;

};

template <class BC, class H, class MAC, class Info>
class DataEncryptorWithMAC : public ProxyFilter
{
public:
        DataEncryptorWithMAC(const char *passphrase, BufferedTransformation *attachment = NULL);

        DataEncryptorWithMAC(const byte *passphrase, size_t passphraseLength, BufferedTransformation *attachment = NULL);

protected:
        void FirstPut(const byte *inString) {CRYPTOPP_UNUSED(inString);}
        void LastPut(const byte *inString, size_t length);

private:
        member_ptr<MAC> m_mac;

};

template <class BC, class H, class MAC, class Info>
class DataDecryptorWithMAC : public ProxyFilter
{
public:
        DataDecryptorWithMAC(const char *passphrase, BufferedTransformation *attachment = NULL, bool throwException=true);

        DataDecryptorWithMAC(const byte *passphrase, size_t passphraseLength, BufferedTransformation *attachment = NULL, bool throwException=true);

        typename DataDecryptor<BC,H,Info>::State CurrentState() const;
        bool CheckLastMAC() const;

protected:
        void FirstPut(const byte *inString) {CRYPTOPP_UNUSED(inString);}
        void LastPut(const byte *inString, size_t length);

private:
        member_ptr<MAC> m_mac;
        HashVerificationFilter *m_hashVerifier;
        bool m_throwException;
};

#if defined(CRYPTOPP_DOXYGEN_PROCESSING)
struct LegacyEncryptor : public DataEncryptor<LegacyBlockCipher,LegacyHashModule,LegacyParametersInfo> {};
struct LegacyDecryptor : public DataDecryptor<LegacyBlockCipher,LegacyHashModule,LegacyParametersInfo> {};
struct DefaultEncryptor : public DataEncryptor<DefaultBlockCipher,DefaultHashModule,DefaultParametersInfo> {};
struct DefaultDecryptor : public DataDecryptor<DefaultBlockCipher,DefaultHashModule,DefaultParametersInfo> {};
struct LegacyEncryptorWithMAC : public DataEncryptorWithMAC<LegacyBlockCipher,LegacyHashModule,DefaultMAC,LegacyParametersInfo> {};
struct LegacyDecryptorWithMAC : public DataDecryptorWithMAC<LegacyBlockCipher,LegacyHashModule,DefaultMAC,LegacyParametersInfo> {};
struct DefaultEncryptorWithMAC : public DataEncryptorWithMAC<DefaultBlockCipher,DefaultHashModule,DefaultMAC,DefaultParametersInfo> {};
struct DefaultDecryptorWithMAC : public DataDecryptorWithMAC<DefaultBlockCipher,DefaultHashModule,DefaultMAC,DefaultParametersInfo> {};
#else
typedef DataEncryptor<LegacyBlockCipher,LegacyHashModule,LegacyParametersInfo> LegacyEncryptor;
typedef DataDecryptor<LegacyBlockCipher,LegacyHashModule,LegacyParametersInfo> LegacyDecryptor;

typedef DataEncryptor<DefaultBlockCipher,DefaultHashModule,DefaultParametersInfo> DefaultEncryptor;
typedef DataDecryptor<DefaultBlockCipher,DefaultHashModule,DefaultParametersInfo> DefaultDecryptor;

typedef DataEncryptorWithMAC<LegacyBlockCipher,LegacyHashModule,DefaultMAC,LegacyParametersInfo> LegacyEncryptorWithMAC;
typedef DataDecryptorWithMAC<LegacyBlockCipher,LegacyHashModule,DefaultMAC,LegacyParametersInfo> LegacyDecryptorWithMAC;

typedef DataEncryptorWithMAC<DefaultBlockCipher,DefaultHashModule,DefaultMAC,DefaultParametersInfo> DefaultEncryptorWithMAC;
typedef DataDecryptorWithMAC<DefaultBlockCipher,DefaultHashModule,DefaultMAC,DefaultParametersInfo> DefaultDecryptorWithMAC;
#endif

NAMESPACE_END

#endif