Botan 2.19.1
Crypto and TLS for C&
ffi.h
Go to the documentation of this file.
1/*
2* FFI (C89 API)
3* (C) 2015,2017 Jack Lloyd
4* (C) 2021 René Fischer
5*
6* Botan is released under the Simplified BSD License (see license.txt)
7*/
8
9#ifndef BOTAN_FFI_H_
10#define BOTAN_FFI_H_
11
12#ifdef __cplusplus
13extern "C" {
14#endif
15
16/*
17This header exports some of botan's functionality via a C89 interface. This API
18is uesd by the Python, OCaml, Rust and Ruby bindings via those languages
19respective ctypes/FFI libraries.
20
21The API is intended to be as easy as possible to call from other
22languages, which often have easy ways to call C, because C. But some C
23code is easier to deal with than others, so to make things easy this
24API follows a few simple rules:
25
26- All interactions are via pointers to opaque structs. No need to worry about
27 structure padding issues and the like.
28
29- All functions return an int error code (except the version calls, which are
30 assumed to always have something to say).
31
32- Use simple types: size_t for lengths, const char* NULL terminated strings,
33 uint8_t for binary.
34
35- No ownership of memory transfers across the API boundary. The API will
36 consume data from const pointers, and will produce output by writing to
37 buffers provided by (and allocated by) the caller.
38
39- If exporting a value (a string or a blob) the function takes a pointer to the
40 output array and a read/write pointer to the length. If the length is insufficient, an
41 error is returned. So passing nullptr/0 allows querying the final value.
42
43 Note this does not apply to all functions, like `botan_hash_final`
44 which is not idempotent and are documented specially. But it's a
45 general theory of operation.
46
47 TODO:
48 - Doxygen comments for all functions/params
49 - TLS
50*/
51
52#include <botan/build.h>
53#include <stdint.h>
54#include <stddef.h>
55
56/**
57* Error codes
58*
59* If you add a new value here be sure to also add it in
60* botan_error_description
61*/
65
68
70
75
82
85
89
91};
92
93/**
94* Convert an error code into a string. Returns "Unknown error"
95* if the error code is not a known one.
96*/
97BOTAN_PUBLIC_API(2,8) const char* botan_error_description(int err);
98
99/**
100* Return the version of the currently supported FFI API. This is
101* expressed in the form YYYYMMDD of the release date of this version
102* of the API.
103*/
104BOTAN_PUBLIC_API(2,0) uint32_t botan_ffi_api_version(void);
105
106/**
107* Return 0 (ok) if the version given is one this library supports.
108* botan_ffi_supports_api(botan_ffi_api_version()) will always return 0.
109*/
110BOTAN_PUBLIC_API(2,0) int botan_ffi_supports_api(uint32_t api_version);
111
112/**
113* Return a free-form version string, e.g., 2.0.0
114*/
115BOTAN_PUBLIC_API(2,0) const char* botan_version_string(void);
116
117/**
118* Return the major version of the library
119*/
120BOTAN_PUBLIC_API(2,0) uint32_t botan_version_major(void);
121
122/**
123* Return the minor version of the library
124*/
125BOTAN_PUBLIC_API(2,0) uint32_t botan_version_minor(void);
126
127/**
128* Return the patch version of the library
129*/
130BOTAN_PUBLIC_API(2,0) uint32_t botan_version_patch(void);
131
132/**
133* Return the date this version was released as
134* an integer, or 0 if an unreleased version
135*/
136BOTAN_PUBLIC_API(2,0) uint32_t botan_version_datestamp(void);
137
138/**
139* Returns 0 if x[0..len] == y[0..len], or otherwise -1
140*/
141BOTAN_PUBLIC_API(2,3) int botan_constant_time_compare(const uint8_t* x, const uint8_t* y, size_t len);
142
143/**
144* Deprecated equivalent to botan_constant_time_compare
145*/
146BOTAN_PUBLIC_API(2,0) int botan_same_mem(const uint8_t* x, const uint8_t* y, size_t len);
147
148/**
149* Clear out memory using a system specific approach to bypass elision by the
150* compiler (currently using RtlSecureZeroMemory or tricks with volatile pointers).
151*/
152BOTAN_PUBLIC_API(2,2) int botan_scrub_mem(void* mem, size_t bytes);
153
154#define BOTAN_FFI_HEX_LOWER_CASE 1
155
156/**
157* Perform hex encoding
158* @param x is some binary data
159* @param len length of x in bytes
160* @param out an array of at least x*2 bytes
161* @param flags flags out be upper or lower case?
162* @return 0 on success, 1 on failure
163*/
164BOTAN_PUBLIC_API(2,0) int botan_hex_encode(const uint8_t* x, size_t len, char* out, uint32_t flags);
165
166/**
167* Perform hex decoding
168* @param hex_str a string of hex chars (whitespace is ignored)
169* @param in_len the length of hex_str
170* @param out the output buffer should be at least strlen(hex_str)/2 bytes
171* @param out_len the size of out
172*/
173BOTAN_PUBLIC_API(2,3) int botan_hex_decode(const char* hex_str, size_t in_len, uint8_t* out, size_t* out_len);
174
175/**
176* Perform base64 encoding
177*/
178BOTAN_PUBLIC_API(2,3) int botan_base64_encode(const uint8_t* x, size_t len, char* out, size_t* out_len);
179
180
181/**
182* Perform base64 decoding
183*/
184BOTAN_PUBLIC_API(2,3) int botan_base64_decode(const char* base64_str, size_t in_len,
185 uint8_t* out, size_t* out_len);
186
187/**
188* RNG type
189*/
190typedef struct botan_rng_struct* botan_rng_t;
191
192/**
193* Initialize a random number generator object
194* @param rng rng object
195* @param rng_type type of the rng, possible values:
196* "system": system RNG
197* "user": userspace RNG
198* "user-threadsafe": userspace RNG, with internal locking
199* "rdrand": directly read RDRAND
200* Set rng_type to null to let the library choose some default.
201*/
202BOTAN_PUBLIC_API(2,0) int botan_rng_init(botan_rng_t* rng, const char* rng_type);
203
204/**
205* Initialize a custom random number generator from a set of callback functions
206* @param rng rng object
207* @param rng_name name of the rng
208* @param context An application-specific context passed to the callback functions
209* @param get_cb Callback for getting random bytes from the rng, return 0 for success
210* @param add_entry_cb Callback for adding entropy to the rng, return 0 for success, may be NULL
211* @param destroy_cb Callback called when rng is destroyed, may be NULL
212*/
213BOTAN_PUBLIC_API(2,18) int botan_rng_init_custom(botan_rng_t* rng_out, const char* rng_name, void* context,
214 int(* get_cb)(void* context, uint8_t* out, size_t out_len),
215 int(* add_entropy_cb)(void* context, const uint8_t input[], size_t length),
216 void(* destroy_cb)(void* context));
217
218/**
219* Get random bytes from a random number generator
220* @param rng rng object
221* @param out output buffer of size out_len
222* @param out_len number of requested bytes
223* @return 0 on success, negative on failure
224*/
225BOTAN_PUBLIC_API(2,0) int botan_rng_get(botan_rng_t rng, uint8_t* out, size_t out_len);
226
227/**
228* Reseed a random number generator
229* Uses the System_RNG as a seed generator.
230*
231* @param rng rng object
232* @param bits number of bits to to reseed with
233* @return 0 on success, a negative value on failure
234*/
235BOTAN_PUBLIC_API(2,0) int botan_rng_reseed(botan_rng_t rng, size_t bits);
236
237/**
238* Reseed a random number generator
239*
240* @param rng rng object
241* @param source_rng the rng that will be read from
242* @param bits number of bits to to reseed with
243* @return 0 on success, a negative value on failure
244*/
246 botan_rng_t source_rng,
247 size_t bits);
248
249/**
250* Add some seed material to a random number generator
251*
252* @param rng rng object
253* @param entropy the data to add
254* @param entropy_len length of entropy buffer
255* @return 0 on success, a negative value on failure
256*/
258 const uint8_t* entropy,
259 size_t entropy_len);
260
261/**
262* Frees all resources of the random number generator object
263* @param rng rng object
264* @return 0 if success, error if invalid object handle
265*/
267
268/*
269* Hash type
270*/
271typedef struct botan_hash_struct* botan_hash_t;
272
273/**
274* Initialize a hash function object
275* @param hash hash object
276* @param hash_name name of the hash function, e.g., "SHA-384"
277* @param flags should be 0 in current API revision, all other uses are reserved
278* and return BOTAN_FFI_ERROR_BAD_FLAG
279*/
280BOTAN_PUBLIC_API(2,0) int botan_hash_init(botan_hash_t* hash, const char* hash_name, uint32_t flags);
281
282/**
283* Copy the state of a hash function object
284* @param dest destination hash object
285* @param source source hash object
286* @return 0 on success, a negative value on failure
287*/
289
290/**
291* Writes the output length of the hash function to *output_length
292* @param hash hash object
293* @param output_length output buffer to hold the hash function output length
294* @return 0 on success, a negative value on failure
295*/
296BOTAN_PUBLIC_API(2,0) int botan_hash_output_length(botan_hash_t hash, size_t* output_length);
297
298/**
299* Writes the block size of the hash function to *block_size
300* @param hash hash object
301* @param block_size output buffer to hold the hash function output length
302* @return 0 on success, a negative value on failure
303*/
304BOTAN_PUBLIC_API(2,2) int botan_hash_block_size(botan_hash_t hash, size_t* block_size);
305
306/**
307* Send more input to the hash function
308* @param hash hash object
309* @param in input buffer
310* @param in_len number of bytes to read from the input buffer
311* @return 0 on success, a negative value on failure
312*/
313BOTAN_PUBLIC_API(2,0) int botan_hash_update(botan_hash_t hash, const uint8_t* in, size_t in_len);
314
315/**
316* Finalizes the hash computation and writes the output to
317* out[0:botan_hash_output_length()] then reinitializes for computing
318* another digest as if botan_hash_clear had been called.
319* @param hash hash object
320* @param out output buffer
321* @return 0 on success, a negative value on failure
322*/
323BOTAN_PUBLIC_API(2,0) int botan_hash_final(botan_hash_t hash, uint8_t out[]);
324
325/**
326* Reinitializes the state of the hash computation. A hash can
327* be computed (with update/final) immediately.
328* @param hash hash object
329* @return 0 on success, a negative value on failure
330*/
332
333/**
334* Frees all resources of the hash object
335* @param hash hash object
336* @return 0 if success, error if invalid object handle
337*/
339
340/**
341* Get the name of this hash function
342* @param hash the object to read
343* @param name output buffer
344* @param name_len on input, the length of buffer, on success the number of bytes written
345*/
346BOTAN_PUBLIC_API(2,8) int botan_hash_name(botan_hash_t hash, char* name, size_t* name_len);
347
348/*
349* Message Authentication type
350*/
351typedef struct botan_mac_struct* botan_mac_t;
352
353/**
354* Initialize a message authentication code object
355* @param mac mac object
356* @param mac_name name of the hash function, e.g., "HMAC(SHA-384)"
357* @param flags should be 0 in current API revision, all other uses are reserved
358* and return a negative value (error code)
359* @return 0 on success, a negative value on failure
360*/
361BOTAN_PUBLIC_API(2,0) int botan_mac_init(botan_mac_t* mac, const char* mac_name, uint32_t flags);
362
363/**
364* Writes the output length of the message authentication code to *output_length
365* @param mac mac object
366* @param output_length output buffer to hold the MAC output length
367* @return 0 on success, a negative value on failure
368*/
369BOTAN_PUBLIC_API(2,0) int botan_mac_output_length(botan_mac_t mac, size_t* output_length);
370
371/**
372* Sets the key on the MAC
373* @param mac mac object
374* @param key buffer holding the key
375* @param key_len size of the key buffer in bytes
376* @return 0 on success, a negative value on failure
377*/
378BOTAN_PUBLIC_API(2,0) int botan_mac_set_key(botan_mac_t mac, const uint8_t* key, size_t key_len);
379
380/**
381* Send more input to the message authentication code
382* @param mac mac object
383* @param buf input buffer
384* @param len number of bytes to read from the input buffer
385* @return 0 on success, a negative value on failure
386*/
387BOTAN_PUBLIC_API(2,0) int botan_mac_update(botan_mac_t mac, const uint8_t* buf, size_t len);
388
389/**
390* Finalizes the MAC computation and writes the output to
391* out[0:botan_mac_output_length()] then reinitializes for computing
392* another MAC as if botan_mac_clear had been called.
393* @param mac mac object
394* @param out output buffer
395* @return 0 on success, a negative value on failure
396*/
397BOTAN_PUBLIC_API(2,0) int botan_mac_final(botan_mac_t mac, uint8_t out[]);
398
399/**
400* Reinitializes the state of the MAC computation. A MAC can
401* be computed (with update/final) immediately.
402* @param mac mac object
403* @return 0 on success, a negative value on failure
404*/
406
407/**
408* Get the name of this MAC
409* @param mac the object to read
410* @param name output buffer
411* @param name_len on input, the length of buffer, on success the number of bytes written
412*/
413BOTAN_PUBLIC_API(2,8) int botan_mac_name(botan_mac_t mac, char* name, size_t* name_len);
414
415/**
416* Get the key length limits of this auth code
417* @param mac the object to read
418* @param out_minimum_keylength if non-NULL, will be set to minimum keylength of MAC
419* @param out_maximum_keylength if non-NULL, will be set to maximum keylength of MAC
420* @param out_keylength_modulo if non-NULL will be set to byte multiple of valid keys
421*/
423 size_t* out_minimum_keylength,
424 size_t* out_maximum_keylength,
425 size_t* out_keylength_modulo);
426
427/**
428* Frees all resources of the MAC object
429* @param mac mac object
430* @return 0 if success, error if invalid object handle
431*/
433
434/*
435* Cipher modes
436*/
437typedef struct botan_cipher_struct* botan_cipher_t;
438
439#define BOTAN_CIPHER_INIT_FLAG_MASK_DIRECTION 1
440#define BOTAN_CIPHER_INIT_FLAG_ENCRYPT 0
441#define BOTAN_CIPHER_INIT_FLAG_DECRYPT 1
442
443/**
444* Initialize a cipher object
445*/
446BOTAN_PUBLIC_API(2,0) int botan_cipher_init(botan_cipher_t* cipher, const char* name, uint32_t flags);
447
448/**
449* Return the name of the cipher object
450*/
451BOTAN_PUBLIC_API(2,8) int botan_cipher_name(botan_cipher_t cipher, char* name, size_t* name_len);
452
453/**
454* Return the output length of this cipher, for a particular input length.
455*/
456BOTAN_PUBLIC_API(2,8) int botan_cipher_output_length(botan_cipher_t cipher, size_t in_len, size_t* out_len);
457
458/**
459* Return if the specified nonce length is valid for this cipher
460*/
462
463/**
464* Get the tag length of the cipher (0 for non-AEAD modes)
465*/
466BOTAN_PUBLIC_API(2,0) int botan_cipher_get_tag_length(botan_cipher_t cipher, size_t* tag_size);
467
468/**
469* Get the default nonce length of this cipher
470*/
472
473/**
474* Return the update granularity of the cipher; botan_cipher_update must be
475* called with blocks of this size, except for the final.
476*/
478
479/**
480* Get information about the key lengths. Prefer botan_cipher_get_keyspec
481*/
483 size_t* out_minimum_keylength,
484 size_t* out_maximum_keylength);
485
486/**
487* Get information about the supported key lengths.
488*/
490 size_t* min_keylen,
491 size_t* max_keylen,
492 size_t* mod_keylen);
493
494/**
495* Set the key for this cipher object
496*/
498 const uint8_t* key, size_t key_len);
499
500/**
501* Reset the message specific state for this cipher.
502* Without resetting the keys, this resets the nonce, and any state
503* associated with any message bits that have been processed so far.
504*
505* It is conceptually equivalent to calling botan_cipher_clear followed
506* by botan_cipher_set_key with the original key.
507*/
509
510/**
511* Set the associated data. Will fail if cipher is not an AEAD
512*/
514 const uint8_t* ad, size_t ad_len);
515
516/**
517* Begin processing a new message using the provided nonce
518*/
520 const uint8_t* nonce, size_t nonce_len);
521
522#define BOTAN_CIPHER_UPDATE_FLAG_FINAL (1U << 0)
523
524/**
525* Encrypt some data
526*/
528 uint32_t flags,
529 uint8_t output[],
530 size_t output_size,
531 size_t* output_written,
532 const uint8_t input_bytes[],
533 size_t input_size,
534 size_t* input_consumed);
535
536/**
537* Reset the key, nonce, AD and all other state on this cipher object
538*/
540
541/**
542* Destroy the cipher object
543* @return 0 if success, error if invalid object handle
544*/
546
547/*
548* Derive a key from a passphrase for a number of iterations
549* @param pbkdf_algo PBKDF algorithm, e.g., "PBKDF2(SHA-256)"
550* @param out buffer to store the derived key, must be of out_len bytes
551* @param out_len the desired length of the key to produce
552* @param passphrase the password to derive the key from
553* @param salt a randomly chosen salt
554* @param salt_len length of salt in bytes
555* @param iterations the number of iterations to use (use 10K or more)
556* @return 0 on success, a negative value on failure
557*
558* Deprecated: use
559* botan_pwdhash(pbkdf_algo, iterations, 0, 0, out, out_len,
560* passphrase, 0, salt, salt_len);
561*/
562BOTAN_PUBLIC_API(2,0) int
563BOTAN_DEPRECATED("Use botan_pwdhash")
564botan_pbkdf(const char* pbkdf_algo,
565 uint8_t out[], size_t out_len,
566 const char* passphrase,
567 const uint8_t salt[], size_t salt_len,
568 size_t iterations);
569
570/**
571* Derive a key from a passphrase, running until msec time has elapsed.
572* @param pbkdf_algo PBKDF algorithm, e.g., "PBKDF2(SHA-256)"
573* @param out buffer to store the derived key, must be of out_len bytes
574* @param out_len the desired length of the key to produce
575* @param passphrase the password to derive the key from
576* @param salt a randomly chosen salt
577* @param salt_len length of salt in bytes
578* @param milliseconds_to_run if iterations is zero, then instead the PBKDF is
579* run until milliseconds_to_run milliseconds has passed
580* @param out_iterations_used set to the number iterations executed
581* @return 0 on success, a negative value on failure
582*
583* Deprecated: use
584*
585* botan_pwdhash_timed(pbkdf_algo,
586* static_cast<uint32_t>(ms_to_run),
587* iterations_used,
588* nullptr,
589* nullptr,
590* out, out_len,
591* password, 0,
592* salt, salt_len);
593*/
594BOTAN_PUBLIC_API(2,0) int botan_pbkdf_timed(const char* pbkdf_algo,
595 uint8_t out[], size_t out_len,
596 const char* passphrase,
597 const uint8_t salt[], size_t salt_len,
598 size_t milliseconds_to_run,
599 size_t* out_iterations_used);
600
601
602/*
603* Derive a key from a passphrase
604* @param algo PBKDF algorithm, e.g., "PBKDF2(SHA-256)" or "Scrypt"
605* @param param1 the first PBKDF algorithm parameter
606* @param param2 the second PBKDF algorithm parameter (may be zero if unneeded)
607* @param param3 the third PBKDF algorithm parameter (may be zero if unneeded)
608* @param out buffer to store the derived key, must be of out_len bytes
609* @param out_len the desired length of the key to produce
610* @param passphrase the password to derive the key from
611* @param passphrase_len if > 0, specifies length of password. If len == 0, then
612* strlen will be called on passphrase to compute the length.
613* @param salt a randomly chosen salt
614* @param salt_len length of salt in bytes
615* @return 0 on success, a negative value on failure
616*/
618 const char* algo,
619 size_t param1,
620 size_t param2,
621 size_t param3,
622 uint8_t out[],
623 size_t out_len,
624 const char* passphrase,
625 size_t passphrase_len,
626 const uint8_t salt[],
627 size_t salt_len);
628
629/*
630* Derive a key from a passphrase
631* @param pbkdf_algo PBKDF algorithm, e.g., "Scrypt" or "PBKDF2(SHA-256)"
632* @param msec the desired runtime in milliseconds
633* @param param1 will be set to the first password hash parameter
634* @param param2 will be set to the second password hash parameter
635* @param param3 will be set to the third password hash parameter
636* @param out buffer to store the derived key, must be of out_len bytes
637* @param out_len the desired length of the key to produce
638* @param passphrase the password to derive the key from
639* @param passphrase_len if > 0, specifies length of password. If len == 0, then
640* strlen will be called on passphrase to compute the length.
641* @param salt a randomly chosen salt
642* @param salt_len length of salt in bytes
643* @return 0 on success, a negative value on failure
644*/
646 const char* algo,
647 uint32_t msec,
648 size_t* param1,
649 size_t* param2,
650 size_t* param3,
651 uint8_t out[],
652 size_t out_len,
653 const char* passphrase,
654 size_t passphrase_len,
655 const uint8_t salt[],
656 size_t salt_len);
657
658/**
659* Derive a key using scrypt
660* Deprecated; use
661* botan_pwdhash("Scrypt", N, r, p, out, out_len, password, 0, salt, salt_len);
662*/
663BOTAN_PUBLIC_API(2,8) int
664BOTAN_DEPRECATED("Use botan_pwdhash")
665botan_scrypt(uint8_t out[], size_t out_len,
666 const char* passphrase,
667 const uint8_t salt[], size_t salt_len,
668 size_t N, size_t r, size_t p);
669
670/**
671* Derive a key
672* @param kdf_algo KDF algorithm, e.g., "SP800-56C"
673* @param out buffer holding the derived key, must be of length out_len
674* @param out_len the desired output length in bytes
675* @param secret the secret input
676* @param secret_len size of secret in bytes
677* @param salt a diversifier
678* @param salt_len size of salt in bytes
679* @param label purpose for the derived keying material
680* @param label_len size of label in bytes
681* @return 0 on success, a negative value on failure
682*/
683BOTAN_PUBLIC_API(2,0) int botan_kdf(const char* kdf_algo,
684 uint8_t out[], size_t out_len,
685 const uint8_t secret[], size_t secret_len,
686 const uint8_t salt[], size_t salt_len,
687 const uint8_t label[], size_t label_len);
688
689/*
690* Raw Block Cipher (PRP) interface
691*/
692typedef struct botan_block_cipher_struct* botan_block_cipher_t;
693
694/**
695* Initialize a block cipher object
696*/
698 const char* cipher_name);
699
700/**
701* Destroy a block cipher object
702* @return 0 if success, error if invalid object handle
703*/
705
706/**
707* Reinitializes the block cipher
708* @return 0 on success, a negative value on failure
709*/
711
712/**
713* Set the key for a block cipher instance
714*/
716 const uint8_t key[], size_t len);
717
718/**
719* Return the positive block size of this block cipher, or negative to
720* indicate an error
721*/
723
724/**
725* Encrypt one or more blocks with the cipher
726*/
728 const uint8_t in[],
729 uint8_t out[],
730 size_t blocks);
731
732/**
733* Decrypt one or more blocks with the cipher
734*/
736 const uint8_t in[],
737 uint8_t out[],
738 size_t blocks);
739
740/**
741* Get the name of this block cipher
742* @param cipher the object to read
743* @param name output buffer
744* @param name_len on input, the length of buffer, on success the number of bytes written
745*/
747 char* name, size_t* name_len);
748
749
750/**
751* Get the key length limits of this block cipher
752* @param cipher the object to read
753* @param out_minimum_keylength if non-NULL, will be set to minimum keylength of cipher
754* @param out_maximum_keylength if non-NULL, will be set to maximum keylength of cipher
755* @param out_keylength_modulo if non-NULL will be set to byte multiple of valid keys
756*/
758 size_t* out_minimum_keylength,
759 size_t* out_maximum_keylength,
760 size_t* out_keylength_modulo);
761
762/*
763* Multiple precision integers (MPI)
764*/
765typedef struct botan_mp_struct* botan_mp_t;
766
767/**
768* Initialize an MPI
769*/
771
772/**
773* Destroy (deallocate) an MPI
774* @return 0 if success, error if invalid object handle
775*/
777
778/**
779* Convert the MPI to a hex string. Writes botan_mp_num_bytes(mp)*2 + 1 bytes
780*/
781BOTAN_PUBLIC_API(2,1) int botan_mp_to_hex(const botan_mp_t mp, char* out);
782
783/**
784* Convert the MPI to a string. Currently base == 10 and base == 16 are supported.
785*/
786BOTAN_PUBLIC_API(2,1) int botan_mp_to_str(const botan_mp_t mp, uint8_t base, char* out, size_t* out_len);
787
788/**
789* Set the MPI to zero
790*/
792
793/**
794* Set the MPI value from an int
795*/
796BOTAN_PUBLIC_API(2,1) int botan_mp_set_from_int(botan_mp_t mp, int initial_value);
797
798/**
799* Set the MPI value from another MP object
800*/
802
803/**
804* Set the MPI value from a string
805*/
806BOTAN_PUBLIC_API(2,1) int botan_mp_set_from_str(botan_mp_t dest, const char* str);
807
808/**
809* Set the MPI value from a string with arbitrary radix.
810* For arbitrary being 10 or 16.
811*/
812BOTAN_PUBLIC_API(2,1) int botan_mp_set_from_radix_str(botan_mp_t dest, const char* str, size_t radix);
813
814/**
815* Return the number of significant bits in the MPI
816*/
817BOTAN_PUBLIC_API(2,1) int botan_mp_num_bits(const botan_mp_t n, size_t* bits);
818
819/**
820* Return the number of significant bytes in the MPI
821*/
822BOTAN_PUBLIC_API(2,1) int botan_mp_num_bytes(const botan_mp_t n, size_t* bytes);
823
824/*
825* Convert the MPI to a big-endian binary string. Writes botan_mp_num_bytes to vec
826*/
827BOTAN_PUBLIC_API(2,1) int botan_mp_to_bin(const botan_mp_t mp, uint8_t vec[]);
828
829/*
830* Set an MP to the big-endian binary value
831*/
832BOTAN_PUBLIC_API(2,1) int botan_mp_from_bin(const botan_mp_t mp, const uint8_t vec[], size_t vec_len);
833
834/*
835* Convert the MPI to a uint32_t, if possible. Fails if MPI is negative or too large.
836*/
837BOTAN_PUBLIC_API(2,1) int botan_mp_to_uint32(const botan_mp_t mp, uint32_t* val);
838
839/**
840* This function should have been named mp_is_non_negative. Returns 1
841* iff mp is greater than *or equal to* zero. Use botan_mp_is_negative
842* to detect negative numbers, botan_mp_is_zero to check for zero.
843*/
845
846/**
847* Return 1 iff mp is less than 0
848*/
850
852
854
855BOTAN_PUBLIC_API(2,1) BOTAN_DEPRECATED("Use botan_mp_get_bit(0)")
856int botan_mp_is_odd(const botan_mp_t mp);
857BOTAN_PUBLIC_API(2,1) BOTAN_DEPRECATED("Use botan_mp_get_bit(0)")
858int botan_mp_is_even(const botan_mp_t mp);
859
860BOTAN_PUBLIC_API(2,8) int botan_mp_add_u32(botan_mp_t result, const botan_mp_t x, uint32_t y);
861BOTAN_PUBLIC_API(2,8) int botan_mp_sub_u32(botan_mp_t result, const botan_mp_t x, uint32_t y);
862
863BOTAN_PUBLIC_API(2,1) int botan_mp_add(botan_mp_t result, const botan_mp_t x, const botan_mp_t y);
864BOTAN_PUBLIC_API(2,1) int botan_mp_sub(botan_mp_t result, const botan_mp_t x, const botan_mp_t y);
865BOTAN_PUBLIC_API(2,1) int botan_mp_mul(botan_mp_t result, const botan_mp_t x, const botan_mp_t y);
866
868 botan_mp_t remainder,
869 const botan_mp_t x, const botan_mp_t y);
870
872 const botan_mp_t y, const botan_mp_t mod);
873
874/*
875* Returns 0 if x != y
876* Returns 1 if x == y
877* Returns negative number on error
878*/
879BOTAN_PUBLIC_API(2,1) int botan_mp_equal(const botan_mp_t x, const botan_mp_t y);
880
881/*
882* Sets *result to comparison result:
883* -1 if x < y, 0 if x == y, 1 if x > y
884* Returns negative number on error or zero on success
885*/
886BOTAN_PUBLIC_API(2,1) int botan_mp_cmp(int* result, const botan_mp_t x, const botan_mp_t y);
887
888/*
889* Swap two botan_mp_t
890*/
892
893/* Return (base^exponent) % modulus */
894BOTAN_PUBLIC_API(2,1) int botan_mp_powmod(botan_mp_t out, const botan_mp_t base, const botan_mp_t exponent, const botan_mp_t modulus);
895
896BOTAN_PUBLIC_API(2,1) int botan_mp_lshift(botan_mp_t out, const botan_mp_t in, size_t shift);
897BOTAN_PUBLIC_API(2,1) int botan_mp_rshift(botan_mp_t out, const botan_mp_t in, size_t shift);
898
899BOTAN_PUBLIC_API(2,1) int botan_mp_mod_inverse(botan_mp_t out, const botan_mp_t in, const botan_mp_t modulus);
900
901BOTAN_PUBLIC_API(2,1) int botan_mp_rand_bits(botan_mp_t rand_out, botan_rng_t rng, size_t bits);
902
904 const botan_mp_t lower_bound, const botan_mp_t upper_bound);
905
906BOTAN_PUBLIC_API(2,1) int botan_mp_gcd(botan_mp_t out, const botan_mp_t x, const botan_mp_t y);
907
908/**
909* Returns 0 if n is not prime
910* Returns 1 if n is prime
911* Returns negative number on error
912*/
913BOTAN_PUBLIC_API(2,1) int botan_mp_is_prime(const botan_mp_t n, botan_rng_t rng, size_t test_prob);
914
915/**
916* Returns 0 if specified bit of n is not set
917* Returns 1 if specified bit of n is set
918* Returns negative number on error
919*/
920BOTAN_PUBLIC_API(2,1) int botan_mp_get_bit(const botan_mp_t n, size_t bit);
921
922/**
923* Set the specified bit
924*/
925BOTAN_PUBLIC_API(2,1) int botan_mp_set_bit(botan_mp_t n, size_t bit);
926
927/**
928* Clear the specified bit
929*/
930BOTAN_PUBLIC_API(2,1) int botan_mp_clear_bit(botan_mp_t n, size_t bit);
931
932/* Bcrypt password hashing */
933
934/**
935* Create a password hash using Bcrypt
936* @param out buffer holding the password hash, should be of length 64 bytes
937* @param out_len the desired output length in bytes
938* @param password the password
939* @param rng a random number generator
940* @param work_factor how much work to do to slow down guessing attacks
941* @param flags should be 0 in current API revision, all other uses are reserved
942* and return BOTAN_FFI_ERROR_BAD_FLAG
943* @return 0 on success, a negative value on failure
944
945* Output is formatted bcrypt $2a$...
946*/
947BOTAN_PUBLIC_API(2,0) int botan_bcrypt_generate(uint8_t* out, size_t* out_len,
948 const char* password,
949 botan_rng_t rng,
950 size_t work_factor,
951 uint32_t flags);
952
953/**
954* Check a previously created password hash
955* @param pass the password to check against
956* @param hash the stored hash to check against
957* @return 0 if if this password/hash combination is valid,
958* 1 if the combination is not valid (but otherwise well formed),
959* negative on error
960*/
961BOTAN_PUBLIC_API(2,0) int botan_bcrypt_is_valid(const char* pass, const char* hash);
962
963/*
964* Public/private key creation, import, ...
965*/
966typedef struct botan_privkey_struct* botan_privkey_t;
967
968/**
969* Create a new private key
970* @param key the new object will be placed here
971* @param algo_name something like "RSA" or "ECDSA"
972* @param algo_params is specific to the algorithm. For RSA, specifies
973* the modulus bit length. For ECC is the name of the curve.
974* @param rng a random number generator
975*/
977 const char* algo_name,
978 const char* algo_params,
979 botan_rng_t rng);
980
981#define BOTAN_CHECK_KEY_EXPENSIVE_TESTS 1
982
984
985BOTAN_PUBLIC_API(2,0) BOTAN_DEPRECATED("Use botan_privkey_create")
986int botan_privkey_create_rsa(botan_privkey_t* key, botan_rng_t rng, size_t n_bits);
987BOTAN_PUBLIC_API(2,0) BOTAN_DEPRECATED("Use botan_privkey_create")
988int botan_privkey_create_ecdsa(botan_privkey_t* key, botan_rng_t rng, const char* params);
989BOTAN_PUBLIC_API(2,0) BOTAN_DEPRECATED("Use botan_privkey_create")
990int botan_privkey_create_ecdh(botan_privkey_t* key, botan_rng_t rng, const char* params);
991BOTAN_PUBLIC_API(2,0) BOTAN_DEPRECATED("Use botan_privkey_create")
992int botan_privkey_create_mceliece(botan_privkey_t* key, botan_rng_t rng, size_t n, size_t t);
993BOTAN_PUBLIC_API(2,0) BOTAN_DEPRECATED("Use botan_privkey_create")
994int botan_privkey_create_dh(botan_privkey_t* key, botan_rng_t rng, const char* param);
995
996/**
997 * Generates DSA key pair. Gives to a caller control over key length
998 * and order of a subgroup 'q'.
999 *
1000 * @param key handler to the resulting key
1001 * @param rng initialized PRNG
1002 * @param pbits length of the key in bits. Must be between in range (1024, 3072)
1003 * and multiple of 64. Bit size of the prime 'p'
1004 * @param qbits order of the subgroup. Must be in range (160, 256) and multiple
1005 * of 8
1006 *
1007 * @returns BOTAN_FFI_SUCCESS Success, `key' initialized with DSA key
1008 * @returns BOTAN_FFI_ERROR_NULL_POINTER either `key' or `rng' is NULL
1009 * @returns BOTAN_FFI_ERROR_BAD_PARAMETER unexpected value for either `pbits' or
1010 * `qbits'
1011 * @returns BOTAN_FFI_ERROR_NOT_IMPLEMENTED functionality not implemented
1012 *
1013*/
1015 botan_privkey_t* key,
1016 botan_rng_t rng,
1017 size_t pbits,
1018 size_t qbits);
1019
1020/**
1021 * Generates ElGamal key pair. Caller has a control over key length
1022 * and order of a subgroup 'q'. Function is able to use two types of
1023 * primes:
1024 * * if pbits-1 == qbits then safe primes are used for key generation
1025 * * otherwise generation uses group of prime order
1026 *
1027 * @param key handler to the resulting key
1028 * @param rng initialized PRNG
1029 * @param pbits length of the key in bits. Must be at least 1024
1030 * @param qbits order of the subgroup. Must be at least 160
1031 *
1032 * @returns BOTAN_FFI_SUCCESS Success, `key' initialized with DSA key
1033 * @returns BOTAN_FFI_ERROR_NULL_POINTER either `key' or `rng' is NULL
1034 * @returns BOTAN_FFI_ERROR_BAD_PARAMETER unexpected value for either `pbits' or
1035 * `qbits'
1036 * @returns BOTAN_FFI_ERROR_NOT_IMPLEMENTED functionality not implemented
1037 *
1038*/
1040 botan_privkey_t* key,
1041 botan_rng_t rng,
1042 size_t pbits,
1043 size_t qbits);
1044
1045/**
1046* Input currently assumed to be PKCS #8 structure;
1047* Set password to NULL to indicate no encryption expected
1048* Starting in 2.8.0, the rng parameter is unused and may be set to null
1049*/
1051 botan_rng_t rng,
1052 const uint8_t bits[], size_t len,
1053 const char* password);
1054
1055/**
1056* @return 0 if success, error if invalid object handle
1057*/
1059
1060#define BOTAN_PRIVKEY_EXPORT_FLAG_DER 0
1061#define BOTAN_PRIVKEY_EXPORT_FLAG_PEM 1
1062
1063/**
1064* On input *out_len is number of bytes in out[]
1065* On output *out_len is number of bytes written (or required)
1066* If out is not big enough no output is written, *out_len is set and 1 is returned
1067* Returns 0 on success and sets
1068* If some other error occurs a negative integer is returned.
1069*/
1071 uint8_t out[], size_t* out_len,
1072 uint32_t flags);
1073
1074BOTAN_PUBLIC_API(2,8) int botan_privkey_algo_name(botan_privkey_t key, char out[], size_t* out_len);
1075
1076/**
1077* Set encryption_algo to NULL or "" to have the library choose a default (recommended)
1078*/
1079BOTAN_DEPRECATED("Use botan_privkey_export_encrypted_pbkdf_{msec,iter}")
1080BOTAN_PUBLIC_API(2,0) int botan_privkey_export_encrypted(botan_privkey_t key,
1081 uint8_t out[], size_t* out_len,
1082 botan_rng_t rng,
1083 const char* passphrase,
1084 const char* encryption_algo,
1085 uint32_t flags);
1086
1087/*
1088* Export a private key, running PBKDF for specified amount of time
1089* @param key the private key to export
1090*/
1091BOTAN_PUBLIC_API(2,0) int botan_privkey_export_encrypted_pbkdf_msec(botan_privkey_t key,
1092 uint8_t out[], size_t* out_len,
1093 botan_rng_t rng,
1094 const char* passphrase,
1095 uint32_t pbkdf_msec_runtime,
1096 size_t* pbkdf_iterations_out,
1097 const char* cipher_algo,
1098 const char* pbkdf_algo,
1099 uint32_t flags);
1100
1101/**
1102* Export a private key using the specified number of iterations.
1103*/
1104BOTAN_PUBLIC_API(2,0) int botan_privkey_export_encrypted_pbkdf_iter(botan_privkey_t key,
1105 uint8_t out[], size_t* out_len,
1106 botan_rng_t rng,
1107 const char* passphrase,
1108 size_t pbkdf_iterations,
1109 const char* cipher_algo,
1110 const char* pbkdf_algo,
1111 uint32_t flags);
1112
1113typedef struct botan_pubkey_struct* botan_pubkey_t;
1114
1115BOTAN_PUBLIC_API(2,0) int botan_pubkey_load(botan_pubkey_t* key, const uint8_t bits[], size_t len);
1116
1117BOTAN_PUBLIC_API(2,0) int botan_privkey_export_pubkey(botan_pubkey_t* out, botan_privkey_t in);
1118
1119BOTAN_PUBLIC_API(2,0) int botan_pubkey_export(botan_pubkey_t key, uint8_t out[], size_t* out_len, uint32_t flags);
1120
1121BOTAN_PUBLIC_API(2,0) int botan_pubkey_algo_name(botan_pubkey_t key, char out[], size_t* out_len);
1122
1123/**
1124* Returns 0 if key is valid, negative if invalid key or some other error
1125*/
1126BOTAN_PUBLIC_API(2,0) int botan_pubkey_check_key(botan_pubkey_t key, botan_rng_t rng, uint32_t flags);
1127
1128BOTAN_PUBLIC_API(2,0) int botan_pubkey_estimated_strength(botan_pubkey_t key, size_t* estimate);
1129
1130BOTAN_PUBLIC_API(2,0) int botan_pubkey_fingerprint(botan_pubkey_t key, const char* hash,
1131 uint8_t out[], size_t* out_len);
1132
1133/**
1134* @return 0 if success, error if invalid object handle
1135*/
1136BOTAN_PUBLIC_API(2,0) int botan_pubkey_destroy(botan_pubkey_t key);
1137
1138/*
1139* Get arbitrary named fields from public or privat keys
1140*/
1141BOTAN_PUBLIC_API(2,0) int botan_pubkey_get_field(botan_mp_t output,
1142 botan_pubkey_t key,
1143 const char* field_name);
1144
1145BOTAN_PUBLIC_API(2,0) int botan_privkey_get_field(botan_mp_t output,
1146 botan_privkey_t key,
1147 const char* field_name);
1148
1149/*
1150* Algorithm specific key operations: RSA
1151*/
1152BOTAN_PUBLIC_API(2,0) int botan_privkey_load_rsa(botan_privkey_t* key,
1153 botan_mp_t p,
1154 botan_mp_t q,
1155 botan_mp_t e);
1156
1157BOTAN_PUBLIC_API(2,8) int botan_privkey_load_rsa_pkcs1(botan_privkey_t* key,
1158 const uint8_t bits[],
1159 size_t len);
1160
1161BOTAN_PUBLIC_API(2,0) BOTAN_DEPRECATED("Use botan_privkey_get_field")
1162int botan_privkey_rsa_get_p(botan_mp_t p, botan_privkey_t rsa_key);
1163BOTAN_PUBLIC_API(2,0) BOTAN_DEPRECATED("Use botan_privkey_get_field")
1164int botan_privkey_rsa_get_q(botan_mp_t q, botan_privkey_t rsa_key);
1165BOTAN_PUBLIC_API(2,0) BOTAN_DEPRECATED("Use botan_privkey_get_field")
1166int botan_privkey_rsa_get_d(botan_mp_t d, botan_privkey_t rsa_key);
1167BOTAN_PUBLIC_API(2,0) BOTAN_DEPRECATED("Use botan_privkey_get_field")
1168int botan_privkey_rsa_get_n(botan_mp_t n, botan_privkey_t rsa_key);
1169BOTAN_PUBLIC_API(2,0) BOTAN_DEPRECATED("Use botan_privkey_get_field")
1170int botan_privkey_rsa_get_e(botan_mp_t e, botan_privkey_t rsa_key);
1171
1172BOTAN_PUBLIC_API(2,8) int botan_privkey_rsa_get_privkey(botan_privkey_t rsa_key,
1173 uint8_t out[], size_t* out_len,
1174 uint32_t flags);
1175
1176BOTAN_PUBLIC_API(2,0) int botan_pubkey_load_rsa(botan_pubkey_t* key,
1177 botan_mp_t n,
1178 botan_mp_t e);
1179
1180BOTAN_PUBLIC_API(2,0) BOTAN_DEPRECATED("Use botan_pubkey_get_field")
1181int botan_pubkey_rsa_get_e(botan_mp_t e, botan_pubkey_t rsa_key);
1182BOTAN_PUBLIC_API(2,0) BOTAN_DEPRECATED("Use botan_pubkey_get_field")
1183int botan_pubkey_rsa_get_n(botan_mp_t n, botan_pubkey_t rsa_key);
1184
1185/*
1186* Algorithm specific key operations: DSA
1187*/
1188BOTAN_PUBLIC_API(2,0) int botan_privkey_load_dsa(botan_privkey_t* key,
1189 botan_mp_t p,
1190 botan_mp_t q,
1191 botan_mp_t g,
1192 botan_mp_t x);
1193
1194BOTAN_PUBLIC_API(2,0) int botan_pubkey_load_dsa(botan_pubkey_t* key,
1195 botan_mp_t p,
1196 botan_mp_t q,
1197 botan_mp_t g,
1198 botan_mp_t y);
1199
1200BOTAN_PUBLIC_API(2,0) BOTAN_DEPRECATED("Use botan_privkey_get_field")
1201int botan_privkey_dsa_get_x(botan_mp_t n, botan_privkey_t key);
1202
1203BOTAN_PUBLIC_API(2,0) BOTAN_DEPRECATED("Use botan_pubkey_get_field")
1204int botan_pubkey_dsa_get_p(botan_mp_t p, botan_pubkey_t key);
1205BOTAN_PUBLIC_API(2,0) BOTAN_DEPRECATED("Use botan_pubkey_get_field")
1206int botan_pubkey_dsa_get_q(botan_mp_t q, botan_pubkey_t key);
1207BOTAN_PUBLIC_API(2,0) BOTAN_DEPRECATED("Use botan_pubkey_get_field")
1208int botan_pubkey_dsa_get_g(botan_mp_t d, botan_pubkey_t key);
1209BOTAN_PUBLIC_API(2,0) BOTAN_DEPRECATED("Use botan_pubkey_get_field")
1210int botan_pubkey_dsa_get_y(botan_mp_t y, botan_pubkey_t key);
1211
1212/*
1213* Loads Diffie Hellman private key
1214*
1215* @param key variable populated with key material
1216* @param p prime order of a Z_p group
1217* @param g group generator
1218* @param x private key
1219*
1220* @pre key is NULL on input
1221* @post function allocates memory and assigns to `key'
1222*
1223* @return 0 on success, a negative value on failure
1224*/
1225BOTAN_PUBLIC_API(2,0) int botan_privkey_load_dh(botan_privkey_t* key,
1226 botan_mp_t p,
1227 botan_mp_t g,
1228 botan_mp_t x);
1229/**
1230* Loads Diffie Hellman public key
1231*
1232* @param key variable populated with key material
1233* @param p prime order of a Z_p group
1234* @param g group generator
1235* @param y public key
1236*
1237* @pre key is NULL on input
1238* @post function allocates memory and assigns to `key'
1239*
1240* @return 0 on success, a negative value on failure
1241*/
1242BOTAN_PUBLIC_API(2,0) int botan_pubkey_load_dh(botan_pubkey_t* key,
1243 botan_mp_t p,
1244 botan_mp_t g,
1245 botan_mp_t y);
1246
1247/*
1248* Algorithm specific key operations: ElGamal
1249*/
1250
1251/**
1252* Loads ElGamal public key
1253* @param key variable populated with key material
1254* @param p prime order of a Z_p group
1255* @param g group generator
1256* @param y public key
1257*
1258* @pre key is NULL on input
1259* @post function allocates memory and assigns to `key'
1260*
1261* @return 0 on success, a negative value on failure
1262*/
1263BOTAN_PUBLIC_API(2,0) int botan_pubkey_load_elgamal(botan_pubkey_t* key,
1264 botan_mp_t p,
1265 botan_mp_t g,
1266 botan_mp_t y);
1267
1268/**
1269* Loads ElGamal private key
1270*
1271* @param key variable populated with key material
1272* @param p prime order of a Z_p group
1273* @param g group generator
1274* @param x private key
1275*
1276* @pre key is NULL on input
1277* @post function allocates memory and assigns to `key'
1278*
1279* @return 0 on success, a negative value on failure
1280*/
1281BOTAN_PUBLIC_API(2,0) int botan_privkey_load_elgamal(botan_privkey_t* key,
1282 botan_mp_t p,
1283 botan_mp_t g,
1284 botan_mp_t x);
1285
1286/*
1287* Algorithm specific key operations: Ed25519
1288*/
1289
1290BOTAN_PUBLIC_API(2,2) int botan_privkey_load_ed25519(botan_privkey_t* key,
1291 const uint8_t privkey[32]);
1292
1293BOTAN_PUBLIC_API(2,2) int botan_pubkey_load_ed25519(botan_pubkey_t* key,
1294 const uint8_t pubkey[32]);
1295
1296BOTAN_PUBLIC_API(2,2) int botan_privkey_ed25519_get_privkey(botan_privkey_t key,
1297 uint8_t output[64]);
1298
1299BOTAN_PUBLIC_API(2,2) int botan_pubkey_ed25519_get_pubkey(botan_pubkey_t key,
1300 uint8_t pubkey[32]);
1301
1302/*
1303* Algorithm specific key operations: X25519
1304*/
1305
1306BOTAN_PUBLIC_API(2,8) int botan_privkey_load_x25519(botan_privkey_t* key,
1307 const uint8_t privkey[32]);
1308
1309BOTAN_PUBLIC_API(2,8) int botan_pubkey_load_x25519(botan_pubkey_t* key,
1310 const uint8_t pubkey[32]);
1311
1312BOTAN_PUBLIC_API(2,8) int botan_privkey_x25519_get_privkey(botan_privkey_t key,
1313 uint8_t output[32]);
1314
1315BOTAN_PUBLIC_API(2,8) int botan_pubkey_x25519_get_pubkey(botan_pubkey_t key,
1316 uint8_t pubkey[32]);
1317
1318/*
1319* Algorithm specific key operations: ECDSA and ECDH
1320*/
1321BOTAN_PUBLIC_API(2,2)
1322int botan_privkey_load_ecdsa(botan_privkey_t* key,
1323 const botan_mp_t scalar,
1324 const char* curve_name);
1325
1326BOTAN_PUBLIC_API(2,2)
1327int botan_pubkey_load_ecdsa(botan_pubkey_t* key,
1328 const botan_mp_t public_x,
1329 const botan_mp_t public_y,
1330 const char* curve_name);
1331
1332BOTAN_PUBLIC_API(2,2)
1333int botan_pubkey_load_ecdh(botan_pubkey_t* key,
1334 const botan_mp_t public_x,
1335 const botan_mp_t public_y,
1336 const char* curve_name);
1337
1338BOTAN_PUBLIC_API(2,2)
1339int botan_privkey_load_ecdh(botan_privkey_t* key,
1340 const botan_mp_t scalar,
1341 const char* curve_name);
1342
1343BOTAN_PUBLIC_API(2,2)
1344int botan_pubkey_load_sm2(botan_pubkey_t* key,
1345 const botan_mp_t public_x,
1346 const botan_mp_t public_y,
1347 const char* curve_name);
1348
1349BOTAN_PUBLIC_API(2,2)
1350int botan_privkey_load_sm2(botan_privkey_t* key,
1351 const botan_mp_t scalar,
1352 const char* curve_name);
1353
1354BOTAN_PUBLIC_API(2,2) BOTAN_DEPRECATED("Use botan_pubkey_load_sm2")
1355int botan_pubkey_load_sm2_enc(botan_pubkey_t* key,
1356 const botan_mp_t public_x,
1357 const botan_mp_t public_y,
1358 const char* curve_name);
1359
1360BOTAN_PUBLIC_API(2,2) BOTAN_DEPRECATED("Use botan_privkey_load_sm2")
1361int botan_privkey_load_sm2_enc(botan_privkey_t* key,
1362 const botan_mp_t scalar,
1363 const char* curve_name);
1364
1365BOTAN_PUBLIC_API(2,3)
1366int botan_pubkey_sm2_compute_za(uint8_t out[],
1367 size_t* out_len,
1368 const char* ident,
1369 const char* hash_algo,
1370 const botan_pubkey_t key);
1371
1372/*
1373* Public Key Encryption
1374*/
1375typedef struct botan_pk_op_encrypt_struct* botan_pk_op_encrypt_t;
1376
1377BOTAN_PUBLIC_API(2,0) int botan_pk_op_encrypt_create(botan_pk_op_encrypt_t* op,
1378 botan_pubkey_t key,
1379 const char* padding,
1380 uint32_t flags);
1381
1382/**
1383* @return 0 if success, error if invalid object handle
1384*/
1385BOTAN_PUBLIC_API(2,0) int botan_pk_op_encrypt_destroy(botan_pk_op_encrypt_t op);
1386
1387BOTAN_PUBLIC_API(2,8) int botan_pk_op_encrypt_output_length(botan_pk_op_encrypt_t op,
1388 size_t ptext_len,
1389 size_t* ctext_len);
1390
1391BOTAN_PUBLIC_API(2,0) int botan_pk_op_encrypt(botan_pk_op_encrypt_t op,
1392 botan_rng_t rng,
1393 uint8_t out[],
1394 size_t* out_len,
1395 const uint8_t plaintext[],
1396 size_t plaintext_len);
1397
1398/*
1399* Public Key Decryption
1400*/
1401typedef struct botan_pk_op_decrypt_struct* botan_pk_op_decrypt_t;
1402
1403BOTAN_PUBLIC_API(2,0) int botan_pk_op_decrypt_create(botan_pk_op_decrypt_t* op,
1404 botan_privkey_t key,
1405 const char* padding,
1406 uint32_t flags);
1407
1408/**
1409* @return 0 if success, error if invalid object handle
1410*/
1411BOTAN_PUBLIC_API(2,0) int botan_pk_op_decrypt_destroy(botan_pk_op_decrypt_t op);
1412
1413BOTAN_PUBLIC_API(2,8) int botan_pk_op_decrypt_output_length(botan_pk_op_decrypt_t op,
1414 size_t ctext_len,
1415 size_t* ptext_len);
1416
1417BOTAN_PUBLIC_API(2,0) int botan_pk_op_decrypt(botan_pk_op_decrypt_t op,
1418 uint8_t out[], size_t* out_len,
1419 const uint8_t ciphertext[], size_t ciphertext_len);
1420
1421/*
1422* Signature Generation
1423*/
1424
1425#define BOTAN_PUBKEY_DER_FORMAT_SIGNATURE 1
1426
1427typedef struct botan_pk_op_sign_struct* botan_pk_op_sign_t;
1428
1429BOTAN_PUBLIC_API(2,0)
1430int botan_pk_op_sign_create(botan_pk_op_sign_t* op,
1431 botan_privkey_t key,
1432 const char* hash_and_padding,
1433 uint32_t flags);
1434
1435/**
1436* @return 0 if success, error if invalid object handle
1437*/
1438BOTAN_PUBLIC_API(2,0) int botan_pk_op_sign_destroy(botan_pk_op_sign_t op);
1439
1440BOTAN_PUBLIC_API(2,8) int botan_pk_op_sign_output_length(botan_pk_op_sign_t op, size_t* olen);
1441
1442BOTAN_PUBLIC_API(2,0) int botan_pk_op_sign_update(botan_pk_op_sign_t op, const uint8_t in[], size_t in_len);
1443
1444BOTAN_PUBLIC_API(2,0)
1445int botan_pk_op_sign_finish(botan_pk_op_sign_t op, botan_rng_t rng,
1446 uint8_t sig[], size_t* sig_len);
1447
1448/*
1449* Signature Verification
1450*/
1451typedef struct botan_pk_op_verify_struct* botan_pk_op_verify_t;
1452
1453BOTAN_PUBLIC_API(2,0)
1454int botan_pk_op_verify_create(botan_pk_op_verify_t* op,
1455 botan_pubkey_t key,
1456 const char* hash_and_padding,
1457 uint32_t flags);
1458
1459/**
1460* @return 0 if success, error if invalid object handle
1461*/
1462BOTAN_PUBLIC_API(2,0) int botan_pk_op_verify_destroy(botan_pk_op_verify_t op);
1463
1464BOTAN_PUBLIC_API(2,0) int botan_pk_op_verify_update(botan_pk_op_verify_t op, const uint8_t in[], size_t in_len);
1465BOTAN_PUBLIC_API(2,0) int botan_pk_op_verify_finish(botan_pk_op_verify_t op, const uint8_t sig[], size_t sig_len);
1466
1467/*
1468* Key Agreement
1469*/
1470typedef struct botan_pk_op_ka_struct* botan_pk_op_ka_t;
1471
1472BOTAN_PUBLIC_API(2,0)
1473int botan_pk_op_key_agreement_create(botan_pk_op_ka_t* op,
1474 botan_privkey_t key,
1475 const char* kdf,
1476 uint32_t flags);
1477
1478/**
1479* @return 0 if success, error if invalid object handle
1480*/
1481BOTAN_PUBLIC_API(2,0) int botan_pk_op_key_agreement_destroy(botan_pk_op_ka_t op);
1482
1483BOTAN_PUBLIC_API(2,0) int botan_pk_op_key_agreement_export_public(botan_privkey_t key,
1484 uint8_t out[], size_t* out_len);
1485
1486BOTAN_PUBLIC_API(2,8) int botan_pk_op_key_agreement_size(botan_pk_op_ka_t op, size_t* out_len);
1487
1488BOTAN_PUBLIC_API(2,0)
1489int botan_pk_op_key_agreement(botan_pk_op_ka_t op,
1490 uint8_t out[], size_t* out_len,
1491 const uint8_t other_key[], size_t other_key_len,
1492 const uint8_t salt[], size_t salt_len);
1493
1494BOTAN_PUBLIC_API(2,0) int botan_pkcs_hash_id(const char* hash_name, uint8_t pkcs_id[], size_t* pkcs_id_len);
1495
1496
1497/*
1498*
1499* @param mce_key must be a McEliece key
1500* ct_len should be pt_len + n/8 + a few?
1501*/
1502BOTAN_PUBLIC_API(2,0) BOTAN_DEPRECATED("Poorly specified, avoid in new code")
1503int botan_mceies_encrypt(botan_pubkey_t mce_key,
1504 botan_rng_t rng,
1505 const char* aead,
1506 const uint8_t pt[], size_t pt_len,
1507 const uint8_t ad[], size_t ad_len,
1508 uint8_t ct[], size_t* ct_len);
1509
1510BOTAN_PUBLIC_API(2,0) BOTAN_DEPRECATED("Poorly specified, avoid in new code")
1511int botan_mceies_decrypt(botan_privkey_t mce_key,
1512 const char* aead,
1513 const uint8_t ct[], size_t ct_len,
1514 const uint8_t ad[], size_t ad_len,
1515 uint8_t pt[], size_t* pt_len);
1516
1517/*
1518* X.509 certificates
1519**************************/
1520
1521typedef struct botan_x509_cert_struct* botan_x509_cert_t;
1522
1523BOTAN_PUBLIC_API(2,0) int botan_x509_cert_load(botan_x509_cert_t* cert_obj, const uint8_t cert[], size_t cert_len);
1524BOTAN_PUBLIC_API(2,0) int botan_x509_cert_load_file(botan_x509_cert_t* cert_obj, const char* filename);
1525
1526/**
1527* @return 0 if success, error if invalid object handle
1528*/
1529BOTAN_PUBLIC_API(2,0) int botan_x509_cert_destroy(botan_x509_cert_t cert);
1530
1531BOTAN_PUBLIC_API(2,8) int botan_x509_cert_dup(botan_x509_cert_t* new_cert, botan_x509_cert_t cert);
1532
1533/* Prefer botan_x509_cert_not_before and botan_x509_cert_not_after */
1534BOTAN_PUBLIC_API(2,0) int botan_x509_cert_get_time_starts(botan_x509_cert_t cert, char out[], size_t* out_len);
1535BOTAN_PUBLIC_API(2,0) int botan_x509_cert_get_time_expires(botan_x509_cert_t cert, char out[], size_t* out_len);
1536
1537BOTAN_PUBLIC_API(2,8) int botan_x509_cert_not_before(botan_x509_cert_t cert, uint64_t* time_since_epoch);
1538BOTAN_PUBLIC_API(2,8) int botan_x509_cert_not_after(botan_x509_cert_t cert, uint64_t* time_since_epoch);
1539
1540BOTAN_PUBLIC_API(2,0) int botan_x509_cert_get_fingerprint(botan_x509_cert_t cert, const char* hash, uint8_t out[], size_t* out_len);
1541
1542BOTAN_PUBLIC_API(2,0) int botan_x509_cert_get_serial_number(botan_x509_cert_t cert, uint8_t out[], size_t* out_len);
1543BOTAN_PUBLIC_API(2,0) int botan_x509_cert_get_authority_key_id(botan_x509_cert_t cert, uint8_t out[], size_t* out_len);
1544BOTAN_PUBLIC_API(2,0) int botan_x509_cert_get_subject_key_id(botan_x509_cert_t cert, uint8_t out[], size_t* out_len);
1545
1546BOTAN_PUBLIC_API(2,0) int botan_x509_cert_get_public_key_bits(botan_x509_cert_t cert,
1547 uint8_t out[], size_t* out_len);
1548
1549BOTAN_PUBLIC_API(2,0) int botan_x509_cert_get_public_key(botan_x509_cert_t cert, botan_pubkey_t* key);
1550
1551BOTAN_PUBLIC_API(2,0)
1552int botan_x509_cert_get_issuer_dn(botan_x509_cert_t cert,
1553 const char* key, size_t index,
1554 uint8_t out[], size_t* out_len);
1555
1556BOTAN_PUBLIC_API(2,0)
1557int botan_x509_cert_get_subject_dn(botan_x509_cert_t cert,
1558 const char* key, size_t index,
1559 uint8_t out[], size_t* out_len);
1560
1561BOTAN_PUBLIC_API(2,0) int botan_x509_cert_to_string(botan_x509_cert_t cert, char out[], size_t* out_len);
1562
1563/* Must match values of Key_Constraints in key_constraints.h */
1564enum botan_x509_cert_key_constraints {
1565 NO_CONSTRAINTS = 0,
1566 DIGITAL_SIGNATURE = 32768,
1567 NON_REPUDIATION = 16384,
1568 KEY_ENCIPHERMENT = 8192,
1569 DATA_ENCIPHERMENT = 4096,
1570 KEY_AGREEMENT = 2048,
1571 KEY_CERT_SIGN = 1024,
1572 CRL_SIGN = 512,
1573 ENCIPHER_ONLY = 256,
1574 DECIPHER_ONLY = 128
1576
1577BOTAN_PUBLIC_API(2,0) int botan_x509_cert_allowed_usage(botan_x509_cert_t cert, unsigned int key_usage);
1578
1579/**
1580* Check if the certificate matches the specified hostname via alternative name or CN match.
1581* RFC 5280 wildcards also supported.
1582*/
1583BOTAN_PUBLIC_API(2,5) int botan_x509_cert_hostname_match(botan_x509_cert_t cert, const char* hostname);
1584
1585/**
1586* Returns 0 if the validation was successful, 1 if validation failed,
1587* and negative on error. A status code with details is written to
1588* *validation_result
1589*
1590* Intermediates or trusted lists can be null
1591* Trusted path can be null
1592*/
1593BOTAN_PUBLIC_API(2,8) int botan_x509_cert_verify(
1594 int* validation_result,
1595 botan_x509_cert_t cert,
1596 const botan_x509_cert_t* intermediates,
1597 size_t intermediates_len,
1598 const botan_x509_cert_t* trusted,
1599 size_t trusted_len,
1600 const char* trusted_path,
1601 size_t required_strength,
1602 const char* hostname,
1603 uint64_t reference_time);
1604
1605/**
1606* Returns a pointer to a static character string explaining the status code,
1607* or else NULL if unknown.
1608*/
1609BOTAN_PUBLIC_API(2,8) const char* botan_x509_cert_validation_status(int code);
1610
1611/*
1612* X.509 CRL
1613**************************/
1614
1615typedef struct botan_x509_crl_struct* botan_x509_crl_t;
1616
1617BOTAN_PUBLIC_API(2,13) int botan_x509_crl_load_file(botan_x509_crl_t* crl_obj, const char* crl_path);
1618BOTAN_PUBLIC_API(2,13) int botan_x509_crl_load(botan_x509_crl_t* crl_obj, const uint8_t crl_bits[], size_t crl_bits_len);
1619
1620BOTAN_PUBLIC_API(2,13) int botan_x509_crl_destroy(botan_x509_crl_t crl);
1621
1622/**
1623 * Given a CRL and a certificate,
1624 * check if the certificate is revoked on that particular CRL
1625 */
1626BOTAN_PUBLIC_API(2,13) int botan_x509_is_revoked(botan_x509_crl_t crl, botan_x509_cert_t cert);
1627
1628/**
1629 * Different flavor of `botan_x509_cert_verify`, supports revocation lists.
1630 * CRLs are passed as an array, same as intermediates and trusted CAs
1631 */
1632BOTAN_PUBLIC_API(2,13) int botan_x509_cert_verify_with_crl(
1633 int* validation_result,
1634 botan_x509_cert_t cert,
1635 const botan_x509_cert_t* intermediates,
1636 size_t intermediates_len,
1637 const botan_x509_cert_t* trusted,
1638 size_t trusted_len,
1639 const botan_x509_crl_t* crls,
1640 size_t crls_len,
1641 const char* trusted_path,
1642 size_t required_strength,
1643 const char* hostname,
1644 uint64_t reference_time);
1645
1646/**
1647 * Key wrapping as per RFC 3394
1648 */
1649BOTAN_PUBLIC_API(2,2)
1650int botan_key_wrap3394(const uint8_t key[], size_t key_len,
1651 const uint8_t kek[], size_t kek_len,
1652 uint8_t wrapped_key[], size_t *wrapped_key_len);
1653
1654BOTAN_PUBLIC_API(2,2)
1655int botan_key_unwrap3394(const uint8_t wrapped_key[], size_t wrapped_key_len,
1656 const uint8_t kek[], size_t kek_len,
1657 uint8_t key[], size_t *key_len);
1658
1659/**
1660* HOTP
1661*/
1662
1663typedef struct botan_hotp_struct* botan_hotp_t;
1664
1665/**
1666* Initialize a HOTP instance
1667*/
1668BOTAN_PUBLIC_API(2,8)
1669int botan_hotp_init(botan_hotp_t* hotp,
1670 const uint8_t key[], size_t key_len,
1671 const char* hash_algo,
1672 size_t digits);
1673
1674/**
1675* Destroy a HOTP instance
1676* @return 0 if success, error if invalid object handle
1677*/
1678BOTAN_PUBLIC_API(2,8)
1679int botan_hotp_destroy(botan_hotp_t hotp);
1680
1681/**
1682* Generate a HOTP code for the provided counter
1683*/
1684BOTAN_PUBLIC_API(2,8)
1685int botan_hotp_generate(botan_hotp_t hotp,
1686 uint32_t* hotp_code,
1687 uint64_t hotp_counter);
1688
1689/**
1690* Verify a HOTP code
1691*/
1692BOTAN_PUBLIC_API(2,8)
1693int botan_hotp_check(botan_hotp_t hotp,
1694 uint64_t* next_hotp_counter,
1695 uint32_t hotp_code,
1696 uint64_t hotp_counter,
1697 size_t resync_range);
1698
1699
1700/**
1701* TOTP
1702*/
1703
1704typedef struct botan_totp_struct* botan_totp_t;
1705
1706/**
1707* Initialize a TOTP instance
1708*/
1709BOTAN_PUBLIC_API(2,8)
1710int botan_totp_init(botan_totp_t* totp,
1711 const uint8_t key[], size_t key_len,
1712 const char* hash_algo,
1713 size_t digits,
1714 size_t time_step);
1715
1716/**
1717* Destroy a TOTP instance
1718* @return 0 if success, error if invalid object handle
1719*/
1720BOTAN_PUBLIC_API(2,8)
1721int botan_totp_destroy(botan_totp_t totp);
1722
1723/**
1724* Generate a TOTP code for the provided timestamp
1725* @param totp the TOTP object
1726* @param totp_code the OTP code will be written here
1727* @param timestamp the current local timestamp
1728*/
1729BOTAN_PUBLIC_API(2,8)
1730int botan_totp_generate(botan_totp_t totp,
1731 uint32_t* totp_code,
1732 uint64_t timestamp);
1733
1734/**
1735* Verify a TOTP code
1736* @param totp the TOTP object
1737* @param totp_code the presented OTP
1738* @param timestamp the current local timestamp
1739* @param acceptable_clock_drift specifies the acceptable amount
1740* of clock drift (in terms of time steps) between the two hosts.
1741*/
1742BOTAN_PUBLIC_API(2,8)
1743int botan_totp_check(botan_totp_t totp,
1744 uint32_t totp_code,
1745 uint64_t timestamp,
1746 size_t acceptable_clock_drift);
1747
1748
1749/**
1750* Format Preserving Encryption
1751*/
1752
1753typedef struct botan_fpe_struct* botan_fpe_t;
1754
1755#define BOTAN_FPE_FLAG_FE1_COMPAT_MODE 1
1756
1757BOTAN_PUBLIC_API(2,8)
1758int botan_fpe_fe1_init(botan_fpe_t* fpe, botan_mp_t n,
1759 const uint8_t key[], size_t key_len,
1760 size_t rounds, uint32_t flags);
1761
1762/**
1763* @return 0 if success, error if invalid object handle
1764*/
1765BOTAN_PUBLIC_API(2,8)
1766int botan_fpe_destroy(botan_fpe_t fpe);
1767
1768BOTAN_PUBLIC_API(2,8)
1769int botan_fpe_encrypt(botan_fpe_t fpe, botan_mp_t x, const uint8_t tweak[], size_t tweak_len);
1770
1771BOTAN_PUBLIC_API(2,8)
1772int botan_fpe_decrypt(botan_fpe_t fpe, botan_mp_t x, const uint8_t tweak[], size_t tweak_len);
1773
1774#ifdef __cplusplus
1775}
1776#endif
1777
1778#endif
std::string name
#define BOTAN_PUBLIC_API(maj, min)
Definition: compiler.h:31
int botan_block_cipher_get_keyspec(botan_block_cipher_t cipher, size_t *out_minimum_keylength, size_t *out_maximum_keylength, size_t *out_keylength_modulo)
Definition: ffi_block.cpp:97
int botan_block_cipher_init(botan_block_cipher_t *bc, const char *cipher_name)
Definition: ffi_block.cpp:17
int botan_rng_reseed_from_rng(botan_rng_t rng, botan_rng_t source_rng, size_t bits)
Definition: ffi_rng.cpp:178
uint32_t botan_version_minor(void)
Definition: ffi.cpp:237
int botan_mp_set_from_int(botan_mp_t mp, int initial_value)
Definition: ffi_mp.cpp:36
int botan_bcrypt_generate(uint8_t *out, size_t *out_len, const char *password, botan_rng_t rng, size_t work_factor, uint32_t flags)
Definition: ffi_kdf.cpp:153
int botan_privkey_check_key(botan_privkey_t key, botan_rng_t rng, uint32_t flags)
Definition: ffi_pkey.cpp:145
int botan_base64_encode(const uint8_t *x, size_t len, char *out, size_t *out_len)
Definition: ffi.cpp:274
int botan_privkey_create_elgamal(botan_privkey_t *key, botan_rng_t rng, size_t pbits, size_t qbits)
int botan_mp_set_from_mp(botan_mp_t dest, const botan_mp_t source)
Definition: ffi_mp.cpp:74
int botan_mp_to_bin(const botan_mp_t mp, uint8_t vec[])
Definition: ffi_mp.cpp:120
int botan_hash_update(botan_hash_t hash, const uint8_t *in, size_t in_len)
Definition: ffi_hash.cpp:58
int botan_privkey_create_rsa(botan_privkey_t *key, botan_rng_t rng, size_t n_bits)
uint32_t botan_version_datestamp(void)
Definition: ffi.cpp:239
uint32_t botan_version_patch(void)
Definition: ffi.cpp:238
int botan_privkey_create_ecdsa(botan_privkey_t *key, botan_rng_t rng, const char *params)
int botan_mp_cmp(int *result, const botan_mp_t x, const botan_mp_t y)
Definition: ffi_mp.cpp:220
int botan_mp_set_from_radix_str(botan_mp_t dest, const char *str, size_t radix)
Definition: ffi_mp.cpp:56
int botan_rng_add_entropy(botan_rng_t rng, const uint8_t *entropy, size_t entropy_len)
Definition: ffi_rng.cpp:173
int botan_cipher_start(botan_cipher_t cipher, const uint8_t *nonce, size_t nonce_len)
Definition: ffi_cipher.cpp:88
uint32_t botan_version_major(void)
Definition: ffi.cpp:236
int botan_cipher_valid_nonce_length(botan_cipher_t cipher, size_t nl)
Definition: ffi_cipher.cpp:205
int botan_mac_init(botan_mac_t *mac, const char *mac_name, uint32_t flags)
Definition: ffi_mac.cpp:17
int botan_mp_sub(botan_mp_t result, const botan_mp_t x, const botan_mp_t y)
Definition: ffi_mp.cpp:149
int botan_privkey_create_dh(botan_privkey_t *key, botan_rng_t rng, const char *param)
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_hash_name(botan_hash_t hash, char *name, size_t *name_len)
Definition: ffi_hash.cpp:82
int botan_mp_to_str(const botan_mp_t mp, uint8_t base, char *out, size_t *out_len)
Definition: ffi_mp.cpp:107
int botan_mp_gcd(botan_mp_t out, const botan_mp_t x, const botan_mp_t y)
Definition: ffi_mp.cpp:275
int botan_cipher_get_tag_length(botan_cipher_t cipher, size_t *tag_size)
Definition: ffi_cipher.cpp:222
int botan_mp_from_bin(const botan_mp_t mp, const uint8_t vec[], size_t vec_len)
Definition: ffi_mp.cpp:94
int botan_privkey_get_field(botan_mp_t output, botan_privkey_t key, const char *field_name)
int botan_mp_add_u32(botan_mp_t result, const botan_mp_t x, uint32_t y)
Definition: ffi_mp.cpp:159
int botan_rng_init_custom(botan_rng_t *rng_out, const char *rng_name, void *context, int(*get_cb)(void *context, uint8_t *out, size_t out_len), int(*add_entropy_cb)(void *context, const uint8_t input[], size_t length), void(*destroy_cb)(void *context))
Definition: ffi_rng.cpp:63
int botan_pwdhash_timed(const char *algo, uint32_t msec, size_t *param1, size_t *param2, size_t *param3, uint8_t out[], size_t out_len, const char *passphrase, size_t passphrase_len, const uint8_t salt[], size_t salt_len)
Definition: ffi_kdf.cpp:86
int botan_rng_reseed(botan_rng_t rng, size_t bits)
Definition: ffi_rng.cpp:168
int botan_mp_init(botan_mp_t *mp)
Definition: ffi_mp.cpp:20
int botan_same_mem(const uint8_t *x, const uint8_t *y, size_t len)
Definition: ffi.cpp:246
int botan_mp_mod_mul(botan_mp_t result, const botan_mp_t x, const botan_mp_t y, const botan_mp_t mod)
Definition: ffi_mp.cpp:252
int botan_privkey_load(botan_privkey_t *key, botan_rng_t rng, const uint8_t bits[], size_t len, const char *password)
Definition: ffi_pkey.cpp:57
struct botan_mac_struct * botan_mac_t
Definition: ffi.h:351
int botan_base64_decode(const char *base64_str, size_t in_len, uint8_t *out, size_t *out_len)
Definition: ffi.cpp:282
int botan_mac_destroy(botan_mac_t mac)
Definition: ffi_mac.cpp:34
struct botan_privkey_struct * botan_privkey_t
Definition: ffi.h:966
int botan_cipher_output_length(botan_cipher_t cipher, size_t in_len, size_t *out_len)
Definition: ffi_cipher.cpp:49
int botan_mp_mul(botan_mp_t result, const botan_mp_t x, const botan_mp_t y)
Definition: ffi_mp.cpp:179
int botan_cipher_reset(botan_cipher_t cipher)
Definition: ffi_cipher.cpp:44
int botan_cipher_init(botan_cipher_t *cipher, const char *name, uint32_t flags)
Definition: ffi_cipher.cpp:21
int botan_mp_is_zero(const botan_mp_t mp)
Definition: ffi_mp.cpp:205
int botan_block_cipher_clear(botan_block_cipher_t bc)
Definition: ffi_block.cpp:42
int botan_privkey_export(botan_privkey_t key, uint8_t out[], size_t *out_len, uint32_t flags)
Definition: ffi_pkey.cpp:165
int botan_hash_destroy(botan_hash_t hash)
Definition: ffi_hash.cpp:34
int botan_block_cipher_block_size(botan_block_cipher_t bc)
Definition: ffi_block.cpp:62
int botan_mp_rand_range(botan_mp_t rand_out, botan_rng_t rng, const botan_mp_t lower_bound, const botan_mp_t upper_bound)
Definition: ffi_mp.cpp:266
int botan_cipher_destroy(botan_cipher_t cipher)
Definition: ffi_cipher.cpp:34
int botan_mp_sub_u32(botan_mp_t result, const botan_mp_t x, uint32_t y)
Definition: ffi_mp.cpp:169
int botan_mp_is_even(const botan_mp_t mp)
Definition: ffi_mp.cpp:215
int botan_cipher_name(botan_cipher_t cipher, char *name, size_t *name_len)
Definition: ffi_cipher.cpp:227
int botan_cipher_set_associated_data(botan_cipher_t cipher, const uint8_t *ad, size_t ad_len)
Definition: ffi_cipher.cpp:191
int botan_cipher_get_keyspec(botan_cipher_t, size_t *min_keylen, size_t *max_keylen, size_t *mod_keylen)
Definition: ffi_cipher.cpp:67
int botan_privkey_destroy(botan_privkey_t key)
Definition: ffi_pkey.cpp:88
int botan_block_cipher_decrypt_blocks(botan_block_cipher_t bc, const uint8_t in[], uint8_t out[], size_t blocks)
Definition: ffi_block.cpp:78
int botan_mp_is_prime(const botan_mp_t n, botan_rng_t rng, size_t test_prob)
Definition: ffi_mp.cpp:281
int botan_hash_clear(botan_hash_t hash)
Definition: ffi_hash.cpp:53
int botan_mp_swap(botan_mp_t x, botan_mp_t y)
Definition: ffi_mp.cpp:225
int botan_mp_destroy(botan_mp_t mp)
Definition: ffi_mp.cpp:134
uint32_t botan_ffi_api_version(void)
Definition: ffi.cpp:196
int botan_mp_is_positive(const botan_mp_t mp)
Definition: ffi_mp.cpp:84
int botan_hash_output_length(botan_hash_t hash, size_t *output_length)
Definition: ffi_hash.cpp:39
int botan_privkey_load_sm2(botan_privkey_t *key, const botan_mp_t scalar, const char *curve_name)
int botan_mp_rand_bits(botan_mp_t rand_out, botan_rng_t rng, size_t bits)
Definition: ffi_mp.cpp:260
int botan_cipher_set_key(botan_cipher_t cipher, const uint8_t *key, size_t key_len)
Definition: ffi_cipher.cpp:82
int botan_cipher_query_keylen(botan_cipher_t, size_t *out_minimum_keylength, size_t *out_maximum_keylength)
Definition: ffi_cipher.cpp:57
int botan_mp_set_from_str(botan_mp_t dest, const char *str)
Definition: ffi_mp.cpp:51
int botan_mp_flip_sign(botan_mp_t mp)
Definition: ffi_mp.cpp:89
int botan_scrypt(uint8_t out[], size_t out_len, const char *passphrase, const uint8_t salt[], size_t salt_len, size_t N, size_t r, size_t p)
Definition: ffi_kdf.cpp:142
int botan_mp_clear_bit(botan_mp_t n, size_t bit)
Definition: ffi_mp.cpp:297
int botan_mp_mod_inverse(botan_mp_t out, const botan_mp_t in, const botan_mp_t modulus)
Definition: ffi_mp.cpp:247
int botan_pbkdf(const char *pbkdf_algo, uint8_t out[], size_t out_len, const char *passphrase, const uint8_t salt[], size_t salt_len, size_t iterations)
Definition: ffi_kdf.cpp:22
struct botan_block_cipher_struct * botan_block_cipher_t
Definition: ffi.h:692
const char * botan_version_string(void)
Definition: ffi.cpp:231
int botan_mp_num_bits(const botan_mp_t n, size_t *bits)
Definition: ffi_mp.cpp:302
int botan_hex_encode(const uint8_t *x, size_t len, char *out, uint32_t flags)
Definition: ffi.cpp:257
int botan_mp_clear(botan_mp_t mp)
Definition: ffi_mp.cpp:31
int botan_hash_copy_state(botan_hash_t *dest, const botan_hash_t source)
Definition: ffi_hash.cpp:76
int botan_mac_final(botan_mac_t mac, uint8_t out[])
Definition: ffi_mac.cpp:59
int botan_block_cipher_name(botan_block_cipher_t cipher, char *name, size_t *name_len)
Definition: ffi_block.cpp:88
int botan_rng_get(botan_rng_t rng, uint8_t *out, size_t out_len)
Definition: ffi_rng.cpp:163
int botan_scrub_mem(void *mem, size_t bytes)
Definition: ffi.cpp:251
int botan_privkey_create(botan_privkey_t *key, const char *algo_name, const char *algo_params, botan_rng_t rng)
Definition: ffi_pkey.cpp:26
int botan_mp_is_odd(const botan_mp_t mp)
Definition: ffi_mp.cpp:210
int botan_mac_update(botan_mac_t mac, const uint8_t *buf, size_t len)
Definition: ffi_mac.cpp:54
int botan_mp_div(botan_mp_t quotient, botan_mp_t remainder, const botan_mp_t x, const botan_mp_t y)
Definition: ffi_mp.cpp:189
int botan_privkey_create_mceliece(botan_privkey_t *key, botan_rng_t rng, size_t n, size_t t)
int botan_privkey_algo_name(botan_privkey_t key, char out[], size_t *out_len)
Definition: ffi_pkey.cpp:126
int botan_hash_block_size(botan_hash_t hash, size_t *block_size)
Definition: ffi_hash.cpp:46
int botan_mp_rshift(botan_mp_t out, const botan_mp_t in, size_t shift)
Definition: ffi_mp.cpp:242
int botan_mp_powmod(botan_mp_t out, const botan_mp_t base, const botan_mp_t exponent, const botan_mp_t modulus)
Definition: ffi_mp.cpp:231
int botan_mp_to_uint32(const botan_mp_t mp, uint32_t *val)
Definition: ffi_mp.cpp:125
int botan_pubkey_get_field(botan_mp_t output, botan_pubkey_t key, const char *field_name)
int botan_privkey_create_dsa(botan_privkey_t *key, botan_rng_t rng, size_t pbits, size_t qbits)
struct botan_mp_struct * botan_mp_t
Definition: ffi.h:765
struct botan_rng_struct * botan_rng_t
Definition: ffi.h:190
int botan_block_cipher_destroy(botan_block_cipher_t bc)
Definition: ffi_block.cpp:37
BOTAN_FFI_ERROR
Definition: ffi.h:62
@ BOTAN_FFI_ERROR_NOT_IMPLEMENTED
Definition: ffi.h:83
@ BOTAN_FFI_ERROR_INVALID_KEY_LENGTH
Definition: ffi.h:80
@ BOTAN_FFI_ERROR_KEY_NOT_SET
Definition: ffi.h:79
@ BOTAN_FFI_ERROR_TLS_ERROR
Definition: ffi.h:86
@ BOTAN_FFI_ERROR_EXCEPTION_THROWN
Definition: ffi.h:71
@ BOTAN_FFI_ERROR_OUT_OF_MEMORY
Definition: ffi.h:72
@ BOTAN_FFI_ERROR_INTERNAL_ERROR
Definition: ffi.h:74
@ BOTAN_FFI_INVALID_VERIFIER
Definition: ffi.h:64
@ BOTAN_FFI_ERROR_INVALID_OBJECT
Definition: ffi.h:84
@ BOTAN_FFI_ERROR_UNKNOWN_ERROR
Definition: ffi.h:90
@ BOTAN_FFI_ERROR_HTTP_ERROR
Definition: ffi.h:87
@ BOTAN_FFI_ERROR_BAD_FLAG
Definition: ffi.h:76
@ BOTAN_FFI_ERROR_INVALID_INPUT
Definition: ffi.h:66
@ BOTAN_FFI_ERROR_NULL_POINTER
Definition: ffi.h:77
@ BOTAN_FFI_SUCCESS
Definition: ffi.h:63
@ BOTAN_FFI_ERROR_SYSTEM_ERROR
Definition: ffi.h:73
@ BOTAN_FFI_ERROR_ROUGHTIME_ERROR
Definition: ffi.h:88
@ BOTAN_FFI_ERROR_INVALID_OBJECT_STATE
Definition: ffi.h:81
@ BOTAN_FFI_ERROR_INSUFFICIENT_BUFFER_SPACE
Definition: ffi.h:69
@ BOTAN_FFI_ERROR_BAD_MAC
Definition: ffi.h:67
@ BOTAN_FFI_ERROR_BAD_PARAMETER
Definition: ffi.h:78
int botan_pwdhash(const char *algo, size_t param1, size_t param2, size_t param3, uint8_t out[], size_t out_len, const char *passphrase, size_t passphrase_len, const uint8_t salt[], size_t salt_len)
Definition: ffi_kdf.cpp:52
int botan_mac_name(botan_mac_t mac, char *name, size_t *name_len)
Definition: ffi_mac.cpp:64
int botan_cipher_clear(botan_cipher_t hash)
Definition: ffi_cipher.cpp:39
int botan_mp_is_negative(const botan_mp_t mp)
Definition: ffi_mp.cpp:79
int botan_mp_get_bit(const botan_mp_t n, size_t bit)
Definition: ffi_mp.cpp:287
int botan_mp_to_hex(const botan_mp_t mp, char *out)
Definition: ffi_mp.cpp:99
int botan_rng_destroy(botan_rng_t rng)
Definition: ffi_rng.cpp:158
int botan_ffi_supports_api(uint32_t api_version)
Definition: ffi.cpp:201
const char * botan_error_description(int err)
Definition: ffi.cpp:125
int botan_mp_num_bytes(const botan_mp_t n, size_t *bytes)
Definition: ffi_mp.cpp:307
int botan_hash_final(botan_hash_t hash, uint8_t out[])
Definition: ffi_hash.cpp:69
int botan_hash_init(botan_hash_t *hash, const char *hash_name, uint32_t flags)
Definition: ffi_hash.cpp:17
int botan_mac_get_keyspec(botan_mac_t mac, size_t *out_minimum_keylength, size_t *out_maximum_keylength, size_t *out_keylength_modulo)
Definition: ffi_mac.cpp:70
struct botan_cipher_struct * botan_cipher_t
Definition: ffi.h:437
int botan_cipher_update(botan_cipher_t cipher, uint32_t flags, uint8_t output[], size_t output_size, size_t *output_written, const uint8_t input_bytes[], size_t input_size, size_t *input_consumed)
Definition: ffi_cipher.cpp:99
int botan_mac_output_length(botan_mac_t mac, size_t *output_length)
Definition: ffi_mac.cpp:44
int botan_mp_add(botan_mp_t result, const botan_mp_t x, const botan_mp_t y)
Definition: ffi_mp.cpp:139
int botan_constant_time_compare(const uint8_t *x, const uint8_t *y, size_t len)
Definition: ffi.cpp:241
int botan_hex_decode(const char *hex_str, size_t in_len, uint8_t *out, size_t *out_len)
Definition: ffi.cpp:266
int botan_mac_set_key(botan_mac_t mac, const uint8_t *key, size_t key_len)
Definition: ffi_mac.cpp:39
int botan_kdf(const char *kdf_algo, uint8_t out[], size_t out_len, const uint8_t secret[], size_t secret_len, const uint8_t salt[], size_t salt_len, const uint8_t label[], size_t label_len)
Definition: ffi_kdf.cpp:129
int botan_privkey_create_ecdh(botan_privkey_t *key, botan_rng_t rng, const char *params)
int botan_rng_init(botan_rng_t *rng, const char *rng_type)
Definition: ffi_rng.cpp:24
int botan_block_cipher_encrypt_blocks(botan_block_cipher_t bc, const uint8_t in[], uint8_t out[], size_t blocks)
Definition: ffi_block.cpp:68
int botan_mp_lshift(botan_mp_t out, const botan_mp_t in, size_t shift)
Definition: ffi_mp.cpp:237
int botan_cipher_get_default_nonce_length(botan_cipher_t cipher, size_t *nl)
Definition: ffi_cipher.cpp:212
int botan_mp_equal(const botan_mp_t x, const botan_mp_t y)
Definition: ffi_mp.cpp:200
int botan_cipher_get_update_granularity(botan_cipher_t cipher, size_t *ug)
Definition: ffi_cipher.cpp:217
int botan_pbkdf_timed(const char *pbkdf_algo, uint8_t out[], size_t out_len, const char *passphrase, const uint8_t salt[], size_t salt_len, size_t milliseconds_to_run, size_t *out_iterations_used)
Definition: ffi_kdf.cpp:35
int botan_mac_clear(botan_mac_t mac)
Definition: ffi_mac.cpp:49
int botan_block_cipher_set_key(botan_block_cipher_t bc, const uint8_t key[], size_t len)
Definition: ffi_block.cpp:50
int botan_mp_set_bit(botan_mp_t n, size_t bit)
Definition: ffi_mp.cpp:292
int botan_bcrypt_is_valid(const char *pass, const char *hash)
Definition: ffi_kdf.cpp:178
struct botan_hash_struct * botan_hash_t
Definition: ffi.h:271
Flags flags(Flag flags)
Definition: p11.h:860
MechanismType hash
size_t salt_len
Definition: x509_obj.cpp:25