1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
/*************************************************
* KDF1/KDF2 Source File *
* (C) 1999-2007 The Botan Project *
*************************************************/
#include <botan/kdf.h>
#include <botan/lookup.h>
#include <botan/loadstor.h>
#include <algorithm>
#include <memory>
namespace Botan {
/*************************************************
* Derive a key *
*************************************************/
SecureVector<byte> KDF::derive_key(u32bit key_len,
const MemoryRegion<byte>& secret,
const std::string& salt) const
{
return derive_key(key_len, secret, secret.size(),
reinterpret_cast<const byte*>(salt.data()),
salt.length());
}
/*************************************************
* Derive a key *
*************************************************/
SecureVector<byte> KDF::derive_key(u32bit key_len,
const MemoryRegion<byte>& secret,
const byte salt[], u32bit salt_len) const
{
return derive_key(key_len, secret.begin(), secret.size(),
salt, salt_len);
}
/*************************************************
* Derive a key *
*************************************************/
SecureVector<byte> KDF::derive_key(u32bit key_len,
const MemoryRegion<byte>& secret,
const MemoryRegion<byte>& salt) const
{
return derive_key(key_len, secret.begin(), secret.size(),
salt.begin(), salt.size());
}
/*************************************************
* Derive a key *
*************************************************/
SecureVector<byte> KDF::derive_key(u32bit key_len,
const byte secret[], u32bit secret_len,
const std::string& salt) const
{
return derive_key(key_len, secret, secret_len,
reinterpret_cast<const byte*>(salt.data()),
salt.length());
}
/*************************************************
* Derive a key *
*************************************************/
SecureVector<byte> KDF::derive_key(u32bit key_len,
const byte secret[], u32bit secret_len,
const byte salt[], u32bit salt_len) const
{
return derive(key_len, secret, secret_len, salt, salt_len);
}
/*************************************************
* KDF1 Key Derivation Mechanism *
*************************************************/
SecureVector<byte> KDF1::derive(u32bit,
const byte secret[], u32bit secret_len,
const byte P[], u32bit P_len) const
{
std::auto_ptr<HashFunction> hash(get_hash(hash_name));
hash->update(secret, secret_len);
hash->update(P, P_len);
return hash->final();
}
/*************************************************
* KDF1 Constructor *
*************************************************/
KDF1::KDF1(const std::string& h_name) : hash_name(h_name)
{
if(!have_hash(hash_name))
throw Algorithm_Not_Found(hash_name);
}
/*************************************************
* KDF2 Key Derivation Mechanism *
*************************************************/
SecureVector<byte> KDF2::derive(u32bit out_len,
const byte secret[], u32bit secret_len,
const byte P[], u32bit P_len) const
{
SecureVector<byte> output;
u32bit counter = 1;
std::auto_ptr<HashFunction> hash(get_hash(hash_name));
while(out_len && counter)
{
hash->update(secret, secret_len);
for(u32bit j = 0; j != 4; ++j)
hash->update(get_byte(j, counter));
hash->update(P, P_len);
SecureVector<byte> hash_result = hash->final();
u32bit added = std::min(hash_result.size(), out_len);
output.push_back(hash_result, added);
out_len -= added;
++counter;
}
return output;
}
/*************************************************
* KDF2 Constructor *
*************************************************/
KDF2::KDF2(const std::string& h_name) : hash_name(h_name)
{
if(!have_hash(hash_name))
throw Algorithm_Not_Found(hash_name);
}
}
|
