Botan 3.14.1
Crypto and TLS for C&
pk_keys.cpp
Go to the documentation of this file.
1/*
2* PK Key Types
3* (C) 1999-2007 Jack Lloyd
4*
5* Botan is released under the Simplified BSD License (see license.txt)
6*/
7
8#include <botan/pk_keys.h>
9
10#include <botan/assert.h>
11#include <botan/der_enc.h>
12#include <botan/hash.h>
13#include <botan/hex.h>
14#include <botan/pk_ops.h>
15#include <botan/internal/fmt.h>
16#include <botan/internal/pk_options_impl.h>
17
18namespace Botan {
19
20const BigInt& Asymmetric_Key::get_int_field(std::string_view field) const {
21 throw Unknown_PK_Field_Name(algo_name(), field);
22}
23
25 try {
27 } catch(Lookup_Error&) {
28 throw Lookup_Error(fmt("Public key algorithm {} has no defined OIDs", algo_name()));
29 }
30}
31
39
40std::string create_hex_fingerprint(std::span<const uint8_t> bits, std::string_view hash_name) {
41 auto hash_fn = HashFunction::create_or_throw(hash_name);
42 hash_fn->update(bits);
43 auto digest = hash_fn->final_stdvec();
44 return format_hex_fingerprint(digest);
45}
46
47std::string format_hex_fingerprint(std::span<const uint8_t> bits) {
48 const std::string hex = hex_encode(bits);
49
50 std::string fprint;
51 fprint.reserve(3 * bits.size());
52
53 for(size_t i = 0; i != hex.size(); i += 2) {
54 if(i != 0) {
55 fprint.push_back(':');
56 }
57
58 fprint.push_back(hex[i]);
59 fprint.push_back(hex[i + 1]);
60 }
61
62 return fprint;
63}
64
65std::vector<uint8_t> Public_Key::subject_public_key() const {
66 std::vector<uint8_t> output;
67
68 DER_Encoder(output)
72 .end_cons();
73
74 return output;
75}
76
78 const size_t PKCS8_VERSION = 0;
79
80 return DER_Encoder()
82 .encode(PKCS8_VERSION)
85 .end_cons()
86 .get_contents();
87}
88
90 throw Not_Implemented(algo_name() + " does not implement raw_private_key_bits");
91}
92
93/*
94* Hash of the X.509 subjectPublicKey encoding
95*/
96std::string Public_Key::fingerprint_public(std::string_view hash_algo) const {
97 return create_hex_fingerprint(subject_public_key(), hash_algo);
98}
99
100/*
101* Hash of the PKCS #8 encoding for this key object
102*/
103std::string Private_Key::fingerprint_private(std::string_view hash_algo) const {
104 return create_hex_fingerprint(private_key_bits(), hash_algo);
105}
106
107std::unique_ptr<PK_Ops::Encryption> Public_Key::_create_encryption_op(
108 RandomNumberGenerator& rng, const PK_Encryption_Options_Reader& options) const {
109 BOTAN_UNUSED(rng, options);
110 throw Lookup_Error(fmt("{} does not support encryption", algo_name()));
111}
112
113std::unique_ptr<PK_Ops::KEM_Encryption> Public_Key::_create_kem_encryption_op(
114 const PK_KEM_Options_Reader& options) const {
115 BOTAN_UNUSED(options);
116 throw Lookup_Error(fmt("{} does not support KEM encryption", algo_name()));
117}
118
119std::unique_ptr<PK_Ops::Verification> Public_Key::_create_verification_op(
120 const PK_Signature_Options_Reader& options) const {
121 BOTAN_UNUSED(options);
122 throw Lookup_Error(fmt("{} does not support verification", algo_name()));
123}
124
125std::unique_ptr<PK_Ops::Verification> Public_Key::create_x509_verification_op(const AlgorithmIdentifier& /*params*/,
126 std::string_view /*provider*/) const {
127 throw Lookup_Error(fmt("{} does not support X.509 verification", algo_name()));
128}
129
130std::unique_ptr<PK_Ops::Decryption> Private_Key::_create_decryption_op(
131 RandomNumberGenerator& rng, const PK_Encryption_Options_Reader& options) const {
132 BOTAN_UNUSED(rng, options);
133 throw Lookup_Error(fmt("{} does not support decryption", algo_name()));
134}
135
136std::unique_ptr<PK_Ops::KEM_Decryption> Private_Key::_create_kem_decryption_op(
137 RandomNumberGenerator& rng, const PK_KEM_Options_Reader& options) const {
138 BOTAN_UNUSED(rng, options);
139 throw Lookup_Error(fmt("{} does not support KEM decryption", algo_name()));
140}
141
142std::unique_ptr<PK_Ops::Signature> Private_Key::_create_signature_op(RandomNumberGenerator& rng,
143 const PK_Signature_Options_Reader& options) const {
144 BOTAN_UNUSED(rng, options);
145 throw Lookup_Error(fmt("{} does not support signatures", algo_name()));
146}
147
148std::unique_ptr<PK_Ops::Key_Agreement> Private_Key::_create_key_agreement_op(
149 RandomNumberGenerator& rng, const PK_Key_Agreement_Options_Reader& options) const {
150 BOTAN_UNUSED(rng, options);
151 throw Lookup_Error(fmt("{} does not support key agreement", algo_name()));
152}
153
154// Forwarding functions for compat
155
156std::unique_ptr<PK_Ops::Verification> Public_Key::create_verification_op(std::string_view params,
157 std::string_view provider) const {
158 const auto options = parse_legacy_sig_options(*this, params).with_provider(provider);
159 const auto reader = PK_Options_Reader_Access::for_verification(options);
160 auto op = this->_create_verification_op(reader);
162 return op;
163}
164
165std::unique_ptr<PK_Ops::Signature> Private_Key::create_signature_op(RandomNumberGenerator& rng,
166 std::string_view params,
167 std::string_view provider) const {
168 const auto options = parse_legacy_sig_options(*this, params).with_provider(provider);
169 const auto reader = PK_Options_Reader_Access::for_signing(options);
170 auto op = this->_create_signature_op(rng, reader);
172 return op;
173}
174
175std::unique_ptr<PK_Ops::Encryption> Public_Key::create_encryption_op(RandomNumberGenerator& rng,
176 std::string_view params,
177 std::string_view provider) const {
178 const auto options = parse_legacy_enc_options(*this, params).with_provider(provider);
179 const auto reader = PK_Options_Reader_Access::read(options);
180 auto op = this->_create_encryption_op(rng, reader);
182 return op;
183}
184
185std::unique_ptr<PK_Ops::Decryption> Private_Key::create_decryption_op(RandomNumberGenerator& rng,
186 std::string_view params,
187 std::string_view provider) const {
188 const auto options = parse_legacy_enc_options(*this, params).with_provider(provider);
189 const auto reader = PK_Options_Reader_Access::read(options);
190 auto op = this->_create_decryption_op(rng, reader);
192 return op;
193}
194
195std::unique_ptr<PK_Ops::KEM_Encryption> Public_Key::create_kem_encryption_op(std::string_view params,
196 std::string_view provider) const {
197 const auto options = parse_legacy_kem_options(params).with_provider(provider);
198 const auto reader = PK_Options_Reader_Access::read(options);
199 auto op = this->_create_kem_encryption_op(reader);
201 return op;
202}
203
204std::unique_ptr<PK_Ops::KEM_Decryption> Private_Key::create_kem_decryption_op(RandomNumberGenerator& rng,
205 std::string_view params,
206 std::string_view provider) const {
207 const auto options = parse_legacy_kem_options(params).with_provider(provider);
208 const auto reader = PK_Options_Reader_Access::read(options);
209 auto op = this->_create_kem_decryption_op(rng, reader);
211 return op;
212}
213
214std::unique_ptr<PK_Ops::Key_Agreement> Private_Key::create_key_agreement_op(RandomNumberGenerator& rng,
215 std::string_view params,
216 std::string_view provider) const {
217 const auto options = parse_legacy_ka_options(params).with_provider(provider);
218 const auto reader = PK_Options_Reader_Access::read(options);
219 auto op = this->_create_key_agreement_op(rng, reader);
221 return op;
222}
223
224} // namespace Botan
#define BOTAN_UNUSED
Definition assert.h:151
virtual std::string algo_name() const =0
virtual const BigInt & get_int_field(std::string_view field) const
Definition pk_keys.cpp:20
virtual OID object_identifier() const
Definition pk_keys.cpp:24
virtual std::optional< size_t > _signature_element_size_for_DER_encoding() const
Definition pk_keys.h:148
virtual Signature_Format _default_x509_signature_format() const
Definition pk_keys.cpp:32
secure_vector< uint8_t > get_contents()
Definition der_enc.cpp:161
DER_Encoder & encode_octet_aligned_bitstring(std::span< const uint8_t > bytes, ASN1_Type type_tag=ASN1_Type::BitString, ASN1_Class class_tag=ASN1_Class::Universal)
Definition der_enc.h:210
DER_Encoder & start_sequence()
Definition der_enc.h:86
DER_Encoder & end_cons()
Definition der_enc.cpp:208
DER_Encoder & encode(bool b)
Definition der_enc.cpp:313
static std::unique_ptr< HashFunction > create_or_throw(std::string_view algo_spec, std::string_view provider="")
Definition hash.cpp:311
static OID from_string(std::string_view str)
Definition asn1_oid.cpp:80
PK_Encryption_Options with_provider(std::string_view provider)
PK_KEM_Options with_provider(std::string_view provider)
PK_Key_Agreement_Options with_provider(std::string_view provider)
static void throw_if_unexamined(const ReaderT &reader, std::string_view algo_name)
static PK_Signature_Options_Reader for_signing(const PK_Signature_Options &options)
static PK_Signature_Options_Reader for_verification(const PK_Signature_Options &options)
static PK_Encryption_Options_Reader read(const PK_Encryption_Options &options)
PK_Signature_Options with_provider(std::string_view provider)
std::unique_ptr< PK_Ops::Signature > create_signature_op(RandomNumberGenerator &rng, std::string_view params, std::string_view provider) const
Definition pk_keys.cpp:165
virtual std::unique_ptr< PK_Ops::Key_Agreement > _create_key_agreement_op(RandomNumberGenerator &rng, const PK_Key_Agreement_Options_Reader &options) const
Definition pk_keys.cpp:148
virtual std::unique_ptr< PK_Ops::Signature > _create_signature_op(RandomNumberGenerator &rng, const PK_Signature_Options_Reader &options) const
Definition pk_keys.cpp:142
virtual std::unique_ptr< PK_Ops::KEM_Decryption > _create_kem_decryption_op(RandomNumberGenerator &rng, const PK_KEM_Options_Reader &options) const
Definition pk_keys.cpp:136
std::string fingerprint_private(std::string_view alg) const
Definition pk_keys.cpp:103
std::unique_ptr< PK_Ops::Decryption > create_decryption_op(RandomNumberGenerator &rng, std::string_view params, std::string_view provider) const
Definition pk_keys.cpp:185
std::unique_ptr< PK_Ops::Key_Agreement > create_key_agreement_op(RandomNumberGenerator &rng, std::string_view params, std::string_view provider) const
Definition pk_keys.cpp:214
virtual AlgorithmIdentifier pkcs8_algorithm_identifier() const
Definition pk_keys.h:390
virtual secure_vector< uint8_t > raw_private_key_bits() const
Definition pk_keys.cpp:89
secure_vector< uint8_t > private_key_info() const
Definition pk_keys.cpp:77
std::unique_ptr< PK_Ops::KEM_Decryption > create_kem_decryption_op(RandomNumberGenerator &rng, std::string_view params, std::string_view provider) const
Definition pk_keys.cpp:204
virtual secure_vector< uint8_t > private_key_bits() const =0
virtual std::unique_ptr< PK_Ops::Decryption > _create_decryption_op(RandomNumberGenerator &rng, const PK_Encryption_Options_Reader &options) const
Definition pk_keys.cpp:130
std::string fingerprint_public(std::string_view alg="SHA-256") const
Definition pk_keys.cpp:96
virtual AlgorithmIdentifier algorithm_identifier() const =0
virtual std::vector< uint8_t > public_key_bits() const =0
virtual std::unique_ptr< PK_Ops::Verification > _create_verification_op(const PK_Signature_Options_Reader &options) const
Definition pk_keys.cpp:119
std::unique_ptr< PK_Ops::Encryption > create_encryption_op(RandomNumberGenerator &rng, std::string_view params, std::string_view provider) const
Definition pk_keys.cpp:175
virtual std::unique_ptr< PK_Ops::KEM_Encryption > _create_kem_encryption_op(const PK_KEM_Options_Reader &options) const
Definition pk_keys.cpp:113
std::unique_ptr< PK_Ops::Verification > create_verification_op(std::string_view params, std::string_view provider) const
Definition pk_keys.cpp:156
virtual std::unique_ptr< PK_Ops::Verification > create_x509_verification_op(const AlgorithmIdentifier &signature_algorithm, std::string_view provider) const
Definition pk_keys.cpp:125
std::unique_ptr< PK_Ops::KEM_Encryption > create_kem_encryption_op(std::string_view params, std::string_view provider) const
Definition pk_keys.cpp:195
std::vector< uint8_t > subject_public_key() const
Definition pk_keys.cpp:65
virtual std::unique_ptr< PK_Ops::Encryption > _create_encryption_op(RandomNumberGenerator &rng, const PK_Encryption_Options_Reader &options) const
Definition pk_keys.cpp:107
PK_Encryption_Options parse_legacy_enc_options(const Public_Key &key, std::string_view params)
std::string fmt(std::string_view format, const T &... args)
Definition fmt.h:53
std::string create_hex_fingerprint(std::span< const uint8_t > bits, std::string_view hash_name)
Definition pk_keys.cpp:40
PK_KEM_Options parse_legacy_kem_options(std::string_view params)
PK_Key_Agreement_Options parse_legacy_ka_options(std::string_view params)
PK_Signature_Options parse_legacy_sig_options(const Public_Key &key, std::string_view params)
void hex_encode(char output[], const uint8_t input[], size_t input_length, bool uppercase)
Definition hex.cpp:34
Signature_Format
Definition pk_keys.h:36
std::vector< T, secure_allocator< T > > secure_vector
Definition secmem.h:128
std::string format_hex_fingerprint(std::span< const uint8_t > bits)
Definition pk_keys.cpp:47