---

cryptlib.h

Go to the documentation of this file.

// cryptlib.h - written and placed in the public domain by Wei Dai
#ifndef CRYPTOPP_CRYPTLIB_H
#define CRYPTOPP_CRYPTLIB_H

#include "config.h"
#include <limits.h>
#include <exception>
#include <string>

NAMESPACE_BEGIN(CryptoPP)


class Exception : public std::exception
{
public:
        explicit Exception(const std::string &s) : m_what(s) {}
        virtual ~Exception() throw() {}
        const char *what() const throw() {return (m_what.c_str());}
        const std::string &GetWhat() const {return m_what;}
        void SetWhat(const std::string &s) {m_what = s;}

private:
        std::string m_what;
};

enum CipherDir {
        ENCRYPTION,
        DECRYPTION};



class BlockTransformation
{
public:
        virtual ~BlockTransformation() {}


        virtual void ProcessBlock(byte *inoutBlock) const =0;


        virtual void ProcessBlock(const byte *inBlock, byte *outBlock) const =0;

        virtual unsigned int BlockSize() const =0;
};

template <unsigned int N>
class FixedBlockSize : public BlockTransformation
{
public:
        enum {BLOCKSIZE = N};
        virtual unsigned int BlockSize() const {return BLOCKSIZE;}
};


class StreamCipher
{
public:
        virtual ~StreamCipher() {}

        virtual byte ProcessByte(byte input) =0;

        virtual void ProcessString(byte *inoutString, unsigned int length);
        virtual void ProcessString(byte *outString, const byte *inString, unsigned int length);
};


class RandomAccessStreamCipher : public virtual StreamCipher
{
public:
        virtual ~RandomAccessStreamCipher() {}
        /*/ specify that the next byte to be processed is at absolute position n
                in the plaintext/ciphertext stream */
        virtual void Seek(unsigned long n) =0;
};


class RandomNumberGenerator
{
public:
        virtual ~RandomNumberGenerator() {}

        virtual byte GenerateByte() =0;


        virtual unsigned int GenerateBit();

        virtual word32 GenerateWord32(word32 a=0, word32 b=0xffffffffL);

        //* Default implementation is to call GenerateByte() size times.
        virtual void GenerateBlock(byte *output, unsigned int size);

        template <class IT> void Shuffle(IT begin, IT end)
        {
                for (; begin != end; ++begin)
                        std::iter_swap(begin, begin + GenerateWord32(0, end-begin-1));
        }

        // for backwards compatibility, maybe be remove later
        byte GetByte() {return GenerateByte();}
        unsigned int GetBit() {return GenerateBit();}
        word32 GetLong(word32 a=0, word32 b=0xffffffffL) {return GenerateWord32(a, b);}
        word16 GetShort(word16 a=0, word16 b=0xffff) {return (word16)GenerateWord32(a, b);}
        void GetBlock(byte *output, unsigned int size) {GenerateBlock(output, size);}
};


class HashModule
{
public:
        virtual ~HashModule() {}

        virtual void Update(const byte *input, unsigned int length) =0;

        /*/ calculate hash for the current message (the concatenation of all
                inputs passed in via Update()), then reinitialize the object */
        //* Precondition: size of digest == DigestSize().
        virtual void Final(byte *digest) =0;

        virtual unsigned int DigestSize() const =0;

        virtual void CalculateDigest(byte *digest, const byte *input, int length)
                {Update(input, length); Final(digest);}


        virtual bool Verify(const byte *digest);

        virtual bool VerifyDigest(const byte *digest, const byte *input, int length)
                {Update(input, length); return Verify(digest);}
};


class MessageAuthenticationCode : public virtual HashModule
{
public:
        virtual ~MessageAuthenticationCode() {}
};


class BufferedTransformation
{
public:
        virtual ~BufferedTransformation() {}



                virtual void Put(byte inByte) =0;
                virtual void Put(const byte *inString, unsigned int length) =0;

                void PutWord16(word16 value, bool highFirst=true);
                void PutWord32(word32 value, bool highFirst=true);




                virtual void Flush(bool completeFlush, int propagation=-1);

                virtual void MessageEnd(int propagation=-1);
                virtual void PutMessageEnd(const byte *inString, unsigned int length, int propagation=-1);

                virtual void MessageSeriesEnd(int propagation=-1);


                virtual void SetAutoSignalPropagation(int propagation) {}

                virtual int GetAutoSignalPropagation() const {return 0;}

                // for backwards compatibility
                void Close() {MessageEnd();}



                enum ErrorType {
                        CANNOT_FLUSH,
                        DATA_INTEGRITY_CHECK_FAILED,
                        INVALID_DATA_FORMAT,
                        INPUT_ERROR,
                        OUTPUT_ERROR,
                        OTHER_ERROR
                };

                class Err : public Exception
                {
                public:
                        Err(ErrorType errorType, const std::string &s="");
                        ErrorType GetErrorType() const {return m_errorType;}
                        void SetErrorType(ErrorType errorType) {m_errorType = errorType;}
                private:
                        ErrorType m_errorType;
                };




                virtual unsigned long MaxRetrievable() const;

                // old mispelled name
                unsigned long MaxRetrieveable() const {return MaxRetrievable();}

                virtual bool AnyRetrievable() const;

                virtual unsigned int Get(byte &outByte);
                virtual unsigned int Get(byte *outString, unsigned int getMax);

                virtual unsigned int Peek(byte &outByte) const;
                virtual unsigned int Peek(byte *outString, unsigned int peekMax) const;

                unsigned int GetWord16(word16 &value, bool highFirst=true);
                unsigned int GetWord32(word32 &value, bool highFirst=true);

                unsigned int PeekWord16(word16 &value, bool highFirst=true);
                unsigned int PeekWord32(word32 &value, bool highFirst=true);

                virtual unsigned long TransferTo(BufferedTransformation &target, unsigned long transferMax=ULONG_MAX);

                virtual unsigned long Skip(unsigned long skipMax=ULONG_MAX);

                virtual unsigned long CopyTo(BufferedTransformation &target, unsigned long copyMax=ULONG_MAX) const;



                virtual unsigned long TotalBytesRetrievable() const;
                virtual unsigned int NumberOfMessages() const;
                virtual bool AnyMessages() const;

                virtual bool GetNextMessage();
                virtual unsigned int SkipMessages(unsigned int count=UINT_MAX);
                virtual unsigned int TransferMessagesTo(BufferedTransformation &target, unsigned int count=UINT_MAX);
                virtual unsigned int CopyMessagesTo(BufferedTransformation &target, unsigned int count=UINT_MAX) const;

                virtual void SkipAll();
                virtual void TransferAllTo(BufferedTransformation &target);
                virtual void CopyAllTo(BufferedTransformation &target) const;


                virtual void ChannelPut(const std::string &channel, byte inByte);
                virtual void ChannelPut(const std::string &channel, const byte *inString, unsigned int length);

                void ChannelPutWord16(const std::string &channel, word16 value, bool highFirst=true);
                void ChannelPutWord32(const std::string &channel, word32 value, bool highFirst=true);

                virtual void ChannelFlush(const std::string &channel, bool completeFlush, int propagation=-1);
                virtual void ChannelMessageEnd(const std::string &channel, int propagation=-1);
                virtual void ChannelPutMessageEnd(const std::string &channel, const byte *inString, unsigned int length, int propagation=-1);
                virtual void ChannelMessageSeriesEnd(const std::string &channel, int propagation=-1);

                virtual void SetRetrievalChannel(const std::string &channel);

                static const std::string NULL_CHANNEL;


                virtual bool Attachable() {return false;}
                virtual BufferedTransformation *AttachedTransformation() {return 0;}
                virtual const BufferedTransformation *AttachedTransformation() const
                        {return const_cast<BufferedTransformation *>(this)->AttachedTransformation();}
                virtual void Detach(BufferedTransformation *newAttachment = 0) {}
                virtual void Attach(BufferedTransformation *newAttachment);
};


class PK_CryptoSystem
{
public:
        virtual ~PK_CryptoSystem() {}

        //* This function returns 0 if cipherTextLength is not valid (too long or too short).
        virtual unsigned int MaxPlainTextLength(unsigned int cipherTextLength) const =0;

        //* This function returns 0 if plainTextLength is not valid (too long).
        virtual unsigned int CipherTextLength(unsigned int plainTextLength) const =0;
};


class PK_Encryptor : public virtual PK_CryptoSystem
{
public:

        virtual void Encrypt(RandomNumberGenerator &rng, const byte *plainText, unsigned int plainTextLength, byte *cipherText) =0;
};


class PK_Decryptor : public virtual PK_CryptoSystem
{
public:

        virtual unsigned int Decrypt(const byte *cipherText, unsigned int cipherTextLength, byte *plainText) =0;
};


class PK_FixedLengthCryptoSystem : public virtual PK_CryptoSystem
{
public:
        virtual unsigned int MaxPlainTextLength() const =0;
        virtual unsigned int CipherTextLength() const =0;

        unsigned int MaxPlainTextLength(unsigned int cipherTextLength) const;
        unsigned int CipherTextLength(unsigned int plainTextLength) const;
};


class PK_FixedLengthEncryptor : public virtual PK_Encryptor, public virtual PK_FixedLengthCryptoSystem
{
};


class PK_FixedLengthDecryptor : public virtual PK_Decryptor, public virtual PK_FixedLengthCryptoSystem
{
public:

        virtual unsigned int Decrypt(const byte *cipherText, byte *plainText) =0;

        unsigned int Decrypt(const byte *cipherText, unsigned int cipherTextLength, byte *plainText);
};


class PK_SignatureSystem
{
public:
        virtual ~PK_SignatureSystem() {};

        virtual unsigned int SignatureLength() const =0;

        virtual HashModule * NewMessageAccumulator() const =0;
};


class PK_Signer : public virtual PK_SignatureSystem
{
public:
        class KeyTooShort : public Exception
        {
        public:
                KeyTooShort() : Exception("PK_Signer: key too short") {}
        };


        virtual void Sign(RandomNumberGenerator &rng, HashModule *messageAccumulator, byte *signature) const =0;


        virtual void SignMessage(RandomNumberGenerator &rng, const byte *message, unsigned int messageLen, byte *signature) const;
};


class PK_Verifier : public virtual PK_SignatureSystem
{
public:

        virtual bool Verify(HashModule *messageAccumulator, const byte *sig) const =0;


        virtual bool VerifyMessage(const byte *message, unsigned int messageLen, const byte *sig) const;
};


class PK_SignatureSystemWithRecovery : public virtual PK_SignatureSystem
{
public:
        virtual unsigned int MaximumRecoverableLength() const =0;


        virtual bool AllowLeftoverMessage() const =0;
};


class PK_SignerWithRecovery : public virtual PK_SignatureSystemWithRecovery, public PK_Signer
{
};


class PK_VerifierWithRecovery : public virtual PK_SignatureSystemWithRecovery, public PK_Verifier
{
public:
        virtual HashModule * NewLeftoverMessageAccumulator(const byte *signature) const =0;


        virtual unsigned int PartialRecover(HashModule *leftoverMessageAccumulator, byte *recoveredMessage) const =0;


        virtual unsigned int Recover(const byte *signature, byte *recoveredMessage) const =0;
};


class PK_SimpleKeyAgreementDomain
{
public:
        virtual ~PK_SimpleKeyAgreementDomain() {}

        virtual bool ValidateDomainParameters(RandomNumberGenerator &rng) const =0;
        virtual unsigned int AgreedValueLength() const =0;
        virtual unsigned int PrivateKeyLength() const =0;
        virtual unsigned int PublicKeyLength() const =0;

        virtual void GenerateKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const =0;

---