package vendor:botan/bindings

Source

FFI_ERROR :: i32

block_cipher_struct :: struct {}

block_cipher_t :: ^block_cipher_struct

cipher_struct :: struct {}

cipher_t :: ^cipher_struct

fpe_struct :: struct {}

fpe_t :: ^fpe_struct

hash_struct :: struct {}

hash_t :: ^hash_struct

hotp_struct :: struct {}

hotp_t :: ^hotp_struct

mac_struct :: struct {}

mac_t :: ^mac_struct

mp_struct :: struct {}

mp_t :: ^mp_struct

pk_op_decrypt_struct :: struct {}

pk_op_decrypt_t :: ^pk_op_decrypt_struct

pk_op_encrypt_struct :: struct {}

pk_op_encrypt_t :: ^pk_op_encrypt_struct

pk_op_ka_struct :: struct {}

pk_op_ka_t :: ^pk_op_ka_struct

pk_op_sign_struct :: struct {}

pk_op_sign_t :: ^pk_op_sign_struct

pk_op_verify_struct :: struct {}

pk_op_verify_t :: ^pk_op_verify_struct

privkey_struct :: struct {}

privkey_t :: ^privkey_struct

pubkey_struct :: struct {}

pubkey_t :: ^pubkey_struct

rng_struct :: struct {}

rng_t :: ^rng_struct

totp_struct :: struct {}

totp_t :: ^totp_struct

x509_cert_key_constraints :: i32

x509_cert_struct :: struct {}

x509_cert_t :: ^x509_cert_struct

x509_crl_struct :: struct {}

x509_crl_t :: ^x509_crl_struct

CHECK_KEY_EXPENSIVE_TESTS :: 1

CIPHER_INIT_FLAG_DECRYPT :: 1

CIPHER_INIT_FLAG_ENCRYPT :: 0

CIPHER_INIT_FLAG_MASK_DIRECTION :: 1

CIPHER_UPDATE_FLAG_FINAL :: 1 << 0

CRL_SIGN: i32 : x509_cert_key_constraints(512)

DATA_ENCIPHERMENT: i32 : x509_cert_key_constraints(4096)

DECIPHER_ONLY: i32 : x509_cert_key_constraints(128)

DIGITAL_SIGNATURE: i32 : x509_cert_key_constraints(32768)

ENCIPHER_ONLY: i32 : x509_cert_key_constraints(256)

FFI_ERROR_BAD_FLAG: i32 : FFI_ERROR(-30)

FFI_ERROR_BAD_MAC: i32 : FFI_ERROR(-2)

FFI_ERROR_BAD_PARAMETER: i32 : FFI_ERROR(-32)

FFI_ERROR_EXCEPTION_THROWN: i32 : FFI_ERROR(-20)

FFI_ERROR_INSUFFICIENT_BUFFER_SPACE: i32 : FFI_ERROR(-10)

FFI_ERROR_INVALID_INPUT: i32 : FFI_ERROR(-1)

FFI_ERROR_INVALID_KEY_LENGTH: i32 : FFI_ERROR(-34)

FFI_ERROR_INVALID_OBJECT: i32 : FFI_ERROR(-50)

FFI_ERROR_KEY_NOT_SET: i32 : FFI_ERROR(-33)

FFI_ERROR_NOT_IMPLEMENTED: i32 : FFI_ERROR(-40)

FFI_ERROR_NULL_POINTER: i32 : FFI_ERROR(-31)

FFI_ERROR_OUT_OF_MEMORY: i32 : FFI_ERROR(-21)

FFI_ERROR_UNKNOWN_ERROR: i32 : FFI_ERROR(-100)

FFI_HEX_LOWER_CASE :: 1

FFI_INVALID_VERIFIER: i32 : FFI_ERROR(1)

FFI_SUCCESS: i32 : FFI_ERROR(0)

FPE_FLAG_FE1_COMPAT_MODE :: 1

HASH_BLAKE2B :: "BLAKE2b"

HASH_GOST :: "GOST-34.11"

HASH_KECCAK_512 :: "Keccak-1600"

HASH_MD4 :: "MD4"

HASH_MD5 :: "MD5"

HASH_RIPEMD_160 :: "RIPEMD-160"

HASH_SHA1 :: "SHA-1"

HASH_SHA3_224 :: "SHA-3(224)"

HASH_SHA3_256 :: "SHA-3(256)"

HASH_SHA3_384 :: "SHA-3(384)"

HASH_SHA3_512 :: "SHA-3(512)"

HASH_SHAKE_128 :: "SHAKE-128"

HASH_SHAKE_256 :: "SHAKE-256"

HASH_SHA_224 :: "SHA-224"

HASH_SHA_256 :: "SHA-256"

HASH_SHA_384 :: "SHA-384"

HASH_SHA_512 :: "SHA-512"

HASH_SKEIN_512 :: "SKEIN_512"

HASH_SKEIN_512_256 :: "Skein-512(256)"

HASH_SKEIN_512_512 :: "Skein-512(512)"

HASH_SM3 :: "SM3"

HASH_STREEBOG_256 :: "Streebog-256"

HASH_STREEBOG_512 :: "Streebog-512"

HASH_TIGER_128 :: "Tiger(16,3)"

HASH_TIGER_160 :: "Tiger(20,3)"

HASH_TIGER_192 :: "Tiger(24,3)"

HASH_WHIRLPOOL :: "Whirlpool"

KEY_AGREEMENT: i32 : x509_cert_key_constraints(2048)

KEY_CERT_SIGN: i32 : x509_cert_key_constraints(1024)

KEY_ENCIPHERMENT: i32 : x509_cert_key_constraints(8192)

MAC_HMAC_MD5 :: "HMAC(MD5)"

MAC_HMAC_SHA1 :: "HMAC(SHA1)"

MAC_HMAC_SHA_224 :: "HMAC(SHA-224)"

MAC_HMAC_SHA_256 :: "HMAC(SHA-256)"

MAC_HMAC_SHA_384 :: "HMAC(SHA-384)"

MAC_HMAC_SHA_512 :: "HMAC(SHA-512)"

MAC_SIPHASH_1_3 :: "SipHash(1,3)"

MAC_SIPHASH_2_4 :: "SipHash(2,4)"

MAC_SIPHASH_4_8 :: "SipHash(4,8)"

NON_REPUDIATION: i32 : x509_cert_key_constraints(16384)

NO_CONSTRAINTS: i32 : x509_cert_key_constraints(0)

PRIVKEY_EXPORT_FLAG_DER :: 0

PRIVKEY_EXPORT_FLAG_PEM :: 1

PUBKEY_DER_FORMAT_SIGNATURE :: 1

base64_decode :: proc "c" (base64_str: cstring, in_len: uint, out: ^u8, out_len: uint) -> i32 ---

base64_encode :: proc "c" (x: ^u8, length: uint, out: ^u8, out_len: uint) -> i32 ---

bcrypt_generate :: proc "c" (
	out:         ^u8, 
	out_len:     ^uint, 
	password:    cstring, 
	rng:         ^rng_struct, 
	work_factor: uint, 
	flags:       u32, 
) -> i32 ---

bcrypt_is_valid :: proc "c" (pass, hash: cstring) -> i32 ---

block_cipher_block_size :: proc "c" (bc: ^block_cipher_struct) -> i32 ---

block_cipher_clear :: proc "c" (bc: ^block_cipher_struct) -> i32 ---

block_cipher_decrypt_blocks :: proc "c" (bc: ^block_cipher_struct, input, out: ^u8, blocks: uint) -> i32 ---

block_cipher_destroy :: proc "c" (bc: ^block_cipher_struct) -> i32 ---

block_cipher_encrypt_blocks :: proc "c" (bc: ^block_cipher_struct, input, out: ^u8, blocks: uint) -> i32 ---

block_cipher_get_keyspec :: proc "c" (bc: ^block_cipher_struct, out_minimum_keylength, out_maximum_keylength, out_keylength_modulo: ^uint) -> i32 ---

block_cipher_init :: proc "c" (bc: ^^block_cipher_struct, name: cstring) -> i32 ---

block_cipher_name :: proc "c" (bc: ^block_cipher_struct, name: ^u8, name_len: ^uint) -> i32 ---

block_cipher_set_key :: proc "c" (bc: ^block_cipher_struct, key: ^u8, key_len: uint) -> i32 ---

cipher_clear :: proc "c" (hash: ^cipher_struct) -> i32 ---

cipher_destroy :: proc "c" (cipher: ^cipher_struct) -> i32 ---

cipher_get_default_nonce_length :: proc "c" (cipher: ^cipher_struct, nl: ^uint) -> i32 ---

cipher_get_keyspec :: proc "c" (cipher: ^cipher_struct, min_keylen, max_keylen, mod_keylen: ^uint) -> i32 ---

cipher_get_tag_length :: proc "c" (cipher: ^cipher_struct, tag_size: ^uint) -> i32 ---

cipher_get_update_granularity :: proc "c" (cipher: ^cipher_struct, ug: ^uint) -> i32 ---

cipher_init :: proc "c" (cipher: ^^cipher_struct, name: cstring, flags: u32) -> i32 ---

cipher_name :: proc "c" (cipher: ^cipher_struct, name: ^u8, name_len: ^uint) -> i32 ---

cipher_output_length :: proc "c" (cipher: ^cipher_struct, output_length: ^uint) -> i32 ---

cipher_query_keylen :: proc "c" (cipher: ^cipher_struct, out_minimum_keylength, out_maximum_keylength: ^uint) -> i32 ---

cipher_reset :: proc "c" (cipher: ^cipher_struct) -> i32 ---

cipher_set_associated_data :: proc "c" (cipher: ^cipher_struct, ad: ^u8, ad_len: uint) -> i32 ---

cipher_set_key :: proc "c" (cipher: ^cipher_struct, key: ^u8, key_len: uint) -> i32 ---

cipher_start :: proc "c" (cipher: ^cipher_struct, nonce: ^u8, nonce_len: uint) -> i32 ---

cipher_update :: proc "c" (
	cipher:         ^cipher_struct, 
	flags:          u32, 
	output:         ^u8, 
	output_size:    uint, 
	output_written: ^uint, 
	input_bytes:    ^u8, 
	input_size:     uint, 
	input_consumed: ^uint, 
) -> i32 ---

cipher_valid_nonce_length :: proc "c" (cipher: ^cipher_struct, nl: uint) -> i32 ---

constant_time_compare :: proc "c" (x, y: ^u8, length: uint) -> i32 ---

error_description :: proc "c" (err: i32) -> cstring ---

ffi_api_version :: proc "c" () -> i32 ---

ffi_supports_api :: proc "c" (api_version: i32) -> i32 ---

fpe_decrypt :: proc "c" (fpe: ^fpe_struct, x: ^mp_struct, tweak: ^u8, tweak_len: uint) -> i32 ---

fpe_destroy :: proc "c" (fpe: ^fpe_struct) -> i32 ---

fpe_encrypt :: proc "c" (fpe: ^fpe_struct, x: ^mp_struct, tweak: ^u8, tweak_len: uint) -> i32 ---

fpe_fe1_init :: proc "c" (
	fpe:             ^^fpe_struct, 
	n:               ^mp_struct, 
	key:             ^u8, 
	key_len, rounds: uint, 
	flags:           u32, 
) -> i32 ---

hash_block_size :: proc "c" (hash: ^hash_struct, block_size: ^uint) -> i32 ---

hash_clear :: proc "c" (hash: ^hash_struct) -> i32 ---

hash_copy_state :: proc "c" (dest: ^^hash_struct, source: ^hash_struct) -> i32 ---

hash_destroy :: proc "c" (hash: ^hash_struct) -> i32 ---

hash_final :: proc "c" (hash: ^hash_struct, out: ^u8) -> i32 ---

hash_init :: proc "c" (hash: ^^hash_struct, hash_name: cstring, flags: u32) -> i32 ---

hash_name :: proc "c" (hash: ^hash_struct, name: ^u8, name_len: ^uint) -> i32 ---

hash_output_length :: proc "c" (hash: ^hash_struct, output_length: ^uint) -> i32 ---

hash_update :: proc "c" (hash: ^hash_struct, input: ^u8, input_len: uint) -> i32 ---

hex_decode :: proc "c" (hex_str: cstring, in_len: uint, out: ^u8, out_len: uint) -> i32 ---

hex_encode :: proc "c" (x: ^u8, length: uint, out: ^u8, flags: u32) -> i32 ---

hotp_check :: proc "c" (hotp: ^hotp_struct, next_hotp_counter: ^u64, hotp_code: u32, hotp_counter: u64, resync_range: uint) -> i32 ---

hotp_destroy :: proc "c" (hotp: ^hotp_struct) -> i32 ---

hotp_generate :: proc "c" (hotp: ^hotp_struct, hotp_code: ^u32, hotp_counter: u64) -> i32 ---

hotp_init :: proc "c" (hotp: ^^hotp_struct, key: ^u8, key_len: uint, hash_algo: cstring, digits: uint) -> i32 ---

kdf :: proc "c" (
	kdf_algo:    cstring, 
	out:         ^u8, 
	out_len:     uint, 
	secret:      ^u8, 
	secret_lent: uint, 
	salt:        ^u8, 
	salt_len:    uint, 
	label:       ^u8, 
	label_len:   uint, 
) -> i32 ---

key_unwrap3394 :: proc "c" (
	wrapped_key:     ^u8, 
	wrapped_key_len: uint, 
	kek:             ^u8, 
	kek_len:         uint, 
	key:             ^u8, 
	key_len:         ^uint, 
) -> i32 ---

key_wrap3394 :: proc "c" (
	key:             ^u8, 
	key_len:         uint, 
	kek:             ^u8, 
	kek_len:         uint, 
	wrapped_key:     ^u8, 
	wrapped_key_len: ^uint, 
) -> i32 ---

mac_clear :: proc "c" (mac: ^mac_struct) -> i32 ---

mac_destroy :: proc "c" (mac: ^mac_struct) -> i32 ---

mac_final :: proc "c" (mac: ^mac_struct, out: ^u8) -> i32 ---

mac_get_keyspec :: proc "c" (mac: ^mac_struct, out_minimum_keylength, out_maximum_keylength, out_keylength_modulo: ^uint) -> i32 ---

mac_init :: proc "c" (mac: ^^mac_struct, hash_name: cstring, flags: u32) -> i32 ---

mac_name :: proc "c" (mac: ^mac_struct, name: ^u8, name_len: ^uint) -> i32 ---

mac_output_length :: proc "c" (mac: ^mac_struct, output_length: ^uint) -> i32 ---

mac_set_key :: proc "c" (mac: ^mac_struct, key: ^u8, key_len: uint) -> i32 ---

mac_update :: proc "c" (mac: ^mac_struct, buf: ^u8, length: uint) -> i32 ---

mceies_decrypt :: proc "c" (
	mce_key: ^privkey_struct, 
	aead:    cstring, 
	ct:      ^u8, 
	ct_len:  uint, 
	ad:      ^u8, 
	ad_len:  uint, 
	pt:      ^u8, 
	pt_len:  ^uint, 
) -> i32 ---

mceies_encrypt :: proc "c" (
	mce_key: ^pubkey_struct, 
	rng:     ^rng_struct, 
	aead:    cstring, 
	pt:      ^u8, 
	pt_len:  uint, 
	ad:      ^u8, 
	ad_len:  uint, 
	ct:      ^u8, 
	ct_len:  ^uint, 
) -> i32 ---

mp_add :: proc "c" (result, x, y: ^mp_struct) -> i32 ---

mp_add_u32 :: proc "c" (result, x: ^mp_struct, y: u32) -> i32 ---

mp_clear :: proc "c" (mp: ^mp_struct) -> i32 ---

mp_clear_bit :: proc "c" (n: ^mp_struct, bit: uint) -> i32 ---

mp_cmp :: proc "c" (result: ^i32, x, y: ^mp_struct) -> i32 ---

mp_destroy :: proc "c" (mp: ^mp_struct) -> i32 ---

mp_div :: proc "c" (quotient, remainder, x, y: ^mp_struct) -> i32 ---

mp_equal :: proc "c" (x, y: ^mp_struct) -> i32 ---

mp_flip_sign :: proc "c" (mp: ^mp_struct) -> i32 ---

mp_from_bin :: proc "c" (mp: ^mp_struct, vec: ^u8, vec_len: uint) -> i32 ---

mp_gcd :: proc "c" (out, x, y: ^mp_struct) -> i32 ---

mp_get_bit :: proc "c" (n: ^mp_struct, bit: uint) -> i32 ---

mp_init :: proc "c" (mp: ^^mp_struct) -> i32 ---

mp_is_even :: proc "c" (mp: ^mp_struct) -> i32 ---

mp_is_negative :: proc "c" (mp: ^mp_struct) -> i32 ---

mp_is_odd :: proc "c" (mp: ^mp_struct) -> i32 ---

mp_is_positive :: proc "c" (mp: ^mp_struct) -> i32 ---

mp_is_prime :: proc "c" (n: ^mp_struct, rng: ^rng_struct, test_prob: uint) -> i32 ---

mp_is_zero :: proc "c" (mp: ^mp_struct) -> i32 ---

mp_lshift :: proc "c" (out, input: ^mp_struct, shift: uint) -> i32 ---

mp_mod_inverse :: proc "c" (out, input, modulus: ^mp_struct) -> i32 ---

mp_mod_mul :: proc "c" (result, x, y, mod: ^mp_struct) -> i32 ---

mp_mul :: proc "c" (result, x, y: ^mp_struct) -> i32 ---

mp_num_bits :: proc "c" (n: ^mp_struct, bits: ^uint) -> i32 ---

mp_num_bytes :: proc "c" (n: ^mp_struct, bytes: ^uint) -> i32 ---

mp_powmod :: proc "c" (out, base, exponent, modulus: ^mp_struct) -> i32 ---

mp_rand_bits :: proc "c" (rand_out: ^mp_struct, rng: ^rng_struct, bits: uint) -> i32 ---

mp_rand_range :: proc "c" (rand_out: ^mp_struct, rng: ^rng_struct, lower_bound, upper_bound: ^mp_struct) -> i32 ---

mp_rshift :: proc "c" (out, input: ^mp_struct, shift: uint) -> i32 ---

mp_set_bit :: proc "c" (n: ^mp_struct, bit: uint) -> i32 ---

mp_set_from_int :: proc "c" (mp: ^mp_struct, initial_value: i32) -> i32 ---

mp_set_from_mp :: proc "c" (dest, source: ^mp_struct) -> i32 ---

mp_set_from_radix_str :: proc "c" (mp: ^mp_struct, str: cstring, radix: uint) -> i32 ---

mp_set_from_str :: proc "c" (dest: ^mp_struct, str: cstring) -> i32 ---

mp_sub :: proc "c" (result, x, y: ^mp_struct) -> i32 ---

mp_sub_u32 :: proc "c" (result, x: ^mp_struct, y: u32) -> i32 ---

mp_swap :: proc "c" (x, y: ^mp_struct) -> i32 ---

mp_to_bin :: proc "c" (mp: ^mp_struct, vec: ^u8) -> i32 ---

mp_to_hex :: proc "c" (mp: ^mp_struct, out: ^u8) -> i32 ---

mp_to_str :: proc "c" (mp: ^mp_struct, base: u8, out: ^u8, out_len: ^uint) -> i32 ---

mp_to_uint32 :: proc "c" (mp: ^mp_struct, val: ^u32) -> i32 ---

pbkdf :: proc "c" (
	pbkdf_algo: cstring, 
	out:        ^u8, 
	out_len:    uint, 
	passphrase: cstring, 
	salt:       ^u8, 
	salt_len, 
	iterations: uint, 
) -> i32 ---

pbkdf_timed :: proc "c" (
	pbkdf_algo:                    cstring, 
	out:                           ^u8, 
	out_len:                       uint, 
	passphrase:                    cstring, 
	salt:                          ^u8, 
	salt_len, milliseconds_to_run: uint, 
	out_iterations_used:           ^uint, 
) -> i32 ---

pk_op_decrypt :: proc "c" (
	op:             ^pk_op_decrypt_struct, 
	rng:            ^rng_struct, 
	out:            ^u8, 
	out_len:        ^uint, 
	ciphertext:     cstring, 
	ciphertext_len: uint, 
) -> i32 ---

pk_op_decrypt_create :: proc "c" (op: ^^pk_op_decrypt_struct, key: ^privkey_struct, padding: cstring, flags: u32) -> i32 ---

pk_op_decrypt_destroy :: proc "c" (op: ^pk_op_decrypt_struct) -> i32 ---

pk_op_decrypt_output_length :: proc "c" (op: ^pk_op_decrypt_struct, ptext_len: uint, ctext_len: ^uint) -> i32 ---

pk_op_encrypt :: proc "c" (
	op:            ^pk_op_encrypt_struct, 
	rng:           ^rng_struct, 
	out:           ^u8, 
	out_len:       ^uint, 
	plaintext:     cstring, 
	plaintext_len: uint, 
) -> i32 ---

pk_op_encrypt_create :: proc "c" (op: ^^pk_op_encrypt_struct, key: ^pubkey_struct, padding: cstring, flags: u32) -> i32 ---

pk_op_encrypt_destroy :: proc "c" (op: ^pk_op_encrypt_struct) -> i32 ---

pk_op_encrypt_output_length :: proc "c" (op: ^pk_op_encrypt_struct, ptext_len: uint, ctext_len: ^uint) -> i32 ---

pk_op_key_agreement :: proc "c" (
	op:            ^pk_op_ka_struct, 
	out:           ^u8, 
	out_len:       ^uint, 
	other_key:     ^u8, 
	other_key_len: uint, 
	salt:          ^u8, 
	salt_len:      uint, 
) -> i32 ---

pk_op_key_agreement_create :: proc "c" (op: ^^pk_op_ka_struct, kdf: cstring, flags: u32) -> i32 ---

pk_op_key_agreement_destroy :: proc "c" (op: ^pk_op_ka_struct) -> i32 ---

pk_op_key_agreement_export_public :: proc "c" (key: ^privkey_struct, out: ^u8, out_len: ^uint) -> i32 ---

pk_op_key_agreement_size :: proc "c" (op: ^pk_op_ka_struct, out_len: ^uint) -> i32 ---

pk_op_sign_create :: proc "c" (op: ^^pk_op_sign_struct, key: ^privkey_struct, hash_and_padding: cstring, flags: u32) -> i32 ---

pk_op_sign_destroy :: proc "c" (op: ^pk_op_sign_struct) -> i32 ---

pk_op_sign_finish :: proc "c" (op: ^pk_op_sign_struct, rng: ^rng_struct, sig: ^u8, sig_len: ^uint) -> i32 ---

pk_op_sign_output_length :: proc "c" (op: ^pk_op_sign_struct, olen: ^uint) -> i32 ---

pk_op_sign_update :: proc "c" (op: ^pk_op_sign_struct, input: ^u8, input_len: uint) -> i32 ---

pk_op_verify_create :: proc "c" (op: ^^pk_op_verify_struct, hash_and_padding: cstring, flags: u32) -> i32 ---

pk_op_verify_destroy :: proc "c" (op: ^pk_op_verify_struct) -> i32 ---

pk_op_verify_finish :: proc "c" (op: ^pk_op_verify_struct, sig: ^u8, sig_len: uint) -> i32 ---

pk_op_verify_update :: proc "c" (op: ^pk_op_verify_struct, input: ^u8, input_len: uint) -> i32 ---

pkcs_hash_id :: proc "c" (hash_name: cstring, pkcs_id: ^u8, pkcs_id_len: ^uint) -> i32 ---

privkey_algo_name :: proc "c" (key: ^privkey_struct, out: ^u8, out_len: ^uint) -> i32 ---

privkey_check_key :: proc "c" (key: ^privkey_struct, rng: ^rng_struct, flags: u32) -> i32 ---

privkey_create :: proc "c" (key: ^^privkey_struct, algo_name, algo_params: cstring, rng: ^rng_struct) -> i32 ---

privkey_create_dh :: proc "c" (key: ^^privkey_struct, rng: ^rng_struct, param: cstring) -> i32 ---

privkey_create_dsa :: proc "c" (key: ^^privkey_struct, rng: ^rng_struct, pbits, qbits: uint) -> i32 ---

privkey_create_ecdh :: proc "c" (key: ^^privkey_struct, rng: ^rng_struct, params: cstring) -> i32 ---

privkey_create_ecdsa :: proc "c" (key: ^^privkey_struct, rng: ^rng_struct, params: cstring) -> i32 ---

privkey_create_elgamal :: proc "c" (key: ^^privkey_struct, rng: ^rng_struct, pbits, qbits: uint) -> i32 ---

privkey_create_mceliece :: proc "c" (key: ^^privkey_struct, rng: ^rng_struct, n, t: uint) -> i32 ---

privkey_create_rsa :: proc "c" (key: ^^privkey_struct, rng: ^rng_struct, bits: uint) -> i32 ---

privkey_destroy :: proc "c" (key: ^privkey_struct) -> i32 ---

privkey_dsa_get_x :: proc "c" (n: ^mp_struct, key: ^privkey_struct) -> i32 ---

privkey_ed25519_get_privkey :: proc "c" (key: ^^privkey_struct, output: [64]u8) -> i32 ---

privkey_export :: proc "c" (key: ^privkey_struct, out: ^u8, out_len: ^uint, flags: u32) -> i32 ---

privkey_export_encrypted :: proc "c" (
	key:                         ^privkey_struct, 
	out:                         ^u8, 
	out_len:                     ^uint, 
	rng:                         ^rng_struct, 
	passphrase, encryption_algo: cstring, 
	flags:                       u32, 
) -> i32 ---

privkey_export_encrypted_pbkdf_iter :: proc "c" (
	key:                     ^privkey_struct, 
	out:                     ^u8, 
	out_len:                 ^uint, 
	rng:                     ^rng_struct, 
	passphrase:              cstring, 
	pbkdf_iterations:        uint, 
	cipher_algo, pbkdf_algo: cstring, 
	flags:                   u32, 
) -> i32 ---

privkey_export_encrypted_pbkdf_msec :: proc "c" (
	key:                     ^privkey_struct, 
	out:                     ^u8, 
	out_len:                 ^uint, 
	rng:                     ^rng_struct, 
	passphrase:              cstring, 
	pbkdf_msec_runtime:      u32, 
	pbkdf_iterations_out:    ^uint, 
	cipher_algo, pbkdf_algo: cstring, 
	flags:                   u32, 
) -> i32 ---

privkey_export_pubkey :: proc "c" (out: ^^pubkey_struct, input: ^privkey_struct) -> i32 ---

privkey_get_field :: proc "c" (output: ^mp_struct, key: ^privkey_struct, field_name: cstring) -> i32 ---

privkey_load :: proc "c" (key: ^^privkey_struct, rng: ^rng_struct, bits: ^u8, length: uint, password: cstring) -> i32 ---

privkey_load_dh :: proc "c" (key: ^^privkey_struct, p, g, y: ^mp_struct) -> i32 ---

privkey_load_dsa :: proc "c" (key: ^^privkey_struct, p, q, g, x: ^mp_struct) -> i32 ---

privkey_load_ecdh :: proc "c" (key: ^^privkey_struct, scalar: ^mp_struct, curve_name: cstring) -> i32 ---

privkey_load_ecdsa :: proc "c" (key: ^^privkey_struct, scalar: ^mp_struct, curve_name: cstring) -> i32 ---

privkey_load_ed25519 :: proc "c" (key: ^^privkey_struct, privkey: [32]u8) -> i32 ---

privkey_load_elgamal :: proc "c" (key: ^^privkey_struct, p, g, y: ^mp_struct) -> i32 ---

privkey_load_rsa :: proc "c" (key: ^^privkey_struct, p, q, e: ^mp_struct) -> i32 ---

privkey_load_rsa_pkcs1 :: proc "c" (key: ^^privkey_struct, bits: ^u8, length: uint) -> i32 ---

privkey_load_sm2 :: proc "c" (key: ^^privkey_struct, scalar: ^mp_struct, curve_name: cstring) -> i32 ---

privkey_load_sm2_enc :: proc "c" (key: ^^privkey_struct, scalar: ^mp_struct, curve_name: cstring) -> i32 ---

privkey_load_x25519 :: proc "c" (key: ^^privkey_struct, privkey: [32]u8) -> i32 ---

privkey_rsa_get_d :: proc "c" (d: ^mp_struct, rsa_key: ^privkey_struct) -> i32 ---

privkey_rsa_get_e :: proc "c" (e: ^mp_struct, rsa_key: ^privkey_struct) -> i32 ---

privkey_rsa_get_n :: proc "c" (n: ^mp_struct, rsa_key: ^privkey_struct) -> i32 ---

privkey_rsa_get_p :: proc "c" (p: ^mp_struct, rsa_key: ^privkey_struct) -> i32 ---

privkey_rsa_get_privkey :: proc "c" (rsa_key: ^privkey_struct, out: ^u8, out_len: ^uint, flags: u32) -> i32 ---

privkey_rsa_get_q :: proc "c" (q: ^mp_struct, rsa_key: ^privkey_struct) -> i32 ---

privkey_x25519_get_privkey :: proc "c" (key: ^^privkey_struct, output: [32]u8) -> i32 ---

pubkey_algo_name :: proc "c" (key: ^pubkey_struct, out: ^u8, out_len: ^uint) -> i32 ---

pubkey_check_key :: proc "c" (key: ^pubkey_struct, rng: ^rng_struct, flags: u32) -> i32 ---

pubkey_destroy :: proc "c" (key: ^pubkey_struct) -> i32 ---

pubkey_dsa_get_g :: proc "c" (d: ^mp_struct, key: ^pubkey_struct) -> i32 ---

pubkey_dsa_get_p :: proc "c" (p: ^mp_struct, key: ^pubkey_struct) -> i32 ---

pubkey_dsa_get_q :: proc "c" (q: ^mp_struct, key: ^pubkey_struct) -> i32 ---

pubkey_dsa_get_y :: proc "c" (y: ^mp_struct, key: ^pubkey_struct) -> i32 ---

pubkey_ed25519_get_pubkey :: proc "c" (key: ^^pubkey_struct, pubkey: [32]u8) -> i32 ---

pubkey_estimated_strength :: proc "c" (key: ^pubkey_struct, estimate: ^uint) -> i32 ---

pubkey_export :: proc "c" (key: ^pubkey_struct, out: ^u8, out_len: ^uint, flags: u32) -> i32 ---

pubkey_fingerprint :: proc "c" (key: ^pubkey_struct, hash: cstring, out: ^u8, out_len: ^uint) -> i32 ---

pubkey_get_field :: proc "c" (output: ^mp_struct, key: ^pubkey_struct, field_name: cstring) -> i32 ---

pubkey_load :: proc "c" (key: ^^pubkey_struct, bits: ^u8, length: uint) -> i32 ---

pubkey_load_dh :: proc "c" (key: ^^pubkey_struct, p, g, x: ^mp_struct) -> i32 ---

pubkey_load_dsa :: proc "c" (key: ^^pubkey_struct, p, q, g, y: ^mp_struct) -> i32 ---

pubkey_load_ecdh :: proc "c" (key: ^^pubkey_struct, public_x, public_y: ^mp_struct, curve_name: cstring) -> i32 ---

pubkey_load_ecdsa :: proc "c" (key: ^^pubkey_struct, public_x, public_y: ^mp_struct, curve_name: cstring) -> i32 ---

pubkey_load_ed25519 :: proc "c" (key: ^^pubkey_struct, pubkey: [32]u8) -> i32 ---

pubkey_load_elgamal :: proc "c" (key: ^^pubkey_struct, p, g, x: ^mp_struct) -> i32 ---

pubkey_load_rsa :: proc "c" (key: ^^pubkey_struct, n, e: ^mp_struct) -> i32 ---

pubkey_load_sm2 :: proc "c" (key: ^^pubkey_struct, public_x, public_y: ^mp_struct, curve_name: cstring) -> i32 ---

pubkey_load_sm2_enc :: proc "c" (key: ^^pubkey_struct, public_x, public_y: ^mp_struct, curve_name: cstring) -> i32 ---

pubkey_load_x25519 :: proc "c" (key: ^^pubkey_struct, pubkey: [32]u8) -> i32 ---

pubkey_rsa_get_e :: proc "c" (e: ^mp_struct, rsa_key: ^pubkey_struct) -> i32 ---

pubkey_rsa_get_n :: proc "c" (n: ^mp_struct, rsa_key: ^pubkey_struct) -> i32 ---

pubkey_sm2_compute_za :: proc "c" (out: ^u8, out_len: ^uint, ident, hash_algo: cstring, key: ^pubkey_struct) -> i32 ---

pubkey_x25519_get_pubkey :: proc "c" (key: ^^pubkey_struct, pubkey: [32]u8) -> i32 ---

pwdhash :: proc "c" (
	algo:                   cstring, 
	param1, param2, param3: uint, 
	out:                    ^u8, 
	out_len:                uint, 
	passphrase:             cstring, 
	passphrase_len:         uint, 
	salt:                   ^u8, 
	salt_len:               uint, 
) -> i32 ---

pwdhash_timed :: proc "c" (
	algo:                   cstring, 
	msec:                   u32, 
	param1, param2, param3: uint, 
	out:                    ^u8, 
	out_len:                uint, 
	passphrase:             cstring, 
	passphrase_len:         uint, 
	salt:                   ^u8, 
	salt_len:               uint, 
) -> i32 ---

rng_add_entropy :: proc "c" (rng: ^rng_struct, entropy: ^u8, entropy_len: uint) -> i32 ---

rng_destroy :: proc "c" (rng: ^rng_struct) -> i32 ---

rng_get :: proc "c" (rng: ^rng_struct, out: ^u8, out_len: uint) -> i32 ---

rng_init :: proc "c" (rng: ^^rng_struct, rng_type: cstring) -> i32 ---

rng_init_custom :: proc "c" (
	rng_out:        ^^rng_struct, 
	rng_name:       cstring, 
	ctx:            rawptr, 
	get_cb:         proc "c" (ctx: rawptr, out: ^u8, out_len: uint) -> ^i32, 
	add_entropy_cb: proc "c" (ctx: rawptr, input: ^u8, length: uint) -> ^i32, 
	destroy_cb:     proc "c" (ctx: rawptr) -> rawptr, 
) -> i32 ---

rng_reseed :: proc "c" (rng: ^rng_struct, bits: uint) -> i32 ---

rng_reseed_from_rng :: proc "c" (rng, source_rng: ^rng_struct, bits: uint) -> i32 ---

same_mem :: proc "c" (x, y: ^u8, length: uint) -> i32 ---

scrub_mem :: proc "c" (mem: rawptr, bytes: uint) -> i32 ---

scrypt :: proc "c" (
	out:            ^u8, 
	out_len:        uint, 
	passphrase:     cstring, 
	salt:           ^u8, 
	salt_len, N, r, 
	p:              uint, 
) -> i32 ---

totp_check :: proc "c" (totp: ^totp_struct, totp_code: ^u32, timestamp: u64, acceptable_clock_drift: uint) -> i32 ---

totp_destroy :: proc "c" (totp: ^totp_struct) -> i32 ---

totp_generate :: proc "c" (totp: ^totp_struct, totp_code: ^u32, timestamp: u64) -> i32 ---

totp_init :: proc "c" (
	totp:      ^^totp_struct, 
	key:       ^u8, 
	key_len:   uint, 
	hash_algo: cstring, 
	digits, 
	time_step: uint, 
) -> i32 ---

version_datestamp :: proc "c" () -> i32 ---

version_major :: proc "c" () -> i32 ---

version_minor :: proc "c" () -> i32 ---

version_patch :: proc "c" () -> i32 ---

version_string :: proc "c" () -> cstring ---

x509_cert_allowed_usage :: proc "c" (cert: ^x509_cert_struct, key_usage: u32) -> i32 ---

x509_cert_destroy :: proc "c" (cert: ^x509_cert_struct) -> i32 ---

x509_cert_dup :: proc "c" (new_cert: ^^x509_cert_struct, cert: ^x509_cert_struct) -> i32 ---

x509_cert_get_authority_key_id :: proc "c" (cert: ^x509_cert_struct, out: ^u8, out_len: ^uint) -> i32 ---

x509_cert_get_fingerprint :: proc "c" (cert: ^x509_cert_struct, hash: cstring, out: ^u8, out_len: ^uint) -> i32 ---

x509_cert_get_issuer_dn :: proc "c" (cert: ^x509_cert_struct, key: ^u8, index: uint, out: ^u8, out_len: ^uint) -> i32 ---

x509_cert_get_public_key :: proc "c" (cert: ^x509_cert_struct, key: ^^pubkey_struct) -> i32 ---

x509_cert_get_public_key_bits :: proc "c" (cert: ^x509_cert_struct, out: ^u8, out_len: ^uint) -> i32 ---

x509_cert_get_serial_number :: proc "c" (cert: ^x509_cert_struct, out: ^u8, out_len: ^uint) -> i32 ---

x509_cert_get_subject_dn :: proc "c" (cert: ^x509_cert_struct, key: ^u8, index: uint, out: ^u8, out_len: ^uint) -> i32 ---

x509_cert_get_subject_key_id :: proc "c" (cert: ^x509_cert_struct, out: ^u8, out_len: ^uint) -> i32 ---

x509_cert_get_time_expires :: proc "c" (cert: ^x509_cert_struct, out: ^u8, out_len: ^uint) -> i32 ---

x509_cert_get_time_starts :: proc "c" (cert: ^x509_cert_struct, out: ^u8, out_len: ^uint) -> i32 ---

x509_cert_hostname_match :: proc "c" (cert: ^x509_cert_struct, hostname: cstring) -> i32 ---

x509_cert_load :: proc "c" (cert_obj: ^^x509_cert_struct, cert: ^u8, cert_len: uint) -> i32 ---

x509_cert_load_file :: proc "c" (cert_obj: ^^x509_cert_struct, filename: cstring) -> i32 ---

x509_cert_not_after :: proc "c" (cert: ^x509_cert_struct, time_since_epoch: ^u64) -> i32 ---

x509_cert_not_before :: proc "c" (cert: ^x509_cert_struct, time_since_epoch: ^u64) -> i32 ---

x509_cert_to_string :: proc "c" (cert: ^x509_cert_struct, out: ^u8, out_len: ^uint) -> i32 ---

x509_cert_validation_status :: proc "c" (code: i32) -> cstring ---

x509_cert_verify :: proc "c" (
	validation_result: ^i32, 
	cert:              ^x509_cert_struct, 
	intermediates:     ^^x509_cert_struct, 
	intermediates_len: uint, 
	trusted:           ^^x509_cert_struct, 
	trusted_len:       uint, 
	trusted_path:      cstring, 
	required_strength: uint, 
	hostname:          cstring, 
	reference_time:    u64, 
) -> i32 ---

x509_cert_verify_with_crl :: proc "c" (
	validation_result: ^i32, 
	cert:              ^x509_cert_struct, 
	intermediates:     ^^x509_cert_struct, 
	intermediates_len: uint, 
	trusted:           ^^x509_cert_struct, 
	trusted_len:       uint, 
	crls:              ^^x509_crl_struct, 
	crls_len:          uint, 
	trusted_path:      cstring, 
	required_strength: uint, 
	hostname:          cstring, 
	reference_time:    u64, 
) -> i32 ---

x509_crl_destroy :: proc "c" (crl: ^x509_crl_struct) -> i32 ---

x509_crl_load :: proc "c" (crl_obj: ^^x509_crl_struct, crl_bits: ^u8, crl_bits_len: uint) -> i32 ---

x509_crl_load_file :: proc "c" (crl_obj: ^^x509_crl_struct, crl_path: cstring) -> i32 ---

x509_is_revoked :: proc "c" (crl: ^x509_crl_struct, cert: ^x509_cert_struct) -> i32 ---