diff --git a/libs/bssl/src/aead.rs b/libs/bssl/src/aead.rs
index 1ac2c22..9aa1885 100644
--- a/libs/bssl/src/aead.rs
+++ b/libs/bssl/src/aead.rs
@@ -16,7 +16,7 @@
 
 use crate::util::{check_int_result, to_call_failed_error};
 use bssl_avf_error::{ApiName, Result};
-use bssl_ffi::{
+use bssl_sys::{
     EVP_AEAD_CTX_free, EVP_AEAD_CTX_new, EVP_AEAD_CTX_open, EVP_AEAD_CTX_seal,
     EVP_AEAD_max_overhead, EVP_AEAD_nonce_length, EVP_aead_aes_256_gcm,
     EVP_aead_aes_256_gcm_randnonce, EVP_AEAD, EVP_AEAD_CTX, EVP_AEAD_DEFAULT_TAG_LENGTH,
diff --git a/libs/bssl/src/cbb.rs b/libs/bssl/src/cbb.rs
index 9b5f7fe..a48c714 100644
--- a/libs/bssl/src/cbb.rs
+++ b/libs/bssl/src/cbb.rs
@@ -14,7 +14,7 @@
 
 //! Helpers for using BoringSSL CBB (crypto byte builder) objects.
 
-use bssl_ffi::{CBB_init_fixed, CBB};
+use bssl_sys::{CBB_init_fixed, CBB};
 use core::marker::PhantomData;
 use core::mem::MaybeUninit;
 
diff --git a/libs/bssl/src/cbs.rs b/libs/bssl/src/cbs.rs
index 9718903..12671cf 100644
--- a/libs/bssl/src/cbs.rs
+++ b/libs/bssl/src/cbs.rs
@@ -14,7 +14,7 @@
 
 //! Helpers for using BoringSSL CBS (crypto byte string) objects.
 
-use bssl_ffi::{CBS_init, CBS};
+use bssl_sys::{CBS_init, CBS};
 use core::marker::PhantomData;
 use core::mem::MaybeUninit;
 
diff --git a/libs/bssl/src/curve25519.rs b/libs/bssl/src/curve25519.rs
index 499a3d0..4c1c398 100644
--- a/libs/bssl/src/curve25519.rs
+++ b/libs/bssl/src/curve25519.rs
@@ -17,8 +17,8 @@
 use crate::util::check_int_result;
 use bssl_avf_error::{ApiName, Result};
 
-const ED25519_PUBLIC_KEY_LEN: usize = bssl_ffi::ED25519_PUBLIC_KEY_LEN as usize;
-const ED25519_SIGNATURE_LEN: usize = bssl_ffi::ED25519_SIGNATURE_LEN as usize;
+const ED25519_PUBLIC_KEY_LEN: usize = bssl_sys::ED25519_PUBLIC_KEY_LEN as usize;
+const ED25519_SIGNATURE_LEN: usize = bssl_sys::ED25519_SIGNATURE_LEN as usize;
 
 /// Verifies the signature of a message with the given ED25519 public key.
 pub fn ed25519_verify(
@@ -28,7 +28,7 @@
 ) -> Result<()> {
     // SAFETY: The function only reads the parameters within their bounds.
     let ret = unsafe {
-        bssl_ffi::ED25519_verify(
+        bssl_sys::ED25519_verify(
             message.as_ptr(),
             message.len(),
             signature.as_ptr(),
diff --git a/libs/bssl/src/digest.rs b/libs/bssl/src/digest.rs
index e986a38..8a51b11 100644
--- a/libs/bssl/src/digest.rs
+++ b/libs/bssl/src/digest.rs
@@ -18,7 +18,7 @@
 use alloc::vec;
 use alloc::vec::Vec;
 use bssl_avf_error::{ApiName, Error, Result};
-use bssl_ffi::{
+use bssl_sys::{
     EVP_Digest, EVP_MD_CTX_free, EVP_MD_CTX_new, EVP_MD_size, EVP_sha256, EVP_sha384, EVP_sha512,
     EVP_MAX_MD_SIZE, EVP_MD, EVP_MD_CTX,
 };
diff --git a/libs/bssl/src/ec_key.rs b/libs/bssl/src/ec_key.rs
index 894934d..6c9910c 100644
--- a/libs/bssl/src/ec_key.rs
+++ b/libs/bssl/src/ec_key.rs
@@ -21,7 +21,7 @@
 use alloc::vec;
 use alloc::vec::Vec;
 use bssl_avf_error::{ApiName, Error, Result};
-use bssl_ffi::{
+use bssl_sys::{
     BN_bin2bn, BN_bn2bin_padded, BN_clear_free, BN_new, CBB_flush, CBB_len, ECDSA_sign, ECDSA_size,
     ECDSA_verify, EC_GROUP_get_curve_name, EC_GROUP_new_by_curve_name, EC_KEY_check_key,
     EC_KEY_free, EC_KEY_generate_key, EC_KEY_get0_group, EC_KEY_get0_public_key,
diff --git a/libs/bssl/src/err.rs b/libs/bssl/src/err.rs
index 7040441..60bab98 100644
--- a/libs/bssl/src/err.rs
+++ b/libs/bssl/src/err.rs
@@ -15,7 +15,7 @@
 //! Wrappers of the error handling functions in BoringSSL err.h.
 
 use bssl_avf_error::{CipherError, EcError, EcdsaError, GlobalError, ReasonCode};
-use bssl_ffi::{self, ERR_get_error, ERR_GET_LIB_RUST, ERR_GET_REASON_RUST};
+use bssl_sys::{self, ERR_get_error, ERR_GET_LIB_RUST, ERR_GET_REASON_RUST};
 
 const NO_ERROR_REASON_CODE: i32 = 0;
 
@@ -61,12 +61,12 @@
 /// Global errors may occur in any library.
 fn map_global_reason_code(reason: i32) -> Option<GlobalError> {
     let reason = match reason {
-        bssl_ffi::ERR_R_FATAL => GlobalError::Fatal,
-        bssl_ffi::ERR_R_MALLOC_FAILURE => GlobalError::MallocFailure,
-        bssl_ffi::ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED => GlobalError::ShouldNotHaveBeenCalled,
-        bssl_ffi::ERR_R_PASSED_NULL_PARAMETER => GlobalError::PassedNullParameter,
-        bssl_ffi::ERR_R_INTERNAL_ERROR => GlobalError::InternalError,
-        bssl_ffi::ERR_R_OVERFLOW => GlobalError::Overflow,
+        bssl_sys::ERR_R_FATAL => GlobalError::Fatal,
+        bssl_sys::ERR_R_MALLOC_FAILURE => GlobalError::MallocFailure,
+        bssl_sys::ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED => GlobalError::ShouldNotHaveBeenCalled,
+        bssl_sys::ERR_R_PASSED_NULL_PARAMETER => GlobalError::PassedNullParameter,
+        bssl_sys::ERR_R_INTERNAL_ERROR => GlobalError::InternalError,
+        bssl_sys::ERR_R_OVERFLOW => GlobalError::Overflow,
         _ => return None,
     };
     Some(reason)
@@ -74,40 +74,40 @@
 
 fn map_library_reason_code(reason: i32, lib: i32) -> Option<ReasonCode> {
     u32::try_from(lib).ok().and_then(|x| match x {
-        bssl_ffi::ERR_LIB_CIPHER => map_cipher_reason_code(reason).map(ReasonCode::Cipher),
-        bssl_ffi::ERR_LIB_EC => map_ec_reason_code(reason).map(ReasonCode::Ec),
-        bssl_ffi::ERR_LIB_ECDSA => map_ecdsa_reason_code(reason).map(ReasonCode::Ecdsa),
+        bssl_sys::ERR_LIB_CIPHER => map_cipher_reason_code(reason).map(ReasonCode::Cipher),
+        bssl_sys::ERR_LIB_EC => map_ec_reason_code(reason).map(ReasonCode::Ec),
+        bssl_sys::ERR_LIB_ECDSA => map_ecdsa_reason_code(reason).map(ReasonCode::Ecdsa),
         _ => None,
     })
 }
 
 fn map_cipher_reason_code(reason: i32) -> Option<CipherError> {
     let error = match reason {
-        bssl_ffi::CIPHER_R_AES_KEY_SETUP_FAILED => CipherError::AesKeySetupFailed,
-        bssl_ffi::CIPHER_R_BAD_DECRYPT => CipherError::BadDecrypt,
-        bssl_ffi::CIPHER_R_BAD_KEY_LENGTH => CipherError::BadKeyLength,
-        bssl_ffi::CIPHER_R_BUFFER_TOO_SMALL => CipherError::BufferTooSmall,
-        bssl_ffi::CIPHER_R_CTRL_NOT_IMPLEMENTED => CipherError::CtrlNotImplemented,
-        bssl_ffi::CIPHER_R_CTRL_OPERATION_NOT_IMPLEMENTED => {
+        bssl_sys::CIPHER_R_AES_KEY_SETUP_FAILED => CipherError::AesKeySetupFailed,
+        bssl_sys::CIPHER_R_BAD_DECRYPT => CipherError::BadDecrypt,
+        bssl_sys::CIPHER_R_BAD_KEY_LENGTH => CipherError::BadKeyLength,
+        bssl_sys::CIPHER_R_BUFFER_TOO_SMALL => CipherError::BufferTooSmall,
+        bssl_sys::CIPHER_R_CTRL_NOT_IMPLEMENTED => CipherError::CtrlNotImplemented,
+        bssl_sys::CIPHER_R_CTRL_OPERATION_NOT_IMPLEMENTED => {
             CipherError::CtrlOperationNotImplemented
         }
-        bssl_ffi::CIPHER_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH => {
+        bssl_sys::CIPHER_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH => {
             CipherError::DataNotMultipleOfBlockLength
         }
-        bssl_ffi::CIPHER_R_INITIALIZATION_ERROR => CipherError::InitializationError,
-        bssl_ffi::CIPHER_R_INPUT_NOT_INITIALIZED => CipherError::InputNotInitialized,
-        bssl_ffi::CIPHER_R_INVALID_AD_SIZE => CipherError::InvalidAdSize,
-        bssl_ffi::CIPHER_R_INVALID_KEY_LENGTH => CipherError::InvalidKeyLength,
-        bssl_ffi::CIPHER_R_INVALID_NONCE_SIZE => CipherError::InvalidNonceSize,
-        bssl_ffi::CIPHER_R_INVALID_OPERATION => CipherError::InvalidOperation,
-        bssl_ffi::CIPHER_R_IV_TOO_LARGE => CipherError::IvTooLarge,
-        bssl_ffi::CIPHER_R_NO_CIPHER_SET => CipherError::NoCipherSet,
-        bssl_ffi::CIPHER_R_OUTPUT_ALIASES_INPUT => CipherError::OutputAliasesInput,
-        bssl_ffi::CIPHER_R_TAG_TOO_LARGE => CipherError::TagTooLarge,
-        bssl_ffi::CIPHER_R_TOO_LARGE => CipherError::TooLarge,
-        bssl_ffi::CIPHER_R_WRONG_FINAL_BLOCK_LENGTH => CipherError::WrongFinalBlockLength,
-        bssl_ffi::CIPHER_R_NO_DIRECTION_SET => CipherError::NoDirectionSet,
-        bssl_ffi::CIPHER_R_INVALID_NONCE => CipherError::InvalidNonce,
+        bssl_sys::CIPHER_R_INITIALIZATION_ERROR => CipherError::InitializationError,
+        bssl_sys::CIPHER_R_INPUT_NOT_INITIALIZED => CipherError::InputNotInitialized,
+        bssl_sys::CIPHER_R_INVALID_AD_SIZE => CipherError::InvalidAdSize,
+        bssl_sys::CIPHER_R_INVALID_KEY_LENGTH => CipherError::InvalidKeyLength,
+        bssl_sys::CIPHER_R_INVALID_NONCE_SIZE => CipherError::InvalidNonceSize,
+        bssl_sys::CIPHER_R_INVALID_OPERATION => CipherError::InvalidOperation,
+        bssl_sys::CIPHER_R_IV_TOO_LARGE => CipherError::IvTooLarge,
+        bssl_sys::CIPHER_R_NO_CIPHER_SET => CipherError::NoCipherSet,
+        bssl_sys::CIPHER_R_OUTPUT_ALIASES_INPUT => CipherError::OutputAliasesInput,
+        bssl_sys::CIPHER_R_TAG_TOO_LARGE => CipherError::TagTooLarge,
+        bssl_sys::CIPHER_R_TOO_LARGE => CipherError::TooLarge,
+        bssl_sys::CIPHER_R_WRONG_FINAL_BLOCK_LENGTH => CipherError::WrongFinalBlockLength,
+        bssl_sys::CIPHER_R_NO_DIRECTION_SET => CipherError::NoDirectionSet,
+        bssl_sys::CIPHER_R_INVALID_NONCE => CipherError::InvalidNonce,
         _ => return None,
     };
     Some(error)
@@ -115,40 +115,40 @@
 
 fn map_ec_reason_code(reason: i32) -> Option<EcError> {
     let error = match reason {
-        bssl_ffi::EC_R_BUFFER_TOO_SMALL => EcError::BufferTooSmall,
-        bssl_ffi::EC_R_COORDINATES_OUT_OF_RANGE => EcError::CoordinatesOutOfRange,
-        bssl_ffi::EC_R_D2I_ECPKPARAMETERS_FAILURE => EcError::D2IEcpkparametersFailure,
-        bssl_ffi::EC_R_EC_GROUP_NEW_BY_NAME_FAILURE => EcError::EcGroupNewByNameFailure,
-        bssl_ffi::EC_R_GROUP2PKPARAMETERS_FAILURE => EcError::Group2PkparametersFailure,
-        bssl_ffi::EC_R_I2D_ECPKPARAMETERS_FAILURE => EcError::I2DEcpkparametersFailure,
-        bssl_ffi::EC_R_INCOMPATIBLE_OBJECTS => EcError::IncompatibleObjects,
-        bssl_ffi::EC_R_INVALID_COMPRESSED_POINT => EcError::InvalidCompressedPoint,
-        bssl_ffi::EC_R_INVALID_COMPRESSION_BIT => EcError::InvalidCompressionBit,
-        bssl_ffi::EC_R_INVALID_ENCODING => EcError::InvalidEncoding,
-        bssl_ffi::EC_R_INVALID_FIELD => EcError::InvalidField,
-        bssl_ffi::EC_R_INVALID_FORM => EcError::InvalidForm,
-        bssl_ffi::EC_R_INVALID_GROUP_ORDER => EcError::InvalidGroupOrder,
-        bssl_ffi::EC_R_INVALID_PRIVATE_KEY => EcError::InvalidPrivateKey,
-        bssl_ffi::EC_R_MISSING_PARAMETERS => EcError::MissingParameters,
-        bssl_ffi::EC_R_MISSING_PRIVATE_KEY => EcError::MissingPrivateKey,
-        bssl_ffi::EC_R_NON_NAMED_CURVE => EcError::NonNamedCurve,
-        bssl_ffi::EC_R_NOT_INITIALIZED => EcError::NotInitialized,
-        bssl_ffi::EC_R_PKPARAMETERS2GROUP_FAILURE => EcError::Pkparameters2GroupFailure,
-        bssl_ffi::EC_R_POINT_AT_INFINITY => EcError::PointAtInfinity,
-        bssl_ffi::EC_R_POINT_IS_NOT_ON_CURVE => EcError::PointIsNotOnCurve,
-        bssl_ffi::EC_R_SLOT_FULL => EcError::SlotFull,
-        bssl_ffi::EC_R_UNDEFINED_GENERATOR => EcError::UndefinedGenerator,
-        bssl_ffi::EC_R_UNKNOWN_GROUP => EcError::UnknownGroup,
-        bssl_ffi::EC_R_UNKNOWN_ORDER => EcError::UnknownOrder,
-        bssl_ffi::EC_R_WRONG_ORDER => EcError::WrongOrder,
-        bssl_ffi::EC_R_BIGNUM_OUT_OF_RANGE => EcError::BignumOutOfRange,
-        bssl_ffi::EC_R_WRONG_CURVE_PARAMETERS => EcError::WrongCurveParameters,
-        bssl_ffi::EC_R_DECODE_ERROR => EcError::DecodeError,
-        bssl_ffi::EC_R_ENCODE_ERROR => EcError::EncodeError,
-        bssl_ffi::EC_R_GROUP_MISMATCH => EcError::GroupMismatch,
-        bssl_ffi::EC_R_INVALID_COFACTOR => EcError::InvalidCofactor,
-        bssl_ffi::EC_R_PUBLIC_KEY_VALIDATION_FAILED => EcError::PublicKeyValidationFailed,
-        bssl_ffi::EC_R_INVALID_SCALAR => EcError::InvalidScalar,
+        bssl_sys::EC_R_BUFFER_TOO_SMALL => EcError::BufferTooSmall,
+        bssl_sys::EC_R_COORDINATES_OUT_OF_RANGE => EcError::CoordinatesOutOfRange,
+        bssl_sys::EC_R_D2I_ECPKPARAMETERS_FAILURE => EcError::D2IEcpkparametersFailure,
+        bssl_sys::EC_R_EC_GROUP_NEW_BY_NAME_FAILURE => EcError::EcGroupNewByNameFailure,
+        bssl_sys::EC_R_GROUP2PKPARAMETERS_FAILURE => EcError::Group2PkparametersFailure,
+        bssl_sys::EC_R_I2D_ECPKPARAMETERS_FAILURE => EcError::I2DEcpkparametersFailure,
+        bssl_sys::EC_R_INCOMPATIBLE_OBJECTS => EcError::IncompatibleObjects,
+        bssl_sys::EC_R_INVALID_COMPRESSED_POINT => EcError::InvalidCompressedPoint,
+        bssl_sys::EC_R_INVALID_COMPRESSION_BIT => EcError::InvalidCompressionBit,
+        bssl_sys::EC_R_INVALID_ENCODING => EcError::InvalidEncoding,
+        bssl_sys::EC_R_INVALID_FIELD => EcError::InvalidField,
+        bssl_sys::EC_R_INVALID_FORM => EcError::InvalidForm,
+        bssl_sys::EC_R_INVALID_GROUP_ORDER => EcError::InvalidGroupOrder,
+        bssl_sys::EC_R_INVALID_PRIVATE_KEY => EcError::InvalidPrivateKey,
+        bssl_sys::EC_R_MISSING_PARAMETERS => EcError::MissingParameters,
+        bssl_sys::EC_R_MISSING_PRIVATE_KEY => EcError::MissingPrivateKey,
+        bssl_sys::EC_R_NON_NAMED_CURVE => EcError::NonNamedCurve,
+        bssl_sys::EC_R_NOT_INITIALIZED => EcError::NotInitialized,
+        bssl_sys::EC_R_PKPARAMETERS2GROUP_FAILURE => EcError::Pkparameters2GroupFailure,
+        bssl_sys::EC_R_POINT_AT_INFINITY => EcError::PointAtInfinity,
+        bssl_sys::EC_R_POINT_IS_NOT_ON_CURVE => EcError::PointIsNotOnCurve,
+        bssl_sys::EC_R_SLOT_FULL => EcError::SlotFull,
+        bssl_sys::EC_R_UNDEFINED_GENERATOR => EcError::UndefinedGenerator,
+        bssl_sys::EC_R_UNKNOWN_GROUP => EcError::UnknownGroup,
+        bssl_sys::EC_R_UNKNOWN_ORDER => EcError::UnknownOrder,
+        bssl_sys::EC_R_WRONG_ORDER => EcError::WrongOrder,
+        bssl_sys::EC_R_BIGNUM_OUT_OF_RANGE => EcError::BignumOutOfRange,
+        bssl_sys::EC_R_WRONG_CURVE_PARAMETERS => EcError::WrongCurveParameters,
+        bssl_sys::EC_R_DECODE_ERROR => EcError::DecodeError,
+        bssl_sys::EC_R_ENCODE_ERROR => EcError::EncodeError,
+        bssl_sys::EC_R_GROUP_MISMATCH => EcError::GroupMismatch,
+        bssl_sys::EC_R_INVALID_COFACTOR => EcError::InvalidCofactor,
+        bssl_sys::EC_R_PUBLIC_KEY_VALIDATION_FAILED => EcError::PublicKeyValidationFailed,
+        bssl_sys::EC_R_INVALID_SCALAR => EcError::InvalidScalar,
         _ => return None,
     };
     Some(error)
@@ -156,15 +156,15 @@
 
 fn map_ecdsa_reason_code(reason: i32) -> Option<EcdsaError> {
     let error = match reason {
-        bssl_ffi::ECDSA_R_BAD_SIGNATURE => EcdsaError::BadSignature,
-        bssl_ffi::ECDSA_R_MISSING_PARAMETERS => EcdsaError::MissingParameters,
-        bssl_ffi::ECDSA_R_NEED_NEW_SETUP_VALUES => EcdsaError::NeedNewSetupValues,
-        bssl_ffi::ECDSA_R_NOT_IMPLEMENTED => EcdsaError::NotImplemented,
-        bssl_ffi::ECDSA_R_RANDOM_NUMBER_GENERATION_FAILED => {
+        bssl_sys::ECDSA_R_BAD_SIGNATURE => EcdsaError::BadSignature,
+        bssl_sys::ECDSA_R_MISSING_PARAMETERS => EcdsaError::MissingParameters,
+        bssl_sys::ECDSA_R_NEED_NEW_SETUP_VALUES => EcdsaError::NeedNewSetupValues,
+        bssl_sys::ECDSA_R_NOT_IMPLEMENTED => EcdsaError::NotImplemented,
+        bssl_sys::ECDSA_R_RANDOM_NUMBER_GENERATION_FAILED => {
             EcdsaError::RandomNumberGenerationFailed
         }
-        bssl_ffi::ECDSA_R_ENCODE_ERROR => EcdsaError::EncodeError,
-        bssl_ffi::ECDSA_R_TOO_MANY_ITERATIONS => EcdsaError::TooManyIterations,
+        bssl_sys::ECDSA_R_ENCODE_ERROR => EcdsaError::EncodeError,
+        bssl_sys::ECDSA_R_TOO_MANY_ITERATIONS => EcdsaError::TooManyIterations,
         _ => return None,
     };
     Some(error)
diff --git a/libs/bssl/src/evp.rs b/libs/bssl/src/evp.rs
index fe3d88e..fca189c 100644
--- a/libs/bssl/src/evp.rs
+++ b/libs/bssl/src/evp.rs
@@ -20,7 +20,7 @@
 use crate::util::{check_int_result, to_call_failed_error};
 use alloc::vec::Vec;
 use bssl_avf_error::{ApiName, Error, Result};
-use bssl_ffi::{
+use bssl_sys::{
     CBB_flush, CBB_len, EVP_DigestVerify, EVP_DigestVerifyInit, EVP_PKEY_free, EVP_PKEY_new,
     EVP_PKEY_new_raw_public_key, EVP_PKEY_set1_EC_KEY, EVP_marshal_public_key, EVP_PKEY,
     EVP_PKEY_ED25519, EVP_PKEY_X25519,
diff --git a/libs/bssl/src/hkdf.rs b/libs/bssl/src/hkdf.rs
index 85bd1ff..d5aeb76 100644
--- a/libs/bssl/src/hkdf.rs
+++ b/libs/bssl/src/hkdf.rs
@@ -17,7 +17,7 @@
 use crate::digest::Digester;
 use crate::util::check_int_result;
 use bssl_avf_error::{ApiName, Result};
-use bssl_ffi::HKDF;
+use bssl_sys::HKDF;
 use zeroize::Zeroizing;
 
 /// Computes HKDF (as specified by [RFC 5869]) of initial keying material `secret` with
diff --git a/libs/bssl/src/hmac.rs b/libs/bssl/src/hmac.rs
index 1b3a403..f820285 100644
--- a/libs/bssl/src/hmac.rs
+++ b/libs/bssl/src/hmac.rs
@@ -18,7 +18,7 @@
 use crate::sha::SHA256_DIGEST_LENGTH;
 use crate::util::to_call_failed_error;
 use bssl_avf_error::{ApiName, Result};
-use bssl_ffi::HMAC;
+use bssl_sys::HMAC;
 
 /// Computes the HMAC using SHA-256 for the given `data` with the given `key`.
 pub fn hmac_sha256(key: &[u8], data: &[u8]) -> Result<[u8; SHA256_DIGEST_LENGTH]> {
diff --git a/libs/bssl/src/rand.rs b/libs/bssl/src/rand.rs
index 9343284..e1b3ebe 100644
--- a/libs/bssl/src/rand.rs
+++ b/libs/bssl/src/rand.rs
@@ -16,7 +16,7 @@
 
 use crate::util::check_int_result;
 use bssl_avf_error::{ApiName, Result};
-use bssl_ffi::RAND_bytes;
+use bssl_sys::RAND_bytes;
 
 /// Fills the given `dest` with random data.
 pub fn rand_bytes(dest: &mut [u8]) -> Result<()> {
diff --git a/libs/bssl/src/sha.rs b/libs/bssl/src/sha.rs
index 6c65d7f..66b4a7c 100644
--- a/libs/bssl/src/sha.rs
+++ b/libs/bssl/src/sha.rs
@@ -16,10 +16,10 @@
 
 use crate::util::to_call_failed_error;
 use bssl_avf_error::{ApiName, Result};
-use bssl_ffi::SHA256;
+use bssl_sys::SHA256;
 
 /// The length of a SHA256 digest.
-pub(crate) const SHA256_DIGEST_LENGTH: usize = bssl_ffi::SHA256_DIGEST_LENGTH as usize;
+pub(crate) const SHA256_DIGEST_LENGTH: usize = bssl_sys::SHA256_DIGEST_LENGTH as usize;
 
 /// Computes the SHA256 digest of the provided `data``.
 pub fn sha256(data: &[u8]) -> Result<[u8; SHA256_DIGEST_LENGTH]> {