pubkey.cpp

含有多种公开密钥算法、多种块加密、多种数据流加密、多种HASH函数、多种CheckSum校验、多种MAC校验等几十种加密算法的程序

/*************************************************
* Public Key Base Source File                    *
* (C) 1999-2002 The Botan Project                *
*************************************************/

#include <botan/pubkey.h>
#include <botan/look_pk.h>
#include <botan/util.h>

namespace Botan {

/*************************************************
* PK_Encryptor Constructor                       *
*************************************************/
PK_Encryptor::PK_Encryptor(const PK_Encrypting_Key& k, EME* me) :
   key(k), encoder(me)
   {
   }

/*************************************************
* PK_Encryptor Constructor                       *
*************************************************/
PK_Encryptor::PK_Encryptor(const PK_Encrypting_Key& k,
                           const std::string& eme) :
   key(k), encoder((eme == "Raw") ? 0 : get_eme(eme))
   {
   }

/*************************************************
* Encrypt a message                              *
*************************************************/
SecureVector<byte> PK_Encryptor::encrypt(const byte msg[],
                                         u32bit msg_len) const
   {
   SecureVector<byte> message;
   if(encoder) message = encoder->encode(msg, msg_len, key.max_input_bits());
   else        message.set(msg, msg_len);

   if(8*(message.size() - 1) + high_bit(message[0]) > key.max_input_bits())
      throw Exception("PK_Encryptor: Input is too large");

   return key.encrypt(message, message.size());
   }

/*************************************************
* Encrypt a message                              *
*************************************************/
SecureVector<byte> PK_Encryptor::encrypt(const SecureVector<byte>& msg) const
   {
   return encrypt(msg, msg.size());
   }

/*************************************************
* Return the max size, in bytes, of a message    *
*************************************************/
u32bit PK_Encryptor::maximum_input_size() const
   {
   if(!encoder)
      return (key.max_input_bits() / 8);
   else
      return encoder->maximum_input_size(key.max_input_bits());
   }

/*************************************************
* PK_Decryptor Constructor                       *
*************************************************/
PK_Decryptor::PK_Decryptor(const PK_Decrypting_Key& k, EME* me) :
   key(k), encoder(me)
   {
   }

/*************************************************
* PK_Decryptor Constructor                       *
*************************************************/
PK_Decryptor::PK_Decryptor(const PK_Decrypting_Key& k,
                           const std::string& eme) :
   key(k), encoder((eme == "Raw") ? 0 : get_eme(eme))
   {
   }

/*************************************************
* Decrypt a message                              *
*************************************************/
SecureVector<byte> PK_Decryptor::decrypt(const byte in[], u32bit length) const
   {
   try {
      SecureVector<byte> decrypted = key.decrypt(in, length);
      if(encoder)
         return encoder->decode(decrypted, key.max_input_bits());
      else
         return decrypted;
      }
   catch(Invalid_Argument)
      {
      throw Exception("PK_Decryptor: Input is invalid");
      }
   catch(Decoding_Error)
      {
      throw Exception("PK_Decryptor: Input is invalid");
      }
   }

/*************************************************
* Decrypt a message                              *
*************************************************/
SecureVector<byte> PK_Decryptor::decrypt(const SecureVector<byte>& msg) const
   {
   return decrypt(msg, msg.size());
   }

/*************************************************
* PK_Signer Constructor                          *
*************************************************/
PK_Signer::PK_Signer(const PK_Signing_Key& k, EMSA* e) :
   key(k), emsa(e)
   {
   }

/*************************************************
* PK_Signer Constructor                          *
*************************************************/
PK_Signer::PK_Signer(const PK_Signing_Key& k, const std::string& emsa_name) :
   key(k), emsa(get_emsa(emsa_name))
   {
   }

/*************************************************
* Sign a message                                 *
*************************************************/
SecureVector<byte> PK_Signer::sign_message(const byte msg[], u32bit length)
   {
   update(msg, length);
   return signature();
   }

/*************************************************
* Add more to the message to be signed           *
*************************************************/
void PK_Signer::update(const byte in[], u32bit length)
   {
   emsa->update(in, length);
   }

/*************************************************
* Create a signature                             *
*************************************************/
SecureVector<byte> PK_Signer::signature()
   {
   SecureVector<byte> encoded = emsa->encoding_of(emsa->raw_data(),
                                                  key.max_input_bits());
   return key.sign(encoded, encoded.size());
   }

/*************************************************
* PK_Verifier Constructor                        *
*************************************************/
PK_Verifier::PK_Verifier(EMSA* e) : emsa(e)
   {
   }

/*************************************************
* PK_Verifier Constructor                        *
*************************************************/
PK_Verifier::PK_Verifier(const std::string& emsa_name) :
   emsa(get_emsa(emsa_name))
   {
   }

/*************************************************
* Verify a message                               *
*************************************************/
bool PK_Verifier::verify_message(const byte msg[], u32bit msg_length,
                                 const byte sig[], u32bit sig_length)
   {
   update(msg, msg_length);
   return valid_signature(sig, sig_length);
   }

/*************************************************
* Append to the message                          *
*************************************************/
void PK_Verifier::update(const byte in[], u32bit length)
   {
   emsa->update(in, length);
   }

/*************************************************
* Create a signature                             *
*************************************************/
bool PK_Verifier::valid_signature(const byte sig[], u32bit length)
   {
   try {
      return validate_signature(emsa->raw_data(), sig, length);
   }
   catch(Invalid_Argument)
      {
      return false;
      }
   }

/*************************************************
* PK_Verifier_with_MR Constructor                *
*************************************************/
PK_Verifier_with_MR::PK_Verifier_with_MR(const PK_Verifying_with_MR_Key& k,
                                         EMSA* e) :
   PK_Verifier(e), key(k)
   {
   }

/*************************************************
* PK_Verifier_with_MR Constructor                *
*************************************************/
PK_Verifier_with_MR::PK_Verifier_with_MR(const PK_Verifying_with_MR_Key& k,
                                         const std::string& emsa_name) :
   PK_Verifier(emsa_name), key(k)
   {
   }

/*************************************************
* Verify a signature                             *
*************************************************/
bool PK_Verifier_with_MR::validate_signature(const SecureVector<byte>& msg,
                                             const byte sig[], u32bit sig_len)
   {
   SecureVector<byte> output_of_key = key.verify(sig, sig_len);
   return emsa->verify(output_of_key, msg, key.max_input_bits());
   }

/*************************************************
* PK_Verifier_wo_MR Constructor                  *
*************************************************/
PK_Verifier_wo_MR::PK_Verifier_wo_MR(const PK_Verifying_wo_MR_Key& k,
                                     EMSA* e) :
   PK_Verifier(e), key(k)
   {
   }

/*************************************************
* PK_Verifier_wo_MR Constructor                  *
*************************************************/
PK_Verifier_wo_MR::PK_Verifier_wo_MR(const PK_Verifying_wo_MR_Key& k,
                                     const std::string& emsa_name) :
   PK_Verifier(emsa_name), key(k)
   {
   }

/*************************************************
* Verify a signature                             *
*************************************************/
bool PK_Verifier_wo_MR::validate_signature(const SecureVector<byte>& msg,
                                           const byte sig[], u32bit sig_len)
   {
   SecureVector<byte> encoded = emsa->encoding_of(msg, key.max_input_bits());
   return key.verify(encoded, encoded.size(), sig, sig_len);
   }

/*************************************************
* PK_Key_Agreement_Scheme Constructor            *
*************************************************/
PK_Key_Agreement_Scheme::PK_Key_Agreement_Scheme(const PK_Key_Agreement_Key& k,
                                                 KDF* kdf_func) :
   key(k), kdf(kdf_func)
   {
   }

/*************************************************
* PK_Key_Agreement_Scheme Constructor            *
*************************************************/
PK_Key_Agreement_Scheme::PK_Key_Agreement_Scheme(const PK_Key_Agreement_Key& k,
                                                 const std::string& kdf_name) :
   key(k), kdf((kdf_name == "Raw") ? 0 : get_kdf(kdf_name))
   {
   }

/*************************************************
* Perform Key Agreement Operation                *
*************************************************/
SymmetricKey PK_Key_Agreement_Scheme::derive_key(const SecureVector<byte>& in,
                                                 u32bit key_len) const
   {
   return derive_key(in, in.size(), key_len);
   }

/*************************************************
* Perform Key Agreement Operation                *
*************************************************/
SymmetricKey PK_Key_Agreement_Scheme::derive_key(const byte in[],
                                                 u32bit in_len,
                                                 u32bit key_len) const
   {
   SecureVector<byte> z = key.derive_key(in, in_len);

   if(kdf)
      return kdf->derive_key(z, key_len);
   else
      return z;
   }

}