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