~zooko/cryptopp/trunk

« back to all changes in this revision

Viewing changes to pubkey.h

  • Committer: weidai
  • Date: 2003-07-29 01:18:33 UTC
  • Revision ID: svn-v4:57ff6487-cd31-0410-9ec3-f628ee90f5f0:trunk/c5:118
fix potential threading problem with initialization of static objects

Show diffs side-by-side

added added

removed removed

Lines of Context:
32
32
        The "DL_" prefix means an implementation using group operations (in groups where discrete log is hard).
33
33
*/
34
34
 
35
 
#include "modarith.h"
 
35
#include "integer.h"
36
36
#include "filters.h"
37
37
#include "eprecomp.h"
38
38
#include "fips140.h"
44
44
 
45
45
NAMESPACE_BEGIN(CryptoPP)
46
46
 
47
 
//! _
 
47
//! .
48
48
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TrapdoorFunctionBounds
49
49
{
50
50
public:
56
56
        virtual Integer MaxImage() const {return --ImageBound();}
57
57
};
58
58
 
59
 
//! _
 
59
//! .
60
60
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE RandomizedTrapdoorFunction : public TrapdoorFunctionBounds
61
61
{
62
62
public:
64
64
        virtual bool IsRandomized() const {return true;}
65
65
};
66
66
 
67
 
//! _
 
67
//! .
68
68
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TrapdoorFunction : public RandomizedTrapdoorFunction
69
69
{
70
70
public:
75
75
        virtual Integer ApplyFunction(const Integer &x) const =0;
76
76
};
77
77
 
78
 
//! _
 
78
//! .
79
79
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE RandomizedTrapdoorFunctionInverse
80
80
{
81
81
public:
85
85
        virtual bool IsRandomized() const {return true;}
86
86
};
87
87
 
88
 
//! _
 
88
//! .
89
89
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TrapdoorFunctionInverse : public RandomizedTrapdoorFunctionInverse
90
90
{
91
91
public:
109
109
        virtual bool ParameterSupported(const char *name) const {return false;}
110
110
 
111
111
        //! max size of unpadded message in bytes, given max size of padded message in bits (1 less than size of modulus)
112
 
        virtual size_t MaxUnpaddedLength(size_t paddedLength) const =0;
113
 
 
114
 
        virtual void Pad(RandomNumberGenerator &rng, const byte *raw, size_t inputLength, byte *padded, size_t paddedBitLength, const NameValuePairs &parameters) const =0;
115
 
 
116
 
        virtual DecodingResult Unpad(const byte *padded, size_t paddedBitLength, byte *raw, const NameValuePairs &parameters) const =0;
 
112
        virtual unsigned int MaxUnpaddedLength(unsigned int paddedLength) const =0;
 
113
 
 
114
        virtual void Pad(RandomNumberGenerator &rng, const byte *raw, unsigned int inputLength, byte *padded, unsigned int paddedBitLength, const NameValuePairs &parameters) const =0;
 
115
 
 
116
        virtual DecodingResult Unpad(const byte *padded, unsigned int paddedBitLength, byte *raw, const NameValuePairs &parameters) const =0;
117
117
};
118
118
 
119
119
// ********************************************************
120
120
 
121
 
//! _
 
121
//! .
122
122
template <class TFI, class MEI>
123
123
class CRYPTOPP_NO_VTABLE TF_Base
124
124
{
134
134
 
135
135
// ********************************************************
136
136
 
137
 
//! _
138
137
template <class BASE>
139
138
class CRYPTOPP_NO_VTABLE PK_FixedLengthCryptoSystemImpl : public BASE
140
139
{
141
140
public:
142
 
        size_t MaxPlaintextLength(size_t ciphertextLength) const
 
141
        unsigned int MaxPlaintextLength(unsigned int ciphertextLength) const
143
142
                {return ciphertextLength == FixedCiphertextLength() ? FixedMaxPlaintextLength() : 0;}
144
 
        size_t CiphertextLength(size_t plaintextLength) const
 
143
        unsigned int CiphertextLength(unsigned int plaintextLength) const
145
144
                {return plaintextLength <= FixedMaxPlaintextLength() ? FixedCiphertextLength() : 0;}
146
145
 
147
 
        virtual size_t FixedMaxPlaintextLength() const =0;
148
 
        virtual size_t FixedCiphertextLength() const =0;
 
146
        virtual unsigned int FixedMaxPlaintextLength() const =0;
 
147
        virtual unsigned int FixedCiphertextLength() const =0;
149
148
};
150
149
 
151
 
//! _
 
150
//! .
152
151
template <class INTERFACE, class BASE>
153
152
class CRYPTOPP_NO_VTABLE TF_CryptoSystemBase : public PK_FixedLengthCryptoSystemImpl<INTERFACE>, protected BASE
154
153
{
155
154
public:
156
 
        bool ParameterSupported(const char *name) const {return this->GetMessageEncodingInterface().ParameterSupported(name);}
157
 
        size_t FixedMaxPlaintextLength() const {return this->GetMessageEncodingInterface().MaxUnpaddedLength(PaddedBlockBitLength());}
158
 
        size_t FixedCiphertextLength() const {return this->GetTrapdoorFunctionBounds().MaxImage().ByteCount();}
 
155
        bool ParameterSupported(const char *name) const {return GetMessageEncodingInterface().ParameterSupported(name);}
 
156
        unsigned int FixedMaxPlaintextLength() const {return GetMessageEncodingInterface().MaxUnpaddedLength(PaddedBlockBitLength());}
 
157
        unsigned int FixedCiphertextLength() const {return GetTrapdoorFunctionBounds().MaxImage().ByteCount();}
159
158
 
160
159
protected:
161
 
        size_t PaddedBlockByteLength() const {return BitsToBytes(PaddedBlockBitLength());}
162
 
        size_t PaddedBlockBitLength() const {return this->GetTrapdoorFunctionBounds().PreimageBound().BitCount()-1;}
 
160
        unsigned int PaddedBlockByteLength() const {return BitsToBytes(PaddedBlockBitLength());}
 
161
        unsigned int PaddedBlockBitLength() const {return GetTrapdoorFunctionBounds().PreimageBound().BitCount()-1;}
163
162
};
164
163
 
165
 
//! _
 
164
//! .
166
165
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TF_DecryptorBase : public TF_CryptoSystemBase<PK_Decryptor, TF_Base<TrapdoorFunctionInverse, PK_EncryptionMessageEncodingMethod> >
167
166
{
168
167
public:
169
 
        DecodingResult Decrypt(RandomNumberGenerator &rng, const byte *ciphertext, size_t ciphertextLength, byte *plaintext, const NameValuePairs &parameters = g_nullNameValuePairs) const;
 
168
        DecodingResult Decrypt(RandomNumberGenerator &rng, const byte *ciphertext, unsigned int ciphertextLength, byte *plaintext, const NameValuePairs &parameters = g_nullNameValuePairs) const;
170
169
};
171
170
 
172
 
//! _
 
171
//! .
173
172
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TF_EncryptorBase : public TF_CryptoSystemBase<PK_Encryptor, TF_Base<RandomizedTrapdoorFunction, PK_EncryptionMessageEncodingMethod> >
174
173
{
175
174
public:
176
 
        void Encrypt(RandomNumberGenerator &rng, const byte *plaintext, size_t plaintextLength, byte *ciphertext, const NameValuePairs &parameters = g_nullNameValuePairs) const;
 
175
        void Encrypt(RandomNumberGenerator &rng, const byte *plaintext, unsigned int plaintextLength, byte *ciphertext, const NameValuePairs &parameters = g_nullNameValuePairs) const;
177
176
};
178
177
 
179
178
// ********************************************************
180
179
 
181
 
typedef std::pair<const byte *, size_t> HashIdentifier;
 
180
typedef std::pair<const byte *, unsigned int> HashIdentifier;
182
181
 
183
 
//! interface for message encoding method for public key signature schemes
 
182
//! .
184
183
class CRYPTOPP_NO_VTABLE PK_SignatureMessageEncodingMethod
185
184
{
186
185
public:
187
186
        virtual ~PK_SignatureMessageEncodingMethod() {}
188
187
 
189
 
        virtual size_t MinRepresentativeBitLength(size_t hashIdentifierLength, size_t digestLength) const
190
 
                {return 0;}
191
 
        virtual size_t MaxRecoverableLength(size_t representativeBitLength, size_t hashIdentifierLength, size_t digestLength) const
 
188
        virtual unsigned int MaxRecoverableLength(unsigned int representativeBitLength, unsigned int hashIdentifierLength, unsigned int digestLength) const
192
189
                {return 0;}
193
190
 
194
191
        bool IsProbabilistic() const 
199
196
                {throw NotImplemented("PK_MessageEncodingMethod: this signature scheme does not support message recovery");}
200
197
 
201
198
        // for verification, DL
202
 
        virtual void ProcessSemisignature(HashTransformation &hash, const byte *semisignature, size_t semisignatureLength) const {}
 
199
        virtual void ProcessSemisignature(HashTransformation &hash, const byte *semisignature, unsigned int semisignatureLength) const {}
203
200
 
204
201
        // for signature
205
202
        virtual void ProcessRecoverableMessage(HashTransformation &hash, 
206
 
                const byte *recoverableMessage, size_t recoverableMessageLength, 
207
 
                const byte *presignature, size_t presignatureLength,
 
203
                const byte *recoverableMessage, unsigned int recoverableMessageLength, 
 
204
                const byte *presignature, unsigned int presignatureLength,
208
205
                SecByteBlock &semisignature) const
209
206
        {
210
207
                if (RecoverablePartFirst())
212
209
        }
213
210
 
214
211
        virtual void ComputeMessageRepresentative(RandomNumberGenerator &rng, 
215
 
                const byte *recoverableMessage, size_t recoverableMessageLength,
 
212
                const byte *recoverableMessage, unsigned int recoverableMessageLength,
216
213
                HashTransformation &hash, HashIdentifier hashIdentifier, bool messageEmpty,
217
 
                byte *representative, size_t representativeBitLength) const =0;
 
214
                byte *representative, unsigned int representativeBitLength) const =0;
218
215
 
219
216
        virtual bool VerifyMessageRepresentative(
220
217
                HashTransformation &hash, HashIdentifier hashIdentifier, bool messageEmpty,
221
 
                byte *representative, size_t representativeBitLength) const =0;
 
218
                byte *representative, unsigned int representativeBitLength) const =0;
222
219
 
223
220
        virtual DecodingResult RecoverMessageFromRepresentative(        // for TF
224
221
                HashTransformation &hash, HashIdentifier hashIdentifier, bool messageEmpty,
225
 
                byte *representative, size_t representativeBitLength,
 
222
                byte *representative, unsigned int representativeBitLength,
226
223
                byte *recoveredMessage) const
227
224
                {throw NotImplemented("PK_MessageEncodingMethod: this signature scheme does not support message recovery");}
228
225
 
229
226
        virtual DecodingResult RecoverMessageFromSemisignature(         // for DL
230
227
                HashTransformation &hash, HashIdentifier hashIdentifier,
231
 
                const byte *presignature, size_t presignatureLength,
232
 
                const byte *semisignature, size_t semisignatureLength,
 
228
                const byte *presignature, unsigned int presignatureLength,
 
229
                const byte *semisignature, unsigned int semisignatureLength,
233
230
                byte *recoveredMessage) const
234
231
                {throw NotImplemented("PK_MessageEncodingMethod: this signature scheme does not support message recovery");}
235
232
 
238
235
        {
239
236
                template <class H> struct HashIdentifierLookup2
240
237
                {
241
 
                        static HashIdentifier CRYPTOPP_API Lookup()
 
238
                        static HashIdentifier Lookup()
242
239
                        {
243
240
                                return HashIdentifier(NULL, 0);
244
241
                        }
251
248
public:
252
249
        bool VerifyMessageRepresentative(
253
250
                HashTransformation &hash, HashIdentifier hashIdentifier, bool messageEmpty,
254
 
                byte *representative, size_t representativeBitLength) const;
 
251
                byte *representative, unsigned int representativeBitLength) const;
255
252
};
256
253
 
257
254
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_RecoverableSignatureMessageEncodingMethod : public PK_SignatureMessageEncodingMethod
259
256
public:
260
257
        bool VerifyMessageRepresentative(
261
258
                HashTransformation &hash, HashIdentifier hashIdentifier, bool messageEmpty,
262
 
                byte *representative, size_t representativeBitLength) const;
 
259
                byte *representative, unsigned int representativeBitLength) const;
263
260
};
264
261
 
265
262
class CRYPTOPP_DLL DL_SignatureMessageEncodingMethod_DSA : public PK_DeterministicSignatureMessageEncodingMethod
266
263
{
267
264
public:
268
265
        void ComputeMessageRepresentative(RandomNumberGenerator &rng, 
269
 
                const byte *recoverableMessage, size_t recoverableMessageLength,
 
266
                const byte *recoverableMessage, unsigned int recoverableMessageLength,
270
267
                HashTransformation &hash, HashIdentifier hashIdentifier, bool messageEmpty,
271
 
                byte *representative, size_t representativeBitLength) const;
 
268
                byte *representative, unsigned int representativeBitLength) const;
272
269
};
273
270
 
274
271
class CRYPTOPP_DLL DL_SignatureMessageEncodingMethod_NR : public PK_DeterministicSignatureMessageEncodingMethod
275
272
{
276
273
public:
277
274
        void ComputeMessageRepresentative(RandomNumberGenerator &rng, 
278
 
                const byte *recoverableMessage, size_t recoverableMessageLength,
 
275
                const byte *recoverableMessage, unsigned int recoverableMessageLength,
279
276
                HashTransformation &hash, HashIdentifier hashIdentifier, bool messageEmpty,
280
 
                byte *representative, size_t representativeBitLength) const;
 
277
                byte *representative, unsigned int representativeBitLength) const;
281
278
};
282
279
 
283
280
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_MessageAccumulatorBase : public PK_MessageAccumulator
287
284
 
288
285
        virtual HashTransformation & AccessHash() =0;
289
286
 
290
 
        void Update(const byte *input, size_t length)
 
287
        void Update(const byte *input, unsigned int length)
291
288
        {
292
289
                AccessHash().Update(input, length);
293
290
                m_empty = m_empty && length == 0;
302
299
class PK_MessageAccumulatorImpl : public PK_MessageAccumulatorBase, protected ObjectHolder<HASH_ALGORITHM>
303
300
{
304
301
public:
305
 
        HashTransformation & AccessHash() {return this->m_object;}
 
302
        HashTransformation & AccessHash() {return m_object;}
306
303
};
307
304
 
308
 
//! _
 
305
//! .
309
306
template <class INTERFACE, class BASE>
310
307
class CRYPTOPP_NO_VTABLE TF_SignatureSchemeBase : public INTERFACE, protected BASE
311
308
{
312
309
public:
313
 
        size_t SignatureLength() const 
314
 
                {return this->GetTrapdoorFunctionBounds().MaxPreimage().ByteCount();}
315
 
        size_t MaxRecoverableLength() const 
316
 
                {return this->GetMessageEncodingInterface().MaxRecoverableLength(MessageRepresentativeBitLength(), GetHashIdentifier().second, GetDigestSize());}
317
 
        size_t MaxRecoverableLengthFromSignatureLength(size_t signatureLength) const
318
 
                {return this->MaxRecoverableLength();}
 
310
        unsigned int SignatureLength() const 
 
311
                {return GetTrapdoorFunctionBounds().MaxPreimage().ByteCount();}
 
312
        unsigned int MaxRecoverableLength() const 
 
313
                {return GetMessageEncodingInterface().MaxRecoverableLength(MessageRepresentativeBitLength(), GetHashIdentifier().second, GetDigestSize());}
 
314
        unsigned int MaxRecoverableLengthFromSignatureLength(unsigned int signatureLength) const
 
315
                {return MaxRecoverableLength();}
319
316
 
320
317
        bool IsProbabilistic() const 
321
 
                {return this->GetTrapdoorFunctionInterface().IsRandomized() || this->GetMessageEncodingInterface().IsProbabilistic();}
 
318
                {return GetTrapdoorFunctionInterface().IsRandomized() || GetMessageEncodingInterface().IsProbabilistic();}
322
319
        bool AllowNonrecoverablePart() const 
323
 
                {return this->GetMessageEncodingInterface().AllowNonrecoverablePart();}
 
320
                {return GetMessageEncodingInterface().AllowNonrecoverablePart();}
324
321
        bool RecoverablePartFirst() const 
325
 
                {return this->GetMessageEncodingInterface().RecoverablePartFirst();}
 
322
                {return GetMessageEncodingInterface().RecoverablePartFirst();}
326
323
 
327
324
protected:
328
 
        size_t MessageRepresentativeLength() const {return BitsToBytes(MessageRepresentativeBitLength());}
329
 
        size_t MessageRepresentativeBitLength() const {return this->GetTrapdoorFunctionBounds().ImageBound().BitCount()-1;}
 
325
        unsigned int MessageRepresentativeLength() const {return BitsToBytes(MessageRepresentativeBitLength());}
 
326
        unsigned int MessageRepresentativeBitLength() const {return GetTrapdoorFunctionBounds().ImageBound().BitCount()-1;}
330
327
        virtual HashIdentifier GetHashIdentifier() const =0;
331
 
        virtual size_t GetDigestSize() const =0;
 
328
        virtual unsigned int GetDigestSize() const =0;
332
329
};
333
330
 
334
 
//! _
 
331
//! .
335
332
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TF_SignerBase : public TF_SignatureSchemeBase<PK_Signer, TF_Base<RandomizedTrapdoorFunctionInverse, PK_SignatureMessageEncodingMethod> >
336
333
{
337
334
public:
338
 
        void InputRecoverableMessage(PK_MessageAccumulator &messageAccumulator, const byte *recoverableMessage, size_t recoverableMessageLength) const;
339
 
        size_t SignAndRestart(RandomNumberGenerator &rng, PK_MessageAccumulator &messageAccumulator, byte *signature, bool restart=true) const;
 
335
        void InputRecoverableMessage(PK_MessageAccumulator &messageAccumulator, const byte *recoverableMessage, unsigned int recoverableMessageLength) const;
 
336
        unsigned int SignAndRestart(RandomNumberGenerator &rng, PK_MessageAccumulator &messageAccumulator, byte *signature, bool restart=true) const;
340
337
};
341
338
 
342
 
//! _
 
339
//! .
343
340
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TF_VerifierBase : public TF_SignatureSchemeBase<PK_Verifier, TF_Base<TrapdoorFunction, PK_SignatureMessageEncodingMethod> >
344
341
{
345
342
public:
346
 
        void InputSignature(PK_MessageAccumulator &messageAccumulator, const byte *signature, size_t signatureLength) const;
 
343
        void InputSignature(PK_MessageAccumulator &messageAccumulator, const byte *signature, unsigned int signatureLength) const;
347
344
        bool VerifyAndRestart(PK_MessageAccumulator &messageAccumulator) const;
348
345
        DecodingResult RecoverAndRestart(byte *recoveredMessage, PK_MessageAccumulator &recoveryAccumulator) const;
349
346
};
350
347
 
351
348
// ********************************************************
352
349
 
353
 
//! _
 
350
//! .
354
351
template <class T1, class T2, class T3>
355
352
struct TF_CryptoSchemeOptions
356
353
{
361
358
        typedef T3 MessageEncodingMethod;
362
359
};
363
360
 
364
 
//! _
 
361
//! .
365
362
template <class T1, class T2, class T3, class T4>
366
363
struct TF_SignatureSchemeOptions : public TF_CryptoSchemeOptions<T1, T2, T3>
367
364
{
368
365
        typedef T4 HashFunction;
369
366
};
370
367
 
371
 
//! _
372
 
template <class BASE, class SCHEME_OPTIONS, class KEY_CLASS>
 
368
//! .
 
369
template <class KEYS>
 
370
class CRYPTOPP_NO_VTABLE PublicKeyCopier
 
371
{
 
372
public:
 
373
        typedef typename KEYS::PublicKey KeyClass;
 
374
        virtual void CopyKeyInto(typename KEYS::PublicKey &key) const =0;
 
375
};
 
376
 
 
377
//! .
 
378
template <class KEYS>
 
379
class CRYPTOPP_NO_VTABLE PrivateKeyCopier
 
380
{
 
381
public:
 
382
        typedef typename KEYS::PrivateKey KeyClass;
 
383
        virtual void CopyKeyInto(typename KEYS::PublicKey &key) const =0;
 
384
        virtual void CopyKeyInto(typename KEYS::PrivateKey &key) const =0;
 
385
};
 
386
 
 
387
//! .
 
388
template <class BASE, class SCHEME_OPTIONS, class KEY>
373
389
class CRYPTOPP_NO_VTABLE TF_ObjectImplBase : public AlgorithmImpl<BASE, typename SCHEME_OPTIONS::AlgorithmInfo>
374
390
{
375
391
public:
376
392
        typedef SCHEME_OPTIONS SchemeOptions;
377
 
        typedef KEY_CLASS KeyClass;
 
393
        typedef KEY KeyClass;
378
394
 
379
395
        PublicKey & AccessPublicKey() {return AccessKey();}
380
396
        const PublicKey & GetPublicKey() const {return GetKey();}
407
423
        // for signature scheme
408
424
        HashIdentifier GetHashIdentifier() const
409
425
        {
410
 
        typedef CPP_TYPENAME SchemeOptions::MessageEncodingMethod::HashIdentifierLookup::template HashIdentifierLookup2<CPP_TYPENAME SchemeOptions::HashFunction> L;
411
 
        return L::Lookup();
 
426
                typedef CPP_TYPENAME SchemeOptions::MessageEncodingMethod::HashIdentifierLookup::HashIdentifierLookup2<CPP_TYPENAME SchemeOptions::HashFunction> L;
 
427
                return L::Lookup();
412
428
        }
413
 
        size_t GetDigestSize() const
 
429
        unsigned int GetDigestSize() const
414
430
        {
415
431
                typedef CPP_TYPENAME SchemeOptions::HashFunction H;
416
432
                return H::DIGESTSIZE;
417
433
        }
418
434
};
419
435
 
420
 
//! _
 
436
//! .
421
437
template <class BASE, class SCHEME_OPTIONS, class KEY>
422
438
class TF_ObjectImplExtRef : public TF_ObjectImplBase<BASE, SCHEME_OPTIONS, KEY>
423
439
{
432
448
        const KEY * m_pKey;
433
449
};
434
450
 
435
 
//! _
436
 
template <class BASE, class SCHEME_OPTIONS, class KEY_CLASS>
437
 
class CRYPTOPP_NO_VTABLE TF_ObjectImpl : public TF_ObjectImplBase<BASE, SCHEME_OPTIONS, KEY_CLASS>
 
451
//! .
 
452
template <class BASE, class SCHEME_OPTIONS, class KEY_COPIER>
 
453
class CRYPTOPP_NO_VTABLE TF_ObjectImpl : public TF_ObjectImplBase<TwoBases<BASE, KEY_COPIER>, SCHEME_OPTIONS, typename KEY_COPIER::KeyClass>
438
454
{
439
455
public:
440
 
        typedef KEY_CLASS KeyClass;
 
456
        typedef typename KEY_COPIER::KeyClass KeyClass;
441
457
 
442
458
        const KeyClass & GetKey() const {return m_trapdoorFunction;}
443
459
        KeyClass & AccessKey() {return m_trapdoorFunction;}
444
460
 
 
461
        void CopyKeyInto(typename SCHEME_OPTIONS::PrivateKey &key) const {key = GetKey();}
 
462
        void CopyKeyInto(typename SCHEME_OPTIONS::PublicKey &key) const {key = GetKey();}
 
463
 
445
464
private:
446
465
        KeyClass m_trapdoorFunction;
447
466
};
448
467
 
449
 
//! _
450
 
template <class SCHEME_OPTIONS>
451
 
class TF_DecryptorImpl : public TF_ObjectImpl<TF_DecryptorBase, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PrivateKey>
452
 
{
453
 
};
454
 
 
455
 
//! _
456
 
template <class SCHEME_OPTIONS>
457
 
class TF_EncryptorImpl : public TF_ObjectImpl<TF_EncryptorBase, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PublicKey>
458
 
{
459
 
};
460
 
 
461
 
//! _
462
 
template <class SCHEME_OPTIONS>
463
 
class TF_SignerImpl : public TF_ObjectImpl<TF_SignerBase, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PrivateKey>
464
 
{
465
 
};
466
 
 
467
 
//! _
468
 
template <class SCHEME_OPTIONS>
469
 
class TF_VerifierImpl : public TF_ObjectImpl<TF_VerifierBase, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PublicKey>
 
468
//! .
 
469
template <class SCHEME_OPTIONS>
 
470
class TF_DecryptorImpl : public TF_ObjectImpl<TF_DecryptorBase, SCHEME_OPTIONS, PrivateKeyCopier<typename SCHEME_OPTIONS::Keys> >
 
471
{
 
472
};
 
473
 
 
474
//! .
 
475
template <class SCHEME_OPTIONS>
 
476
class TF_EncryptorImpl : public TF_ObjectImpl<TF_EncryptorBase, SCHEME_OPTIONS, PublicKeyCopier<typename SCHEME_OPTIONS::Keys> >
 
477
{
 
478
};
 
479
 
 
480
//! .
 
481
template <class SCHEME_OPTIONS>
 
482
class TF_SignerImpl : public TF_ObjectImpl<TF_SignerBase, SCHEME_OPTIONS, PrivateKeyCopier<typename SCHEME_OPTIONS::Keys> >
 
483
{
 
484
};
 
485
 
 
486
//! .
 
487
template <class SCHEME_OPTIONS>
 
488
class TF_VerifierImpl : public TF_ObjectImpl<TF_VerifierBase, SCHEME_OPTIONS, PublicKeyCopier<typename SCHEME_OPTIONS::Keys> >
470
489
{
471
490
};
472
491
 
473
492
// ********************************************************
474
493
 
475
 
//! _
476
494
class CRYPTOPP_NO_VTABLE MaskGeneratingFunction
477
495
{
478
496
public:
479
497
        virtual ~MaskGeneratingFunction() {}
480
 
        virtual void GenerateAndMask(HashTransformation &hash, byte *output, size_t outputLength, const byte *input, size_t inputLength, bool mask = true) const =0;
 
498
        virtual void GenerateAndMask(HashTransformation &hash, byte *output, unsigned int outputLength, const byte *input, unsigned int inputLength, bool mask = true) const =0;
481
499
};
482
500
 
483
 
CRYPTOPP_DLL void CRYPTOPP_API P1363_MGF1KDF2_Common(HashTransformation &hash, byte *output, size_t outputLength, const byte *input, size_t inputLength, const byte *derivationParams, size_t derivationParamsLength, bool mask, unsigned int counterStart);
 
501
CRYPTOPP_DLL void P1363_MGF1KDF2_Common(HashTransformation &hash, byte *output, unsigned int outputLength, const byte *input, unsigned int inputLength, const byte *derivationParams, unsigned int derivationParamsLength, bool mask, unsigned int counterStart);
484
502
 
485
 
//! _
 
503
//! .
486
504
class P1363_MGF1 : public MaskGeneratingFunction
487
505
{
488
506
public:
489
 
        static const char * CRYPTOPP_API StaticAlgorithmName() {return "MGF1";}
490
 
        void GenerateAndMask(HashTransformation &hash, byte *output, size_t outputLength, const byte *input, size_t inputLength, bool mask = true) const
 
507
        static const char * StaticAlgorithmName() {return "MGF1";}
 
508
        void GenerateAndMask(HashTransformation &hash, byte *output, unsigned int outputLength, const byte *input, unsigned int inputLength, bool mask = true) const
491
509
        {
492
510
                P1363_MGF1KDF2_Common(hash, output, outputLength, input, inputLength, NULL, 0, mask, 0);
493
511
        }
495
513
 
496
514
// ********************************************************
497
515
 
498
 
//! _
 
516
//! .
499
517
template <class H>
500
518
class P1363_KDF2
501
519
{
502
520
public:
503
 
        static void CRYPTOPP_API DeriveKey(byte *output, size_t outputLength, const byte *input, size_t inputLength, const byte *derivationParams, size_t derivationParamsLength)
 
521
        static void DeriveKey(byte *output, unsigned int outputLength, const byte *input, unsigned int inputLength, const byte *derivationParams, unsigned int derivationParamsLength)
504
522
        {
505
523
                H h;
506
524
                P1363_MGF1KDF2_Common(h, output, outputLength, input, inputLength, derivationParams, derivationParamsLength, false, 1);
509
527
 
510
528
// ********************************************************
511
529
 
512
 
//! to be thrown by DecodeElement and AgreeWithStaticPrivateKey
 
530
// to be thrown by DecodeElement and AgreeWithStaticPrivateKey
513
531
class DL_BadElement : public InvalidDataFormat
514
532
{
515
533
public:
516
534
        DL_BadElement() : InvalidDataFormat("CryptoPP: invalid group element") {}
517
535
};
518
536
 
519
 
//! interface for DL group parameters
 
537
//! .
520
538
template <class T>
521
539
class CRYPTOPP_NO_VTABLE DL_GroupParameters : public CryptoParameters
522
540
{
608
626
        mutable unsigned int m_validationLevel;
609
627
};
610
628
 
611
 
//! _
 
629
//! .
612
630
template <class GROUP_PRECOMP, class BASE_PRECOMP = DL_FixedBasePrecomputationImpl<CPP_TYPENAME GROUP_PRECOMP::Element>, class BASE = DL_GroupParameters<CPP_TYPENAME GROUP_PRECOMP::Element> >
613
631
class DL_GroupParametersImpl : public BASE
614
632
{
626
644
        BASE_PRECOMP m_gpc;
627
645
};
628
646
 
629
 
//! _
 
647
//! .
630
648
template <class T>
631
649
class CRYPTOPP_NO_VTABLE DL_Key
632
650
{
635
653
        virtual DL_GroupParameters<T> & AccessAbstractGroupParameters() =0;
636
654
};
637
655
 
638
 
//! interface for DL public keys
 
656
//! .
639
657
template <class T>
640
658
class CRYPTOPP_NO_VTABLE DL_PublicKey : public DL_Key<T>
641
659
{
646
664
 
647
665
        bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const
648
666
        {
649
 
                return GetValueHelper(this, name, valueType, pValue, &this->GetAbstractGroupParameters())
 
667
                return GetValueHelper(this, name, valueType, pValue, &GetAbstractGroupParameters())
650
668
                                CRYPTOPP_GET_FUNCTION_ENTRY(PublicElement);
651
669
        }
652
670
 
653
671
        void AssignFrom(const NameValuePairs &source);
654
672
        
655
673
        // non-inherited
656
 
        virtual const Element & GetPublicElement() const {return GetPublicPrecomputation().GetBase(this->GetAbstractGroupParameters().GetGroupPrecomputation());}
657
 
        virtual void SetPublicElement(const Element &y) {AccessPublicPrecomputation().SetBase(this->GetAbstractGroupParameters().GetGroupPrecomputation(), y);}
 
674
        virtual const Element & GetPublicElement() const {return GetPublicPrecomputation().GetBase(GetAbstractGroupParameters().GetGroupPrecomputation());}
 
675
        virtual void SetPublicElement(const Element &y) {AccessPublicPrecomputation().SetBase(GetAbstractGroupParameters().GetGroupPrecomputation(), y);}
658
676
        virtual Element ExponentiatePublicElement(const Integer &exponent) const
659
677
        {
660
 
                const DL_GroupParameters<T> &params = this->GetAbstractGroupParameters();
 
678
                const DL_GroupParameters<T> &params = GetAbstractGroupParameters();
661
679
                return GetPublicPrecomputation().Exponentiate(params.GetGroupPrecomputation(), exponent);
662
680
        }
663
681
        virtual Element CascadeExponentiateBaseAndPublicElement(const Integer &baseExp, const Integer &publicExp) const
664
682
        {
665
 
                const DL_GroupParameters<T> &params = this->GetAbstractGroupParameters();
 
683
                const DL_GroupParameters<T> &params = GetAbstractGroupParameters();
666
684
                return params.GetBasePrecomputation().CascadeExponentiate(params.GetGroupPrecomputation(), baseExp, GetPublicPrecomputation(), publicExp);
667
685
        }
668
686
 
670
688
        virtual DL_FixedBasePrecomputation<T> & AccessPublicPrecomputation() =0;
671
689
};
672
690
 
673
 
//! interface for DL private keys
 
691
//! .
674
692
template <class T>
675
693
class CRYPTOPP_NO_VTABLE DL_PrivateKey : public DL_Key<T>
676
694
{
681
699
 
682
700
        void MakePublicKey(DL_PublicKey<T> &pub) const
683
701
        {
684
 
                pub.AccessAbstractGroupParameters().AssignFrom(this->GetAbstractGroupParameters());
685
 
                pub.SetPublicElement(this->GetAbstractGroupParameters().ExponentiateBase(GetPrivateExponent()));
 
702
                pub.AccessAbstractGroupParameters().AssignFrom(GetAbstractGroupParameters());
 
703
                pub.SetPublicElement(GetAbstractGroupParameters().ExponentiateBase(GetPrivateExponent()));
686
704
        }
687
705
 
688
706
        bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const
689
707
        {
690
 
                return GetValueHelper(this, name, valueType, pValue, &this->GetAbstractGroupParameters())
 
708
                return GetValueHelper(this, name, valueType, pValue, &GetAbstractGroupParameters())
691
709
                                CRYPTOPP_GET_FUNCTION_ENTRY(PrivateExponent);
692
710
        }
693
711
 
694
712
        void AssignFrom(const NameValuePairs &source)
695
713
        {
696
 
                this->AccessAbstractGroupParameters().AssignFrom(source);
 
714
                AccessAbstractGroupParameters().AssignFrom(source);
697
715
                AssignFromHelper(this, source)
698
716
                        CRYPTOPP_SET_FUNCTION_ENTRY(PrivateExponent);
699
717
        }
710
728
                pPrivateKey->MakePublicKey(*this);
711
729
        else
712
730
        {
713
 
                this->AccessAbstractGroupParameters().AssignFrom(source);
 
731
                AccessAbstractGroupParameters().AssignFrom(source);
714
732
                AssignFromHelper(this, source)
715
733
                        CRYPTOPP_SET_FUNCTION_ENTRY(PublicElement);
716
734
        }
718
736
 
719
737
class OID;
720
738
 
721
 
//! _
 
739
//! .
722
740
template <class PK, class GP, class O = OID>
723
741
class DL_KeyImpl : public PK
724
742
{
745
763
class X509PublicKey;
746
764
class PKCS8PrivateKey;
747
765
 
748
 
//! _
 
766
//! .
749
767
template <class GP>
750
768
class DL_PrivateKeyImpl : public DL_PrivateKey<CPP_TYPENAME GP::Element>, public DL_KeyImpl<PKCS8PrivateKey, GP>
751
769
{
778
796
 
779
797
        void GenerateRandom(RandomNumberGenerator &rng, const NameValuePairs &params)
780
798
        {
781
 
                if (!params.GetThisObject(this->AccessGroupParameters()))
782
 
                        this->AccessGroupParameters().GenerateRandom(rng, params);
 
799
                if (!params.GetThisObject(AccessGroupParameters()))
 
800
                        AccessGroupParameters().GenerateRandom(rng, params);
783
801
//              std::pair<const byte *, int> seed;
784
802
                Integer x(rng, Integer::One(), GetAbstractGroupParameters().GetMaxExponent());
785
803
//                      Integer::ANY, Integer::Zero(), Integer::One(),
799
817
                {GetAbstractGroupParameters().SavePrecomputation(storedPrecomputation);}
800
818
 
801
819
        // DL_Key
802
 
        const DL_GroupParameters<Element> & GetAbstractGroupParameters() const {return this->GetGroupParameters();}
803
 
        DL_GroupParameters<Element> & AccessAbstractGroupParameters() {return this->AccessGroupParameters();}
 
820
        const DL_GroupParameters<Element> & GetAbstractGroupParameters() const {return GetGroupParameters();}
 
821
        DL_GroupParameters<Element> & AccessAbstractGroupParameters() {return AccessGroupParameters();}
804
822
 
805
823
        // DL_PrivateKey
806
824
        const Integer & GetPrivateExponent() const {return m_x;}
816
834
        Integer m_x;
817
835
};
818
836
 
819
 
//! _
 
837
//! .
820
838
template <class BASE, class SIGNATURE_SCHEME>
821
839
class DL_PrivateKey_WithSignaturePairwiseConsistencyTest : public BASE
822
840
{
834
852
        }
835
853
};
836
854
 
837
 
//! _
 
855
//! .
838
856
template <class GP>
839
857
class DL_PublicKeyImpl : public DL_PublicKey<typename GP::Element>, public DL_KeyImpl<X509PublicKey, GP>
840
858
{
845
863
        bool Validate(RandomNumberGenerator &rng, unsigned int level) const
846
864
        {
847
865
                bool pass = GetAbstractGroupParameters().Validate(rng, level);
848
 
                pass = pass && GetAbstractGroupParameters().ValidateElement(level, this->GetPublicElement(), &GetPublicPrecomputation());
 
866
                pass = pass && GetAbstractGroupParameters().ValidateElement(level, GetPublicElement(), &GetPublicPrecomputation());
849
867
                return pass;
850
868
        }
851
869
 
880
898
        }
881
899
 
882
900
        // DL_Key
883
 
        const DL_GroupParameters<Element> & GetAbstractGroupParameters() const {return this->GetGroupParameters();}
884
 
        DL_GroupParameters<Element> & AccessAbstractGroupParameters() {return this->AccessGroupParameters();}
 
901
        const DL_GroupParameters<Element> & GetAbstractGroupParameters() const {return GetGroupParameters();}
 
902
        DL_GroupParameters<Element> & AccessAbstractGroupParameters() {return AccessGroupParameters();}
885
903
 
886
904
        // DL_PublicKey
887
905
        const DL_FixedBasePrecomputation<Element> & GetPublicPrecomputation() const {return m_ypc;}
889
907
 
890
908
        // non-inherited
891
909
        bool operator==(const DL_PublicKeyImpl<GP> &rhs) const
892
 
                {return this->GetGroupParameters() == rhs.GetGroupParameters() && this->GetPublicElement() == rhs.GetPublicElement();}
 
910
                {return GetGroupParameters() == rhs.GetGroupParameters() && GetPublicElement() == rhs.GetPublicElement();}
893
911
 
894
912
private:
895
913
        typename GP::BasePrecomputation m_ypc;
896
914
};
897
915
 
898
 
//! interface for Elgamal-like signature algorithms
 
916
//! .
899
917
template <class T>
900
918
class CRYPTOPP_NO_VTABLE DL_ElgamalLikeSignatureAlgorithm
901
919
{
904
922
        virtual bool Verify(const DL_GroupParameters<T> &params, const DL_PublicKey<T> &publicKey, const Integer &e, const Integer &r, const Integer &s) const =0;
905
923
        virtual Integer RecoverPresignature(const DL_GroupParameters<T> &params, const DL_PublicKey<T> &publicKey, const Integer &r, const Integer &s) const
906
924
                {throw NotImplemented("DL_ElgamalLikeSignatureAlgorithm: this signature scheme does not support message recovery");}
907
 
        virtual size_t RLen(const DL_GroupParameters<T> &params) const
 
925
        virtual unsigned int RLen(const DL_GroupParameters<T> &params) const
908
926
                {return params.GetSubgroupOrder().ByteCount();}
909
 
        virtual size_t SLen(const DL_GroupParameters<T> &params) const
 
927
        virtual unsigned int SLen(const DL_GroupParameters<T> &params) const
910
928
                {return params.GetSubgroupOrder().ByteCount();}
911
929
};
912
930
 
913
 
//! interface for DL key agreement algorithms
 
931
//! .
914
932
template <class T>
915
933
class CRYPTOPP_NO_VTABLE DL_KeyAgreementAlgorithm
916
934
{
921
939
        virtual Element AgreeWithStaticPrivateKey(const DL_GroupParameters<Element> &params, const Element &publicElement, bool validateOtherPublicKey, const Integer &privateExponent) const =0;
922
940
};
923
941
 
924
 
//! interface for key derivation algorithms used in DL cryptosystems
 
942
//! .
925
943
template <class T>
926
944
class CRYPTOPP_NO_VTABLE DL_KeyDerivationAlgorithm
927
945
{
928
946
public:
929
947
        virtual bool ParameterSupported(const char *name) const {return false;}
930
 
        virtual void Derive(const DL_GroupParameters<T> &groupParams, byte *derivedKey, size_t derivedLength, const T &agreedElement, const T &ephemeralPublicKey, const NameValuePairs &derivationParams) const =0;
 
948
        virtual void Derive(const DL_GroupParameters<T> &groupParams, byte *derivedKey, unsigned int derivedLength, const T &agreedElement, const T &ephemeralPublicKey, const NameValuePairs &derivationParams) const =0;
931
949
};
932
950
 
933
 
//! interface for symmetric encryption algorithms used in DL cryptosystems
 
951
//! .
934
952
class CRYPTOPP_NO_VTABLE DL_SymmetricEncryptionAlgorithm
935
953
{
936
954
public:
937
955
        virtual bool ParameterSupported(const char *name) const {return false;}
938
 
        virtual size_t GetSymmetricKeyLength(size_t plaintextLength) const =0;
939
 
        virtual size_t GetSymmetricCiphertextLength(size_t plaintextLength) const =0;
940
 
        virtual size_t GetMaxSymmetricPlaintextLength(size_t ciphertextLength) const =0;
941
 
        virtual void SymmetricEncrypt(RandomNumberGenerator &rng, const byte *key, const byte *plaintext, size_t plaintextLength, byte *ciphertext, const NameValuePairs &parameters) const =0;
942
 
        virtual DecodingResult SymmetricDecrypt(const byte *key, const byte *ciphertext, size_t ciphertextLength, byte *plaintext, const NameValuePairs &parameters) const =0;
 
956
        virtual unsigned int GetSymmetricKeyLength(unsigned int plaintextLength) const =0;
 
957
        virtual unsigned int GetSymmetricCiphertextLength(unsigned int plaintextLength) const =0;
 
958
        virtual unsigned int GetMaxSymmetricPlaintextLength(unsigned int ciphertextLength) const =0;
 
959
        virtual void SymmetricEncrypt(RandomNumberGenerator &rng, const byte *key, const byte *plaintext, unsigned int plaintextLength, byte *ciphertext, const NameValuePairs &parameters) const =0;
 
960
        virtual DecodingResult SymmetricDecrypt(const byte *key, const byte *ciphertext, unsigned int ciphertextLength, byte *plaintext, const NameValuePairs &parameters) const =0;
943
961
};
944
962
 
945
 
//! _
 
963
//! .
946
964
template <class KI>
947
965
class CRYPTOPP_NO_VTABLE DL_Base
948
966
{
957
975
        virtual const KeyInterface & GetKeyInterface() const =0;
958
976
};
959
977
 
960
 
//! _
 
978
//! .
961
979
template <class INTERFACE, class KEY_INTERFACE>
962
980
class CRYPTOPP_NO_VTABLE DL_SignatureSchemeBase : public INTERFACE, public DL_Base<KEY_INTERFACE>
963
981
{
964
982
public:
965
 
        size_t SignatureLength() const
 
983
        unsigned int SignatureLength() const
966
984
        {
967
 
                return GetSignatureAlgorithm().RLen(this->GetAbstractGroupParameters())
968
 
                        + GetSignatureAlgorithm().SLen(this->GetAbstractGroupParameters());
 
985
                return GetSignatureAlgorithm().RLen(GetAbstractGroupParameters())
 
986
                        + GetSignatureAlgorithm().SLen(GetAbstractGroupParameters());
969
987
        }
970
 
        size_t MaxRecoverableLength() const 
 
988
        unsigned int MaxRecoverableLength() const 
971
989
                {return GetMessageEncodingInterface().MaxRecoverableLength(0, GetHashIdentifier().second, GetDigestSize());}
972
 
        size_t MaxRecoverableLengthFromSignatureLength(size_t signatureLength) const
 
990
        unsigned int MaxRecoverableLengthFromSignatureLength(unsigned int signatureLength) const
973
991
                {assert(false); return 0;}      // TODO
974
992
 
975
993
        bool IsProbabilistic() const 
980
998
                {return GetMessageEncodingInterface().RecoverablePartFirst();}
981
999
 
982
1000
protected:
983
 
        size_t MessageRepresentativeLength() const {return BitsToBytes(MessageRepresentativeBitLength());}
984
 
        size_t MessageRepresentativeBitLength() const {return this->GetAbstractGroupParameters().GetSubgroupOrder().BitCount();}
 
1001
        unsigned int MessageRepresentativeLength() const {return BitsToBytes(MessageRepresentativeBitLength());}
 
1002
        unsigned int MessageRepresentativeBitLength() const {return GetAbstractGroupParameters().GetSubgroupOrder().BitCount();}
985
1003
 
986
1004
        virtual const DL_ElgamalLikeSignatureAlgorithm<CPP_TYPENAME KEY_INTERFACE::Element> & GetSignatureAlgorithm() const =0;
987
1005
        virtual const PK_SignatureMessageEncodingMethod & GetMessageEncodingInterface() const =0;
988
1006
        virtual HashIdentifier GetHashIdentifier() const =0;
989
 
        virtual size_t GetDigestSize() const =0;
 
1007
        virtual unsigned int GetDigestSize() const =0;
990
1008
};
991
1009
 
992
 
//! _
 
1010
//! .
993
1011
template <class T>
994
1012
class CRYPTOPP_NO_VTABLE DL_SignerBase : public DL_SignatureSchemeBase<PK_Signer, DL_PrivateKey<T> >
995
1013
{
997
1015
        // for validation testing
998
1016
        void RawSign(const Integer &k, const Integer &e, Integer &r, Integer &s) const
999
1017
        {
1000
 
                const DL_ElgamalLikeSignatureAlgorithm<T> &alg = this->GetSignatureAlgorithm();
1001
 
                const DL_GroupParameters<T> &params = this->GetAbstractGroupParameters();
1002
 
                const DL_PrivateKey<T> &key = this->GetKeyInterface();
 
1018
                const DL_ElgamalLikeSignatureAlgorithm<T> &alg = GetSignatureAlgorithm();
 
1019
                const DL_GroupParameters<T> &params = GetAbstractGroupParameters();
 
1020
                const DL_PrivateKey<T> &key = GetKeyInterface();
1003
1021
 
1004
1022
                r = params.ConvertElementToInteger(params.ExponentiateBase(k));
1005
1023
                alg.Sign(params, key.GetPrivateExponent(), k, e, r, s);
1006
1024
        }
1007
1025
 
1008
 
        void InputRecoverableMessage(PK_MessageAccumulator &messageAccumulator, const byte *recoverableMessage, size_t recoverableMessageLength) const
 
1026
        void InputRecoverableMessage(PK_MessageAccumulator &messageAccumulator, const byte *recoverableMessage, unsigned int recoverableMessageLength) const
1009
1027
        {
1010
1028
                PK_MessageAccumulatorBase &ma = static_cast<PK_MessageAccumulatorBase &>(messageAccumulator);
1011
1029
                ma.m_recoverableMessage.Assign(recoverableMessage, recoverableMessageLength);
1012
 
                this->GetMessageEncodingInterface().ProcessRecoverableMessage(ma.AccessHash(), 
 
1030
                GetMessageEncodingInterface().ProcessRecoverableMessage(ma.AccessHash(), 
1013
1031
                        recoverableMessage, recoverableMessageLength, 
1014
1032
                        ma.m_presignature, ma.m_presignature.size(),
1015
1033
                        ma.m_semisignature);
1016
1034
        }
1017
1035
 
1018
 
        size_t SignAndRestart(RandomNumberGenerator &rng, PK_MessageAccumulator &messageAccumulator, byte *signature, bool restart) const
 
1036
        unsigned int SignAndRestart(RandomNumberGenerator &rng, PK_MessageAccumulator &messageAccumulator, byte *signature, bool restart) const
1019
1037
        {
1020
 
                this->GetMaterial().DoQuickSanityCheck();
 
1038
                GetMaterial().DoQuickSanityCheck();
1021
1039
 
1022
1040
                PK_MessageAccumulatorBase &ma = static_cast<PK_MessageAccumulatorBase &>(messageAccumulator);
1023
 
                const DL_ElgamalLikeSignatureAlgorithm<T> &alg = this->GetSignatureAlgorithm();
1024
 
                const DL_GroupParameters<T> &params = this->GetAbstractGroupParameters();
1025
 
                const DL_PrivateKey<T> &key = this->GetKeyInterface();
 
1041
                const DL_ElgamalLikeSignatureAlgorithm<T> &alg = GetSignatureAlgorithm();
 
1042
                const DL_GroupParameters<T> &params = GetAbstractGroupParameters();
 
1043
                const DL_PrivateKey<T> &key = GetKeyInterface();
1026
1044
 
1027
 
                SecByteBlock representative(this->MessageRepresentativeLength());
1028
 
                this->GetMessageEncodingInterface().ComputeMessageRepresentative(
 
1045
                SecByteBlock representative(MessageRepresentativeLength());
 
1046
                GetMessageEncodingInterface().ComputeMessageRepresentative(
1029
1047
                        rng, 
1030
1048
                        ma.m_recoverableMessage, ma.m_recoverableMessage.size(), 
1031
 
                        ma.AccessHash(), this->GetHashIdentifier(), ma.m_empty, 
1032
 
                        representative, this->MessageRepresentativeBitLength());
 
1049
                        ma.AccessHash(), GetHashIdentifier(), ma.m_empty, 
 
1050
                        representative, MessageRepresentativeBitLength());
1033
1051
                ma.m_empty = true;
1034
1052
                Integer e(representative, representative.size());
1035
1053
 
1036
1054
                Integer r;
1037
 
                if (this->MaxRecoverableLength() > 0)
 
1055
                if (MaxRecoverableLength() > 0)
1038
1056
                        r.Decode(ma.m_semisignature, ma.m_semisignature.size());
1039
1057
                else
1040
1058
                        r.Decode(ma.m_presignature, ma.m_presignature.size());
1041
1059
                Integer s;
1042
1060
                alg.Sign(params, key.GetPrivateExponent(), ma.m_k, e, r, s);
1043
1061
 
1044
 
                size_t rLen = alg.RLen(params);
 
1062
                unsigned int rLen = alg.RLen(params);
1045
1063
                r.Encode(signature, rLen);
1046
1064
                s.Encode(signature+rLen, alg.SLen(params));
1047
1065
 
1048
1066
                if (restart)
1049
1067
                        RestartMessageAccumulator(rng, ma);
1050
1068
 
1051
 
                return this->SignatureLength();
 
1069
                return SignatureLength();
1052
1070
        }
1053
1071
 
1054
1072
protected:
1055
1073
        void RestartMessageAccumulator(RandomNumberGenerator &rng, PK_MessageAccumulatorBase &ma) const
1056
1074
        {
1057
 
                const DL_ElgamalLikeSignatureAlgorithm<T> &alg = this->GetSignatureAlgorithm();
1058
 
                const DL_GroupParameters<T> &params = this->GetAbstractGroupParameters();
 
1075
                const DL_ElgamalLikeSignatureAlgorithm<T> &alg = GetSignatureAlgorithm();
 
1076
                const DL_GroupParameters<T> &params = GetAbstractGroupParameters();
1059
1077
                ma.m_k.Randomize(rng, 1, params.GetSubgroupOrder()-1);
1060
1078
                ma.m_presignature.New(params.GetEncodedElementSize(false));
1061
1079
                params.ConvertElementToInteger(params.ExponentiateBase(ma.m_k)).Encode(ma.m_presignature, ma.m_presignature.size());
1062
1080
        }
1063
1081
};
1064
1082
 
1065
 
//! _
 
1083
//! .
1066
1084
template <class T>
1067
1085
class CRYPTOPP_NO_VTABLE DL_VerifierBase : public DL_SignatureSchemeBase<PK_Verifier, DL_PublicKey<T> >
1068
1086
{
1069
1087
public:
1070
 
        void InputSignature(PK_MessageAccumulator &messageAccumulator, const byte *signature, size_t signatureLength) const
 
1088
        void InputSignature(PK_MessageAccumulator &messageAccumulator, const byte *signature, unsigned int signatureLength) const
1071
1089
        {
1072
1090
                PK_MessageAccumulatorBase &ma = static_cast<PK_MessageAccumulatorBase &>(messageAccumulator);
1073
 
                const DL_ElgamalLikeSignatureAlgorithm<T> &alg = this->GetSignatureAlgorithm();
1074
 
                const DL_GroupParameters<T> &params = this->GetAbstractGroupParameters();
 
1091
                const DL_ElgamalLikeSignatureAlgorithm<T> &alg = GetSignatureAlgorithm();
 
1092
                const DL_GroupParameters<T> &params = GetAbstractGroupParameters();
1075
1093
 
1076
 
                size_t rLen = alg.RLen(params);
 
1094
                unsigned int rLen = alg.RLen(params);
1077
1095
                ma.m_semisignature.Assign(signature, rLen);
1078
1096
                ma.m_s.Decode(signature+rLen, alg.SLen(params));
1079
1097
 
1080
 
                this->GetMessageEncodingInterface().ProcessSemisignature(ma.AccessHash(), ma.m_semisignature, ma.m_semisignature.size());
 
1098
                GetMessageEncodingInterface().ProcessSemisignature(ma.AccessHash(), ma.m_semisignature, ma.m_semisignature.size());
1081
1099
        }
1082
1100
        
1083
1101
        bool VerifyAndRestart(PK_MessageAccumulator &messageAccumulator) const
1084
1102
        {
1085
 
                this->GetMaterial().DoQuickSanityCheck();
 
1103
                GetMaterial().DoQuickSanityCheck();
1086
1104
 
1087
1105
                PK_MessageAccumulatorBase &ma = static_cast<PK_MessageAccumulatorBase &>(messageAccumulator);
1088
 
                const DL_ElgamalLikeSignatureAlgorithm<T> &alg = this->GetSignatureAlgorithm();
1089
 
                const DL_GroupParameters<T> &params = this->GetAbstractGroupParameters();
1090
 
                const DL_PublicKey<T> &key = this->GetKeyInterface();
 
1106
                const DL_ElgamalLikeSignatureAlgorithm<T> &alg = GetSignatureAlgorithm();
 
1107
                const DL_GroupParameters<T> &params = GetAbstractGroupParameters();
 
1108
                const DL_PublicKey<T> &key = GetKeyInterface();
1091
1109
 
1092
 
                SecByteBlock representative(this->MessageRepresentativeLength());
1093
 
                this->GetMessageEncodingInterface().ComputeMessageRepresentative(NullRNG(), ma.m_recoverableMessage, ma.m_recoverableMessage.size(), 
1094
 
                        ma.AccessHash(), this->GetHashIdentifier(), ma.m_empty,
1095
 
                        representative, this->MessageRepresentativeBitLength());
 
1110
                SecByteBlock representative(MessageRepresentativeLength());
 
1111
                GetMessageEncodingInterface().ComputeMessageRepresentative(NullRNG(), ma.m_recoverableMessage, ma.m_recoverableMessage.size(), 
 
1112
                        ma.AccessHash(), GetHashIdentifier(), ma.m_empty,
 
1113
                        representative, MessageRepresentativeBitLength());
1096
1114
                ma.m_empty = true;
1097
1115
                Integer e(representative, representative.size());
1098
1116
 
1102
1120
 
1103
1121
        DecodingResult RecoverAndRestart(byte *recoveredMessage, PK_MessageAccumulator &messageAccumulator) const
1104
1122
        {
1105
 
                this->GetMaterial().DoQuickSanityCheck();
 
1123
                GetMaterial().DoQuickSanityCheck();
1106
1124
 
1107
1125
                PK_MessageAccumulatorBase &ma = static_cast<PK_MessageAccumulatorBase &>(messageAccumulator);
1108
 
                const DL_ElgamalLikeSignatureAlgorithm<T> &alg = this->GetSignatureAlgorithm();
1109
 
                const DL_GroupParameters<T> &params = this->GetAbstractGroupParameters();
1110
 
                const DL_PublicKey<T> &key = this->GetKeyInterface();
 
1126
                const DL_ElgamalLikeSignatureAlgorithm<T> &alg = GetSignatureAlgorithm();
 
1127
                const DL_GroupParameters<T> &params = GetAbstractGroupParameters();
 
1128
                const DL_PublicKey<T> &key = GetKeyInterface();
1111
1129
 
1112
 
                SecByteBlock representative(this->MessageRepresentativeLength());
1113
 
                this->GetMessageEncodingInterface().ComputeMessageRepresentative(
 
1130
                SecByteBlock representative(MessageRepresentativeLength());
 
1131
                GetMessageEncodingInterface().ComputeMessageRepresentative(
1114
1132
                        NullRNG(), 
1115
1133
                        ma.m_recoverableMessage, ma.m_recoverableMessage.size(), 
1116
 
                        ma.AccessHash(), this->GetHashIdentifier(), ma.m_empty,
1117
 
                        representative, this->MessageRepresentativeBitLength());
 
1134
                        ma.AccessHash(), GetHashIdentifier(), ma.m_empty,
 
1135
                        representative, MessageRepresentativeBitLength());
1118
1136
                ma.m_empty = true;
1119
1137
                Integer e(representative, representative.size());
1120
1138
 
1122
1140
                Integer r(ma.m_semisignature, ma.m_semisignature.size());
1123
1141
                alg.RecoverPresignature(params, key, r, ma.m_s).Encode(ma.m_presignature, ma.m_presignature.size());
1124
1142
 
1125
 
                return this->GetMessageEncodingInterface().RecoverMessageFromSemisignature(
1126
 
                        ma.AccessHash(), this->GetHashIdentifier(),
 
1143
                return GetMessageEncodingInterface().RecoverMessageFromSemisignature(
 
1144
                        ma.AccessHash(), GetHashIdentifier(),
1127
1145
                        ma.m_presignature, ma.m_presignature.size(),
1128
1146
                        ma.m_semisignature, ma.m_semisignature.size(),
1129
1147
                        recoveredMessage);
1130
1148
        }
1131
1149
};
1132
1150
 
1133
 
//! _
 
1151
//! .
1134
1152
template <class PK, class KI>
1135
1153
class CRYPTOPP_NO_VTABLE DL_CryptoSystemBase : public PK, public DL_Base<KI>
1136
1154
{
1137
1155
public:
1138
1156
        typedef typename DL_Base<KI>::Element Element;
1139
1157
 
1140
 
        size_t MaxPlaintextLength(size_t ciphertextLength) const
 
1158
        unsigned int MaxPlaintextLength(unsigned int ciphertextLength) const
1141
1159
        {
1142
 
                unsigned int minLen = this->GetAbstractGroupParameters().GetEncodedElementSize(true);
 
1160
                unsigned int minLen = GetAbstractGroupParameters().GetEncodedElementSize(true);
1143
1161
                return ciphertextLength < minLen ? 0 : GetSymmetricEncryptionAlgorithm().GetMaxSymmetricPlaintextLength(ciphertextLength - minLen);
1144
1162
        }
1145
1163
 
1146
 
        size_t CiphertextLength(size_t plaintextLength) const
 
1164
        unsigned int CiphertextLength(unsigned int plaintextLength) const
1147
1165
        {
1148
 
                size_t len = GetSymmetricEncryptionAlgorithm().GetSymmetricCiphertextLength(plaintextLength);
1149
 
                return len == 0 ? 0 : this->GetAbstractGroupParameters().GetEncodedElementSize(true) + len;
 
1166
                unsigned int len = GetSymmetricEncryptionAlgorithm().GetSymmetricCiphertextLength(plaintextLength);
 
1167
                return len == 0 ? 0 : GetAbstractGroupParameters().GetEncodedElementSize(true) + len;
1150
1168
        }
1151
1169
 
1152
1170
        bool ParameterSupported(const char *name) const
1158
1176
        virtual const DL_SymmetricEncryptionAlgorithm & GetSymmetricEncryptionAlgorithm() const =0;
1159
1177
};
1160
1178
 
1161
 
//! _
 
1179
//! .
1162
1180
template <class T>
1163
1181
class CRYPTOPP_NO_VTABLE DL_DecryptorBase : public DL_CryptoSystemBase<PK_Decryptor, DL_PrivateKey<T> >
1164
1182
{
1165
1183
public:
1166
1184
        typedef T Element;
1167
1185
 
1168
 
        DecodingResult Decrypt(RandomNumberGenerator &rng, const byte *ciphertext, size_t ciphertextLength, byte *plaintext, const NameValuePairs &parameters = g_nullNameValuePairs) const
 
1186
        DecodingResult Decrypt(RandomNumberGenerator &rng, const byte *ciphertext, unsigned int ciphertextLength, byte *plaintext, const NameValuePairs &parameters = g_nullNameValuePairs) const
1169
1187
        {
1170
1188
                try
1171
1189
                {
1172
 
                        const DL_KeyAgreementAlgorithm<T> &agreeAlg = this->GetKeyAgreementAlgorithm();
1173
 
                        const DL_KeyDerivationAlgorithm<T> &derivAlg = this->GetKeyDerivationAlgorithm();
1174
 
                        const DL_SymmetricEncryptionAlgorithm &encAlg = this->GetSymmetricEncryptionAlgorithm();
1175
 
                        const DL_GroupParameters<T> &params = this->GetAbstractGroupParameters();
1176
 
                        const DL_PrivateKey<T> &key = this->GetKeyInterface();
 
1190
                        const DL_KeyAgreementAlgorithm<T> &agreeAlg = GetKeyAgreementAlgorithm();
 
1191
                        const DL_KeyDerivationAlgorithm<T> &derivAlg = GetKeyDerivationAlgorithm();
 
1192
                        const DL_SymmetricEncryptionAlgorithm &encAlg = GetSymmetricEncryptionAlgorithm();
 
1193
                        const DL_GroupParameters<T> &params = GetAbstractGroupParameters();
 
1194
                        const DL_PrivateKey<T> &key = GetKeyInterface();
1177
1195
 
1178
1196
                        Element q = params.DecodeElement(ciphertext, true);
1179
 
                        size_t elementSize = params.GetEncodedElementSize(true);
 
1197
                        unsigned int elementSize = params.GetEncodedElementSize(true);
1180
1198
                        ciphertext += elementSize;
1181
1199
                        ciphertextLength -= elementSize;
1182
1200
 
1194
1212
        }
1195
1213
};
1196
1214
 
1197
 
//! _
 
1215
//! .
1198
1216
template <class T>
1199
1217
class CRYPTOPP_NO_VTABLE DL_EncryptorBase : public DL_CryptoSystemBase<PK_Encryptor, DL_PublicKey<T> >
1200
1218
{
1201
1219
public:
1202
1220
        typedef T Element;
1203
1221
 
1204
 
        void Encrypt(RandomNumberGenerator &rng, const byte *plaintext, size_t plaintextLength, byte *ciphertext, const NameValuePairs &parameters = g_nullNameValuePairs) const
 
1222
        void Encrypt(RandomNumberGenerator &rng, const byte *plaintext, unsigned int plaintextLength, byte *ciphertext, const NameValuePairs &parameters = g_nullNameValuePairs) const
1205
1223
        {
1206
 
                const DL_KeyAgreementAlgorithm<T> &agreeAlg = this->GetKeyAgreementAlgorithm();
1207
 
                const DL_KeyDerivationAlgorithm<T> &derivAlg = this->GetKeyDerivationAlgorithm();
1208
 
                const DL_SymmetricEncryptionAlgorithm &encAlg = this->GetSymmetricEncryptionAlgorithm();
1209
 
                const DL_GroupParameters<T> &params = this->GetAbstractGroupParameters();
1210
 
                const DL_PublicKey<T> &key = this->GetKeyInterface();
 
1224
                const DL_KeyAgreementAlgorithm<T> &agreeAlg = GetKeyAgreementAlgorithm();
 
1225
                const DL_KeyDerivationAlgorithm<T> &derivAlg = GetKeyDerivationAlgorithm();
 
1226
                const DL_SymmetricEncryptionAlgorithm &encAlg = GetSymmetricEncryptionAlgorithm();
 
1227
                const DL_GroupParameters<T> &params = GetAbstractGroupParameters();
 
1228
                const DL_PublicKey<T> &key = GetKeyInterface();
1211
1229
 
1212
1230
                Integer x(rng, Integer::One(), params.GetMaxExponent());
1213
1231
                Element q = params.ExponentiateBase(x);
1224
1242
        }
1225
1243
};
1226
1244
 
1227
 
//! _
 
1245
//! .
1228
1246
template <class T1, class T2>
1229
1247
struct DL_SchemeOptionsBase
1230
1248
{
1233
1251
        typedef typename GroupParameters::Element Element;
1234
1252
};
1235
1253
 
1236
 
//! _
 
1254
//! .
1237
1255
template <class T1, class T2>
1238
1256
struct DL_KeyedSchemeOptions : public DL_SchemeOptionsBase<T1, typename T2::PublicKey::GroupParameters>
1239
1257
{
1242
1260
        typedef typename Keys::PublicKey PublicKey;
1243
1261
};
1244
1262
 
1245
 
//! _
 
1263
//! .
1246
1264
template <class T1, class T2, class T3, class T4, class T5>
1247
1265
struct DL_SignatureSchemeOptions : public DL_KeyedSchemeOptions<T1, T2>
1248
1266
{
1251
1269
        typedef T5 HashFunction;
1252
1270
};
1253
1271
 
1254
 
//! _
 
1272
//! .
1255
1273
template <class T1, class T2, class T3, class T4, class T5>
1256
1274
struct DL_CryptoSchemeOptions : public DL_KeyedSchemeOptions<T1, T2>
1257
1275
{
1260
1278
        typedef T5 SymmetricEncryptionAlgorithm;
1261
1279
};
1262
1280
 
1263
 
//! _
 
1281
//! .
1264
1282
template <class BASE, class SCHEME_OPTIONS, class KEY>
1265
1283
class CRYPTOPP_NO_VTABLE DL_ObjectImplBase : public AlgorithmImpl<BASE, typename SCHEME_OPTIONS::AlgorithmInfo>
1266
1284
{
1282
1300
        // for signature scheme
1283
1301
        HashIdentifier GetHashIdentifier() const
1284
1302
        {
1285
 
                typedef typename SchemeOptions::MessageEncodingMethod::HashIdentifierLookup HashLookup;
1286
 
                return HashLookup::template HashIdentifierLookup2<CPP_TYPENAME SchemeOptions::HashFunction>::Lookup();
 
1303
                typedef CPP_TYPENAME SchemeOptions::MessageEncodingMethod::HashIdentifierLookup::HashIdentifierLookup2<CPP_TYPENAME SchemeOptions::HashFunction> L;
 
1304
                return L::Lookup();
1287
1305
        }
1288
 
        size_t GetDigestSize() const
 
1306
        unsigned int GetDigestSize() const
1289
1307
        {
1290
1308
                typedef CPP_TYPENAME SchemeOptions::HashFunction H;
1291
1309
                return H::DIGESTSIZE;
1295
1313
        KEY m_key;
1296
1314
};
1297
1315
 
1298
 
//! _
 
1316
//! .
1299
1317
template <class BASE, class SCHEME_OPTIONS, class KEY>
1300
1318
class CRYPTOPP_NO_VTABLE DL_ObjectImpl : public DL_ObjectImplBase<BASE, SCHEME_OPTIONS, KEY>
1301
1319
{
1317
1335
                {return Singleton<CPP_TYPENAME SCHEME_OPTIONS::MessageEncodingMethod>().Ref();}
1318
1336
};
1319
1337
 
1320
 
//! _
 
1338
//! .
 
1339
template <class BASE, class SCHEME_OPTIONS>
 
1340
class CRYPTOPP_NO_VTABLE DL_PublicObjectImpl : public DL_ObjectImpl<BASE, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PublicKey>, public PublicKeyCopier<SCHEME_OPTIONS>
 
1341
{
 
1342
public:
 
1343
        void CopyKeyInto(typename SCHEME_OPTIONS::PublicKey &key) const
 
1344
                {key = GetKey();}
 
1345
};
 
1346
 
 
1347
//! .
 
1348
template <class BASE, class SCHEME_OPTIONS>
 
1349
class CRYPTOPP_NO_VTABLE DL_PrivateObjectImpl : public DL_ObjectImpl<BASE, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PrivateKey>, public PrivateKeyCopier<SCHEME_OPTIONS>
 
1350
{
 
1351
public:
 
1352
        void CopyKeyInto(typename SCHEME_OPTIONS::PublicKey &key) const
 
1353
                {GetKey().MakePublicKey(key);}
 
1354
        void CopyKeyInto(typename SCHEME_OPTIONS::PrivateKey &key) const
 
1355
                {key = GetKey();}
 
1356
};
 
1357
 
 
1358
//! .
1321
1359
template <class SCHEME_OPTIONS>
1322
 
class DL_SignerImpl : public DL_ObjectImpl<DL_SignerBase<typename SCHEME_OPTIONS::Element>, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PrivateKey>
 
1360
class DL_SignerImpl : public DL_PrivateObjectImpl<DL_SignerBase<typename SCHEME_OPTIONS::Element>, SCHEME_OPTIONS>
1323
1361
{
1324
1362
public:
1325
1363
        PK_MessageAccumulator * NewSignatureAccumulator(RandomNumberGenerator &rng) const
1326
1364
        {
1327
1365
                std::auto_ptr<PK_MessageAccumulatorBase> p(new PK_MessageAccumulatorImpl<CPP_TYPENAME SCHEME_OPTIONS::HashFunction>);
1328
 
                this->RestartMessageAccumulator(rng, *p);
 
1366
                RestartMessageAccumulator(rng, *p);
1329
1367
                return p.release();
1330
1368
        }
1331
1369
};
1332
1370
 
1333
 
//! _
 
1371
//! .
1334
1372
template <class SCHEME_OPTIONS>
1335
 
class DL_VerifierImpl : public DL_ObjectImpl<DL_VerifierBase<typename SCHEME_OPTIONS::Element>, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PublicKey>
 
1373
class DL_VerifierImpl : public DL_PublicObjectImpl<DL_VerifierBase<typename SCHEME_OPTIONS::Element>, SCHEME_OPTIONS>
1336
1374
{
1337
1375
public:
1338
1376
        PK_MessageAccumulator * NewVerificationAccumulator() const
1341
1379
        }
1342
1380
};
1343
1381
 
1344
 
//! _
 
1382
//! .
1345
1383
template <class SCHEME_OPTIONS>
1346
 
class DL_EncryptorImpl : public DL_ObjectImpl<DL_EncryptorBase<typename SCHEME_OPTIONS::Element>, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PublicKey>
 
1384
class DL_EncryptorImpl : public DL_PublicObjectImpl<DL_EncryptorBase<typename SCHEME_OPTIONS::Element>, SCHEME_OPTIONS>
1347
1385
{
1348
1386
};
1349
1387
 
1350
 
//! _
 
1388
//! .
1351
1389
template <class SCHEME_OPTIONS>
1352
 
class DL_DecryptorImpl : public DL_ObjectImpl<DL_DecryptorBase<typename SCHEME_OPTIONS::Element>, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PrivateKey>
 
1390
class DL_DecryptorImpl : public DL_PrivateObjectImpl<DL_DecryptorBase<typename SCHEME_OPTIONS::Element>, SCHEME_OPTIONS>
1353
1391
{
1354
1392
};
1355
1393
 
1356
1394
// ********************************************************
1357
1395
 
1358
 
//! _
 
1396
//! .
1359
1397
template <class T>
1360
1398
class CRYPTOPP_NO_VTABLE DL_SimpleKeyAgreementDomainBase : public SimpleKeyAgreementDomain
1361
1399
{
1420
1458
public:
1421
1459
        typedef ELEMENT Element;
1422
1460
 
1423
 
        static const char * CRYPTOPP_API StaticAlgorithmName()
1424
 
                {return COFACTOR_OPTION::ToEnum() == INCOMPATIBLE_COFACTOR_MULTIPLICTION ? "DHC" : "DH";}
 
1461
        static const char *StaticAlgorithmName()
 
1462
                {return COFACTOR_OPTION::ToEnum() == NO_COFACTOR_MULTIPLICTION ? "DH" : "DHC";}
1425
1463
 
1426
1464
        Element AgreeWithEphemeralPrivateKey(const DL_GroupParameters<Element> &params, const DL_FixedBasePrecomputation<Element> &publicPrecomputation, const Integer &privateExponent) const
1427
1465
        {
1474
1512
public:
1475
1513
        PK_FinalTemplate() {}
1476
1514
 
1477
 
        PK_FinalTemplate(const CryptoMaterial &key)
1478
 
                {this->AccessKey().AssignFrom(key);}
1479
 
 
1480
 
        PK_FinalTemplate(BufferedTransformation &bt)
1481
 
                {this->AccessKey().BERDecode(bt);}
1482
 
 
1483
 
        PK_FinalTemplate(const AsymmetricAlgorithm &algorithm)
1484
 
                {this->AccessKey().AssignFrom(algorithm.GetMaterial());}
1485
 
 
1486
1515
        PK_FinalTemplate(const Integer &v1)
1487
 
                {this->AccessKey().Initialize(v1);}
 
1516
                {AccessKey().Initialize(v1);}
 
1517
 
 
1518
        PK_FinalTemplate(const typename BASE::KeyClass &key)  {AccessKey().operator=(key);}
 
1519
 
 
1520
        template <class T>
 
1521
        PK_FinalTemplate(const PublicKeyCopier<T> &key)
 
1522
                {key.CopyKeyInto(AccessKey());}
 
1523
 
 
1524
        template <class T>
 
1525
        PK_FinalTemplate(const PrivateKeyCopier<T> &key)
 
1526
                {key.CopyKeyInto(AccessKey());}
 
1527
 
 
1528
        PK_FinalTemplate(BufferedTransformation &bt) {AccessKey().BERDecode(bt);}
1488
1529
 
1489
1530
#if (defined(_MSC_VER) && _MSC_VER < 1300)
1490
1531
 
1491
1532
        template <class T1, class T2>
1492
1533
        PK_FinalTemplate(T1 &v1, T2 &v2)
1493
 
                {this->AccessKey().Initialize(v1, v2);}
 
1534
                {AccessKey().Initialize(v1, v2);}
1494
1535
 
1495
1536
        template <class T1, class T2, class T3>
1496
1537
        PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3)
1497
 
                {this->AccessKey().Initialize(v1, v2, v3);}
 
1538
                {AccessKey().Initialize(v1, v2, v3);}
1498
1539
        
1499
1540
        template <class T1, class T2, class T3, class T4>
1500
1541
        PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3, T4 &v4)
1501
 
                {this->AccessKey().Initialize(v1, v2, v3, v4);}
 
1542
                {AccessKey().Initialize(v1, v2, v3, v4);}
1502
1543
 
1503
1544
        template <class T1, class T2, class T3, class T4, class T5>
1504
1545
        PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3, T4 &v4, T5 &v5)
1505
 
                {this->AccessKey().Initialize(v1, v2, v3, v4, v5);}
 
1546
                {AccessKey().Initialize(v1, v2, v3, v4, v5);}
1506
1547
 
1507
1548
        template <class T1, class T2, class T3, class T4, class T5, class T6>
1508
1549
        PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3, T4 &v4, T5 &v5, T6 &v6)
1509
 
                {this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6);}
 
1550
                {AccessKey().Initialize(v1, v2, v3, v4, v5, v6);}
1510
1551
 
1511
1552
        template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>
1512
1553
        PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3, T4 &v4, T5 &v5, T6 &v6, T7 &v7)
1513
 
                {this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7);}
 
1554
                {AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7);}
1514
1555
 
1515
1556
        template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
1516
1557
        PK_FinalTemplate(T1 &v1, T2 &v2, T3 &v3, T4 &v4, T5 &v5, T6 &v6, T7 &v7, T8 &v8)
1517
 
                {this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7, v8);}
 
1558
                {AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7, v8);}
1518
1559
 
1519
1560
#else
1520
1561
 
1521
1562
        template <class T1, class T2>
1522
1563
        PK_FinalTemplate(const T1 &v1, const T2 &v2)
1523
 
                {this->AccessKey().Initialize(v1, v2);}
 
1564
                {AccessKey().Initialize(v1, v2);}
1524
1565
 
1525
1566
        template <class T1, class T2, class T3>
1526
1567
        PK_FinalTemplate(const T1 &v1, const T2 &v2, const T3 &v3)
1527
 
                {this->AccessKey().Initialize(v1, v2, v3);}
 
1568
                {AccessKey().Initialize(v1, v2, v3);}
1528
1569
        
1529
1570
        template <class T1, class T2, class T3, class T4>
1530
1571
        PK_FinalTemplate(const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4)
1531
 
                {this->AccessKey().Initialize(v1, v2, v3, v4);}
 
1572
                {AccessKey().Initialize(v1, v2, v3, v4);}
1532
1573
 
1533
1574
        template <class T1, class T2, class T3, class T4, class T5>
1534
1575
        PK_FinalTemplate(const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5)
1535
 
                {this->AccessKey().Initialize(v1, v2, v3, v4, v5);}
 
1576
                {AccessKey().Initialize(v1, v2, v3, v4, v5);}
1536
1577
 
1537
1578
        template <class T1, class T2, class T3, class T4, class T5, class T6>
1538
1579
        PK_FinalTemplate(const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6)
1539
 
                {this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6);}
 
1580
                {AccessKey().Initialize(v1, v2, v3, v4, v5, v6);}
1540
1581
 
1541
1582
        template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>
1542
1583
        PK_FinalTemplate(const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7)
1543
 
                {this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7);}
 
1584
                {AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7);}
1544
1585
 
1545
1586
        template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
1546
1587
        PK_FinalTemplate(const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7, const T8 &v8)
1547
 
                {this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7, v8);}
 
1588
                {AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7, v8);}
1548
1589
 
1549
1590
        template <class T1, class T2>
1550
1591
        PK_FinalTemplate(T1 &v1, const T2 &v2)
1551
 
                {this->AccessKey().Initialize(v1, v2);}
 
1592
                {AccessKey().Initialize(v1, v2);}
1552
1593
 
1553
1594
        template <class T1, class T2, class T3>
1554
1595
        PK_FinalTemplate(T1 &v1, const T2 &v2, const T3 &v3)
1555
 
                {this->AccessKey().Initialize(v1, v2, v3);}
 
1596
                {AccessKey().Initialize(v1, v2, v3);}
1556
1597
        
1557
1598
        template <class T1, class T2, class T3, class T4>
1558
1599
        PK_FinalTemplate(T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4)
1559
 
                {this->AccessKey().Initialize(v1, v2, v3, v4);}
 
1600
                {AccessKey().Initialize(v1, v2, v3, v4);}
1560
1601
 
1561
1602
        template <class T1, class T2, class T3, class T4, class T5>
1562
1603
        PK_FinalTemplate(T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5)
1563
 
                {this->AccessKey().Initialize(v1, v2, v3, v4, v5);}
 
1604
                {AccessKey().Initialize(v1, v2, v3, v4, v5);}
1564
1605
 
1565
1606
        template <class T1, class T2, class T3, class T4, class T5, class T6>
1566
1607
        PK_FinalTemplate(T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6)
1567
 
                {this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6);}
 
1608
                {AccessKey().Initialize(v1, v2, v3, v4, v5, v6);}
1568
1609
 
1569
1610
        template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>
1570
1611
        PK_FinalTemplate(T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7)
1571
 
                {this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7);}
 
1612
                {AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7);}
1572
1613
 
1573
1614
        template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
1574
1615
        PK_FinalTemplate(T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7, const T8 &v8)
1575
 
                {this->AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7, v8);}
 
1616
                {AccessKey().Initialize(v1, v2, v3, v4, v5, v6, v7, v8);}
1576
1617
 
1577
1618
#endif
1578
1619
};
1597
1638
        typedef STANDARD Standard;
1598
1639
        typedef TF_CryptoSchemeOptions<ALG_INFO, KEYS, MessageEncodingMethod> SchemeOptions;
1599
1640
 
1600
 
        static std::string CRYPTOPP_API StaticAlgorithmName() {return std::string(KEYS::StaticAlgorithmName()) + "/" + MessageEncodingMethod::StaticAlgorithmName();}
 
1641
        static std::string StaticAlgorithmName() {return KEYS::StaticAlgorithmName() + "/" + MessageEncodingMethod::StaticAlgorithmName();}
1601
1642
 
1602
1643
        //! implements PK_Decryptor interface
1603
1644
        typedef PK_FinalTemplate<TF_DecryptorImpl<SchemeOptions> > Decryptor;
1618
1659
        typedef typename Standard::SignatureMessageEncodingMethod MessageEncodingMethod;
1619
1660
        typedef TF_SignatureSchemeOptions<ALG_INFO, KEYS, MessageEncodingMethod, H> SchemeOptions;
1620
1661
 
1621
 
        static std::string CRYPTOPP_API StaticAlgorithmName() {return std::string(KEYS::StaticAlgorithmName()) + "/" + MessageEncodingMethod::StaticAlgorithmName() + "(" + H::StaticAlgorithmName() + ")";}
 
1662
        static std::string StaticAlgorithmName() {return KEYS::StaticAlgorithmName() + "/" + MessageEncodingMethod::StaticAlgorithmName() + "(" + H::StaticAlgorithmName() + ")";}
1622
1663
 
1623
1664
        //! implements PK_Signer interface
1624
1665
        typedef PK_FinalTemplate<TF_SignerImpl<SchemeOptions> > Signer;