← Back to branch summary

~zooko/cryptopp/trunk

« back to all changes in this revision

Viewing changes to strciphr.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:
strciphr.h
14
14
        (since it's an additive cipher, i.e., it xors a keystream into the plaintext).
15
15
        See this line in seal.h:
16
16
 
17
 
        typedef SymmetricCipherFinal\<ConcretePolicyHolder\<SEAL_Policy\<B\>, AdditiveCipherTemplate\<\> \> \> Encryption;
 
17
        typedef SymmetricCipherFinal<ConcretePolicyHolder<SEAL_Policy<B>, AdditiveCipherTemplate<> > > Encryption;
18
18
 
19
19
        AdditiveCipherTemplate and CFB_CipherTemplate are designed so that they don't need
20
20
        to take a policy class as a template parameter (although this is allowed), so that
60
60
        virtual unsigned int GetAlignment() const =0;
61
61
        virtual unsigned int GetBytesPerIteration() const =0;
62
62
        virtual unsigned int GetIterationsToBuffer() const =0;
63
 
        virtual void WriteKeystream(byte *keystreamBuffer, size_t iterationCount) =0;
 
63
        virtual void WriteKeystream(byte *keystreamBuffer, unsigned int iterationCount) =0;
64
64
        virtual bool CanOperateKeystream() const {return false;}
65
 
        virtual void OperateKeystream(KeystreamOperation operation, byte *output, const byte *input, size_t iterationCount) {assert(false);}
66
 
        virtual void CipherSetKey(const NameValuePairs &params, const byte *key, size_t length) =0;
 
65
        virtual void OperateKeystream(KeystreamOperation operation, byte *output, const byte *input, unsigned int iterationCount) {assert(false);}
 
66
        virtual void CipherSetKey(const NameValuePairs &params, const byte *key, unsigned int length) =0;
67
67
        virtual void CipherResynchronize(byte *keystreamBuffer, const byte *iv) {throw NotImplemented("StreamTransformation: this object doesn't support resynchronization");}
68
68
        virtual bool IsRandomAccess() const =0;
69
69
        virtual void SeekToIteration(lword iterationCount) {assert(!IsRandomAccess()); throw NotImplemented("StreamTransformation: this object doesn't support random access");}
77
77
        unsigned int GetAlignment() const {return sizeof(WordType);}
78
78
        unsigned int GetBytesPerIteration() const {return sizeof(WordType) * W;}
79
79
        unsigned int GetIterationsToBuffer() const {return X;}
80
 
        void WriteKeystream(byte *buffer, size_t iterationCount)
 
80
        void WriteKeystream(byte *buffer, unsigned int iterationCount)
81
81
                {OperateKeystream(WRITE_KEYSTREAM, buffer, NULL, iterationCount);}
82
82
        bool CanOperateKeystream() const {return true;}
83
 
        virtual void OperateKeystream(KeystreamOperation operation, byte *output, const byte *input, size_t iterationCount) =0;
 
83
        virtual void OperateKeystream(KeystreamOperation operation, byte *output, const byte *input, unsigned int iterationCount) =0;
84
84
 
85
85
        template <class B>
86
86
        struct KeystreamOutput
122
122
{
123
123
public:
124
124
    byte GenerateByte();
125
 
    void ProcessData(byte *outString, const byte *inString, size_t length);
 
125
    void ProcessData(byte *outString, const byte *inString, unsigned int length);
126
126
        void Resynchronize(const byte *iv);
127
 
        unsigned int OptimalBlockSize() const {return this->GetPolicy().GetBytesPerIteration();}
128
 
        unsigned int GetOptimalNextBlockSize() const {return (unsigned int)this->m_leftOver;}
129
 
        unsigned int OptimalDataAlignment() const {return this->GetPolicy().GetAlignment();}
 
127
        unsigned int OptimalBlockSize() const {return GetPolicy().GetBytesPerIteration();}
 
128
        unsigned int GetOptimalNextBlockSize() const {return m_leftOver;}
 
129
        unsigned int OptimalDataAlignment() const {return GetPolicy().GetAlignment();}
130
130
        bool IsSelfInverting() const {return true;}
131
131
        bool IsForwardTransformation() const {return true;}
132
 
        bool IsRandomAccess() const {return this->GetPolicy().IsRandomAccess();}
 
132
        bool IsRandomAccess() const {return GetPolicy().IsRandomAccess();}
133
133
        void Seek(lword position);
134
134
 
135
135
        typedef typename BASE::PolicyInterface PolicyInterface;
139
139
 
140
140
        unsigned int GetBufferByteSize(const PolicyInterface &policy) const {return policy.GetBytesPerIteration() * policy.GetIterationsToBuffer();}
141
141
 
142
 
        inline byte * KeystreamBufferBegin() {return this->m_buffer.data();}
143
 
        inline byte * KeystreamBufferEnd() {return (this->m_buffer.data() + this->m_buffer.size());}
 
142
        inline byte * KeystreamBufferBegin() {return m_buffer.data();}
 
143
        inline byte * KeystreamBufferEnd() {return (m_buffer.data() + m_buffer.size());}
144
144
 
145
145
        SecByteBlock m_buffer;
146
 
        size_t m_leftOver;
 
146
        unsigned int m_leftOver;
147
147
};
148
148
 
 
149
CRYPTOPP_DLL_TEMPLATE_CLASS TwoBases<SymmetricCipher, RandomNumberGenerator>;
 
150
CRYPTOPP_DLL_TEMPLATE_CLASS AbstractPolicyHolder<AdditiveCipherAbstractPolicy, TwoBases<SymmetricCipher, RandomNumberGenerator> >;
 
151
CRYPTOPP_DLL_TEMPLATE_CLASS AdditiveCipherTemplate<>;
 
152
 
149
153
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CFB_CipherAbstractPolicy
150
154
{
151
155
public:
154
158
        virtual byte * GetRegisterBegin() =0;
155
159
        virtual void TransformRegister() =0;
156
160
        virtual bool CanIterate() const {return false;}
157
 
        virtual void Iterate(byte *output, const byte *input, CipherDir dir, size_t iterationCount) {assert(false);}
158
 
        virtual void CipherSetKey(const NameValuePairs &params, const byte *key, size_t length) =0;
 
161
        virtual void Iterate(byte *output, const byte *input, CipherDir dir, unsigned int iterationCount) {assert(false);}
 
162
        virtual void CipherSetKey(const NameValuePairs &params, const byte *key, unsigned int length) =0;
159
163
        virtual void CipherResynchronize(const byte *iv) {throw NotImplemented("StreamTransformation: this object doesn't support resynchronization");}
160
164
};
161
165
 
167
171
        unsigned int GetAlignment() const {return sizeof(WordType);}
168
172
        unsigned int GetBytesPerIteration() const {return sizeof(WordType) * W;}
169
173
        bool CanIterate() const {return true;}
170
 
        void TransformRegister() {this->Iterate(NULL, NULL, ENCRYPTION, 1);}
 
174
        void TransformRegister() {Iterate(NULL, NULL, ENCRYPTION, 1);}
171
175
 
172
176
        template <class B>
173
177
        struct RegisterOutput
185
189
 
186
190
                        if (m_dir == ENCRYPTION)
187
191
                        {
188
 
                                if (m_input == NULL)
189
 
                                        assert(m_output == NULL);
190
 
                                else
191
 
                                {
192
 
                                        WordType ct = *(const WordType *)m_input ^ registerWord;
193
 
                                        registerWord = ct;
194
 
                                        *(WordType*)m_output = ct;
195
 
                                        m_input += sizeof(WordType);
196
 
                                        m_output += sizeof(WordType);
197
 
                                }
 
192
                                WordType ct = *(const WordType *)m_input ^ registerWord;
 
193
                                registerWord = ct;
 
194
                                *(WordType*)m_output = ct;
 
195
                                m_input += sizeof(WordType);
 
196
                                m_output += sizeof(WordType);
198
197
                        }
199
198
                        else
200
199
                        {
220
219
class CRYPTOPP_NO_VTABLE CFB_CipherTemplate : public BASE
221
220
{
222
221
public:
223
 
        void ProcessData(byte *outString, const byte *inString, size_t length);
 
222
        void ProcessData(byte *outString, const byte *inString, unsigned int length);
224
223
        void Resynchronize(const byte *iv);
225
 
        unsigned int OptimalBlockSize() const {return this->GetPolicy().GetBytesPerIteration();}
226
 
        unsigned int GetOptimalNextBlockSize() const {return (unsigned int)m_leftOver;}
227
 
        unsigned int OptimalDataAlignment() const {return this->GetPolicy().GetAlignment();}
 
224
        unsigned int OptimalBlockSize() const {return GetPolicy().GetBytesPerIteration();}
 
225
        unsigned int GetOptimalNextBlockSize() const {return m_leftOver;}
 
226
        unsigned int OptimalDataAlignment() const {return GetPolicy().GetAlignment();}
228
227
        bool IsRandomAccess() const {return false;}
229
228
        bool IsSelfInverting() const {return false;}
230
229
 
231
230
        typedef typename BASE::PolicyInterface PolicyInterface;
232
231
 
233
232
protected:
234
 
        virtual void CombineMessageAndShiftRegister(byte *output, byte *reg, const byte *message, size_t length) =0;
 
233
        virtual void CombineMessageAndShiftRegister(byte *output, byte *reg, const byte *message, unsigned int length) =0;
235
234
 
236
235
        void UncheckedSetKey(const NameValuePairs &params, const byte *key, unsigned int length, const byte *iv);
237
236
 
238
 
        size_t m_leftOver;
 
237
        unsigned int m_leftOver;
239
238
};
240
239
 
241
240
template <class BASE = AbstractPolicyHolder<CFB_CipherAbstractPolicy, SymmetricCipher> >
242
241
class CRYPTOPP_NO_VTABLE CFB_EncryptionTemplate : public CFB_CipherTemplate<BASE>
243
242
{
244
243
        bool IsForwardTransformation() const {return true;}
245
 
        void CombineMessageAndShiftRegister(byte *output, byte *reg, const byte *message, size_t length);
 
244
        void CombineMessageAndShiftRegister(byte *output, byte *reg, const byte *message, unsigned int length);
246
245
};
247
246
 
248
247
template <class BASE = AbstractPolicyHolder<CFB_CipherAbstractPolicy, SymmetricCipher> >
249
248
class CRYPTOPP_NO_VTABLE CFB_DecryptionTemplate : public CFB_CipherTemplate<BASE>
250
249
{
251
250
        bool IsForwardTransformation() const {return false;}
252
 
        void CombineMessageAndShiftRegister(byte *output, byte *reg, const byte *message, size_t length);
253
 
};
254
 
 
255
 
template <class BASE>
256
 
class CFB_RequireFullDataBlocks : public BASE
257
 
{
258
 
public:
259
 
        unsigned int MandatoryBlockSize() const {return this->OptimalBlockSize();}
260
 
};
261
 
 
262
 
//! _
 
251
        void CombineMessageAndShiftRegister(byte *output, byte *reg, const byte *message, unsigned int length);
 
252
};
 
253
 
 
254
CRYPTOPP_DLL_TEMPLATE_CLASS AbstractPolicyHolder<CFB_CipherAbstractPolicy, SymmetricCipher>;
 
255
CRYPTOPP_DLL_TEMPLATE_CLASS CFB_CipherTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, SymmetricCipher> >;
 
256
CRYPTOPP_DLL_TEMPLATE_CLASS CFB_EncryptionTemplate<>;
 
257
CRYPTOPP_DLL_TEMPLATE_CLASS CFB_DecryptionTemplate<>;
 
258
 
263
259
template <class BASE, class INFO = BASE>
264
260
class SymmetricCipherFinal : public AlgorithmImpl<SimpleKeyingInterfaceImpl<BASE, INFO>, INFO>
265
261
{
266
262
public:
267
263
        SymmetricCipherFinal() {}
268
264
        SymmetricCipherFinal(const byte *key)
269
 
                {SetKey(key, this->DEFAULT_KEYLENGTH);}
270
 
        SymmetricCipherFinal(const byte *key, size_t length)
 
265
                {SetKey(key, DEFAULT_KEYLENGTH);}
 
266
        SymmetricCipherFinal(const byte *key, unsigned int length)
271
267
                {SetKey(key, length);}
272
 
        SymmetricCipherFinal(const byte *key, size_t length, const byte *iv)
273
 
                {this->SetKeyWithIV(key, length, iv);}
 
268
        SymmetricCipherFinal(const byte *key, unsigned int length, const byte *iv)
 
269
                {SetKeyWithIV(key, length, iv);}
274
270
 
275
 
        void SetKey(const byte *key, size_t length, const NameValuePairs &params = g_nullNameValuePairs)
 
271
        void SetKey(const byte *key, unsigned int length, const NameValuePairs &params = g_nullNameValuePairs)
276
272
        {
277
 
                this->ThrowIfInvalidKeyLength(length);
278
 
                this->UncheckedSetKey(params, key, (unsigned int)length, this->GetIVAndThrowIfInvalid(params));
 
273
                ThrowIfInvalidKeyLength(length);
 
274
                UncheckedSetKey(params, key, length, GetIVAndThrowIfInvalid(params));
279
275
        }
280
276
 
281
277
        Clonable * Clone() const {return static_cast<SymmetricCipher *>(new SymmetricCipherFinal<BASE, INFO>(*this));}
284
280
template <class S>
285
281
void AdditiveCipherTemplate<S>::UncheckedSetKey(const NameValuePairs &params, const byte *key, unsigned int length, const byte *iv)
286
282
{
287
 
        PolicyInterface &policy = this->AccessPolicy();
 
283
        PolicyInterface &policy = AccessPolicy();
288
284
        policy.CipherSetKey(params, key, length);
289
285
        m_leftOver = 0;
290
286
        m_buffer.New(GetBufferByteSize(policy));
291
287
 
292
 
        if (this->IsResynchronizable())
 
288
        if (IsResynchronizable())
293
289
                policy.CipherResynchronize(m_buffer, iv);
294
290
}
295
291
 
296
292
template <class BASE>
297
293
void CFB_CipherTemplate<BASE>::UncheckedSetKey(const NameValuePairs &params, const byte *key, unsigned int length, const byte *iv)
298
294
{
299
 
        PolicyInterface &policy = this->AccessPolicy();
 
295
        PolicyInterface &policy = AccessPolicy();
300
296
        policy.CipherSetKey(params, key, length);
301
297
 
302
 
        if (this->IsResynchronizable())
 
298
        if (IsResynchronizable())
303
299
                policy.CipherResynchronize(iv);
304
300
 
305
301
        m_leftOver = policy.GetBytesPerIteration();
307
303
 
308
304
NAMESPACE_END
309
305
 
310
 
#ifdef CRYPTOPP_MANUALLY_INSTANTIATE_TEMPLATES
311
 
#include "strciphr.cpp"
312
 
#endif
313
 
 
314
 
NAMESPACE_BEGIN(CryptoPP)
315
 
CRYPTOPP_DLL_TEMPLATE_CLASS TwoBases<SymmetricCipher, RandomNumberGenerator>;
316
 
CRYPTOPP_DLL_TEMPLATE_CLASS AbstractPolicyHolder<AdditiveCipherAbstractPolicy, TwoBases<SymmetricCipher, RandomNumberGenerator> >;
317
 
CRYPTOPP_DLL_TEMPLATE_CLASS AdditiveCipherTemplate<>;
318
 
CRYPTOPP_DLL_TEMPLATE_CLASS CFB_CipherTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, SymmetricCipher> >;
319
 
CRYPTOPP_DLL_TEMPLATE_CLASS CFB_EncryptionTemplate<>;
320
 
CRYPTOPP_DLL_TEMPLATE_CLASS CFB_DecryptionTemplate<>;
321
 
NAMESPACE_END
322
 
 
323
306
#endif