pub const Hacl_Impl_Blake2_Core_M32: u32 = 0;
pub const Hacl_Impl_Blake2_Core_M128: u32 = 1;
pub const Hacl_Impl_Blake2_Core_M256: u32 = 2;
pub const Spec_Blake2_Blake2S: u32 = 0;
pub const Spec_Blake2_Blake2B: u32 = 1;
pub const Spec_Hash_Definitions_SHA2_224: u32 = 0;
pub const Spec_Hash_Definitions_SHA2_256: u32 = 1;
pub const Spec_Hash_Definitions_SHA2_384: u32 = 2;
pub const Spec_Hash_Definitions_SHA2_512: u32 = 3;
pub const Spec_Hash_Definitions_SHA1: u32 = 4;
pub const Spec_Hash_Definitions_MD5: u32 = 5;
pub const Spec_Hash_Definitions_Blake2S: u32 = 6;
pub const Spec_Hash_Definitions_Blake2B: u32 = 7;
pub const Spec_FFDHE_FFDHE2048: u32 = 0;
pub const Spec_FFDHE_FFDHE3072: u32 = 1;
pub const Spec_FFDHE_FFDHE4096: u32 = 2;
pub const Spec_FFDHE_FFDHE6144: u32 = 3;
pub const Spec_FFDHE_FFDHE8192: u32 = 4;
pub const Spec_Agile_Cipher_AES128: u32 = 0;
pub const Spec_Agile_Cipher_AES256: u32 = 1;
pub const Spec_Agile_Cipher_CHACHA20: u32 = 2;
pub const Spec_Cipher_Expansion_Hacl_CHACHA20: u32 = 0;
pub const Spec_Cipher_Expansion_Vale_AES128: u32 = 1;
pub const Spec_Cipher_Expansion_Vale_AES256: u32 = 2;
pub const Spec_Agile_AEAD_AES128_GCM: u32 = 0;
pub const Spec_Agile_AEAD_AES256_GCM: u32 = 1;
pub const Spec_Agile_AEAD_CHACHA20_POLY1305: u32 = 2;
pub const Spec_Agile_AEAD_AES128_CCM: u32 = 3;
pub const Spec_Agile_AEAD_AES256_CCM: u32 = 4;
pub const Spec_Agile_AEAD_AES128_CCM8: u32 = 5;
pub const Spec_Agile_AEAD_AES256_CCM8: u32 = 6;
pub const Spec_Frodo_Params_SHAKE128: u32 = 0;
pub const Spec_Frodo_Params_AES128: u32 = 1;
pub const EverCrypt_Hash_MD5_s: u32 = 0;
pub const EverCrypt_Hash_SHA1_s: u32 = 1;
pub const EverCrypt_Hash_SHA2_224_s: u32 = 2;
pub const EverCrypt_Hash_SHA2_256_s: u32 = 3;
pub const EverCrypt_Hash_SHA2_384_s: u32 = 4;
pub const EverCrypt_Hash_SHA2_512_s: u32 = 5;
pub const EverCrypt_Hash_Blake2S_s: u32 = 6;
pub const EverCrypt_Hash_Blake2B_s: u32 = 7;
pub const EverCrypt_Error_Success: u32 = 0;
pub const EverCrypt_Error_UnsupportedAlgorithm: u32 = 1;
pub const EverCrypt_Error_InvalidKey: u32 = 2;
pub const EverCrypt_Error_AuthenticationFailure: u32 = 3;
pub const EverCrypt_Error_InvalidIVLength: u32 = 4;
pub const EverCrypt_Error_DecodeError: u32 = 5;
pub const EverCrypt_DRBG_SHA1_s: u32 = 0;
pub const EverCrypt_DRBG_SHA2_256_s: u32 = 1;
pub const EverCrypt_DRBG_SHA2_384_s: u32 = 2;
pub const EverCrypt_DRBG_SHA2_512_s: u32 = 3;
pub type C_String_t = *const ::std::os::raw::c_char;
pub type FStar_UInt128_uint128 = u128;
extern "C" {
pub static Hacl_Impl_Blake2_Constants_sigmaTable: [u32; 160usize];
}
extern "C" {
pub static Hacl_Impl_Blake2_Constants_ivTable_S: [u32; 8usize];
}
extern "C" {
pub static Hacl_Impl_Blake2_Constants_ivTable_B: [u64; 8usize];
}
pub type Hacl_Impl_Blake2_Core_m_spec = u8;
extern "C" {
pub fn Hacl_Blake2b_32_blake2b_init(hash: *mut u64, kk: u32, nn: u32);
}
extern "C" {
pub fn Hacl_Blake2b_32_blake2b_update_key(wv: *mut u64, hash: *mut u64, kk: u32, k: *mut u8, ll: u32);
}
extern "C" {
pub fn Hacl_Blake2b_32_blake2b_finish(nn: u32, output: *mut u8, hash: *mut u64);
}
extern "C" {
pub fn Hacl_Blake2b_32_blake2b(nn: u32, output: *mut u8, ll: u32, d: *mut u8, kk: u32, k: *mut u8);
}
extern "C" {
pub fn Hacl_Blake2s_32_blake2s_init(hash: *mut u32, kk: u32, nn: u32);
}
extern "C" {
pub fn Hacl_Blake2s_32_blake2s_update_key(wv: *mut u32, hash: *mut u32, kk: u32, k: *mut u8, ll: u32);
}
extern "C" {
pub fn Hacl_Blake2s_32_blake2s_update_multi(
len: u32,
wv: *mut u32,
hash: *mut u32,
prev: u64,
blocks: *mut u8,
nb: u32,
);
}
extern "C" {
pub fn Hacl_Blake2s_32_blake2s_update_last(len: u32, wv: *mut u32, hash: *mut u32, prev: u64, rem: u32, d: *mut u8);
}
extern "C" {
pub fn Hacl_Blake2s_32_blake2s_finish(nn: u32, output: *mut u8, hash: *mut u32);
}
extern "C" {
pub fn Hacl_Blake2s_32_blake2s(nn: u32, output: *mut u8, ll: u32, d: *mut u8, kk: u32, k: *mut u8);
}
pub type Spec_Blake2_alg = u8;
pub type Spec_Hash_Definitions_hash_alg = u8;
pub type Spec_FFDHE_ffdhe_alg = u8;
pub type Spec_Agile_Cipher_cipher_alg = u8;
pub type Spec_Cipher_Expansion_impl = u8;
pub type Spec_Agile_AEAD_alg = u8;
pub type Spec_Frodo_Params_frodo_gen_a = u8;
extern "C" {
pub static Hacl_Impl_SHA3_keccak_rotc: [u32; 24usize];
}
extern "C" {
pub static Hacl_Impl_SHA3_keccak_piln: [u32; 24usize];
}
extern "C" {
pub static Hacl_Impl_SHA3_keccak_rndc: [u64; 24usize];
}
extern "C" {
pub fn Hacl_Impl_SHA3_rotl(a: u64, b: u32) -> u64;
}
extern "C" {
pub fn Hacl_Impl_SHA3_state_permute(s: *mut u64);
}
extern "C" {
pub fn Hacl_Impl_SHA3_loadState(rateInBytes: u32, input: *mut u8, s: *mut u64);
}
extern "C" {
pub fn Hacl_Impl_SHA3_storeState(rateInBytes: u32, s: *mut u64, res: *mut u8);
}
extern "C" {
pub fn Hacl_Impl_SHA3_absorb(s: *mut u64, rateInBytes: u32, inputByteLen: u32, input: *mut u8, delimitedSuffix: u8);
}
extern "C" {
pub fn Hacl_Impl_SHA3_squeeze(s: *mut u64, rateInBytes: u32, outputByteLen: u32, output: *mut u8);
}
extern "C" {
pub fn Hacl_Impl_SHA3_keccak(
rate: u32,
capacity: u32,
inputByteLen: u32,
input: *mut u8,
delimitedSuffix: u8,
outputByteLen: u32,
output: *mut u8,
);
}
extern "C" {
pub fn Hacl_SHA3_shake128_hacl(inputByteLen: u32, input: *mut u8, outputByteLen: u32, output: *mut u8);
}
extern "C" {
pub fn Hacl_SHA3_shake256_hacl(inputByteLen: u32, input: *mut u8, outputByteLen: u32, output: *mut u8);
}
extern "C" {
pub fn Hacl_SHA3_sha3_224(inputByteLen: u32, input: *mut u8, output: *mut u8);
}
extern "C" {
pub fn Hacl_SHA3_sha3_256(inputByteLen: u32, input: *mut u8, output: *mut u8);
}
extern "C" {
pub fn Hacl_SHA3_sha3_384(inputByteLen: u32, input: *mut u8, output: *mut u8);
}
extern "C" {
pub fn Hacl_SHA3_sha3_512(inputByteLen: u32, input: *mut u8, output: *mut u8);
}
extern "C" {
pub static Hacl_Impl_Frodo_Params_cdf_table640: [u16; 13usize];
}
extern "C" {
pub static Hacl_Impl_Frodo_Params_cdf_table976: [u16; 11usize];
}
extern "C" {
pub static Hacl_Impl_Frodo_Params_cdf_table1344: [u16; 7usize];
}
extern "C" {
pub static mut Hacl_Poly1305_32_blocklen: u32;
}
pub type Hacl_Poly1305_32_poly1305_ctx = *mut u64;
extern "C" {
pub fn Hacl_Poly1305_32_poly1305_init(ctx: *mut u64, key: *mut u8);
}
extern "C" {
pub fn Hacl_Poly1305_32_poly1305_update1(ctx: *mut u64, text: *mut u8);
}
extern "C" {
pub fn Hacl_Poly1305_32_poly1305_update(ctx: *mut u64, len: u32, text: *mut u8);
}
extern "C" {
pub fn Hacl_Poly1305_32_poly1305_finish(tag: *mut u8, key: *mut u8, ctx: *mut u64);
}
extern "C" {
pub fn Hacl_Poly1305_32_poly1305_mac(tag: *mut u8, len: u32, text: *mut u8, key: *mut u8);
}
extern "C" {
pub fn Hacl_Chacha20_chacha20_encrypt(len: u32, out: *mut u8, text: *mut u8, key: *mut u8, n: *mut u8, ctr: u32);
}
extern "C" {
pub fn Hacl_Chacha20_chacha20_decrypt(len: u32, out: *mut u8, cipher: *mut u8, key: *mut u8, n: *mut u8, ctr: u32);
}
extern "C" {
pub fn Hacl_Chacha20Poly1305_32_aead_encrypt(
k: *mut u8,
n: *mut u8,
aadlen: u32,
aad: *mut u8,
mlen: u32,
m: *mut u8,
cipher: *mut u8,
mac: *mut u8,
);
}
extern "C" {
pub fn Hacl_Chacha20Poly1305_32_aead_decrypt(
k: *mut u8,
n: *mut u8,
aadlen: u32,
aad: *mut u8,
mlen: u32,
m: *mut u8,
cipher: *mut u8,
mac: *mut u8,
) -> u32;
}
extern "C" {
pub static mut Hacl_Poly1305_256_blocklen: u32;
}
pub type Hacl_Poly1305_256_poly1305_ctx = *mut *mut ::std::os::raw::c_void;
extern "C" {
pub fn Hacl_Poly1305_256_poly1305_init(ctx: *mut *mut ::std::os::raw::c_void, key: *mut u8);
}
extern "C" {
pub fn Hacl_Poly1305_256_poly1305_update1(ctx: *mut *mut ::std::os::raw::c_void, text: *mut u8);
}
extern "C" {
pub fn Hacl_Poly1305_256_poly1305_update(ctx: *mut *mut ::std::os::raw::c_void, len: u32, text: *mut u8);
}
extern "C" {
pub fn Hacl_Poly1305_256_poly1305_finish(tag: *mut u8, key: *mut u8, ctx: *mut *mut ::std::os::raw::c_void);
}
extern "C" {
pub fn Hacl_Poly1305_256_poly1305_mac(tag: *mut u8, len: u32, text: *mut u8, key: *mut u8);
}
extern "C" {
pub fn Hacl_Chacha20_Vec256_chacha20_encrypt_256(
len: u32,
out: *mut u8,
text: *mut u8,
key: *mut u8,
n: *mut u8,
ctr: u32,
);
}
extern "C" {
pub fn Hacl_Chacha20_Vec256_chacha20_decrypt_256(
len: u32,
out: *mut u8,
cipher: *mut u8,
key: *mut u8,
n: *mut u8,
ctr: u32,
);
}
extern "C" {
pub fn Hacl_Chacha20Poly1305_256_aead_encrypt(
k: *mut u8,
n: *mut u8,
aadlen: u32,
aad: *mut u8,
mlen: u32,
m: *mut u8,
cipher: *mut u8,
mac: *mut u8,
);
}
extern "C" {
pub fn Hacl_Chacha20Poly1305_256_aead_decrypt(
k: *mut u8,
n: *mut u8,
aadlen: u32,
aad: *mut u8,
mlen: u32,
m: *mut u8,
cipher: *mut u8,
mac: *mut u8,
) -> u32;
}
extern "C" {
pub static mut Hacl_Poly1305_128_blocklen: u32;
}
pub type Hacl_Poly1305_128_poly1305_ctx = *mut *mut ::std::os::raw::c_void;
extern "C" {
pub fn Hacl_Poly1305_128_poly1305_init(ctx: *mut *mut ::std::os::raw::c_void, key: *mut u8);
}
extern "C" {
pub fn Hacl_Poly1305_128_poly1305_update1(ctx: *mut *mut ::std::os::raw::c_void, text: *mut u8);
}
extern "C" {
pub fn Hacl_Poly1305_128_poly1305_update(ctx: *mut *mut ::std::os::raw::c_void, len: u32, text: *mut u8);
}
extern "C" {
pub fn Hacl_Poly1305_128_poly1305_finish(tag: *mut u8, key: *mut u8, ctx: *mut *mut ::std::os::raw::c_void);
}
extern "C" {
pub fn Hacl_Poly1305_128_poly1305_mac(tag: *mut u8, len: u32, text: *mut u8, key: *mut u8);
}
extern "C" {
pub fn Hacl_Chacha20_Vec128_chacha20_encrypt_128(
len: u32,
out: *mut u8,
text: *mut u8,
key: *mut u8,
n: *mut u8,
ctr: u32,
);
}
extern "C" {
pub fn Hacl_Chacha20_Vec128_chacha20_decrypt_128(
len: u32,
out: *mut u8,
cipher: *mut u8,
key: *mut u8,
n: *mut u8,
ctr: u32,
);
}
extern "C" {
pub fn Hacl_Chacha20Poly1305_128_aead_encrypt(
k: *mut u8,
n: *mut u8,
aadlen: u32,
aad: *mut u8,
mlen: u32,
m: *mut u8,
cipher: *mut u8,
mac: *mut u8,
);
}
extern "C" {
pub fn Hacl_Chacha20Poly1305_128_aead_decrypt(
k: *mut u8,
n: *mut u8,
aadlen: u32,
aad: *mut u8,
mlen: u32,
m: *mut u8,
cipher: *mut u8,
mac: *mut u8,
) -> u32;
}
extern "C" {
pub fn EverCrypt_AutoConfig2_has_shaext() -> bool;
}
extern "C" {
pub fn EverCrypt_AutoConfig2_has_aesni() -> bool;
}
extern "C" {
pub fn EverCrypt_AutoConfig2_has_pclmulqdq() -> bool;
}
extern "C" {
pub fn EverCrypt_AutoConfig2_has_avx2() -> bool;
}
extern "C" {
pub fn EverCrypt_AutoConfig2_has_avx() -> bool;
}
extern "C" {
pub fn EverCrypt_AutoConfig2_has_bmi2() -> bool;
}
extern "C" {
pub fn EverCrypt_AutoConfig2_has_adx() -> bool;
}
extern "C" {
pub fn EverCrypt_AutoConfig2_has_sse() -> bool;
}
extern "C" {
pub fn EverCrypt_AutoConfig2_has_movbe() -> bool;
}
extern "C" {
pub fn EverCrypt_AutoConfig2_has_rdrand() -> bool;
}
extern "C" {
pub fn EverCrypt_AutoConfig2_has_avx512() -> bool;
}
extern "C" {
pub fn EverCrypt_AutoConfig2_wants_vale() -> bool;
}
extern "C" {
pub fn EverCrypt_AutoConfig2_wants_hacl() -> bool;
}
extern "C" {
pub fn EverCrypt_AutoConfig2_wants_openssl() -> bool;
}
extern "C" {
pub fn EverCrypt_AutoConfig2_wants_bcrypt() -> bool;
}
extern "C" {
pub fn EverCrypt_AutoConfig2_recall();
}
extern "C" {
pub fn EverCrypt_AutoConfig2_init();
}
pub type EverCrypt_AutoConfig2_disabler = ::std::option::Option<unsafe extern "C" fn()>;
extern "C" {
pub fn EverCrypt_AutoConfig2_disable_avx2();
}
extern "C" {
pub fn EverCrypt_AutoConfig2_disable_avx();
}
extern "C" {
pub fn EverCrypt_AutoConfig2_disable_bmi2();
}
extern "C" {
pub fn EverCrypt_AutoConfig2_disable_adx();
}
extern "C" {
pub fn EverCrypt_AutoConfig2_disable_shaext();
}
extern "C" {
pub fn EverCrypt_AutoConfig2_disable_aesni();
}
extern "C" {
pub fn EverCrypt_AutoConfig2_disable_pclmulqdq();
}
extern "C" {
pub fn EverCrypt_AutoConfig2_disable_sse();
}
extern "C" {
pub fn EverCrypt_AutoConfig2_disable_movbe();
}
extern "C" {
pub fn EverCrypt_AutoConfig2_disable_rdrand();
}
extern "C" {
pub fn EverCrypt_AutoConfig2_disable_avx512();
}
extern "C" {
pub fn EverCrypt_AutoConfig2_disable_vale();
}
extern "C" {
pub fn EverCrypt_AutoConfig2_disable_hacl();
}
extern "C" {
pub fn EverCrypt_AutoConfig2_disable_openssl();
}
extern "C" {
pub fn EverCrypt_AutoConfig2_disable_bcrypt();
}
extern "C" {
pub fn EverCrypt_AutoConfig2_has_vec128() -> bool;
}
extern "C" {
pub fn EverCrypt_AutoConfig2_has_vec256() -> bool;
}
extern "C" {
pub fn EverCrypt_Chacha20Poly1305_aead_encrypt(
k: *mut u8,
n: *mut u8,
aadlen: u32,
aad: *mut u8,
mlen: u32,
m: *mut u8,
cipher: *mut u8,
tag: *mut u8,
);
}
extern "C" {
pub fn EverCrypt_Chacha20Poly1305_aead_decrypt(
k: *mut u8,
n: *mut u8,
aadlen: u32,
aad: *mut u8,
mlen: u32,
m: *mut u8,
cipher: *mut u8,
tag: *mut u8,
) -> u32;
}
extern "C" {
pub static Hacl_Impl_SHA2_Generic_h224: [u32; 8usize];
}
extern "C" {
pub static Hacl_Impl_SHA2_Generic_h256: [u32; 8usize];
}
extern "C" {
pub static Hacl_Impl_SHA2_Generic_h384: [u64; 8usize];
}
extern "C" {
pub static Hacl_Impl_SHA2_Generic_h512: [u64; 8usize];
}
extern "C" {
pub static Hacl_Impl_SHA2_Generic_k224_256: [u32; 64usize];
}
extern "C" {
pub static Hacl_Impl_SHA2_Generic_k384_512: [u64; 80usize];
}
extern "C" {
pub fn Hacl_SHA2_Vec128_sha224_4(
dst0: *mut u8,
dst1: *mut u8,
dst2: *mut u8,
dst3: *mut u8,
input_len: u32,
input0: *mut u8,
input1: *mut u8,
input2: *mut u8,
input3: *mut u8,
);
}
extern "C" {
pub fn Hacl_SHA2_Vec128_sha256_4(
dst0: *mut u8,
dst1: *mut u8,
dst2: *mut u8,
dst3: *mut u8,
input_len: u32,
input0: *mut u8,
input1: *mut u8,
input2: *mut u8,
input3: *mut u8,
);
}
extern "C" {
pub fn Hacl_Curve25519_51_scalarmult(out: *mut u8, priv_: *mut u8, pub_: *mut u8);
}
extern "C" {
pub fn Hacl_Curve25519_51_secret_to_public(pub_: *mut u8, priv_: *mut u8);
}
extern "C" {
pub fn Hacl_Curve25519_51_ecdh(out: *mut u8, priv_: *mut u8, pub_: *mut u8) -> bool;
}
extern "C" {
pub fn Hacl_Hash_SHA2_update_multi_224(s: *mut u32, blocks: *mut u8, n_blocks: u32);
}
extern "C" {
pub fn Hacl_Hash_SHA2_update_multi_256(s: *mut u32, blocks: *mut u8, n_blocks: u32);
}
extern "C" {
pub fn Hacl_Hash_SHA2_update_multi_384(s: *mut u64, blocks: *mut u8, n_blocks: u32);
}
extern "C" {
pub fn Hacl_Hash_SHA2_update_multi_512(s: *mut u64, blocks: *mut u8, n_blocks: u32);
}
extern "C" {
pub fn Hacl_Hash_SHA2_update_last_224(s: *mut u32, prev_len: u64, input: *mut u8, input_len: u32);
}
extern "C" {
pub fn Hacl_Hash_SHA2_update_last_256(s: *mut u32, prev_len: u64, input: *mut u8, input_len: u32);
}
extern "C" {
pub fn Hacl_Hash_SHA2_hash_224(input: *mut u8, input_len: u32, dst: *mut u8);
}
extern "C" {
pub fn Hacl_Hash_SHA2_hash_256(input: *mut u8, input_len: u32, dst: *mut u8);
}
extern "C" {
pub fn Hacl_Hash_SHA2_hash_384(input: *mut u8, input_len: u32, dst: *mut u8);
}
extern "C" {
pub fn Hacl_Hash_SHA2_hash_512(input: *mut u8, input_len: u32, dst: *mut u8);
}
extern "C" {
pub fn Hacl_Hash_SHA1_legacy_update_multi(s: *mut u32, blocks: *mut u8, n_blocks: u32);
}
extern "C" {
pub fn Hacl_Hash_SHA1_legacy_update_last(s: *mut u32, prev_len: u64, input: *mut u8, input_len: u32);
}
extern "C" {
pub fn Hacl_Hash_SHA1_legacy_hash(input: *mut u8, input_len: u32, dst: *mut u8);
}
extern "C" {
pub fn Hacl_HMAC_legacy_compute_sha1(dst: *mut u8, key: *mut u8, key_len: u32, data: *mut u8, data_len: u32);
}
extern "C" {
pub fn Hacl_HMAC_compute_sha2_256(dst: *mut u8, key: *mut u8, key_len: u32, data: *mut u8, data_len: u32);
}
extern "C" {
pub fn Hacl_HMAC_compute_sha2_384(dst: *mut u8, key: *mut u8, key_len: u32, data: *mut u8, data_len: u32);
}
extern "C" {
pub fn Hacl_HMAC_compute_sha2_512(dst: *mut u8, key: *mut u8, key_len: u32, data: *mut u8, data_len: u32);
}
extern "C" {
pub fn Hacl_HMAC_compute_blake2s_32(dst: *mut u8, key: *mut u8, key_len: u32, data: *mut u8, data_len: u32);
}
extern "C" {
pub fn Hacl_HMAC_compute_blake2b_32(dst: *mut u8, key: *mut u8, key_len: u32, data: *mut u8, data_len: u32);
}
extern "C" {
pub fn Hacl_HKDF_expand_sha2_256(okm: *mut u8, prk: *mut u8, prklen: u32, info: *mut u8, infolen: u32, len: u32);
}
extern "C" {
pub fn Hacl_HKDF_extract_sha2_256(prk: *mut u8, salt: *mut u8, saltlen: u32, ikm: *mut u8, ikmlen: u32);
}
extern "C" {
pub fn Hacl_HKDF_expand_sha2_512(okm: *mut u8, prk: *mut u8, prklen: u32, info: *mut u8, infolen: u32, len: u32);
}
extern "C" {
pub fn Hacl_HKDF_extract_sha2_512(prk: *mut u8, salt: *mut u8, saltlen: u32, ikm: *mut u8, ikmlen: u32);
}
extern "C" {
pub fn Hacl_HKDF_expand_blake2s_32(okm: *mut u8, prk: *mut u8, prklen: u32, info: *mut u8, infolen: u32, len: u32);
}
extern "C" {
pub fn Hacl_HKDF_extract_blake2s_32(prk: *mut u8, salt: *mut u8, saltlen: u32, ikm: *mut u8, ikmlen: u32);
}
extern "C" {
pub fn Hacl_HKDF_expand_blake2b_32(okm: *mut u8, prk: *mut u8, prklen: u32, info: *mut u8, infolen: u32, len: u32);
}
extern "C" {
pub fn Hacl_HKDF_extract_blake2b_32(prk: *mut u8, salt: *mut u8, saltlen: u32, ikm: *mut u8, ikmlen: u32);
}
extern "C" {
pub fn Hacl_Curve25519_64_scalarmult(out: *mut u8, priv_: *mut u8, pub_: *mut u8);
}
extern "C" {
pub fn Hacl_Curve25519_64_secret_to_public(pub_: *mut u8, priv_: *mut u8);
}
extern "C" {
pub fn Hacl_Curve25519_64_ecdh(out: *mut u8, priv_: *mut u8, pub_: *mut u8) -> bool;
}
extern "C" {
pub fn Hacl_HPKE_Curve64_CP128_SHA512_setupBaseI(
o_pkE: *mut u8,
o_k: *mut u8,
o_n: *mut u8,
skE: *mut u8,
pkR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve64_CP128_SHA512_setupBaseR(
o_key_aead: *mut u8,
o_nonce_aead: *mut u8,
pkE: *mut u8,
skR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve64_CP128_SHA512_sealBase(
skE: *mut u8,
pkR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve64_CP128_SHA512_openBase(
pkE: *mut u8,
skR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_Bignum256_add(a: *mut u64, b: *mut u64, res: *mut u64) -> u64;
}
extern "C" {
pub fn Hacl_Bignum256_sub(a: *mut u64, b: *mut u64, res: *mut u64) -> u64;
}
extern "C" {
pub fn Hacl_Bignum256_add_mod(n: *mut u64, a: *mut u64, b: *mut u64, res: *mut u64);
}
extern "C" {
pub fn Hacl_Bignum256_sub_mod(n: *mut u64, a: *mut u64, b: *mut u64, res: *mut u64);
}
extern "C" {
pub fn Hacl_Bignum256_mul(a: *mut u64, b: *mut u64, res: *mut u64);
}
extern "C" {
pub fn Hacl_Bignum256_sqr(a: *mut u64, res: *mut u64);
}
extern "C" {
pub fn Hacl_Bignum256_mod(n: *mut u64, a: *mut u64, res: *mut u64) -> bool;
}
extern "C" {
pub fn Hacl_Bignum256_mod_exp_vartime(n: *mut u64, a: *mut u64, bBits: u32, b: *mut u64, res: *mut u64) -> bool;
}
extern "C" {
pub fn Hacl_Bignum256_mod_exp_consttime(n: *mut u64, a: *mut u64, bBits: u32, b: *mut u64, res: *mut u64) -> bool;
}
extern "C" {
pub fn Hacl_Bignum256_mod_inv_prime_vartime(n: *mut u64, a: *mut u64, res: *mut u64) -> bool;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s {
pub len: u32,
pub n: *mut u64,
pub mu: u64,
pub r2: *mut u64,
}
pub type Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64 = Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64_s;
extern "C" {
pub fn Hacl_Bignum256_mont_ctx_init(n: *mut u64) -> *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64;
}
extern "C" {
pub fn Hacl_Bignum256_mont_ctx_free(k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64);
}
extern "C" {
pub fn Hacl_Bignum256_mod_precomp(k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64, a: *mut u64, res: *mut u64);
}
extern "C" {
pub fn Hacl_Bignum256_mod_exp_vartime_precomp(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64,
a: *mut u64,
bBits: u32,
b: *mut u64,
res: *mut u64,
);
}
extern "C" {
pub fn Hacl_Bignum256_mod_exp_consttime_precomp(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64,
a: *mut u64,
bBits: u32,
b: *mut u64,
res: *mut u64,
);
}
extern "C" {
pub fn Hacl_Bignum256_mod_inv_prime_vartime_precomp(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64,
a: *mut u64,
res: *mut u64,
);
}
extern "C" {
pub fn Hacl_Bignum256_new_bn_from_bytes_be(len: u32, b: *mut u8) -> *mut u64;
}
extern "C" {
pub fn Hacl_Bignum256_new_bn_from_bytes_le(len: u32, b: *mut u8) -> *mut u64;
}
extern "C" {
pub fn Hacl_Bignum256_bn_to_bytes_be(b: *mut u64, res: *mut u8);
}
extern "C" {
pub fn Hacl_Bignum256_bn_to_bytes_le(b: *mut u64, res: *mut u8);
}
extern "C" {
pub fn Hacl_Bignum256_lt_mask(a: *mut u64, b: *mut u64) -> u64;
}
extern "C" {
pub fn Hacl_Bignum256_eq_mask(a: *mut u64, b: *mut u64) -> u64;
}
extern "C" {
pub fn Hacl_HMAC_Blake2b_256_compute_blake2b_256(
dst: *mut u8,
key: *mut u8,
key_len: u32,
data: *mut u8,
data_len: u32,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32_s {
pub len: u32,
pub n: *mut u32,
pub mu: u32,
pub r2: *mut u32,
}
pub type Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32 = Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32_s;
pub type Hacl_GenericField32_pbn_mont_ctx_u32 = *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32;
extern "C" {
#[doc = "A verified field arithmetic library."]
#[doc = ""]
#[doc = "This is a 32-bit optimized version, where bignums are represented as an array"]
#[doc = "of `len` unsigned 32-bit integers, i.e. uint32_t[len]."]
#[doc = ""]
#[doc = "All the arithmetic operations are performed in the Montgomery domain."]
#[doc = ""]
#[doc = "All the functions below preserve the following invariant for a bignum `aM` in"]
#[doc = "Montgomery form."]
#[doc = "• aM < n"]
pub fn Hacl_GenericField32_field_modulus_check(len: u32, n: *mut u32) -> bool;
}
extern "C" {
pub fn Hacl_GenericField32_field_init(len: u32, n: *mut u32) -> *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32;
}
extern "C" {
pub fn Hacl_GenericField32_field_free(k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32);
}
extern "C" {
pub fn Hacl_GenericField32_field_get_len(k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32) -> u32;
}
extern "C" {
pub fn Hacl_GenericField32_to_field(k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32, a: *mut u32, aM: *mut u32);
}
extern "C" {
pub fn Hacl_GenericField32_from_field(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32,
aM: *mut u32,
a: *mut u32,
);
}
extern "C" {
pub fn Hacl_GenericField32_add(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32,
aM: *mut u32,
bM: *mut u32,
cM: *mut u32,
);
}
extern "C" {
pub fn Hacl_GenericField32_sub(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32,
aM: *mut u32,
bM: *mut u32,
cM: *mut u32,
);
}
extern "C" {
pub fn Hacl_GenericField32_mul(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32,
aM: *mut u32,
bM: *mut u32,
cM: *mut u32,
);
}
extern "C" {
pub fn Hacl_GenericField32_sqr(k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32, aM: *mut u32, cM: *mut u32);
}
extern "C" {
pub fn Hacl_GenericField32_one(k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32, oneM: *mut u32);
}
extern "C" {
pub fn Hacl_GenericField32_exp_consttime(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32,
aM: *mut u32,
bBits: u32,
b: *mut u32,
resM: *mut u32,
);
}
extern "C" {
pub fn Hacl_GenericField32_exp_vartime(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32,
aM: *mut u32,
bBits: u32,
b: *mut u32,
resM: *mut u32,
);
}
extern "C" {
pub fn Hacl_GenericField32_inverse(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32,
aM: *mut u32,
aInvM: *mut u32,
);
}
extern "C" {
pub fn Hacl_Bignum4096_32_add(a: *mut u32, b: *mut u32, res: *mut u32) -> u32;
}
extern "C" {
pub fn Hacl_Bignum4096_32_sub(a: *mut u32, b: *mut u32, res: *mut u32) -> u32;
}
extern "C" {
pub fn Hacl_Bignum4096_32_add_mod(n: *mut u32, a: *mut u32, b: *mut u32, res: *mut u32);
}
extern "C" {
pub fn Hacl_Bignum4096_32_sub_mod(n: *mut u32, a: *mut u32, b: *mut u32, res: *mut u32);
}
extern "C" {
pub fn Hacl_Bignum4096_32_mul(a: *mut u32, b: *mut u32, res: *mut u32);
}
extern "C" {
pub fn Hacl_Bignum4096_32_sqr(a: *mut u32, res: *mut u32);
}
extern "C" {
pub fn Hacl_Bignum4096_32_mod(n: *mut u32, a: *mut u32, res: *mut u32) -> bool;
}
extern "C" {
pub fn Hacl_Bignum4096_32_mod_exp_vartime(n: *mut u32, a: *mut u32, bBits: u32, b: *mut u32, res: *mut u32)
-> bool;
}
extern "C" {
pub fn Hacl_Bignum4096_32_mod_exp_consttime(
n: *mut u32,
a: *mut u32,
bBits: u32,
b: *mut u32,
res: *mut u32,
) -> bool;
}
extern "C" {
pub fn Hacl_Bignum4096_32_mod_inv_prime_vartime(n: *mut u32, a: *mut u32, res: *mut u32) -> bool;
}
extern "C" {
pub fn Hacl_Bignum4096_32_mont_ctx_init(n: *mut u32) -> *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32;
}
extern "C" {
pub fn Hacl_Bignum4096_32_mont_ctx_free(k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32);
}
extern "C" {
pub fn Hacl_Bignum4096_32_mod_precomp(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32,
a: *mut u32,
res: *mut u32,
);
}
extern "C" {
pub fn Hacl_Bignum4096_32_mod_exp_vartime_precomp(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32,
a: *mut u32,
bBits: u32,
b: *mut u32,
res: *mut u32,
);
}
extern "C" {
pub fn Hacl_Bignum4096_32_mod_exp_consttime_precomp(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32,
a: *mut u32,
bBits: u32,
b: *mut u32,
res: *mut u32,
);
}
extern "C" {
pub fn Hacl_Bignum4096_32_mod_inv_prime_vartime_precomp(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32,
a: *mut u32,
res: *mut u32,
);
}
extern "C" {
pub fn Hacl_Bignum4096_32_new_bn_from_bytes_be(len: u32, b: *mut u8) -> *mut u32;
}
extern "C" {
pub fn Hacl_Bignum4096_32_new_bn_from_bytes_le(len: u32, b: *mut u8) -> *mut u32;
}
extern "C" {
pub fn Hacl_Bignum4096_32_bn_to_bytes_be(b: *mut u32, res: *mut u8);
}
extern "C" {
pub fn Hacl_Bignum4096_32_bn_to_bytes_le(b: *mut u32, res: *mut u8);
}
extern "C" {
pub fn Hacl_Bignum4096_32_lt_mask(a: *mut u32, b: *mut u32) -> u32;
}
extern "C" {
pub fn Hacl_Bignum4096_32_eq_mask(a: *mut u32, b: *mut u32) -> u32;
}
extern "C" {
pub fn Hacl_Streaming_Blake2_blocks_state_len(a: Spec_Blake2_alg, m: Hacl_Impl_Blake2_Core_m_spec) -> u32;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Hacl_Streaming_Blake2_blake2s_32_block_state_s {
pub fst: *mut u32,
pub snd: *mut u32,
}
pub type Hacl_Streaming_Blake2_blake2s_32_block_state = Hacl_Streaming_Blake2_blake2s_32_block_state_s;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Hacl_Streaming_Blake2_blake2s_32_state_s {
pub block_state: Hacl_Streaming_Blake2_blake2s_32_block_state,
pub buf: *mut u8,
pub total_len: u64,
}
pub type Hacl_Streaming_Blake2_blake2s_32_state = Hacl_Streaming_Blake2_blake2s_32_state_s;
extern "C" {
pub fn Hacl_Streaming_Blake2_blake2s_32_no_key_create_in() -> *mut Hacl_Streaming_Blake2_blake2s_32_state;
}
extern "C" {
pub fn Hacl_Streaming_Blake2_blake2s_32_no_key_init(s1: *mut Hacl_Streaming_Blake2_blake2s_32_state);
}
extern "C" {
pub fn Hacl_Streaming_Blake2_blake2s_32_no_key_update(
p: *mut Hacl_Streaming_Blake2_blake2s_32_state,
data: *mut u8,
len: u32,
);
}
extern "C" {
pub fn Hacl_Streaming_Blake2_blake2s_32_no_key_finish(p: *mut Hacl_Streaming_Blake2_blake2s_32_state, dst: *mut u8);
}
extern "C" {
pub fn Hacl_Streaming_Blake2_blake2s_32_no_key_free(s1: *mut Hacl_Streaming_Blake2_blake2s_32_state);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Hacl_Streaming_Blake2_blake2b_32_block_state_s {
pub fst: *mut u64,
pub snd: *mut u64,
}
pub type Hacl_Streaming_Blake2_blake2b_32_block_state = Hacl_Streaming_Blake2_blake2b_32_block_state_s;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Hacl_Streaming_Blake2_blake2b_32_state_s {
pub block_state: Hacl_Streaming_Blake2_blake2b_32_block_state,
pub buf: *mut u8,
pub total_len: u64,
}
pub type Hacl_Streaming_Blake2_blake2b_32_state = Hacl_Streaming_Blake2_blake2b_32_state_s;
extern "C" {
pub fn Hacl_Streaming_Blake2_blake2b_32_no_key_create_in() -> *mut Hacl_Streaming_Blake2_blake2b_32_state;
}
extern "C" {
pub fn Hacl_Streaming_Blake2_blake2b_32_no_key_init(s1: *mut Hacl_Streaming_Blake2_blake2b_32_state);
}
extern "C" {
pub fn Hacl_Streaming_Blake2_blake2b_32_no_key_update(
p: *mut Hacl_Streaming_Blake2_blake2b_32_state,
data: *mut u8,
len: u32,
);
}
extern "C" {
pub fn Hacl_Streaming_Blake2_blake2b_32_no_key_finish(p: *mut Hacl_Streaming_Blake2_blake2b_32_state, dst: *mut u8);
}
extern "C" {
pub fn Hacl_Streaming_Blake2_blake2b_32_no_key_free(s1: *mut Hacl_Streaming_Blake2_blake2b_32_state);
}
extern "C" {
pub fn Hacl_Blake2s_128_blake2s_init(hash: *mut *mut ::std::os::raw::c_void, kk: u32, nn: u32);
}
extern "C" {
pub fn Hacl_Blake2s_128_blake2s_update_key(
wv: *mut *mut ::std::os::raw::c_void,
hash: *mut *mut ::std::os::raw::c_void,
kk: u32,
k: *mut u8,
ll: u32,
);
}
extern "C" {
pub fn Hacl_Blake2s_128_blake2s_update_multi(
len: u32,
wv: *mut *mut ::std::os::raw::c_void,
hash: *mut *mut ::std::os::raw::c_void,
prev: u64,
blocks: *mut u8,
nb: u32,
);
}
extern "C" {
pub fn Hacl_Blake2s_128_blake2s_update_last(
len: u32,
wv: *mut *mut ::std::os::raw::c_void,
hash: *mut *mut ::std::os::raw::c_void,
prev: u64,
rem: u32,
d: *mut u8,
);
}
extern "C" {
pub fn Hacl_Blake2s_128_blake2s_finish(nn: u32, output: *mut u8, hash: *mut *mut ::std::os::raw::c_void);
}
extern "C" {
pub fn Hacl_Blake2s_128_blake2s(nn: u32, output: *mut u8, ll: u32, d: *mut u8, kk: u32, k: *mut u8);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Hacl_Streaming_Blake2s_128_blake2s_128_block_state_s {
pub fst: *mut *mut ::std::os::raw::c_void,
pub snd: *mut *mut ::std::os::raw::c_void,
}
pub type Hacl_Streaming_Blake2s_128_blake2s_128_block_state = Hacl_Streaming_Blake2s_128_blake2s_128_block_state_s;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Hacl_Streaming_Blake2s_128_blake2s_128_state_s {
pub block_state: Hacl_Streaming_Blake2s_128_blake2s_128_block_state,
pub buf: *mut u8,
pub total_len: u64,
}
pub type Hacl_Streaming_Blake2s_128_blake2s_128_state = Hacl_Streaming_Blake2s_128_blake2s_128_state_s;
extern "C" {
pub fn Hacl_Streaming_Blake2s_128_blake2s_128_no_key_create_in() -> *mut Hacl_Streaming_Blake2s_128_blake2s_128_state;
}
extern "C" {
pub fn Hacl_Streaming_Blake2s_128_blake2s_128_no_key_init(s: *mut Hacl_Streaming_Blake2s_128_blake2s_128_state);
}
extern "C" {
pub fn Hacl_Streaming_Blake2s_128_blake2s_128_no_key_update(
p: *mut Hacl_Streaming_Blake2s_128_blake2s_128_state,
data: *mut u8,
len: u32,
);
}
extern "C" {
pub fn Hacl_Streaming_Blake2s_128_blake2s_128_no_key_finish(
p: *mut Hacl_Streaming_Blake2s_128_blake2s_128_state,
dst: *mut u8,
);
}
extern "C" {
pub fn Hacl_Streaming_Blake2s_128_blake2s_128_no_key_free(s: *mut Hacl_Streaming_Blake2s_128_blake2s_128_state);
}
extern "C" {
pub fn EverCrypt_Poly1305_poly1305(dst: *mut u8, src: *mut u8, len: u32, key: *mut u8);
}
extern "C" {
pub fn Hacl_Hash_MD5_legacy_update_multi(s: *mut u32, blocks: *mut u8, n_blocks: u32);
}
extern "C" {
pub fn Hacl_Hash_MD5_legacy_update_last(s: *mut u32, prev_len: u64, input: *mut u8, input_len: u32);
}
extern "C" {
pub fn Hacl_Hash_MD5_legacy_hash(input: *mut u8, input_len: u32, dst: *mut u8);
}
pub type EverCrypt_Hash_alg = Spec_Hash_Definitions_hash_alg;
extern "C" {
pub fn EverCrypt_Hash_string_of_alg(uu___: Spec_Hash_Definitions_hash_alg) -> C_String_t;
}
pub type EverCrypt_Hash_broken_alg = Spec_Hash_Definitions_hash_alg;
pub type EverCrypt_Hash_alg13 = Spec_Hash_Definitions_hash_alg;
pub type EverCrypt_Hash_e_alg = *mut ::std::os::raw::c_void;
pub type EverCrypt_Hash_state_s_tags = u8;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct EverCrypt_Hash_state_s_s {
pub tag: EverCrypt_Hash_state_s_tags,
pub val: EverCrypt_Hash_state_s_s__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union EverCrypt_Hash_state_s_s__bindgen_ty_1 {
pub case_MD5_s: *mut u32,
pub case_SHA1_s: *mut u32,
pub case_SHA2_224_s: *mut u32,
pub case_SHA2_256_s: *mut u32,
pub case_SHA2_384_s: *mut u64,
pub case_SHA2_512_s: *mut u64,
pub case_Blake2S_s: *mut u32,
pub case_Blake2B_s: *mut u64,
}
pub type EverCrypt_Hash_state_s = EverCrypt_Hash_state_s_s;
extern "C" {
pub fn EverCrypt_Hash_uu___is_MD5_s(
uu___: Spec_Hash_Definitions_hash_alg,
projectee: EverCrypt_Hash_state_s,
) -> bool;
}
extern "C" {
pub fn EverCrypt_Hash_uu___is_SHA1_s(
uu___: Spec_Hash_Definitions_hash_alg,
projectee: EverCrypt_Hash_state_s,
) -> bool;
}
extern "C" {
pub fn EverCrypt_Hash_uu___is_SHA2_224_s(
uu___: Spec_Hash_Definitions_hash_alg,
projectee: EverCrypt_Hash_state_s,
) -> bool;
}
extern "C" {
pub fn EverCrypt_Hash_uu___is_SHA2_256_s(
uu___: Spec_Hash_Definitions_hash_alg,
projectee: EverCrypt_Hash_state_s,
) -> bool;
}
extern "C" {
pub fn EverCrypt_Hash_uu___is_SHA2_384_s(
uu___: Spec_Hash_Definitions_hash_alg,
projectee: EverCrypt_Hash_state_s,
) -> bool;
}
extern "C" {
pub fn EverCrypt_Hash_uu___is_SHA2_512_s(
uu___: Spec_Hash_Definitions_hash_alg,
projectee: EverCrypt_Hash_state_s,
) -> bool;
}
extern "C" {
pub fn EverCrypt_Hash_uu___is_Blake2S_s(
uu___: Spec_Hash_Definitions_hash_alg,
projectee: EverCrypt_Hash_state_s,
) -> bool;
}
extern "C" {
pub fn EverCrypt_Hash_uu___is_Blake2B_s(
uu___: Spec_Hash_Definitions_hash_alg,
projectee: EverCrypt_Hash_state_s,
) -> bool;
}
extern "C" {
pub fn EverCrypt_Hash_alg_of_state(s: *mut EverCrypt_Hash_state_s) -> Spec_Hash_Definitions_hash_alg;
}
extern "C" {
pub fn EverCrypt_Hash_create_in(a: Spec_Hash_Definitions_hash_alg) -> *mut EverCrypt_Hash_state_s;
}
extern "C" {
pub fn EverCrypt_Hash_create(a: Spec_Hash_Definitions_hash_alg) -> *mut EverCrypt_Hash_state_s;
}
extern "C" {
pub fn EverCrypt_Hash_init(s: *mut EverCrypt_Hash_state_s);
}
extern "C" {
pub fn EverCrypt_Hash_update_multi_256(s: *mut u32, blocks: *mut u8, n: u32);
}
extern "C" {
pub fn EverCrypt_Hash_update2(s: *mut EverCrypt_Hash_state_s, prevlen: u64, block: *mut u8);
}
extern "C" {
pub fn EverCrypt_Hash_update(s: *mut EverCrypt_Hash_state_s, block: *mut u8);
}
extern "C" {
pub fn EverCrypt_Hash_update_multi2(s: *mut EverCrypt_Hash_state_s, prevlen: u64, blocks: *mut u8, len: u32);
}
extern "C" {
pub fn EverCrypt_Hash_update_multi(s: *mut EverCrypt_Hash_state_s, blocks: *mut u8, len: u32);
}
extern "C" {
pub fn EverCrypt_Hash_update_last_256(s: *mut u32, input: u64, input_len: *mut u8, input_len1: u32);
}
extern "C" {
pub fn EverCrypt_Hash_update_last2(s: *mut EverCrypt_Hash_state_s, prev_len: u64, last: *mut u8, last_len: u32);
}
extern "C" {
pub fn EverCrypt_Hash_update_last(s: *mut EverCrypt_Hash_state_s, last: *mut u8, total_len: u64);
}
extern "C" {
pub fn EverCrypt_Hash_finish(s: *mut EverCrypt_Hash_state_s, dst: *mut u8);
}
extern "C" {
pub fn EverCrypt_Hash_free(s: *mut EverCrypt_Hash_state_s);
}
extern "C" {
pub fn EverCrypt_Hash_copy(s_src: *mut EverCrypt_Hash_state_s, s_dst: *mut EverCrypt_Hash_state_s);
}
extern "C" {
pub fn EverCrypt_Hash_hash_256(input: *mut u8, input_len: u32, dst: *mut u8);
}
extern "C" {
pub fn EverCrypt_Hash_hash_224(input: *mut u8, input_len: u32, dst: *mut u8);
}
extern "C" {
pub fn EverCrypt_Hash_hash(a: Spec_Hash_Definitions_hash_alg, dst: *mut u8, input: *mut u8, len: u32);
}
extern "C" {
pub fn EverCrypt_Hash_Incremental_hash_len(a: Spec_Hash_Definitions_hash_alg) -> u32;
}
extern "C" {
pub fn EverCrypt_Hash_Incremental_block_len(a: Spec_Hash_Definitions_hash_alg) -> u32;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Hacl_Streaming_Functor_state_s___EverCrypt_Hash_state_s_____s {
pub block_state: *mut EverCrypt_Hash_state_s,
pub buf: *mut u8,
pub total_len: u64,
}
pub type Hacl_Streaming_Functor_state_s___EverCrypt_Hash_state_s____ =
Hacl_Streaming_Functor_state_s___EverCrypt_Hash_state_s_____s;
extern "C" {
pub fn EverCrypt_Hash_Incremental_create_in(
a: Spec_Hash_Definitions_hash_alg,
) -> *mut Hacl_Streaming_Functor_state_s___EverCrypt_Hash_state_s____;
}
extern "C" {
pub fn EverCrypt_Hash_Incremental_init(s: *mut Hacl_Streaming_Functor_state_s___EverCrypt_Hash_state_s____);
}
extern "C" {
pub fn EverCrypt_Hash_Incremental_update(
p: *mut Hacl_Streaming_Functor_state_s___EverCrypt_Hash_state_s____,
data: *mut u8,
len: u32,
);
}
extern "C" {
pub fn EverCrypt_Hash_Incremental_finish_md5(
p: *mut Hacl_Streaming_Functor_state_s___EverCrypt_Hash_state_s____,
dst: *mut u8,
);
}
extern "C" {
pub fn EverCrypt_Hash_Incremental_finish_sha1(
p: *mut Hacl_Streaming_Functor_state_s___EverCrypt_Hash_state_s____,
dst: *mut u8,
);
}
extern "C" {
pub fn EverCrypt_Hash_Incremental_finish_sha224(
p: *mut Hacl_Streaming_Functor_state_s___EverCrypt_Hash_state_s____,
dst: *mut u8,
);
}
extern "C" {
pub fn EverCrypt_Hash_Incremental_finish_sha256(
p: *mut Hacl_Streaming_Functor_state_s___EverCrypt_Hash_state_s____,
dst: *mut u8,
);
}
extern "C" {
pub fn EverCrypt_Hash_Incremental_finish_sha384(
p: *mut Hacl_Streaming_Functor_state_s___EverCrypt_Hash_state_s____,
dst: *mut u8,
);
}
extern "C" {
pub fn EverCrypt_Hash_Incremental_finish_sha512(
p: *mut Hacl_Streaming_Functor_state_s___EverCrypt_Hash_state_s____,
dst: *mut u8,
);
}
extern "C" {
pub fn EverCrypt_Hash_Incremental_finish_blake2s(
p: *mut Hacl_Streaming_Functor_state_s___EverCrypt_Hash_state_s____,
dst: *mut u8,
);
}
extern "C" {
pub fn EverCrypt_Hash_Incremental_finish_blake2b(
p: *mut Hacl_Streaming_Functor_state_s___EverCrypt_Hash_state_s____,
dst: *mut u8,
);
}
extern "C" {
pub fn EverCrypt_Hash_Incremental_alg_of_state(
s: *mut Hacl_Streaming_Functor_state_s___EverCrypt_Hash_state_s____,
) -> Spec_Hash_Definitions_hash_alg;
}
extern "C" {
pub fn EverCrypt_Hash_Incremental_finish(
s: *mut Hacl_Streaming_Functor_state_s___EverCrypt_Hash_state_s____,
dst: *mut u8,
);
}
extern "C" {
pub fn EverCrypt_Hash_Incremental_free(s: *mut Hacl_Streaming_Functor_state_s___EverCrypt_Hash_state_s____);
}
extern "C" {
pub fn EverCrypt_HMAC_compute_sha1(dst: *mut u8, key: *mut u8, key_len: u32, data: *mut u8, data_len: u32);
}
extern "C" {
pub fn EverCrypt_HMAC_compute_sha2_256(dst: *mut u8, key: *mut u8, key_len: u32, data: *mut u8, data_len: u32);
}
extern "C" {
pub fn EverCrypt_HMAC_compute_sha2_384(dst: *mut u8, key: *mut u8, key_len: u32, data: *mut u8, data_len: u32);
}
extern "C" {
pub fn EverCrypt_HMAC_compute_sha2_512(dst: *mut u8, key: *mut u8, key_len: u32, data: *mut u8, data_len: u32);
}
extern "C" {
pub fn EverCrypt_HMAC_compute_blake2s(dst: *mut u8, key: *mut u8, key_len: u32, data: *mut u8, data_len: u32);
}
extern "C" {
pub fn EverCrypt_HMAC_compute_blake2b(dst: *mut u8, key: *mut u8, key_len: u32, data: *mut u8, data_len: u32);
}
extern "C" {
pub fn EverCrypt_HMAC_is_supported_alg(uu___: Spec_Hash_Definitions_hash_alg) -> bool;
}
pub type EverCrypt_HMAC_supported_alg = Spec_Hash_Definitions_hash_alg;
extern "C" {
pub fn EverCrypt_HMAC_compute(
a: Spec_Hash_Definitions_hash_alg,
mac: *mut u8,
key: *mut u8,
keylen: u32,
data: *mut u8,
datalen: u32,
);
}
extern "C" {
pub fn EverCrypt_HKDF_expand_sha1(okm: *mut u8, prk: *mut u8, prklen: u32, info: *mut u8, infolen: u32, len: u32);
}
extern "C" {
pub fn EverCrypt_HKDF_extract_sha1(prk: *mut u8, salt: *mut u8, saltlen: u32, ikm: *mut u8, ikmlen: u32);
}
extern "C" {
pub fn EverCrypt_HKDF_expand_sha2_256(
okm: *mut u8,
prk: *mut u8,
prklen: u32,
info: *mut u8,
infolen: u32,
len: u32,
);
}
extern "C" {
pub fn EverCrypt_HKDF_extract_sha2_256(prk: *mut u8, salt: *mut u8, saltlen: u32, ikm: *mut u8, ikmlen: u32);
}
extern "C" {
pub fn EverCrypt_HKDF_expand_sha2_384(
okm: *mut u8,
prk: *mut u8,
prklen: u32,
info: *mut u8,
infolen: u32,
len: u32,
);
}
extern "C" {
pub fn EverCrypt_HKDF_extract_sha2_384(prk: *mut u8, salt: *mut u8, saltlen: u32, ikm: *mut u8, ikmlen: u32);
}
extern "C" {
pub fn EverCrypt_HKDF_expand_sha2_512(
okm: *mut u8,
prk: *mut u8,
prklen: u32,
info: *mut u8,
infolen: u32,
len: u32,
);
}
extern "C" {
pub fn EverCrypt_HKDF_extract_sha2_512(prk: *mut u8, salt: *mut u8, saltlen: u32, ikm: *mut u8, ikmlen: u32);
}
extern "C" {
pub fn EverCrypt_HKDF_expand_blake2s(
okm: *mut u8,
prk: *mut u8,
prklen: u32,
info: *mut u8,
infolen: u32,
len: u32,
);
}
extern "C" {
pub fn EverCrypt_HKDF_extract_blake2s(prk: *mut u8, salt: *mut u8, saltlen: u32, ikm: *mut u8, ikmlen: u32);
}
extern "C" {
pub fn EverCrypt_HKDF_expand_blake2b(
okm: *mut u8,
prk: *mut u8,
prklen: u32,
info: *mut u8,
infolen: u32,
len: u32,
);
}
extern "C" {
pub fn EverCrypt_HKDF_extract_blake2b(prk: *mut u8, salt: *mut u8, saltlen: u32, ikm: *mut u8, ikmlen: u32);
}
extern "C" {
pub fn EverCrypt_HKDF_expand(
a: Spec_Hash_Definitions_hash_alg,
okm: *mut u8,
prk: *mut u8,
prklen: u32,
info: *mut u8,
infolen: u32,
len: u32,
);
}
extern "C" {
pub fn EverCrypt_HKDF_extract(
a: Spec_Hash_Definitions_hash_alg,
prk: *mut u8,
salt: *mut u8,
saltlen: u32,
ikm: *mut u8,
ikmlen: u32,
);
}
extern "C" {
pub fn EverCrypt_HKDF_hkdf_expand(
a: Spec_Hash_Definitions_hash_alg,
okm: *mut u8,
prk: *mut u8,
prklen: u32,
info: *mut u8,
infolen: u32,
len: u32,
);
}
extern "C" {
pub fn EverCrypt_HKDF_hkdf_extract(
a: Spec_Hash_Definitions_hash_alg,
prk: *mut u8,
salt: *mut u8,
saltlen: u32,
ikm: *mut u8,
ikmlen: u32,
);
}
extern "C" {
pub static mut Hacl_Frodo640_crypto_bytes: u32;
}
extern "C" {
pub static mut Hacl_Frodo640_crypto_publickeybytes: u32;
}
extern "C" {
pub static mut Hacl_Frodo640_crypto_secretkeybytes: u32;
}
extern "C" {
pub static mut Hacl_Frodo640_crypto_ciphertextbytes: u32;
}
extern "C" {
pub fn Hacl_Frodo640_crypto_kem_keypair(pk: *mut u8, sk: *mut u8) -> u32;
}
extern "C" {
pub fn Hacl_Frodo640_crypto_kem_enc(ct: *mut u8, ss: *mut u8, pk: *mut u8) -> u32;
}
extern "C" {
pub fn Hacl_Frodo640_crypto_kem_dec(ss: *mut u8, ct: *mut u8, sk: *mut u8) -> u32;
}
pub type Hacl_HMAC_DRBG_supported_alg = Spec_Hash_Definitions_hash_alg;
extern "C" {
pub static mut Hacl_HMAC_DRBG_reseed_interval: u32;
}
extern "C" {
pub static mut Hacl_HMAC_DRBG_max_output_length: u32;
}
extern "C" {
pub static mut Hacl_HMAC_DRBG_max_length: u32;
}
extern "C" {
pub static mut Hacl_HMAC_DRBG_max_personalization_string_length: u32;
}
extern "C" {
pub static mut Hacl_HMAC_DRBG_max_additional_input_length: u32;
}
extern "C" {
pub fn Hacl_HMAC_DRBG_min_length(a: Spec_Hash_Definitions_hash_alg) -> u32;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Hacl_HMAC_DRBG_state_s {
pub k: *mut u8,
pub v: *mut u8,
pub reseed_counter: *mut u32,
}
pub type Hacl_HMAC_DRBG_state = Hacl_HMAC_DRBG_state_s;
extern "C" {
pub fn Hacl_HMAC_DRBG_uu___is_State(a: Spec_Hash_Definitions_hash_alg, projectee: Hacl_HMAC_DRBG_state) -> bool;
}
extern "C" {
pub fn Hacl_HMAC_DRBG_create_in(a: Spec_Hash_Definitions_hash_alg) -> Hacl_HMAC_DRBG_state;
}
extern "C" {
pub fn Hacl_HMAC_DRBG_instantiate(
a: Spec_Hash_Definitions_hash_alg,
st: Hacl_HMAC_DRBG_state,
entropy_input_len: u32,
entropy_input: *mut u8,
nonce_len: u32,
nonce: *mut u8,
personalization_string_len: u32,
personalization_string: *mut u8,
);
}
extern "C" {
pub fn Hacl_HMAC_DRBG_reseed(
a: Spec_Hash_Definitions_hash_alg,
st: Hacl_HMAC_DRBG_state,
entropy_input_len: u32,
entropy_input: *mut u8,
additional_input_input_len: u32,
additional_input_input: *mut u8,
);
}
extern "C" {
pub fn Hacl_HMAC_DRBG_generate(
a: Spec_Hash_Definitions_hash_alg,
output: *mut u8,
st: Hacl_HMAC_DRBG_state,
n: u32,
additional_input_len: u32,
additional_input: *mut u8,
) -> bool;
}
extern "C" {
pub fn Hacl_HPKE_P256_CP32_SHA256_setupBaseI(
o_pkE: *mut u8,
o_k: *mut u8,
o_n: *mut u8,
skE: *mut u8,
pkR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_P256_CP32_SHA256_setupBaseR(
o_key_aead: *mut u8,
o_nonce_aead: *mut u8,
pkE: *mut u8,
skR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_P256_CP32_SHA256_sealBase(
skE: *mut u8,
pkR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_P256_CP32_SHA256_openBase(
pkE: *mut u8,
skR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve64_CP128_SHA256_setupBaseI(
o_pkE: *mut u8,
o_k: *mut u8,
o_n: *mut u8,
skE: *mut u8,
pkR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve64_CP128_SHA256_setupBaseR(
o_key_aead: *mut u8,
o_nonce_aead: *mut u8,
pkE: *mut u8,
skR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve64_CP128_SHA256_sealBase(
skE: *mut u8,
pkR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve64_CP128_SHA256_openBase(
pkE: *mut u8,
skR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
pub type Hacl_Bignum64_pbn_mont_ctx_u64 = *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64;
extern "C" {
pub fn Hacl_Bignum64_add(len: u32, a: *mut u64, b: *mut u64, res: *mut u64) -> u64;
}
extern "C" {
pub fn Hacl_Bignum64_sub(len: u32, a: *mut u64, b: *mut u64, res: *mut u64) -> u64;
}
extern "C" {
pub fn Hacl_Bignum64_add_mod(len: u32, n: *mut u64, a: *mut u64, b: *mut u64, res: *mut u64);
}
extern "C" {
pub fn Hacl_Bignum64_sub_mod(len: u32, n: *mut u64, a: *mut u64, b: *mut u64, res: *mut u64);
}
extern "C" {
pub fn Hacl_Bignum64_mul(len: u32, a: *mut u64, b: *mut u64, res: *mut u64);
}
extern "C" {
pub fn Hacl_Bignum64_sqr(len: u32, a: *mut u64, res: *mut u64);
}
extern "C" {
pub fn Hacl_Bignum64_mod(len: u32, n: *mut u64, a: *mut u64, res: *mut u64) -> bool;
}
extern "C" {
pub fn Hacl_Bignum64_mod_exp_vartime(
len: u32,
n: *mut u64,
a: *mut u64,
bBits: u32,
b: *mut u64,
res: *mut u64,
) -> bool;
}
extern "C" {
pub fn Hacl_Bignum64_mod_exp_consttime(
len: u32,
n: *mut u64,
a: *mut u64,
bBits: u32,
b: *mut u64,
res: *mut u64,
) -> bool;
}
extern "C" {
pub fn Hacl_Bignum64_mod_inv_prime_vartime(len: u32, n: *mut u64, a: *mut u64, res: *mut u64) -> bool;
}
extern "C" {
pub fn Hacl_Bignum64_mont_ctx_init(len: u32, n: *mut u64) -> *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64;
}
extern "C" {
pub fn Hacl_Bignum64_mont_ctx_free(k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64);
}
extern "C" {
pub fn Hacl_Bignum64_mod_precomp(k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64, a: *mut u64, res: *mut u64);
}
extern "C" {
pub fn Hacl_Bignum64_mod_exp_vartime_precomp(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64,
a: *mut u64,
bBits: u32,
b: *mut u64,
res: *mut u64,
);
}
extern "C" {
pub fn Hacl_Bignum64_mod_exp_consttime_precomp(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64,
a: *mut u64,
bBits: u32,
b: *mut u64,
res: *mut u64,
);
}
extern "C" {
pub fn Hacl_Bignum64_mod_inv_prime_vartime_precomp(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64,
a: *mut u64,
res: *mut u64,
);
}
extern "C" {
pub fn Hacl_Bignum64_new_bn_from_bytes_be(len: u32, b: *mut u8) -> *mut u64;
}
extern "C" {
pub fn Hacl_Bignum64_new_bn_from_bytes_le(len: u32, b: *mut u8) -> *mut u64;
}
extern "C" {
pub fn Hacl_Bignum64_bn_to_bytes_be(len: u32, b: *mut u64, res: *mut u8);
}
extern "C" {
pub fn Hacl_Bignum64_bn_to_bytes_le(len: u32, b: *mut u64, res: *mut u8);
}
extern "C" {
pub fn Hacl_Bignum64_lt_mask(len: u32, a: *mut u64, b: *mut u64) -> u64;
}
extern "C" {
pub fn Hacl_Bignum64_eq_mask(len: u32, a: *mut u64, b: *mut u64) -> u64;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Hacl_Streaming_SHA2_state_sha2_224_s {
pub block_state: *mut u32,
pub buf: *mut u8,
pub total_len: u64,
}
pub type Hacl_Streaming_SHA2_state_sha2_224 = Hacl_Streaming_SHA2_state_sha2_224_s;
pub type Hacl_Streaming_SHA2_state_sha2_256 = Hacl_Streaming_SHA2_state_sha2_224;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Hacl_Streaming_SHA2_state_sha2_384_s {
pub block_state: *mut u64,
pub buf: *mut u8,
pub total_len: u64,
}
pub type Hacl_Streaming_SHA2_state_sha2_384 = Hacl_Streaming_SHA2_state_sha2_384_s;
pub type Hacl_Streaming_SHA2_state_sha2_512 = Hacl_Streaming_SHA2_state_sha2_384;
extern "C" {
pub fn Hacl_Streaming_SHA2_create_in_224() -> *mut Hacl_Streaming_SHA2_state_sha2_224;
}
extern "C" {
pub fn Hacl_Streaming_SHA2_init_224(s: *mut Hacl_Streaming_SHA2_state_sha2_224);
}
extern "C" {
pub fn Hacl_Streaming_SHA2_update_224(p: *mut Hacl_Streaming_SHA2_state_sha2_224, data: *mut u8, len: u32);
}
extern "C" {
pub fn Hacl_Streaming_SHA2_finish_224(p: *mut Hacl_Streaming_SHA2_state_sha2_224, dst: *mut u8);
}
extern "C" {
pub fn Hacl_Streaming_SHA2_free_224(s: *mut Hacl_Streaming_SHA2_state_sha2_224);
}
extern "C" {
pub fn Hacl_Streaming_SHA2_create_in_256() -> *mut Hacl_Streaming_SHA2_state_sha2_224;
}
extern "C" {
pub fn Hacl_Streaming_SHA2_init_256(s: *mut Hacl_Streaming_SHA2_state_sha2_224);
}
extern "C" {
pub fn Hacl_Streaming_SHA2_update_256(p: *mut Hacl_Streaming_SHA2_state_sha2_224, data: *mut u8, len: u32);
}
extern "C" {
pub fn Hacl_Streaming_SHA2_finish_256(p: *mut Hacl_Streaming_SHA2_state_sha2_224, dst: *mut u8);
}
extern "C" {
pub fn Hacl_Streaming_SHA2_free_256(s: *mut Hacl_Streaming_SHA2_state_sha2_224);
}
extern "C" {
pub fn Hacl_Streaming_SHA2_create_in_384() -> *mut Hacl_Streaming_SHA2_state_sha2_384;
}
extern "C" {
pub fn Hacl_Streaming_SHA2_init_384(s: *mut Hacl_Streaming_SHA2_state_sha2_384);
}
extern "C" {
pub fn Hacl_Streaming_SHA2_update_384(p: *mut Hacl_Streaming_SHA2_state_sha2_384, data: *mut u8, len: u32);
}
extern "C" {
pub fn Hacl_Streaming_SHA2_finish_384(p: *mut Hacl_Streaming_SHA2_state_sha2_384, dst: *mut u8);
}
extern "C" {
pub fn Hacl_Streaming_SHA2_free_384(s: *mut Hacl_Streaming_SHA2_state_sha2_384);
}
extern "C" {
pub fn Hacl_Streaming_SHA2_create_in_512() -> *mut Hacl_Streaming_SHA2_state_sha2_384;
}
extern "C" {
pub fn Hacl_Streaming_SHA2_init_512(s: *mut Hacl_Streaming_SHA2_state_sha2_384);
}
extern "C" {
pub fn Hacl_Streaming_SHA2_update_512(p: *mut Hacl_Streaming_SHA2_state_sha2_384, data: *mut u8, len: u32);
}
extern "C" {
pub fn Hacl_Streaming_SHA2_finish_512(p: *mut Hacl_Streaming_SHA2_state_sha2_384, dst: *mut u8);
}
extern "C" {
pub fn Hacl_Streaming_SHA2_free_512(s: *mut Hacl_Streaming_SHA2_state_sha2_384);
}
pub type Hacl_Streaming_SHA1_state_sha1 = Hacl_Streaming_SHA2_state_sha2_224;
extern "C" {
pub fn Hacl_Streaming_SHA1_legacy_create_in_sha1() -> *mut Hacl_Streaming_SHA2_state_sha2_224;
}
extern "C" {
pub fn Hacl_Streaming_SHA1_legacy_init_sha1(s: *mut Hacl_Streaming_SHA2_state_sha2_224);
}
extern "C" {
pub fn Hacl_Streaming_SHA1_legacy_update_sha1(p: *mut Hacl_Streaming_SHA2_state_sha2_224, data: *mut u8, len: u32);
}
extern "C" {
pub fn Hacl_Streaming_SHA1_legacy_finish_sha1(p: *mut Hacl_Streaming_SHA2_state_sha2_224, dst: *mut u8);
}
extern "C" {
pub fn Hacl_Streaming_SHA1_legacy_free_sha1(s: *mut Hacl_Streaming_SHA2_state_sha2_224);
}
extern "C" {
pub fn Hacl_HMAC_Blake2s_128_compute_blake2s_128(
dst: *mut u8,
key: *mut u8,
key_len: u32,
data: *mut u8,
data_len: u32,
);
}
pub type Hacl_Streaming_MD5_state_md5 = Hacl_Streaming_SHA2_state_sha2_224;
extern "C" {
pub fn Hacl_Streaming_MD5_legacy_create_in_md5() -> *mut Hacl_Streaming_SHA2_state_sha2_224;
}
extern "C" {
pub fn Hacl_Streaming_MD5_legacy_init_md5(s: *mut Hacl_Streaming_SHA2_state_sha2_224);
}
extern "C" {
pub fn Hacl_Streaming_MD5_legacy_update_md5(p: *mut Hacl_Streaming_SHA2_state_sha2_224, data: *mut u8, len: u32);
}
extern "C" {
pub fn Hacl_Streaming_MD5_legacy_finish_md5(p: *mut Hacl_Streaming_SHA2_state_sha2_224, dst: *mut u8);
}
extern "C" {
pub fn Hacl_Streaming_MD5_legacy_free_md5(s: *mut Hacl_Streaming_SHA2_state_sha2_224);
}
extern "C" {
pub fn Hacl_Blake2b_256_blake2b_init(hash: *mut *mut ::std::os::raw::c_void, kk: u32, nn: u32);
}
extern "C" {
pub fn Hacl_Blake2b_256_blake2b_update_key(
wv: *mut *mut ::std::os::raw::c_void,
hash: *mut *mut ::std::os::raw::c_void,
kk: u32,
k: *mut u8,
ll: u32,
);
}
extern "C" {
pub fn Hacl_Blake2b_256_blake2b_finish(nn: u32, output: *mut u8, hash: *mut *mut ::std::os::raw::c_void);
}
extern "C" {
pub fn Hacl_Blake2b_256_blake2b(nn: u32, output: *mut u8, ll: u32, d: *mut u8, kk: u32, k: *mut u8);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Hacl_Streaming_Blake2b_256_blake2b_256_block_state_s {
pub fst: *mut *mut ::std::os::raw::c_void,
pub snd: *mut *mut ::std::os::raw::c_void,
}
pub type Hacl_Streaming_Blake2b_256_blake2b_256_block_state = Hacl_Streaming_Blake2b_256_blake2b_256_block_state_s;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Hacl_Streaming_Blake2b_256_blake2b_256_state_s {
pub block_state: Hacl_Streaming_Blake2b_256_blake2b_256_block_state,
pub buf: *mut u8,
pub total_len: u64,
}
pub type Hacl_Streaming_Blake2b_256_blake2b_256_state = Hacl_Streaming_Blake2b_256_blake2b_256_state_s;
extern "C" {
pub fn Hacl_Streaming_Blake2b_256_blake2b_256_no_key_create_in() -> *mut Hacl_Streaming_Blake2b_256_blake2b_256_state;
}
extern "C" {
pub fn Hacl_Streaming_Blake2b_256_blake2b_256_no_key_init(s: *mut Hacl_Streaming_Blake2b_256_blake2b_256_state);
}
extern "C" {
pub fn Hacl_Streaming_Blake2b_256_blake2b_256_no_key_update(
p: *mut Hacl_Streaming_Blake2b_256_blake2b_256_state,
data: *mut u8,
len: u32,
);
}
extern "C" {
pub fn Hacl_Streaming_Blake2b_256_blake2b_256_no_key_finish(
p: *mut Hacl_Streaming_Blake2b_256_blake2b_256_state,
dst: *mut u8,
);
}
extern "C" {
pub fn Hacl_Streaming_Blake2b_256_blake2b_256_no_key_free(s: *mut Hacl_Streaming_Blake2b_256_blake2b_256_state);
}
extern "C" {
pub fn Hacl_Bignum256_32_add(a: *mut u32, b: *mut u32, res: *mut u32) -> u32;
}
extern "C" {
pub fn Hacl_Bignum256_32_sub(a: *mut u32, b: *mut u32, res: *mut u32) -> u32;
}
extern "C" {
pub fn Hacl_Bignum256_32_add_mod(n: *mut u32, a: *mut u32, b: *mut u32, res: *mut u32);
}
extern "C" {
pub fn Hacl_Bignum256_32_sub_mod(n: *mut u32, a: *mut u32, b: *mut u32, res: *mut u32);
}
extern "C" {
pub fn Hacl_Bignum256_32_mul(a: *mut u32, b: *mut u32, res: *mut u32);
}
extern "C" {
pub fn Hacl_Bignum256_32_sqr(a: *mut u32, res: *mut u32);
}
extern "C" {
pub fn Hacl_Bignum256_32_mod(n: *mut u32, a: *mut u32, res: *mut u32) -> bool;
}
extern "C" {
pub fn Hacl_Bignum256_32_mod_exp_vartime(n: *mut u32, a: *mut u32, bBits: u32, b: *mut u32, res: *mut u32) -> bool;
}
extern "C" {
pub fn Hacl_Bignum256_32_mod_exp_consttime(
n: *mut u32,
a: *mut u32,
bBits: u32,
b: *mut u32,
res: *mut u32,
) -> bool;
}
extern "C" {
pub fn Hacl_Bignum256_32_mod_inv_prime_vartime(n: *mut u32, a: *mut u32, res: *mut u32) -> bool;
}
extern "C" {
pub fn Hacl_Bignum256_32_mont_ctx_init(n: *mut u32) -> *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32;
}
extern "C" {
pub fn Hacl_Bignum256_32_mont_ctx_free(k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32);
}
extern "C" {
pub fn Hacl_Bignum256_32_mod_precomp(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32,
a: *mut u32,
res: *mut u32,
);
}
extern "C" {
pub fn Hacl_Bignum256_32_mod_exp_vartime_precomp(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32,
a: *mut u32,
bBits: u32,
b: *mut u32,
res: *mut u32,
);
}
extern "C" {
pub fn Hacl_Bignum256_32_mod_exp_consttime_precomp(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32,
a: *mut u32,
bBits: u32,
b: *mut u32,
res: *mut u32,
);
}
extern "C" {
pub fn Hacl_Bignum256_32_mod_inv_prime_vartime_precomp(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32,
a: *mut u32,
res: *mut u32,
);
}
extern "C" {
pub fn Hacl_Bignum256_32_new_bn_from_bytes_be(len: u32, b: *mut u8) -> *mut u32;
}
extern "C" {
pub fn Hacl_Bignum256_32_new_bn_from_bytes_le(len: u32, b: *mut u8) -> *mut u32;
}
extern "C" {
pub fn Hacl_Bignum256_32_bn_to_bytes_be(b: *mut u32, res: *mut u8);
}
extern "C" {
pub fn Hacl_Bignum256_32_bn_to_bytes_le(b: *mut u32, res: *mut u8);
}
extern "C" {
pub fn Hacl_Bignum256_32_lt_mask(a: *mut u32, b: *mut u32) -> u32;
}
extern "C" {
pub fn Hacl_Bignum256_32_eq_mask(a: *mut u32, b: *mut u32) -> u32;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Hacl_Streaming_Poly1305_128_poly1305_128_state_s {
pub block_state: *mut *mut ::std::os::raw::c_void,
pub buf: *mut u8,
pub total_len: u64,
pub p_key: *mut u8,
}
pub type Hacl_Streaming_Poly1305_128_poly1305_128_state = Hacl_Streaming_Poly1305_128_poly1305_128_state_s;
extern "C" {
pub fn Hacl_Streaming_Poly1305_128_create_in(k: *mut u8) -> *mut Hacl_Streaming_Poly1305_128_poly1305_128_state;
}
extern "C" {
pub fn Hacl_Streaming_Poly1305_128_init(k: *mut u8, s: *mut Hacl_Streaming_Poly1305_128_poly1305_128_state);
}
extern "C" {
pub fn Hacl_Streaming_Poly1305_128_update(
p: *mut Hacl_Streaming_Poly1305_128_poly1305_128_state,
data: *mut u8,
len: u32,
);
}
extern "C" {
pub fn Hacl_Streaming_Poly1305_128_finish(p: *mut Hacl_Streaming_Poly1305_128_poly1305_128_state, dst: *mut u8);
}
extern "C" {
pub fn Hacl_Streaming_Poly1305_128_free(s: *mut Hacl_Streaming_Poly1305_128_poly1305_128_state);
}
extern "C" {
pub fn Hacl_HPKE_Curve64_CP32_SHA256_setupBaseI(
o_pkE: *mut u8,
o_k: *mut u8,
o_n: *mut u8,
skE: *mut u8,
pkR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve64_CP32_SHA256_setupBaseR(
o_key_aead: *mut u8,
o_nonce_aead: *mut u8,
pkE: *mut u8,
skR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve64_CP32_SHA256_sealBase(
skE: *mut u8,
pkR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve64_CP32_SHA256_openBase(
pkE: *mut u8,
skR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_Salsa20_salsa20_encrypt(len: u32, out: *mut u8, text: *mut u8, key: *mut u8, n: *mut u8, ctr: u32);
}
extern "C" {
pub fn Hacl_Salsa20_salsa20_decrypt(len: u32, out: *mut u8, cipher: *mut u8, key: *mut u8, n: *mut u8, ctr: u32);
}
extern "C" {
pub fn Hacl_Salsa20_salsa20_key_block0(out: *mut u8, key: *mut u8, n: *mut u8);
}
extern "C" {
pub fn Hacl_Salsa20_hsalsa20(out: *mut u8, key: *mut u8, n: *mut u8);
}
extern "C" {
pub fn Hacl_HPKE_Curve64_CP256_SHA512_setupBaseI(
o_pkE: *mut u8,
o_k: *mut u8,
o_n: *mut u8,
skE: *mut u8,
pkR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve64_CP256_SHA512_setupBaseR(
o_key_aead: *mut u8,
o_nonce_aead: *mut u8,
pkE: *mut u8,
skR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve64_CP256_SHA512_sealBase(
skE: *mut u8,
pkR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve64_CP256_SHA512_openBase(
pkE: *mut u8,
skR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_Bignum4096_add(a: *mut u64, b: *mut u64, res: *mut u64) -> u64;
}
extern "C" {
pub fn Hacl_Bignum4096_sub(a: *mut u64, b: *mut u64, res: *mut u64) -> u64;
}
extern "C" {
pub fn Hacl_Bignum4096_add_mod(n: *mut u64, a: *mut u64, b: *mut u64, res: *mut u64);
}
extern "C" {
pub fn Hacl_Bignum4096_sub_mod(n: *mut u64, a: *mut u64, b: *mut u64, res: *mut u64);
}
extern "C" {
pub fn Hacl_Bignum4096_mul(a: *mut u64, b: *mut u64, res: *mut u64);
}
extern "C" {
pub fn Hacl_Bignum4096_sqr(a: *mut u64, res: *mut u64);
}
extern "C" {
pub fn Hacl_Bignum4096_mod(n: *mut u64, a: *mut u64, res: *mut u64) -> bool;
}
extern "C" {
pub fn Hacl_Bignum4096_mod_exp_vartime(n: *mut u64, a: *mut u64, bBits: u32, b: *mut u64, res: *mut u64) -> bool;
}
extern "C" {
pub fn Hacl_Bignum4096_mod_exp_consttime(n: *mut u64, a: *mut u64, bBits: u32, b: *mut u64, res: *mut u64) -> bool;
}
extern "C" {
pub fn Hacl_Bignum4096_mod_inv_prime_vartime(n: *mut u64, a: *mut u64, res: *mut u64) -> bool;
}
extern "C" {
pub fn Hacl_Bignum4096_mont_ctx_init(n: *mut u64) -> *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64;
}
extern "C" {
pub fn Hacl_Bignum4096_mont_ctx_free(k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64);
}
extern "C" {
pub fn Hacl_Bignum4096_mod_precomp(k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64, a: *mut u64, res: *mut u64);
}
extern "C" {
pub fn Hacl_Bignum4096_mod_exp_vartime_precomp(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64,
a: *mut u64,
bBits: u32,
b: *mut u64,
res: *mut u64,
);
}
extern "C" {
pub fn Hacl_Bignum4096_mod_exp_consttime_precomp(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64,
a: *mut u64,
bBits: u32,
b: *mut u64,
res: *mut u64,
);
}
extern "C" {
pub fn Hacl_Bignum4096_mod_inv_prime_vartime_precomp(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64,
a: *mut u64,
res: *mut u64,
);
}
extern "C" {
pub fn Hacl_Bignum4096_new_bn_from_bytes_be(len: u32, b: *mut u8) -> *mut u64;
}
extern "C" {
pub fn Hacl_Bignum4096_new_bn_from_bytes_le(len: u32, b: *mut u8) -> *mut u64;
}
extern "C" {
pub fn Hacl_Bignum4096_bn_to_bytes_be(b: *mut u64, res: *mut u8);
}
extern "C" {
pub fn Hacl_Bignum4096_bn_to_bytes_le(b: *mut u64, res: *mut u8);
}
extern "C" {
pub fn Hacl_Bignum4096_lt_mask(a: *mut u64, b: *mut u64) -> u64;
}
extern "C" {
pub fn Hacl_Bignum4096_eq_mask(a: *mut u64, b: *mut u64) -> u64;
}
extern "C" {
pub fn Hacl_HPKE_Curve64_CP32_SHA512_setupBaseI(
o_pkE: *mut u8,
o_k: *mut u8,
o_n: *mut u8,
skE: *mut u8,
pkR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve64_CP32_SHA512_setupBaseR(
o_key_aead: *mut u8,
o_nonce_aead: *mut u8,
pkE: *mut u8,
skR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve64_CP32_SHA512_sealBase(
skE: *mut u8,
pkR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve64_CP32_SHA512_openBase(
pkE: *mut u8,
skR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve64_CP256_SHA256_setupBaseI(
o_pkE: *mut u8,
o_k: *mut u8,
o_n: *mut u8,
skE: *mut u8,
pkR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve64_CP256_SHA256_setupBaseR(
o_key_aead: *mut u8,
o_nonce_aead: *mut u8,
pkE: *mut u8,
skR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve64_CP256_SHA256_sealBase(
skE: *mut u8,
pkR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve64_CP256_SHA256_openBase(
pkE: *mut u8,
skR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_Hash_Definitions_word_len(a: Spec_Hash_Definitions_hash_alg) -> u32;
}
extern "C" {
pub fn Hacl_Hash_Definitions_block_len(a: Spec_Hash_Definitions_hash_alg) -> u32;
}
extern "C" {
pub fn Hacl_Hash_Definitions_hash_word_len(a: Spec_Hash_Definitions_hash_alg) -> u32;
}
extern "C" {
pub fn Hacl_Hash_Definitions_hash_len(a: Spec_Hash_Definitions_hash_alg) -> u32;
}
extern "C" {
pub fn Hacl_Ed25519_sign(signature: *mut u8, priv_: *mut u8, len: u32, msg: *mut u8);
}
extern "C" {
pub fn Hacl_Ed25519_verify(pub_: *mut u8, len: u32, msg: *mut u8, signature: *mut u8) -> bool;
}
extern "C" {
pub fn Hacl_Ed25519_secret_to_public(pub_: *mut u8, priv_: *mut u8);
}
extern "C" {
pub fn Hacl_Ed25519_expand_keys(ks: *mut u8, priv_: *mut u8);
}
extern "C" {
pub fn Hacl_Ed25519_sign_expanded(signature: *mut u8, ks: *mut u8, len: u32, msg: *mut u8);
}
extern "C" {
pub static Hacl_Impl_FFDHE_Constants_ffdhe_g2: [u8; 1usize];
}
extern "C" {
pub static Hacl_Impl_FFDHE_Constants_ffdhe_p2048: [u8; 256usize];
}
extern "C" {
pub static Hacl_Impl_FFDHE_Constants_ffdhe_p3072: [u8; 384usize];
}
extern "C" {
pub static Hacl_Impl_FFDHE_Constants_ffdhe_p4096: [u8; 512usize];
}
extern "C" {
pub static Hacl_Impl_FFDHE_Constants_ffdhe_p6144: [u8; 768usize];
}
extern "C" {
pub static Hacl_Impl_FFDHE_Constants_ffdhe_p8192: [u8; 1024usize];
}
extern "C" {
pub fn Hacl_FFDHE_ffdhe_len(a: Spec_FFDHE_ffdhe_alg) -> u32;
}
extern "C" {
pub fn Hacl_FFDHE_new_ffdhe_precomp_p(a: Spec_FFDHE_ffdhe_alg) -> *mut u64;
}
extern "C" {
pub fn Hacl_FFDHE_ffdhe_secret_to_public_precomp(
a: Spec_FFDHE_ffdhe_alg,
p_r2_n: *mut u64,
sk: *mut u8,
pk: *mut u8,
);
}
extern "C" {
pub fn Hacl_FFDHE_ffdhe_secret_to_public(a: Spec_FFDHE_ffdhe_alg, sk: *mut u8, pk: *mut u8);
}
extern "C" {
pub fn Hacl_FFDHE_ffdhe_shared_secret_precomp(
a: Spec_FFDHE_ffdhe_alg,
p_r2_n: *mut u64,
sk: *mut u8,
pk: *mut u8,
ss: *mut u8,
) -> u64;
}
extern "C" {
pub fn Hacl_FFDHE_ffdhe_shared_secret(a: Spec_FFDHE_ffdhe_alg, sk: *mut u8, pk: *mut u8, ss: *mut u8) -> u64;
}
extern "C" {
pub fn EverCrypt_Curve25519_secret_to_public(pub_: *mut u8, priv_: *mut u8);
}
extern "C" {
pub fn EverCrypt_Curve25519_scalarmult(shared: *mut u8, my_priv: *mut u8, their_pub: *mut u8);
}
extern "C" {
pub fn EverCrypt_Curve25519_ecdh(shared: *mut u8, my_priv: *mut u8, their_pub: *mut u8) -> bool;
}
extern "C" {
pub fn Hacl_EC_Ed25519_mk_felem_zero(b: *mut u64);
}
extern "C" {
pub fn Hacl_EC_Ed25519_mk_felem_one(b: *mut u64);
}
extern "C" {
pub fn Hacl_EC_Ed25519_felem_add(a: *mut u64, b: *mut u64, out: *mut u64);
}
extern "C" {
pub fn Hacl_EC_Ed25519_felem_sub(a: *mut u64, b: *mut u64, out: *mut u64);
}
extern "C" {
pub fn Hacl_EC_Ed25519_felem_mul(a: *mut u64, b: *mut u64, out: *mut u64);
}
extern "C" {
pub fn Hacl_EC_Ed25519_felem_inv(a: *mut u64, out: *mut u64);
}
extern "C" {
pub fn Hacl_EC_Ed25519_felem_load(b: *mut u8, out: *mut u64);
}
extern "C" {
pub fn Hacl_EC_Ed25519_felem_store(a: *mut u64, out: *mut u8);
}
extern "C" {
pub fn Hacl_EC_Ed25519_mk_point_at_inf(p: *mut u64);
}
extern "C" {
pub fn Hacl_EC_Ed25519_mk_base_point(p: *mut u64);
}
extern "C" {
pub fn Hacl_EC_Ed25519_point_negate(p: *mut u64, out: *mut u64);
}
extern "C" {
pub fn Hacl_EC_Ed25519_point_add(p: *mut u64, q: *mut u64, out: *mut u64);
}
extern "C" {
pub fn Hacl_EC_Ed25519_point_mul(scalar: *mut u8, p: *mut u64, out: *mut u64);
}
extern "C" {
pub fn Hacl_EC_Ed25519_point_eq(p: *mut u64, q: *mut u64) -> bool;
}
extern "C" {
pub fn Hacl_EC_Ed25519_point_compress(p: *mut u64, out: *mut u8);
}
extern "C" {
pub fn Hacl_EC_Ed25519_point_decompress(s: *mut u8, out: *mut u64) -> bool;
}
extern "C" {
pub fn Hacl_HPKE_Curve51_CP256_SHA512_setupBaseI(
o_pkE: *mut u8,
o_k: *mut u8,
o_n: *mut u8,
skE: *mut u8,
pkR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve51_CP256_SHA512_setupBaseR(
o_key_aead: *mut u8,
o_nonce_aead: *mut u8,
pkE: *mut u8,
skR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve51_CP256_SHA512_sealBase(
skE: *mut u8,
pkR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve51_CP256_SHA512_openBase(
pkE: *mut u8,
skR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
extern "C" {
pub fn EverCrypt_Ed25519_sign(signature: *mut u8, secret: *mut u8, len: u32, msg: *mut u8);
}
extern "C" {
pub fn EverCrypt_Ed25519_verify(pubkey: *mut u8, len: u32, msg: *mut u8, signature: *mut u8) -> bool;
}
extern "C" {
pub fn EverCrypt_Ed25519_secret_to_public(output: *mut u8, secret: *mut u8);
}
extern "C" {
pub fn EverCrypt_Ed25519_expand_keys(ks: *mut u8, secret: *mut u8);
}
extern "C" {
pub fn EverCrypt_Ed25519_sign_expanded(signature: *mut u8, ks: *mut u8, len: u32, msg: *mut u8);
}
extern "C" {
pub static mut Hacl_Frodo976_crypto_bytes: u32;
}
extern "C" {
pub static mut Hacl_Frodo976_crypto_publickeybytes: u32;
}
extern "C" {
pub static mut Hacl_Frodo976_crypto_secretkeybytes: u32;
}
extern "C" {
pub static mut Hacl_Frodo976_crypto_ciphertextbytes: u32;
}
extern "C" {
pub fn Hacl_Frodo976_crypto_kem_keypair(pk: *mut u8, sk: *mut u8) -> u32;
}
extern "C" {
pub fn Hacl_Frodo976_crypto_kem_enc(ct: *mut u8, ss: *mut u8, pk: *mut u8) -> u32;
}
extern "C" {
pub fn Hacl_Frodo976_crypto_kem_dec(ss: *mut u8, ct: *mut u8, sk: *mut u8) -> u32;
}
pub type Hacl_GenericField64_pbn_mont_ctx_u64 = *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64;
extern "C" {
#[doc = "A verified field arithmetic library."]
#[doc = ""]
#[doc = "This is a 64-bit optimized version, where bignums are represented as an array"]
#[doc = "of `len` unsigned 64-bit integers, i.e. uint64_t[len]."]
#[doc = ""]
#[doc = "All the arithmetic operations are performed in the Montgomery domain."]
#[doc = ""]
#[doc = "All the functions below preserve the following invariant for a bignum `aM` in"]
#[doc = "Montgomery form."]
#[doc = "• aM < n"]
pub fn Hacl_GenericField64_field_modulus_check(len: u32, n: *mut u64) -> bool;
}
extern "C" {
pub fn Hacl_GenericField64_field_init(len: u32, n: *mut u64) -> *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64;
}
extern "C" {
pub fn Hacl_GenericField64_field_free(k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64);
}
extern "C" {
pub fn Hacl_GenericField64_field_get_len(k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64) -> u32;
}
extern "C" {
pub fn Hacl_GenericField64_to_field(k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64, a: *mut u64, aM: *mut u64);
}
extern "C" {
pub fn Hacl_GenericField64_from_field(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64,
aM: *mut u64,
a: *mut u64,
);
}
extern "C" {
pub fn Hacl_GenericField64_add(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64,
aM: *mut u64,
bM: *mut u64,
cM: *mut u64,
);
}
extern "C" {
pub fn Hacl_GenericField64_sub(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64,
aM: *mut u64,
bM: *mut u64,
cM: *mut u64,
);
}
extern "C" {
pub fn Hacl_GenericField64_mul(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64,
aM: *mut u64,
bM: *mut u64,
cM: *mut u64,
);
}
extern "C" {
pub fn Hacl_GenericField64_sqr(k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64, aM: *mut u64, cM: *mut u64);
}
extern "C" {
pub fn Hacl_GenericField64_one(k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64, oneM: *mut u64);
}
extern "C" {
pub fn Hacl_GenericField64_exp_consttime(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64,
aM: *mut u64,
bBits: u32,
b: *mut u64,
resM: *mut u64,
);
}
extern "C" {
pub fn Hacl_GenericField64_exp_vartime(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64,
aM: *mut u64,
bBits: u32,
b: *mut u64,
resM: *mut u64,
);
}
extern "C" {
pub fn Hacl_GenericField64_inverse(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u64,
aM: *mut u64,
aInvM: *mut u64,
);
}
pub type Hacl_Bignum32_pbn_mont_ctx_u32 = *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32;
extern "C" {
pub fn Hacl_Bignum32_add(len: u32, a: *mut u32, b: *mut u32, res: *mut u32) -> u32;
}
extern "C" {
pub fn Hacl_Bignum32_sub(len: u32, a: *mut u32, b: *mut u32, res: *mut u32) -> u32;
}
extern "C" {
pub fn Hacl_Bignum32_add_mod(len: u32, n: *mut u32, a: *mut u32, b: *mut u32, res: *mut u32);
}
extern "C" {
pub fn Hacl_Bignum32_sub_mod(len: u32, n: *mut u32, a: *mut u32, b: *mut u32, res: *mut u32);
}
extern "C" {
pub fn Hacl_Bignum32_mul(len: u32, a: *mut u32, b: *mut u32, res: *mut u32);
}
extern "C" {
pub fn Hacl_Bignum32_sqr(len: u32, a: *mut u32, res: *mut u32);
}
extern "C" {
pub fn Hacl_Bignum32_mod(len: u32, n: *mut u32, a: *mut u32, res: *mut u32) -> bool;
}
extern "C" {
pub fn Hacl_Bignum32_mod_exp_vartime(
len: u32,
n: *mut u32,
a: *mut u32,
bBits: u32,
b: *mut u32,
res: *mut u32,
) -> bool;
}
extern "C" {
pub fn Hacl_Bignum32_mod_exp_consttime(
len: u32,
n: *mut u32,
a: *mut u32,
bBits: u32,
b: *mut u32,
res: *mut u32,
) -> bool;
}
extern "C" {
pub fn Hacl_Bignum32_mod_inv_prime_vartime(len: u32, n: *mut u32, a: *mut u32, res: *mut u32) -> bool;
}
extern "C" {
pub fn Hacl_Bignum32_mont_ctx_init(len: u32, n: *mut u32) -> *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32;
}
extern "C" {
pub fn Hacl_Bignum32_mont_ctx_free(k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32);
}
extern "C" {
pub fn Hacl_Bignum32_mod_precomp(k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32, a: *mut u32, res: *mut u32);
}
extern "C" {
pub fn Hacl_Bignum32_mod_exp_vartime_precomp(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32,
a: *mut u32,
bBits: u32,
b: *mut u32,
res: *mut u32,
);
}
extern "C" {
pub fn Hacl_Bignum32_mod_exp_consttime_precomp(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32,
a: *mut u32,
bBits: u32,
b: *mut u32,
res: *mut u32,
);
}
extern "C" {
pub fn Hacl_Bignum32_mod_inv_prime_vartime_precomp(
k: *mut Hacl_Bignum_MontArithmetic_bn_mont_ctx_u32,
a: *mut u32,
res: *mut u32,
);
}
extern "C" {
pub fn Hacl_Bignum32_new_bn_from_bytes_be(len: u32, b: *mut u8) -> *mut u32;
}
extern "C" {
pub fn Hacl_Bignum32_new_bn_from_bytes_le(len: u32, b: *mut u8) -> *mut u32;
}
extern "C" {
pub fn Hacl_Bignum32_bn_to_bytes_be(len: u32, b: *mut u32, res: *mut u8);
}
extern "C" {
pub fn Hacl_Bignum32_bn_to_bytes_le(len: u32, b: *mut u32, res: *mut u8);
}
extern "C" {
pub fn Hacl_Bignum32_lt_mask(len: u32, a: *mut u32, b: *mut u32) -> u32;
}
extern "C" {
pub fn Hacl_Bignum32_eq_mask(len: u32, a: *mut u32, b: *mut u32) -> u32;
}
extern "C" {
pub fn Hacl_P256_ecdsa_sign_p256_sha2(result: *mut u8, mLen: u32, m: *mut u8, privKey: *mut u8, k: *mut u8)
-> bool;
}
extern "C" {
pub fn Hacl_P256_ecdsa_sign_p256_sha384(
result: *mut u8,
mLen: u32,
m: *mut u8,
privKey: *mut u8,
k: *mut u8,
) -> bool;
}
extern "C" {
pub fn Hacl_P256_ecdsa_sign_p256_sha512(
result: *mut u8,
mLen: u32,
m: *mut u8,
privKey: *mut u8,
k: *mut u8,
) -> bool;
}
extern "C" {
pub fn Hacl_P256_ecdsa_sign_p256_without_hash(
result: *mut u8,
mLen: u32,
m: *mut u8,
privKey: *mut u8,
k: *mut u8,
) -> bool;
}
extern "C" {
pub fn Hacl_P256_ecdsa_verif_p256_sha2(mLen: u32, m: *mut u8, pubKey: *mut u8, r: *mut u8, s: *mut u8) -> bool;
}
extern "C" {
pub fn Hacl_P256_ecdsa_verif_p256_sha384(mLen: u32, m: *mut u8, pubKey: *mut u8, r: *mut u8, s: *mut u8) -> bool;
}
extern "C" {
pub fn Hacl_P256_ecdsa_verif_p256_sha512(mLen: u32, m: *mut u8, pubKey: *mut u8, r: *mut u8, s: *mut u8) -> bool;
}
extern "C" {
pub fn Hacl_P256_ecdsa_verif_without_hash(mLen: u32, m: *mut u8, pubKey: *mut u8, r: *mut u8, s: *mut u8) -> bool;
}
extern "C" {
pub fn Hacl_P256_verify_q(pubKey: *mut u8) -> bool;
}
extern "C" {
pub fn Hacl_P256_decompression_not_compressed_form(b: *mut u8, result: *mut u8) -> bool;
}
extern "C" {
pub fn Hacl_P256_decompression_compressed_form(b: *mut u8, result: *mut u8) -> bool;
}
extern "C" {
pub fn Hacl_P256_compression_not_compressed_form(b: *mut u8, result: *mut u8);
}
extern "C" {
pub fn Hacl_P256_compression_compressed_form(b: *mut u8, result: *mut u8);
}
extern "C" {
pub fn Hacl_P256_ecp256dh_i(result: *mut u8, scalar: *mut u8) -> bool;
}
extern "C" {
pub fn Hacl_P256_ecp256dh_r(result: *mut u8, pubKey: *mut u8, scalar: *mut u8) -> bool;
}
extern "C" {
pub fn Hacl_P256_is_more_than_zero_less_than_order(x: *mut u8) -> bool;
}
extern "C" {
pub fn Hacl_HPKE_Curve51_CP256_SHA256_setupBaseI(
o_pkE: *mut u8,
o_k: *mut u8,
o_n: *mut u8,
skE: *mut u8,
pkR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve51_CP256_SHA256_setupBaseR(
o_key_aead: *mut u8,
o_nonce_aead: *mut u8,
pkE: *mut u8,
skR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve51_CP256_SHA256_sealBase(
skE: *mut u8,
pkR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve51_CP256_SHA256_openBase(
pkE: *mut u8,
skR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_Curve25519_64_Slow_scalarmult(out: *mut u8, priv_: *mut u8, pub_: *mut u8);
}
extern "C" {
pub fn Hacl_Curve25519_64_Slow_secret_to_public(pub_: *mut u8, priv_: *mut u8);
}
extern "C" {
pub fn Hacl_Curve25519_64_Slow_ecdh(out: *mut u8, priv_: *mut u8, pub_: *mut u8) -> bool;
}
extern "C" {
pub static mut EverCrypt_StaticConfig_hacl: bool;
}
extern "C" {
pub static mut EverCrypt_StaticConfig_vale: bool;
}
extern "C" {
pub static mut EverCrypt_StaticConfig_openssl: bool;
}
extern "C" {
pub static mut EverCrypt_StaticConfig_bcrypt: bool;
}
extern "C" {
pub static mut Hacl_Frodo1344_crypto_bytes: u32;
}
extern "C" {
pub static mut Hacl_Frodo1344_crypto_publickeybytes: u32;
}
extern "C" {
pub static mut Hacl_Frodo1344_crypto_secretkeybytes: u32;
}
extern "C" {
pub static mut Hacl_Frodo1344_crypto_ciphertextbytes: u32;
}
extern "C" {
pub fn Hacl_Frodo1344_crypto_kem_keypair(pk: *mut u8, sk: *mut u8) -> u32;
}
extern "C" {
pub fn Hacl_Frodo1344_crypto_kem_enc(ct: *mut u8, ss: *mut u8, pk: *mut u8) -> u32;
}
extern "C" {
pub fn Hacl_Frodo1344_crypto_kem_dec(ss: *mut u8, ct: *mut u8, sk: *mut u8) -> u32;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Hacl_Streaming_Poly1305_256_poly1305_256_state_s {
pub block_state: *mut *mut ::std::os::raw::c_void,
pub buf: *mut u8,
pub total_len: u64,
pub p_key: *mut u8,
}
pub type Hacl_Streaming_Poly1305_256_poly1305_256_state = Hacl_Streaming_Poly1305_256_poly1305_256_state_s;
extern "C" {
pub fn Hacl_Streaming_Poly1305_256_create_in(k: *mut u8) -> *mut Hacl_Streaming_Poly1305_256_poly1305_256_state;
}
extern "C" {
pub fn Hacl_Streaming_Poly1305_256_init(k: *mut u8, s: *mut Hacl_Streaming_Poly1305_256_poly1305_256_state);
}
extern "C" {
pub fn Hacl_Streaming_Poly1305_256_update(
p: *mut Hacl_Streaming_Poly1305_256_poly1305_256_state,
data: *mut u8,
len: u32,
);
}
extern "C" {
pub fn Hacl_Streaming_Poly1305_256_finish(p: *mut Hacl_Streaming_Poly1305_256_poly1305_256_state, dst: *mut u8);
}
extern "C" {
pub fn Hacl_Streaming_Poly1305_256_free(s: *mut Hacl_Streaming_Poly1305_256_poly1305_256_state);
}
extern "C" {
pub fn Hacl_HPKE_P256_CP128_SHA256_setupBaseI(
o_pkE: *mut u8,
o_k: *mut u8,
o_n: *mut u8,
skE: *mut u8,
pkR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_P256_CP128_SHA256_setupBaseR(
o_key_aead: *mut u8,
o_nonce_aead: *mut u8,
pkE: *mut u8,
skR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_P256_CP128_SHA256_sealBase(
skE: *mut u8,
pkR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_P256_CP128_SHA256_openBase(
pkE: *mut u8,
skR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve51_CP128_SHA512_setupBaseI(
o_pkE: *mut u8,
o_k: *mut u8,
o_n: *mut u8,
skE: *mut u8,
pkR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve51_CP128_SHA512_setupBaseR(
o_key_aead: *mut u8,
o_nonce_aead: *mut u8,
pkE: *mut u8,
skR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve51_CP128_SHA512_sealBase(
skE: *mut u8,
pkR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve51_CP128_SHA512_openBase(
pkE: *mut u8,
skR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HKDF_Blake2b_256_expand_blake2b_256(
okm: *mut u8,
prk: *mut u8,
prklen: u32,
info: *mut u8,
infolen: u32,
len: u32,
);
}
extern "C" {
pub fn Hacl_HKDF_Blake2b_256_extract_blake2b_256(
prk: *mut u8,
salt: *mut u8,
saltlen: u32,
ikm: *mut u8,
ikmlen: u32,
);
}
extern "C" {
pub fn Hacl_HPKE_Curve51_CP32_SHA512_setupBaseI(
o_pkE: *mut u8,
o_k: *mut u8,
o_n: *mut u8,
skE: *mut u8,
pkR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve51_CP32_SHA512_setupBaseR(
o_key_aead: *mut u8,
o_nonce_aead: *mut u8,
pkE: *mut u8,
skR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve51_CP32_SHA512_sealBase(
skE: *mut u8,
pkR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve51_CP32_SHA512_openBase(
pkE: *mut u8,
skR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
pub type EverCrypt_Error_error_code = u8;
extern "C" {
pub fn EverCrypt_Error_uu___is_Success(projectee: EverCrypt_Error_error_code) -> bool;
}
extern "C" {
pub fn EverCrypt_Error_uu___is_UnsupportedAlgorithm(projectee: EverCrypt_Error_error_code) -> bool;
}
extern "C" {
pub fn EverCrypt_Error_uu___is_InvalidKey(projectee: EverCrypt_Error_error_code) -> bool;
}
extern "C" {
pub fn EverCrypt_Error_uu___is_AuthenticationFailure(projectee: EverCrypt_Error_error_code) -> bool;
}
extern "C" {
pub fn EverCrypt_Error_uu___is_InvalidIVLength(projectee: EverCrypt_Error_error_code) -> bool;
}
extern "C" {
pub fn EverCrypt_Error_uu___is_DecodeError(projectee: EverCrypt_Error_error_code) -> bool;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct EverCrypt_CTR_state_s_s {
_unused: [u8; 0],
}
pub type EverCrypt_CTR_state_s = EverCrypt_CTR_state_s_s;
extern "C" {
pub fn EverCrypt_CTR_uu___is_State(a: Spec_Agile_Cipher_cipher_alg, projectee: EverCrypt_CTR_state_s) -> bool;
}
pub type EverCrypt_CTR_uint8 = u8;
extern "C" {
pub fn EverCrypt_CTR_xor8(a: u8, b: u8) -> u8;
}
pub type EverCrypt_CTR_e_alg = *mut ::std::os::raw::c_void;
extern "C" {
pub fn EverCrypt_CTR_alg_of_state(s: *mut EverCrypt_CTR_state_s) -> Spec_Agile_Cipher_cipher_alg;
}
extern "C" {
pub fn EverCrypt_CTR_create_in(
a: Spec_Agile_Cipher_cipher_alg,
dst: *mut *mut EverCrypt_CTR_state_s,
k: *mut u8,
iv: *mut u8,
iv_len: u32,
c: u32,
) -> EverCrypt_Error_error_code;
}
extern "C" {
pub fn EverCrypt_CTR_init(p: *mut EverCrypt_CTR_state_s, k: *mut u8, iv: *mut u8, iv_len: u32, c: u32);
}
extern "C" {
pub fn EverCrypt_CTR_update_block(p: *mut EverCrypt_CTR_state_s, dst: *mut u8, src: *mut u8);
}
extern "C" {
pub fn EverCrypt_CTR_free(p: *mut EverCrypt_CTR_state_s);
}
pub type EverCrypt_Helpers_uint8_t = u8;
pub type EverCrypt_Helpers_uint16_t = u16;
pub type EverCrypt_Helpers_uint32_t = u32;
pub type EverCrypt_Helpers_uint64_t = u64;
pub type EverCrypt_Helpers_uint8_p = *mut u8;
pub type EverCrypt_Helpers_uint16_p = *mut u16;
pub type EverCrypt_Helpers_uint32_p = *mut u32;
pub type EverCrypt_Helpers_uint64_p = *mut u64;
extern "C" {
pub fn Hacl_HPKE_Curve51_CP128_SHA256_setupBaseI(
o_pkE: *mut u8,
o_k: *mut u8,
o_n: *mut u8,
skE: *mut u8,
pkR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve51_CP128_SHA256_setupBaseR(
o_key_aead: *mut u8,
o_nonce_aead: *mut u8,
pkE: *mut u8,
skR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve51_CP128_SHA256_sealBase(
skE: *mut u8,
pkR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve51_CP128_SHA256_openBase(
pkE: *mut u8,
skR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
extern "C" {
pub static mut Hacl_Frodo64_crypto_bytes: u32;
}
extern "C" {
pub static mut Hacl_Frodo64_crypto_publickeybytes: u32;
}
extern "C" {
pub static mut Hacl_Frodo64_crypto_secretkeybytes: u32;
}
extern "C" {
pub static mut Hacl_Frodo64_crypto_ciphertextbytes: u32;
}
extern "C" {
pub fn Hacl_Frodo64_crypto_kem_keypair(pk: *mut u8, sk: *mut u8) -> u32;
}
extern "C" {
pub fn Hacl_Frodo64_crypto_kem_enc(ct: *mut u8, ss: *mut u8, pk: *mut u8) -> u32;
}
extern "C" {
pub fn Hacl_Frodo64_crypto_kem_dec(ss: *mut u8, ct: *mut u8, sk: *mut u8) -> u32;
}
pub type EverCrypt_DRBG_supported_alg = Spec_Hash_Definitions_hash_alg;
extern "C" {
pub static mut EverCrypt_DRBG_reseed_interval: u32;
}
extern "C" {
pub static mut EverCrypt_DRBG_max_output_length: u32;
}
extern "C" {
pub static mut EverCrypt_DRBG_max_length: u32;
}
extern "C" {
pub static mut EverCrypt_DRBG_max_personalization_string_length: u32;
}
extern "C" {
pub static mut EverCrypt_DRBG_max_additional_input_length: u32;
}
extern "C" {
pub fn EverCrypt_DRBG_min_length(a: Spec_Hash_Definitions_hash_alg) -> u32;
}
pub type EverCrypt_DRBG_state_s_tags = u8;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct EverCrypt_DRBG_state_s_s {
_unused: [u8; 0],
}
pub type EverCrypt_DRBG_state_s = EverCrypt_DRBG_state_s_s;
extern "C" {
pub fn EverCrypt_DRBG_uu___is_SHA1_s(
uu___: Spec_Hash_Definitions_hash_alg,
projectee: EverCrypt_DRBG_state_s,
) -> bool;
}
extern "C" {
pub fn EverCrypt_DRBG_uu___is_SHA2_256_s(
uu___: Spec_Hash_Definitions_hash_alg,
projectee: EverCrypt_DRBG_state_s,
) -> bool;
}
extern "C" {
pub fn EverCrypt_DRBG_uu___is_SHA2_384_s(
uu___: Spec_Hash_Definitions_hash_alg,
projectee: EverCrypt_DRBG_state_s,
) -> bool;
}
extern "C" {
pub fn EverCrypt_DRBG_uu___is_SHA2_512_s(
uu___: Spec_Hash_Definitions_hash_alg,
projectee: EverCrypt_DRBG_state_s,
) -> bool;
}
extern "C" {
pub fn EverCrypt_DRBG_create(a: Spec_Hash_Definitions_hash_alg) -> *mut EverCrypt_DRBG_state_s;
}
extern "C" {
pub fn EverCrypt_DRBG_instantiate_sha1(
st: *mut EverCrypt_DRBG_state_s,
personalization_string: *mut u8,
personalization_string_len: u32,
) -> bool;
}
extern "C" {
pub fn EverCrypt_DRBG_instantiate_sha2_256(
st: *mut EverCrypt_DRBG_state_s,
personalization_string: *mut u8,
personalization_string_len: u32,
) -> bool;
}
extern "C" {
pub fn EverCrypt_DRBG_instantiate_sha2_384(
st: *mut EverCrypt_DRBG_state_s,
personalization_string: *mut u8,
personalization_string_len: u32,
) -> bool;
}
extern "C" {
pub fn EverCrypt_DRBG_instantiate_sha2_512(
st: *mut EverCrypt_DRBG_state_s,
personalization_string: *mut u8,
personalization_string_len: u32,
) -> bool;
}
extern "C" {
pub fn EverCrypt_DRBG_reseed_sha1(
st: *mut EverCrypt_DRBG_state_s,
additional_input: *mut u8,
additional_input_len: u32,
) -> bool;
}
extern "C" {
pub fn EverCrypt_DRBG_reseed_sha2_256(
st: *mut EverCrypt_DRBG_state_s,
additional_input: *mut u8,
additional_input_len: u32,
) -> bool;
}
extern "C" {
pub fn EverCrypt_DRBG_reseed_sha2_384(
st: *mut EverCrypt_DRBG_state_s,
additional_input: *mut u8,
additional_input_len: u32,
) -> bool;
}
extern "C" {
pub fn EverCrypt_DRBG_reseed_sha2_512(
st: *mut EverCrypt_DRBG_state_s,
additional_input: *mut u8,
additional_input_len: u32,
) -> bool;
}
extern "C" {
pub fn EverCrypt_DRBG_generate_sha1(
output: *mut u8,
st: *mut EverCrypt_DRBG_state_s,
n: u32,
additional_input: *mut u8,
additional_input_len: u32,
) -> bool;
}
extern "C" {
pub fn EverCrypt_DRBG_generate_sha2_256(
output: *mut u8,
st: *mut EverCrypt_DRBG_state_s,
n: u32,
additional_input: *mut u8,
additional_input_len: u32,
) -> bool;
}
extern "C" {
pub fn EverCrypt_DRBG_generate_sha2_384(
output: *mut u8,
st: *mut EverCrypt_DRBG_state_s,
n: u32,
additional_input: *mut u8,
additional_input_len: u32,
) -> bool;
}
extern "C" {
pub fn EverCrypt_DRBG_generate_sha2_512(
output: *mut u8,
st: *mut EverCrypt_DRBG_state_s,
n: u32,
additional_input: *mut u8,
additional_input_len: u32,
) -> bool;
}
extern "C" {
pub fn EverCrypt_DRBG_uninstantiate_sha1(st: *mut EverCrypt_DRBG_state_s);
}
extern "C" {
pub fn EverCrypt_DRBG_uninstantiate_sha2_256(st: *mut EverCrypt_DRBG_state_s);
}
extern "C" {
pub fn EverCrypt_DRBG_uninstantiate_sha2_384(st: *mut EverCrypt_DRBG_state_s);
}
extern "C" {
pub fn EverCrypt_DRBG_uninstantiate_sha2_512(st: *mut EverCrypt_DRBG_state_s);
}
extern "C" {
pub fn EverCrypt_DRBG_instantiate(
st: *mut EverCrypt_DRBG_state_s,
personalization_string: *mut u8,
personalization_string_len: u32,
) -> bool;
}
extern "C" {
pub fn EverCrypt_DRBG_reseed(
st: *mut EverCrypt_DRBG_state_s,
additional_input: *mut u8,
additional_input_len: u32,
) -> bool;
}
extern "C" {
pub fn EverCrypt_DRBG_generate(
output: *mut u8,
st: *mut EverCrypt_DRBG_state_s,
n: u32,
additional_input: *mut u8,
additional_input_len: u32,
) -> bool;
}
extern "C" {
pub fn EverCrypt_DRBG_uninstantiate(st: *mut EverCrypt_DRBG_state_s);
}
extern "C" {
pub fn Hacl_NaCl_crypto_secretbox_detached(
c: *mut u8,
tag: *mut u8,
m: *mut u8,
mlen: u32,
n: *mut u8,
k: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_NaCl_crypto_secretbox_open_detached(
m: *mut u8,
c: *mut u8,
tag: *mut u8,
mlen: u32,
n: *mut u8,
k: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_NaCl_crypto_secretbox_easy(c: *mut u8, m: *mut u8, mlen: u32, n: *mut u8, k: *mut u8) -> u32;
}
extern "C" {
pub fn Hacl_NaCl_crypto_secretbox_open_easy(m: *mut u8, c: *mut u8, clen: u32, n: *mut u8, k: *mut u8) -> u32;
}
extern "C" {
pub fn Hacl_NaCl_crypto_box_beforenm(k: *mut u8, pk: *mut u8, sk: *mut u8) -> u32;
}
extern "C" {
pub fn Hacl_NaCl_crypto_box_detached_afternm(
c: *mut u8,
tag: *mut u8,
m: *mut u8,
mlen: u32,
n: *mut u8,
k: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_NaCl_crypto_box_detached(
c: *mut u8,
tag: *mut u8,
m: *mut u8,
mlen: u32,
n: *mut u8,
pk: *mut u8,
sk: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_NaCl_crypto_box_open_detached_afternm(
m: *mut u8,
c: *mut u8,
tag: *mut u8,
mlen: u32,
n: *mut u8,
k: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_NaCl_crypto_box_open_detached(
m: *mut u8,
c: *mut u8,
tag: *mut u8,
mlen: u32,
n: *mut u8,
pk: *mut u8,
sk: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_NaCl_crypto_box_easy_afternm(c: *mut u8, m: *mut u8, mlen: u32, n: *mut u8, k: *mut u8) -> u32;
}
extern "C" {
pub fn Hacl_NaCl_crypto_box_easy(c: *mut u8, m: *mut u8, mlen: u32, n: *mut u8, pk: *mut u8, sk: *mut u8) -> u32;
}
extern "C" {
pub fn Hacl_NaCl_crypto_box_open_easy_afternm(m: *mut u8, c: *mut u8, clen: u32, n: *mut u8, k: *mut u8) -> u32;
}
extern "C" {
pub fn Hacl_NaCl_crypto_box_open_easy(
m: *mut u8,
c: *mut u8,
clen: u32,
n: *mut u8,
pk: *mut u8,
sk: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_AES128_aes128_key_expansion(key: *mut u8, expanded_key: *mut u8);
}
extern "C" {
pub fn Hacl_AES128_aes128_encrypt_block(cipher: *mut u16, plain: *mut u16, expanded_key: *mut u8);
}
extern "C" {
pub fn EverCrypt_Cipher_chacha20(len: u32, dst: *mut u8, src: *mut u8, key: *mut u8, iv: *mut u8, ctr: u32);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct Hacl_Streaming_Poly1305_32_poly1305_32_state_s {
pub block_state: *mut u64,
pub buf: *mut u8,
pub total_len: u64,
pub p_key: *mut u8,
}
pub type Hacl_Streaming_Poly1305_32_poly1305_32_state = Hacl_Streaming_Poly1305_32_poly1305_32_state_s;
extern "C" {
pub fn Hacl_Streaming_Poly1305_32_create_in(k: *mut u8) -> *mut Hacl_Streaming_Poly1305_32_poly1305_32_state;
}
extern "C" {
pub fn Hacl_Streaming_Poly1305_32_init(k: *mut u8, s: *mut Hacl_Streaming_Poly1305_32_poly1305_32_state);
}
extern "C" {
pub fn Hacl_Streaming_Poly1305_32_update(
p: *mut Hacl_Streaming_Poly1305_32_poly1305_32_state,
data: *mut u8,
len: u32,
);
}
extern "C" {
pub fn Hacl_Streaming_Poly1305_32_finish(p: *mut Hacl_Streaming_Poly1305_32_poly1305_32_state, dst: *mut u8);
}
extern "C" {
pub fn Hacl_Streaming_Poly1305_32_free(s: *mut Hacl_Streaming_Poly1305_32_poly1305_32_state);
}
extern "C" {
pub fn Hacl_RSAPSS_rsapss_sign(
a: Spec_Hash_Definitions_hash_alg,
modBits: u32,
eBits: u32,
dBits: u32,
skey: *mut u64,
saltLen: u32,
salt: *mut u8,
msgLen: u32,
msg: *mut u8,
sgnt: *mut u8,
) -> bool;
}
extern "C" {
pub fn Hacl_RSAPSS_rsapss_verify(
a: Spec_Hash_Definitions_hash_alg,
modBits: u32,
eBits: u32,
pkey: *mut u64,
saltLen: u32,
sgntLen: u32,
sgnt: *mut u8,
msgLen: u32,
msg: *mut u8,
) -> bool;
}
extern "C" {
pub fn Hacl_RSAPSS_new_rsapss_load_pkey(modBits: u32, eBits: u32, nb: *mut u8, eb: *mut u8) -> *mut u64;
}
extern "C" {
pub fn Hacl_RSAPSS_new_rsapss_load_skey(
modBits: u32,
eBits: u32,
dBits: u32,
nb: *mut u8,
eb: *mut u8,
db: *mut u8,
) -> *mut u64;
}
extern "C" {
pub fn Hacl_RSAPSS_rsapss_skey_sign(
a: Spec_Hash_Definitions_hash_alg,
modBits: u32,
eBits: u32,
dBits: u32,
nb: *mut u8,
eb: *mut u8,
db: *mut u8,
saltLen: u32,
salt: *mut u8,
msgLen: u32,
msg: *mut u8,
sgnt: *mut u8,
) -> bool;
}
extern "C" {
pub fn Hacl_RSAPSS_rsapss_pkey_verify(
a: Spec_Hash_Definitions_hash_alg,
modBits: u32,
eBits: u32,
nb: *mut u8,
eb: *mut u8,
saltLen: u32,
sgntLen: u32,
sgnt: *mut u8,
msgLen: u32,
msg: *mut u8,
) -> bool;
}
extern "C" {
pub fn Hacl_HPKE_Curve51_CP32_SHA256_setupBaseI(
o_pkE: *mut u8,
o_k: *mut u8,
o_n: *mut u8,
skE: *mut u8,
pkR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve51_CP32_SHA256_setupBaseR(
o_key_aead: *mut u8,
o_nonce_aead: *mut u8,
pkE: *mut u8,
skR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve51_CP32_SHA256_sealBase(
skE: *mut u8,
pkR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_Curve51_CP32_SHA256_openBase(
pkE: *mut u8,
skR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HKDF_Blake2s_128_expand_blake2s_128(
okm: *mut u8,
prk: *mut u8,
prklen: u32,
info: *mut u8,
infolen: u32,
len: u32,
);
}
extern "C" {
pub fn Hacl_HKDF_Blake2s_128_extract_blake2s_128(
prk: *mut u8,
salt: *mut u8,
saltlen: u32,
ikm: *mut u8,
ikmlen: u32,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct EverCrypt_AEAD_state_s_s {
_unused: [u8; 0],
}
pub type EverCrypt_AEAD_state_s = EverCrypt_AEAD_state_s_s;
extern "C" {
pub fn EverCrypt_AEAD_uu___is_Ek(a: Spec_Agile_AEAD_alg, projectee: EverCrypt_AEAD_state_s) -> bool;
}
extern "C" {
pub fn EverCrypt_AEAD_alg_of_state(s: *mut EverCrypt_AEAD_state_s) -> Spec_Agile_AEAD_alg;
}
extern "C" {
pub fn EverCrypt_AEAD_create_in(
a: Spec_Agile_AEAD_alg,
dst: *mut *mut EverCrypt_AEAD_state_s,
k: *mut u8,
) -> EverCrypt_Error_error_code;
}
extern "C" {
pub fn EverCrypt_AEAD_encrypt(
s: *mut EverCrypt_AEAD_state_s,
iv: *mut u8,
iv_len: u32,
ad: *mut u8,
ad_len: u32,
plain: *mut u8,
plain_len: u32,
cipher: *mut u8,
tag: *mut u8,
) -> EverCrypt_Error_error_code;
}
extern "C" {
pub fn EverCrypt_AEAD_encrypt_expand_aes128_gcm_no_check(
k: *mut u8,
iv: *mut u8,
iv_len: u32,
ad: *mut u8,
ad_len: u32,
plain: *mut u8,
plain_len: u32,
cipher: *mut u8,
tag: *mut u8,
) -> EverCrypt_Error_error_code;
}
extern "C" {
pub fn EverCrypt_AEAD_encrypt_expand_aes256_gcm_no_check(
k: *mut u8,
iv: *mut u8,
iv_len: u32,
ad: *mut u8,
ad_len: u32,
plain: *mut u8,
plain_len: u32,
cipher: *mut u8,
tag: *mut u8,
) -> EverCrypt_Error_error_code;
}
extern "C" {
pub fn EverCrypt_AEAD_encrypt_expand_aes128_gcm(
k: *mut u8,
iv: *mut u8,
iv_len: u32,
ad: *mut u8,
ad_len: u32,
plain: *mut u8,
plain_len: u32,
cipher: *mut u8,
tag: *mut u8,
) -> EverCrypt_Error_error_code;
}
extern "C" {
pub fn EverCrypt_AEAD_encrypt_expand_aes256_gcm(
k: *mut u8,
iv: *mut u8,
iv_len: u32,
ad: *mut u8,
ad_len: u32,
plain: *mut u8,
plain_len: u32,
cipher: *mut u8,
tag: *mut u8,
) -> EverCrypt_Error_error_code;
}
extern "C" {
pub fn EverCrypt_AEAD_encrypt_expand_chacha20_poly1305(
k: *mut u8,
iv: *mut u8,
iv_len: u32,
ad: *mut u8,
ad_len: u32,
plain: *mut u8,
plain_len: u32,
cipher: *mut u8,
tag: *mut u8,
) -> EverCrypt_Error_error_code;
}
extern "C" {
pub fn EverCrypt_AEAD_encrypt_expand(
a: Spec_Agile_AEAD_alg,
k: *mut u8,
iv: *mut u8,
iv_len: u32,
ad: *mut u8,
ad_len: u32,
plain: *mut u8,
plain_len: u32,
cipher: *mut u8,
tag: *mut u8,
) -> EverCrypt_Error_error_code;
}
extern "C" {
pub fn EverCrypt_AEAD_decrypt(
s: *mut EverCrypt_AEAD_state_s,
iv: *mut u8,
iv_len: u32,
ad: *mut u8,
ad_len: u32,
cipher: *mut u8,
cipher_len: u32,
tag: *mut u8,
dst: *mut u8,
) -> EverCrypt_Error_error_code;
}
extern "C" {
pub fn EverCrypt_AEAD_decrypt_expand_aes128_gcm_no_check(
k: *mut u8,
iv: *mut u8,
iv_len: u32,
ad: *mut u8,
ad_len: u32,
cipher: *mut u8,
cipher_len: u32,
tag: *mut u8,
dst: *mut u8,
) -> EverCrypt_Error_error_code;
}
extern "C" {
pub fn EverCrypt_AEAD_decrypt_expand_aes256_gcm_no_check(
k: *mut u8,
iv: *mut u8,
iv_len: u32,
ad: *mut u8,
ad_len: u32,
cipher: *mut u8,
cipher_len: u32,
tag: *mut u8,
dst: *mut u8,
) -> EverCrypt_Error_error_code;
}
extern "C" {
pub fn EverCrypt_AEAD_decrypt_expand_aes128_gcm(
k: *mut u8,
iv: *mut u8,
iv_len: u32,
ad: *mut u8,
ad_len: u32,
cipher: *mut u8,
cipher_len: u32,
tag: *mut u8,
dst: *mut u8,
) -> EverCrypt_Error_error_code;
}
extern "C" {
pub fn EverCrypt_AEAD_decrypt_expand_aes256_gcm(
k: *mut u8,
iv: *mut u8,
iv_len: u32,
ad: *mut u8,
ad_len: u32,
cipher: *mut u8,
cipher_len: u32,
tag: *mut u8,
dst: *mut u8,
) -> EverCrypt_Error_error_code;
}
extern "C" {
pub fn EverCrypt_AEAD_decrypt_expand_chacha20_poly1305(
k: *mut u8,
iv: *mut u8,
iv_len: u32,
ad: *mut u8,
ad_len: u32,
cipher: *mut u8,
cipher_len: u32,
tag: *mut u8,
dst: *mut u8,
) -> EverCrypt_Error_error_code;
}
extern "C" {
pub fn EverCrypt_AEAD_decrypt_expand(
a: Spec_Agile_AEAD_alg,
k: *mut u8,
iv: *mut u8,
iv_len: u32,
ad: *mut u8,
ad_len: u32,
cipher: *mut u8,
cipher_len: u32,
tag: *mut u8,
dst: *mut u8,
) -> EverCrypt_Error_error_code;
}
extern "C" {
pub fn EverCrypt_AEAD_free(s: *mut EverCrypt_AEAD_state_s);
}
extern "C" {
pub fn Hacl_HPKE_P256_CP256_SHA256_setupBaseI(
o_pkE: *mut u8,
o_k: *mut u8,
o_n: *mut u8,
skE: *mut u8,
pkR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_P256_CP256_SHA256_setupBaseR(
o_key_aead: *mut u8,
o_nonce_aead: *mut u8,
pkE: *mut u8,
skR: *mut u8,
infolen: u32,
info: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_P256_CP256_SHA256_sealBase(
skE: *mut u8,
pkR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_HPKE_P256_CP256_SHA256_openBase(
pkE: *mut u8,
skR: *mut u8,
mlen: u32,
m: *mut u8,
infolen: u32,
info: *mut u8,
output: *mut u8,
) -> u32;
}
extern "C" {
pub fn Hacl_Chacha20_Vec32_chacha20_encrypt_32(
len: u32,
out: *mut u8,
text: *mut u8,
key: *mut u8,
n: *mut u8,
ctr: u32,
);
}
extern "C" {
pub fn Hacl_Chacha20_Vec32_chacha20_decrypt_32(
len: u32,
out: *mut u8,
cipher: *mut u8,
key: *mut u8,
n: *mut u8,
ctr: u32,
);
}
extern "C" {
pub fn Hacl_SHA2_Vec256_sha224_8(
dst0: *mut u8,
dst1: *mut u8,
dst2: *mut u8,
dst3: *mut u8,
dst4: *mut u8,
dst5: *mut u8,
dst6: *mut u8,
dst7: *mut u8,
input_len: u32,
input0: *mut u8,
input1: *mut u8,
input2: *mut u8,
input3: *mut u8,
input4: *mut u8,
input5: *mut u8,
input6: *mut u8,
input7: *mut u8,
);
}
extern "C" {
pub fn Hacl_SHA2_Vec256_sha256_8(
dst0: *mut u8,
dst1: *mut u8,
dst2: *mut u8,
dst3: *mut u8,
dst4: *mut u8,
dst5: *mut u8,
dst6: *mut u8,
dst7: *mut u8,
input_len: u32,
input0: *mut u8,
input1: *mut u8,
input2: *mut u8,
input3: *mut u8,
input4: *mut u8,
input5: *mut u8,
input6: *mut u8,
input7: *mut u8,
);
}
extern "C" {
pub fn Hacl_SHA2_Vec256_sha384_4(
dst0: *mut u8,
dst1: *mut u8,
dst2: *mut u8,
dst3: *mut u8,
input_len: u32,
input0: *mut u8,
input1: *mut u8,
input2: *mut u8,
input3: *mut u8,
);
}
extern "C" {
pub fn Hacl_SHA2_Vec256_sha512_4(
dst0: *mut u8,
dst1: *mut u8,
dst2: *mut u8,
dst3: *mut u8,
input_len: u32,
input0: *mut u8,
input1: *mut u8,
input2: *mut u8,
input3: *mut u8,
);
}
extern "C" {
pub fn Hacl_SHA2_Scalar32_sha224(dst: *mut u8, input_len: u32, input: *mut u8);
}
extern "C" {
pub fn Hacl_SHA2_Scalar32_sha256(dst: *mut u8, input_len: u32, input: *mut u8);
}
extern "C" {
pub fn Hacl_SHA2_Scalar32_sha384(dst: *mut u8, input_len: u32, input: *mut u8);
}
extern "C" {
pub fn Hacl_SHA2_Scalar32_sha512(dst: *mut u8, input_len: u32, input: *mut u8);
}