311 lines
16 KiB
C++
311 lines
16 KiB
C++
// default.h - originally written and placed in the public domain by Wei Dai
|
|
|
|
/// \file default.h
|
|
/// \brief Classes for DefaultEncryptor, DefaultDecryptor, DefaultEncryptorWithMAC and DefaultDecryptorWithMAC
|
|
|
|
#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)
|
|
|
|
/// \brief Legacy block cipher for LegacyEncryptor, LegacyDecryptor, LegacyEncryptorWithMAC and LegacyDecryptorWithMAC
|
|
typedef DES_EDE2 LegacyBlockCipher;
|
|
/// \brief Legacy hash for use with LegacyEncryptorWithMAC and LegacyDecryptorWithMAC
|
|
typedef SHA1 LegacyHashModule;
|
|
/// \brief Legacy HMAC for use withLegacyEncryptorWithMAC and LegacyDecryptorWithMAC
|
|
typedef HMAC<LegacyHashModule> LegacyMAC;
|
|
|
|
/// \brief Default block cipher for DefaultEncryptor, DefaultDecryptor, DefaultEncryptorWithMAC and DefaultDecryptorWithMAC
|
|
typedef AES DefaultBlockCipher;
|
|
/// \brief Default hash for use with DefaultEncryptorWithMAC and DefaultDecryptorWithMAC
|
|
typedef SHA256 DefaultHashModule;
|
|
/// \brief Default HMAC for use withDefaultEncryptorWithMAC and DefaultDecryptorWithMAC
|
|
typedef HMAC<DefaultHashModule> DefaultMAC;
|
|
|
|
/// \brief Exception thrown when LegacyDecryptorWithMAC or DefaultDecryptorWithMAC decryption error is encountered
|
|
class DataDecryptorErr : public Exception
|
|
{
|
|
public:
|
|
DataDecryptorErr(const std::string &s)
|
|
: Exception(DATA_INTEGRITY_CHECK_FAILED, s) {}
|
|
};
|
|
|
|
/// \brief Exception thrown when a bad key is encountered in DefaultDecryptorWithMAC and LegacyDecryptorWithMAC
|
|
class KeyBadErr : public DataDecryptorErr
|
|
{
|
|
public: KeyBadErr()
|
|
: DataDecryptorErr("DataDecryptor: cannot decrypt message with this passphrase") {}
|
|
};
|
|
|
|
/// \brief Exception thrown when an incorrect MAC is encountered in DefaultDecryptorWithMAC and LegacyDecryptorWithMAC
|
|
class MACBadErr : public DataDecryptorErr
|
|
{
|
|
public: MACBadErr()
|
|
: DataDecryptorErr("DataDecryptorWithMAC: MAC check failed") {}
|
|
};
|
|
|
|
/// \brief Algorithm information for password-based encryptors and decryptors
|
|
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;
|
|
|
|
/// \brief Password-based Encryptor
|
|
/// \tparam BC BlockCipher based class used for encryption
|
|
/// \tparam H HashTransformation based class used for mashing
|
|
/// \tparam Info Constants used by the algorithms
|
|
/// \details Crypto++ 5.6.5 and earlier used the legacy algorithms, including DES_EDE2 and SHA1.
|
|
/// Crypto++ 5.7 switched to AES and SHA256.
|
|
/// \sa DefaultEncryptor, DefaultDecryptor, LegacyEncryptor, LegacyDecryptor
|
|
/// \since Crypto++ 2.0
|
|
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);
|
|
|
|
/// \brief Construct a DataEncryptor
|
|
/// \param passphrase a C-String password
|
|
/// \param attachment a BufferedTransformation to attach to this object
|
|
DataEncryptor(const char *passphrase, BufferedTransformation *attachment = NULLPTR);
|
|
|
|
/// \brief Construct a DataEncryptor
|
|
/// \param passphrase a byte string password
|
|
/// \param passphraseLength the length of the byte string password
|
|
/// \param attachment a BufferedTransformation to attach to this object
|
|
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;
|
|
};
|
|
|
|
/// \brief Password-based Decryptor
|
|
/// \tparam BC BlockCipher based class used for encryption
|
|
/// \tparam H HashTransformation based class used for mashing
|
|
/// \tparam Info Constants used by the algorithms
|
|
/// \details Crypto++ 5.6.5 and earlier used the legacy algorithms, including DES_EDE2 and SHA1.
|
|
/// Crypto++ 5.7 switched to AES and SHA256.
|
|
/// \sa DefaultEncryptor, DefaultDecryptor, LegacyEncryptor, LegacyDecryptor
|
|
/// \since Crypto++ 2.0
|
|
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);
|
|
|
|
/// \brief Constructs a DataDecryptor
|
|
/// \param passphrase a C-String password
|
|
/// \param attachment a BufferedTransformation to attach to this object
|
|
/// \param throwException a flag specifying whether an Exception should be thrown on error
|
|
DataDecryptor(const char *passphrase, BufferedTransformation *attachment = NULLPTR, bool throwException=true);
|
|
|
|
/// \brief Constructs a DataDecryptor
|
|
/// \param passphrase a byte string password
|
|
/// \param passphraseLength the length of the byte string password
|
|
/// \param attachment a BufferedTransformation to attach to this object
|
|
/// \param throwException a flag specifying whether an Exception should be thrown on error
|
|
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;
|
|
|
|
};
|
|
|
|
/// \brief Password-based encryptor with MAC
|
|
/// \tparam BC BlockCipher based class used for encryption
|
|
/// \tparam H HashTransformation based class used for mashing
|
|
/// \tparam MAC HashTransformation based class used for authentication
|
|
/// \tparam Info Constants used by the algorithms
|
|
/// \details DataEncryptorWithMAC uses a non-standard mashup function called Mash() to derive key
|
|
/// bits from the password.
|
|
/// \details The purpose of the function Mash() is to take an arbitrary length input string and
|
|
/// *deterministically* produce an arbitrary length output string such that (1) it looks random,
|
|
/// (2) no information about the input is deducible from it, and (3) it contains as much entropy
|
|
/// as it can hold, or the amount of entropy in the input string, whichever is smaller.
|
|
/// \details Crypto++ 5.6.5 and earlier used the legacy algorithms, including DES_EDE2 and SHA1.
|
|
/// Crypto++ 5.7 switched to AES and SHA256.
|
|
/// \sa DefaultEncryptorWithMAC, DefaultDecryptorWithMAC, LegacyDecryptorWithMAC, LegacyEncryptorWithMAC
|
|
/// \since Crypto++ 2.0
|
|
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);
|
|
|
|
/// \brief Constructs a DataEncryptorWithMAC
|
|
/// \param passphrase a C-String password
|
|
/// \param attachment a BufferedTransformation to attach to this object
|
|
DataEncryptorWithMAC(const char *passphrase, BufferedTransformation *attachment = NULLPTR);
|
|
|
|
/// \brief Constructs a DataEncryptorWithMAC
|
|
/// \param passphrase a byte string password
|
|
/// \param passphraseLength the length of the byte string password
|
|
/// \param attachment a BufferedTransformation to attach to this object
|
|
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;
|
|
|
|
};
|
|
|
|
/// \brief Password-based decryptor with MAC
|
|
/// \tparam BC BlockCipher based class used for encryption
|
|
/// \tparam H HashTransformation based class used for mashing
|
|
/// \tparam MAC HashTransformation based class used for authentication
|
|
/// \tparam Info Constants used by the algorithms
|
|
/// \details DataDecryptorWithMAC uses a non-standard mashup function called Mash() to derive key
|
|
/// bits from the password.
|
|
/// \details The purpose of the function Mash() is to take an arbitrary length input string and
|
|
/// *deterministically* produce an arbitrary length output string such that (1) it looks random,
|
|
/// (2) no information about the input is deducible from it, and (3) it contains as much entropy
|
|
/// as it can hold, or the amount of entropy in the input string, whichever is smaller.
|
|
/// \details Crypto++ 5.6.5 and earlier used the legacy algorithms, including DES_EDE2 and SHA1.
|
|
/// Crypto++ 5.7 switched to AES and SHA256.
|
|
/// \sa DefaultEncryptorWithMAC, DefaultDecryptorWithMAC, LegacyDecryptorWithMAC, LegacyEncryptorWithMAC
|
|
/// \since Crypto++ 2.0
|
|
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);
|
|
|
|
/// \brief Constructs a DataDecryptor
|
|
/// \param passphrase a C-String password
|
|
/// \param attachment a BufferedTransformation to attach to this object
|
|
/// \param throwException a flag specifying whether an Exception should be thrown on error
|
|
DataDecryptorWithMAC(const char *passphrase, BufferedTransformation *attachment = NULLPTR, bool throwException=true);
|
|
|
|
/// \brief Constructs a DataDecryptor
|
|
/// \param passphrase a byte string password
|
|
/// \param passphraseLength the length of the byte string password
|
|
/// \param attachment a BufferedTransformation to attach to this object
|
|
/// \param throwException a flag specifying whether an Exception should be thrown on error
|
|
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)
|
|
/// \brief Password-based encryptor (deprecated)
|
|
/// \details Crypto++ 5.6.5 and earlier used the legacy algorithms, including DES_EDE2 and SHA1.
|
|
/// Crypto++ 5.7 switched to AES and SHA256. The updated algorithms are available with the
|
|
/// <tt>Default*</tt> classes, and the old algorithms are available with the <tt>Legacy*</tt> classes.
|
|
struct LegacyEncryptor : public DataEncryptor<LegacyBlockCipher,LegacyHashModule,LegacyParametersInfo> {};
|
|
/// \brief Password-based decryptor (deprecated)
|
|
/// \details Crypto++ 5.6.5 and earlier used the legacy algorithms, including DES_EDE2 and SHA1.
|
|
/// Crypto++ 5.7 switched to AES and SHA256. The updated algorithms are available with the
|
|
/// <tt>Default*</tt> classes, and the old algorithms are available with the <tt>Legacy*</tt> classes.
|
|
struct LegacyDecryptor : public DataDecryptor<LegacyBlockCipher,LegacyHashModule,LegacyParametersInfo> {};
|
|
/// \brief Password-based encryptor
|
|
/// \details Crypto++ 5.6.5 and earlier used the legacy algorithms, including DES_EDE2 and SHA1.
|
|
/// Crypto++ 5.7 switched to AES and SHA256. The updated algorithms are available with the
|
|
/// <tt>Default*</tt> classes, and the old algorithms are available with the <tt>Legacy*</tt> classes.
|
|
struct DefaultEncryptor : public DataEncryptor<DefaultBlockCipher,DefaultHashModule,DefaultParametersInfo> {};
|
|
/// \brief Password-based decryptor
|
|
/// \details Crypto++ 5.6.5 and earlier used the legacy algorithms, including DES_EDE2 and SHA1.
|
|
/// Crypto++ 5.7 switched to AES and SHA256. The updated algorithms are available with the
|
|
/// <tt>Default*</tt> classes, and the old algorithms are available with the <tt>Legacy*</tt> classes.
|
|
struct DefaultDecryptor : public DataDecryptor<DefaultBlockCipher,DefaultHashModule,DefaultParametersInfo> {};
|
|
/// \brief Password-based encryptor with MAC (deprecated)
|
|
/// \details Crypto++ 5.6.5 and earlier used the legacy algorithms, including DES_EDE2 and SHA1.
|
|
/// Crypto++ 5.7 switched to AES and SHA256. The updated algorithms are available with the
|
|
/// <tt>Default*</tt> classes, and the old algorithms are available with the <tt>Legacy*</tt> classes.
|
|
struct LegacyEncryptorWithMAC : public DataEncryptorWithMAC<LegacyBlockCipher,LegacyHashModule,LegacyMAC,LegacyParametersInfo> {};
|
|
/// \brief Password-based decryptor with MAC (deprecated)
|
|
/// \details Crypto++ 5.6.5 and earlier used the legacy algorithms, including DES_EDE2 and SHA1.
|
|
/// Crypto++ 5.7 switched to AES and SHA256. The updated algorithms are available with the
|
|
/// <tt>Default*</tt> classes, and the old algorithms are available with the <tt>Legacy*</tt> classes.
|
|
struct LegacyDecryptorWithMAC : public DataDecryptorWithMAC<LegacyBlockCipher,LegacyHashModule,LegacyMAC,LegacyParametersInfo> {};
|
|
/// \brief Password-based encryptor with MAC
|
|
/// \details Crypto++ 5.6.5 and earlier used the legacy algorithms, including DES_EDE2 and SHA1.
|
|
/// Crypto++ 5.7 switched to AES and SHA256. The updated algorithms are available with the
|
|
/// <tt>Default*</tt> classes, and the old algorithms are available with the <tt>Legacy*</tt> classes.
|
|
struct DefaultEncryptorWithMAC : public DataEncryptorWithMAC<DefaultBlockCipher,DefaultHashModule,DefaultMAC,DefaultParametersInfo> {};
|
|
/// \brief Password-based decryptor with MAC
|
|
/// \details Crypto++ 5.6.5 and earlier used the legacy algorithms, including DES_EDE2 and SHA1.
|
|
/// Crypto++ 5.7 switched to AES and SHA256. The updated algorithms are available with the
|
|
/// <tt>Default*</tt> classes, and the old algorithms are available with the <tt>Legacy*</tt> classes.
|
|
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
|