Replace more casts with safer conversions & enable cast-related lints.

src/error.rs

@@ -94,18 +94,16 @@ impl Error {
     /// [1]: https://doc.rust-lang.org/std/io/struct.Error.html#method.raw_os_error
     #[inline]
     pub fn raw_os_error(self) -> Option<i32> {
-        if self.0.get() < Self::INTERNAL_START {
-            match () {
-                #[cfg(target_os = "solid_asp3")]
+        const _: () = assert!(i32::MAX.unsigned_abs() == Error::INTERNAL_START - 1);
+        i32::try_from(self.0.get()).ok().map(|errno| {
+            if cfg!(target_os = "solid_asp3") {
                 // On SOLID, negate the error code again to obtain the original
                 // error code.
-                () => Some(-(self.0.get() as i32)),
-                #[cfg(not(target_os = "solid_asp3"))]
-                () => Some(self.0.get() as i32),
+                -errno
+            } else {
+                errno
             }
-        } else {
-            None
-        }
+        })
     }
 
     /// Extract the bare error code.

src/hermit.rs

@@ -9,18 +9,14 @@ extern "C" {
 pub fn getrandom_inner(mut dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
     while !dest.is_empty() {
         let res = unsafe { sys_read_entropy(dest.as_mut_ptr().cast::<u8>(), dest.len(), 0) };
-        // Positive `isize`s can be safely casted to `usize`
-        if res > 0 && (res as usize) <= dest.len() {
-            dest = &mut dest[res as usize..];
-        } else {
-            let err = if res < 0 {
-                u32::try_from(res.unsigned_abs())
+        match usize::try_from(res) {
+            Ok(res) if res > 0 => dest = dest.get_mut(res..).ok_or(Error::UNEXPECTED)?,
+            _ => {
+                let err = u32::try_from(res.unsigned_abs())
                     .ok()
-                    .map_or(Error::UNEXPECTED, Error::from_os_error)
-            } else {
-                Error::UNEXPECTED
-            };
-            return Err(err);
+                    .map_or(Error::UNEXPECTED, Error::from_os_error);
+                return Err(err);
+            }
         }
     }
     Ok(())

src/js.rs

@@ -9,7 +9,7 @@ use wasm_bindgen::{prelude::wasm_bindgen, JsCast, JsValue};
 
 // Size of our temporary Uint8Array buffer used with WebCrypto methods
 // Maximum is 65536 bytes see https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues
-const WEB_CRYPTO_BUFFER_SIZE: usize = 256;
+const WEB_CRYPTO_BUFFER_SIZE: u16 = 256;
 // Node.js's crypto.randomFillSync requires the size to be less than 2**31.
 const NODE_MAX_BUFFER_SIZE: usize = (1 << 31) - 1;
 
@@ -50,9 +50,10 @@ pub(crate) fn getrandom_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error>
             RngSource::Web(crypto, buf) => {
                 // getRandomValues does not work with all types of WASM memory,
                 // so we initially write to browser memory to avoid exceptions.
-                for chunk in dest.chunks_mut(WEB_CRYPTO_BUFFER_SIZE) {
+                for chunk in dest.chunks_mut(WEB_CRYPTO_BUFFER_SIZE.into()) {
                     // The chunk can be smaller than buf's length, so we call to
                     // JS to create a smaller view of buf without allocation.
+                    #[allow(clippy::cast_possible_truncation)]
                     let sub_buf = buf.subarray(0, chunk.len() as u32);
 
                     if crypto.get_random_values(&sub_buf).is_err() {
@@ -95,7 +96,7 @@ fn getrandom_init() -> Result<RngSource, Error> {
         },
     };
 
-    let buf = Uint8Array::new_with_length(WEB_CRYPTO_BUFFER_SIZE as u32);
+    let buf = Uint8Array::new_with_length(WEB_CRYPTO_BUFFER_SIZE.into());
     Ok(RngSource::Web(crypto, buf))
 }
 

src/lib.rs

@@ -208,6 +208,24 @@
 #![no_std]
 #![warn(rust_2018_idioms, unused_lifetimes, missing_docs)]
 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![deny(
+    clippy::cast_lossless,
+    clippy::cast_possible_truncation,
+    clippy::cast_possible_wrap,
+    clippy::cast_precision_loss,
+    clippy::cast_ptr_alignment,
+    clippy::cast_sign_loss,
+    clippy::char_lit_as_u8,
+    clippy::checked_conversions,
+    clippy::fn_to_numeric_cast,
+    clippy::fn_to_numeric_cast_with_truncation,
+    clippy::ptr_as_ptr,
+    clippy::unnecessary_cast,
+    clippy::useless_conversion
+)]
+// `clippy::cast_ref_to_mut` was replaced by `invalid_reference_casting` in 1.73.
+#![allow(renamed_and_removed_lints)]
+#![deny(clippy::cast_ref_to_mut)]
 
 #[macro_use]
 extern crate cfg_if;

src/linux_android.rs

@@ -8,12 +8,20 @@ pub fn getrandom_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
 
 // Also used by linux_android_with_fallback to check if the syscall is available.
 pub fn getrandom_syscall(buf: &mut [MaybeUninit<u8>]) -> libc::ssize_t {
-    unsafe {
+    let res: libc::c_long = unsafe {
         libc::syscall(
             libc::SYS_getrandom,
             buf.as_mut_ptr().cast::<core::ffi::c_void>(),
             buf.len(),
             0,
-        ) as libc::ssize_t
-    }
+        )
+    };
+
+    // c_long to ssize_t conversion is lossless.
+    const _: () =
+        assert!(core::mem::size_of::<libc::c_long>() == core::mem::size_of::<libc::ssize_t>());
+    #[allow(clippy::cast_possible_truncation)]
+    let res = res as libc::ssize_t;
+
+    res
 }

src/util_libc.rs

@@ -55,9 +55,9 @@ pub fn sys_fill_exact(
 ) -> Result<(), Error> {
     while !buf.is_empty() {
         let res = sys_fill(buf);
-        match res {
-            res if res > 0 => buf = buf.get_mut(res as usize..).ok_or(Error::UNEXPECTED)?,
-            -1 => {
+        match usize::try_from(res) {
+            Ok(res) if res > 0 => buf = buf.get_mut(res..).ok_or(Error::UNEXPECTED)?,
+            Err(_) if res == -1 => {
                 let err = last_os_error();
                 // We should try again if the call was interrupted.
                 if err.raw_os_error() != Some(libc::EINTR) {

src/windows7.rs

@@ -27,7 +27,9 @@ pub fn getrandom_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
     // Prevent overflow of u32
     let chunk_size = usize::try_from(i32::MAX).expect("Windows does not support 16-bit targets");
     for chunk in dest.chunks_mut(chunk_size) {
-        let ret = unsafe { RtlGenRandom(chunk.as_mut_ptr().cast::<c_void>(), chunk.len() as u32) };
+        #[allow(clippy::cast_possible_truncation)]
+        let chunk_len = chunk.len() as u32;
+        let ret = unsafe { RtlGenRandom(chunk.as_mut_ptr().cast::<c_void>(), chunk_len) };
         if ret != TRUE {
             return Err(Error::WINDOWS_RTL_GEN_RANDOM);
         }