base64 0.23.1

Source: https://github.com/marshallpierce/rust-base64
Tag scanned: v0.23.1
Compared with: v0.23.0 (0 signals introduced since)
Files: 33 scanned, 8 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 0 warn · 9 info
Scan time: 7.8 s
LLM review: Reviewed by claude-haiku-5-5 (Anthropic): 9 of 9 warn and critical signals; 9 demoted to info.
Disclude version: 4.0.0
Scanned (UTC): 2026-10-14 20:13

Signals

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

info ~~warn~~ → info by review encoding-base64 src/chunked_encoder.rs:100:14

base64-like blob (48 bytes, compression ratio 1.23) (raw pass, confidence 0.60)
```
        assert_eq!(
            "Zm9vYmFyYmF6cXV4cXV1eGNvcmdlZ3JhdWx0Z2FycGx5eg==",
            chunked_encode_str(b"foobarbazquxquuxcorgegraultgarplyz", PAD)
        );
```
likely benign LLM, confidence 0.95 A base64 test vector asserted against chunked_encode_str output in a base64 library's test suite.
Reasoning
The raw-pass base64 hit is a plain expected-output string in an assert_eq! inside a base64 encoder's unit tests. It is a known test vector, not an obfuscated payload.
info ~~warn~~ → info by review encoding-base64 src/engine/tests.rs:261:10

base64-like blob (64 bytes, compression ratio 1.17) (raw pass, confidence 0.60)
```
    let alphabet = Alphabet::new_with_padding(
        "4QTRhE+Hiz0Nme6DsnuAFCP8WaojxdVOZpKL53r2=BIkqSUcbYJG91tvX7lywMgf",
        Symbol::new(b'-').unwrap(),
    )
```
likely benign LLM, confidence 0.95 A custom base64 alphabet literal used to construct an Alphabet in engine tests.
Reasoning
The string is a custom 64-character alphabet passed to Alphabet::new_with_padding in a test. This is a configuration fixture for an encoding library, with no execution or exfiltration behavior.
info ~~warn~~ → info by review encoding-base64 src/engine/tests.rs:788:16

base64-like blob (128 bytes, compression ratio 1.00) (raw pass, confidence 0.60)
```
fn detects_users_real_world_invalid_suffix<E: EngineWrapper>(engine_wrapper: E) {
    let b64 = "z3Uuv7+Xsn+acg0ZNRsw1/ZEl1FJEMw3kV0N0MaAZuEqXsMjfR2AE51PUsgwNEY4c+PdL3UxO/kcDInOe4+MiyeJL2mAapHLXk+7PBQ6hdqt5Oy4rwOIW4TvRzGHAW==";

    let engine = E::standard();
```
likely benign LLM, confidence 0.92 A base64 sample string used as test input for invalid-suffix detection.
Reasoning
The literal is a sample base64 input inside a test named detects_users_real_world_invalid_suffix. It exists to exercise decoder error handling on a suffix, which is ordinary test data.
info ~~warn~~ → info by review high-complexity src/engine/tests.rs:788:16

string literal compression ratio 0.953 (128 bytes) (raw pass, confidence 0.60)
```
fn detects_users_real_world_invalid_suffix<E: EngineWrapper>(engine_wrapper: E) {
    let b64 = "z3Uuv7+Xsn+acg0ZNRsw1/ZEl1FJEMw3kV0N0MaAZuEqXsMjfR2AE51PUsgwNEY4c+PdL3UxO/kcDInOe4+MiyeJL2mAapHLXk+7PBQ6hdqt5Oy4rwOIW4TvRzGHAW==";

    let engine = E::standard();
```
likely benign LLM, confidence 0.90 The same base64 test-input literal, flagged for high string complexity.
Reasoning
This high-complexity hit is the same test-data literal as the base64 finding on the same line. Its high entropy is expected for random-looking encoded sample data in a decoder test.
info ~~warn~~ → info by review encoding-base64 tests/encode.rs:14:10

base64-like blob (81 bytes, compression ratio 1.14) (raw pass, confidence 0.60)
```
    compare_encode(
        "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7P\
         D0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn8\
         =",
```
likely benign LLM, confidence 0.96 A sequential-bytes base64 test vector in an encode integration test.
Reasoning
This is a sequential byte-range base64 vector (AAEC... through ...fn8=) passed to compare_encode in an encoder integration test. It is a standard exhaustive-alphabet test input.
info ~~warn~~ → info by review encoding-base64 tests/encode.rs:15:10

base64-like blob (90 bytes, compression ratio 1.06) (raw pass, confidence 0.60)
```
        "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7P\
         D0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn8\
         =",
        &ascii,
```
likely benign LLM, confidence 0.96 Continuation of the sequential-bytes base64 test vector in an encode integration test.
Reasoning
This continuation line of the same sequential-bytes base64 test vector completes the string in compare_encode. It is test data with no executable or hidden behavior.
info ~~warn~~ → info by review encoding-base64 tests/encode.rs:26:10

4 rows of base64-like lines, lines 26-29 (first: base64-like blob (81 bytes, compression ratio 1.14)) (raw pass, confidence 0.60)
```
    compare_encode(
        "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7P\
         D0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn\
         +AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6\
```
likely benign LLM, confidence 0.95 Multi-line sequential-bytes base64 test vector in an encode integration test.
Reasoning
Rows 26-29 are the same sequential-byte base64 test vector split across lines with backslash continuations. The multi-row pattern is a formatting artifact of a long literal in a test, not a dropper.
info ~~warn~~ → info by review encoding-base64 tests/encode.rs:39:10

base64-like blob (83 bytes, compression ratio 1.13) (raw pass, confidence 0.60)
```
    assert_eq!(
        "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0\
         -P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn\
         -AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq\
```
likely benign LLM, confidence 0.96 Sequential-bytes base64 expected value in an assert_eq! encoder test.
Reasoning
This is another line of the sequential-bytes base64 test vector used as an assert_eq! expectation. The context is clearly an encoder correctness test.
info ~~warn~~ → info by review encoding-base64 tests/encode.rs:40:11

base64-like blob (86 bytes, compression ratio 1.06) (raw pass, confidence 0.60)
```
        "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0\
         -P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn\
         -AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq\
```
likely benign LLM, confidence 0.96 Continuation of the sequential-bytes base64 expected value in an encoder test.
Reasoning
This line continues the same sequential-bytes base64 test vector in an encoder test. The repetition of the alphabet bytes is expected for exhaustive encoding coverage.

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/marshallpierce/rust-base64 rust-base64 && cd rust-base64
git checkout v0.23.1
disclude scan --severity info --diff v0.23.0 .