8 #include <botan/pubkey.h>
9 #include <botan/der_enc.h>
10 #include <botan/ber_dec.h>
11 #include <botan/bigint.h>
12 #include <botan/parsing.h>
13 #include <botan/libstate.h>
14 #include <botan/engine.h>
15 #include <botan/lookup.h>
16 #include <botan/internal/bit_ops.h>
17 #include <botan/internal/assert.h>
26 const std::string& eme_name)
34 op = engine->get_encryption_op(key);
42 eme = (eme_name ==
"Raw") ? 0 :
get_eme(eme_name);
49 PK_Encryptor_EME::enc(
const byte in[],
68 return op->
encrypt(&in[0], length, rng);
87 const std::string& eme_name)
95 op = engine->get_decryption_op(key);
103 eme = (eme_name ==
"Raw") ? 0 :
get_eme(eme_name);
121 throw Decoding_Error(
"PK_Decryptor_EME: Input is invalid");
129 const std::string& emsa_name,
141 op = engine->get_signature_op(key);
144 verify_op = engine->get_verify_op(key);
191 size_t extra_0s = msg.
size() - recovered.
size();
193 for(
size_t i = 0; i != extra_0s; ++i)
197 return same_mem(&msg[extra_0s], &recovered[0], recovered.
size());
200 return (recovered == msg);
204 &sig[0], sig.
size());
219 "PK_Signer consistency check failed");
231 for(
size_t j = 0; j != sig_parts.size(); ++j)
232 sig_parts[j].binary_decode(&plain_sig[SIZE_OF_PART*j], SIZE_OF_PART);
249 const std::string& emsa_name,
258 op = engine->get_verify_op(key);
276 throw Invalid_State(
"PK_Verifier: This algorithm always uses IEEE 1363");
284 const byte sig[],
size_t sig_length)
305 return validate_signature(emsa->
raw_data(), sig, length);
324 return validate_signature(emsa->
raw_data(),
325 &real_sig[0], real_sig.
size());
338 const byte sig[],
size_t sig_len)
349 SecureVector<byte> encoded =
352 return op->
verify(&encoded[0], encoded.size(), sig, sig_len);
360 const std::string& kdf_name)
368 op = engine->get_key_agreement_op(key);
376 kdf = (kdf_name ==
"Raw") ? 0 :
get_kdf(kdf_name);
380 size_t in_len,
const byte params[],
381 size_t params_len)
const
388 return kdf->
derive_key(key_len, z, params, params_len);
bool check_signature(const byte sig[], size_t length)
SecureVector< byte > decode(const byte in[], size_t in_length, size_t key_length) const
DER_Encoder & encode_list(const std::vector< T > &values)
SecureVector< byte > get_contents()
virtual SecureVector< byte > verify_mr(const byte[], size_t)
EMSA * get_emsa(const std::string &algo_spec)
virtual SecureVector< byte > agree(const byte w[], size_t w_len)=0
size_t maximum_input_size() const
bool same_mem(const T *p1, const T *p2, size_t n)
virtual size_t max_input_bits() const =0
virtual size_t message_parts() const
SymmetricKey derive_key(size_t key_len, const byte in[], size_t in_len, const byte params[], size_t params_len) const
virtual SecureVector< byte > decrypt(const byte msg[], size_t msg_len)=0
BER_Decoder & decode(bool &)
SecureVector< byte > signature(RandomNumberGenerator &rng)
PK_Encryptor_EME(const Public_Key &key, const std::string &eme)
virtual std::string algo_name() const =0
std::invalid_argument Invalid_Argument
virtual SecureVector< byte > sign(const byte msg[], size_t msg_len, RandomNumberGenerator &rng)=0
virtual bool with_recovery() const =0
virtual size_t max_input_bits() const =0
virtual SecureVector< byte > encoding_of(const MemoryRegion< byte > &msg, size_t output_bits, RandomNumberGenerator &rng)=0
BER_Decoder start_cons(ASN1_Tag, ASN1_Tag=UNIVERSAL)
virtual size_t max_input_bits() const =0
PK_Verifier(const Public_Key &pub_key, const std::string &emsa, Signature_Format format=IEEE_1363)
virtual bool verify(const byte[], size_t, const byte[], size_t)
#define BOTAN_ASSERT(expr, msg)
virtual size_t maximum_input_size(size_t keybits) const =0
PK_Signer(const Private_Key &key, const std::string &emsa, Signature_Format format=IEEE_1363, Fault_Protection prot=ENABLE_FAULT_PROTECTION)
virtual SecureVector< byte > raw_data()=0
RandomNumberGenerator * rng
SecureVector< byte > sign_message(const byte in[], size_t length, RandomNumberGenerator &rng)
virtual SecureVector< byte > encrypt(const byte msg[], size_t msg_len, RandomNumberGenerator &rng)=0
Library_State & global_state()
virtual size_t message_part_size() const
virtual size_t max_input_bits() const =0
bool verify_message(const byte msg[], size_t msg_length, const byte sig[], size_t sig_length)
SecureVector< byte > encode(const byte in[], size_t in_length, size_t key_length, RandomNumberGenerator &rng) const
SecureVector< byte > derive_key(size_t key_len, const MemoryRegion< byte > &secret, const std::string &salt="") const
virtual bool verify(const MemoryRegion< byte > &coded, const MemoryRegion< byte > &raw, size_t key_bits)=0
virtual size_t message_parts() const
EME * get_eme(const std::string &algo_spec)
void set_input_format(Signature_Format format)
virtual void update(const byte input[], size_t length)=0
PK_Decryptor_EME(const Private_Key &key, const std::string &eme)
DER_Encoder & start_cons(ASN1_Tag type_tag, ASN1_Tag class_tag=UNIVERSAL)
std::string to_string(u64bit n, size_t min_len)
KDF * get_kdf(const std::string &algo_spec)
PK_Key_Agreement(const PK_Key_Agreement_Key &key, const std::string &kdf)
static SecureVector< byte > encode_1363(const BigInt &n, size_t bytes)