00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077 #ifndef CRYPTOPP_CRYPTLIB_H
00078 #define CRYPTOPP_CRYPTLIB_H
00079
00080 #include "config.h"
00081 #include "stdcpp.h"
00082
00083 NAMESPACE_BEGIN(CryptoPP)
00084
00085
00086 class Integer;
00087 class RandomNumberGenerator;
00088 class BufferedTransformation;
00089
00090
00091 enum CipherDir {ENCRYPTION, DECRYPTION};
00092
00093
00094 const unsigned long INFINITE_TIME = ULONG_MAX;
00095
00096
00097 template <typename ENUM_TYPE, int VALUE>
00098 struct EnumToType
00099 {
00100 static ENUM_TYPE ToEnum() {return (ENUM_TYPE)VALUE;}
00101 };
00102
00103 enum ByteOrder {LITTLE_ENDIAN_ORDER = 0, BIG_ENDIAN_ORDER = 1};
00104 typedef EnumToType<ByteOrder, LITTLE_ENDIAN_ORDER> LittleEndian;
00105 typedef EnumToType<ByteOrder, BIG_ENDIAN_ORDER> BigEndian;
00106
00107
00108 class CRYPTOPP_DLL Exception : public std::exception
00109 {
00110 public:
00111
00112 enum ErrorType {
00113
00114 NOT_IMPLEMENTED,
00115
00116 INVALID_ARGUMENT,
00117
00118 CANNOT_FLUSH,
00119
00120 DATA_INTEGRITY_CHECK_FAILED,
00121
00122 INVALID_DATA_FORMAT,
00123
00124 IO_ERROR,
00125
00126 OTHER_ERROR
00127 };
00128
00129 explicit Exception(ErrorType errorType, const std::string &s) : m_errorType(errorType), m_what(s) {}
00130 virtual ~Exception() throw() {}
00131 const char *what() const throw() {return (m_what.c_str());}
00132 const std::string &GetWhat() const {return m_what;}
00133 void SetWhat(const std::string &s) {m_what = s;}
00134 ErrorType GetErrorType() const {return m_errorType;}
00135 void SetErrorType(ErrorType errorType) {m_errorType = errorType;}
00136
00137 private:
00138 ErrorType m_errorType;
00139 std::string m_what;
00140 };
00141
00142
00143 class CRYPTOPP_DLL InvalidArgument : public Exception
00144 {
00145 public:
00146 explicit InvalidArgument(const std::string &s) : Exception(INVALID_ARGUMENT, s) {}
00147 };
00148
00149
00150 class CRYPTOPP_DLL InvalidDataFormat : public Exception
00151 {
00152 public:
00153 explicit InvalidDataFormat(const std::string &s) : Exception(INVALID_DATA_FORMAT, s) {}
00154 };
00155
00156
00157 class CRYPTOPP_DLL InvalidCiphertext : public InvalidDataFormat
00158 {
00159 public:
00160 explicit InvalidCiphertext(const std::string &s) : InvalidDataFormat(s) {}
00161 };
00162
00163
00164 class CRYPTOPP_DLL NotImplemented : public Exception
00165 {
00166 public:
00167 explicit NotImplemented(const std::string &s) : Exception(NOT_IMPLEMENTED, s) {}
00168 };
00169
00170
00171 class CRYPTOPP_DLL CannotFlush : public Exception
00172 {
00173 public:
00174 explicit CannotFlush(const std::string &s) : Exception(CANNOT_FLUSH, s) {}
00175 };
00176
00177
00178 class CRYPTOPP_DLL OS_Error : public Exception
00179 {
00180 public:
00181 OS_Error(ErrorType errorType, const std::string &s, const std::string& operation, int errorCode)
00182 : Exception(errorType, s), m_operation(operation), m_errorCode(errorCode) {}
00183 ~OS_Error() throw() {}
00184
00185
00186 const std::string & GetOperation() const {return m_operation;}
00187
00188 int GetErrorCode() const {return m_errorCode;}
00189
00190 protected:
00191 std::string m_operation;
00192 int m_errorCode;
00193 };
00194
00195
00196 struct CRYPTOPP_DLL DecodingResult
00197 {
00198 explicit DecodingResult() : isValidCoding(false), messageLength(0) {}
00199 explicit DecodingResult(size_t len) : isValidCoding(true), messageLength(len) {}
00200
00201 bool operator==(const DecodingResult &rhs) const {return isValidCoding == rhs.isValidCoding && messageLength == rhs.messageLength;}
00202 bool operator!=(const DecodingResult &rhs) const {return !operator==(rhs);}
00203
00204 bool isValidCoding;
00205 size_t messageLength;
00206
00207 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY
00208 operator size_t() const {return isValidCoding ? messageLength : 0;}
00209 #endif
00210 };
00211
00212
00213
00214
00215
00216
00217
00218
00219
00220
00221
00222
00223 class CRYPTOPP_NO_VTABLE NameValuePairs
00224 {
00225 public:
00226 virtual ~NameValuePairs() {}
00227
00228
00229 class CRYPTOPP_DLL ValueTypeMismatch : public InvalidArgument
00230 {
00231 public:
00232 ValueTypeMismatch(const std::string &name, const std::type_info &stored, const std::type_info &retrieving)
00233 : InvalidArgument("NameValuePairs: type mismatch for '" + name + "', stored '" + stored.name() + "', trying to retrieve '" + retrieving.name() + "'")
00234 , m_stored(stored), m_retrieving(retrieving) {}
00235
00236 const std::type_info & GetStoredTypeInfo() const {return m_stored;}
00237 const std::type_info & GetRetrievingTypeInfo() const {return m_retrieving;}
00238
00239 private:
00240 const std::type_info &m_stored;
00241 const std::type_info &m_retrieving;
00242 };
00243
00244
00245 template <class T>
00246 bool GetThisObject(T &object) const
00247 {
00248 return GetValue((std::string("ThisObject:")+typeid(T).name()).c_str(), object);
00249 }
00250
00251
00252 template <class T>
00253 bool GetThisPointer(T *&p) const
00254 {
00255 return GetValue((std::string("ThisPointer:")+typeid(T).name()).c_str(), p);
00256 }
00257
00258
00259 template <class T>
00260 bool GetValue(const char *name, T &value) const
00261 {
00262 return GetVoidValue(name, typeid(T), &value);
00263 }
00264
00265
00266 template <class T>
00267 T GetValueWithDefault(const char *name, T defaultValue) const
00268 {
00269 GetValue(name, defaultValue);
00270 return defaultValue;
00271 }
00272
00273
00274 CRYPTOPP_DLL std::string GetValueNames() const
00275 {std::string result; GetValue("ValueNames", result); return result;}
00276
00277
00278
00279
00280 CRYPTOPP_DLL bool GetIntValue(const char *name, int &value) const
00281 {return GetValue(name, value);}
00282
00283
00284 CRYPTOPP_DLL int GetIntValueWithDefault(const char *name, int defaultValue) const
00285 {return GetValueWithDefault(name, defaultValue);}
00286
00287
00288 CRYPTOPP_DLL static void CRYPTOPP_API ThrowIfTypeMismatch(const char *name, const std::type_info &stored, const std::type_info &retrieving)
00289 {if (stored != retrieving) throw ValueTypeMismatch(name, stored, retrieving);}
00290
00291 template <class T>
00292 void GetRequiredParameter(const char *className, const char *name, T &value) const
00293 {
00294 if (!GetValue(name, value))
00295 throw InvalidArgument(std::string(className) + ": missing required parameter '" + name + "'");
00296 }
00297
00298 CRYPTOPP_DLL void GetRequiredIntParameter(const char *className, const char *name, int &value) const
00299 {
00300 if (!GetIntValue(name, value))
00301 throw InvalidArgument(std::string(className) + ": missing required parameter '" + name + "'");
00302 }
00303
00304
00305 CRYPTOPP_DLL virtual bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const =0;
00306 };
00307
00308
00309
00310
00311
00312
00313
00314 DOCUMENTED_NAMESPACE_BEGIN(Name)
00315
00316 DOCUMENTED_NAMESPACE_END
00317
00318
00319 class CRYPTOPP_DLL NullNameValuePairs : public NameValuePairs
00320 {
00321 public:
00322 bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const {return false;}
00323 };
00324
00325
00326 extern CRYPTOPP_DLL const NullNameValuePairs g_nullNameValuePairs;
00327
00328
00329
00330
00331 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE Clonable
00332 {
00333 public:
00334 virtual ~Clonable() {}
00335
00336 virtual Clonable* Clone() const {throw NotImplemented("Clone() is not implemented yet.");}
00337 };
00338
00339
00340
00341 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE Algorithm : public Clonable
00342 {
00343 public:
00344
00345
00346 Algorithm(bool checkSelfTestStatus = true);
00347
00348 virtual std::string AlgorithmName() const {return "unknown";}
00349 };
00350
00351
00352
00353 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE SimpleKeyingInterface
00354 {
00355 public:
00356
00357 virtual size_t MinKeyLength() const =0;
00358
00359 virtual size_t MaxKeyLength() const =0;
00360
00361 virtual size_t DefaultKeyLength() const =0;
00362
00363
00364 virtual size_t GetValidKeyLength(size_t n) const =0;
00365
00366
00367 virtual bool IsValidKeyLength(size_t n) const
00368 {return n == GetValidKeyLength(n);}
00369
00370
00371
00372 virtual void SetKey(const byte *key, size_t length, const NameValuePairs ¶ms = g_nullNameValuePairs);
00373
00374
00375 void SetKeyWithRounds(const byte *key, size_t length, int rounds);
00376
00377
00378 void SetKeyWithIV(const byte *key, size_t length, const byte *iv);
00379
00380 enum IV_Requirement {UNIQUE_IV = 0, RANDOM_IV, UNPREDICTABLE_RANDOM_IV, INTERNALLY_GENERATED_IV, NOT_RESYNCHRONIZABLE};
00381
00382 virtual IV_Requirement IVRequirement() const =0;
00383
00384
00385
00386 bool IsResynchronizable() const {return IVRequirement() < NOT_RESYNCHRONIZABLE;}
00387
00388 bool CanUseRandomIVs() const {return IVRequirement() <= UNPREDICTABLE_RANDOM_IV;}
00389
00390 bool CanUsePredictableIVs() const {return IVRequirement() <= RANDOM_IV;}
00391
00392 bool CanUseStructuredIVs() const {return IVRequirement() <= UNIQUE_IV;}
00393
00394
00395 virtual unsigned int IVSize() const {throw NotImplemented("SimpleKeyingInterface: this object doesn't support resynchronization");}
00396
00397 virtual void Resynchronize(const byte *IV) {throw NotImplemented("SimpleKeyingInterface: this object doesn't support resynchronization");}
00398
00399
00400
00401
00402 virtual void GetNextIV(RandomNumberGenerator &rng, byte *IV);
00403
00404 protected:
00405 virtual const Algorithm & GetAlgorithm() const =0;
00406 virtual void UncheckedSetKey(const byte *key, unsigned int length, const NameValuePairs ¶ms) =0;
00407
00408 void ThrowIfInvalidKeyLength(size_t length);
00409 void ThrowIfResynchronizable();
00410 void ThrowIfInvalidIV(const byte *iv);
00411 const byte * GetIVAndThrowIfInvalid(const NameValuePairs ¶ms);
00412 inline void AssertValidKeyLength(size_t length) const
00413 {assert(IsValidKeyLength(length));}
00414 };
00415
00416
00417
00418
00419
00420
00421
00422
00423
00424 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE BlockTransformation : public Algorithm
00425 {
00426 public:
00427
00428 virtual void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const =0;
00429
00430
00431
00432 void ProcessBlock(const byte *inBlock, byte *outBlock) const
00433 {ProcessAndXorBlock(inBlock, NULL, outBlock);}
00434
00435
00436 void ProcessBlock(byte *inoutBlock) const
00437 {ProcessAndXorBlock(inoutBlock, NULL, inoutBlock);}
00438
00439
00440 virtual unsigned int BlockSize() const =0;
00441
00442
00443 virtual unsigned int BlockAlignment() const;
00444
00445
00446 virtual bool IsPermutation() const {return true;}
00447
00448
00449 virtual bool IsForwardTransformation() const =0;
00450
00451
00452 virtual unsigned int OptimalNumberOfParallelBlocks() const {return 1;}
00453
00454
00455 virtual void ProcessAndXorMultipleBlocks(const byte *inBlocks, const byte *xorBlocks, byte *outBlocks, size_t numberOfBlocks) const;
00456
00457 inline CipherDir GetCipherDirection() const {return IsForwardTransformation() ? ENCRYPTION : DECRYPTION;}
00458 };
00459
00460
00461
00462 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE StreamTransformation : public Algorithm
00463 {
00464 public:
00465
00466
00467
00468 StreamTransformation& Ref() {return *this;}
00469
00470
00471 virtual unsigned int MandatoryBlockSize() const {return 1;}
00472
00473
00474
00475 virtual unsigned int OptimalBlockSize() const {return MandatoryBlockSize();}
00476
00477 virtual unsigned int GetOptimalBlockSizeUsed() const {return 0;}
00478
00479
00480 virtual unsigned int OptimalDataAlignment() const {return 1;}
00481
00482
00483
00484 virtual void ProcessData(byte *outString, const byte *inString, size_t length) =0;
00485
00486
00487
00488 virtual void ProcessLastBlock(byte *outString, const byte *inString, size_t length);
00489
00490 virtual unsigned int MinLastBlockSize() const {return 0;}
00491
00492
00493 inline void ProcessString(byte *inoutString, size_t length)
00494 {ProcessData(inoutString, inoutString, length);}
00495
00496 inline void ProcessString(byte *outString, const byte *inString, size_t length)
00497 {ProcessData(outString, inString, length);}
00498
00499 inline byte ProcessByte(byte input)
00500 {ProcessData(&input, &input, 1); return input;}
00501
00502
00503 virtual bool IsRandomAccess() const =0;
00504
00505 virtual void Seek(lword n)
00506 {
00507 assert(!IsRandomAccess());
00508 throw NotImplemented("StreamTransformation: this object doesn't support random access");
00509 }
00510
00511
00512 virtual bool IsSelfInverting() const =0;
00513
00514 virtual bool IsForwardTransformation() const =0;
00515 };
00516
00517
00518
00519
00520
00521
00522
00523
00524
00525 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE HashTransformation : public Algorithm
00526 {
00527 public:
00528
00529
00530
00531 HashTransformation& Ref() {return *this;}
00532
00533
00534 virtual void Update(const byte *input, size_t length) =0;
00535
00536
00537 virtual byte * CreateUpdateSpace(size_t &size) {size=0; return NULL;}
00538
00539
00540
00541 virtual void Final(byte *digest)
00542 {TruncatedFinal(digest, DigestSize());}
00543
00544
00545 virtual void Restart()
00546 {TruncatedFinal(NULL, 0);}
00547
00548
00549 virtual unsigned int DigestSize() const =0;
00550
00551
00552 virtual unsigned int BlockSize() const {return 0;}
00553
00554
00555 virtual unsigned int OptimalBlockSize() const {return 1;}
00556
00557
00558 virtual unsigned int OptimalDataAlignment() const {return 1;}
00559
00560
00561 virtual void CalculateDigest(byte *digest, const byte *input, size_t length)
00562 {Update(input, length); Final(digest);}
00563
00564
00565
00566
00567 virtual bool Verify(const byte *digest)
00568 {return TruncatedVerify(digest, DigestSize());}
00569
00570
00571 virtual bool VerifyDigest(const byte *digest, const byte *input, size_t length)
00572 {Update(input, length); return Verify(digest);}
00573
00574
00575 virtual void TruncatedFinal(byte *digest, size_t digestSize) =0;
00576
00577
00578 virtual void CalculateTruncatedDigest(byte *digest, size_t digestSize, const byte *input, size_t length)
00579 {Update(input, length); TruncatedFinal(digest, digestSize);}
00580
00581
00582 virtual bool TruncatedVerify(const byte *digest, size_t digestLength);
00583
00584
00585 virtual bool VerifyTruncatedDigest(const byte *digest, size_t digestLength, const byte *input, size_t length)
00586 {Update(input, length); return TruncatedVerify(digest, digestLength);}
00587
00588 protected:
00589 void ThrowIfInvalidTruncatedSize(size_t size) const;
00590 };
00591
00592 typedef HashTransformation HashFunction;
00593
00594 template <class T>
00595 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE SimpleKeyedTransformation : public T, public SimpleKeyingInterface
00596 {
00597 protected:
00598 const Algorithm & GetAlgorithm() const {return *this;}
00599 };
00600
00601 #ifdef CRYPTOPP_DOXYGEN_PROCESSING
00602
00603
00604 class BlockCipher : public BlockTransformation, public SimpleKeyingInterface {};
00605
00606 class SymmetricCipher : public StreamTransformation, public SimpleKeyingInterface {};
00607
00608 class MessageAuthenticationCode : public HashTransformation, public SimpleKeyingInterface {};
00609 #else
00610 typedef SimpleKeyedTransformation<BlockTransformation> BlockCipher;
00611 typedef SimpleKeyedTransformation<StreamTransformation> SymmetricCipher;
00612 typedef SimpleKeyedTransformation<HashTransformation> MessageAuthenticationCode;
00613 #endif
00614
00615 CRYPTOPP_DLL_TEMPLATE_CLASS SimpleKeyedTransformation<BlockTransformation>;
00616 CRYPTOPP_DLL_TEMPLATE_CLASS SimpleKeyedTransformation<StreamTransformation>;
00617 CRYPTOPP_DLL_TEMPLATE_CLASS SimpleKeyedTransformation<HashTransformation>;
00618
00619 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY
00620 typedef SymmetricCipher StreamCipher;
00621 #endif
00622
00623
00624
00625
00626 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE RandomNumberGenerator : public Algorithm
00627 {
00628 public:
00629
00630 virtual void IncorporateEntropy(const byte *input, size_t length) {throw NotImplemented("RandomNumberGenerator: IncorporateEntropy not implemented");}
00631
00632
00633 virtual bool CanIncorporateEntropy() const {return false;}
00634
00635
00636 virtual byte GenerateByte();
00637
00638
00639
00640 virtual unsigned int GenerateBit();
00641
00642
00643 virtual word32 GenerateWord32(word32 a=0, word32 b=0xffffffffL);
00644
00645
00646 virtual void GenerateBlock(byte *output, size_t size);
00647
00648
00649 virtual void DiscardBytes(size_t n);
00650
00651
00652 virtual void GenerateIntoBufferedTransformation(BufferedTransformation &target, const std::string &channel, lword length);
00653
00654
00655 template <class IT> void Shuffle(IT begin, IT end)
00656 {
00657 for (; begin != end; ++begin)
00658 std::iter_swap(begin, begin + GenerateWord32(0, end-begin-1));
00659 }
00660
00661 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY
00662 byte GetByte() {return GenerateByte();}
00663 unsigned int GetBit() {return GenerateBit();}
00664 word32 GetLong(word32 a=0, word32 b=0xffffffffL) {return GenerateWord32(a, b);}
00665 word16 GetShort(word16 a=0, word16 b=0xffff) {return (word16)GenerateWord32(a, b);}
00666 void GetBlock(byte *output, size_t size) {GenerateBlock(output, size);}
00667 #endif
00668 };
00669
00670
00671 CRYPTOPP_DLL RandomNumberGenerator & CRYPTOPP_API NullRNG();
00672
00673 class WaitObjectContainer;
00674 class CallStack;
00675
00676
00677
00678 class CRYPTOPP_NO_VTABLE Waitable
00679 {
00680 public:
00681
00682 virtual unsigned int GetMaxWaitObjectCount() const =0;
00683
00684
00685
00686
00687
00688 virtual void GetWaitObjects(WaitObjectContainer &container, CallStack const& callStack) =0;
00689
00690
00691 bool Wait(unsigned long milliseconds, CallStack const& callStack);
00692 };
00693
00694
00695
00696
00697
00698
00699
00700
00701
00702
00703
00704
00705
00706
00707
00708
00709
00710
00711
00712
00713
00714
00715
00716
00717
00718
00719
00720 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE BufferedTransformation : public Algorithm, public Waitable
00721 {
00722 public:
00723
00724 static const std::string NULL_CHANNEL;
00725
00726 BufferedTransformation() : Algorithm(false) {}
00727
00728
00729
00730
00731 BufferedTransformation& Ref() {return *this;}
00732
00733
00734
00735
00736 size_t Put(byte inByte, bool blocking=true)
00737 {return Put(&inByte, 1, blocking);}
00738
00739 size_t Put(const byte *inString, size_t length, bool blocking=true)
00740 {return Put2(inString, length, 0, blocking);}
00741
00742
00743 size_t PutWord16(word16 value, ByteOrder order=BIG_ENDIAN_ORDER, bool blocking=true);
00744
00745 size_t PutWord32(word32 value, ByteOrder order=BIG_ENDIAN_ORDER, bool blocking=true);
00746
00747
00748
00749
00750 virtual byte * CreatePutSpace(size_t &size) {size=0; return NULL;}
00751
00752 virtual bool CanModifyInput() const {return false;}
00753
00754
00755 size_t PutModifiable(byte *inString, size_t length, bool blocking=true)
00756 {return PutModifiable2(inString, length, 0, blocking);}
00757
00758 bool MessageEnd(int propagation=-1, bool blocking=true)
00759 {return !!Put2(NULL, 0, propagation < 0 ? -1 : propagation+1, blocking);}
00760 size_t PutMessageEnd(const byte *inString, size_t length, int propagation=-1, bool blocking=true)
00761 {return Put2(inString, length, propagation < 0 ? -1 : propagation+1, blocking);}
00762
00763
00764
00765 virtual size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking) =0;
00766
00767
00768 virtual size_t PutModifiable2(byte *inString, size_t length, int messageEnd, bool blocking)
00769 {return Put2(inString, length, messageEnd, blocking);}
00770
00771
00772 struct BlockingInputOnly : public NotImplemented
00773 {BlockingInputOnly(const std::string &s) : NotImplemented(s + ": Nonblocking input is not implemented by this object.") {}};
00774
00775
00776
00777
00778 unsigned int GetMaxWaitObjectCount() const;
00779 void GetWaitObjects(WaitObjectContainer &container, CallStack const& callStack);
00780
00781
00782
00783
00784 virtual void IsolatedInitialize(const NameValuePairs ¶meters) {throw NotImplemented("BufferedTransformation: this object can't be reinitialized");}
00785 virtual bool IsolatedFlush(bool hardFlush, bool blocking) =0;
00786 virtual bool IsolatedMessageSeriesEnd(bool blocking) {return false;}
00787
00788
00789 virtual void Initialize(const NameValuePairs ¶meters=g_nullNameValuePairs, int propagation=-1);
00790
00791
00792
00793
00794
00795
00796
00797
00798
00799
00800
00801 virtual bool Flush(bool hardFlush, int propagation=-1, bool blocking=true);
00802
00803
00804 virtual bool MessageSeriesEnd(int propagation=-1, bool blocking=true);
00805
00806
00807
00808 virtual void SetAutoSignalPropagation(int propagation) {}
00809
00810
00811 virtual int GetAutoSignalPropagation() const {return 0;}
00812 public:
00813
00814 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY
00815 void Close() {MessageEnd();}
00816 #endif
00817
00818
00819
00820
00821
00822
00823
00824
00825 virtual lword MaxRetrievable() const;
00826
00827
00828 virtual bool AnyRetrievable() const;
00829
00830
00831 virtual size_t Get(byte &outByte);
00832
00833 virtual size_t Get(byte *outString, size_t getMax);
00834
00835
00836 virtual size_t Peek(byte &outByte) const;
00837
00838 virtual size_t Peek(byte *outString, size_t peekMax) const;
00839
00840
00841 size_t GetWord16(word16 &value, ByteOrder order=BIG_ENDIAN_ORDER);
00842
00843 size_t GetWord32(word32 &value, ByteOrder order=BIG_ENDIAN_ORDER);
00844
00845
00846 size_t PeekWord16(word16 &value, ByteOrder order=BIG_ENDIAN_ORDER) const;
00847
00848 size_t PeekWord32(word32 &value, ByteOrder order=BIG_ENDIAN_ORDER) const;
00849
00850
00851 lword TransferTo(BufferedTransformation &target, lword transferMax=LWORD_MAX, const std::string &channel=NULL_CHANNEL)
00852 {TransferTo2(target, transferMax, channel); return transferMax;}
00853
00854
00855 virtual lword Skip(lword skipMax=LWORD_MAX);
00856
00857
00858 lword CopyTo(BufferedTransformation &target, lword copyMax=LWORD_MAX, const std::string &channel=NULL_CHANNEL) const
00859 {return CopyRangeTo(target, 0, copyMax, channel);}
00860
00861
00862 lword CopyRangeTo(BufferedTransformation &target, lword position, lword copyMax=LWORD_MAX, const std::string &channel=NULL_CHANNEL) const
00863 {lword i = position; CopyRangeTo2(target, i, i+copyMax, channel); return i-position;}
00864
00865 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY
00866 unsigned long MaxRetrieveable() const {return MaxRetrievable();}
00867 #endif
00868
00869
00870
00871
00872
00873 virtual lword TotalBytesRetrievable() const;
00874
00875 virtual unsigned int NumberOfMessages() const;
00876
00877 virtual bool AnyMessages() const;
00878
00879
00880
00881
00882
00883 virtual bool GetNextMessage();
00884
00885 virtual unsigned int SkipMessages(unsigned int count=UINT_MAX);
00886
00887 unsigned int TransferMessagesTo(BufferedTransformation &target, unsigned int count=UINT_MAX, const std::string &channel=NULL_CHANNEL)
00888 {TransferMessagesTo2(target, count, channel); return count;}
00889
00890 unsigned int CopyMessagesTo(BufferedTransformation &target, unsigned int count=UINT_MAX, const std::string &channel=NULL_CHANNEL) const;
00891
00892
00893 virtual void SkipAll();
00894
00895 void TransferAllTo(BufferedTransformation &target, const std::string &channel=NULL_CHANNEL)
00896 {TransferAllTo2(target, channel);}
00897
00898 void CopyAllTo(BufferedTransformation &target, const std::string &channel=NULL_CHANNEL) const;
00899
00900 virtual bool GetNextMessageSeries() {return false;}
00901 virtual unsigned int NumberOfMessagesInThisSeries() const {return NumberOfMessages();}
00902 virtual unsigned int NumberOfMessageSeries() const {return 0;}
00903
00904
00905
00906
00907
00908 virtual size_t TransferTo2(BufferedTransformation &target, lword &byteCount, const std::string &channel=NULL_CHANNEL, bool blocking=true) =0;
00909
00910 virtual size_t CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end=LWORD_MAX, const std::string &channel=NULL_CHANNEL, bool blocking=true) const =0;
00911
00912 size_t TransferMessagesTo2(BufferedTransformation &target, unsigned int &messageCount, const std::string &channel=NULL_CHANNEL, bool blocking=true);
00913
00914 size_t TransferAllTo2(BufferedTransformation &target, const std::string &channel=NULL_CHANNEL, bool blocking=true);
00915
00916
00917
00918
00919 struct NoChannelSupport : public NotImplemented
00920 {NoChannelSupport() : NotImplemented("BufferedTransformation: this object doesn't support multiple channels") {}};
00921
00922 size_t ChannelPut(const std::string &channel, byte inByte, bool blocking=true)
00923 {return ChannelPut(channel, &inByte, 1, blocking);}
00924 size_t ChannelPut(const std::string &channel, const byte *inString, size_t length, bool blocking=true)
00925 {return ChannelPut2(channel, inString, length, 0, blocking);}
00926
00927 size_t ChannelPutModifiable(const std::string &channel, byte *inString, size_t length, bool blocking=true)
00928 {return ChannelPutModifiable2(channel, inString, length, 0, blocking);}
00929
00930 size_t ChannelPutWord16(const std::string &channel, word16 value, ByteOrder order=BIG_ENDIAN_ORDER, bool blocking=true);
00931 size_t ChannelPutWord32(const std::string &channel, word32 value, ByteOrder order=BIG_ENDIAN_ORDER, bool blocking=true);
00932
00933 bool ChannelMessageEnd(const std::string &channel, int propagation=-1, bool blocking=true)
00934 {return !!ChannelPut2(channel, NULL, 0, propagation < 0 ? -1 : propagation+1, blocking);}
00935 size_t ChannelPutMessageEnd(const std::string &channel, const byte *inString, size_t length, int propagation=-1, bool blocking=true)
00936 {return ChannelPut2(channel, inString, length, propagation < 0 ? -1 : propagation+1, blocking);}
00937
00938 virtual byte * ChannelCreatePutSpace(const std::string &channel, size_t &size);
00939
00940 virtual size_t ChannelPut2(const std::string &channel, const byte *begin, size_t length, int messageEnd, bool blocking);
00941 virtual size_t ChannelPutModifiable2(const std::string &channel, byte *begin, size_t length, int messageEnd, bool blocking);
00942
00943 virtual bool ChannelFlush(const std::string &channel, bool hardFlush, int propagation=-1, bool blocking=true);
00944 virtual bool ChannelMessageSeriesEnd(const std::string &channel, int propagation=-1, bool blocking=true);
00945
00946 virtual void SetRetrievalChannel(const std::string &channel);
00947
00948
00949
00950
00951
00952
00953
00954
00955
00956
00957
00958 virtual bool Attachable() {return false;}
00959
00960 virtual BufferedTransformation *AttachedTransformation() {assert(!Attachable()); return 0;}
00961
00962 virtual const BufferedTransformation *AttachedTransformation() const
00963 {return const_cast<BufferedTransformation *>(this)->AttachedTransformation();}
00964
00965 virtual void Detach(BufferedTransformation *newAttachment = 0)
00966 {assert(!Attachable()); throw NotImplemented("BufferedTransformation: this object is not attachable");}
00967
00968 virtual void Attach(BufferedTransformation *newAttachment);
00969
00970
00971 protected:
00972 static int DecrementPropagation(int propagation)
00973 {return propagation != 0 ? propagation - 1 : 0;}
00974
00975 private:
00976 byte m_buf[4];
00977 };
00978
00979
00980 BufferedTransformation & TheBitBucket();
00981
00982
00983
00984 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CryptoMaterial : public NameValuePairs
00985 {
00986 public:
00987
00988 class CRYPTOPP_DLL InvalidMaterial : public InvalidDataFormat
00989 {
00990 public:
00991 explicit InvalidMaterial(const std::string &s) : InvalidDataFormat(s) {}
00992 };
00993
00994
00995
00996 virtual void AssignFrom(const NameValuePairs &source) =0;
00997
00998
00999
01000
01001
01002
01003
01004
01005 virtual bool Validate(RandomNumberGenerator &rng, unsigned int level) const =0;
01006
01007
01008 virtual void ThrowIfInvalid(RandomNumberGenerator &rng, unsigned int level) const
01009 {if (!Validate(rng, level)) throw InvalidMaterial("CryptoMaterial: this object contains invalid values");}
01010
01011
01012
01013
01014 virtual void Save(BufferedTransformation &bt) const
01015 {throw NotImplemented("CryptoMaterial: this object does not support saving");}
01016
01017
01018
01019
01020
01021 virtual void Load(BufferedTransformation &bt)
01022 {throw NotImplemented("CryptoMaterial: this object does not support loading");}
01023
01024
01025 virtual bool SupportsPrecomputation() const {return false;}
01026
01027
01028
01029
01030 virtual void Precompute(unsigned int n)
01031 {assert(!SupportsPrecomputation()); throw NotImplemented("CryptoMaterial: this object does not support precomputation");}
01032
01033 virtual void LoadPrecomputation(BufferedTransformation &storedPrecomputation)
01034 {assert(!SupportsPrecomputation()); throw NotImplemented("CryptoMaterial: this object does not support precomputation");}
01035
01036 virtual void SavePrecomputation(BufferedTransformation &storedPrecomputation) const
01037 {assert(!SupportsPrecomputation()); throw NotImplemented("CryptoMaterial: this object does not support precomputation");}
01038
01039
01040 void DoQuickSanityCheck() const {ThrowIfInvalid(NullRNG(), 0);}
01041
01042 #ifdef __SUNPRO_CC
01043
01044 char m_sunCCworkaround;
01045 #endif
01046 };
01047
01048
01049
01050 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE GeneratableCryptoMaterial : virtual public CryptoMaterial
01051 {
01052 public:
01053
01054
01055
01056 virtual void GenerateRandom(RandomNumberGenerator &rng, const NameValuePairs ¶ms = g_nullNameValuePairs)
01057 {throw NotImplemented("GeneratableCryptoMaterial: this object does not support key/parameter generation");}
01058
01059
01060 void GenerateRandomWithKeySize(RandomNumberGenerator &rng, unsigned int keySize);
01061 };
01062
01063
01064
01065 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PublicKey : virtual public CryptoMaterial
01066 {
01067 };
01068
01069
01070
01071 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PrivateKey : public GeneratableCryptoMaterial
01072 {
01073 };
01074
01075
01076
01077 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CryptoParameters : public GeneratableCryptoMaterial
01078 {
01079 };
01080
01081
01082
01083 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE AsymmetricAlgorithm : public Algorithm
01084 {
01085 public:
01086
01087 virtual CryptoMaterial & AccessMaterial() =0;
01088
01089 virtual const CryptoMaterial & GetMaterial() const =0;
01090
01091
01092 void BERDecode(BufferedTransformation &bt)
01093 {AccessMaterial().Load(bt);}
01094
01095 void DEREncode(BufferedTransformation &bt) const
01096 {GetMaterial().Save(bt);}
01097 };
01098
01099
01100
01101 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PublicKeyAlgorithm : public AsymmetricAlgorithm
01102 {
01103 public:
01104
01105 CryptoMaterial & AccessMaterial() {return AccessPublicKey();}
01106 const CryptoMaterial & GetMaterial() const {return GetPublicKey();}
01107
01108 virtual PublicKey & AccessPublicKey() =0;
01109 virtual const PublicKey & GetPublicKey() const {return const_cast<PublicKeyAlgorithm *>(this)->AccessPublicKey();}
01110 };
01111
01112
01113
01114 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PrivateKeyAlgorithm : public AsymmetricAlgorithm
01115 {
01116 public:
01117 CryptoMaterial & AccessMaterial() {return AccessPrivateKey();}
01118 const CryptoMaterial & GetMaterial() const {return GetPrivateKey();}
01119
01120 virtual PrivateKey & AccessPrivateKey() =0;
01121 virtual const PrivateKey & GetPrivateKey() const {return const_cast<PrivateKeyAlgorithm *>(this)->AccessPrivateKey();}
01122 };
01123
01124
01125
01126 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE KeyAgreementAlgorithm : public AsymmetricAlgorithm
01127 {
01128 public:
01129 CryptoMaterial & AccessMaterial() {return AccessCryptoParameters();}
01130 const CryptoMaterial & GetMaterial() const {return GetCryptoParameters();}
01131
01132 virtual CryptoParameters & AccessCryptoParameters() =0;
01133 virtual const CryptoParameters & GetCryptoParameters() const {return const_cast<KeyAgreementAlgorithm *>(this)->AccessCryptoParameters();}
01134 };
01135
01136
01137
01138
01139
01140
01141 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_CryptoSystem
01142 {
01143 public:
01144 virtual ~PK_CryptoSystem() {}
01145
01146
01147
01148 virtual size_t MaxPlaintextLength(size_t ciphertextLength) const =0;
01149
01150
01151
01152 virtual size_t CiphertextLength(size_t plaintextLength) const =0;
01153
01154
01155
01156 virtual bool ParameterSupported(const char *name) const =0;
01157
01158
01159
01160
01161 virtual size_t FixedCiphertextLength() const {return 0;}
01162
01163
01164 virtual size_t FixedMaxPlaintextLength() const {return 0;}
01165
01166 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY
01167 size_t MaxPlainTextLength(size_t cipherTextLength) const {return MaxPlaintextLength(cipherTextLength);}
01168 size_t CipherTextLength(size_t plainTextLength) const {return CiphertextLength(plainTextLength);}
01169 #endif
01170 };
01171
01172
01173 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_Encryptor : public PK_CryptoSystem, public PublicKeyAlgorithm
01174 {
01175 public:
01176
01177 class CRYPTOPP_DLL InvalidPlaintextLength : public Exception
01178 {
01179 public:
01180 InvalidPlaintextLength() : Exception(OTHER_ERROR, "PK_Encryptor: invalid plaintext length") {}
01181 };
01182
01183
01184
01185
01186
01187 virtual void Encrypt(RandomNumberGenerator &rng,
01188 const byte *plaintext, size_t plaintextLength,
01189 byte *ciphertext, const NameValuePairs ¶meters = g_nullNameValuePairs) const =0;
01190
01191
01192
01193
01194
01195 virtual BufferedTransformation * CreateEncryptionFilter(RandomNumberGenerator &rng,
01196 BufferedTransformation *attachment=NULL, const NameValuePairs ¶meters = g_nullNameValuePairs) const;
01197 };
01198
01199
01200
01201 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_Decryptor : public PK_CryptoSystem, public PrivateKeyAlgorithm
01202 {
01203 public:
01204
01205
01206
01207
01208 virtual DecodingResult Decrypt(RandomNumberGenerator &rng,
01209 const byte *ciphertext, size_t ciphertextLength,
01210 byte *plaintext, const NameValuePairs ¶meters = g_nullNameValuePairs) const =0;
01211
01212
01213
01214
01215 virtual BufferedTransformation * CreateDecryptionFilter(RandomNumberGenerator &rng,
01216 BufferedTransformation *attachment=NULL, const NameValuePairs ¶meters = g_nullNameValuePairs) const;
01217
01218
01219 DecodingResult FixedLengthDecrypt(RandomNumberGenerator &rng, const byte *ciphertext, byte *plaintext, const NameValuePairs ¶meters = g_nullNameValuePairs) const
01220 {return Decrypt(rng, ciphertext, FixedCiphertextLength(), plaintext, parameters);}
01221 };
01222
01223 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY
01224 typedef PK_CryptoSystem PK_FixedLengthCryptoSystem;
01225 typedef PK_Encryptor PK_FixedLengthEncryptor;
01226 typedef PK_Decryptor PK_FixedLengthDecryptor;
01227 #endif
01228
01229
01230
01231
01232
01233
01234 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_SignatureScheme
01235 {
01236 public:
01237
01238 class CRYPTOPP_DLL InvalidKeyLength : public Exception
01239 {
01240 public:
01241 InvalidKeyLength(const std::string &message) : Exception(OTHER_ERROR, message) {}
01242 };
01243
01244
01245 class CRYPTOPP_DLL KeyTooShort : public InvalidKeyLength
01246 {
01247 public:
01248 KeyTooShort() : InvalidKeyLength("PK_Signer: key too short for this signature scheme") {}
01249 };
01250
01251 virtual ~PK_SignatureScheme() {}
01252
01253
01254 virtual size_t SignatureLength() const =0;
01255
01256
01257 virtual size_t MaxSignatureLength(size_t recoverablePartLength = 0) const {return SignatureLength();}
01258
01259
01260 virtual size_t MaxRecoverableLength() const =0;
01261
01262
01263 virtual size_t MaxRecoverableLengthFromSignatureLength(size_t signatureLength) const =0;
01264
01265
01266
01267 virtual bool IsProbabilistic() const =0;
01268
01269
01270 virtual bool AllowNonrecoverablePart() const =0;
01271
01272
01273 virtual bool SignatureUpfront() const {return false;}
01274
01275
01276 virtual bool RecoverablePartFirst() const =0;
01277 };
01278
01279
01280
01281
01282
01283 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_MessageAccumulator : public HashTransformation
01284 {
01285 public:
01286
01287 unsigned int DigestSize() const
01288 {throw NotImplemented("PK_MessageAccumulator: DigestSize() should not be called");}
01289
01290 void TruncatedFinal(byte *digest, size_t digestSize)
01291 {throw NotImplemented("PK_MessageAccumulator: TruncatedFinal() should not be called");}
01292 };
01293
01294
01295
01296 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_Signer : public PK_SignatureScheme, public PrivateKeyAlgorithm
01297 {
01298 public:
01299
01300 virtual PK_MessageAccumulator * NewSignatureAccumulator(RandomNumberGenerator &rng) const =0;
01301
01302 virtual void InputRecoverableMessage(PK_MessageAccumulator &messageAccumulator, const byte *recoverableMessage, size_t recoverableMessageLength) const =0;
01303
01304
01305
01306
01307
01308 virtual size_t Sign(RandomNumberGenerator &rng, PK_MessageAccumulator *messageAccumulator, byte *signature) const;
01309
01310
01311
01312
01313
01314 virtual size_t SignAndRestart(RandomNumberGenerator &rng, PK_MessageAccumulator &messageAccumulator, byte *signature, bool restart=true) const =0;
01315
01316
01317
01318
01319
01320 virtual size_t SignMessage(RandomNumberGenerator &rng, const byte *message, size_t messageLen, byte *signature) const;
01321
01322
01323
01324
01325
01326 virtual size_t SignMessageWithRecovery(RandomNumberGenerator &rng, const byte *recoverableMessage, size_t recoverableMessageLength,
01327 const byte *nonrecoverableMessage, size_t nonrecoverableMessageLength, byte *signature) const;
01328 };
01329
01330
01331
01332
01333
01334
01335
01336
01337 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_Verifier : public PK_SignatureScheme, public PublicKeyAlgorithm
01338 {
01339 public:
01340
01341 virtual PK_MessageAccumulator * NewVerificationAccumulator() const =0;
01342
01343
01344 virtual void InputSignature(PK_MessageAccumulator &messageAccumulator, const byte *signature, size_t signatureLength) const =0;
01345
01346
01347 virtual bool Verify(PK_MessageAccumulator *messageAccumulator) const;
01348
01349
01350 virtual bool VerifyAndRestart(PK_MessageAccumulator &messageAccumulator) const =0;
01351
01352
01353 virtual bool VerifyMessage(const byte *message, size_t messageLen,
01354 const byte *signature, size_t signatureLength) const;
01355
01356
01357
01358
01359 virtual DecodingResult Recover(byte *recoveredMessage, PK_MessageAccumulator *messageAccumulator) const;
01360
01361
01362
01363
01364 virtual DecodingResult RecoverAndRestart(byte *recoveredMessage, PK_MessageAccumulator &messageAccumulator) const =0;
01365
01366
01367
01368
01369 virtual DecodingResult RecoverMessage(byte *recoveredMessage,
01370 const byte *nonrecoverableMessage, size_t nonrecoverableMessageLength,
01371 const byte *signature, size_t signatureLength) const;
01372 };
01373
01374
01375
01376
01377
01378
01379
01380 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE SimpleKeyAgreementDomain : public KeyAgreementAlgorithm
01381 {
01382 public:
01383
01384 virtual unsigned int AgreedValueLength() const =0;
01385
01386 virtual unsigned int PrivateKeyLength() const =0;
01387
01388 virtual unsigned int PublicKeyLength() const =0;
01389
01390
01391 virtual void GeneratePrivateKey(RandomNumberGenerator &rng, byte *privateKey) const =0;
01392
01393
01394 virtual void GeneratePublicKey(RandomNumberGenerator &rng, const byte *privateKey, byte *publicKey) const =0;
01395
01396
01397 virtual void GenerateKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const;
01398
01399
01400
01401
01402
01403
01404 virtual bool Agree(byte *agreedValue, const byte *privateKey, const byte *otherPublicKey, bool validateOtherPublicKey=true) const =0;
01405
01406 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY
01407 bool ValidateDomainParameters(RandomNumberGenerator &rng) const
01408 {return GetCryptoParameters().Validate(rng, 2);}
01409 #endif
01410 };
01411
01412
01413
01414
01415
01416
01417
01418 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE AuthenticatedKeyAgreementDomain : public KeyAgreementAlgorithm
01419 {
01420 public:
01421
01422 virtual unsigned int AgreedValueLength() const =0;
01423
01424
01425 virtual unsigned int StaticPrivateKeyLength() const =0;
01426
01427 virtual unsigned int StaticPublicKeyLength() const =0;
01428
01429
01430 virtual void GenerateStaticPrivateKey(RandomNumberGenerator &rng, byte *privateKey) const =0;
01431
01432
01433 virtual void GenerateStaticPublicKey(RandomNumberGenerator &rng, const byte *privateKey, byte *publicKey) const =0;
01434
01435
01436 virtual void GenerateStaticKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const;
01437
01438
01439 virtual unsigned int EphemeralPrivateKeyLength() const =0;
01440
01441 virtual unsigned int EphemeralPublicKeyLength() const =0;
01442
01443
01444 virtual void GenerateEphemeralPrivateKey(RandomNumberGenerator &rng, byte *privateKey) const =0;
01445
01446
01447 virtual void GenerateEphemeralPublicKey(RandomNumberGenerator &rng, const byte *privateKey, byte *publicKey) const =0;
01448
01449
01450 virtual void GenerateEphemeralKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const;
01451
01452
01453
01454
01455
01456
01457
01458
01459
01460
01461 virtual bool Agree(byte *agreedValue,
01462 const byte *staticPrivateKey, const byte *ephemeralPrivateKey,
01463 const byte *staticOtherPublicKey, const byte *ephemeralOtherPublicKey,
01464 bool validateStaticOtherPublicKey=true) const =0;
01465
01466 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY
01467 bool ValidateDomainParameters(RandomNumberGenerator &rng) const
01468 {return GetCryptoParameters().Validate(rng, 2);}
01469 #endif
01470 };
01471
01472
01473 #if 0
01474
01475
01476
01477
01478
01479
01480
01481
01482
01483
01484
01485
01486
01487
01488
01489
01490
01491
01492
01493
01494
01495 class ProtocolSession
01496 {
01497 public:
01498
01499 class ProtocolError : public Exception
01500 {
01501 public:
01502 ProtocolError(ErrorType errorType, const std::string &s) : Exception(errorType, s) {}
01503 };
01504
01505
01506
01507 class UnexpectedMethodCall : public Exception
01508 {
01509 public:
01510 UnexpectedMethodCall(const std::string &s) : Exception(OTHER_ERROR, s) {}
01511 };
01512
01513 ProtocolSession() : m_rng(NULL), m_throwOnProtocolError(true), m_validState(false) {}
01514 virtual ~ProtocolSession() {}
01515
01516 virtual void InitializeSession(RandomNumberGenerator &rng, const NameValuePairs ¶meters) =0;
01517
01518 bool GetThrowOnProtocolError() const {return m_throwOnProtocolError;}
01519 void SetThrowOnProtocolError(bool throwOnProtocolError) {m_throwOnProtocolError = throwOnProtocolError;}
01520
01521 bool HasValidState() const {return m_validState;}
01522
01523 virtual bool OutgoingMessageAvailable() const =0;
01524 virtual unsigned int GetOutgoingMessageLength() const =0;
01525 virtual void GetOutgoingMessage(byte *message) =0;
01526
01527 virtual bool LastMessageProcessed() const =0;
01528 virtual void ProcessIncomingMessage(const byte *message, unsigned int messageLength) =0;
01529
01530 protected:
01531 void HandleProtocolError(Exception::ErrorType errorType, const std::string &s) const;
01532 void CheckAndHandleInvalidState() const;
01533 void SetValidState(bool valid) {m_validState = valid;}
01534
01535 RandomNumberGenerator *m_rng;
01536
01537 private:
01538 bool m_throwOnProtocolError, m_validState;
01539 };
01540
01541 class KeyAgreementSession : public ProtocolSession
01542 {
01543 public:
01544 virtual unsigned int GetAgreedValueLength() const =0;
01545 virtual void GetAgreedValue(byte *agreedValue) const =0;
01546 };
01547
01548 class PasswordAuthenticatedKeyAgreementSession : public KeyAgreementSession
01549 {
01550 public:
01551 void InitializePasswordAuthenticatedKeyAgreementSession(RandomNumberGenerator &rng,
01552 const byte *myId, unsigned int myIdLength,
01553 const byte *counterPartyId, unsigned int counterPartyIdLength,
01554 const byte *passwordOrVerifier, unsigned int passwordOrVerifierLength);
01555 };
01556
01557 class PasswordAuthenticatedKeyAgreementDomain : public KeyAgreementAlgorithm
01558 {
01559 public:
01560
01561 virtual bool ValidateDomainParameters(RandomNumberGenerator &rng) const
01562 {return GetCryptoParameters().Validate(rng, 2);}
01563
01564 virtual unsigned int GetPasswordVerifierLength(const byte *password, unsigned int passwordLength) const =0;
01565 virtual void GeneratePasswordVerifier(RandomNumberGenerator &rng, const byte *userId, unsigned int userIdLength, const byte *password, unsigned int passwordLength, byte *verifier) const =0;
01566
01567 enum RoleFlags {CLIENT=1, SERVER=2, INITIATOR=4, RESPONDER=8};
01568
01569 virtual bool IsValidRole(unsigned int role) =0;
01570 virtual PasswordAuthenticatedKeyAgreementSession * CreateProtocolSession(unsigned int role) const =0;
01571 };
01572 #endif
01573
01574
01575 class CRYPTOPP_DLL BERDecodeErr : public InvalidArgument
01576 {
01577 public:
01578 BERDecodeErr() : InvalidArgument("BER decode error") {}
01579 BERDecodeErr(const std::string &s) : InvalidArgument(s) {}
01580 };
01581
01582
01583 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE ASN1Object
01584 {
01585 public:
01586 virtual ~ASN1Object() {}
01587
01588 virtual void BERDecode(BufferedTransformation &bt) =0;
01589
01590 virtual void DEREncode(BufferedTransformation &bt) const =0;
01591
01592
01593 virtual void BEREncode(BufferedTransformation &bt) const {DEREncode(bt);}
01594 };
01595
01596 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY
01597 typedef PK_SignatureScheme PK_SignatureSystem;
01598 typedef SimpleKeyAgreementDomain PK_SimpleKeyAgreementDomain;
01599 typedef AuthenticatedKeyAgreementDomain PK_AuthenticatedKeyAgreementDomain;
01600 #endif
01601
01602 NAMESPACE_END
01603
01604 #endif