ffi_pkey_algs.cpp File Reference

#include <botan/ffi.h>
#include <botan/assert.h>
#include <botan/ec_group.h>
#include <botan/hash.h>
#include <botan/mem_ops.h>
#include <botan/pem.h>
#include <botan/internal/ffi_ec.h>
#include <botan/internal/ffi_mp.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_get_group (botan_privkey_t key, botan_ec_group_t *ec_group)
int	botan_ec_privkey_get_private_key (botan_privkey_t key, botan_ec_scalar_t *value)
int	botan_ec_pubkey_get_group (botan_pubkey_t key, botan_ec_group_t *ec_group)
int	botan_mceies_decrypt (botan_privkey_t mce_key_obj, const char *aead, const uint8_t ct[], size_t ct_len, const uint8_t ad[], size_t ad_len, uint8_t out[], size_t *out_len)
int	botan_mceies_encrypt (botan_pubkey_t mce_key_obj, botan_rng_t rng_obj, const char *aead, const uint8_t pt[], size_t pt_len, const uint8_t ad[], size_t ad_len, uint8_t out[], size_t *out_len)
int	botan_privkey_create_dh (botan_privkey_t *key_obj, botan_rng_t rng_obj, const char *param_str)
int	botan_privkey_create_dsa (botan_privkey_t *key, botan_rng_t rng_obj, size_t pbits, size_t qbits)
int	botan_privkey_create_ecdh (botan_privkey_t *key_obj, botan_rng_t rng_obj, const char *param_str)
int	botan_privkey_create_ecdsa (botan_privkey_t *key_obj, botan_rng_t rng_obj, const char *param_str)
int	botan_privkey_create_elgamal (botan_privkey_t *key, botan_rng_t rng_obj, size_t pbits, size_t qbits)
int	botan_privkey_create_mceliece (botan_privkey_t *key_obj, botan_rng_t rng_obj, size_t n, size_t t)
int	botan_privkey_create_rsa (botan_privkey_t *key_obj, botan_rng_t rng_obj, size_t n_bits)
int	botan_privkey_dsa_get_x (botan_mp_t x, botan_privkey_t key)
int	botan_privkey_ed25519_get_privkey (botan_privkey_t key, uint8_t output[64])
int	botan_privkey_ed448_get_privkey (botan_privkey_t key, uint8_t output[57])
int	botan_privkey_get_field (botan_mp_t output, botan_privkey_t key, const char *field_name_cstr)
int	botan_privkey_load_classic_mceliece (botan_privkey_t *key, const uint8_t privkey[], size_t key_len, const char *cmce_mode)
int	botan_privkey_load_dh (botan_privkey_t *key, botan_mp_t p, botan_mp_t g, botan_mp_t x)
int	botan_privkey_load_dsa (botan_privkey_t *key, botan_mp_t p, botan_mp_t q, botan_mp_t g, botan_mp_t x)
int	botan_privkey_load_ecdh (botan_privkey_t *key, const botan_mp_t scalar, const char *curve_name)
int	botan_privkey_load_ecdsa (botan_privkey_t *key, const botan_mp_t scalar, const char *curve_name)
int	botan_privkey_load_ed25519 (botan_privkey_t *key, const uint8_t privkey[32])
int	botan_privkey_load_ed448 (botan_privkey_t *key, const uint8_t privkey[57])
int	botan_privkey_load_elgamal (botan_privkey_t *key, botan_mp_t p, botan_mp_t g, botan_mp_t x)
int	botan_privkey_load_frodokem (botan_privkey_t *key, const uint8_t privkey[], size_t key_len, const char *frodo_mode)
int	botan_privkey_load_kyber (botan_privkey_t *key, const uint8_t privkey[], size_t key_len)
int	botan_privkey_load_ml_dsa (botan_privkey_t *key, const uint8_t privkey[], size_t key_len, const char *mldsa_mode)
int	botan_privkey_load_ml_kem (botan_privkey_t *key, const uint8_t privkey[], size_t key_len, const char *mlkem_mode)
int	botan_privkey_load_rsa (botan_privkey_t *key, botan_mp_t rsa_p, botan_mp_t rsa_q, botan_mp_t rsa_e)
int	botan_privkey_load_rsa_pkcs1 (botan_privkey_t *key, const uint8_t bits[], size_t len)
int	botan_privkey_load_slh_dsa (botan_privkey_t *key, const uint8_t privkey[], size_t key_len, const char *slhdsa_mode)
int	botan_privkey_load_sm2 (botan_privkey_t *key, const botan_mp_t scalar, const char *curve_name)
int	botan_privkey_load_sm2_enc (botan_privkey_t *key, const botan_mp_t scalar, const char *curve_name)
int	botan_privkey_load_x25519 (botan_privkey_t *key, const uint8_t privkey[32])
int	botan_privkey_load_x448 (botan_privkey_t *key, const uint8_t privkey[56])
int	botan_privkey_rsa_get_d (botan_mp_t d, botan_privkey_t key)
int	botan_privkey_rsa_get_e (botan_mp_t e, botan_privkey_t key)
int	botan_privkey_rsa_get_n (botan_mp_t n, botan_privkey_t key)
int	botan_privkey_rsa_get_p (botan_mp_t p, botan_privkey_t key)
int	botan_privkey_rsa_get_privkey (botan_privkey_t rsa_key, uint8_t out[], size_t *out_len, uint32_t flags)
int	botan_privkey_rsa_get_q (botan_mp_t q, botan_privkey_t key)
int	botan_privkey_view_kyber_raw_key (botan_privkey_t key, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_privkey_x25519_get_privkey (botan_privkey_t key, uint8_t output[32])
int	botan_privkey_x448_get_privkey (botan_privkey_t key, uint8_t output[56])
int	botan_pubkey_dsa_get_g (botan_mp_t g, botan_pubkey_t key)
int	botan_pubkey_dsa_get_p (botan_mp_t p, botan_pubkey_t key)
int	botan_pubkey_dsa_get_q (botan_mp_t q, botan_pubkey_t key)
int	botan_pubkey_dsa_get_y (botan_mp_t y, botan_pubkey_t key)
int	botan_pubkey_ecc_key_used_explicit_encoding (botan_pubkey_t key)
int	botan_pubkey_ed25519_get_pubkey (botan_pubkey_t key, uint8_t output[32])
int	botan_pubkey_ed448_get_pubkey (botan_pubkey_t key, uint8_t output[57])
int	botan_pubkey_get_field (botan_mp_t output, botan_pubkey_t key, const char *field_name_cstr)
int	botan_pubkey_load_classic_mceliece (botan_pubkey_t *key, const uint8_t pubkey[], size_t key_len, const char *cmce_mode)
int	botan_pubkey_load_dh (botan_pubkey_t *key, botan_mp_t p, botan_mp_t g, botan_mp_t y)
int	botan_pubkey_load_dsa (botan_pubkey_t *key, botan_mp_t p, botan_mp_t q, botan_mp_t g, botan_mp_t y)
int	botan_pubkey_load_ecdh (botan_pubkey_t *key, const botan_mp_t public_x, const botan_mp_t public_y, const char *curve_name)
int	botan_pubkey_load_ecdh_sec1 (botan_pubkey_t *key, const uint8_t sec1[], size_t sec1_len, const char *curve_name)
int	botan_pubkey_load_ecdsa (botan_pubkey_t *key, const botan_mp_t public_x, const botan_mp_t public_y, const char *curve_name)
int	botan_pubkey_load_ecdsa_sec1 (botan_pubkey_t *key, const uint8_t sec1[], size_t sec1_len, const char *curve_name)
int	botan_pubkey_load_ed25519 (botan_pubkey_t *key, const uint8_t pubkey[32])
int	botan_pubkey_load_ed448 (botan_pubkey_t *key, const uint8_t pubkey[57])
int	botan_pubkey_load_elgamal (botan_pubkey_t *key, botan_mp_t p, botan_mp_t g, botan_mp_t y)
int	botan_pubkey_load_frodokem (botan_pubkey_t *key, const uint8_t pubkey[], size_t key_len, const char *frodo_mode)
int	botan_pubkey_load_kyber (botan_pubkey_t *key, const uint8_t pubkey[], size_t key_len)
int	botan_pubkey_load_ml_dsa (botan_pubkey_t *key, const uint8_t pubkey[], size_t key_len, const char *mldsa_mode)
int	botan_pubkey_load_ml_kem (botan_pubkey_t *key, const uint8_t pubkey[], size_t key_len, const char *mlkem_mode)
int	botan_pubkey_load_rsa (botan_pubkey_t *key, botan_mp_t n, botan_mp_t e)
int	botan_pubkey_load_rsa_pkcs1 (botan_pubkey_t *key, const uint8_t bits[], size_t len)
int	botan_pubkey_load_slh_dsa (botan_pubkey_t *key, const uint8_t pubkey[], size_t key_len, const char *slhdsa_mode)
int	botan_pubkey_load_sm2 (botan_pubkey_t *key, const botan_mp_t public_x, const botan_mp_t public_y, const char *curve_name)
int	botan_pubkey_load_sm2_enc (botan_pubkey_t *key, const botan_mp_t public_x, const botan_mp_t public_y, const char *curve_name)
int	botan_pubkey_load_sm2_sec1 (botan_pubkey_t *key, const uint8_t sec1[], size_t sec1_len, const char *curve_name)
int	botan_pubkey_load_x25519 (botan_pubkey_t *key, const uint8_t pubkey[32])
int	botan_pubkey_load_x448 (botan_pubkey_t *key, const uint8_t pubkey[56])
int	botan_pubkey_rsa_get_e (botan_mp_t e, botan_pubkey_t key)
int	botan_pubkey_rsa_get_n (botan_mp_t n, botan_pubkey_t key)
int	botan_pubkey_sm2_compute_za (uint8_t out[], size_t *out_len, const char *ident, const char *hash_algo, const botan_pubkey_t key)
int	botan_pubkey_view_ec_public_point (const botan_pubkey_t key, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_pubkey_view_kyber_raw_key (botan_pubkey_t key, botan_view_ctx ctx, botan_view_bin_fn view)
int	botan_pubkey_x25519_get_pubkey (botan_pubkey_t key, uint8_t output[32])
int	botan_pubkey_x448_get_pubkey (botan_pubkey_t key, uint8_t output[56])

Function Documentation

botan_ec_privkey_get_group()

int botan_ec_privkey_get_group	(	botan_privkey_t	key,
		botan_ec_group_t *	ec_group )

Get the group of an elliptic curve private key

Parameters

key	the EC private key
EC Group	the new object will be placed here

Returns

0 on success, a negative value on failure

Definition at line 859 of file ffi_pkey_algs.cpp.

                                                                                {
   if(Botan::any_null_pointers(ec_group)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
#if defined(BOTAN_HAS_ECC_KEY)
   return ffi_guard_thunk(__func__, [=]() -> int {
      const Botan::EC_PrivateKey* ec_key = dynamic_cast<const Botan::EC_PrivateKey*>(&safe_get(key));
      if(ec_key == nullptr) {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
      return ffi_new_object(ec_group, std::make_unique<Botan::EC_Group>(ec_key->domain()));
   });
#else
   BOTAN_UNUSED(key, ec_group);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan::EC_PublicKey::domain(), Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_ec_privkey_get_private_key()

int botan_ec_privkey_get_private_key	(	botan_privkey_t	key,
		botan_ec_scalar_t *	value )

Loads Diffie Hellman private key

Parameters

key	variable populated with key material
p	prime order of a Z_p group
g	group generator
x	private key

Precondition

key is NULL on input

Postcondition

function allocates memory and assigns to `key'

Returns

0 on success, a negative value on failure */ int botan_privkey_load_dh(botan_privkey_t* key, botan_mp_t p, botan_mp_t g, botan_mp_t x); /** Loads Diffie Hellman public key

Parameters

key	variable populated with key material
p	prime order of a Z_p group
g	group generator
y	public key

Precondition

key is NULL on input

Postcondition

function allocates memory and assigns to `key'

Returns

0 on success, a negative value on failure */ int botan_pubkey_load_dh(botan_pubkey_t* key, botan_mp_t p, botan_mp_t g, botan_mp_t y);

/* Algorithm specific key operations: ElGamal Loads ElGamal public key

Parameters

key	variable populated with key material
p	prime order of a Z_p group
g	group generator
y	public key

Precondition

key is NULL on input

Postcondition

function allocates memory and assigns to `key'

Returns

0 on success, a negative value on failure */ int botan_pubkey_load_elgamal(botan_pubkey_t* key, botan_mp_t p, botan_mp_t g, botan_mp_t y);

/** Loads ElGamal private key

Parameters

key	variable populated with key material
p	prime order of a Z_p group
g	group generator
x	private key

Precondition

key is NULL on input

Postcondition

function allocates memory and assigns to `key'

Returns

0 on success, a negative value on failure */ int botan_privkey_load_elgamal(botan_privkey_t* key, botan_mp_t p, botan_mp_t g, botan_mp_t x);

/* Algorithm specific key operations: EC keys Get the secret scalar of an elliptic curve private key

Parameters

key	the EC private key
value	the new object will be placed here

Returns

0 on success, a negative value on failure

Definition at line 841 of file ffi_pkey_algs.cpp.

                                                                                    {
   if(Botan::any_null_pointers(value)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_ECC_KEY)
   return ffi_guard_thunk(__func__, [=]() -> int {
      const Botan::EC_PrivateKey* ec_key = dynamic_cast<const Botan::EC_PrivateKey*>(&safe_get(key));
      if(ec_key == nullptr) {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
      return ffi_new_object(value, std::make_unique<Botan::EC_Scalar>(ec_key->_private_key()));
   });
#else
   BOTAN_UNUSED(key, value);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::EC_PrivateKey::_private_key(), Botan::any_null_pointers(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_ec_pubkey_get_group()

int botan_ec_pubkey_get_group	(	botan_pubkey_t	key,
		botan_ec_group_t *	ec_group )

Get the group of an elliptic curve public key

Parameters

key	the EC public key
EC Group	the new object will be placed here

Returns

0 on success, a negative value on failure

Definition at line 878 of file ffi_pkey_algs.cpp.

                                                                              {
   if(Botan::any_null_pointers(ec_group)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_ECC_KEY)
   return ffi_guard_thunk(__func__, [=]() -> int {
      const Botan::EC_PublicKey* ec_key = dynamic_cast<const Botan::EC_PublicKey*>(&safe_get(key));
      if(ec_key == nullptr) {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
      return ffi_new_object(ec_group, std::make_unique<Botan::EC_Group>(ec_key->domain()));
   });
#else
   BOTAN_UNUSED(key, ec_group);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan::EC_PublicKey::domain(), Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_mceies_decrypt()

int botan_mceies_decrypt	(	botan_privkey_t	mce_key,
		const char *	aead,
		const uint8_t	ct[],
		size_t	ct_len,
		const uint8_t	ad[],
		size_t	ad_len,
		uint8_t	pt[],
		size_t *	pt_len )

Formerly decrypted a message using McEliece with an AEAD.

Always returns BOTAN_FFI_ERROR_NOT_IMPLEMENTED

Parameters

mce_key	ignored
AEAD Modes	ignored
ct	ignored
ct_len	ignored
ad	ignored
ad_len	ignored
pt	ignored
pt_len	ignored

Returns

BOTAN_FFI_ERROR_NOT_IMPLEMENTED

Definition at line 1564 of file ffi_pkey_algs.cpp.

                                          {
   BOTAN_UNUSED(mce_key_obj, aead, ct, ct_len, ad, ad_len, out, out_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, and BOTAN_UNUSED.

botan_mceies_encrypt()

int botan_mceies_encrypt	(	botan_pubkey_t	mce_key,
		botan_rng_t	rng,
		const char *	aead,
		const uint8_t	pt[],
		size_t	pt_len,
		const uint8_t	ad[],
		size_t	ad_len,
		uint8_t	ct[],
		size_t *	ct_len )

Formerly encrypted a message using McEliece with an AEAD.

Always returns BOTAN_FFI_ERROR_NOT_IMPLEMENTED

Parameters

mce_key	ignored
Random Number Generators	ignored
AEAD Modes	ignored
pt	ignored
pt_len	ignored
ad	ignored
ad_len	ignored
ct	ignored
ct_len	ignored

Returns

BOTAN_FFI_ERROR_NOT_IMPLEMENTED

Definition at line 1576 of file ffi_pkey_algs.cpp.

                                          {
   BOTAN_UNUSED(mce_key_obj, rng_obj, aead, pt, pt_len, ad, ad_len, out, out_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, and BOTAN_UNUSED.

botan_privkey_create_dh()

int botan_privkey_create_dh	(	botan_privkey_t *	key,
		botan_rng_t	rng,
		const char *	param )

Create a new Diffie-Hellman private key

Parameters

key	the new object will be placed here
Random Number Generators	a random number generator
param	the name of the group, eg "modp/ietf/2048"

Returns

0 on success, a negative value on failure

Definition at line 598 of file ffi_pkey_algs.cpp.

                                                                                                  {
   return botan_privkey_create(key_obj, "DH", param_str, rng_obj);
}

References botan_privkey_create().

botan_privkey_create_dsa()

int botan_privkey_create_dsa	(	botan_privkey_t *	key,
		botan_rng_t	rng_obj,
		size_t	pbits,
		size_t	qbits )

Definition at line 360 of file ffi_pkey_algs.cpp.

                                                                                                    {
#if defined(BOTAN_HAS_DSA)
 
   if(Botan::any_null_pointers(rng_obj, key)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   if((pbits % 64 != 0) || (qbits % 8 != 0) || (pbits < 1024) || (pbits > 3072) || (qbits < 160) || (qbits > 256)) {
      return BOTAN_FFI_ERROR_BAD_PARAMETER;
   }
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      Botan::RandomNumberGenerator& rng = safe_get(rng_obj);
      const Botan::DL_Group group(rng, Botan::DL_Group::Prime_Subgroup, pbits, qbits);
      auto dsa = std::make_unique<Botan::DSA_PrivateKey>(rng, group);
      return ffi_new_object(key, std::move(dsa));
   });
#else
   BOTAN_UNUSED(key, rng_obj, pbits, qbits);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), Botan::DL_Group::Prime_Subgroup, and Botan_FFI::safe_get().

botan_privkey_create_ecdh()

int botan_privkey_create_ecdh	(	botan_privkey_t *	key,
		botan_rng_t	rng,
		const char *	params )

Create a new ECDH private key

Parameters

key	the new object will be placed here
Random Number Generators	a random number generator
params	the name of the curve, eg "secp256r1"

Returns

0 on success, a negative value on failure

Definition at line 638 of file ffi_pkey_algs.cpp.

                                                                                                    {
   if(Botan::any_null_pointers(key_obj, param_str)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key_obj = nullptr;
 
   const std::string params(param_str);
 
   if(params == "X25519" || params == "x25519" || params == "curve25519") {
      return botan_privkey_create(key_obj, "X25519", "", rng_obj);
   }
 
   if(params == "X448" || params == "x448") {
      return botan_privkey_create(key_obj, "X448", "", rng_obj);
   }
 
   return botan_privkey_create(key_obj, "ECDH", param_str, rng_obj);
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NULL_POINTER, and botan_privkey_create().

botan_privkey_create_ecdsa()

int botan_privkey_create_ecdsa	(	botan_privkey_t *	key,
		botan_rng_t	rng,
		const char *	params )

Create a new ECDSA private key

Parameters

key	the new object will be placed here
Random Number Generators	a random number generator
params	the name of the curve, eg "secp256r1"

Returns

0 on success, a negative value on failure

Definition at line 439 of file ffi_pkey_algs.cpp.

                                                                                                     {
   return botan_privkey_create(key_obj, "ECDSA", param_str, rng_obj);
}

References botan_privkey_create().

botan_privkey_create_elgamal()

int botan_privkey_create_elgamal	(	botan_privkey_t *	key,
		botan_rng_t	rng_obj,
		size_t	pbits,
		size_t	qbits )

Definition at line 536 of file ffi_pkey_algs.cpp.

                                                                                                        {
#if defined(BOTAN_HAS_ELGAMAL)
   if(Botan::any_null_pointers(key, rng_obj)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
 
   if(pbits < 1024 || qbits < 160) {
      return BOTAN_FFI_ERROR_BAD_PARAMETER;
   }
 
   const Botan::DL_Group::PrimeType prime_type =
      ((pbits - 1) == qbits) ? Botan::DL_Group::Strong : Botan::DL_Group::Prime_Subgroup;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      Botan::RandomNumberGenerator& rng = safe_get(rng_obj);
      const Botan::DL_Group group(rng, prime_type, pbits, qbits);
      auto elg = std::make_unique<Botan::ElGamal_PrivateKey>(rng, group);
      return ffi_new_object(key, std::move(elg));
   });
#else
   BOTAN_UNUSED(key, rng_obj, pbits, qbits);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), Botan::DL_Group::Prime_Subgroup, Botan_FFI::safe_get(), and Botan::DL_Group::Strong.

botan_privkey_create_mceliece()

int botan_privkey_create_mceliece	(	botan_privkey_t *	key,
		botan_rng_t	rng,
		size_t	n,
		size_t	t )

Create a new McEliece private key

Parameters

key	the new object will be placed here
Random Number Generators	a random number generator
n	the code length
t	the error correction capability

Returns

0 on success, a negative value on failure

Definition at line 1559 of file ffi_pkey_algs.cpp.

                                                                                                     {
   const std::string mce_params = std::to_string(n) + "," + std::to_string(t);
   return botan_privkey_create(key_obj, "McEliece", mce_params.c_str(), rng_obj);
}

References botan_privkey_create().

botan_privkey_create_rsa()

int botan_privkey_create_rsa	(	botan_privkey_t *	key,
		botan_rng_t	rng,
		size_t	n_bits )

Create a new RSA private key

Parameters

key	the new object will be placed here
Random Number Generators	a random number generator
n_bits	the bit length of the modulus

Returns

0 on success, a negative value on failure

Definition at line 228 of file ffi_pkey_algs.cpp.

                                                                                           {
   if(n_bits < 1024 || n_bits > 16 * 1024) {
      return BOTAN_FFI_ERROR_BAD_PARAMETER;
   }
 
   const std::string n_str = std::to_string(n_bits);
 
   return botan_privkey_create(key_obj, "RSA", n_str.c_str(), rng_obj);
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, and botan_privkey_create().

botan_privkey_dsa_get_x()

int botan_privkey_dsa_get_x	(	botan_mp_t	n,
		botan_privkey_t	key )

Get the secret value of a DSA private key

Parameters

n	set to the value of the private key
key	the DSA private key

Returns

0 on success, a negative value on failure

Definition at line 419 of file ffi_pkey_algs.cpp.

                                                               {
   return botan_privkey_get_field(x, key, "x");
}

References botan_privkey_get_field().

botan_privkey_ed25519_get_privkey()

int botan_privkey_ed25519_get_privkey	(	botan_privkey_t	key,
		uint8_t	output[64] )

Get the raw encoding of an Ed25519 private key, followed by the public key

Parameters

key	the Ed25519 private key
output	set to the 64 byte concatenation of the private and public keys

Returns

0 on success, a negative value on failure

Definition at line 932 of file ffi_pkey_algs.cpp.

                                                                               {
   if(output == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_ED25519)
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      if(auto ed = dynamic_cast<const Botan::Ed25519_PrivateKey*>(&k)) {
         const auto ed_key = ed->raw_private_key_bits();
         if(ed_key.size() != 64) {
            return BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE;
         }
         Botan::copy_mem(output, ed_key.data(), ed_key.size());
         return BOTAN_FFI_SUCCESS;
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
#else
   BOTAN_UNUSED(key, output);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan::copy_mem().

botan_privkey_ed448_get_privkey()

int botan_privkey_ed448_get_privkey	(	botan_privkey_t	key,
		uint8_t	output[57] )

Get the raw 57 byte encoding of an Ed448 private key

Parameters

key	the Ed448 private key
output	set to the raw private key

Returns

0 on success, a negative value on failure

Definition at line 1012 of file ffi_pkey_algs.cpp.

                                                                             {
   if(output == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_ED448)
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      if(auto ed = dynamic_cast<const Botan::Ed448_PrivateKey*>(&k)) {
         const auto ed_key = ed->raw_private_key_bits();
         Botan::copy_mem(std::span(output, 57), ed_key);
         return BOTAN_FFI_SUCCESS;
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
#else
   BOTAN_UNUSED(key, output);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan::copy_mem().

botan_privkey_get_field()

int botan_privkey_get_field	(	botan_mp_t	output,
		botan_privkey_t	key,
		const char *	field_name )

Get an arbitrary named field from a private key, eg "p" or "q" for RSA

Parameters

output	set to the value of the requested field
key	the private key to query
field_name	the name of the field to retrieve

Returns

0 on success, a negative value on failure

Definition at line 216 of file ffi_pkey_algs.cpp.

                                                                                                 {
   if(field_name_cstr == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   const std::string field_name(field_name_cstr);
 
   return BOTAN_FFI_VISIT(key, [=](const auto& k) { safe_get(output) = privkey_get_field(k, field_name); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, and Botan_FFI::safe_get().

Referenced by botan_privkey_dsa_get_x(), botan_privkey_rsa_get_d(), botan_privkey_rsa_get_e(), botan_privkey_rsa_get_n(), botan_privkey_rsa_get_p(), and botan_privkey_rsa_get_q().

botan_privkey_load_classic_mceliece()

int botan_privkey_load_classic_mceliece	(	botan_privkey_t *	key,
		const uint8_t	privkey[],
		size_t	key_len,
		const char *	cmce_mode )

Load a Classic McEliece private key from its raw encoding

Parameters

key	the new object will be placed here
privkey	the raw private key
key_len	length of privkey in bytes
cmce_mode	the parameter set, eg "348864"

Returns

0 on success, a negative value on failure

Definition at line 1497 of file ffi_pkey_algs.cpp.

                                                               {
#if defined(BOTAN_HAS_CLASSICMCELIECE)
   if(Botan::any_null_pointers(key, privkey, cmce_mode)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      const auto mode = Botan::Classic_McEliece_Parameter_Set::from_string(cmce_mode);
      auto cmce_key = std::make_unique<Botan::Classic_McEliece_PrivateKey>(std::span{privkey, key_len}, mode);
      return ffi_new_object(key, std::move(cmce_key));
   });
#else
   BOTAN_UNUSED(key, privkey, key_len, cmce_mode);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan::Classic_McEliece_Parameter_Set::from_string().

botan_privkey_load_dh()

int botan_privkey_load_dh	(	botan_privkey_t *	key,
		botan_mp_t	p,
		botan_mp_t	g,
		botan_mp_t	x )

Definition at line 602 of file ffi_pkey_algs.cpp.

                                                                                          {
#if defined(BOTAN_HAS_DIFFIE_HELLMAN)
   if(key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
   return ffi_guard_thunk(__func__, [=]() -> int {
      const Botan::DL_Group group(safe_get(p), safe_get(g));
      auto dh = std::make_unique<Botan::DH_PrivateKey>(group, safe_get(x));
      return ffi_new_object(key, std::move(dh));
   });
#else
   BOTAN_UNUSED(key, p, g, x);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_privkey_load_dsa()

int botan_privkey_load_dsa	(	botan_privkey_t *	key,
		botan_mp_t	p,
		botan_mp_t	q,
		botan_mp_t	g,
		botan_mp_t	x )

Load a DSA private key from its group parameters and secret value

Parameters

key	the new object will be placed here
p	the group prime
q	the order of the subgroup
g	the subgroup generator
x	the private key

Returns

0 on success, a negative value on failure

Definition at line 383 of file ffi_pkey_algs.cpp.

                                                                                                         {
#if defined(BOTAN_HAS_DSA)
   if(key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      const Botan::DL_Group group(safe_get(p), safe_get(q), safe_get(g));
      auto dsa = std::make_unique<Botan::DSA_PrivateKey>(group, safe_get(x));
      return ffi_new_object(key, std::move(dsa));
   });
#else
   BOTAN_UNUSED(key, p, q, g, x);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_privkey_load_ecdh()

int botan_privkey_load_ecdh	(	botan_privkey_t *	key,
		botan_mp_t	scalar,
		const char *	curve_name )

Load an ECDH private key from its secret scalar

Parameters

key	the new object will be placed here
scalar	the private scalar
curve_name	the name of the curve, eg "secp256r1"

Returns

0 on success, a negative value on failure

Definition at line 704 of file ffi_pkey_algs.cpp.

                                                                                                   {
#if defined(BOTAN_HAS_ECDH)
   if(Botan::any_null_pointers(key, curve_name)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
   return ffi_guard_thunk(__func__, [=]() -> int {
      std::unique_ptr<Botan::ECDH_PrivateKey> p_key;
      const int rc = privkey_load_ec(p_key, safe_get(scalar), curve_name);
      if(rc == BOTAN_FFI_SUCCESS) {
         ffi_new_object(key, std::move(p_key));
      }
      return rc;
   });
#else
   BOTAN_UNUSED(key, scalar, curve_name);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_privkey_load_ecdsa()

int botan_privkey_load_ecdsa	(	botan_privkey_t *	key,
		botan_mp_t	scalar,
		const char *	curve_name )

Load an ECDSA private key from its secret scalar

Parameters

key	the new object will be placed here
scalar	the private scalar
curve_name	the name of the curve, eg "secp256r1"

Returns

0 on success, a negative value on failure

Definition at line 514 of file ffi_pkey_algs.cpp.

                                                                                                    {
#if defined(BOTAN_HAS_ECDSA)
   if(Botan::any_null_pointers(key, curve_name)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      std::unique_ptr<Botan::ECDSA_PrivateKey> p_key;
      const int rc = privkey_load_ec(p_key, safe_get(scalar), curve_name);
      if(rc == BOTAN_FFI_SUCCESS) {
         ffi_new_object(key, std::move(p_key));
      }
      return rc;
   });
#else
   BOTAN_UNUSED(key, scalar, curve_name);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_privkey_load_ed25519()

int botan_privkey_load_ed25519	(	botan_privkey_t *	key,
		const uint8_t	privkey[32] )

Load an Ed25519 private key from its raw 32 byte encoding

Parameters

key	the new object will be placed here
privkey	the raw private key

Returns

0 on success, a negative value on failure

Definition at line 898 of file ffi_pkey_algs.cpp.

                                                                                {
#if defined(BOTAN_HAS_ED25519)
   if(any_null_pointers(key, privkey)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto ed25519 =
         std::make_unique<Botan::Ed25519_PrivateKey>(Botan::Ed25519_PrivateKey::from_seed(std::span{privkey, 32}));
      return ffi_new_object(key, std::move(ed25519));
   });
#else
   BOTAN_UNUSED(key, privkey);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan_FFI::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan::Ed25519_PrivateKey::from_seed().

botan_privkey_load_ed448()

int botan_privkey_load_ed448	(	botan_privkey_t *	key,
		const uint8_t	privkey[57] )

Load an Ed448 private key from its raw 57 byte encoding

Parameters

key	the new object will be placed here
privkey	the raw private key

Returns

0 on success, a negative value on failure

Definition at line 980 of file ffi_pkey_algs.cpp.

                                                                              {
#if defined(BOTAN_HAS_ED448)
   if(any_null_pointers(key, privkey)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto ed448 = std::make_unique<Botan::Ed448_PrivateKey>(std::span(privkey, 57));
      return ffi_new_object(key, std::move(ed448));
   });
#else
   BOTAN_UNUSED(key, privkey);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan_FFI::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_privkey_load_elgamal()

int botan_privkey_load_elgamal	(	botan_privkey_t *	key,
		botan_mp_t	p,
		botan_mp_t	g,
		botan_mp_t	x )

Definition at line 579 of file ffi_pkey_algs.cpp.

                                                                                               {
#if defined(BOTAN_HAS_ELGAMAL)
   if(key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
   return ffi_guard_thunk(__func__, [=]() -> int {
      const Botan::DL_Group group(safe_get(p), safe_get(g));
      auto elg = std::make_unique<Botan::ElGamal_PrivateKey>(group, safe_get(x));
      return ffi_new_object(key, std::move(elg));
   });
#else
   BOTAN_UNUSED(key, p, g, x);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_privkey_load_frodokem()

int botan_privkey_load_frodokem	(	botan_privkey_t *	key,
		const uint8_t	privkey[],
		size_t	key_len,
		const char *	frodo_mode )

Load a FrodoKEM private key from its raw encoding

Parameters

key	the new object will be placed here
privkey	the raw private key
key_len	length of privkey in bytes
frodo_mode	the parameter set, eg "FrodoKEM-640-SHAKE"

Returns

0 on success, a negative value on failure

Definition at line 1455 of file ffi_pkey_algs.cpp.

                                                                                                                       {
#if defined(BOTAN_HAS_FRODOKEM)
   if(Botan::any_null_pointers(key, privkey, frodo_mode)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      const auto mode = Botan::FrodoKEMMode(frodo_mode);
      auto frodo_key = std::make_unique<Botan::FrodoKEM_PrivateKey>(std::span{privkey, key_len}, mode);
      return ffi_new_object(key, std::move(frodo_key));
   });
#else
   BOTAN_UNUSED(key, privkey, key_len, frodo_mode);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_privkey_load_kyber()

int botan_privkey_load_kyber	(	botan_privkey_t *	key,
		const uint8_t	privkey[],
		size_t	key_len )

Load a Kyber private key from its raw encoding. The parameter set is inferred from the key length.

Parameters

key	the new object will be placed here
privkey	the raw private key
key_len	length of privkey in bytes

Returns

0 on success, a negative value on failure

Definition at line 1205 of file ffi_pkey_algs.cpp.

                                                                                            {
#if defined(BOTAN_HAS_KYBER)
   if(Botan::any_null_pointers(key, privkey)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
 
   const auto mode = [](size_t len) -> std::optional<Botan::KyberMode> {
      if(len == 1632) {
         return Botan::KyberMode::Kyber512_R3;
      } else if(len == 2400) {
         return Botan::KyberMode::Kyber768_R3;
      } else if(len == 3168) {
         return Botan::KyberMode::Kyber1024_R3;
      } else {
         return {};
      }
   }(key_len);
 
   if(mode.has_value()) {
      return ffi_guard_thunk(__func__, [=]() -> int {
         auto kyber = std::make_unique<Botan::Kyber_PrivateKey>(std::span{privkey, key_len}, *mode);
         return ffi_new_object(key, std::move(kyber));
      });
   } else {
      return BOTAN_FFI_ERROR_BAD_PARAMETER;
   }
#else
   BOTAN_UNUSED(key, key_len, privkey);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), Botan::KyberMode::Kyber1024_R3, Botan::KyberMode::Kyber512_R3, and Botan::KyberMode::Kyber768_R3.

botan_privkey_load_ml_dsa()

int botan_privkey_load_ml_dsa	(	botan_privkey_t *	key,
		const uint8_t	privkey[],
		size_t	key_len,
		const char *	mldsa_mode )

Load an ML-DSA private key from its raw encoding

Parameters

key	the new object will be placed here
privkey	the raw private key
key_len	length of privkey in bytes
mldsa_mode	the parameter set, eg "ML-DSA-6x5"

Returns

0 on success, a negative value on failure

Definition at line 1355 of file ffi_pkey_algs.cpp.

                                                                                                                     {
#if defined(BOTAN_HAS_ML_DSA)
   if(Botan::any_null_pointers(key, privkey, mldsa_mode)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto mode = Botan::ML_DSA_Mode(mldsa_mode);
      if(!mode.is_ml_dsa()) {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
 
      auto mldsa_key = std::make_unique<Botan::ML_DSA_PrivateKey>(std::span{privkey, key_len}, mode);
      return ffi_new_object(key, std::move(mldsa_key));
   });
#else
   BOTAN_UNUSED(key, key_len, privkey, mldsa_mode);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_privkey_load_ml_kem()

int botan_privkey_load_ml_kem	(	botan_privkey_t *	key,
		const uint8_t	privkey[],
		size_t	key_len,
		const char *	mlkem_mode )

Load an ML-KEM private key from its raw encoding

Parameters

key	the new object will be placed here
privkey	the raw private key
key_len	length of privkey in bytes
mlkem_mode	the parameter set, eg "ML-KEM-768"

Returns

0 on success, a negative value on failure

Definition at line 1305 of file ffi_pkey_algs.cpp.

                                                                                                                     {
#if defined(BOTAN_HAS_ML_KEM)
   if(Botan::any_null_pointers(key, privkey, mlkem_mode)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto mode = Botan::ML_KEM_Mode(mlkem_mode);
      if(!mode.is_ml_kem()) {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
 
      auto mlkem_key = std::make_unique<Botan::ML_KEM_PrivateKey>(std::span{privkey, key_len}, mode);
      return ffi_new_object(key, std::move(mlkem_key));
   });
#else
   BOTAN_UNUSED(key, key_len, privkey, mlkem_mode);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_privkey_load_rsa()

int botan_privkey_load_rsa	(	botan_privkey_t *	key,
		botan_mp_t	p,
		botan_mp_t	q,
		botan_mp_t	e )

Load an RSA private key from its factors and public exponent

Parameters

key	the new object will be placed here
p	the first prime factor
q	the second prime factor
e	the public exponent

Returns

0 on success, a negative value on failure

Definition at line 238 of file ffi_pkey_algs.cpp.

                                                                                                       {
#if defined(BOTAN_HAS_RSA)
   if(key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto rsa = std::make_unique<Botan::RSA_PrivateKey>(safe_get(rsa_p), safe_get(rsa_q), safe_get(rsa_e));
      return ffi_new_object(key, std::move(rsa));
   });
#else
   BOTAN_UNUSED(key, rsa_p, rsa_q, rsa_e);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_privkey_load_rsa_pkcs1()

int botan_privkey_load_rsa_pkcs1	(	botan_privkey_t *	key,
		const uint8_t	bits[],
		size_t	len )

Load an RSA private key from a PKCS #1 RSAPrivateKey structure

Parameters

key	the new object will be placed here
bits	the DER encoding to load
len	length of bits in bytes

Returns

0 on success, a negative value on failure

Definition at line 255 of file ffi_pkey_algs.cpp.

                                                                                         {
#if defined(BOTAN_HAS_RSA)
   if(Botan::any_null_pointers(key, bits)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      const Botan::AlgorithmIdentifier alg_id("RSA", Botan::AlgorithmIdentifier::USE_NULL_PARAM);
      auto rsa = std::make_unique<Botan::RSA_PrivateKey>(alg_id, std::span{bits, len});
      return ffi_new_object(key, std::move(rsa));
   });
#else
   BOTAN_UNUSED(key, bits, len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan::AlgorithmIdentifier::USE_NULL_PARAM.

botan_privkey_load_slh_dsa()

int botan_privkey_load_slh_dsa	(	botan_privkey_t *	key,
		const uint8_t	privkey[],
		size_t	key_len,
		const char *	slhdsa_mode )

Load an SLH-DSA private key from its raw encoding

Parameters

key	the new object will be placed here
privkey	the raw private key
key_len	length of privkey in bytes
slhdsa_mode	the parameter set, eg "SLH-DSA-SHA2-128s"

Returns

0 on success, a negative value on failure

Definition at line 1405 of file ffi_pkey_algs.cpp.

                                                                                                                       {
#if defined(BOTAN_HAS_SLH_DSA_WITH_SHA2) || defined(BOTAN_HAS_SLH_DSA_WITH_SHAKE)
   if(Botan::any_null_pointers(key, privkey, slhdsa_mode)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto mode = Botan::SLH_DSA_Parameters::create(slhdsa_mode);
      if(!mode.is_slh_dsa()) {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
 
      auto slhdsa_key = std::make_unique<Botan::SLH_DSA_PrivateKey>(std::span{privkey, key_len}, mode);
      return ffi_new_object(key, std::move(slhdsa_key));
   });
#else
   BOTAN_UNUSED(key, key_len, privkey, slhdsa_mode);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_privkey_load_sm2()

int botan_privkey_load_sm2	(	botan_privkey_t *	key,
		botan_mp_t	scalar,
		const char *	curve_name )

Load an SM2 private key from its secret scalar

Parameters

key	the new object will be placed here
scalar	the private scalar
curve_name	the name of the curve, typically "sm2p256v1"

Returns

0 on success, a negative value on failure

Definition at line 806 of file ffi_pkey_algs.cpp.

                                                                                                  {
#if defined(BOTAN_HAS_SM2)
   if(Botan::any_null_pointers(key, curve_name)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      std::unique_ptr<Botan::SM2_PrivateKey> p_key;
      const int rc = privkey_load_ec(p_key, safe_get(scalar), curve_name);
 
      if(rc == BOTAN_FFI_SUCCESS) {
         ffi_new_object(key, std::move(p_key));
      }
      return rc;
   });
#else
   BOTAN_UNUSED(key, scalar, curve_name);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

Referenced by botan_privkey_load_sm2_enc().

botan_privkey_load_sm2_enc()

int botan_privkey_load_sm2_enc	(	botan_privkey_t *	key,
		botan_mp_t	scalar,
		const char *	curve_name )

Load an SM2 encryption private key; identical to botan_privkey_load_sm2

Parameters

key	the new object will be placed here
scalar	the private scalar
curve_name	the name of the curve, typically "sm2p256v1"

Returns

0 on success, a negative value on failure

Definition at line 835 of file ffi_pkey_algs.cpp.

                                                                                                      {
   return botan_privkey_load_sm2(key, scalar, curve_name);
}

References botan_privkey_load_sm2().

botan_privkey_load_x25519()

int botan_privkey_load_x25519	(	botan_privkey_t *	key,
		const uint8_t	privkey[32] )

Load an X25519 private key from its raw 32 byte encoding

Parameters

key	the new object will be placed here
privkey	the raw private key

Returns

0 on success, a negative value on failure

Definition at line 1054 of file ffi_pkey_algs.cpp.

                                                                               {
#if defined(BOTAN_HAS_X25519)
   if(any_null_pointers(key, privkey)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto x25519 = std::make_unique<Botan::X25519_PrivateKey>(std::span{privkey, 32});
      return ffi_new_object(key, std::move(x25519));
   });
#else
   BOTAN_UNUSED(key, privkey);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan_FFI::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_privkey_load_x448()

int botan_privkey_load_x448	(	botan_privkey_t *	key,
		const uint8_t	privkey[56] )

Load an X448 private key from its raw 56 byte encoding

Parameters

key	the new object will be placed here
privkey	the raw private key

Returns

0 on success, a negative value on failure

Definition at line 1130 of file ffi_pkey_algs.cpp.

                                                                             {
#if defined(BOTAN_HAS_X448)
   if(any_null_pointers(key, privkey)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto x448 = std::make_unique<Botan::X448_PrivateKey>(std::span{privkey, 56});
      return ffi_new_object(key, std::move(x448));
   });
#else
   BOTAN_UNUSED(key, privkey);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan_FFI::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_privkey_rsa_get_d()

int botan_privkey_rsa_get_d	(	botan_mp_t	d,
		botan_privkey_t	rsa_key )

Get the private exponent of an RSA private key

Parameters

d	set to the value of the private exponent
rsa_key	the RSA private key

Returns

0 on success, a negative value on failure

Definition at line 323 of file ffi_pkey_algs.cpp.

                                                               {
   return botan_privkey_get_field(d, key, "d");
}

References botan_privkey_get_field().

botan_privkey_rsa_get_e()

int botan_privkey_rsa_get_e	(	botan_mp_t	e,
		botan_privkey_t	rsa_key )

Get the public exponent of an RSA private key

Parameters

e	set to the value of the public exponent
rsa_key	the RSA private key

Returns

0 on success, a negative value on failure

Definition at line 319 of file ffi_pkey_algs.cpp.

                                                               {
   return botan_privkey_get_field(e, key, "e");
}

References botan_privkey_get_field().

botan_privkey_rsa_get_n()

int botan_privkey_rsa_get_n	(	botan_mp_t	n,
		botan_privkey_t	rsa_key )

Get the modulus of an RSA private key

Parameters

n	set to the value of the modulus
rsa_key	the RSA private key

Returns

0 on success, a negative value on failure

Definition at line 315 of file ffi_pkey_algs.cpp.

                                                               {
   return botan_privkey_get_field(n, key, "n");
}

References botan_privkey_get_field().

botan_privkey_rsa_get_p()

int botan_privkey_rsa_get_p	(	botan_mp_t	p,
		botan_privkey_t	rsa_key )

Get the first prime factor of an RSA private key

Parameters

p	set to the value of the factor
rsa_key	the RSA private key

Returns

0 on success, a negative value on failure

Definition at line 307 of file ffi_pkey_algs.cpp.

                                                               {
   return botan_privkey_get_field(p, key, "p");
}

References botan_privkey_get_field().

botan_privkey_rsa_get_privkey()

int botan_privkey_rsa_get_privkey	(	botan_privkey_t	rsa_key,
		uint8_t	out[],
		size_t *	out_len,
		uint32_t	flags )

Export an RSA private key as a PKCS #1 RSAPrivateKey structure

Parameters

rsa_key	the RSA private key
out	output buffer
out_len	on input the size of out, on output the number of bytes written or required
flags	either BOTAN_PRIVKEY_EXPORT_FLAG_DER or BOTAN_PRIVKEY_EXPORT_FLAG_PEM

Returns

0 on success, a negative value on failure

Definition at line 335 of file ffi_pkey_algs.cpp.

                                                                                                           {
#if defined(BOTAN_HAS_RSA)
   return BOTAN_FFI_VISIT(rsa_key, [=](const auto& k) -> int {
      if(const Botan::RSA_PrivateKey* rsa = dynamic_cast<const Botan::RSA_PrivateKey*>(&k)) {
         if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_DER) {
            return write_vec_output(out, out_len, rsa->private_key_bits());
         } else if(flags == BOTAN_PRIVKEY_EXPORT_FLAG_PEM) {
            // TODO define new generic functions for this
            return write_str_output(reinterpret_cast<char*>(out),
                                    out_len,
                                    Botan::PEM_Code::encode(rsa->private_key_bits(), "RSA PRIVATE KEY"));
         } else {
            return BOTAN_FFI_ERROR_BAD_FLAG;
         }
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
#else
   BOTAN_UNUSED(rsa_key, out, out_len, flags);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_VISIT, BOTAN_PRIVKEY_EXPORT_FLAG_DER, BOTAN_PRIVKEY_EXPORT_FLAG_PEM, BOTAN_UNUSED, Botan::PEM_Code::encode(), Botan_FFI::write_str_output(), and Botan_FFI::write_vec_output().

botan_privkey_rsa_get_q()

int botan_privkey_rsa_get_q	(	botan_mp_t	q,
		botan_privkey_t	rsa_key )

Get the second prime factor of an RSA private key

Parameters

q	set to the value of the factor
rsa_key	the RSA private key

Returns

0 on success, a negative value on failure

Definition at line 311 of file ffi_pkey_algs.cpp.

                                                               {
   return botan_privkey_get_field(q, key, "q");
}

References botan_privkey_get_field().

botan_privkey_view_kyber_raw_key()

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

View the raw encoding of a Kyber private key

Parameters

key	the Kyber private key
ctx	an application context passed to the view function
view	the view callback which receives the encoding

Returns

0 on success, a negative value on failure

Definition at line 1271 of file ffi_pkey_algs.cpp.

                                                                                                      {
#if defined(BOTAN_HAS_KYBER)
   return BOTAN_FFI_VISIT(key, [=](const auto& k) -> int {
      if(auto kyber = dynamic_cast<const Botan::Kyber_PrivateKey*>(&k)) {
         return invoke_view_callback(view, ctx, kyber->raw_private_key_bits());
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
#else
   BOTAN_UNUSED(key, ctx, view);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan_FFI::invoke_view_callback().

botan_privkey_x25519_get_privkey()

int botan_privkey_x25519_get_privkey	(	botan_privkey_t	key,
		uint8_t	output[32] )

Get the raw 32 byte encoding of an X25519 private key

Parameters

key	the X25519 private key
output	set to the raw private key

Returns

0 on success, a negative value on failure

Definition at line 1086 of file ffi_pkey_algs.cpp.

                                                                              {
   if(output == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_X25519)
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      if(auto x25519 = dynamic_cast<const Botan::X25519_PrivateKey*>(&k)) {
         const auto x25519_key = x25519->raw_private_key_bits();
         if(x25519_key.size() != 32) {
            return BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE;
         }
         Botan::copy_mem(output, x25519_key.data(), x25519_key.size());
         return BOTAN_FFI_SUCCESS;
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
#else
   BOTAN_UNUSED(key, output);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan::copy_mem().

botan_privkey_x448_get_privkey()

int botan_privkey_x448_get_privkey	(	botan_privkey_t	key,
		uint8_t	output[56] )

Get the raw 56 byte encoding of an X448 private key

Parameters

key	the X448 private key
output	set to the raw private key

Returns

0 on success, a negative value on failure

Definition at line 1162 of file ffi_pkey_algs.cpp.

                                                                            {
   if(output == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_X448)
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      if(auto x448 = dynamic_cast<const Botan::X448_PrivateKey*>(&k)) {
         const auto x448_key = x448->raw_private_key_bits();
         Botan::copy_mem(std::span{output, 56}, x448_key);
         return BOTAN_FFI_SUCCESS;
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
#else
   BOTAN_UNUSED(key, output);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan::copy_mem().

botan_pubkey_dsa_get_g()

int botan_pubkey_dsa_get_g	(	botan_mp_t	d,
		botan_pubkey_t	key )

Get the subgroup generator of a DSA public key

Parameters

d	set to the value of the generator
key	the DSA public key

Returns

0 on success, a negative value on failure

Definition at line 431 of file ffi_pkey_algs.cpp.

                                                             {
   return botan_pubkey_get_field(g, key, "g");
}

References botan_pubkey_get_field().

botan_pubkey_dsa_get_p()

int botan_pubkey_dsa_get_p	(	botan_mp_t	p,
		botan_pubkey_t	key )

Get the group prime of a DSA public key

Parameters

p	set to the value of the group prime
key	the DSA public key

Returns

0 on success, a negative value on failure

Definition at line 423 of file ffi_pkey_algs.cpp.

                                                             {
   return botan_pubkey_get_field(p, key, "p");
}

References botan_pubkey_get_field().

botan_pubkey_dsa_get_q()

int botan_pubkey_dsa_get_q	(	botan_mp_t	q,
		botan_pubkey_t	key )

Get the subgroup order of a DSA public key

Parameters

q	set to the value of the subgroup order
key	the DSA public key

Returns

0 on success, a negative value on failure

Definition at line 427 of file ffi_pkey_algs.cpp.

                                                             {
   return botan_pubkey_get_field(q, key, "q");
}

References botan_pubkey_get_field().

botan_pubkey_dsa_get_y()

int botan_pubkey_dsa_get_y	(	botan_mp_t	y,
		botan_pubkey_t	key )

Get the public value of a DSA public key

Parameters

y	set to the value of the public key
key	the DSA public key

Returns

0 on success, a negative value on failure

Definition at line 435 of file ffi_pkey_algs.cpp.

                                                             {
   return botan_pubkey_get_field(y, key, "y");
}

References botan_pubkey_get_field().

botan_pubkey_ecc_key_used_explicit_encoding()

int botan_pubkey_ecc_key_used_explicit_encoding

(

botan_pubkey_t

key

)

Check if the group of this EC key was encoded using explicit curve parameters rather than a named curve OID

Parameters

key	the EC public key to examine

Returns

1 if explicit encoding was used, 0 if not, negative on error

Definition at line 445 of file ffi_pkey_algs.cpp.

                                                                    {
#if defined(BOTAN_HAS_ECC_KEY)
   return ffi_guard_thunk(__func__, [=]() -> int {
      const Botan::Public_Key& pub_key = safe_get(key);
      const Botan::EC_PublicKey* ec_key = dynamic_cast<const Botan::EC_PublicKey*>(&pub_key);
 
      if(ec_key == nullptr) {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
 
      return ec_key->domain().used_explicit_encoding() ? 1 : 0;
   });
#else
   BOTAN_UNUSED(key);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_UNUSED, Botan::EC_PublicKey::domain(), Botan_FFI::ffi_guard_thunk(), Botan_FFI::safe_get(), and Botan::EC_Group::used_explicit_encoding().

botan_pubkey_ed25519_get_pubkey()

int botan_pubkey_ed25519_get_pubkey	(	botan_pubkey_t	key,
		uint8_t	pubkey[32] )

Get the raw 32 byte encoding of an Ed25519 public key

Parameters

key	the Ed25519 public key
Public Key Algorithms	set to the raw public key

Returns

0 on success, a negative value on failure

Definition at line 955 of file ffi_pkey_algs.cpp.

                                                                            {
   if(output == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_ED25519)
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      if(auto ed = dynamic_cast<const Botan::Ed25519_PublicKey*>(&k)) {
         const std::vector<uint8_t>& ed_key = ed->get_public_key();
         if(ed_key.size() != 32) {
            return BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE;
         }
         Botan::copy_mem(output, ed_key.data(), ed_key.size());
         return BOTAN_FFI_SUCCESS;
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
#else
   BOTAN_UNUSED(key, output);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan::copy_mem().

botan_pubkey_ed448_get_pubkey()

int botan_pubkey_ed448_get_pubkey	(	botan_pubkey_t	key,
		uint8_t	pubkey[57] )

Get the raw 57 byte encoding of an Ed448 public key

Parameters

key	the Ed448 public key
Public Key Algorithms	set to the raw public key

Returns

0 on success, a negative value on failure

Definition at line 1032 of file ffi_pkey_algs.cpp.

                                                                          {
   if(output == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_ED448)
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      if(auto ed = dynamic_cast<const Botan::Ed448_PublicKey*>(&k)) {
         const auto ed_key = ed->public_key_bits();
         Botan::copy_mem(std::span(output, 57), ed_key);
         return BOTAN_FFI_SUCCESS;
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
#else
   BOTAN_UNUSED(key, output);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan::copy_mem().

botan_pubkey_get_field()

int botan_pubkey_get_field	(	botan_mp_t	output,
		botan_pubkey_t	key,
		const char *	field_name )

Get an arbitrary named field from a public key, eg "n" or "e" for RSA

Parameters

output	set to the value of the requested field
key	the public key to query
field_name	the name of the field to retrieve

Returns

0 on success, a negative value on failure

Definition at line 206 of file ffi_pkey_algs.cpp.

                                                                                               {
   if(field_name_cstr == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   const std::string field_name(field_name_cstr);
 
   return BOTAN_FFI_VISIT(key, [=](const auto& k) { safe_get(output) = pubkey_get_field(k, field_name); });
}

References BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_VISIT, and Botan_FFI::safe_get().

Referenced by botan_pubkey_dsa_get_g(), botan_pubkey_dsa_get_p(), botan_pubkey_dsa_get_q(), botan_pubkey_dsa_get_y(), botan_pubkey_rsa_get_e(), and botan_pubkey_rsa_get_n().

botan_pubkey_load_classic_mceliece()

int botan_pubkey_load_classic_mceliece	(	botan_pubkey_t *	key,
		const uint8_t	pubkey[],
		size_t	key_len,
		const char *	cmce_mode )

Load a Classic McEliece public key from its raw encoding

Parameters

key	the new object will be placed here
Public Key Algorithms	the raw public key
key_len	length of pubkey in bytes
cmce_mode	the parameter set, eg "348864"

Returns

0 on success, a negative value on failure

Definition at line 1519 of file ffi_pkey_algs.cpp.

                                                              {
#if defined(BOTAN_HAS_CLASSICMCELIECE)
   if(Botan::any_null_pointers(key, pubkey, cmce_mode)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      const auto mode = Botan::Classic_McEliece_Parameter_Set::from_string(cmce_mode);
      auto cmce_key = std::make_unique<Botan::Classic_McEliece_PublicKey>(std::span{pubkey, key_len}, mode);
      return ffi_new_object(key, std::move(cmce_key));
   });
#else
   BOTAN_UNUSED(key, pubkey, key_len, cmce_mode);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan::Classic_McEliece_Parameter_Set::from_string().

botan_pubkey_load_dh()

int botan_pubkey_load_dh	(	botan_pubkey_t *	key,
		botan_mp_t	p,
		botan_mp_t	g,
		botan_mp_t	y )

Definition at line 619 of file ffi_pkey_algs.cpp.

                                                                                        {
#if defined(BOTAN_HAS_DIFFIE_HELLMAN)
   if(key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
   return ffi_guard_thunk(__func__, [=]() -> int {
      const Botan::DL_Group group(safe_get(p), safe_get(g));
      auto dh = std::make_unique<Botan::DH_PublicKey>(group, safe_get(y));
      return ffi_new_object(key, std::move(dh));
   });
#else
   BOTAN_UNUSED(key, p, g, y);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_pubkey_load_dsa()

int botan_pubkey_load_dsa	(	botan_pubkey_t *	key,
		botan_mp_t	p,
		botan_mp_t	q,
		botan_mp_t	g,
		botan_mp_t	y )

Load a DSA public key from its group parameters and public value

Parameters

key	the new object will be placed here
p	the group prime
q	the order of the subgroup
g	the subgroup generator
y	the public key

Returns

0 on success, a negative value on failure

Definition at line 401 of file ffi_pkey_algs.cpp.

                                                                                                       {
#if defined(BOTAN_HAS_DSA)
   if(key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      const Botan::DL_Group group(safe_get(p), safe_get(q), safe_get(g));
      auto dsa = std::make_unique<Botan::DSA_PublicKey>(group, safe_get(y));
      return ffi_new_object(key, std::move(dsa));
   });
#else
   BOTAN_UNUSED(key, p, q, g, y);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_pubkey_load_ecdh()

int botan_pubkey_load_ecdh	(	botan_pubkey_t *	key,
		botan_mp_t	public_x,
		botan_mp_t	public_y,
		const char *	curve_name )

Load an ECDH public key from the affine coordinates of the public point

Parameters

key	the new object will be placed here
public_x	the x coordinate of the public point
public_y	the y coordinate of the public point
curve_name	the name of the curve, eg "secp256r1"

Returns

0 on success, a negative value on failure

Definition at line 657 of file ffi_pkey_algs.cpp.

                                                   {
#if defined(BOTAN_HAS_ECDH)
   if(Botan::any_null_pointers(key, curve_name)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
   return ffi_guard_thunk(__func__, [=]() -> int {
      std::unique_ptr<Botan::ECDH_PublicKey> p_key;
      const int rc = pubkey_load_ec(p_key, safe_get(public_x), safe_get(public_y), curve_name);
 
      if(rc == BOTAN_FFI_SUCCESS) {
         ffi_new_object(key, std::move(p_key));
      }
      return rc;
   });
#else
   BOTAN_UNUSED(key, public_x, public_y, curve_name);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_pubkey_load_ecdh_sec1()

int botan_pubkey_load_ecdh_sec1	(	botan_pubkey_t *	key,
		const uint8_t	sec1[],
		size_t	sec1_len,
		const char *	curve_name )

Load an ECDH public key from the SEC1 encoding of the public point

Parameters

key	the new object will be placed here
sec1	the SEC1 compressed or uncompressed point encoding
sec1_len	length of sec1 in bytes
curve_name	the name of the curve, eg "secp256r1"

Returns

0 on success, a negative value on failure

Definition at line 681 of file ffi_pkey_algs.cpp.

                                                                                                                    {
#if defined(BOTAN_HAS_ECDH)
   if(Botan::any_null_pointers(key, sec1, curve_name)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      std::unique_ptr<Botan::ECDH_PublicKey> p_key;
 
      const int rc = pubkey_load_ec_sec1(p_key, {sec1, sec1_len}, curve_name);
      if(rc == BOTAN_FFI_SUCCESS) {
         ffi_new_object(key, std::move(p_key));
      }
 
      return rc;
   });
#else
   BOTAN_UNUSED(key, sec1, sec1_len, curve_name);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_pubkey_load_ecdsa()

int botan_pubkey_load_ecdsa	(	botan_pubkey_t *	key,
		botan_mp_t	public_x,
		botan_mp_t	public_y,
		const char *	curve_name )

Load an ECDSA public key from the affine coordinates of the public point

Parameters

key	the new object will be placed here
public_x	the x coordinate of the public point
public_y	the y coordinate of the public point
curve_name	the name of the curve, eg "secp256r1"

Returns

0 on success, a negative value on failure

Definition at line 465 of file ffi_pkey_algs.cpp.

                                                    {
#if defined(BOTAN_HAS_ECDSA)
   if(Botan::any_null_pointers(key, curve_name)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      std::unique_ptr<Botan::ECDSA_PublicKey> p_key;
 
      const int rc = pubkey_load_ec(p_key, safe_get(public_x), safe_get(public_y), curve_name);
      if(rc == BOTAN_FFI_SUCCESS) {
         ffi_new_object(key, std::move(p_key));
      }
 
      return rc;
   });
#else
   BOTAN_UNUSED(key, public_x, public_y, curve_name);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_pubkey_load_ecdsa_sec1()

int botan_pubkey_load_ecdsa_sec1	(	botan_pubkey_t *	key,
		const uint8_t	sec1[],
		size_t	sec1_len,
		const char *	curve_name )

Load an ECDSA public key from the SEC1 encoding of the public point

Parameters

key	the new object will be placed here
sec1	the SEC1 compressed or uncompressed point encoding
sec1_len	length of sec1 in bytes
curve_name	the name of the curve, eg "secp256r1"

Returns

0 on success, a negative value on failure

Definition at line 491 of file ffi_pkey_algs.cpp.

                                                                                                                     {
#if defined(BOTAN_HAS_ECDSA)
   if(Botan::any_null_pointers(key, sec1, curve_name)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      std::unique_ptr<Botan::ECDSA_PublicKey> p_key;
 
      const int rc = pubkey_load_ec_sec1(p_key, {sec1, sec1_len}, curve_name);
      if(rc == BOTAN_FFI_SUCCESS) {
         ffi_new_object(key, std::move(p_key));
      }
 
      return rc;
   });
#else
   BOTAN_UNUSED(key, sec1, sec1_len, curve_name);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_pubkey_load_ed25519()

int botan_pubkey_load_ed25519	(	botan_pubkey_t *	key,
		const uint8_t	pubkey[32] )

Load an Ed25519 public key from its raw 32 byte encoding

Parameters

key	the new object will be placed here
Public Key Algorithms	the raw public key

Returns

0 on success, a negative value on failure

Definition at line 915 of file ffi_pkey_algs.cpp.

                                                                             {
#if defined(BOTAN_HAS_ED25519)
   if(any_null_pointers(key, pubkey)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
   return ffi_guard_thunk(__func__, [=]() -> int {
      const std::vector<uint8_t> pubkey_vec(pubkey, pubkey + 32);
      auto ed25519 = std::make_unique<Botan::Ed25519_PublicKey>(pubkey_vec);
      return ffi_new_object(key, std::move(ed25519));
   });
#else
   BOTAN_UNUSED(key, pubkey);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan_FFI::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_pubkey_load_ed448()

int botan_pubkey_load_ed448	(	botan_pubkey_t *	key,
		const uint8_t	pubkey[57] )

Load an Ed448 public key from its raw 57 byte encoding

Parameters

key	the new object will be placed here
Public Key Algorithms	the raw public key

Returns

0 on success, a negative value on failure

Definition at line 996 of file ffi_pkey_algs.cpp.

                                                                           {
#if defined(BOTAN_HAS_ED448)
   if(any_null_pointers(key, pubkey)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto ed448 = std::make_unique<Botan::Ed448_PublicKey>(std::span(pubkey, 57));
      return ffi_new_object(key, std::move(ed448));
   });
#else
   BOTAN_UNUSED(key, pubkey);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan_FFI::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_pubkey_load_elgamal()

int botan_pubkey_load_elgamal	(	botan_pubkey_t *	key,
		botan_mp_t	p,
		botan_mp_t	g,
		botan_mp_t	y )

Definition at line 562 of file ffi_pkey_algs.cpp.

                                                                                             {
#if defined(BOTAN_HAS_ELGAMAL)
   if(key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
   return ffi_guard_thunk(__func__, [=]() -> int {
      const Botan::DL_Group group(safe_get(p), safe_get(g));
      auto elg = std::make_unique<Botan::ElGamal_PublicKey>(group, safe_get(y));
      return ffi_new_object(key, std::move(elg));
   });
#else
   BOTAN_UNUSED(key, p, g, y);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_pubkey_load_frodokem()

int botan_pubkey_load_frodokem	(	botan_pubkey_t *	key,
		const uint8_t	pubkey[],
		size_t	key_len,
		const char *	frodo_mode )

Load a FrodoKEM public key from its raw encoding

Parameters

key	the new object will be placed here
Public Key Algorithms	the raw public key
key_len	length of pubkey in bytes
frodo_mode	the parameter set, eg "FrodoKEM-640-SHAKE"

Returns

0 on success, a negative value on failure

Definition at line 1474 of file ffi_pkey_algs.cpp.

                                                                                                                    {
#if defined(BOTAN_HAS_FRODOKEM)
   if(Botan::any_null_pointers(key, pubkey, frodo_mode)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      const auto mode = Botan::FrodoKEMMode(frodo_mode);
      auto frodo_key = std::make_unique<Botan::FrodoKEM_PublicKey>(std::span{pubkey, key_len}, mode);
      return ffi_new_object(key, std::move(frodo_key));
   });
#else
   BOTAN_UNUSED(key, pubkey, key_len, frodo_mode);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_pubkey_load_kyber()

int botan_pubkey_load_kyber	(	botan_pubkey_t *	key,
		const uint8_t	pubkey[],
		size_t	key_len )

Load a Kyber public key from its raw encoding. The parameter set is inferred from the key length.

Parameters

key	the new object will be placed here
Public Key Algorithms	the raw public key
key_len	length of pubkey in bytes

Returns

0 on success, a negative value on failure

Definition at line 1238 of file ffi_pkey_algs.cpp.

                                                                                         {
#if defined(BOTAN_HAS_KYBER)
   if(Botan::any_null_pointers(key, pubkey)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
 
   const auto mode = [](size_t len) -> std::optional<Botan::KyberMode> {
      if(len == 800) {
         return Botan::KyberMode::Kyber512_R3;
      } else if(len == 1184) {
         return Botan::KyberMode::Kyber768_R3;
      } else if(len == 1568) {
         return Botan::KyberMode::Kyber1024_R3;
      } else {
         return {};
      }
   }(key_len);
 
   if(mode.has_value()) {
      return ffi_guard_thunk(__func__, [=]() -> int {
         auto kyber = std::make_unique<Botan::Kyber_PublicKey>(std::span{pubkey, key_len}, *mode);
         return ffi_new_object(key, std::move(kyber));
      });
   } else {
      return BOTAN_FFI_ERROR_BAD_PARAMETER;
   }
#else
   BOTAN_UNUSED(key, pubkey, key_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), Botan::KyberMode::Kyber1024_R3, Botan::KyberMode::Kyber512_R3, and Botan::KyberMode::Kyber768_R3.

botan_pubkey_load_ml_dsa()

int botan_pubkey_load_ml_dsa	(	botan_pubkey_t *	key,
		const uint8_t	pubkey[],
		size_t	key_len,
		const char *	mldsa_mode )

Load an ML-DSA public key from its raw encoding

Parameters

key	the new object will be placed here
Public Key Algorithms	the raw public key
key_len	length of pubkey in bytes
mldsa_mode	the parameter set, eg "ML-DSA-6x5"

Returns

0 on success, a negative value on failure

Definition at line 1378 of file ffi_pkey_algs.cpp.

                                                                                                                  {
#if defined(BOTAN_HAS_ML_DSA)
   if(Botan::any_null_pointers(key, pubkey, mldsa_mode)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto mode = Botan::ML_DSA_Mode(mldsa_mode);
      if(!mode.is_ml_dsa()) {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
 
      auto mldsa_key = std::make_unique<Botan::ML_DSA_PublicKey>(std::span{pubkey, key_len}, mode);
      return ffi_new_object(key, std::move(mldsa_key));
   });
#else
   BOTAN_UNUSED(key, key_len, pubkey, mldsa_mode);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_pubkey_load_ml_kem()

int botan_pubkey_load_ml_kem	(	botan_pubkey_t *	key,
		const uint8_t	pubkey[],
		size_t	key_len,
		const char *	mlkem_mode )

Load an ML-KEM public key from its raw encoding

Parameters

key	the new object will be placed here
Public Key Algorithms	the raw public key
key_len	length of pubkey in bytes
mlkem_mode	the parameter set, eg "ML-KEM-768"

Returns

0 on success, a negative value on failure

Definition at line 1328 of file ffi_pkey_algs.cpp.

                                                                                                                  {
#if defined(BOTAN_HAS_ML_KEM)
   if(Botan::any_null_pointers(key, pubkey, mlkem_mode)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto mode = Botan::ML_KEM_Mode(mlkem_mode);
      if(!mode.is_ml_kem()) {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
 
      auto mlkem_key = std::make_unique<Botan::ML_KEM_PublicKey>(std::span{pubkey, key_len}, mode.mode());
      return ffi_new_object(key, std::move(mlkem_key));
   });
#else
   BOTAN_UNUSED(key, key_len, pubkey, mlkem_mode);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_pubkey_load_rsa()

int botan_pubkey_load_rsa	(	botan_pubkey_t *	key,
		botan_mp_t	n,
		botan_mp_t	e )

Load an RSA public key from its modulus and public exponent

Parameters

key	the new object will be placed here
n	the modulus
e	the public exponent

Returns

0 on success, a negative value on failure

Definition at line 273 of file ffi_pkey_algs.cpp.

                                                                           {
#if defined(BOTAN_HAS_RSA)
   if(key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto rsa = std::make_unique<Botan::RSA_PublicKey>(safe_get(n), safe_get(e));
      return ffi_new_object(key, std::move(rsa));
   });
#else
   BOTAN_UNUSED(key, n, e);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

botan_pubkey_load_rsa_pkcs1()

int botan_pubkey_load_rsa_pkcs1	(	botan_pubkey_t *	key,
		const uint8_t	bits[],
		size_t	len )

Load an RSA public key from a PKCS #1 RSAPublicKey structure

Parameters

key	the new object will be placed here
bits	the DER encoding to load
len	length of bits in bytes

Returns

0 on success, a negative value on failure

Definition at line 289 of file ffi_pkey_algs.cpp.

                                                                                       {
#if defined(BOTAN_HAS_RSA)
   if(Botan::any_null_pointers(key, bits)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      const Botan::AlgorithmIdentifier alg_id("RSA", Botan::AlgorithmIdentifier::USE_NULL_PARAM);
      auto rsa = std::make_unique<Botan::RSA_PublicKey>(alg_id, std::span{bits, len});
      return ffi_new_object(key, std::move(rsa));
   });
#else
   BOTAN_UNUSED(key, bits, len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan::AlgorithmIdentifier::USE_NULL_PARAM.

botan_pubkey_load_slh_dsa()

int botan_pubkey_load_slh_dsa	(	botan_pubkey_t *	key,
		const uint8_t	pubkey[],
		size_t	key_len,
		const char *	slhdsa_mode )

Load an SLH-DSA public key from its raw encoding

Parameters

key	the new object will be placed here
Public Key Algorithms	the raw public key
key_len	length of pubkey in bytes
slhdsa_mode	the parameter set, eg "SLH-DSA-SHA2-128s"

Returns

0 on success, a negative value on failure

Definition at line 1428 of file ffi_pkey_algs.cpp.

                                                                                                                    {
#if defined(BOTAN_HAS_SLH_DSA_WITH_SHA2) || defined(BOTAN_HAS_SLH_DSA_WITH_SHAKE)
   if(Botan::any_null_pointers(key, pubkey, slhdsa_mode)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto mode = Botan::SLH_DSA_Parameters::create(slhdsa_mode);
      if(!mode.is_slh_dsa()) {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
 
      auto mldsa_key = std::make_unique<Botan::SLH_DSA_PublicKey>(std::span{pubkey, key_len}, mode);
      return ffi_new_object(key, std::move(mldsa_key));
   });
#else
   BOTAN_UNUSED(key, key_len, pubkey, slhdsa_mode);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_pubkey_load_sm2()

int botan_pubkey_load_sm2	(	botan_pubkey_t *	key,
		botan_mp_t	public_x,
		botan_mp_t	public_y,
		const char *	curve_name )

Load an SM2 public key from the affine coordinates of the public point

Parameters

key	the new object will be placed here
public_x	the x coordinate of the public point
public_y	the y coordinate of the public point
curve_name	the name of the curve, typically "sm2p256v1"

Returns

0 on success, a negative value on failure

Definition at line 759 of file ffi_pkey_algs.cpp.

                                                  {
#if defined(BOTAN_HAS_SM2)
   if(Botan::any_null_pointers(key, curve_name)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      std::unique_ptr<Botan::SM2_PublicKey> p_key;
      if(pubkey_load_ec(p_key, safe_get(public_x), safe_get(public_y), curve_name) == 0) {
         return ffi_new_object(key, std::move(p_key));
      } else {
         return BOTAN_FFI_ERROR_UNKNOWN_ERROR;
      }
   });
#else
   BOTAN_UNUSED(key, public_x, public_y, curve_name);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_ERROR_UNKNOWN_ERROR, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), Botan_FFI::ffi_new_object(), and Botan_FFI::safe_get().

Referenced by botan_pubkey_load_sm2_enc().

botan_pubkey_load_sm2_enc()

int botan_pubkey_load_sm2_enc	(	botan_pubkey_t *	key,
		botan_mp_t	public_x,
		botan_mp_t	public_y,
		const char *	curve_name )

Load an SM2 encryption public key; identical to botan_pubkey_load_sm2

Parameters

key	the new object will be placed here
public_x	the x coordinate of the public point
public_y	the y coordinate of the public point
curve_name	the name of the curve, typically "sm2p256v1"

Returns

0 on success, a negative value on failure

Definition at line 828 of file ffi_pkey_algs.cpp.

                                                      {
   return botan_pubkey_load_sm2(key, public_x, public_y, curve_name);
}

References botan_pubkey_load_sm2().

botan_pubkey_load_sm2_sec1()

int botan_pubkey_load_sm2_sec1	(	botan_pubkey_t *	key,
		const uint8_t	sec1[],
		size_t	sec1_len,
		const char *	curve_name )

Load an SM2 public key from the SEC1 encoding of the public point

Parameters

key	the new object will be placed here
sec1	the SEC1 compressed or uncompressed point encoding
sec1_len	length of sec1 in bytes
curve_name	the name of the curve, typically "sm2p256v1"

Returns

0 on success, a negative value on failure

Definition at line 783 of file ffi_pkey_algs.cpp.

                                                                                                                   {
#if defined(BOTAN_HAS_SM2)
   if(Botan::any_null_pointers(key, sec1, curve_name)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
 
   return ffi_guard_thunk(__func__, [=]() -> int {
      std::unique_ptr<Botan::SM2_PublicKey> p_key;
 
      const int rc = pubkey_load_ec_sec1(p_key, {sec1, sec1_len}, curve_name);
      if(rc == BOTAN_FFI_SUCCESS) {
         ffi_new_object(key, std::move(p_key));
      }
 
      return rc;
   });
#else
   BOTAN_UNUSED(key, sec1, sec1_len, curve_name);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_pubkey_load_x25519()

int botan_pubkey_load_x25519	(	botan_pubkey_t *	key,
		const uint8_t	pubkey[32] )

Load an X25519 public key from its raw 32 byte encoding

Parameters

key	the new object will be placed here
Public Key Algorithms	the raw public key

Returns

0 on success, a negative value on failure

Definition at line 1070 of file ffi_pkey_algs.cpp.

                                                                            {
#if defined(BOTAN_HAS_X25519)
   if(any_null_pointers(key, pubkey)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto x25519 = std::make_unique<Botan::X25519_PublicKey>(std::span{pubkey, 32});
      return ffi_new_object(key, std::move(x25519));
   });
#else
   BOTAN_UNUSED(key, pubkey);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan_FFI::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_pubkey_load_x448()

int botan_pubkey_load_x448	(	botan_pubkey_t *	key,
		const uint8_t	pubkey[56] )

Load an X448 public key from its raw 56 byte encoding

Parameters

key	the new object will be placed here
Public Key Algorithms	the raw public key

Returns

0 on success, a negative value on failure

Definition at line 1146 of file ffi_pkey_algs.cpp.

                                                                          {
#if defined(BOTAN_HAS_X448)
   if(any_null_pointers(key, pubkey)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
   *key = nullptr;
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto x448 = std::make_unique<Botan::X448_PublicKey>(std::span{pubkey, 56});
      return ffi_new_object(key, std::move(x448));
   });
#else
   BOTAN_UNUSED(key, pubkey);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan_FFI::any_null_pointers(), BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_UNUSED, Botan_FFI::ffi_guard_thunk(), and Botan_FFI::ffi_new_object().

botan_pubkey_rsa_get_e()

int botan_pubkey_rsa_get_e	(	botan_mp_t	e,
		botan_pubkey_t	rsa_key )

Get the public exponent of an RSA public key

Parameters

e	set to the value of the public exponent
rsa_key	the RSA public key

Returns

0 on success, a negative value on failure

Definition at line 327 of file ffi_pkey_algs.cpp.

                                                             {
   return botan_pubkey_get_field(e, key, "e");
}

References botan_pubkey_get_field().

botan_pubkey_rsa_get_n()

int botan_pubkey_rsa_get_n	(	botan_mp_t	n,
		botan_pubkey_t	rsa_key )

Get the modulus of an RSA public key

Parameters

n	set to the value of the modulus
rsa_key	the RSA public key

Returns

0 on success, a negative value on failure

Definition at line 331 of file ffi_pkey_algs.cpp.

                                                             {
   return botan_pubkey_get_field(n, key, "n");
}

References botan_pubkey_get_field().

botan_pubkey_sm2_compute_za()

int botan_pubkey_sm2_compute_za	(	uint8_t	out[],
		size_t *	out_len,
		const char *	ident,
		const char *	hash_algo,
		botan_pubkey_t	key )

Compute the SM2 ZA value, the hash of the user identity and public key which is prefixed to the message before signing

Parameters

out	output buffer
out_len	on input the size of out, on output the number of bytes written or required
ident	the user identifier
hash_algo	the hash to use, typically "SM3"
key	the SM2 public key

Returns

0 on success, a negative value on failure

Definition at line 726 of file ffi_pkey_algs.cpp.

                                                                                                       {
   if(Botan::any_null_pointers(out, out_len, ident, hash_algo, key)) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
 
#if defined(BOTAN_HAS_SM2)
   return ffi_guard_thunk(__func__, [=]() -> int {
      const Botan::Public_Key& pub_key = safe_get(key);
      const Botan::EC_PublicKey* ec_key = dynamic_cast<const Botan::EC_PublicKey*>(&pub_key);
 
      if(ec_key == nullptr) {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
 
      if(ec_key->algo_name() != "SM2") {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
 
      const std::string ident_str(ident);
      std::unique_ptr<Botan::HashFunction> hash = Botan::HashFunction::create_or_throw(hash_algo);
 
      const auto& pt = ec_key->_public_ec_point();
 
      const auto za = Botan::sm2_compute_za(*hash, ident_str, ec_key->domain(), pt);
 
      return write_vec_output(out, out_len, za);
   });
#else
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References Botan::EC_PublicKey::_public_ec_point(), Botan::Asymmetric_Key::algo_name(), Botan::any_null_pointers(), BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, Botan::HashFunction::create_or_throw(), Botan::EC_PublicKey::domain(), Botan_FFI::ffi_guard_thunk(), Botan_FFI::safe_get(), Botan::sm2_compute_za(), and Botan_FFI::write_vec_output().

botan_pubkey_view_ec_public_point()

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

View the uncompressed public point associated with the key

Definition at line 1541 of file ffi_pkey_algs.cpp.

                                                                                                            {
#if defined(BOTAN_HAS_ECC_PUBLIC_KEY_CRYPTO)
   return BOTAN_FFI_VISIT(key, [=](const auto& k) -> int {
      if(auto ecc = dynamic_cast<const Botan::EC_PublicKey*>(&k)) {
         auto pt = ecc->_public_ec_point().serialize_uncompressed();
         return invoke_view_callback(view, ctx, pt);
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
#else
   BOTAN_UNUSED(key, view, ctx);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan_FFI::invoke_view_callback().

botan_pubkey_view_kyber_raw_key()

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

View the raw encoding of a Kyber public key

Parameters

key	the Kyber public key
ctx	an application context passed to the view function
view	the view callback which receives the encoding

Returns

0 on success, a negative value on failure

Definition at line 1286 of file ffi_pkey_algs.cpp.

                                                                                                    {
#if defined(BOTAN_HAS_KYBER)
   return BOTAN_FFI_VISIT(key, [=](const auto& k) -> int {
      if(auto kyber = dynamic_cast<const Botan::Kyber_PublicKey*>(&k)) {
         return invoke_view_callback(view, ctx, kyber->public_key_bits());
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
#else
   BOTAN_UNUSED(key, ctx, view);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan_FFI::invoke_view_callback().

botan_pubkey_x25519_get_pubkey()

int botan_pubkey_x25519_get_pubkey	(	botan_pubkey_t	key,
		uint8_t	pubkey[32] )

Get the raw 32 byte encoding of an X25519 public key

Parameters

key	the X25519 public key
Public Key Algorithms	set to the raw public key

Returns

0 on success, a negative value on failure

Definition at line 1109 of file ffi_pkey_algs.cpp.

                                                                           {
   if(output == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_X25519)
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      if(auto x25519 = dynamic_cast<const Botan::X25519_PublicKey*>(&k)) {
         Botan::copy_mem(std::span{output, 32}, x25519->raw_public_key_bits());
         return BOTAN_FFI_SUCCESS;
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
#else
   BOTAN_UNUSED(key, output);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan::copy_mem().

botan_pubkey_x448_get_pubkey()

int botan_pubkey_x448_get_pubkey	(	botan_pubkey_t	key,
		uint8_t	pubkey[56] )

Get the raw 56 byte encoding of an X448 public key

Parameters

key	the X448 public key
Public Key Algorithms	set to the raw public key

Returns

0 on success, a negative value on failure

Definition at line 1182 of file ffi_pkey_algs.cpp.

                                                                         {
   if(output == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }
#if defined(BOTAN_HAS_X448)
   return BOTAN_FFI_VISIT(key, [=](const auto& k) {
      if(auto x448 = dynamic_cast<const Botan::X448_PublicKey*>(&k)) {
         Botan::copy_mem(std::span{output, 56}, x448->raw_public_key_bits());
         return BOTAN_FFI_SUCCESS;
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
#else
   BOTAN_UNUSED(key, output);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

References BOTAN_FFI_ERROR_BAD_PARAMETER, BOTAN_FFI_ERROR_NOT_IMPLEMENTED, BOTAN_FFI_ERROR_NULL_POINTER, BOTAN_FFI_SUCCESS, BOTAN_FFI_VISIT, BOTAN_UNUSED, and Botan::copy_mem().