00001
00002
00003
00004
00005
00006 #ifndef CRYPTOPP_SIMPLE_H
00007 #define CRYPTOPP_SIMPLE_H
00008
00009 #include "cryptlib.h"
00010 #include "misc.h"
00011
00012 NAMESPACE_BEGIN(CryptoPP)
00013
00014
00015 template <class DERIVED, class BASE>
00016 class CRYPTOPP_NO_VTABLE ClonableImpl : public BASE
00017 {
00018 public:
00019 Clonable * Clone() const {return new DERIVED(*static_cast<const DERIVED *>(this));}
00020 };
00021
00022
00023 template <class BASE, class ALGORITHM_INFO=BASE>
00024 class CRYPTOPP_NO_VTABLE AlgorithmImpl : public BASE
00025 {
00026 public:
00027 static std::string CRYPTOPP_API StaticAlgorithmName() {return ALGORITHM_INFO::StaticAlgorithmName();}
00028 std::string AlgorithmName() const {return ALGORITHM_INFO::StaticAlgorithmName();}
00029 };
00030
00031
00032 class CRYPTOPP_DLL InvalidKeyLength : public InvalidArgument
00033 {
00034 public:
00035 explicit InvalidKeyLength(const std::string &algorithm, size_t length) : InvalidArgument(algorithm + ": " + IntToString(length) + " is not a valid key length") {}
00036 };
00037
00038
00039 class CRYPTOPP_DLL InvalidRounds : public InvalidArgument
00040 {
00041 public:
00042 explicit InvalidRounds(const std::string &algorithm, unsigned int rounds) : InvalidArgument(algorithm + ": " + IntToString(rounds) + " is not a valid number of rounds") {}
00043 };
00044
00045
00046
00047
00048 template <class T>
00049 class CRYPTOPP_NO_VTABLE Bufferless : public T
00050 {
00051 public:
00052 bool IsolatedFlush(bool hardFlush, bool blocking) {return false;}
00053 };
00054
00055
00056 template <class T>
00057 class CRYPTOPP_NO_VTABLE Unflushable : public T
00058 {
00059 public:
00060 bool Flush(bool completeFlush, int propagation=-1, bool blocking=true)
00061 {return ChannelFlush(DEFAULT_CHANNEL, completeFlush, propagation, blocking);}
00062 bool IsolatedFlush(bool hardFlush, bool blocking)
00063 {assert(false); return false;}
00064 bool ChannelFlush(const std::string &channel, bool hardFlush, int propagation=-1, bool blocking=true)
00065 {
00066 if (hardFlush && !InputBufferIsEmpty())
00067 throw CannotFlush("Unflushable<T>: this object has buffered input that cannot be flushed");
00068 else
00069 {
00070 BufferedTransformation *attached = this->AttachedTransformation();
00071 return attached && propagation ? attached->ChannelFlush(channel, hardFlush, propagation-1, blocking) : false;
00072 }
00073 }
00074
00075 protected:
00076 virtual bool InputBufferIsEmpty() const {return false;}
00077 };
00078
00079
00080 template <class T>
00081 class CRYPTOPP_NO_VTABLE InputRejecting : public T
00082 {
00083 public:
00084 struct InputRejected : public NotImplemented
00085 {InputRejected() : NotImplemented("BufferedTransformation: this object doesn't allow input") {}};
00086
00087
00088 size_t Put2(const byte *begin, size_t length, int messageEnd, bool blocking)
00089 {throw InputRejected();}
00090 bool IsolatedFlush(bool, bool) {return false;}
00091 bool IsolatedMessageSeriesEnd(bool) {throw InputRejected();}
00092
00093 size_t ChannelPut2(const std::string &channel, const byte *begin, size_t length, int messageEnd, bool blocking)
00094 {throw InputRejected();}
00095 bool ChannelMessageSeriesEnd(const std::string &, int, bool) {throw InputRejected();}
00096 };
00097
00098
00099 template <class T>
00100 class CRYPTOPP_NO_VTABLE CustomFlushPropagation : public T
00101 {
00102 public:
00103 virtual bool Flush(bool hardFlush, int propagation=-1, bool blocking=true) =0;
00104
00105 private:
00106 bool IsolatedFlush(bool hardFlush, bool blocking) {assert(false); return false;}
00107 };
00108
00109
00110 template <class T>
00111 class CRYPTOPP_NO_VTABLE CustomSignalPropagation : public CustomFlushPropagation<T>
00112 {
00113 public:
00114 virtual void Initialize(const NameValuePairs ¶meters=g_nullNameValuePairs, int propagation=-1) =0;
00115
00116 private:
00117 void IsolatedInitialize(const NameValuePairs ¶meters) {assert(false);}
00118 };
00119
00120
00121 template <class T>
00122 class CRYPTOPP_NO_VTABLE Multichannel : public CustomFlushPropagation<T>
00123 {
00124 public:
00125 bool Flush(bool hardFlush, int propagation=-1, bool blocking=true)
00126 {return this->ChannelFlush(DEFAULT_CHANNEL, hardFlush, propagation, blocking);}
00127 bool MessageSeriesEnd(int propagation=-1, bool blocking=true)
00128 {return this->ChannelMessageSeriesEnd(DEFAULT_CHANNEL, propagation, blocking);}
00129 byte * CreatePutSpace(size_t &size)
00130 {return this->ChannelCreatePutSpace(DEFAULT_CHANNEL, size);}
00131 size_t Put2(const byte *begin, size_t length, int messageEnd, bool blocking)
00132 {return this->ChannelPut2(DEFAULT_CHANNEL, begin, length, messageEnd, blocking);}
00133 size_t PutModifiable2(byte *inString, size_t length, int messageEnd, bool blocking)
00134 {return this->ChannelPutModifiable2(DEFAULT_CHANNEL, inString, length, messageEnd, blocking);}
00135
00136
00137
00138 byte * ChannelCreatePutSpace(const std::string &channel, size_t &size)
00139 {size = 0; return NULL;}
00140 bool ChannelPutModifiable(const std::string &channel, byte *inString, size_t length)
00141 {this->ChannelPut(channel, inString, length); return false;}
00142
00143 virtual size_t ChannelPut2(const std::string &channel, const byte *begin, size_t length, int messageEnd, bool blocking) =0;
00144 size_t ChannelPutModifiable2(const std::string &channel, byte *begin, size_t length, int messageEnd, bool blocking)
00145 {return ChannelPut2(channel, begin, length, messageEnd, blocking);}
00146
00147 virtual bool ChannelFlush(const std::string &channel, bool hardFlush, int propagation=-1, bool blocking=true) =0;
00148 };
00149
00150
00151 template <class T>
00152 class CRYPTOPP_NO_VTABLE AutoSignaling : public T
00153 {
00154 public:
00155 AutoSignaling(int propagation=-1) : m_autoSignalPropagation(propagation) {}
00156
00157 void SetAutoSignalPropagation(int propagation)
00158 {m_autoSignalPropagation = propagation;}
00159 int GetAutoSignalPropagation() const
00160 {return m_autoSignalPropagation;}
00161
00162 private:
00163 int m_autoSignalPropagation;
00164 };
00165
00166
00167 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE Store : public AutoSignaling<InputRejecting<BufferedTransformation> >
00168 {
00169 public:
00170 Store() : m_messageEnd(false) {}
00171
00172 void IsolatedInitialize(const NameValuePairs ¶meters)
00173 {
00174 m_messageEnd = false;
00175 StoreInitialize(parameters);
00176 }
00177
00178 unsigned int NumberOfMessages() const {return m_messageEnd ? 0 : 1;}
00179 bool GetNextMessage();
00180 unsigned int CopyMessagesTo(BufferedTransformation &target, unsigned int count=UINT_MAX, const std::string &channel=DEFAULT_CHANNEL) const;
00181
00182 protected:
00183 virtual void StoreInitialize(const NameValuePairs ¶meters) =0;
00184
00185 bool m_messageEnd;
00186 };
00187
00188
00189 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE Sink : public BufferedTransformation
00190 {
00191 public:
00192 size_t TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true)
00193 {transferBytes = 0; return 0;}
00194 size_t CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end=LWORD_MAX, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true) const
00195 {return 0;}
00196 };
00197
00198 class CRYPTOPP_DLL BitBucket : public Bufferless<Sink>
00199 {
00200 public:
00201 std::string AlgorithmName() const {return "BitBucket";}
00202 void IsolatedInitialize(const NameValuePairs ¶meters) {}
00203 size_t Put2(const byte *begin, size_t length, int messageEnd, bool blocking)
00204 {return 0;}
00205 };
00206
00207 NAMESPACE_END
00208
00209 #endif