7#include <botan/pubkey.h>
9#include <botan/ber_dec.h>
10#include <botan/bigint.h>
11#include <botan/der_enc.h>
12#include <botan/pk_ops.h>
13#include <botan/pk_options_readers.h>
15#include <botan/internal/buffer_slicer.h>
16#include <botan/internal/ct_utils.h>
17#include <botan/internal/fmt.h>
18#include <botan/internal/mem_utils.h>
19#include <botan/internal/pk_options_impl.h>
27 uint8_t valid_mask = 0;
28 const size_t ptext_len = do_decrypt(valid_mask, ptext, {in, length});
34 throw Decoding_Error(
"Invalid public key ciphertext, cannot decrypt");
37 ptext.resize(ptext_len);
43 size_t expected_pt_len,
45 const uint8_t required_content_bytes[],
46 const uint8_t required_content_offsets[],
47 size_t required_contents_length)
const {
51 for(
size_t i = 0; i != required_contents_length; ++i) {
52 const uint8_t exp = required_content_bytes[i];
60 const uint8_t off = required_content_offsets[i];
61 BOTAN_ASSERT(off < expected_pt_len,
"Offset in range of plaintext");
71 uint8_t decrypt_valid = 0;
72 const size_t decoded_len = do_decrypt(decrypt_valid, decoded, {in, length});
77 decoded.resize(expected_pt_len);
79 for(
size_t i = 0; i != required_contents_length; ++i) {
80 const uint8_t exp = required_content_bytes[i];
83 const uint8_t off = required_content_offsets[i];
91 valid_mask.select_n(decoded.data(), decoded.data(), fake_pms.data(), expected_pt_len);
100 size_t expected_pt_len,
107 std::string_view padding,
108 std::string_view provider) :
121 reader.throw_if_unexamined(key.
algo_name());
130 return m_op->ciphertext_length(ptext_len);
133std::vector<uint8_t> PK_Encryptor_EME::enc(
const uint8_t ptext[],
size_t len,
RandomNumberGenerator& rng)
const {
134 return m_op->encrypt(std::span{ptext, len}, rng);
138 return m_op->max_input_bits() / 8;
143 std::string_view padding,
144 std::string_view provider) :
157 reader.throw_if_unexamined(key.
algo_name());
166 return m_op->plaintext_length(ctext_len);
170 return m_op->ciphertext_length(ptext_len);
173size_t PK_Decryptor_EME::do_decrypt(uint8_t& valid_mask,
174 std::span<uint8_t> ptext,
175 std::span<const uint8_t> ctext)
const {
176 return m_op->decrypt(valid_mask, ptext, ctext);
190 reader.throw_if_unexamined(key.
algo_name());
195 std::string_view kem_param,
196 std::string_view provider) :
207 return m_op->shared_key_length(desired_shared_key_len);
211 return m_op->encapsulated_key_length();
215 std::span<uint8_t> out_shared_key,
217 size_t desired_shared_key_len,
218 std::span<const uint8_t> salt) {
221 "not enough space for shared key");
222 m_op->kem_encrypt(out_encapsulated_key, out_shared_key, rng, desired_shared_key_len, salt);
226 return m_op->shared_key_length(desired_shared_key_len);
230 return m_op->encapsulated_key_length();
235 std::string_view param,
236 std::string_view provider) :
247 reader.throw_if_unexamined(key.
algo_name());
256 std::span<const uint8_t> encap_key,
257 size_t desired_shared_key_len,
258 std::span<const uint8_t> salt) {
260 "inconsistent size of shared key output buffer");
261 m_op->kem_decrypt(out_shared_key, encap_key, desired_shared_key_len, salt);
266 std::string_view kdf,
267 std::string_view provider) :
280 reader.throw_if_unexamined(key.
algo_name());
289 return m_op->agreed_value_size();
293 const uint8_t peer_key[],
295 std::string_view salt)
const {
300 const std::span<const uint8_t> peer_key,
301 std::string_view salt)
const {
306 std::span<const uint8_t> peer_key,
307 std::span<const uint8_t> salt)
const {
308 return SymmetricKey(m_op->agree(key_len, peer_key, salt));
313 std::string_view padding,
315 std::string_view provider) :
320 .with_provider(provider)) {}
337 reader.throw_if_unexamined(key.
algo_name());
341 return m_op->algorithm_identifier();
345 return m_op->hash_function();
358 m_op->update({in, length});
363std::vector<uint8_t> der_encode_signature(std::span<const uint8_t> sig,
size_t parts,
size_t part_size) {
364 if(sig.size() % parts != 0 || sig.size() != parts * part_size) {
368 BufferSlicer bs_sig(sig);
369 std::vector<BigInt> sig_parts;
370 sig_parts.reserve(parts);
371 for(
size_t i = 0; i != parts; ++i) {
375 std::vector<uint8_t> output;
384 return m_op->signature_length();
386 const size_t sig_len = m_op->signature_length();
388 const size_t der_overhead = [sig_len]() {
407 }
else if(sig_len <= 248) {
420 return sig_len + der_overhead;
428 BOTAN_ARG_CHECK(m_sig_element_size.has_value(),
"This key does not support DER signatures");
430 m_sig_format = format;
436 return m_op->sign(rng);
439 return der_encode_signature(m_op->sign(rng), 2, m_sig_element_size.value());
446 std::string_view padding,
448 std::string_view provider) :
452 .with_provider(provider)) {}
470 reader.throw_if_unexamined(key.
algo_name());
475 std::string_view provider) {
491 return m_op->hash_function();
496 BOTAN_ARG_CHECK(m_sig_element_size.has_value(),
"This key does not support DER signatures");
498 m_sig_format = format;
511 m_op->update({in, length});
516std::vector<uint8_t> decode_der_signature_pair(std::span<const uint8_t> der_sig,
size_t sig_part_size) {
529 if(invalid_r || invalid_s) {
533 std::vector<uint8_t> sig(2 * sig_part_size);
544 return m_op->is_valid_signature({sig, length});
546 bool decoding_success =
false;
547 std::vector<uint8_t> real_sig;
552 real_sig = decode_der_signature_pair({sig, length}, m_sig_element_size.value());
553 decoding_success =
true;
558 const bool accept = m_op->is_valid_signature(real_sig);
560 return accept && decoding_success;
562 throw Internal_Error(
"PK_Verifier: Invalid signature format enum");
#define BOTAN_ASSERT_NOMSG(expr)
#define BOTAN_ARG_CHECK(expr, msg)
#define BOTAN_ASSERT(expr, assertion_made)
virtual std::string algo_name() const =0
virtual std::optional< size_t > _signature_element_size_for_DER_encoding() const
virtual Signature_Format _default_x509_signature_format() const
BER_Decoder & decode(bool &out)
BER_Decoder & verify_end()
BER_Decoder start_sequence()
void serialize_to(std::span< uint8_t > out) const
static BigInt from_bytes(std::span< const uint8_t > bytes)
static constexpr Mask< T > is_equal(T x, T y)
DER_Encoder & encode_list(const std::vector< T > &values)
DER_Encoder & start_sequence()
PK_Decryptor_EME(const Private_Key &key, RandomNumberGenerator &rng, const PK_Encryption_Options &options)
~PK_Decryptor_EME() override
size_t plaintext_length(size_t ctext_len) const override
size_t ciphertext_length(size_t ptext_len) const override
virtual size_t plaintext_length(size_t ctext_len) const =0
secure_vector< uint8_t > decrypt_or_random(const uint8_t in[], size_t length, size_t expected_pt_len, RandomNumberGenerator &rng) const
secure_vector< uint8_t > decrypt(const uint8_t in[], size_t length) const
~PK_Encryptor_EME() override
PK_Encryptor_EME(const Public_Key &key, RandomNumberGenerator &rng, const PK_Encryption_Options &options)
size_t maximum_input_size() const override
size_t ciphertext_length(size_t ptext_len) const override
size_t encapsulated_key_length() const
PK_KEM_Decryptor(const Private_Key &key, RandomNumberGenerator &rng, const PK_KEM_Options &options)
size_t shared_key_length(size_t desired_shared_key_len) const
void decrypt(std::span< uint8_t > out_shared_key, std::span< const uint8_t > encap_key, size_t desired_shared_key_len=32, std::span< const uint8_t > salt={})
PK_KEM_Encryptor(const Public_Key &key, const PK_KEM_Options &options)
KEM_Encapsulation encrypt(RandomNumberGenerator &rng, size_t desired_shared_key_len=32, std::span< const uint8_t > salt={})
size_t shared_key_length(size_t desired_shared_key_len) const
size_t encapsulated_key_length() const
SymmetricKey derive_key(size_t key_len, std::span< const uint8_t > peer_key, std::span< const uint8_t > salt) const
PK_Key_Agreement(const Private_Key &key, RandomNumberGenerator &rng, const PK_Key_Agreement_Options &options)
size_t agreed_value_size() const
bool using_der_encoded_signature() const
PK_Signer(const Private_Key &key, RandomNumberGenerator &rng, const PK_Signature_Options &options=PK_Signature_Options())
size_t signature_length() const
std::vector< uint8_t > signature(RandomNumberGenerator &rng)
void set_output_format(Signature_Format format)
std::string hash_function() const
AlgorithmIdentifier algorithm_identifier() const
PK_Verifier(const Public_Key &pub_key, const PK_Signature_Options &options=PK_Signature_Options())
void set_input_format(Signature_Format format)
bool verify_message(const uint8_t msg[], size_t msg_length, const uint8_t sig[], size_t sig_length)
std::string hash_function() const
bool check_signature(const uint8_t sig[], size_t length)
virtual std::unique_ptr< PK_Ops::Key_Agreement > _create_key_agreement_op(RandomNumberGenerator &rng, const PK_Key_Agreement_Options_Reader &options) const
virtual std::unique_ptr< PK_Ops::Signature > _create_signature_op(RandomNumberGenerator &rng, const PK_Signature_Options_Reader &options) const
virtual std::unique_ptr< PK_Ops::KEM_Decryption > _create_kem_decryption_op(RandomNumberGenerator &rng, const PK_KEM_Options_Reader &options) const
virtual std::unique_ptr< PK_Ops::Decryption > _create_decryption_op(RandomNumberGenerator &rng, const PK_Encryption_Options_Reader &options) const
virtual std::unique_ptr< PK_Ops::Verification > _create_verification_op(const PK_Signature_Options_Reader &options) const
virtual std::unique_ptr< PK_Ops::KEM_Encryption > _create_kem_encryption_op(const PK_KEM_Options_Reader &options) const
virtual std::unique_ptr< PK_Ops::Verification > create_x509_verification_op(const AlgorithmIdentifier &signature_algorithm, std::string_view provider) const
virtual std::unique_ptr< PK_Ops::Encryption > _create_encryption_op(RandomNumberGenerator &rng, const PK_Encryption_Options_Reader &options) const
void random_vec(std::span< uint8_t > v)
constexpr void unpoison_all(const Ts &... ts)
constexpr void unpoison(const T *p, size_t n)
PK_Encryption_Options parse_legacy_enc_options(const Public_Key &key, std::string_view params)
std::span< const uint8_t > as_span_of_bytes(const char *s, size_t len)
std::string fmt(std::string_view format, const T &... args)
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)
std::vector< T, secure_allocator< T > > secure_vector