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
|
/*
* GOST 34.10-2001
* (C) 2007 Falko Strenzke, FlexSecure GmbH
* Manuel Hartl, FlexSecure GmbH
* (C) 2008-2010 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>
#include <botan/pk_ops.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:
/**
* 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) :
EC_PublicKey(dom_par, public_point) {}
/**
* Construct from X.509 algorithm id and subject public key bits
*/
GOST_3410_PublicKey(const AlgorithmIdentifier& alg_id,
const MemoryRegion<byte>& key_bits);
/**
* Get this keys algorithm name.
* @result this keys algorithm name
*/
std::string algo_name() const { return "GOST-34.10"; }
AlgorithmIdentifier algorithm_identifier() const;
MemoryVector<byte> x509_subject_public_key() const;
/**
* 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 { return domain().get_order().bits(); }
u32bit message_parts() const { return 2; }
u32bit message_part_size() const
{ return domain().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;
protected:
GOST_3410_PublicKey() {}
};
/**
* 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:
GOST_3410_PrivateKey(const AlgorithmIdentifier& alg_id,
const MemoryRegion<byte>& key_bits) :
EC_PrivateKey(alg_id, key_bits) {}
/**
* Generate a new private key
* @param the domain parameters to used for this key
*/
GOST_3410_PrivateKey(RandomNumberGenerator& rng,
const EC_Domain_Params& domain) :
EC_PrivateKey(rng, domain) {}
/**
* Load a private key
* @param domain parameters
* @param x the private key
*/
GOST_3410_PrivateKey(const EC_Domain_Params& domain, const BigInt& x) :
EC_PrivateKey(domain, x) {}
AlgorithmIdentifier pkcs8_algorithm_identifier() const
{ return EC_PublicKey::algorithm_identifier(); }
};
class BOTAN_DLL GOST_3410_Signature_Operation : public PK_Ops::Signature_Operation
{
public:
GOST_3410_Signature_Operation(const GOST_3410_PrivateKey& gost_3410);
u32bit message_parts() const { return 2; }
u32bit message_part_size() const { return order.bytes(); }
u32bit max_input_bits() const { return order.bits(); }
SecureVector<byte> sign(const byte msg[], u32bit msg_len,
RandomNumberGenerator& rng);
private:
const PointGFp& base_point;
const BigInt& order;
const BigInt& x;
};
class BOTAN_DLL GOST_3410_Verification_Operation : public PK_Ops::Verification
{
public:
GOST_3410_Verification_Operation(const GOST_3410_PublicKey& gost);
u32bit message_parts() const { return 2; }
u32bit message_part_size() const { return order.bytes(); }
u32bit max_input_bits() const { return order.bits(); }
bool with_recovery() const { return false; }
bool verify(const byte msg[], u32bit msg_len,
const byte sig[], u32bit sig_len);
private:
const PointGFp& base_point;
const PointGFp& public_point;
const BigInt& order;
};
}
#endif
|
