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