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