← Back to branch summary

~zooko/cryptopp/trunk

« back to all changes in this revision

Viewing changes to default.cpp

  • Committer: weidai
  • Date: 2004-09-03 10:57:31 UTC
  • Revision ID: svn-v4:57ff6487-cd31-0410-9ec3-f628ee90f5f0:trunk/c5:193
changes related to the next FIPS validation

Show diffs side-by-side

added added

removed removed

Lines of Context:
default.cpp
19
19
// deducible from it, and (3) it contains as much entropy as it can hold, or
20
20
// the amount of entropy in the input string, whichever is smaller.
21
21
 
22
 
static void Mash(const byte *in, size_t inLen, byte *out, size_t outLen, int iterations)
 
22
static void Mash(const byte *in, word16 inLen, byte *out, word16 outLen, int iterations)
23
23
{
24
 
        if (BytePrecision(outLen) > 2)
25
 
                throw InvalidArgument("Mash: output legnth too large");
26
 
 
27
 
        size_t bufSize = RoundUpToMultipleOf(outLen, (size_t)DefaultHashModule::DIGESTSIZE);
 
24
        unsigned int bufSize = (outLen-1+DefaultHashModule::DIGESTSIZE-((outLen-1)%DefaultHashModule::DIGESTSIZE));
 
25
 
 
26
        // ASSERT: bufSize == (the smallest multiple of DIGESTSIZE that is >= outLen)
 
27
 
28
28
        byte b[2];
29
29
        SecByteBlock buf(bufSize);
30
30
        SecByteBlock outBuf(bufSize);
33
33
        unsigned int i;
34
34
        for(i=0; i<outLen; i+=DefaultHashModule::DIGESTSIZE)
35
35
        {
36
 
                b[0] = (byte) (i >> 8);
 
36
                b[0] = (byte) i >> 8;
37
37
                b[1] = (byte) i;
38
38
                hash.Update(b, 2);
39
39
                hash.Update(in, inLen);
45
45
                memcpy(buf, outBuf, bufSize);
46
46
                for (i=0; i<bufSize; i+=DefaultHashModule::DIGESTSIZE)
47
47
                {
48
 
                        b[0] = (byte) (i >> 8);
 
48
                        b[0] = (byte) i >> 8;
49
49
                        b[1] = (byte) i;
50
50
                        hash.Update(b, 2);
51
51
                        hash.Update(buf, bufSize);
56
56
        memcpy(out, outBuf, outLen);
57
57
}
58
58
 
59
 
static void GenerateKeyIV(const byte *passphrase, size_t passphraseLength, const byte *salt, size_t saltLength, byte *key, byte *IV)
 
59
static void GenerateKeyIV(const byte *passphrase, unsigned int passphraseLength, const byte *salt, unsigned int saltLength, byte *key, byte *IV)
60
60
{
61
61
        SecByteBlock temp(passphraseLength+saltLength);
62
62
        memcpy(temp, passphrase, passphraseLength);
74
74
{
75
75
}
76
76
 
77
 
DefaultEncryptor::DefaultEncryptor(const byte *passphrase, size_t passphraseLength, BufferedTransformation *attachment)
 
77
DefaultEncryptor::DefaultEncryptor(const byte *passphrase, unsigned int passphraseLength, BufferedTransformation *attachment)
78
78
        : ProxyFilter(NULL, 0, 0, attachment), m_passphrase(passphrase, passphraseLength)
79
79
{
80
80
}
115
115
        m_filter->Put(keyCheck, BLOCKSIZE);
116
116
}
117
117
 
118
 
void DefaultEncryptor::LastPut(const byte *inString, size_t length)
 
118
void DefaultEncryptor::LastPut(const byte *inString, unsigned int length)
119
119
{
120
120
        m_filter->MessageEnd();
121
121
}
130
130
{
131
131
}
132
132
 
133
 
DefaultDecryptor::DefaultDecryptor(const byte *passphrase, size_t passphraseLength, BufferedTransformation *attachment, bool throwException)
 
133
DefaultDecryptor::DefaultDecryptor(const byte *passphrase, unsigned int passphraseLength, BufferedTransformation *attachment, bool throwException)
134
134
        : ProxyFilter(NULL, SALTLENGTH+BLOCKSIZE, 0, attachment)
135
135
        , m_state(WAITING_FOR_KEYCHECK)
136
136
        , m_passphrase(passphrase, passphraseLength)
143
143
        CheckKey(inString, inString+SALTLENGTH);
144
144
}
145
145
 
146
 
void DefaultDecryptor::LastPut(const byte *inString, size_t length)
 
146
void DefaultDecryptor::LastPut(const byte *inString, unsigned int length)
147
147
{
148
148
        if (m_filter.get() == NULL)
149
149
        {
192
192
 
193
193
// ********************************************************
194
194
 
195
 
static DefaultMAC * NewDefaultEncryptorMAC(const byte *passphrase, size_t passphraseLength)
 
195
static DefaultMAC * NewDefaultEncryptorMAC(const byte *passphrase, unsigned int passphraseLength)
196
196
{
197
 
        size_t macKeyLength = DefaultMAC::StaticGetValidKeyLength(16);
 
197
        unsigned int macKeyLength = DefaultMAC::StaticGetValidKeyLength(16);
198
198
        SecByteBlock macKey(macKeyLength);
199
199
        // since the MAC is encrypted there is no reason to mash the passphrase for many iterations
200
200
        Mash(passphrase, passphraseLength, macKey, macKeyLength, 1);
208
208
        SetFilter(new HashFilter(*m_mac, new DefaultEncryptor(passphrase), true));
209
209
}
210
210
 
211
 
DefaultEncryptorWithMAC::DefaultEncryptorWithMAC(const byte *passphrase, size_t passphraseLength, BufferedTransformation *attachment)
 
211
DefaultEncryptorWithMAC::DefaultEncryptorWithMAC(const byte *passphrase, unsigned int passphraseLength, BufferedTransformation *attachment)
212
212
        : ProxyFilter(NULL, 0, 0, attachment)
213
213
        , m_mac(NewDefaultEncryptorMAC(passphrase, passphraseLength))
214
214
{
215
215
        SetFilter(new HashFilter(*m_mac, new DefaultEncryptor(passphrase, passphraseLength), true));
216
216
}
217
217
 
218
 
void DefaultEncryptorWithMAC::LastPut(const byte *inString, size_t length)
 
218
void DefaultEncryptorWithMAC::LastPut(const byte *inString, unsigned int length)
219
219
{
220
220
        m_filter->MessageEnd();
221
221
}
230
230
        SetFilter(new DefaultDecryptor(passphrase, m_hashVerifier=new HashVerifier(*m_mac, NULL, HashVerifier::PUT_MESSAGE), throwException));
231
231
}
232
232
 
233
 
DefaultDecryptorWithMAC::DefaultDecryptorWithMAC(const byte *passphrase, size_t passphraseLength, BufferedTransformation *attachment, bool throwException)
 
233
DefaultDecryptorWithMAC::DefaultDecryptorWithMAC(const byte *passphrase, unsigned int passphraseLength, BufferedTransformation *attachment, bool throwException)
234
234
        : ProxyFilter(NULL, 0, 0, attachment)
235
235
        , m_mac(NewDefaultEncryptorMAC(passphrase, passphraseLength))
236
236
        , m_throwException(throwException)
248
248
        return m_hashVerifier->GetLastResult();
249
249
}
250
250
 
251
 
void DefaultDecryptorWithMAC::LastPut(const byte *inString, size_t length)
 
251
void DefaultDecryptorWithMAC::LastPut(const byte *inString, unsigned int length)
252
252
{
253
253
        m_filter->MessageEnd();
254
254
        if (m_throwException && !CheckLastMAC())