Botan::KeyPair Namespace Reference

Functions
bool	encryption_consistency_check (RandomNumberGenerator &rng, const Private_Key &private_key, const Public_Key &public_key, const std::string &padding)
bool	encryption_consistency_check (RandomNumberGenerator &rng, const Private_Key &key, const std::string &padding)
bool	signature_consistency_check (RandomNumberGenerator &rng, const Private_Key &private_key, const Public_Key &public_key, const std::string &padding)
bool	signature_consistency_check (RandomNumberGenerator &rng, const Private_Key &key, const std::string &padding)

Function Documentation

bool Botan::KeyPair::encryption_consistency_check	(	RandomNumberGenerator &	rng,
		const Private_Key &	private_key,
		const Public_Key &	public_key,
		const std::string &	padding
	)

Tests whether the key is consistent for encryption; whether encrypting and then decrypting gives to the original plaintext.

Parameters

rng	the rng to use
private_key	the key to test
public_key	the key to test
padding	the encryption padding method to use

Returns

true if consistent otherwise false

Definition at line 19 of file keypair.cpp.

References Botan::PK_Decryptor::decrypt(), Botan::PK_Encryptor::encrypt(), Botan::PK_Encryptor_EME::maximum_input_size(), Botan::RandomNumberGenerator::random_vec(), and Botan::unlock().

Referenced by Botan::ElGamal_PrivateKey::check_key().

   {
   PK_Encryptor_EME encryptor(public_key, rng, padding);
   PK_Decryptor_EME decryptor(private_key, rng, padding);

   /*
   Weird corner case, if the key is too small to encrypt anything at
   all. This can happen with very small RSA keys with PSS
   */
   if(encryptor.maximum_input_size() == 0)
      return true;

   std::vector<uint8_t> plaintext;
   rng.random_vec(plaintext, encryptor.maximum_input_size() - 1);

   std::vector<uint8_t> ciphertext = encryptor.encrypt(plaintext, rng);
   if(ciphertext == plaintext)
      return false;

   std::vector<uint8_t> decrypted = unlock(decryptor.decrypt(ciphertext));

   return (plaintext == decrypted);
   }

bool Botan::KeyPair::encryption_consistency_check ( RandomNumberGenerator &  rng, const Private_Key &  key, const std::string &  padding  )

inline

Tests whether the key is consistent for encryption; whether encrypting and then decrypting gives to the original plaintext.

Parameters

rng	the rng to use
key	the key to test
padding	the encryption padding method to use

Returns

true if consistent otherwise false

Definition at line 58 of file keypair.h.

   {
   return encryption_consistency_check(rng, key, key, padding);
   }

bool Botan::KeyPair::signature_consistency_check	(	RandomNumberGenerator &	rng,
		const Private_Key &	private_key,
		const Public_Key &	public_key,
		const std::string &	padding
	)

Tests whether the key is consistent for signatures; whether a signature can be created and then verified

Parameters

rng	the rng to use
private_key	the key to test
public_key	the key to test
padding	the signature padding method to use

Returns

true if consistent otherwise false

Definition at line 49 of file keypair.cpp.

References Botan::RandomNumberGenerator::randomize(), Botan::PK_Signer::sign_message(), and Botan::PK_Verifier::verify_message().

Referenced by Botan::DSA_PrivateKey::check_key(), Botan::ECKCDSA_PrivateKey::check_key(), Botan::ECGDSA_PrivateKey::check_key(), Botan::SM2_PrivateKey::check_key(), Botan::ECDSA_PrivateKey::check_key(), and Botan::RSA_PrivateKey::check_key().

   {
   PK_Signer signer(private_key, rng, padding);
   PK_Verifier verifier(public_key, padding);

   std::vector<uint8_t> message(32);
   rng.randomize(message.data(), message.size());

   std::vector<uint8_t> signature;

   try
      {
      signature = signer.sign_message(message, rng);
      }
   catch(Encoding_Error&)
      {
      return false;
      }

   if(!verifier.verify_message(message, signature))
      return false;

   // Now try to check a corrupt signature, ensure it does not succeed
   ++signature[0];

   if(verifier.verify_message(message, signature))
      return false;

   return true;
   }

bool Botan::KeyPair::signature_consistency_check ( RandomNumberGenerator &  rng, const Private_Key &  key, const std::string &  padding  )

inline

Tests whether the key is consistent for signatures; whether a signature can be created and then verified

Parameters

rng	the rng to use
key	the key to test
padding	the signature padding method to use

Returns

true if consistent otherwise false

Definition at line 74 of file keypair.h.

   {
   return signature_consistency_check(rng, key, key, padding);
   }