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);
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 virtual const Algorithm & GetAlgorithm() const =0;
00404 virtual void UncheckedSetKey(const byte *key, unsigned int length, const NameValuePairs ¶ms) =0;
00405
00406 void ThrowIfInvalidKeyLength(size_t length);
00407 void ThrowIfResynchronizable();
00408 void ThrowIfInvalidIV(const byte *iv);
00409 const byte * GetIVAndThrowIfInvalid(const NameValuePairs ¶ms);
00410 inline void AssertValidKeyLength(size_t length) const
00411 {assert(IsValidKeyLength(length));}
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 inline CipherDir GetCipherDirection() const {return IsForwardTransformation() ? ENCRYPTION : DECRYPTION;}
00456 };
00457
00458
00459
00460 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE StreamTransformation : public Algorithm
00461 {
00462 public:
00463
00464
00465
00466 StreamTransformation& Ref() {return *this;}
00467
00468
00469 virtual unsigned int MandatoryBlockSize() const {return 1;}
00470
00471
00472
00473 virtual unsigned int OptimalBlockSize() const {return MandatoryBlockSize();}
00474
00475 virtual unsigned int GetOptimalBlockSizeUsed() const {return 0;}
00476
00477
00478 virtual unsigned int OptimalDataAlignment() const {return 1;}
00479
00480
00481
00482 virtual void ProcessData(byte *outString, const byte *inString, size_t length) =0;
00483
00484
00485
00486 virtual void ProcessLastBlock(byte *outString, const byte *inString, size_t length);
00487
00488 virtual unsigned int MinLastBlockSize() const {return 0;}
00489
00490
00491 inline void ProcessString(byte *inoutString, size_t length)
00492 {ProcessData(inoutString, inoutString, length);}
00493
00494 inline void ProcessString(byte *outString, const byte *inString, size_t length)
00495 {ProcessData(outString, inString, length);}
00496
00497 inline byte ProcessByte(byte input)
00498 {ProcessData(&input, &input, 1); return input;}
00499
00500
00501 virtual bool IsRandomAccess() const =0;
00502
00503 virtual void Seek(lword n)
00504 {
00505 assert(!IsRandomAccess());
00506 throw NotImplemented("StreamTransformation: this object doesn't support random access");
00507 }
00508
00509
00510 virtual bool IsSelfInverting() const =0;
00511
00512 virtual bool IsForwardTransformation() const =0;
00513 };
00514
00515
00516
00517
00518
00519
00520
00521
00522
00523 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE HashTransformation : public Algorithm
00524 {
00525 public:
00526
00527
00528
00529 HashTransformation& Ref() {return *this;}
00530
00531
00532 virtual void Update(const byte *input, size_t length) =0;
00533
00534
00535 virtual byte * CreateUpdateSpace(size_t &size) {size=0; return NULL;}
00536
00537
00538
00539 virtual void Final(byte *digest)
00540 {TruncatedFinal(digest, DigestSize());}
00541
00542
00543 virtual void Restart()
00544 {TruncatedFinal(NULL, 0);}
00545
00546
00547 virtual unsigned int DigestSize() const =0;
00548
00549
00550 virtual unsigned int BlockSize() const {return 0;}
00551
00552
00553 virtual unsigned int OptimalBlockSize() const {return 1;}
00554
00555
00556 virtual unsigned int OptimalDataAlignment() const {return 1;}
00557
00558
00559 virtual void CalculateDigest(byte *digest, const byte *input, size_t length)
00560 {Update(input, length); Final(digest);}
00561
00562
00563
00564
00565 virtual bool Verify(const byte *digest)
00566 {return TruncatedVerify(digest, DigestSize());}
00567
00568
00569 virtual bool VerifyDigest(const byte *digest, const byte *input, size_t length)
00570 {Update(input, length); return Verify(digest);}
00571
00572
00573 virtual void TruncatedFinal(byte *digest, size_t digestSize) =0;
00574
00575
00576 virtual void CalculateTruncatedDigest(byte *digest, size_t digestSize, const byte *input, size_t length)
00577 {Update(input, length); TruncatedFinal(digest, digestSize);}
00578
00579
00580 virtual bool TruncatedVerify(const byte *digest, size_t digestLength);
00581
00582
00583 virtual bool VerifyTruncatedDigest(const byte *digest, size_t digestLength, const byte *input, size_t length)
00584 {Update(input, length); return TruncatedVerify(digest, digestLength);}
00585
00586 protected:
00587 void ThrowIfInvalidTruncatedSize(size_t size) const;
00588 };
00589
00590 typedef HashTransformation HashFunction;
00591
00592 template <class T>
00593 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE SimpleKeyedTransformation : public T, public SimpleKeyingInterface
00594 {
00595 protected:
00596 const Algorithm & GetAlgorithm() const {return *this;}
00597 };
00598
00599 #ifdef CRYPTOPP_DOXYGEN_PROCESSING
00600
00601
00602 class BlockCipher : public BlockTransformation, public SimpleKeyingInterface {};
00603
00604 class SymmetricCipher : public StreamTransformation, public SimpleKeyingInterface {};
00605
00606 class MessageAuthenticationCode : public HashTransformation, public SimpleKeyingInterface {};
00607 #else
00608 typedef SimpleKeyedTransformation<BlockTransformation> BlockCipher;
00609 typedef SimpleKeyedTransformation<StreamTransformation> SymmetricCipher;
00610 typedef SimpleKeyedTransformation<HashTransformation> MessageAuthenticationCode;
00611 #endif
00612
00613 CRYPTOPP_DLL_TEMPLATE_CLASS SimpleKeyedTransformation<BlockTransformation>;
00614 CRYPTOPP_DLL_TEMPLATE_CLASS SimpleKeyedTransformation<StreamTransformation>;
00615 CRYPTOPP_DLL_TEMPLATE_CLASS SimpleKeyedTransformation<HashTransformation>;
00616
00617 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY
00618 typedef SymmetricCipher StreamCipher;
00619 #endif
00620
00621
00622
00623
00624 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE RandomNumberGenerator : public Algorithm
00625 {
00626 public:
00627
00628 virtual byte GenerateByte() =0;
00629
00630
00631
00632 virtual unsigned int GenerateBit();
00633
00634
00635 virtual word32 GenerateWord32(word32 a=0, word32 b=0xffffffffL);
00636
00637
00638
00639 virtual void GenerateBlock(byte *output, size_t size);
00640
00641
00642
00643 virtual void DiscardBytes(size_t n);
00644
00645
00646 template <class IT> void Shuffle(IT begin, IT end)
00647 {
00648 for (; begin != end; ++begin)
00649 std::iter_swap(begin, begin + GenerateWord32(0, end-begin-1));
00650 }
00651
00652 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY
00653 byte GetByte() {return GenerateByte();}
00654 unsigned int GetBit() {return GenerateBit();}
00655 word32 GetLong(word32 a=0, word32 b=0xffffffffL) {return GenerateWord32(a, b);}
00656 word16 GetShort(word16 a=0, word16 b=0xffff) {return (word16)GenerateWord32(a, b);}
00657 void GetBlock(byte *output, size_t size) {GenerateBlock(output, size);}
00658 #endif
00659 };
00660
00661
00662 CRYPTOPP_DLL RandomNumberGenerator & CRYPTOPP_API NullRNG();
00663
00664 class WaitObjectContainer;
00665 class CallStack;
00666
00667
00668
00669 class CRYPTOPP_NO_VTABLE Waitable
00670 {
00671 public:
00672
00673 virtual unsigned int GetMaxWaitObjectCount() const =0;
00674
00675
00676
00677
00678
00679 virtual void GetWaitObjects(WaitObjectContainer &container, CallStack const& callStack) =0;
00680
00681
00682 bool Wait(unsigned long milliseconds, CallStack const& callStack);
00683 };
00684
00685
00686
00687
00688
00689
00690
00691
00692
00693
00694
00695
00696
00697
00698
00699
00700
00701
00702
00703
00704
00705
00706
00707
00708
00709
00710
00711 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE BufferedTransformation : public Algorithm, public Waitable
00712 {
00713 public:
00714
00715 static const std::string NULL_CHANNEL;
00716
00717 BufferedTransformation() : Algorithm(false) {}
00718
00719
00720
00721
00722 BufferedTransformation& Ref() {return *this;}
00723
00724
00725
00726
00727 size_t Put(byte inByte, bool blocking=true)
00728 {return Put(&inByte, 1, blocking);}
00729
00730 size_t Put(const byte *inString, size_t length, bool blocking=true)
00731 {return Put2(inString, length, 0, blocking);}
00732
00733
00734 size_t PutWord16(word16 value, ByteOrder order=BIG_ENDIAN_ORDER, bool blocking=true);
00735
00736 size_t PutWord32(word32 value, ByteOrder order=BIG_ENDIAN_ORDER, bool blocking=true);
00737
00738
00739
00740
00741 virtual byte * CreatePutSpace(size_t &size) {size=0; return NULL;}
00742
00743 virtual bool CanModifyInput() const {return false;}
00744
00745
00746 size_t PutModifiable(byte *inString, size_t length, bool blocking=true)
00747 {return PutModifiable2(inString, length, 0, blocking);}
00748
00749 bool MessageEnd(int propagation=-1, bool blocking=true)
00750 {return !!Put2(NULL, 0, propagation < 0 ? -1 : propagation+1, blocking);}
00751 size_t PutMessageEnd(const byte *inString, size_t length, int propagation=-1, bool blocking=true)
00752 {return Put2(inString, length, propagation < 0 ? -1 : propagation+1, blocking);}
00753
00754
00755
00756 virtual size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking) =0;
00757
00758
00759 virtual size_t PutModifiable2(byte *inString, size_t length, int messageEnd, bool blocking)
00760 {return Put2(inString, length, messageEnd, blocking);}
00761
00762
00763 struct BlockingInputOnly : public NotImplemented
00764 {BlockingInputOnly(const std::string &s) : NotImplemented(s + ": Nonblocking input is not implemented by this object.") {}};
00765
00766
00767
00768
00769 unsigned int GetMaxWaitObjectCount() const;
00770 void GetWaitObjects(WaitObjectContainer &container, CallStack const& callStack);
00771
00772
00773
00774
00775 virtual void IsolatedInitialize(const NameValuePairs ¶meters) {throw NotImplemented("BufferedTransformation: this object can't be reinitialized");}
00776 virtual bool IsolatedFlush(bool hardFlush, bool blocking) =0;
00777 virtual bool IsolatedMessageSeriesEnd(bool blocking) {return false;}
00778
00779
00780 virtual void Initialize(const NameValuePairs ¶meters=g_nullNameValuePairs, int propagation=-1);
00781
00782
00783
00784
00785
00786
00787
00788
00789
00790
00791
00792 virtual bool Flush(bool hardFlush, int propagation=-1, bool blocking=true);
00793
00794
00795 virtual bool MessageSeriesEnd(int propagation=-1, bool blocking=true);
00796
00797
00798
00799 virtual void SetAutoSignalPropagation(int propagation) {}
00800
00801
00802 virtual int GetAutoSignalPropagation() const {return 0;}
00803 public:
00804
00805 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY
00806 void Close() {MessageEnd();}
00807 #endif
00808
00809
00810
00811
00812
00813
00814
00815
00816 virtual lword MaxRetrievable() const;
00817
00818
00819 virtual bool AnyRetrievable() const;
00820
00821
00822 virtual size_t Get(byte &outByte);
00823
00824 virtual size_t Get(byte *outString, size_t getMax);
00825
00826
00827 virtual size_t Peek(byte &outByte) const;
00828
00829 virtual size_t Peek(byte *outString, size_t peekMax) const;
00830
00831
00832 size_t GetWord16(word16 &value, ByteOrder order=BIG_ENDIAN_ORDER);
00833
00834 size_t GetWord32(word32 &value, ByteOrder order=BIG_ENDIAN_ORDER);
00835
00836
00837 size_t PeekWord16(word16 &value, ByteOrder order=BIG_ENDIAN_ORDER) const;
00838
00839 size_t PeekWord32(word32 &value, ByteOrder order=BIG_ENDIAN_ORDER) const;
00840
00841
00842 lword TransferTo(BufferedTransformation &target, lword transferMax=LWORD_MAX, const std::string &channel=NULL_CHANNEL)
00843 {TransferTo2(target, transferMax, channel); return transferMax;}
00844
00845
00846 virtual lword Skip(lword skipMax=LWORD_MAX);
00847
00848
00849 lword CopyTo(BufferedTransformation &target, lword copyMax=LWORD_MAX, const std::string &channel=NULL_CHANNEL) const
00850 {return CopyRangeTo(target, 0, copyMax, channel);}
00851
00852
00853 lword CopyRangeTo(BufferedTransformation &target, lword position, lword copyMax=LWORD_MAX, const std::string &channel=NULL_CHANNEL) const
00854 {lword i = position; CopyRangeTo2(target, i, i+copyMax, channel); return i-position;}
00855
00856 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY
00857 unsigned long MaxRetrieveable() const {return MaxRetrievable();}
00858 #endif
00859
00860
00861
00862
00863
00864 virtual lword TotalBytesRetrievable() const;
00865
00866 virtual unsigned int NumberOfMessages() const;
00867
00868 virtual bool AnyMessages() const;
00869
00870
00871
00872
00873
00874 virtual bool GetNextMessage();
00875
00876 virtual unsigned int SkipMessages(unsigned int count=UINT_MAX);
00877
00878 unsigned int TransferMessagesTo(BufferedTransformation &target, unsigned int count=UINT_MAX, const std::string &channel=NULL_CHANNEL)
00879 {TransferMessagesTo2(target, count, channel); return count;}
00880
00881 unsigned int CopyMessagesTo(BufferedTransformation &target, unsigned int count=UINT_MAX, const std::string &channel=NULL_CHANNEL) const;
00882
00883
00884 virtual void SkipAll();
00885
00886 void TransferAllTo(BufferedTransformation &target, const std::string &channel=NULL_CHANNEL)
00887 {TransferAllTo2(target, channel);}
00888
00889 void CopyAllTo(BufferedTransformation &target, const std::string &channel=NULL_CHANNEL) const;
00890
00891 virtual bool GetNextMessageSeries() {return false;}
00892 virtual unsigned int NumberOfMessagesInThisSeries() const {return NumberOfMessages();}
00893 virtual unsigned int NumberOfMessageSeries() const {return 0;}
00894
00895
00896
00897
00898
00899 virtual size_t TransferTo2(BufferedTransformation &target, lword &byteCount, const std::string &channel=NULL_CHANNEL, bool blocking=true) =0;
00900
00901 virtual size_t CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end=LWORD_MAX, const std::string &channel=NULL_CHANNEL, bool blocking=true) const =0;
00902
00903 size_t TransferMessagesTo2(BufferedTransformation &target, unsigned int &messageCount, const std::string &channel=NULL_CHANNEL, bool blocking=true);
00904
00905 size_t TransferAllTo2(BufferedTransformation &target, const std::string &channel=NULL_CHANNEL, bool blocking=true);
00906
00907
00908
00909
00910 struct NoChannelSupport : public NotImplemented
00911 {NoChannelSupport() : NotImplemented("BufferedTransformation: this object doesn't support multiple channels") {}};
00912
00913 size_t ChannelPut(const std::string &channel, byte inByte, bool blocking=true)
00914 {return ChannelPut(channel, &inByte, 1, blocking);}
00915 size_t ChannelPut(const std::string &channel, const byte *inString, size_t length, bool blocking=true)
00916 {return ChannelPut2(channel, inString, length, 0, blocking);}
00917
00918 size_t ChannelPutModifiable(const std::string &channel, byte *inString, size_t length, bool blocking=true)
00919 {return ChannelPutModifiable2(channel, inString, length, 0, blocking);}
00920
00921 size_t ChannelPutWord16(const std::string &channel, word16 value, ByteOrder order=BIG_ENDIAN_ORDER, bool blocking=true);
00922 size_t ChannelPutWord32(const std::string &channel, word32 value, ByteOrder order=BIG_ENDIAN_ORDER, bool blocking=true);
00923
00924 bool ChannelMessageEnd(const std::string &channel, int propagation=-1, bool blocking=true)
00925 {return !!ChannelPut2(channel, NULL, 0, propagation < 0 ? -1 : propagation+1, blocking);}
00926 size_t ChannelPutMessageEnd(const std::string &channel, const byte *inString, size_t length, int propagation=-1, bool blocking=true)
00927 {return ChannelPut2(channel, inString, length, propagation < 0 ? -1 : propagation+1, blocking);}
00928
00929 virtual byte * ChannelCreatePutSpace(const std::string &channel, size_t &size);
00930
00931 virtual size_t ChannelPut2(const std::string &channel, const byte *begin, size_t length, int messageEnd, bool blocking);
00932 virtual size_t ChannelPutModifiable2(const std::string &channel, byte *begin, size_t length, int messageEnd, bool blocking);
00933
00934 virtual bool ChannelFlush(const std::string &channel, bool hardFlush, int propagation=-1, bool blocking=true);
00935 virtual bool ChannelMessageSeriesEnd(const std::string &channel, int propagation=-1, bool blocking=true);
00936
00937 virtual void SetRetrievalChannel(const std::string &channel);
00938
00939
00940
00941
00942
00943
00944
00945
00946
00947
00948
00949 virtual bool Attachable() {return false;}
00950
00951 virtual BufferedTransformation *AttachedTransformation() {assert(!Attachable()); return 0;}
00952
00953 virtual const BufferedTransformation *AttachedTransformation() const
00954 {return const_cast<BufferedTransformation *>(this)->AttachedTransformation();}
00955
00956 virtual void Detach(BufferedTransformation *newAttachment = 0)
00957 {assert(!Attachable()); throw NotImplemented("BufferedTransformation: this object is not attachable");}
00958
00959 virtual void Attach(BufferedTransformation *newAttachment);
00960
00961
00962 protected:
00963 static int DecrementPropagation(int propagation)
00964 {return propagation != 0 ? propagation - 1 : 0;}
00965
00966 private:
00967 byte m_buf[4];
00968 };
00969
00970
00971 BufferedTransformation & TheBitBucket();
00972
00973
00974
00975 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CryptoMaterial : public NameValuePairs
00976 {
00977 public:
00978
00979 class CRYPTOPP_DLL InvalidMaterial : public InvalidDataFormat
00980 {
00981 public:
00982 explicit InvalidMaterial(const std::string &s) : InvalidDataFormat(s) {}
00983 };
00984
00985
00986
00987 virtual void AssignFrom(const NameValuePairs &source) =0;
00988
00989
00990
00991
00992
00993
00994
00995
00996 virtual bool Validate(RandomNumberGenerator &rng, unsigned int level) const =0;
00997
00998
00999 virtual void ThrowIfInvalid(RandomNumberGenerator &rng, unsigned int level) const
01000 {if (!Validate(rng, level)) throw InvalidMaterial("CryptoMaterial: this object contains invalid values");}
01001
01002
01003
01004
01005 virtual void Save(BufferedTransformation &bt) const
01006 {throw NotImplemented("CryptoMaterial: this object does not support saving");}
01007
01008
01009
01010
01011
01012 virtual void Load(BufferedTransformation &bt)
01013 {throw NotImplemented("CryptoMaterial: this object does not support loading");}
01014
01015
01016 virtual bool SupportsPrecomputation() const {return false;}
01017
01018
01019
01020
01021 virtual void Precompute(unsigned int n)
01022 {assert(!SupportsPrecomputation()); throw NotImplemented("CryptoMaterial: this object does not support precomputation");}
01023
01024 virtual void LoadPrecomputation(BufferedTransformation &storedPrecomputation)
01025 {assert(!SupportsPrecomputation()); throw NotImplemented("CryptoMaterial: this object does not support precomputation");}
01026
01027 virtual void SavePrecomputation(BufferedTransformation &storedPrecomputation) const
01028 {assert(!SupportsPrecomputation()); throw NotImplemented("CryptoMaterial: this object does not support precomputation");}
01029
01030
01031 void DoQuickSanityCheck() const {ThrowIfInvalid(NullRNG(), 0);}
01032 };
01033
01034
01035
01036 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE GeneratableCryptoMaterial : virtual public CryptoMaterial
01037 {
01038 public:
01039
01040
01041
01042 virtual void GenerateRandom(RandomNumberGenerator &rng, const NameValuePairs ¶ms = g_nullNameValuePairs)
01043 {throw NotImplemented("GeneratableCryptoMaterial: this object does not support key/parameter generation");}
01044
01045
01046 void GenerateRandomWithKeySize(RandomNumberGenerator &rng, unsigned int keySize);
01047 };
01048
01049
01050
01051 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PublicKey : virtual public CryptoMaterial
01052 {
01053 };
01054
01055
01056
01057 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PrivateKey : public GeneratableCryptoMaterial
01058 {
01059 };
01060
01061
01062
01063 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CryptoParameters : public GeneratableCryptoMaterial
01064 {
01065 };
01066
01067
01068
01069 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE AsymmetricAlgorithm : public Algorithm
01070 {
01071 public:
01072
01073 virtual CryptoMaterial & AccessMaterial() =0;
01074
01075 virtual const CryptoMaterial & GetMaterial() const =0;
01076
01077
01078 void BERDecode(BufferedTransformation &bt)
01079 {AccessMaterial().Load(bt);}
01080
01081 void DEREncode(BufferedTransformation &bt) const
01082 {GetMaterial().Save(bt);}
01083 };
01084
01085
01086
01087 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PublicKeyAlgorithm : public AsymmetricAlgorithm
01088 {
01089 public:
01090
01091 CryptoMaterial & AccessMaterial() {return AccessPublicKey();}
01092 const CryptoMaterial & GetMaterial() const {return GetPublicKey();}
01093
01094 virtual PublicKey & AccessPublicKey() =0;
01095 virtual const PublicKey & GetPublicKey() const {return const_cast<PublicKeyAlgorithm *>(this)->AccessPublicKey();}
01096 };
01097
01098
01099
01100 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PrivateKeyAlgorithm : public AsymmetricAlgorithm
01101 {
01102 public:
01103 CryptoMaterial & AccessMaterial() {return AccessPrivateKey();}
01104 const CryptoMaterial & GetMaterial() const {return GetPrivateKey();}
01105
01106 virtual PrivateKey & AccessPrivateKey() =0;
01107 virtual const PrivateKey & GetPrivateKey() const {return const_cast<PrivateKeyAlgorithm *>(this)->AccessPrivateKey();}
01108 };
01109
01110
01111
01112 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE KeyAgreementAlgorithm : public AsymmetricAlgorithm
01113 {
01114 public:
01115 CryptoMaterial & AccessMaterial() {return AccessCryptoParameters();}
01116 const CryptoMaterial & GetMaterial() const {return GetCryptoParameters();}
01117
01118 virtual CryptoParameters & AccessCryptoParameters() =0;
01119 virtual const CryptoParameters & GetCryptoParameters() const {return const_cast<KeyAgreementAlgorithm *>(this)->AccessCryptoParameters();}
01120 };
01121
01122
01123
01124
01125
01126
01127 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_CryptoSystem
01128 {
01129 public:
01130 virtual ~PK_CryptoSystem() {}
01131
01132
01133
01134 virtual size_t MaxPlaintextLength(size_t ciphertextLength) const =0;
01135
01136
01137
01138 virtual size_t CiphertextLength(size_t plaintextLength) const =0;
01139
01140
01141
01142 virtual bool ParameterSupported(const char *name) const =0;
01143
01144
01145
01146
01147 virtual size_t FixedCiphertextLength() const {return 0;}
01148
01149
01150 virtual size_t FixedMaxPlaintextLength() const {return 0;}
01151
01152 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY
01153 size_t MaxPlainTextLength(size_t cipherTextLength) const {return MaxPlaintextLength(cipherTextLength);}
01154 size_t CipherTextLength(size_t plainTextLength) const {return CiphertextLength(plainTextLength);}
01155 #endif
01156 };
01157
01158
01159 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_Encryptor : public PK_CryptoSystem, public PublicKeyAlgorithm
01160 {
01161 public:
01162
01163 class CRYPTOPP_DLL InvalidPlaintextLength : public Exception
01164 {
01165 public:
01166 InvalidPlaintextLength() : Exception(OTHER_ERROR, "PK_Encryptor: invalid plaintext length") {}
01167 };
01168
01169
01170
01171
01172
01173 virtual void Encrypt(RandomNumberGenerator &rng,
01174 const byte *plaintext, size_t plaintextLength,
01175 byte *ciphertext, const NameValuePairs ¶meters = g_nullNameValuePairs) const =0;
01176
01177
01178
01179
01180
01181 virtual BufferedTransformation * CreateEncryptionFilter(RandomNumberGenerator &rng,
01182 BufferedTransformation *attachment=NULL, const NameValuePairs ¶meters = g_nullNameValuePairs) const;
01183 };
01184
01185
01186
01187 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_Decryptor : public PK_CryptoSystem, public PrivateKeyAlgorithm
01188 {
01189 public:
01190
01191
01192
01193
01194 virtual DecodingResult Decrypt(RandomNumberGenerator &rng,
01195 const byte *ciphertext, size_t ciphertextLength,
01196 byte *plaintext, const NameValuePairs ¶meters = g_nullNameValuePairs) const =0;
01197
01198
01199
01200
01201 virtual BufferedTransformation * CreateDecryptionFilter(RandomNumberGenerator &rng,
01202 BufferedTransformation *attachment=NULL, const NameValuePairs ¶meters = g_nullNameValuePairs) const;
01203
01204
01205 DecodingResult FixedLengthDecrypt(RandomNumberGenerator &rng, const byte *ciphertext, byte *plaintext, const NameValuePairs ¶meters = g_nullNameValuePairs) const
01206 {return Decrypt(rng, ciphertext, FixedCiphertextLength(), plaintext, parameters);}
01207 };
01208
01209 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY
01210 typedef PK_CryptoSystem PK_FixedLengthCryptoSystem;
01211 typedef PK_Encryptor PK_FixedLengthEncryptor;
01212 typedef PK_Decryptor PK_FixedLengthDecryptor;
01213 #endif
01214
01215
01216
01217
01218
01219
01220 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_SignatureScheme
01221 {
01222 public:
01223
01224 class CRYPTOPP_DLL InvalidKeyLength : public Exception
01225 {
01226 public:
01227 InvalidKeyLength(const std::string &message) : Exception(OTHER_ERROR, message) {}
01228 };
01229
01230
01231 class CRYPTOPP_DLL KeyTooShort : public InvalidKeyLength
01232 {
01233 public:
01234 KeyTooShort() : InvalidKeyLength("PK_Signer: key too short for this signature scheme") {}
01235 };
01236
01237 virtual ~PK_SignatureScheme() {}
01238
01239
01240 virtual size_t SignatureLength() const =0;
01241
01242
01243 virtual size_t MaxSignatureLength(size_t recoverablePartLength = 0) const {return SignatureLength();}
01244
01245
01246 virtual size_t MaxRecoverableLength() const =0;
01247
01248
01249 virtual size_t MaxRecoverableLengthFromSignatureLength(size_t signatureLength) const =0;
01250
01251
01252
01253 virtual bool IsProbabilistic() const =0;
01254
01255
01256 virtual bool AllowNonrecoverablePart() const =0;
01257
01258
01259 virtual bool SignatureUpfront() const {return false;}
01260
01261
01262 virtual bool RecoverablePartFirst() const =0;
01263 };
01264
01265
01266
01267
01268
01269 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_MessageAccumulator : public HashTransformation
01270 {
01271 public:
01272
01273 unsigned int DigestSize() const
01274 {throw NotImplemented("PK_MessageAccumulator: DigestSize() should not be called");}
01275
01276 void TruncatedFinal(byte *digest, size_t digestSize)
01277 {throw NotImplemented("PK_MessageAccumulator: TruncatedFinal() should not be called");}
01278 };
01279
01280
01281
01282 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_Signer : public PK_SignatureScheme, public PrivateKeyAlgorithm
01283 {
01284 public:
01285
01286 virtual PK_MessageAccumulator * NewSignatureAccumulator(RandomNumberGenerator &rng) const =0;
01287
01288 virtual void InputRecoverableMessage(PK_MessageAccumulator &messageAccumulator, const byte *recoverableMessage, size_t recoverableMessageLength) const =0;
01289
01290
01291
01292
01293
01294 virtual size_t Sign(RandomNumberGenerator &rng, PK_MessageAccumulator *messageAccumulator, byte *signature) const;
01295
01296
01297
01298
01299
01300 virtual size_t SignAndRestart(RandomNumberGenerator &rng, PK_MessageAccumulator &messageAccumulator, byte *signature, bool restart=true) const =0;
01301
01302
01303
01304
01305
01306 virtual size_t SignMessage(RandomNumberGenerator &rng, const byte *message, size_t messageLen, byte *signature) const;
01307
01308
01309
01310
01311
01312 virtual size_t SignMessageWithRecovery(RandomNumberGenerator &rng, const byte *recoverableMessage, size_t recoverableMessageLength,
01313 const byte *nonrecoverableMessage, size_t nonrecoverableMessageLength, byte *signature) const;
01314 };
01315
01316
01317
01318
01319
01320
01321
01322
01323 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_Verifier : public PK_SignatureScheme, public PublicKeyAlgorithm
01324 {
01325 public:
01326
01327 virtual PK_MessageAccumulator * NewVerificationAccumulator() const =0;
01328
01329
01330 virtual void InputSignature(PK_MessageAccumulator &messageAccumulator, const byte *signature, size_t signatureLength) const =0;
01331
01332
01333 virtual bool Verify(PK_MessageAccumulator *messageAccumulator) const;
01334
01335
01336 virtual bool VerifyAndRestart(PK_MessageAccumulator &messageAccumulator) const =0;
01337
01338
01339 virtual bool VerifyMessage(const byte *message, size_t messageLen,
01340 const byte *signature, size_t signatureLength) const;
01341
01342
01343
01344
01345 virtual DecodingResult Recover(byte *recoveredMessage, PK_MessageAccumulator *messageAccumulator) const;
01346
01347
01348
01349
01350 virtual DecodingResult RecoverAndRestart(byte *recoveredMessage, PK_MessageAccumulator &messageAccumulator) const =0;
01351
01352
01353
01354
01355 virtual DecodingResult RecoverMessage(byte *recoveredMessage,
01356 const byte *nonrecoverableMessage, size_t nonrecoverableMessageLength,
01357 const byte *signature, size_t signatureLength) const;
01358 };
01359
01360
01361
01362
01363
01364
01365
01366 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE SimpleKeyAgreementDomain : public KeyAgreementAlgorithm
01367 {
01368 public:
01369
01370 virtual unsigned int AgreedValueLength() const =0;
01371
01372 virtual unsigned int PrivateKeyLength() const =0;
01373
01374 virtual unsigned int PublicKeyLength() const =0;
01375
01376
01377 virtual void GeneratePrivateKey(RandomNumberGenerator &rng, byte *privateKey) const =0;
01378
01379
01380 virtual void GeneratePublicKey(RandomNumberGenerator &rng, const byte *privateKey, byte *publicKey) const =0;
01381
01382
01383 virtual void GenerateKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const;
01384
01385
01386
01387
01388
01389
01390 virtual bool Agree(byte *agreedValue, const byte *privateKey, const byte *otherPublicKey, bool validateOtherPublicKey=true) const =0;
01391
01392 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY
01393 bool ValidateDomainParameters(RandomNumberGenerator &rng) const
01394 {return GetCryptoParameters().Validate(rng, 2);}
01395 #endif
01396 };
01397
01398
01399
01400
01401
01402
01403
01404 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE AuthenticatedKeyAgreementDomain : public KeyAgreementAlgorithm
01405 {
01406 public:
01407
01408 virtual unsigned int AgreedValueLength() const =0;
01409
01410
01411 virtual unsigned int StaticPrivateKeyLength() const =0;
01412
01413 virtual unsigned int StaticPublicKeyLength() const =0;
01414
01415
01416 virtual void GenerateStaticPrivateKey(RandomNumberGenerator &rng, byte *privateKey) const =0;
01417
01418
01419 virtual void GenerateStaticPublicKey(RandomNumberGenerator &rng, const byte *privateKey, byte *publicKey) const =0;
01420
01421
01422 virtual void GenerateStaticKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const;
01423
01424
01425 virtual unsigned int EphemeralPrivateKeyLength() const =0;
01426
01427 virtual unsigned int EphemeralPublicKeyLength() const =0;
01428
01429
01430 virtual void GenerateEphemeralPrivateKey(RandomNumberGenerator &rng, byte *privateKey) const =0;
01431
01432
01433 virtual void GenerateEphemeralPublicKey(RandomNumberGenerator &rng, const byte *privateKey, byte *publicKey) const =0;
01434
01435
01436 virtual void GenerateEphemeralKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const;
01437
01438
01439
01440
01441
01442
01443
01444
01445
01446
01447 virtual bool Agree(byte *agreedValue,
01448 const byte *staticPrivateKey, const byte *ephemeralPrivateKey,
01449 const byte *staticOtherPublicKey, const byte *ephemeralOtherPublicKey,
01450 bool validateStaticOtherPublicKey=true) const =0;
01451
01452 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY
01453 bool ValidateDomainParameters(RandomNumberGenerator &rng) const
01454 {return GetCryptoParameters().Validate(rng, 2);}
01455 #endif
01456 };
01457
01458
01459 #if 0
01460
01461
01462
01463
01464
01465
01466
01467
01468
01469
01470
01471
01472
01473
01474
01475
01476
01477
01478
01479
01480
01481 class ProtocolSession
01482 {
01483 public:
01484
01485 class ProtocolError : public Exception
01486 {
01487 public:
01488 ProtocolError(ErrorType errorType, const std::string &s) : Exception(errorType, s) {}
01489 };
01490
01491
01492
01493 class UnexpectedMethodCall : public Exception
01494 {
01495 public:
01496 UnexpectedMethodCall(const std::string &s) : Exception(OTHER_ERROR, s) {}
01497 };
01498
01499 ProtocolSession() : m_rng(NULL), m_throwOnProtocolError(true), m_validState(false) {}
01500 virtual ~ProtocolSession() {}
01501
01502 virtual void InitializeSession(RandomNumberGenerator &rng, const NameValuePairs ¶meters) =0;
01503
01504 bool GetThrowOnProtocolError() const {return m_throwOnProtocolError;}
01505 void SetThrowOnProtocolError(bool throwOnProtocolError) {m_throwOnProtocolError = throwOnProtocolError;}
01506
01507 bool HasValidState() const {return m_validState;}
01508
01509 virtual bool OutgoingMessageAvailable() const =0;
01510 virtual unsigned int GetOutgoingMessageLength() const =0;
01511 virtual void GetOutgoingMessage(byte *message) =0;
01512
01513 virtual bool LastMessageProcessed() const =0;
01514 virtual void ProcessIncomingMessage(const byte *message, unsigned int messageLength) =0;
01515
01516 protected:
01517 void HandleProtocolError(Exception::ErrorType errorType, const std::string &s) const;
01518 void CheckAndHandleInvalidState() const;
01519 void SetValidState(bool valid) {m_validState = valid;}
01520
01521 RandomNumberGenerator *m_rng;
01522
01523 private:
01524 bool m_throwOnProtocolError, m_validState;
01525 };
01526
01527 class KeyAgreementSession : public ProtocolSession
01528 {
01529 public:
01530 virtual unsigned int GetAgreedValueLength() const =0;
01531 virtual void GetAgreedValue(byte *agreedValue) const =0;
01532 };
01533
01534 class PasswordAuthenticatedKeyAgreementSession : public KeyAgreementSession
01535 {
01536 public:
01537 void InitializePasswordAuthenticatedKeyAgreementSession(RandomNumberGenerator &rng,
01538 const byte *myId, unsigned int myIdLength,
01539 const byte *counterPartyId, unsigned int counterPartyIdLength,
01540 const byte *passwordOrVerifier, unsigned int passwordOrVerifierLength);
01541 };
01542
01543 class PasswordAuthenticatedKeyAgreementDomain : public KeyAgreementAlgorithm
01544 {
01545 public:
01546
01547 virtual bool ValidateDomainParameters(RandomNumberGenerator &rng) const
01548 {return GetCryptoParameters().Validate(rng, 2);}
01549
01550 virtual unsigned int GetPasswordVerifierLength(const byte *password, unsigned int passwordLength) const =0;
01551 virtual void GeneratePasswordVerifier(RandomNumberGenerator &rng, const byte *userId, unsigned int userIdLength, const byte *password, unsigned int passwordLength, byte *verifier) const =0;
01552
01553 enum RoleFlags {CLIENT=1, SERVER=2, INITIATOR=4, RESPONDER=8};
01554
01555 virtual bool IsValidRole(unsigned int role) =0;
01556 virtual PasswordAuthenticatedKeyAgreementSession * CreateProtocolSession(unsigned int role) const =0;
01557 };
01558 #endif
01559
01560
01561 class CRYPTOPP_DLL BERDecodeErr : public InvalidArgument
01562 {
01563 public:
01564 BERDecodeErr() : InvalidArgument("BER decode error") {}
01565 BERDecodeErr(const std::string &s) : InvalidArgument(s) {}
01566 };
01567
01568
01569 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE ASN1Object
01570 {
01571 public:
01572 virtual ~ASN1Object() {}
01573
01574 virtual void BERDecode(BufferedTransformation &bt) =0;
01575
01576 virtual void DEREncode(BufferedTransformation &bt) const =0;
01577
01578
01579 virtual void BEREncode(BufferedTransformation &bt) const {DEREncode(bt);}
01580 };
01581
01582 #ifdef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY
01583 typedef PK_SignatureScheme PK_SignatureSystem;
01584 typedef SimpleKeyAgreementDomain PK_SimpleKeyAgreementDomain;
01585 typedef AuthenticatedKeyAgreementDomain PK_AuthenticatedKeyAgreementDomain;
01586 #endif
01587
01588 NAMESPACE_END
01589
01590 #endif