yescrypt: enable clippy::cast_possible_truncation (#704)

Fixes offenses, either by masking to show that truncation is expected,
using `TryFrom` and `?` to convert to `Error::Internal` if the
conversion fails, or starting with a narrower type and widening instead
of trying to go the other direction.

Author: tarcieri

yescrypt/src/encoding.rs

@@ -12,9 +12,9 @@ static ITOA64: &[u8] = b"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopq
 /// Reverse lookup table for (s)crypt-flavored Base64 alphabet.
 pub const ATOI64: [u8; 128] = {
     let mut tbl = [0xFFu8; 128]; // use 0xFF as a placeholder for invalid chars
-    let mut i = 0;
+    let mut i = 0u8;
     while i < 64 {
-        tbl[ITOA64[i] as usize] = i as u8;
+        tbl[ITOA64[i as usize] as usize] = i;
         i += 1;
     }
     tbl
@@ -47,7 +47,7 @@ pub(crate) fn decode64<'o>(src: &str, dst: &'o mut [u8]) -> Result<&'o [u8]> {
         }
 
         while pos < dst.len() {
-            dst[pos] = value as u8;
+            dst[pos] = (value & 0xFF) as u8;
             pos += 1;
             value >>= 8;
             bits -= 8;

yescrypt/src/lib.rs

@@ -8,7 +8,7 @@
 #![deny(unsafe_code)]
 #![warn(
     clippy::cast_lossless,
-    // TODO: clippy::cast_possible_truncation,
+    clippy::cast_possible_truncation,
     clippy::cast_possible_wrap,
     clippy::cast_precision_loss,
     clippy::cast_sign_loss,
@@ -172,9 +172,10 @@ pub fn yescrypt_verify(passwd: &[u8], hash: &str) -> Result<()> {
 
 /// yescrypt Key Derivation Function (KDF)
 pub fn yescrypt_kdf(passwd: &[u8], salt: &[u8], params: &Params, out: &mut [u8]) -> Result<()> {
-    // Perform conditional pre-hashing
     let mut passwd = passwd;
     let mut dk = [0u8; 32];
+
+    // Conditionally perform pre-hashing
     if params.mode.is_rw()
         && params.p >= 1
         && params.n / u64::from(params.p) >= 0x100
@@ -185,7 +186,7 @@ pub fn yescrypt_kdf(passwd: &[u8], salt: &[u8], params: &Params, out: &mut [u8])
         prehash_params.t = 0;
         yescrypt_kdf_body(passwd, salt, &prehash_params, true, &mut dk)?;
 
-        // Use derived key as the "password" for the subsequent step
+        // Use derived key as the "password" for the subsequent step when pre-hashing
         passwd = &dk;
     }
 
@@ -215,7 +216,7 @@ fn yescrypt_kdf_body(
         return Err(Error::Params);
     }
 
-    let mut v = vec![0; 32 * (r as usize) * (n as usize)];
+    let mut v = vec![0; 32 * (r as usize) * usize::try_from(n)?];
     let mut b = vec![0; 32 * (r as usize) * (p as usize)];
     let mut xy = vec![0; 64 * (r as usize)];
 

yescrypt/src/params.rs

@@ -82,7 +82,7 @@ impl Params {
 
         if mode.is_rw()
             && (n / u64::from(p) <= 1
-                || r < RMIN as u32
+                || r < RMIN
                 || u64::from(p) > u64::MAX / (3 * (1 << 8) * 2 * 8)
                 || u64::from(p) > u64::MAX / (size_of::<PwxformCtx<'_>>() as u64))
         {

yescrypt/src/pwxform.rs

@@ -8,6 +8,7 @@ use crate::{
     salsa20,
     util::{slice_as_chunks_mut, xor},
 };
+use core::mem;
 
 /// Number of 64-bit lanes per "simple SIMD" lane (requiring only arithmetic and bitwise operations
 /// on its 64-bit elements). Must be a power of 2.
@@ -31,7 +32,9 @@ const PWXWORDS: usize = PWXBYTES / size_of::<u32>();
 const SMASK: usize = ((1 << SWIDTH) - 1) * PWXSIMPLE * 8;
 pub(crate) const SBYTES: usize = 3 * (1 << SWIDTH) * PWXSIMPLE * 8;
 pub(crate) const SWORDS: usize = SBYTES / size_of::<u32>();
-pub(crate) const RMIN: usize = PWXBYTES.div_ceil(128);
+
+#[allow(clippy::cast_possible_truncation)]
+pub(crate) const RMIN: u32 = PWXBYTES.div_ceil(128) as u32;
 
 /// Parallel wide transformation (pwxform) context.
 pub(crate) struct PwxformCtx<'a> {
@@ -128,23 +131,25 @@ impl PwxformCtx<'_> {
                     x = x.wrapping_add(s0);
                     x ^= s1;
 
-                    xptr[j][k][0] = x as u32;
-                    xptr[j][k][1] = (x >> 32) as u32;
+                    let x_lo = (x & 0xFFFF_FFFF) as u32;
+                    let x_hi = ((x >> 32) & 0xFFFF_FFFF) as u32;
+                    xptr[j][k][0] = x_lo;
+                    xptr[j][k][1] = x_hi;
 
                     // 8: if (i != 0) and (i != PWXrounds - 1)
                     if i != 0 && i != (PWXROUNDS - 1) {
                         // 9: S2_w <-- B_j
-                        self.s2[w][0] = x as u32;
-                        self.s2[w][1] = (x >> 32) as u32;
+                        self.s2[w][0] = x_lo;
+                        self.s2[w][1] = x_hi;
                         w += 1;
                     }
                 }
             }
         }
 
         // 14: (S0, S1, S2) <-- (S2, S0, S1)
-        core::mem::swap(&mut self.s0, &mut self.s2);
-        core::mem::swap(&mut self.s1, &mut self.s2);
+        mem::swap(&mut self.s0, &mut self.s2);
+        mem::swap(&mut self.s1, &mut self.s2);
 
         // 15: w <-- w mod 2^Swidth
         self.w = w & ((1 << SWIDTH) * PWXSIMPLE - 1);

yescrypt/src/smix.rs

@@ -69,7 +69,6 @@ pub(crate) fn smix(
     // 10: Nloop_rw <-- Nloop_rw + (Nloop_rw mod 2)
     nloop_rw += 1;
     nloop_rw &= !1; // round up to even
-    let mut vchunk = 0;
 
     // S_n = [S_i for i in 0..p]
     let mut sn = if mode.is_rw() {
@@ -80,6 +79,8 @@ pub(crate) fn smix(
     let mut ctxs = Vec::with_capacity(sn.len());
     let mut sn = sn.iter_mut();
 
+    let mut vchunk = 0;
+
     // 11: for i = 0 to p - 1 do
     // 12: u <-- in
     #[allow(clippy::needless_range_loop)]
@@ -95,7 +96,7 @@ pub(crate) fn smix(
         };
 
         let bs = &mut b[(i * s)..];
-        let vp = &mut v[vchunk as usize * s..];
+        let vp = &mut v[(usize::try_from(vchunk)? * s)..];
 
         // 17: if YESCRYPT_RW flag is set
         let mut ctx_i = if mode.is_rw() {
@@ -216,7 +217,7 @@ fn smix1(
     // 2: for i = 0 to N - 1 do
     for i in 0..n {
         // 3: V_i <-- X
-        v[i as usize * s..][..s].copy_from_slice(x);
+        v[(usize::try_from(i)? * s)..][..s].copy_from_slice(x);
         if mode.is_rw() && i > 1 {
             let n = prev_power_of_two(i);
             let j = usize::try_from((integerify(x, r) & (n - 1)) + (i - n))?;