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