package vendor:botan/bindings

⌘K
Ctrl+K
or
/

    Index

    Constants (59)
    Variables (0)

    This section is empty.

    Procedures (244)
    Procedure Groups (0)

    This section is empty.

    Types

    FFI_ERROR ¶

    FFI_ERROR :: i32

    fpe_struct ¶

    fpe_struct :: struct {}
    Related Procedures With Parameters

    hotp_struct ¶

    hotp_struct :: struct {}
    Related Procedures With Parameters

    pk_op_decrypt_struct ¶

    pk_op_decrypt_struct :: struct {}
    Related Procedures With Parameters

    pk_op_encrypt_struct ¶

    pk_op_encrypt_struct :: struct {}
    Related Procedures With Parameters

    pk_op_ka_struct ¶

    pk_op_ka_struct :: struct {}
    Related Procedures With Parameters

    pk_op_sign_struct ¶

    pk_op_sign_struct :: struct {}
    Related Procedures With Parameters

    pk_op_verify_struct ¶

    pk_op_verify_struct :: struct {}
    Related Procedures With Parameters

    totp_struct ¶

    totp_struct :: struct {}
    Related Procedures With Parameters

    x509_cert_key_constraints ¶

    x509_cert_key_constraints :: i32

    x509_crl_struct ¶

    x509_crl_struct :: struct {}
    Related Procedures With Parameters

    Constants

    CHECK_KEY_EXPENSIVE_TESTS ¶

    CHECK_KEY_EXPENSIVE_TESTS :: 1

    CIPHER_INIT_FLAG_DECRYPT ¶

    CIPHER_INIT_FLAG_DECRYPT :: 1

    CIPHER_INIT_FLAG_ENCRYPT ¶

    CIPHER_INIT_FLAG_ENCRYPT :: 0

    CIPHER_INIT_FLAG_MASK_DIRECTION ¶

    CIPHER_INIT_FLAG_MASK_DIRECTION :: 1

    CIPHER_UPDATE_FLAG_FINAL ¶

    CIPHER_UPDATE_FLAG_FINAL :: 1 << 0

    CRL_SIGN ¶

    CRL_SIGN: i32 : x509_cert_key_constraints(512)

    DATA_ENCIPHERMENT ¶

    DATA_ENCIPHERMENT: i32 : x509_cert_key_constraints(4096)

    DECIPHER_ONLY ¶

    DECIPHER_ONLY: i32 : x509_cert_key_constraints(128)

    DIGITAL_SIGNATURE ¶

    DIGITAL_SIGNATURE: i32 : x509_cert_key_constraints(32768)

    ENCIPHER_ONLY ¶

    ENCIPHER_ONLY: i32 : x509_cert_key_constraints(256)

    FFI_ERROR_BAD_FLAG ¶

    FFI_ERROR_BAD_FLAG: i32 : FFI_ERROR(-30)

    FFI_ERROR_BAD_MAC ¶

    FFI_ERROR_BAD_MAC: i32 : FFI_ERROR(-2)

    FFI_ERROR_BAD_PARAMETER ¶

    FFI_ERROR_BAD_PARAMETER: i32 : FFI_ERROR(-32)

    FFI_ERROR_EXCEPTION_THROWN ¶

    FFI_ERROR_EXCEPTION_THROWN: i32 : FFI_ERROR(-20)

    FFI_ERROR_INSUFFICIENT_BUFFER_SPACE ¶

    FFI_ERROR_INSUFFICIENT_BUFFER_SPACE: i32 : FFI_ERROR(-10)

    FFI_ERROR_INVALID_INPUT ¶

    FFI_ERROR_INVALID_INPUT: i32 : FFI_ERROR(-1)

    FFI_ERROR_INVALID_KEY_LENGTH ¶

    FFI_ERROR_INVALID_KEY_LENGTH: i32 : FFI_ERROR(-34)

    FFI_ERROR_INVALID_OBJECT ¶

    FFI_ERROR_INVALID_OBJECT: i32 : FFI_ERROR(-50)

    FFI_ERROR_KEY_NOT_SET ¶

    FFI_ERROR_KEY_NOT_SET: i32 : FFI_ERROR(-33)

    FFI_ERROR_NOT_IMPLEMENTED ¶

    FFI_ERROR_NOT_IMPLEMENTED: i32 : FFI_ERROR(-40)

    FFI_ERROR_NULL_POINTER ¶

    FFI_ERROR_NULL_POINTER: i32 : FFI_ERROR(-31)

    FFI_ERROR_OUT_OF_MEMORY ¶

    FFI_ERROR_OUT_OF_MEMORY: i32 : FFI_ERROR(-21)

    FFI_ERROR_UNKNOWN_ERROR ¶

    FFI_ERROR_UNKNOWN_ERROR: i32 : FFI_ERROR(-100)

    FFI_HEX_LOWER_CASE ¶

    FFI_HEX_LOWER_CASE :: 1

    FFI_INVALID_VERIFIER ¶

    FFI_INVALID_VERIFIER: i32 : FFI_ERROR(1)

    FFI_SUCCESS ¶

    FFI_SUCCESS: i32 : FFI_ERROR(0)

    FPE_FLAG_FE1_COMPAT_MODE ¶

    FPE_FLAG_FE1_COMPAT_MODE :: 1

    HASH_BLAKE2B ¶

    HASH_BLAKE2B :: "BLAKE2b"

    HASH_KECCAK_512 ¶

    HASH_KECCAK_512 :: "Keccak-1600"

    HASH_MD5 ¶

    HASH_MD5 :: "MD5"

    HASH_SHA1 ¶

    HASH_SHA1 :: "SHA-1"

    HASH_SHA3_224 ¶

    HASH_SHA3_224 :: "SHA-3(224)"

    HASH_SHA3_256 ¶

    HASH_SHA3_256 :: "SHA-3(256)"

    HASH_SHA3_384 ¶

    HASH_SHA3_384 :: "SHA-3(384)"

    HASH_SHA3_512 ¶

    HASH_SHA3_512 :: "SHA-3(512)"

    HASH_SHAKE_128 ¶

    HASH_SHAKE_128 :: "SHAKE-128"

    HASH_SHAKE_256 ¶

    HASH_SHAKE_256 :: "SHAKE-256"

    HASH_SHA_224 ¶

    HASH_SHA_224 :: "SHA-224"

    HASH_SHA_256 ¶

    HASH_SHA_256 :: "SHA-256"

    HASH_SHA_384 ¶

    HASH_SHA_384 :: "SHA-384"

    HASH_SHA_512 ¶

    HASH_SHA_512 :: "SHA-512"

    HASH_SM3 ¶

    HASH_SM3 :: "SM3"

    KEY_AGREEMENT ¶

    KEY_AGREEMENT: i32 : x509_cert_key_constraints(2048)

    KEY_CERT_SIGN ¶

    KEY_CERT_SIGN: i32 : x509_cert_key_constraints(1024)

    KEY_ENCIPHERMENT ¶

    KEY_ENCIPHERMENT: i32 : x509_cert_key_constraints(8192)

    MAC_HMAC_MD5 ¶

    MAC_HMAC_MD5 :: "HMAC(MD5)"

    MAC_HMAC_SHA1 ¶

    MAC_HMAC_SHA1 :: "HMAC(SHA1)"

    MAC_HMAC_SHA_224 ¶

    MAC_HMAC_SHA_224 :: "HMAC(SHA-224)"

    MAC_HMAC_SHA_256 ¶

    MAC_HMAC_SHA_256 :: "HMAC(SHA-256)"

    MAC_HMAC_SHA_384 ¶

    MAC_HMAC_SHA_384 :: "HMAC(SHA-384)"

    MAC_HMAC_SHA_512 ¶

    MAC_HMAC_SHA_512 :: "HMAC(SHA-512)"

    MAC_SIPHASH_1_3 ¶

    MAC_SIPHASH_1_3 :: "SipHash(1,3)"

    MAC_SIPHASH_2_4 ¶

    MAC_SIPHASH_2_4 :: "SipHash(2,4)"

    MAC_SIPHASH_4_8 ¶

    MAC_SIPHASH_4_8 :: "SipHash(4,8)"

    NON_REPUDIATION ¶

    NON_REPUDIATION: i32 : x509_cert_key_constraints(16384)

    NO_CONSTRAINTS ¶

    NO_CONSTRAINTS: i32 : x509_cert_key_constraints(0)

    PRIVKEY_EXPORT_FLAG_DER ¶

    PRIVKEY_EXPORT_FLAG_DER :: 0

    PRIVKEY_EXPORT_FLAG_PEM ¶

    PRIVKEY_EXPORT_FLAG_PEM :: 1

    PUBKEY_DER_FORMAT_SIGNATURE ¶

    PUBKEY_DER_FORMAT_SIGNATURE :: 1

    Variables

    This section is empty.

    Procedures

    base64_decode ¶

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

    base64_encode ¶

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

    bcrypt_generate ¶

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

    bcrypt_is_valid ¶

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

    block_cipher_block_size ¶

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

    block_cipher_clear ¶

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

    block_cipher_decrypt_blocks ¶

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

    block_cipher_destroy ¶

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

    block_cipher_encrypt_blocks ¶

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

    block_cipher_get_keyspec ¶

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

    block_cipher_init ¶

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

    block_cipher_name ¶

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

    block_cipher_set_key ¶

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

    cipher_clear ¶

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

    cipher_destroy ¶

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

    cipher_get_default_nonce_length ¶

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

    cipher_get_keyspec ¶

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

    cipher_get_tag_length ¶

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

    cipher_get_update_granularity ¶

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

    cipher_init ¶

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

    cipher_name ¶

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

    cipher_output_length ¶

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

    cipher_query_keylen ¶

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

    cipher_reset ¶

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

    cipher_set_associated_data ¶

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

    cipher_set_key ¶

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

    cipher_start ¶

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

    cipher_update ¶

    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 ¶

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

    constant_time_compare ¶

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

    error_description ¶

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

    ffi_api_version ¶

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

    ffi_supports_api ¶

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

    fpe_decrypt ¶

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

    fpe_destroy ¶

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

    fpe_encrypt ¶

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

    fpe_fe1_init ¶

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

    hash_block_size ¶

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

    hash_clear ¶

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

    hash_copy_state ¶

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

    hash_destroy ¶

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

    hash_final ¶

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

    hash_init ¶

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

    hash_name ¶

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

    hash_output_length ¶

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

    hash_update ¶

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

    hex_decode ¶

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

    hex_encode ¶

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

    hotp_check ¶

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

    hotp_destroy ¶

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

    hotp_generate ¶

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

    hotp_init ¶

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

    kdf ¶

    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 ¶

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

    key_wrap3394 ¶

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

    mac_clear ¶

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

    mac_destroy ¶

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

    mac_final ¶

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

    mac_get_keyspec ¶

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

    mac_init ¶

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

    mac_name ¶

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

    mac_output_length ¶

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

    mac_set_key ¶

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

    mac_update ¶

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

    mceies_decrypt ¶

    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 ¶

    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 ¶

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

    mp_add_u32 ¶

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

    mp_clear ¶

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

    mp_clear_bit ¶

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

    mp_cmp ¶

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

    mp_destroy ¶

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

    mp_div ¶

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

    mp_equal ¶

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

    mp_flip_sign ¶

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

    mp_from_bin ¶

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

    mp_gcd ¶

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

    mp_get_bit ¶

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

    mp_init ¶

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

    mp_is_even ¶

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

    mp_is_negative ¶

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

    mp_is_odd ¶

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

    mp_is_positive ¶

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

    mp_is_prime ¶

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

    mp_is_zero ¶

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

    mp_lshift ¶

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

    mp_mod_inverse ¶

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

    mp_mod_mul ¶

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

    mp_mul ¶

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

    mp_num_bits ¶

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

    mp_num_bytes ¶

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

    mp_powmod ¶

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

    mp_rand_bits ¶

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

    mp_rand_range ¶

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

    mp_rshift ¶

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

    mp_set_bit ¶

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

    mp_set_from_int ¶

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

    mp_set_from_mp ¶

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

    mp_set_from_radix_str ¶

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

    mp_set_from_str ¶

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

    mp_sub ¶

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

    mp_sub_u32 ¶

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

    mp_swap ¶

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

    mp_to_bin ¶

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

    mp_to_hex ¶

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

    mp_to_str ¶

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

    mp_to_uint32 ¶

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

    pbkdf ¶

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

    pbkdf_timed ¶

    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 ¶

    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 ¶

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

    pk_op_decrypt_destroy ¶

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

    pk_op_decrypt_output_length ¶

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

    pk_op_encrypt ¶

    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 ¶

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

    pk_op_encrypt_destroy ¶

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

    pk_op_encrypt_output_length ¶

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

    pk_op_key_agreement ¶

    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 ¶

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

    pk_op_key_agreement_destroy ¶

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

    pk_op_key_agreement_export_public ¶

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

    pk_op_key_agreement_size ¶

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

    pk_op_sign_create ¶

    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 ¶

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

    pk_op_sign_finish ¶

    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 ¶

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

    pk_op_sign_update ¶

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

    pk_op_verify_create ¶

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

    pk_op_verify_destroy ¶

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

    pk_op_verify_finish ¶

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

    pk_op_verify_update ¶

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

    pkcs_hash_id ¶

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

    privkey_algo_name ¶

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

    privkey_check_key ¶

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

    privkey_create ¶

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

    privkey_create_dh ¶

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

    privkey_create_dsa ¶

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

    privkey_create_ecdh ¶

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

    privkey_create_ecdsa ¶

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

    privkey_create_elgamal ¶

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

    privkey_create_mceliece ¶

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

    privkey_create_rsa ¶

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

    privkey_destroy ¶

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

    privkey_dsa_get_x ¶

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

    privkey_ed25519_get_privkey ¶

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

    privkey_export ¶

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

    privkey_export_encrypted ¶

    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 ¶

    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 ¶

    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 ¶

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

    privkey_get_field ¶

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

    privkey_load ¶

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

    privkey_load_dh ¶

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

    privkey_load_dsa ¶

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

    privkey_load_ecdh ¶

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

    privkey_load_ecdsa ¶

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

    privkey_load_ed25519 ¶

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

    privkey_load_elgamal ¶

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

    privkey_load_rsa ¶

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

    privkey_load_rsa_pkcs1 ¶

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

    privkey_load_sm2 ¶

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

    privkey_load_sm2_enc ¶

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

    privkey_load_x25519 ¶

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

    privkey_rsa_get_d ¶

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

    privkey_rsa_get_e ¶

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

    privkey_rsa_get_n ¶

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

    privkey_rsa_get_p ¶

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

    privkey_rsa_get_privkey ¶

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

    privkey_rsa_get_q ¶

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

    privkey_x25519_get_privkey ¶

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

    pubkey_algo_name ¶

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

    pubkey_check_key ¶

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

    pubkey_destroy ¶

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

    pubkey_dsa_get_g ¶

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

    pubkey_dsa_get_p ¶

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

    pubkey_dsa_get_q ¶

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

    pubkey_dsa_get_y ¶

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

    pubkey_ed25519_get_pubkey ¶

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

    pubkey_estimated_strength ¶

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

    pubkey_export ¶

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

    pubkey_fingerprint ¶

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

    pubkey_get_field ¶

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

    pubkey_load ¶

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

    pubkey_load_dh ¶

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

    pubkey_load_dsa ¶

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

    pubkey_load_ecdh ¶

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

    pubkey_load_ecdsa ¶

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

    pubkey_load_ed25519 ¶

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

    pubkey_load_elgamal ¶

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

    pubkey_load_rsa ¶

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

    pubkey_load_sm2 ¶

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

    pubkey_load_sm2_enc ¶

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

    pubkey_load_x25519 ¶

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

    pubkey_rsa_get_e ¶

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

    pubkey_rsa_get_n ¶

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

    pubkey_sm2_compute_za ¶

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

    pubkey_x25519_get_pubkey ¶

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

    pwdhash ¶

    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 ¶

    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 ¶

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

    rng_destroy ¶

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

    rng_get ¶

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

    rng_init ¶

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

    rng_init_custom ¶

    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 ¶

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

    rng_reseed_from_rng ¶

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

    same_mem ¶

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

    scrub_mem ¶

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

    scrypt ¶

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

    totp_check ¶

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

    totp_destroy ¶

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

    totp_generate ¶

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

    totp_init ¶

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

    version_datestamp ¶

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

    version_major ¶

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

    version_minor ¶

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

    version_patch ¶

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

    version_string ¶

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

    x509_cert_allowed_usage ¶

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

    x509_cert_destroy ¶

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

    x509_cert_dup ¶

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

    x509_cert_get_authority_key_id ¶

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

    x509_cert_get_fingerprint ¶

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

    x509_cert_get_issuer_dn ¶

    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 ¶

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

    x509_cert_get_public_key_bits ¶

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

    x509_cert_get_serial_number ¶

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

    x509_cert_get_subject_dn ¶

    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 ¶

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

    x509_cert_get_time_expires ¶

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

    x509_cert_get_time_starts ¶

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

    x509_cert_hostname_match ¶

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

    x509_cert_load ¶

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

    x509_cert_load_file ¶

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

    x509_cert_not_after ¶

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

    x509_cert_not_before ¶

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

    x509_cert_to_string ¶

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

    x509_cert_validation_status ¶

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

    x509_cert_verify ¶

    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 ¶

    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 ¶

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

    x509_crl_load ¶

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

    x509_crl_load_file ¶

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

    x509_is_revoked ¶

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

    Procedure Groups

    This section is empty.

    Source Files

    Generation Information

    Generated with odin version dev-2024-03 (vendor "odin") Windows_amd64 @ 2024-03-01 21:10:24.943867600 +0000 UTC