default.h

Go to the documentation of this file.

// default.h - originally 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 SHA1 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 = NULLPTR);
 
        DataEncryptor(const byte *passphrase, size_t passphraseLength, BufferedTransformation *attachment = NULLPTR);
 
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 = NULLPTR, bool throwException=true);
 
        DataDecryptor(const byte *passphrase, size_t passphraseLength, BufferedTransformation *attachment = NULLPTR, 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:
        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);
 
        DataEncryptorWithMAC(const char *passphrase, BufferedTransformation *attachment = NULLPTR);
 
        DataEncryptorWithMAC(const byte *passphrase, size_t passphraseLength, BufferedTransformation *attachment = NULLPTR);
 
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:
        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);
 
        DataDecryptorWithMAC(const char *passphrase, BufferedTransformation *attachment = NULLPTR, bool throwException=true);
 
        DataDecryptorWithMAC(const byte *passphrase, size_t passphraseLength, BufferedTransformation *attachment = NULLPTR, 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,LegacyMAC,LegacyParametersInfo> {};
struct LegacyDecryptorWithMAC : public DataDecryptorWithMAC<LegacyBlockCipher,LegacyHashModule,LegacyMAC,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,LegacyMAC,LegacyParametersInfo> LegacyEncryptorWithMAC;
typedef DataDecryptorWithMAC<LegacyBlockCipher,LegacyHashModule,LegacyMAC,LegacyParametersInfo> LegacyDecryptorWithMAC;
 
typedef DataEncryptorWithMAC<DefaultBlockCipher,DefaultHashModule,DefaultMAC,DefaultParametersInfo> DefaultEncryptorWithMAC;
typedef DataDecryptorWithMAC<DefaultBlockCipher,DefaultHashModule,DefaultMAC,DefaultParametersInfo> DefaultDecryptorWithMAC;
#endif
 
NAMESPACE_END
 
#endif