crates.io / num-integer / 0.1.47

num-integer 0.1.47

Source

https://github.com/rust-num/num-integer

Tag scanned

num-integer-0.1.47

Compared with

num-integer-0.1.46 (1 signals introduced since)

Files

12 scanned, 3 skipped (binary, oversized, or unrecognised)

Signals

0 critical · 0 warn · 9 info

Scan time

3.1 s

LLM review

Reviewed by claude-haiku-5-5 (Anthropic): 2 of 2 warn and critical signals; 2 demoted to info.

Disclude version

4.0.0

Scanned (UTC)

2026-10-14 21:19

Signals

Ordered by severity, then signals introduced in this release. Hidden characters are shown as ⟨U+…⟩.

1. info unicode-mixed-script src/roots.rs:207:21 new in this release

   identifier `aᵢ` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

       // Algorithm SqrtRem(n = a₃b³ + a₂b² + a₁b + a₀)
       // Input: 0 ≤ aᵢ < b with a₃ ≥ b/4
       // Output: (s,r) such that s² ≤ n = s² + r < (s+1)²
       debug_assert!(n.leading_zeros() < 2);

2. info warn → info by review ifs-manipulation ci/test_full.sh:16:3

   `IFS` set to `.` — non-standard separator enables word-splitting obfuscation (ast pass, confidence 0.80)

   check_version() {
     IFS=. read -ra rust <<< "$RUST_VERSION"
     IFS=. read -ra want <<< "$1"
     [[ "${rust[0]}" -gt "${want[0]}" ||

   likely benign LLM, confidence 0.95 A bash helper that splits version strings on '.' using IFS-scoped read to compare Rust versions in a CI test script.

   Reasoning

   Setting IFS to '.' for a single read command to split a version string like 1.70.0 into an array is a standard, legitimate bash idiom in CI scripts. The IFS assignment is scoped to the read builtin, is not used for word-splitting of attacker input, and the surrounding code only compares version numbers. Nothing indicates obfuscation or malicious intent.

3. info warn → info by review ifs-manipulation ci/test_full.sh:17:3

   `IFS` set to `.` — non-standard separator enables word-splitting obfuscation (ast pass, confidence 0.80)

     IFS=. read -ra rust <<< "$RUST_VERSION"
     IFS=. read -ra want <<< "$1"
     [[ "${rust[0]}" -gt "${want[0]}" ||
      ( "${rust[0]}" -eq "${want[0]}" &&

   likely benign LLM, confidence 0.95 Second IFS-scoped read in the same CI version-check function, splitting the wanted version for numeric comparison.

   Reasoning

   This is the same version-comparison helper as the adjacent finding, splitting the requested version on '.' via a command-scoped IFS assignment for a numeric comparison. It is a common, legitimate shell pattern with no encoded payload or execution of split data.

4. info unicode-mixed-script src/roots.rs:11:37

   identifier `rⁿ` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

       ///
       /// This is solving for `r` in `rⁿ = x`, rounding toward zero.
       /// If `x` is positive, the result will satisfy `rⁿ ≤ x < (r+1)ⁿ`.
       /// If `x` is negative and `n` is odd, then `(r-1)ⁿ < x ≤ rⁿ`.

5. info unicode-mixed-script src/roots.rs:12:54

   identifier `rⁿ` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

       /// This is solving for `r` in `rⁿ = x`, rounding toward zero.
       /// If `x` is positive, the result will satisfy `rⁿ ≤ x < (r+1)ⁿ`.
       /// If `x` is negative and `n` is odd, then `(r-1)ⁿ < x ≤ rⁿ`.
       ///

6. info unicode-mixed-script src/roots.rs:13:67

   identifier `rⁿ` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

       /// If `x` is positive, the result will satisfy `rⁿ ≤ x < (r+1)ⁿ`.
       /// If `x` is negative and `n` is odd, then `(r-1)ⁿ < x ≤ rⁿ`.
       ///
       /// # Panics

7. info unicode-mixed-script src/roots.rs:265:41

   identifier `hiⁿ` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

                               // 128-bit `checked_mul` also involves division, but we can't always
                               // compute `hiⁿ` without risking overflow.  Try to avoid it though...
                               if hi.next_power_of_two().trailing_zeros() * n >= bits::<$T>() {

8. info unicode-mixed-script tests/roots.rs:14:32

   identifier `rⁿ` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

   ///
   /// If `x` is positive, check `rⁿ ≤ x < (r+1)ⁿ`.
   /// If `x` is negative, check `(r-1)ⁿ < x ≤ rⁿ`.
   fn check<T>(v: &[T], n: u32)

9. info unicode-mixed-script tests/roots.rs:15:49

   identifier `rⁿ` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

   /// If `x` is positive, check `rⁿ ≤ x < (r+1)ⁿ`.
   /// If `x` is negative, check `(r-1)ⁿ < x ≤ rⁿ`.
   fn check<T>(v: &[T], n: u32)
   where

Reproduce This Scan

Run disclude locally to verify. Add --format sarif for SARIF output. Add --llm (with an API key in the environment) to include the LLM review.

cargo install disclude --version 4.0.0
git clone https://github.com/rust-num/num-integer num-integer && cd num-integer
git checkout num-integer-0.1.47
disclude scan --severity info --diff num-integer-0.1.46 .