ffi_pkey.cpp File Reference

#include <botan/ffi.h>
#include <botan/data_src.h>
#include <botan/hash.h>
#include <botan/pk_algs.h>
#include <botan/pk_keys.h>
#include <botan/pkcs8.h>
#include <botan/x509_key.h>
#include <botan/internal/ffi_ec.h>
#include <botan/internal/ffi_oid.h>
#include <botan/internal/ffi_pkey.h>
#include <botan/internal/ffi_rng.h>
#include <botan/internal/ffi_util.h>

Go to the source code of this file.

Functions
int	botan_ec_privkey_create (botan_privkey_t *key_obj, const char *algo_name, botan_ec_group_t ec_group_obj, botan_rng_t rng_obj)
int	botan_pkcs_hash_id (const char *hash_name, uint8_t pkcs_id[], size_t *pkcs_id_len)
int	botan_privkey_algo_name (botan_privkey_t key, char out[], size_t *out_len)
int	botan_privkey_check_key (botan_privkey_t key, botan_rng_t rng, uint32_t flags)
int	botan_privkey_create (botan_privkey_t *key_obj, const char *algo_name, const char *algo_params, botan_rng_t rng_obj)
int	botan_privkey_destroy (botan_privkey_t key)
int	botan_privkey_export (botan_privkey_t key, uint8_t out[], size_t *out_len, uint32_t flags)
int	botan_privkey_export_encrypted (botan_privkey_t key, uint8_t out[], size_t *out_len, botan_rng_t rng_obj, const char *pass, const char *, uint32_t flags)
int	botan_privkey_export_encrypted_pbkdf_iter (botan_privkey_t key, uint8_t out[], size_t *out_len, botan_rng_t rng, const char *passphrase, size_t pbkdf_iter, const char *cipher, const char *pbkdf_algo, uint32_t flags)
int	botan_privkey_export_encrypted_pbkdf_msec (botan_privkey_t key, uint8_t out[], size_t *out_len, botan_rng_t rng, const char *passphrase, uint32_t pbkdf_msec, size_t *pbkdf_iters_out, const char *cipher, const char *pbkdf_hash, uint32_t flags)
int	botan_privkey_export_pubkey (botan_pubkey_t *pubout, botan_privkey_t key_obj)
int	botan_privkey_load (botan_privkey_t *key, botan_rng_t rng_obj, const uint8_t bits[], size_t len, const char *password)
int	botan_privkey_oid (botan_asn1_oid_t *oid, botan_privkey_t key)
int	botan_privkey_remaining_operations (botan_privkey_t key, uint64_t *out)
int	botan_privkey_stateful_operation (botan_privkey_t key, int *out)
int	botan_privkey_view_der (botan_privkey_t key, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_privkey_view_encrypted_der (botan_privkey_t key, botan_rng_t rng_obj, const char *passphrase, const char *maybe_cipher, const char *maybe_pbkdf_algo, size_t maybe_pbkdf_iterations, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_privkey_view_encrypted_der_timed (botan_privkey_t key, botan_rng_t rng_obj, const char *passphrase, const char *maybe_cipher, const char *maybe_pbkdf_algo, size_t pbkdf_runtime_msec, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_privkey_view_encrypted_pem (botan_privkey_t key, botan_rng_t rng_obj, const char *passphrase, const char *maybe_cipher, const char *maybe_pbkdf_algo, size_t maybe_pbkdf_iterations, botan_view_ctx ctx, botan_view_str_fn view)
int	botan_privkey_view_encrypted_pem_timed (botan_privkey_t key, botan_rng_t rng_obj, const char *passphrase, const char *maybe_cipher, const char *maybe_pbkdf_algo, size_t pbkdf_runtime_msec, botan_view_ctx ctx, botan_view_str_fn view)
int	botan_privkey_view_pem (botan_privkey_t key, botan_view_ctx ctx, botan_view_str_fn view)
int	botan_privkey_view_raw (botan_privkey_t key, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_pubkey_algo_name (botan_pubkey_t key, char out[], size_t *out_len)
int	botan_pubkey_check_key (botan_pubkey_t key, botan_rng_t rng, uint32_t flags)
int	botan_pubkey_destroy (botan_pubkey_t key)
int	botan_pubkey_estimated_strength (botan_pubkey_t key, size_t *estimate)
int	botan_pubkey_export (botan_pubkey_t key, uint8_t out[], size_t *out_len, uint32_t flags)
int	botan_pubkey_fingerprint (botan_pubkey_t key, const char *hash_fn, uint8_t out[], size_t *out_len)
int	botan_pubkey_load (botan_pubkey_t *key, const uint8_t bits[], size_t bits_len)
int	botan_pubkey_oid (botan_asn1_oid_t *oid, botan_pubkey_t key)
int	botan_pubkey_view_der (botan_pubkey_t key, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_pubkey_view_pem (botan_pubkey_t key, botan_view_ctx ctx, botan_view_str_fn view)
int	botan_pubkey_view_raw (botan_pubkey_t key, botan_view_ctx ctx, botan_view_bin_fn view)

Function Documentation

botan_ec_privkey_create()

int botan_ec_privkey_create	(	botan_privkey_t *	key,
		const char *	algo_name,
		botan_ec_group_t	ec_group,
		botan_rng_t	rng )

Create a new ec private key

Parameters

key	the new object will be placed here
algo_name	something like "ECDSA" or "ECDH"
ec_group	a (possibly application specific) elliptic curve
rng	a random number generator

Definition at line 56 of file ffi_pkey.cpp.

                                                 {
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(key_obj == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
      *key_obj = nullptr;
 
      Botan::EC_Group ec_group = safe_get(ec_group_obj);
      Botan::RandomNumberGenerator& rng = safe_get(rng_obj);
      std::unique_ptr<Botan::Private_Key> key(
         Botan::create_ec_private_key(algo_name ? algo_name : "ECDSA", ec_group, rng));
 
      if(key) {
         *key_obj = new botan_privkey_struct(std::move(key));
         return BOTAN_FFI_SUCCESS;
      } else {
         return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
      }
   });
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, Botan::create_ec_private_key(), Botan_FFI::ffi_guard_thunk(), and Botan_FFI::safe_get().

botan_pkcs_hash_id()

int botan_pkcs_hash_id	(	const char *	hash_name,
		uint8_t	pkcs_id[],
		size_t *	pkcs_id_len )

Signature Scheme Utility Functions

Definition at line 438 of file ffi_pkey.cpp.

                                                                                      {
#if defined(BOTAN_HAS_HASH_ID)
   return ffi_guard_thunk(__func__, [=]() -> int {
      const std::vector<uint8_t> hash_id = Botan::pkcs_hash_id(hash_name);
      return write_output(pkcs_id, pkcs_id_len, hash_id.data(), hash_id.size());
   });
#else
   BOTAN_UNUSED(hash_name, pkcs_id, pkcs_id_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan::pkcs_hash_id(), and Botan_FFI::write_output().

botan_privkey_algo_name()

int botan_privkey_algo_name	(	botan_privkey_t	key,
		char	out[],
		size_t *	out_len )

Definition at line 137 of file ffi_pkey.cpp.

                                                                              {
   return BOTAN_FFI_VISIT(key, [=](const auto& k) { return write_str_output(out, out_len, k.algo_name()); });
}

References BOTAN_FFI_VISIT, and Botan_FFI::write_str_output().

botan_privkey_check_key()

int botan_privkey_check_key	(	botan_privkey_t	key,
		botan_rng_t	rng,
		uint32_t	flags )

Definition at line 153 of file ffi_pkey.cpp.

                                                                                  {
   const bool strong = (flags & BOTAN_CHECK_KEY_EXPENSIVE_TESTS);
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      return (k.check_key(safe_get(rng), strong) == true) ? 0 : BOTAN_FFI_ERROR_INVALID_INPUT;
   });
}

References BOTAN_CHECK_KEY_EXPENSIVE_TESTS, BOTAN_FFI_ERROR_INVALID_INPUT, BOTAN_FFI_VISIT, and Botan_FFI::safe_get().

botan_privkey_create()

int botan_privkey_create	(	botan_privkey_t *	key,
		const char *	algo_name,
		const char *	algo_params,
		botan_rng_t	rng )

Create a new private key

Parameters

key	the new object will be placed here
algo_name	something like "RSA" or "ECDSA"
algo_params	is specific to the algorithm. For RSA, specifies the modulus bit length. For ECC is the name of the curve.
rng	a random number generator

Definition at line 29 of file ffi_pkey.cpp.

                                              {
   return ffi_guard_thunk(__func__, [=]() -> int {
      if(key_obj == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      *key_obj = nullptr;
      if(rng_obj == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      Botan::RandomNumberGenerator& rng = safe_get(rng_obj);
      std::unique_ptr<Botan::Private_Key> key(
         Botan::create_private_key(algo_name ? algo_name : "RSA", rng, algo_params ? algo_params : ""));
 
      if(key) {
         *key_obj = new botan_privkey_struct(std::move(key));
         return BOTAN_FFI_SUCCESS;
      } else {
         return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
      }
   });
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, Botan::create_private_key(), Botan_FFI::ffi_guard_thunk(), and Botan_FFI::safe_get().

Referenced by botan_privkey_create_dh(), botan_privkey_create_ecdh(), botan_privkey_create_ecdsa(), botan_privkey_create_mceliece(), and botan_privkey_create_rsa().

botan_privkey_destroy()

int botan_privkey_destroy

(

botan_privkey_t

key

)

Returns

0 if success, error if invalid object handle

Definition at line 105 of file ffi_pkey.cpp.

                                               {
   return BOTAN_FFI_CHECKED_DELETE(key);
}

References BOTAN_FFI_CHECKED_DELETE.

botan_privkey_export()

int botan_privkey_export	(	botan_privkey_t	key,
		uint8_t	out[],
		size_t *	out_len,
		uint32_t	flags )

On input *out_len is number of bytes in out[] On output *out_len is number of bytes written (or required) If out is not big enough no output is written, *out_len is set and 1 is returned Returns 0 on success and sets If some other error occurs a negative integer is returned.

Definition at line 187 of file ffi_pkey.cpp.

                                                                                              {
   if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_DER) {
      return copy_view_bin(out, out_len, botan_privkey_view_der, key);
   } else if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_PEM) {
      return copy_view_str(out, out_len, botan_privkey_view_pem, key);
   } else if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_RAW) {
      return copy_view_bin(out, out_len, botan_privkey_view_raw, key);
   } else {
      return BOTAN_FFI_ERROR_BAD_FLAG;
   }
}

References BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_PRIVKEY_EXPORT_FLAG_DER, BOTAN_PRIVKEY_EXPORT_FLAG_PEM, BOTAN_PRIVKEY_EXPORT_FLAG_RAW, botan_privkey_view_der(), botan_privkey_view_pem(), botan_privkey_view_raw(), Botan_FFI::copy_view_bin(), and Botan_FFI::copy_view_str().

botan_privkey_export_encrypted()

int botan_privkey_export_encrypted	(	botan_privkey_t	key,
		uint8_t	out[],
		size_t *	out_len,
		botan_rng_t	rng,
		const char *	passphrase,
		const char *	encryption_algo,
		uint32_t	flags )

Set encryption_algo to NULL or "" to have the library choose a default (recommended)

Definition at line 214 of file ffi_pkey.cpp.

                                                   {
   return botan_privkey_export_encrypted_pbkdf_iter(key, out, out_len, rng_obj, pass, 100000, nullptr, nullptr, flags);
}

References botan_privkey_export_encrypted_pbkdf_iter().

botan_privkey_export_encrypted_pbkdf_iter()

int botan_privkey_export_encrypted_pbkdf_iter	(	botan_privkey_t	key,
		uint8_t	out[],
		size_t *	out_len,
		botan_rng_t	rng,
		const char *	passphrase,
		size_t	pbkdf_iterations,
		const char *	cipher_algo,
		const char *	pbkdf_algo,
		uint32_t	flags )

Export a private key using the specified number of iterations.

Definition at line 301 of file ffi_pkey.cpp.

                                                              {
   if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_DER) {
      return copy_view_bin(
         out, out_len, botan_privkey_view_encrypted_der, key, rng, passphrase, cipher, pbkdf_algo, pbkdf_iter);
   } else if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_PEM) {
      return copy_view_str(
         out, out_len, botan_privkey_view_encrypted_pem, key, rng, passphrase, cipher, pbkdf_algo, pbkdf_iter);
   } else {
      return BOTAN_FFI_ERROR_BAD_FLAG;
   }
}

References BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_PRIVKEY_EXPORT_FLAG_DER, BOTAN_PRIVKEY_EXPORT_FLAG_PEM, botan_privkey_view_encrypted_der(), botan_privkey_view_encrypted_pem(), Botan_FFI::copy_view_bin(), and Botan_FFI::copy_view_str().

Referenced by botan_privkey_export_encrypted().

botan_privkey_export_encrypted_pbkdf_msec()

int botan_privkey_export_encrypted_pbkdf_msec	(	botan_privkey_t	key,
		uint8_t	out[],
		size_t *	out_len,
		botan_rng_t	rng,
		const char *	passphrase,
		uint32_t	pbkdf_msec,
		size_t *	pbkdf_iters_out,
		const char *	cipher,
		const char *	pbkdf_hash,
		uint32_t	flags )

Definition at line 224 of file ffi_pkey.cpp.

                                                              {
   if(pbkdf_iters_out) {
      *pbkdf_iters_out = 0;
   }
 
   if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_DER) {
      return copy_view_bin(
         out, out_len, botan_privkey_view_encrypted_der_timed, key, rng, passphrase, cipher, pbkdf_hash, pbkdf_msec);
   } else if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_PEM) {
      return copy_view_str(
         out, out_len, botan_privkey_view_encrypted_pem_timed, key, rng, passphrase, cipher, pbkdf_hash, pbkdf_msec);
   } else {
      return BOTAN_FFI_ERROR_BAD_FLAG;
   }
}

References BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_PRIVKEY_EXPORT_FLAG_DER, BOTAN_PRIVKEY_EXPORT_FLAG_PEM, botan_privkey_view_encrypted_der_timed(), botan_privkey_view_encrypted_pem_timed(), Botan_FFI::copy_view_bin(), and Botan_FFI::copy_view_str().

botan_privkey_export_pubkey()

int botan_privkey_export_pubkey	(	botan_pubkey_t *	pubout,
		botan_privkey_t	key_obj )

Definition at line 129 of file ffi_pkey.cpp.

                                                                                 {
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto public_key = safe_get(key_obj).public_key();
      *pubout = new botan_pubkey_struct(std::move(public_key));
      return BOTAN_FFI_SUCCESS;
   });
}

References BOTAN_FFI_SUCCESS, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::safe_get().

botan_privkey_load()

int botan_privkey_load	(	botan_privkey_t *	key,
		botan_rng_t	rng,
		const uint8_t	bits[],
		size_t	len,
		const char *	password )

Input currently assumed to be PKCS #8 structure; Set password to NULL to indicate no encryption expected Starting in 2.8.0, the rng parameter is unused and may be set to null

Definition at line 80 of file ffi_pkey.cpp.

                                                                                                      {
   BOTAN_UNUSED(rng_obj);
 
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      Botan::DataSource_Memory src(bits, len);
 
      std::unique_ptr<Botan::Private_Key> pkcs8;
 
      if(password == nullptr) {
         pkcs8 = Botan::PKCS8::load_key(src);
      } else {
         pkcs8 = Botan::PKCS8::load_key(src, std::string(password));
      }
 
      if(pkcs8) {
         *key = new botan_privkey_struct(std::move(pkcs8));
         return BOTAN_FFI_SUCCESS;
      }
      return BOTAN_FFI_ERROR_UNKNOWN_ERROR;
   });
}

References BOTAN_FFI_ERROR_UNKNOWN_ERROR, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan::PKCS8::load_key().

botan_privkey_oid()

int botan_privkey_oid	(	botan_asn1_oid_t *	oid,
		botan_privkey_t	key )

Definition at line 384 of file ffi_pkey.cpp.

                                                                  {
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      if(oid == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      auto oid_ptr = std::make_unique<Botan::OID>(k.object_identifier());
      *oid = new botan_asn1_oid_struct(std::move(oid_ptr));
 
      return BOTAN_FFI_SUCCESS;
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, and BOTAN_FFI_VISIT.

botan_privkey_remaining_operations()

int botan_privkey_remaining_operations	(	botan_privkey_t	key,
		uint64_t *	out )

Gets information on many operations a (stateful) key has remaining and sets

Parameters

out	to that value

Returns

0 on success, a negative value on failure or if the key is not stateful

Definition at line 412 of file ffi_pkey.cpp.

                                                                           {
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      if(out == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      if(auto remaining = k.remaining_operations()) {
         *out = remaining.value();
         return BOTAN_FFI_SUCCESS;
      } else {
         return BOTAN_FFI_ERROR_NO_VALUE;
      }
   });
}

References BOTAN_FFI_ERROR_NO_VALUE, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, and BOTAN_FFI_VISIT.

botan_privkey_stateful_operation()

int botan_privkey_stateful_operation	(	botan_privkey_t	key,
		int *	out )

Checks whether a key is stateful and sets

Parameters

out	to 1 if it is, or 0 if the key is not stateful

Returns

0 on success, a negative value on failure

Definition at line 397 of file ffi_pkey.cpp.

                                                                    {
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      if(out == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      if(k.stateful_operation()) {
         *out = 1;
      } else {
         *out = 0;
      }
      return BOTAN_FFI_SUCCESS;
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, and BOTAN_FFI_VISIT.

botan_privkey_view_der()

int botan_privkey_view_der	(	botan_privkey_t	key,
		botan_view_ctx	ctx,
		botan_view_bin_fn	view )

View the private key's DER encoding

Definition at line 199 of file ffi_pkey.cpp.

                                                                                            {
   return BOTAN_FFI_VISIT(
      key, [=](const auto& k) -> int { return invoke_view_callback(view, ctx, Botan::PKCS8::BER_encode(k)); });
}

References Botan::PKCS8::BER_encode(), BOTAN_FFI_VISIT, and Botan_FFI::invoke_view_callback().

Referenced by botan_privkey_export().

botan_privkey_view_encrypted_der()

int botan_privkey_view_encrypted_der	(	botan_privkey_t	key,
		botan_rng_t	rng,
		const char *	passphrase,
		const char *	cipher_algo,
		const char *	pbkdf_algo,
		size_t	pbkdf_iterations,
		botan_view_ctx	ctx,
		botan_view_bin_fn	view )

View the encryption of a private key (binary DER encoding)

Set cipher_algo, pbkdf_algo to NULL to use defaults Set pbkdf_iterations to 0 to use defaults

Definition at line 321 of file ffi_pkey.cpp.

                                                             {
   if(passphrase == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      Botan::RandomNumberGenerator& rng = safe_get(rng_obj);
 
      const std::string cipher = (maybe_cipher ? maybe_cipher : "");
      const std::string pbkdf_algo = (maybe_pbkdf_algo ? maybe_pbkdf_algo : "");
      const size_t pbkdf_iter = (maybe_pbkdf_iterations ? maybe_pbkdf_iterations : 100000);
 
      auto pkcs8 = Botan::PKCS8::BER_encode_encrypted_pbkdf_iter(k, rng, passphrase, pbkdf_iter, cipher, pbkdf_algo);
 
      return invoke_view_callback(view, ctx, pkcs8);
   });
}

References Botan::PKCS8::BER_encode_encrypted_pbkdf_iter(), BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, Botan_FFI::invoke_view_callback(), and Botan_FFI::safe_get().

Referenced by botan_privkey_export_encrypted_pbkdf_iter().

botan_privkey_view_encrypted_der_timed()

int botan_privkey_view_encrypted_der_timed	(	botan_privkey_t	key,
		botan_rng_t	rng,
		const char *	passphrase,
		const char *	cipher_algo,
		const char *	pbkdf_algo,
		size_t	pbkdf_runtime_msec,
		botan_view_ctx	ctx,
		botan_view_bin_fn	view )

View the encryption of a private key (binary DER encoding)

Set cipher_algo, pbkdf_algo to NULL to use defaults

Definition at line 249 of file ffi_pkey.cpp.

                                                                   {
   if(passphrase == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      const std::chrono::milliseconds pbkdf_time(pbkdf_runtime_msec);
      Botan::RandomNumberGenerator& rng = safe_get(rng_obj);
 
      const std::string cipher = (maybe_cipher ? maybe_cipher : "");
      const std::string pbkdf_algo = (maybe_pbkdf_algo ? maybe_pbkdf_algo : "");
 
      auto pkcs8 =
         Botan::PKCS8::BER_encode_encrypted_pbkdf_msec(k, rng, passphrase, pbkdf_time, nullptr, cipher, pbkdf_algo);
 
      return invoke_view_callback(view, ctx, pkcs8);
   });
}

References Botan::PKCS8::BER_encode_encrypted_pbkdf_msec(), BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, Botan_FFI::invoke_view_callback(), and Botan_FFI::safe_get().

Referenced by botan_privkey_export_encrypted_pbkdf_msec().

botan_privkey_view_encrypted_pem()

int botan_privkey_view_encrypted_pem	(	botan_privkey_t	key,
		botan_rng_t	rng,
		const char *	passphrase,
		const char *	cipher_algo,
		const char *	pbkdf_algo,
		size_t	pbkdf_iterations,
		botan_view_ctx	ctx,
		botan_view_str_fn	view )

View the encryption of a private key (PEM encoding)

Set cipher_algo, pbkdf_algo to NULL to use defaults Set pbkdf_iterations to 0 to use defaults

Definition at line 346 of file ffi_pkey.cpp.

                                                             {
   if(passphrase == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      Botan::RandomNumberGenerator& rng = safe_get(rng_obj);
 
      const std::string cipher = (maybe_cipher ? maybe_cipher : "");
      const std::string pbkdf_algo = (maybe_pbkdf_algo ? maybe_pbkdf_algo : "");
      const size_t pbkdf_iter = (maybe_pbkdf_iterations ? maybe_pbkdf_iterations : 100000);
 
      auto pkcs8 = Botan::PKCS8::PEM_encode_encrypted_pbkdf_iter(k, rng, passphrase, pbkdf_iter, cipher, pbkdf_algo);
 
      return invoke_view_callback(view, ctx, pkcs8);
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, Botan_FFI::invoke_view_callback(), Botan::PKCS8::PEM_encode_encrypted_pbkdf_iter(), and Botan_FFI::safe_get().

Referenced by botan_privkey_export_encrypted_pbkdf_iter().

botan_privkey_view_encrypted_pem_timed()

int botan_privkey_view_encrypted_pem_timed	(	botan_privkey_t	key,
		botan_rng_t	rng,
		const char *	passphrase,
		const char *	cipher_algo,
		const char *	pbkdf_algo,
		size_t	pbkdf_runtime_msec,
		botan_view_ctx	ctx,
		botan_view_str_fn	view )

View the encryption of a private key (PEM encoding)

Set cipher_algo, pbkdf_algo to NULL to use defaults

Definition at line 275 of file ffi_pkey.cpp.

                                                                   {
   if(passphrase == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      const std::chrono::milliseconds pbkdf_time(pbkdf_runtime_msec);
      Botan::RandomNumberGenerator& rng = safe_get(rng_obj);
 
      const std::string cipher = (maybe_cipher ? maybe_cipher : "");
      const std::string pbkdf_algo = (maybe_pbkdf_algo ? maybe_pbkdf_algo : "");
 
      auto pkcs8 =
         Botan::PKCS8::PEM_encode_encrypted_pbkdf_msec(k, rng, passphrase, pbkdf_time, nullptr, cipher, pbkdf_algo);
 
      return invoke_view_callback(view, ctx, pkcs8);
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, Botan_FFI::invoke_view_callback(), Botan::PKCS8::PEM_encode_encrypted_pbkdf_msec(), and Botan_FFI::safe_get().

Referenced by botan_privkey_export_encrypted_pbkdf_msec().

botan_privkey_view_pem()

int botan_privkey_view_pem	(	botan_privkey_t	key,
		botan_view_ctx	ctx,
		botan_view_str_fn	view )

View the private key's PEM encoding

Definition at line 204 of file ffi_pkey.cpp.

                                                                                            {
   return BOTAN_FFI_VISIT(
      key, [=](const auto& k) -> int { return invoke_view_callback(view, ctx, Botan::PKCS8::PEM_encode(k)); });
}

References BOTAN_FFI_VISIT, Botan_FFI::invoke_view_callback(), and Botan::PKCS8::PEM_encode().

Referenced by botan_privkey_export().

botan_privkey_view_raw()

int botan_privkey_view_raw	(	botan_privkey_t	key,
		botan_view_ctx	ctx,
		botan_view_bin_fn	view )

View the private key's raw encoding

Definition at line 209 of file ffi_pkey.cpp.

                                                                                            {
   return BOTAN_FFI_VISIT(
      key, [=](const auto& k) -> int { return invoke_view_callback(view, ctx, k.raw_private_key_bits()); });
}

References BOTAN_FFI_VISIT, and Botan_FFI::invoke_view_callback().

Referenced by botan_privkey_export().

botan_pubkey_algo_name()

int botan_pubkey_algo_name	(	botan_pubkey_t	key,
		char	out[],
		size_t *	out_len )

Definition at line 141 of file ffi_pkey.cpp.

                                                                            {
   return BOTAN_FFI_VISIT(key, [=](const auto& k) { return write_str_output(out, out_len, k.algo_name()); });
}

References BOTAN_FFI_VISIT, and Botan_FFI::write_str_output().

botan_pubkey_check_key()

int botan_pubkey_check_key	(	botan_pubkey_t	key,
		botan_rng_t	rng,
		uint32_t	flags )

Returns 0 if key is valid, negative if invalid key or some other error

Definition at line 145 of file ffi_pkey.cpp.

                                                                                {
   const bool strong = (flags & BOTAN_CHECK_KEY_EXPENSIVE_TESTS);
 
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      return (k.check_key(safe_get(rng), strong) == true) ? 0 : BOTAN_FFI_ERROR_INVALID_INPUT;
   });
}

References BOTAN_CHECK_KEY_EXPENSIVE_TESTS, BOTAN_FFI_ERROR_INVALID_INPUT, BOTAN_FFI_VISIT, and Botan_FFI::safe_get().

botan_pubkey_destroy()

int botan_pubkey_destroy

(

botan_pubkey_t

key

)

Returns

0 if success, error if invalid object handle

Definition at line 125 of file ffi_pkey.cpp.

                                             {
   return BOTAN_FFI_CHECKED_DELETE(key);
}

References BOTAN_FFI_CHECKED_DELETE.

botan_pubkey_estimated_strength()

int botan_pubkey_estimated_strength	(	botan_pubkey_t	key,
		size_t *	estimate )

Definition at line 427 of file ffi_pkey.cpp.

                                                                          {
   return BOTAN_FFI_VISIT(key, [=](const auto& k) { *estimate = k.estimated_strength(); });
}

References BOTAN_FFI_VISIT.

botan_pubkey_export()

int botan_pubkey_export	(	botan_pubkey_t	key,
		uint8_t	out[],
		size_t *	out_len,
		uint32_t	flags )

Definition at line 160 of file ffi_pkey.cpp.

                                                                                            {
   if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_DER) {
      return copy_view_bin(out, out_len, botan_pubkey_view_der, key);
   } else if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_PEM) {
      return copy_view_str(out, out_len, botan_pubkey_view_pem, key);
   } else if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_RAW) {
      return copy_view_bin(out, out_len, botan_pubkey_view_raw, key);
   } else {
      return BOTAN_FFI_ERROR_BAD_FLAG;
   }
}

References BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_PRIVKEY_EXPORT_FLAG_DER, BOTAN_PRIVKEY_EXPORT_FLAG_PEM, BOTAN_PRIVKEY_EXPORT_FLAG_RAW, botan_pubkey_view_der(), botan_pubkey_view_pem(), botan_pubkey_view_raw(), Botan_FFI::copy_view_bin(), and Botan_FFI::copy_view_str().

botan_pubkey_fingerprint()

int botan_pubkey_fingerprint	(	botan_pubkey_t	key,
		const char *	hash_fn,
		uint8_t	out[],
		size_t *	out_len )

Definition at line 431 of file ffi_pkey.cpp.

                                                                                                      {
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      auto h = Botan::HashFunction::create_or_throw(hash_fn);
      return write_vec_output(out, out_len, h->process(k.public_key_bits()));
   });
}

References BOTAN_FFI_VISIT, Botan::HashFunction::create_or_throw(), and Botan_FFI::write_vec_output().

botan_pubkey_load()

int botan_pubkey_load	(	botan_pubkey_t *	key,
		const uint8_t	bits[],
		size_t	bits_len )

Definition at line 109 of file ffi_pkey.cpp.

                                                                                  {
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      Botan::DataSource_Memory src(bits, bits_len);
      std::unique_ptr<Botan::Public_Key> pubkey(Botan::X509::load_key(src));
 
      if(pubkey == nullptr) {
         return BOTAN_FFI_ERROR_UNKNOWN_ERROR;
      }
 
      *key = new botan_pubkey_struct(std::move(pubkey));
      return BOTAN_FFI_SUCCESS;
   });
}

References BOTAN_FFI_ERROR_UNKNOWN_ERROR, BOTAN_FFI_SUCCESS, Botan_FFI::ffi_guard_thunk(), and Botan::X509::load_key().

botan_pubkey_oid()

int botan_pubkey_oid	(	botan_asn1_oid_t *	oid,
		botan_pubkey_t	key )

Definition at line 371 of file ffi_pkey.cpp.

                                                                {
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      if(oid == nullptr) {
         return BOTAN_FFI_ERROR_NULL_POINTER;
      }
 
      auto oid_ptr = std::make_unique<Botan::OID>(k.object_identifier());
      *oid = new botan_asn1_oid_struct(std::move(oid_ptr));
 
      return BOTAN_FFI_SUCCESS;
   });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, and BOTAN_FFI_VISIT.

botan_pubkey_view_der()

int botan_pubkey_view_der	(	botan_pubkey_t	key,
		botan_view_ctx	ctx,
		botan_view_bin_fn	view )

View the public key's DER encoding

Definition at line 172 of file ffi_pkey.cpp.

                                                                                          {
   return BOTAN_FFI_VISIT(
      key, [=](const auto& k) -> int { return invoke_view_callback(view, ctx, k.subject_public_key()); });
}

References BOTAN_FFI_VISIT, and Botan_FFI::invoke_view_callback().

Referenced by botan_pubkey_export().

botan_pubkey_view_pem()

int botan_pubkey_view_pem	(	botan_pubkey_t	key,
		botan_view_ctx	ctx,
		botan_view_str_fn	view )

View the public key's PEM encoding

Definition at line 177 of file ffi_pkey.cpp.

                                                                                          {
   return BOTAN_FFI_VISIT(
      key, [=](const auto& k) -> int { return invoke_view_callback(view, ctx, Botan::X509::PEM_encode(k)); });
}

References BOTAN_FFI_VISIT, Botan_FFI::invoke_view_callback(), and Botan::X509::PEM_encode().

Referenced by botan_pubkey_export().

botan_pubkey_view_raw()

int botan_pubkey_view_raw	(	botan_pubkey_t	key,
		botan_view_ctx	ctx,
		botan_view_bin_fn	view )

View the public key's raw encoding

Definition at line 182 of file ffi_pkey.cpp.

                                                                                          {
   return BOTAN_FFI_VISIT(
      key, [=](const auto& k) -> int { return invoke_view_callback(view, ctx, k.raw_public_key_bits()); });
}

References BOTAN_FFI_VISIT, and Botan_FFI::invoke_view_callback().

Referenced by botan_pubkey_export().