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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
/*
* GOST 34.10-2001
* (C) 2007 Falko Strenzke, FlexSecure GmbH
* Manuel Hartl, FlexSecure GmbH
* (C) 2008-2009 Jack Lloyd
*
* Distributed under the terms of the Botan license
*/
#ifndef BOTAN_GOST_3410_KEY_H__
#define BOTAN_GOST_3410_KEY_H__
#include <botan/ecc_key.h>
namespace Botan {
/**
* This class represents GOST_3410 Public Keys.
*/
class BOTAN_DLL GOST_3410_PublicKey : public virtual EC_PublicKey,
public PK_Verifying_wo_MR_Key
{
public:
/**
* Get this keys algorithm name.
* @result this keys algorithm name
*/
std::string algo_name() const { return "GOST-34.10"; }
/**
* Get the maximum number of bits allowed to be fed to this key.
* This is the bitlength of the order of the base point.
* @result the maximum number of input bits
*/
u32bit max_input_bits() const;
u32bit message_parts() const { return 2; }
u32bit message_part_size() const
{ return mp_dom_pars->get_order().bytes(); }
/**
* Verify a message with this key.
* @param message the byte array containing the message
* @param mess_len the number of bytes in the message byte array
* @param signature the byte array containing the signature
* @param sig_len the number of bytes in the signature byte array
*/
bool verify(const byte message[], u32bit mess_len,
const byte signature[], u32bit sig_len) const;
/**
* Default constructor. Use this one if you want to later fill
* this object with data from an encoded key.
*/
GOST_3410_PublicKey() {}
/**
* Construct a public key from a given public point.
* @param dom_par the domain parameters associated with this key
* @param public_point the public point defining this key
*/
GOST_3410_PublicKey(const EC_Domain_Params& dom_par,
const PointGFp& public_point); // sets core
GOST_3410_PublicKey const& operator=(const GOST_3410_PublicKey& rhs);
GOST_3410_PublicKey(const GOST_3410_PublicKey& other);
/**
* Set the domain parameters of this key. This function has to be
* used when a key encoded without domain parameters was decoded into
* this key. Otherwise it will not be able to verify a signature.
* @param dom_pars the domain_parameters associated with this key
* @throw Invalid_Argument if the point was found not to be satisfying the
* curve equation of the provided domain parameters
* or if this key already has domain parameters set
* and these are differing from those given as the parameter
*/
void set_domain_parameters(const EC_Domain_Params& dom_pars);
/**
* Ensure that the public point and domain parameters of this key are set.
* @throw Invalid_State if either of the two data members is not set
*/
virtual void affirm_init() const;
/**
* Get an x509_encoder that can be used to encode this key.
* @result an x509_encoder for this key
*/
X509_Encoder* x509_encoder() const;
/**
* Get an x509_decoder that can be used to decode a stored key into
* this key.
* @result an x509_decoder for this key
*/
X509_Decoder* x509_decoder();
protected:
void X509_load_hook();
void set_all_values(const GOST_3410_PublicKey& other);
};
/**
* This class represents GOST_3410 Private Keys
*/
class BOTAN_DLL GOST_3410_PrivateKey : public GOST_3410_PublicKey,
public EC_PrivateKey,
public PK_Signing_Key
{
public:
/**
* Default constructor. Use this one if you want to later fill
* this object with data from an encoded key.
*/
GOST_3410_PrivateKey() {}
/**
* Generate a new private key
* @param the domain parameters to used for this key
*/
GOST_3410_PrivateKey(RandomNumberGenerator& rng,
const EC_Domain_Params& domain);
/**
* Load a private key
* @param domain parameters
* @param x the private key
*/
GOST_3410_PrivateKey(const EC_Domain_Params& domain, const BigInt& x);
GOST_3410_PrivateKey(const GOST_3410_PrivateKey& other);
GOST_3410_PrivateKey const& operator=(const GOST_3410_PrivateKey& rhs);
/**
* Sign a message with this key.
* @param message the byte array representing the message to be signed
* @param mess_len the length of the message byte array
* @result the signature
*/
SecureVector<byte> sign(const byte message[], u32bit mess_len,
RandomNumberGenerator& rng) const;
/**
* Make sure that the public key parts of this object are set
* (calls EC_PublicKey::affirm_init()) as well as the private key
* value.
* @throw Invalid_State if the above conditions are not satisfied
*/
virtual void affirm_init() const;
private:
void set_all_values(const GOST_3410_PrivateKey& other);
void PKCS8_load_hook(bool = false);
};
}
#endif
|
