Botan  2.9.0
Crypto and TLS for C++11
Functions
ffi_pkey.cpp File Reference
#include <botan/ffi.h>
#include <botan/internal/ffi_util.h>
#include <botan/internal/ffi_pkey.h>
#include <botan/internal/ffi_rng.h>
#include <botan/data_src.h>
#include <botan/hash.h>
#include <botan/pkcs8.h>
#include <botan/pk_keys.h>
#include <botan/x509_key.h>
#include <botan/pk_algs.h>

Go to the source code of this file.

Functions

int botan_pkcs_hash_id (const char *hash_name, uint8_t pkcs_id[], size_t *pkcs_id_len)
 
int botan_privkey_algo_name (botan_privkey_t key, char out[], size_t *out_len)
 
int botan_privkey_check_key (botan_privkey_t key, botan_rng_t rng, uint32_t flags)
 
int botan_privkey_create (botan_privkey_t *key_obj, const char *algo_name, const char *algo_params, botan_rng_t rng_obj)
 
int botan_privkey_destroy (botan_privkey_t key)
 
int botan_privkey_export (botan_privkey_t key, uint8_t out[], size_t *out_len, uint32_t flags)
 
int botan_privkey_export_encrypted (botan_privkey_t key, uint8_t out[], size_t *out_len, botan_rng_t rng_obj, const char *pass, const char *, uint32_t flags)
 
int botan_privkey_export_encrypted_pbkdf_iter (botan_privkey_t key, uint8_t out[], size_t *out_len, botan_rng_t rng_obj, const char *pass, size_t pbkdf_iter, const char *maybe_cipher, const char *maybe_pbkdf_hash, uint32_t flags)
 
int botan_privkey_export_encrypted_pbkdf_msec (botan_privkey_t key, uint8_t out[], size_t *out_len, botan_rng_t rng_obj, const char *pass, uint32_t pbkdf_msec, size_t *pbkdf_iters_out, const char *maybe_cipher, const char *maybe_pbkdf_hash, uint32_t flags)
 
int botan_privkey_export_pubkey (botan_pubkey_t *pubout, botan_privkey_t key_obj)
 
int botan_privkey_load (botan_privkey_t *key, botan_rng_t rng_obj, const uint8_t bits[], size_t len, const char *password)
 
int botan_pubkey_algo_name (botan_pubkey_t key, char out[], size_t *out_len)
 
int botan_pubkey_check_key (botan_pubkey_t key, botan_rng_t rng, uint32_t flags)
 
int botan_pubkey_destroy (botan_pubkey_t key)
 
int botan_pubkey_estimated_strength (botan_pubkey_t key, size_t *estimate)
 
int botan_pubkey_export (botan_pubkey_t key, uint8_t out[], size_t *out_len, uint32_t flags)
 
int botan_pubkey_fingerprint (botan_pubkey_t key, const char *hash_fn, uint8_t out[], size_t *out_len)
 
int botan_pubkey_load (botan_pubkey_t *key, const uint8_t bits[], size_t bits_len)
 

Function Documentation

◆ botan_pkcs_hash_id()

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

Definition at line 265 of file ffi_pkey.cpp.

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

266  {
267 #if defined(BOTAN_HAS_HASH_ID)
268  return ffi_guard_thunk(__func__, [=]() -> int {
269  const std::vector<uint8_t> hash_id = Botan::pkcs_hash_id(hash_name);
270  return write_output(pkcs_id, pkcs_id_len, hash_id.data(), hash_id.size());
271  });
272 #else
274 #endif
275  }
int ffi_guard_thunk(const char *func_name, std::function< int()> thunk)
Definition: ffi.cpp:81
int write_output(uint8_t out[], size_t *out_len, const uint8_t buf[], size_t buf_len)
Definition: ffi_util.h:118
std::vector< uint8_t > pkcs_hash_id(const std::string &name)
Definition: hash_id.cpp:77

◆ botan_privkey_algo_name()

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

Definition at line 126 of file ffi_pkey.cpp.

References BOTAN_FFI_DO, and Botan_FFI::write_str_output().

127  {
128  return BOTAN_FFI_DO(Botan::Private_Key, key, k, { return write_str_output(out, out_len, k.algo_name()); });
129  }
int write_str_output(uint8_t out[], size_t *out_len, const std::string &str)
Definition: ffi_util.h:147
#define BOTAN_FFI_DO(T, obj, param, block)
Definition: ffi_util.h:88

◆ botan_privkey_check_key()

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

Definition at line 144 of file ffi_pkey.cpp.

References BOTAN_CHECK_KEY_EXPENSIVE_TESTS, BOTAN_FFI_DO, Botan::PKCS11::flags(), and Botan_FFI::safe_get().

145  {
146  const bool strong = (flags & BOTAN_CHECK_KEY_EXPENSIVE_TESTS);
147  return BOTAN_FFI_DO(Botan::Private_Key, key, k,
148  { return (k.check_key(safe_get(rng), strong) == true) ? 0 : -1; });
149  }
Flags flags(Flag flags)
Definition: p11.h:858
#define BOTAN_CHECK_KEY_EXPENSIVE_TESTS
Definition: ffi.h:936
T & safe_get(botan_struct< T, M > *p)
Definition: ffi_util.h:61
#define BOTAN_FFI_DO(T, obj, param, block)
Definition: ffi_util.h:88

◆ botan_privkey_create()

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

Create a new private key

Parameters
keythe new object will be placed here
algo_namesomething like "RSA" or "ECDSA"
algo_paramsis specific to the algorithm. For RSA, specifies the modulus bit length. For ECC is the name of the curve.
rnga random number generator

Definition at line 26 of file ffi_pkey.cpp.

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

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

30  {
31  return ffi_guard_thunk(__func__, [=]() -> int {
32  if(key_obj == nullptr)
34 
35  *key_obj = nullptr;
36  if(rng_obj == nullptr)
38 
39  Botan::RandomNumberGenerator& rng = safe_get(rng_obj);
40  std::unique_ptr<Botan::Private_Key> key(
41  Botan::create_private_key(algo_name ? algo_name : "RSA",
42  rng,
43  algo_params ? algo_params : ""));
44 
45  if(key)
46  {
47  *key_obj = new botan_privkey_struct(key.release());
48  return BOTAN_FFI_SUCCESS;
49  }
50  else
51  {
53  }
54  });
55  }
int ffi_guard_thunk(const char *func_name, std::function< int()> thunk)
Definition: ffi.cpp:81
std::unique_ptr< Private_Key > create_private_key(const std::string &alg_name, RandomNumberGenerator &rng, const std::string &params, const std::string &provider)
Definition: pk_algs.cpp:268
T & safe_get(botan_struct< T, M > *p)
Definition: ffi_util.h:61

◆ botan_privkey_destroy()

int botan_privkey_destroy ( botan_privkey_t  key)

Definition at line 88 of file ffi_pkey.cpp.

References BOTAN_FFI_CHECKED_DELETE.

89  {
90  return BOTAN_FFI_CHECKED_DELETE(key);
91  }
#define BOTAN_FFI_CHECKED_DELETE(o)
Definition: ffi_util.h:116

◆ botan_privkey_export()

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

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

Definition at line 163 of file ffi_pkey.cpp.

References Botan::PKCS8::BER_encode(), BOTAN_FFI_DO, BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_PRIVKEY_EXPORT_FLAG_DER, BOTAN_PRIVKEY_EXPORT_FLAG_PEM, Botan::PKCS11::flags(), Botan::PKCS8::PEM_encode(), Botan_FFI::write_str_output(), and Botan_FFI::write_vec_output().

164  {
165  return BOTAN_FFI_DO(Botan::Private_Key, key, k, {
167  return write_vec_output(out, out_len, Botan::PKCS8::BER_encode(k));
169  return write_str_output(out, out_len, Botan::PKCS8::PEM_encode(k));
170  else
172  });
173  }
#define BOTAN_PRIVKEY_EXPORT_FLAG_PEM
Definition: ffi.h:1009
Flags flags(Flag flags)
Definition: p11.h:858
int write_vec_output(uint8_t out[], size_t *out_len, const std::vector< uint8_t, Alloc > &buf)
Definition: ffi_util.h:142
int write_str_output(uint8_t out[], size_t *out_len, const std::string &str)
Definition: ffi_util.h:147
#define BOTAN_PRIVKEY_EXPORT_FLAG_DER
Definition: ffi.h:1008
std::string PEM_encode(const Private_Key &key)
Definition: pkcs8.cpp:148
secure_vector< uint8_t > BER_encode(const Private_Key &key)
Definition: pkcs8.cpp:139
#define BOTAN_FFI_DO(T, obj, param, block)
Definition: ffi_util.h:88

◆ botan_privkey_export_encrypted()

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

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

Definition at line 175 of file ffi_pkey.cpp.

References botan_privkey_export_encrypted_pbkdf_iter(), and Botan::PKCS11::flags().

181  {
182  return botan_privkey_export_encrypted_pbkdf_iter(key, out, out_len, rng_obj, pass, 100000, nullptr, nullptr, flags);
183  }
Flags flags(Flag flags)
Definition: p11.h:858
int botan_privkey_export_encrypted_pbkdf_iter(botan_privkey_t key, uint8_t out[], size_t *out_len, botan_rng_t rng_obj, const char *pass, size_t pbkdf_iter, const char *maybe_cipher, const char *maybe_pbkdf_hash, uint32_t flags)
Definition: ffi_pkey.cpp:219

◆ botan_privkey_export_encrypted_pbkdf_iter()

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

Export a private key using the specified number of iterations.

Definition at line 219 of file ffi_pkey.cpp.

References Botan::PKCS8::BER_encode_encrypted_pbkdf_iter(), BOTAN_FFI_DO, BOTAN_PRIVKEY_EXPORT_FLAG_DER, BOTAN_PRIVKEY_EXPORT_FLAG_PEM, Botan::PKCS11::flags(), Botan::PKCS8::PEM_encode_encrypted_pbkdf_iter(), Botan_FFI::safe_get(), Botan_FFI::write_str_output(), and Botan_FFI::write_vec_output().

Referenced by botan_privkey_export_encrypted().

227  {
228  return BOTAN_FFI_DO(Botan::Private_Key, key, k, {
229  Botan::RandomNumberGenerator& rng = safe_get(rng_obj);
230 
231  const std::string cipher = (maybe_cipher ? maybe_cipher : "");
232  const std::string pbkdf_hash = (maybe_pbkdf_hash ? maybe_pbkdf_hash : "");
233 
235  {
236  return write_vec_output(out, out_len,
237  Botan::PKCS8::BER_encode_encrypted_pbkdf_iter(k, rng, pass, pbkdf_iter, cipher, pbkdf_hash));
238  }
240  {
241  return write_str_output(out, out_len,
242  Botan::PKCS8::PEM_encode_encrypted_pbkdf_iter(k, rng, pass, pbkdf_iter, cipher, pbkdf_hash));
243  }
244  else
245  {
246  return -2;
247  }
248  });
249  }
#define BOTAN_PRIVKEY_EXPORT_FLAG_PEM
Definition: ffi.h:1009
Flags flags(Flag flags)
Definition: p11.h:858
std::vector< uint8_t > BER_encode_encrypted_pbkdf_iter(const Private_Key &key, RandomNumberGenerator &rng, const std::string &pass, size_t pbkdf_iterations, const std::string &cipher, const std::string &pbkdf_hash)
Definition: pkcs8.cpp:233
int write_vec_output(uint8_t out[], size_t *out_len, const std::vector< uint8_t, Alloc > &buf)
Definition: ffi_util.h:142
int write_str_output(uint8_t out[], size_t *out_len, const std::string &str)
Definition: ffi_util.h:147
#define BOTAN_PRIVKEY_EXPORT_FLAG_DER
Definition: ffi.h:1008
std::string PEM_encode_encrypted_pbkdf_iter(const Private_Key &key, RandomNumberGenerator &rng, const std::string &pass, size_t pbkdf_iterations, const std::string &cipher, const std::string &pbkdf_hash)
Definition: pkcs8.cpp:266
T & safe_get(botan_struct< T, M > *p)
Definition: ffi_util.h:61
#define BOTAN_FFI_DO(T, obj, param, block)
Definition: ffi_util.h:88

◆ botan_privkey_export_encrypted_pbkdf_msec()

int botan_privkey_export_encrypted_pbkdf_msec ( botan_privkey_t  key,
uint8_t  out[],
size_t *  out_len,
botan_rng_t  rng_obj,
const char *  pass,
uint32_t  pbkdf_msec,
size_t *  pbkdf_iters_out,
const char *  maybe_cipher,
const char *  maybe_pbkdf_hash,
uint32_t  flags 
)

Definition at line 185 of file ffi_pkey.cpp.

References Botan::PKCS8::BER_encode_encrypted_pbkdf_msec(), BOTAN_FFI_DO, BOTAN_PRIVKEY_EXPORT_FLAG_DER, BOTAN_PRIVKEY_EXPORT_FLAG_PEM, Botan::PKCS11::flags(), Botan::PKCS8::PEM_encode_encrypted_pbkdf_msec(), Botan_FFI::safe_get(), Botan_FFI::write_str_output(), and Botan_FFI::write_vec_output().

194  {
195  return BOTAN_FFI_DO(Botan::Private_Key, key, k, {
196  const std::chrono::milliseconds pbkdf_time(pbkdf_msec);
197  Botan::RandomNumberGenerator& rng = safe_get(rng_obj);
198 
199  const std::string cipher = (maybe_cipher ? maybe_cipher : "");
200  const std::string pbkdf_hash = (maybe_pbkdf_hash ? maybe_pbkdf_hash : "");
201 
203  {
204  return write_vec_output(out, out_len,
205  Botan::PKCS8::BER_encode_encrypted_pbkdf_msec(k, rng, pass, pbkdf_time, pbkdf_iters_out, cipher, pbkdf_hash));
206  }
208  {
209  return write_str_output(out, out_len,
210  Botan::PKCS8::PEM_encode_encrypted_pbkdf_msec(k, rng, pass, pbkdf_time, pbkdf_iters_out, cipher, pbkdf_hash));
211  }
212  else
213  {
214  return -2;
215  }
216  });
217  }
#define BOTAN_PRIVKEY_EXPORT_FLAG_PEM
Definition: ffi.h:1009
Flags flags(Flag flags)
Definition: p11.h:858
int write_vec_output(uint8_t out[], size_t *out_len, const std::vector< uint8_t, Alloc > &buf)
Definition: ffi_util.h:142
std::vector< uint8_t > BER_encode_encrypted_pbkdf_msec(const Private_Key &key, RandomNumberGenerator &rng, const std::string &pass, std::chrono::milliseconds pbkdf_msec, size_t *pbkdf_iterations, const std::string &cipher, const std::string &pbkdf_hash)
Definition: pkcs8.cpp:281
int write_str_output(uint8_t out[], size_t *out_len, const std::string &str)
Definition: ffi_util.h:147
#define BOTAN_PRIVKEY_EXPORT_FLAG_DER
Definition: ffi.h:1008
T & safe_get(botan_struct< T, M > *p)
Definition: ffi_util.h:61
#define BOTAN_FFI_DO(T, obj, param, block)
Definition: ffi_util.h:88
std::string PEM_encode_encrypted_pbkdf_msec(const Private_Key &key, RandomNumberGenerator &rng, const std::string &pass, std::chrono::milliseconds pbkdf_msec, size_t *pbkdf_iterations, const std::string &cipher, const std::string &pbkdf_hash)
Definition: pkcs8.cpp:314

◆ botan_privkey_export_pubkey()

int botan_privkey_export_pubkey ( botan_pubkey_t pubout,
botan_privkey_t  key_obj 
)

Definition at line 115 of file ffi_pkey.cpp.

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

116  {
117  return ffi_guard_thunk(__func__, [=]() -> int {
118  std::unique_ptr<Botan::Public_Key>
120 
121  *pubout = new botan_pubkey_struct(pubkey.release());
122  return BOTAN_FFI_SUCCESS;
123  });
124  }
int ffi_guard_thunk(const char *func_name, std::function< int()> thunk)
Definition: ffi.cpp:81
std::vector< uint8_t > BER_encode(const Public_Key &key)
Definition: x509_key.cpp:19
T & safe_get(botan_struct< T, M > *p)
Definition: ffi_util.h:61
Public_Key * load_key(DataSource &source)
Definition: x509_key.cpp:37

◆ botan_privkey_load()

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

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

Definition at line 57 of file ffi_pkey.cpp.

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

60  {
61  BOTAN_UNUSED(rng_obj);
62 
63  *key = nullptr;
64 
65  return ffi_guard_thunk(__func__, [=]() -> int {
66  Botan::DataSource_Memory src(bits, len);
67 
68  std::unique_ptr<Botan::Private_Key> pkcs8;
69 
70  if(password == nullptr)
71  {
72  pkcs8 = Botan::PKCS8::load_key(src);
73  }
74  else
75  {
76  pkcs8 = Botan::PKCS8::load_key(src, std::string(password));
77  }
78 
79  if(pkcs8)
80  {
81  *key = new botan_privkey_struct(pkcs8.release());
82  return BOTAN_FFI_SUCCESS;
83  }
85  });
86  }
int ffi_guard_thunk(const char *func_name, std::function< int()> thunk)
Definition: ffi.cpp:81
#define BOTAN_UNUSED(...)
Definition: assert.h:142
std::unique_ptr< Private_Key > load_key(DataSource &source, std::function< std::string()> get_pass)
Definition: pkcs8.cpp:353

◆ botan_pubkey_algo_name()

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

Definition at line 131 of file ffi_pkey.cpp.

References BOTAN_FFI_DO, and Botan_FFI::write_str_output().

132  {
133  return BOTAN_FFI_DO(Botan::Public_Key, key, k, { return write_str_output(out, out_len, k.algo_name()); });
134  }
int write_str_output(uint8_t out[], size_t *out_len, const std::string &str)
Definition: ffi_util.h:147
#define BOTAN_FFI_DO(T, obj, param, block)
Definition: ffi_util.h:88

◆ botan_pubkey_check_key()

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

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

Definition at line 136 of file ffi_pkey.cpp.

References BOTAN_CHECK_KEY_EXPENSIVE_TESTS, BOTAN_FFI_DO, Botan::PKCS11::flags(), and Botan_FFI::safe_get().

137  {
138  const bool strong = (flags & BOTAN_CHECK_KEY_EXPENSIVE_TESTS);
139 
140  return BOTAN_FFI_DO(Botan::Public_Key, key, k,
141  { return (k.check_key(safe_get(rng), strong) == true) ? 0 : -1; });
142  }
Flags flags(Flag flags)
Definition: p11.h:858
#define BOTAN_CHECK_KEY_EXPENSIVE_TESTS
Definition: ffi.h:936
T & safe_get(botan_struct< T, M > *p)
Definition: ffi_util.h:61
#define BOTAN_FFI_DO(T, obj, param, block)
Definition: ffi_util.h:88

◆ botan_pubkey_destroy()

int botan_pubkey_destroy ( botan_pubkey_t  key)

Definition at line 110 of file ffi_pkey.cpp.

References BOTAN_FFI_CHECKED_DELETE.

111  {
112  return BOTAN_FFI_CHECKED_DELETE(key);
113  }
#define BOTAN_FFI_CHECKED_DELETE(o)
Definition: ffi_util.h:116

◆ botan_pubkey_estimated_strength()

int botan_pubkey_estimated_strength ( botan_pubkey_t  key,
size_t *  estimate 
)

Definition at line 251 of file ffi_pkey.cpp.

References BOTAN_FFI_DO, and Botan::Public_Key::estimated_strength().

252  {
253  return BOTAN_FFI_DO(Botan::Public_Key, key, k, { *estimate = k.estimated_strength(); });
254  }
virtual size_t estimated_strength() const =0
#define BOTAN_FFI_DO(T, obj, param, block)
Definition: ffi_util.h:88

◆ botan_pubkey_export()

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

Definition at line 151 of file ffi_pkey.cpp.

References Botan::X509::BER_encode(), BOTAN_FFI_DO, BOTAN_FFI_ERROR_BAD_FLAG, BOTAN_PRIVKEY_EXPORT_FLAG_DER, BOTAN_PRIVKEY_EXPORT_FLAG_PEM, Botan::PKCS11::flags(), Botan::X509::PEM_encode(), Botan_FFI::write_str_output(), and Botan_FFI::write_vec_output().

152  {
153  return BOTAN_FFI_DO(Botan::Public_Key, key, k, {
155  return write_vec_output(out, out_len, Botan::X509::BER_encode(k));
157  return write_str_output(out, out_len, Botan::X509::PEM_encode(k));
158  else
160  });
161  }
#define BOTAN_PRIVKEY_EXPORT_FLAG_PEM
Definition: ffi.h:1009
std::string PEM_encode(const Public_Key &key)
Definition: x509_key.cpp:28
std::vector< uint8_t > BER_encode(const Public_Key &key)
Definition: x509_key.cpp:19
Flags flags(Flag flags)
Definition: p11.h:858
int write_vec_output(uint8_t out[], size_t *out_len, const std::vector< uint8_t, Alloc > &buf)
Definition: ffi_util.h:142
int write_str_output(uint8_t out[], size_t *out_len, const std::string &str)
Definition: ffi_util.h:147
#define BOTAN_PRIVKEY_EXPORT_FLAG_DER
Definition: ffi.h:1008
#define BOTAN_FFI_DO(T, obj, param, block)
Definition: ffi_util.h:88

◆ botan_pubkey_fingerprint()

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

Definition at line 256 of file ffi_pkey.cpp.

References BOTAN_FFI_DO, Botan::HashFunction::create(), and Botan_FFI::write_vec_output().

258  {
259  return BOTAN_FFI_DO(Botan::Public_Key, key, k, {
260  std::unique_ptr<Botan::HashFunction> h(Botan::HashFunction::create(hash_fn));
261  return write_vec_output(out, out_len, h->process(k.public_key_bits()));
262  });
263  }
int write_vec_output(uint8_t out[], size_t *out_len, const std::vector< uint8_t, Alloc > &buf)
Definition: ffi_util.h:142
static std::unique_ptr< HashFunction > create(const std::string &algo_spec, const std::string &provider="")
Definition: hash.cpp:110
#define BOTAN_FFI_DO(T, obj, param, block)
Definition: ffi_util.h:88

◆ botan_pubkey_load()

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

Definition at line 93 of file ffi_pkey.cpp.

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

95  {
96  *key = nullptr;
97 
98  return ffi_guard_thunk(__func__, [=]() -> int {
99  Botan::DataSource_Memory src(bits, bits_len);
100  std::unique_ptr<Botan::Public_Key> pubkey(Botan::X509::load_key(src));
101 
102  if(pubkey == nullptr)
104 
105  *key = new botan_pubkey_struct(pubkey.release());
106  return BOTAN_FFI_SUCCESS;
107  });
108  }
int ffi_guard_thunk(const char *func_name, std::function< int()> thunk)
Definition: ffi.cpp:81
Public_Key * load_key(DataSource &source)
Definition: x509_key.cpp:37