11#include <botan/pk_keys.h>
12#include <botan/pk_ops_fwd.h>
13#include <botan/pk_options.h>
14#include <botan/symkey.h>
38 return enc(in, length, rng);
48 return enc(in.data(), in.size(), rng);
106 size_t expected_pt_len,
125 size_t expected_pt_len,
127 const uint8_t required_content_bytes[],
128 const uint8_t required_content_offsets[],
129 size_t required_contents)
const;
166 virtual
size_t do_decrypt(uint8_t& valid_mask,
167 std::span<uint8_t> ptext,
168 std::span<const uint8_t> ctext) const = 0;
203 std::string_view padding,
205 std::string_view provider =
"");
248 void update(
const uint8_t in[],
size_t length);
254 void update(std::span<const uint8_t> in) {
update(in.data(), in.size()); }
260 void update(std::string_view in);
280 size_t signature_length()
const;
295 std::string hash_function()
const;
298 std::unique_ptr<PK_Ops::Signature> m_op;
300 std::optional<size_t> m_sig_element_size;
326 std::string_view padding,
328 std::string_view provider =
"");
343 std::string_view provider =
"");
361 bool verify_message(const uint8_t msg[],
size_t msg_length, const uint8_t sig[],
size_t sig_length);
369 bool verify_message(std::span<const uint8_t> msg, std::span<const uint8_t> sig) {
370 return verify_message(msg.data(), msg.size(), sig.data(), sig.size());
386 void update(
const uint8_t msg_part[],
size_t length);
393 void update(std::span<const uint8_t> in) {
update(in.data(), in.size()); }
399 void update(std::string_view in);
408 bool check_signature(
const uint8_t sig[],
size_t length);
430 std::
string hash_function() const;
433 std::unique_ptr<
PK_Ops::Verification> m_op;
435 std::optional<
size_t> m_sig_element_size;
460 std::string_view kdf,
461 std::string_view provider =
"");
477 SymmetricKey derive_key(
size_t key_len, std::span<const uint8_t> peer_key, std::span<const uint8_t> salt) const;
488 size_t key_len, const uint8_t peer_key[],
size_t peer_key_len, const uint8_t salt[],
size_t salt_len)
const {
489 return this->
derive_key(key_len, {peer_key, peer_key_len}, {salt, salt_len});
500 std::span<const uint8_t> peer_key,
501 const uint8_t salt[],
502 size_t salt_len)
const {
503 return derive_key(key_len, peer_key.data(), peer_key.size(), salt, salt_len);
514 const uint8_t peer_key[],
516 std::string_view salt =
"")
const;
524 SymmetricKey derive_key(
size_t key_len, std::span<const uint8_t> peer_key, std::string_view salt =
"")
const;
531 size_t agreed_value_size()
const;
534 std::unique_ptr<PK_Ops::Key_Agreement> m_op;
565 std::string_view padding,
566 std::string_view provider =
"");
583 std::vector<uint8_t> enc(const uint8_t ptext[],
size_t len,
RandomNumberGenerator& rng) const override;
585 std::unique_ptr<
PK_Ops::Encryption> m_op;
612 std::string_view padding,
613 std::string_view provider =
"");
628 size_t do_decrypt(uint8_t& valid_mask, std::span<uint8_t> ptext, std::span<const uint8_t> ctext) const override;
630 std::unique_ptr<
PK_Ops::Decryption> m_op;
656 return std::make_pair(std::exchange(kem.m_encapsulated_shared_key, {}), std::exchange(kem.m_shared_key, {}));
663 m_encapsulated_shared_key(encapsulated_size), m_shared_key(shared_key_size) {}
666 std::vector<uint8_t> m_encapsulated_shared_key;
689 std::string_view kem_param =
"",
690 std::string_view provider =
"");
702 std::string_view kem_param =
"",
703 std::string_view provider =
"");
746 size_t desired_shared_key_len = 32,
747 std::span<const uint8_t> salt = {}) {
748 std::vector<uint8_t> encapsulated_shared_key(encapsulated_key_length());
751 encrypt(std::span{encapsulated_shared_key}, std::span{shared_key}, rng, desired_shared_key_len, salt);
752 return KEM_Encapsulation(std::move(encapsulated_shared_key), std::move(shared_key));
768 size_t desired_shared_key_len = 32,
769 std::span<const uint8_t> salt = {}) {
770 out_encapsulated_key.resize(encapsulated_key_length());
771 out_shared_key.resize(shared_key_length(desired_shared_key_len));
772 encrypt(std::span{out_encapsulated_key}, std::span{out_shared_key}, rng, desired_shared_key_len, salt);
785 void encrypt(std::span<uint8_t> out_encapsulated_key,
786 std::span<uint8_t> out_shared_key,
787 RandomNumberGenerator& rng,
788 size_t desired_shared_key_len = 32,
789 std::span<const uint8_t> salt = {});
794 size_t desired_shared_key_len,
796 const uint8_t salt[],
798 this->
encrypt(out_encapsulated_key, out_shared_key, rng, desired_shared_key_len, {salt, salt_len});
804 size_t desired_shared_key_len,
806 std::span<const uint8_t> salt = {}) {
807 out_encapsulated_key.resize(encapsulated_key_length());
808 out_shared_key.resize(shared_key_length(desired_shared_key_len));
809 encrypt(out_encapsulated_key, out_shared_key, rng, desired_shared_key_len, salt);
813 std::unique_ptr<PK_Ops::KEM_Encryption> m_op;
838 std::string_view kem_param =
"",
839 std::string_view provider =
"");
879 void decrypt(std::span<uint8_t> out_shared_key,
880 std::span<const uint8_t> encap_key,
881 size_t desired_shared_key_len = 32,
882 std::span<const uint8_t> salt = {});
899 size_t encap_key_len,
900 size_t desired_shared_key_len,
901 const uint8_t salt[] =
nullptr,
902 size_t salt_len = 0) {
904 decrypt(shared_key, {encap_key, encap_key_len}, desired_shared_key_len, {salt, salt_len});
920 size_t desired_shared_key_len = 32,
921 std::span<const uint8_t> salt = {}) {
923 decrypt(shared_key, encap_key, desired_shared_key_len, salt);
928 std::unique_ptr<PK_Ops::KEM_Decryption> m_op;
#define BOTAN_PUBLIC_API(maj, min)
#define BOTAN_DEPRECATED(msg)
#define BOTAN_FUTURE_EXPLICIT
KEM_Encapsulation(std::vector< uint8_t > encapsulated_shared_key, secure_vector< uint8_t > shared_key)
const secure_vector< uint8_t > & shared_key() const
friend class PK_KEM_Encryptor
static std::pair< std::vector< uint8_t >, secure_vector< uint8_t > > destructure(KEM_Encapsulation &&kem)
const std::vector< uint8_t > & encapsulated_shared_key() const
PK_Decryptor_EME(const Private_Key &key, RandomNumberGenerator &rng, const PK_Encryption_Options &options)
~PK_Decryptor_EME() override
PK_Decryptor_EME(PK_Decryptor_EME &&) noexcept
PK_Decryptor_EME(const PK_Decryptor_EME &)=delete
size_t plaintext_length(size_t ctext_len) const override
PK_Decryptor_EME & operator=(const PK_Decryptor_EME &)=delete
size_t ciphertext_length(size_t ptext_len) const override
virtual ~PK_Decryptor()=default
virtual size_t plaintext_length(size_t ctext_len) const =0
secure_vector< uint8_t > decrypt(std::span< const uint8_t > in) const
PK_Decryptor & operator=(const PK_Decryptor &)=delete
PK_Decryptor(PK_Decryptor &&) noexcept=default
virtual size_t ciphertext_length(size_t ptext_len) const =0
secure_vector< uint8_t > decrypt(const uint8_t in[], size_t length) const
PK_Decryptor(const PK_Decryptor &)=delete
~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
PK_Encryptor_EME & operator=(const PK_Encryptor_EME &)=delete
size_t ciphertext_length(size_t ptext_len) const override
PK_Encryptor_EME(PK_Encryptor_EME &&) noexcept
PK_Encryptor_EME(const PK_Encryptor_EME &)=delete
virtual size_t ciphertext_length(size_t ptext_len) const =0
PK_Encryptor & operator=(const PK_Encryptor &)=delete
virtual size_t maximum_input_size() const =0
std::vector< uint8_t > encrypt(std::span< const uint8_t > in, RandomNumberGenerator &rng) const
virtual ~PK_Encryptor()=default
std::vector< uint8_t > encrypt(const uint8_t in[], size_t length, RandomNumberGenerator &rng) const
PK_Encryptor(const PK_Encryptor &)=delete
PK_Encryptor(PK_Encryptor &&) noexcept=default
secure_vector< uint8_t > decrypt(const uint8_t encap_key[], size_t encap_key_len, size_t desired_shared_key_len, const uint8_t salt[]=nullptr, size_t salt_len=0)
size_t encapsulated_key_length() const
PK_KEM_Decryptor(PK_KEM_Decryptor &&) noexcept
PK_KEM_Decryptor(const Private_Key &key, RandomNumberGenerator &rng, const PK_KEM_Options &options)
PK_KEM_Decryptor & operator=(const PK_KEM_Decryptor &)=delete
PK_KEM_Decryptor(const PK_KEM_Decryptor &)=delete
secure_vector< uint8_t > decrypt(std::span< const uint8_t > encap_key, 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
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={})
void encrypt(secure_vector< uint8_t > &out_encapsulated_key, secure_vector< uint8_t > &out_shared_key, RandomNumberGenerator &rng, size_t desired_shared_key_len=32, std::span< const uint8_t > salt={})
PK_KEM_Encryptor(PK_KEM_Encryptor &&) noexcept
size_t shared_key_length(size_t desired_shared_key_len) const
size_t encapsulated_key_length() const
PK_KEM_Encryptor(const PK_KEM_Encryptor &)=delete
PK_KEM_Encryptor & operator=(const PK_KEM_Encryptor &)=delete
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)
SymmetricKey derive_key(size_t key_len, std::span< const uint8_t > peer_key, const uint8_t salt[], size_t salt_len) const
PK_Key_Agreement & operator=(const PK_Key_Agreement &)=delete
PK_Key_Agreement(const PK_Key_Agreement &)=delete
PK_Key_Agreement(PK_Key_Agreement &&) noexcept
PK_Signer(PK_Signer &&) noexcept
std::vector< uint8_t > sign_message(std::span< const uint8_t > in, RandomNumberGenerator &rng)
PK_Signer(const Private_Key &key, RandomNumberGenerator &rng, const PK_Signature_Options &options=PK_Signature_Options())
void update(std::span< const uint8_t > in)
std::vector< uint8_t > signature(RandomNumberGenerator &rng)
PK_Signer & operator=(const PK_Signer &)=delete
PK_Signer(const PK_Signer &)=delete
std::vector< uint8_t > sign_message(const uint8_t in[], size_t length, RandomNumberGenerator &rng)
PK_Verifier(const Public_Key &pub_key, const PK_Signature_Options &options=PK_Signature_Options())
PK_Verifier(PK_Verifier &&) noexcept
bool verify_message(const uint8_t msg[], size_t msg_length, const uint8_t sig[], size_t sig_length)
void update(std::span< const uint8_t > in)
PK_Verifier(const PK_Verifier &)=delete
bool check_signature(std::span< const uint8_t > sig)
PK_Verifier & operator=(const PK_Verifier &)=delete
std::string encrypt(const uint8_t input[], size_t input_len, std::string_view passphrase, RandomNumberGenerator &rng)
std::vector< T, secure_allocator< T > > secure_vector