Botan 3.14.1
Crypto and TLS for C&
dl_scheme.cpp
Go to the documentation of this file.
1/*
2* (C) 2023 Jack Lloyd
3*
4* Botan is released under the Simplified BSD License (see license.txt)
5*/
6
7#include <botan/internal/dl_scheme.h>
8
9#include <botan/ber_dec.h>
10#include <botan/der_enc.h>
11#include <botan/exceptn.h>
12#include <botan/internal/ct_utils.h>
13
14namespace Botan {
15
16namespace {
17
18BigInt decode_single_bigint(std::span<const uint8_t> key_bits) {
19 BigInt x;
21 return x;
22}
23
24// If false, private keys are chosen uniformly in [2, q)
25bool uses_short_exponents(const DL_Group& group) {
26 return !(group.has_q() && group.q_bits() >= 160 && group.q_bits() <= 384);
27}
28
29BigInt generate_private_dl_key(const DL_Group& group, RandomNumberGenerator& rng) {
30 if(uses_short_exponents(group)) {
31 return CT::driveby_poison(BigInt(rng, group.exponent_bits()));
32 } else {
33 return CT::driveby_poison(BigInt::random_integer(rng, BigInt::from_s32(2), group.get_q()));
34 }
35}
36
37BigInt check_dl_private_key_input(const BigInt& x, const DL_Group& group) {
38 if(!group.verify_private_element(x)) {
39 throw Decoding_Error("Invalid DL private key");
40 }
41 return CT::driveby_poison(BigInt(x));
42}
43
44/*
45* A public upper bound on the bit length of x. This reveals which of these
46* ranges x is in, which for keys we generated is determined by the group.
47*/
48size_t dl_private_key_max_bits(const BigInt& x, const DL_Group& group) {
49 const size_t exp_bits = group.exponent_bits();
50 if(uses_short_exponents(group) && CT::driveby_unpoison(x < BigInt::power_of_2(exp_bits))) {
51 return exp_bits;
52 }
53 if(group.has_q() && CT::driveby_unpoison(x < group.get_q())) {
54 return group.q_bits();
55 }
56 return group.p_bits();
57}
58
59BigInt check_dl_public_key_input(const BigInt& y, const DL_Group& group) {
60 // The subgroup check (y^q == 1 mod p) is deferred to check_key() since it can be expensive
61 if(y <= 1 || y >= group.get_p() - 1) {
62 throw Decoding_Error("Invalid DL public key");
63 }
64 return y;
65}
66
67} // namespace
68
70 m_group(group), m_public_key(check_dl_public_key_input(public_key, m_group)) {}
71
73 std::span<const uint8_t> key_bits,
74 DL_Group_Format format) :
75 m_group(alg_id.parameters(), format),
76 m_public_key(check_dl_public_key_input(decode_single_bigint(key_bits), m_group)) {}
77
78std::vector<uint8_t> DL_PublicKey::public_key_as_bytes() const {
79 return m_public_key.serialize(m_group.p_bytes());
80}
81
82std::vector<uint8_t> DL_PublicKey::DER_encode() const {
83 std::vector<uint8_t> output;
84 DER_Encoder(output).encode(m_public_key);
85 return output;
86}
87
88bool DL_PublicKey::check_key(RandomNumberGenerator& rng, bool strong) const {
89 return m_group.verify_group(rng, strong) && m_group.verify_public_element(m_public_key);
90}
91
93 return m_group.estimated_strength();
94}
95
96size_t DL_PublicKey::p_bits() const {
97 return m_group.p_bits();
98}
99
101 m_group(group),
102 m_private_key(check_dl_private_key_input(private_key, m_group)),
103 m_max_private_key_bits(dl_private_key_max_bits(m_private_key, m_group)),
104 m_public_key(m_group.power_g_p(m_private_key, m_max_private_key_bits)) {
105 CT::unpoison_all(m_private_key, m_public_key);
106}
107
109 m_group(group),
110 m_private_key(generate_private_dl_key(group, rng)),
111 m_max_private_key_bits(dl_private_key_max_bits(m_private_key, m_group)),
112 m_public_key(m_group.power_g_p(m_private_key, m_max_private_key_bits)) {
113 CT::unpoison_all(m_private_key, m_public_key);
114}
115
117 std::span<const uint8_t> key_bits,
118 DL_Group_Format format) :
119 m_group(alg_id.parameters(), format),
120 m_private_key(check_dl_private_key_input(decode_single_bigint(key_bits), m_group)),
121 m_max_private_key_bits(dl_private_key_max_bits(m_private_key, m_group)),
122 m_public_key(m_group.power_g_p(m_private_key, m_max_private_key_bits)) {
123 CT::unpoison_all(m_private_key, m_public_key);
124}
125
129
131 return m_private_key.serialize<secure_vector<uint8_t>>();
132}
133
134bool DL_PrivateKey::check_key(RandomNumberGenerator& rng, bool strong) const {
135 return m_group.verify_group(rng, strong) && m_group.verify_private_element(m_private_key);
136}
137
138std::shared_ptr<DL_PublicKey> DL_PrivateKey::public_key() const {
139 return std::make_shared<DL_PublicKey>(m_group, m_public_key);
140}
141
142const BigInt& DL_PublicKey::get_int_field(std::string_view algo, std::string_view field) const {
143 if(field == "p") {
144 return m_group.get_p();
145 } else if(field == "q") {
146 return m_group.get_q();
147 } else if(field == "g") {
148 return m_group.get_g();
149 } else if(field == "y") {
150 return m_public_key;
151 } else {
152 throw Unknown_PK_Field_Name(algo, field);
153 }
154}
155
156const BigInt& DL_PrivateKey::get_int_field(std::string_view algo, std::string_view field) const {
157 if(field == "p") {
158 return m_group.get_p();
159 } else if(field == "q") {
160 return m_group.get_q();
161 } else if(field == "g") {
162 return m_group.get_g();
163 } else if(field == "x") {
164 return m_private_key;
165 } else if(field == "y") {
166 return m_public_key;
167 } else {
168 throw Unknown_PK_Field_Name(algo, field);
169 }
170}
171
172} // namespace Botan
static Limits DER()
Definition ber_dec.h:44
BER_Decoder & decode(bool &out)
Definition ber_dec.h:361
BER_Decoder & verify_end()
Definition ber_dec.cpp:471
static BigInt random_integer(RandomNumberGenerator &rng, const BigInt &min, const BigInt &max)
Definition big_rand.cpp:45
static BigInt power_of_2(size_t n)
Definition bigint.h:906
static BigInt from_s32(int32_t n)
Definition bigint.cpp:43
secure_vector< uint8_t > get_contents()
Definition der_enc.cpp:161
DER_Encoder & encode(bool b)
Definition der_enc.cpp:313
DL_PrivateKey(const DL_Group &group, const BigInt &private_key)
const BigInt & private_key() const
Definition dl_scheme.h:72
secure_vector< uint8_t > DER_encode() const
const BigInt & get_int_field(std::string_view algo_name, std::string_view field) const
secure_vector< uint8_t > raw_private_key_bits() const
const DL_Group & group() const
Definition dl_scheme.h:67
std::shared_ptr< DL_PublicKey > public_key() const
bool check_key(RandomNumberGenerator &rng, bool strong) const
std::vector< uint8_t > public_key_as_bytes() const
Definition dl_scheme.cpp:78
const BigInt & get_int_field(std::string_view algo_name, std::string_view field) const
size_t p_bits() const
Definition dl_scheme.cpp:96
size_t estimated_strength() const
Definition dl_scheme.cpp:92
std::vector< uint8_t > DER_encode() const
Definition dl_scheme.cpp:82
bool check_key(RandomNumberGenerator &rng, bool strong) const
Definition dl_scheme.cpp:88
const BigInt & public_key() const
Definition dl_scheme.h:31
DL_PublicKey(const DL_Group &group, const BigInt &public_key)
Definition dl_scheme.cpp:69
const DL_Group & group() const
Definition dl_scheme.h:29
constexpr decltype(auto) driveby_unpoison(T &&v)
Definition ct_utils.h:243
constexpr void unpoison_all(const Ts &... ts)
Definition ct_utils.h:207
constexpr decltype(auto) driveby_poison(T &&v)
Definition ct_utils.h:232
DL_Group_Format
Definition dl_group.h:30
std::vector< T, secure_allocator< T > > secure_vector
Definition secmem.h:128