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
132
133
|
/*
* Diffie-Hellman
* (C) 1999-2007 Jack Lloyd
*
* Botan is released under the Simplified BSD License (see license.txt)
*/
#include <botan/internal/pk_utils.h>
#include <botan/dh.h>
#include <botan/workfactor.h>
#include <botan/pow_mod.h>
#include <botan/blinding.h>
#if defined(BOTAN_HAS_SYSTEM_RNG)
#include <botan/system_rng.h>
#else
#include <botan/auto_rng.h>
#endif
namespace Botan {
/*
* DH_PublicKey Constructor
*/
DH_PublicKey::DH_PublicKey(const DL_Group& grp, const BigInt& y1)
{
group = grp;
y = y1;
}
/*
* Return the public value for key agreement
*/
std::vector<byte> DH_PublicKey::public_value() const
{
return unlock(BigInt::encode_1363(y, group_p().bytes()));
}
/*
* Create a DH private key
*/
DH_PrivateKey::DH_PrivateKey(RandomNumberGenerator& rng,
const DL_Group& grp,
const BigInt& x_arg)
{
group = grp;
x = x_arg;
if(x == 0)
{
const BigInt& p = group_p();
x.randomize(rng, 2 * dl_work_factor(p.bits()));
}
if(y == 0)
y = power_mod(group_g(), x, group_p());
if(x == 0)
gen_check(rng);
else
load_check(rng);
}
/*
* Load a DH private key
*/
DH_PrivateKey::DH_PrivateKey(const AlgorithmIdentifier& alg_id,
const secure_vector<byte>& key_bits,
RandomNumberGenerator& rng) :
DL_Scheme_PrivateKey(alg_id, key_bits, DL_Group::ANSI_X9_42)
{
if(y == 0)
y = power_mod(group_g(), x, group_p());
load_check(rng);
}
/*
* Return the public value for key agreement
*/
std::vector<byte> DH_PrivateKey::public_value() const
{
return DH_PublicKey::public_value();
}
namespace {
/**
* DH operation
*/
class DH_KA_Operation : public PK_Ops::Key_Agreement
{
public:
typedef DH_PrivateKey Key_Type;
DH_KA_Operation(const DH_PrivateKey& key, const std::string&);
secure_vector<byte> agree(const byte w[], size_t w_len);
private:
const BigInt& p;
Fixed_Exponent_Power_Mod powermod_x_p;
Blinder blinder;
};
DH_KA_Operation::DH_KA_Operation(const DH_PrivateKey& dh, const std::string&) :
p(dh.group_p()), powermod_x_p(dh.get_x(), p)
{
#if defined(BOTAN_HAS_SYSTEM_RNG)
auto& rng = system_rng();
#else
AutoSeeded_RNG rng;
#endif
BigInt k(rng, p.bits() - 1);
blinder = Blinder(k, powermod_x_p(inverse_mod(k, p)), p);
}
secure_vector<byte> DH_KA_Operation::agree(const byte w[], size_t w_len)
{
BigInt input = BigInt::decode(w, w_len);
if(input <= 1 || input >= p - 1)
throw Invalid_Argument("DH agreement - invalid key provided");
BigInt r = blinder.unblind(powermod_x_p(blinder.blind(input)));
return BigInt::encode_1363(r, p.bytes());
}
}
BOTAN_REGISTER_PK_KEY_AGREE_OP("DH", DH_KA_Operation);
}
|
