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[],
61 return op->
encrypt(&encoded[0], encoded.
size(), rng);
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);
129 const std::string& emsa_name,
141 op = engine->get_signature_op(key);
144 verify_op = engine->get_verify_op(key);
164 return signature(rng);
172 emsa->update(in, length);
184 if(verify_op->with_recovery())
187 verify_op->verify_mr(&sig[0], sig.
size());
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);
203 return verify_op->verify(&msg[0], msg.
size(),
204 &sig[0], sig.
size());
219 "PK_Signer consistency check failed");
221 if(op->message_parts() == 1 || sig_format ==
IEEE_1363)
226 if(plain_sig.
size() % op->message_parts())
228 const size_t SIZE_OF_PART = plain_sig.
size() / op->message_parts();
230 std::vector<BigInt> sig_parts(op->message_parts());
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);
275 if(op->message_parts() == 1 && format !=
IEEE_1363)
276 throw Invalid_State(
"PK_Verifier: This algorithm always uses IEEE 1363");
284 const byte sig[],
size_t sig_length)
286 update(msg, msg_length);
287 return check_signature(sig, sig_length);
295 emsa->update(in, length);
305 return validate_signature(emsa->raw_data(), sig, length);
321 if(count != op->message_parts())
324 return validate_signature(emsa->raw_data(),
325 &real_sig[0], real_sig.
size());
338 const byte sig[],
size_t sig_len)
340 if(op->with_recovery())
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)
DER_Encoder & encode_list(const std::vector< T > &values)
SecureVector< byte > get_contents()
EMSA * get_emsa(const std::string &algo_spec)
bool same_mem(const T *p1, const T *p2, size_t n)
BER_Decoder & decode(bool &)
SecureVector< byte > signature(RandomNumberGenerator &rng)
PK_Encryptor_EME(const Public_Key &key, const std::string &eme)
size_t maximum_input_size() const
virtual std::string algo_name() const =0
std::invalid_argument Invalid_Argument
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)
#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)
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()
SecureVector< byte > decode(const byte in[], size_t in_length, size_t key_length) const
bool verify_message(const byte msg[], size_t msg_length, const byte sig[], size_t sig_length)
EME * get_eme(const std::string &algo_spec)
void set_input_format(Signature_Format format)
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)
SecureVector< byte > encode(const byte in[], size_t in_length, size_t key_length, RandomNumberGenerator &rng) const
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)
SymmetricKey derive_key(size_t key_len, const byte in[], size_t in_len, const byte params[], size_t params_len) const