orjson 3.13.0

Source: https://github.com/ijl/orjson
Tag scanned: 3.13.0
Compared with: 3.12.0 (0 signals introduced since)
Files: 162 scanned, 417 skipped (binary, oversized, or unrecognised)
Signals: 1 critical · 0 warn · 27 info
Scan time: 18.6 s
LLM review: Reviewed by claude-haiku-5-5 (Anthropic): 25 of 25 warn and critical signals; 24 demoted to info.
Disclude version: 4.1.0
Scanned (UTC): 2026-10-22 04:15

Signals

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

critical dynamic-execution integration/run:14:2

command name is a variable (`$_dir`) and `_dir` is assigned the output of a command — executed command determined at runtime (ast pass, confidence 0.90)
```
if [[ $to_run == *"thread"* ]]; then
	"${_dir}"/thread
fi
```
likely benign LLM, confidence 0.60 Test runner executes a thread binary from a computed directory.
Reasoning
The flagged command runs a directory-derived executable named thread, which is ordinary test-harness behavior. The assignment of _dir is not shown in the snippet, so the critical severity cannot be fully checked. Benign is the more likely reading given the repository context.
info ~~warn~~ → info by review decoder-decompress-payload bench/util.py:17:20

file imports decoder module(s) lzma and calls `.decompress()` — embedded payload decompressed at runtime (ast pass, confidence 0.75)
```
    if path.suffix == ".xz":
        contents = lzma.decompress(path.read_bytes())
    else:
        contents = path.read_bytes()
```
likely benign LLM, confidence 0.90 Benchmark helper that decompresses a local .xz data file.
Reasoning
lzma.decompress is applied to a local .xz file read from the bench directory when its suffix matches. This is ordinary benchmark data handling, not a hidden payload.
info ~~warn~~ → info by review dynamic-execution ci/macos.sh:9:1

pipeline feeds into `sh` — piped data is executed as shell code (ast pass, confidence 0.80)
```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- --default-toolchain "${RUST_TOOLCHAIN}" --target "${TARGET}" --profile minimal --component rust-src -y

source $HOME/.cargo/env
```
likely benign LLM, confidence 0.85 CI step that installs Rust via the official rustup script piped to sh.
Reasoning
This is the standard rustup bootstrap from the official https://sh.rustup.rs domain, using TLS 1.2 and fail-on-error flags. It is a well-known, widely used CI pattern. The pipe-to-shell shape is still a supply-chain risk in principle, but the context is legitimate.
info ~~warn~~ → info by review dynamic-import ci/macos.sh:11:1

`source` called with a dynamic path — sourcing a variable script path (ast pass, confidence 0.75)
```
source $HOME/.cargo/env

cargo fetch --target "${TARGET}" &
```
likely benign LLM, confidence 0.90 Loads the cargo environment after rustup installs it.
Reasoning
Sourcing $HOME/.cargo/env is the standard way to load the rustup environment after installation. The path is fixed to the user's home directory.
info ~~warn~~ → info by review dynamic-execution ci/macos.sh:15:1

command name is a variable (`$PYTHON`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)
```
${PYTHON} -m pip install maturin -r test/requirements.txt

${PYTHON} -m maturin build \
```
likely benign LLM, confidence 0.90 Runs pip and maturin through a configurable Python interpreter.
Reasoning
$PYTHON is a CI-provided interpreter variable used to run pip and maturin. The flagged command is the normal build pattern for a Python extension.
info ~~warn~~ → info by review dynamic-execution ci/macos.sh:17:1

command name is a variable (`$PYTHON`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)
```
${PYTHON} -m maturin build \
  --release \
  --strip \
```
likely benign LLM, confidence 0.90 Runs the maturin wheel build via the configured interpreter.
Reasoning
The same CI-configured $PYTHON runs maturin build with release flags. This is normal build tooling.
info ~~warn~~ → info by review dynamic-execution ci/macos.sh:24:1

command name is a variable (`$PYTHON`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)
```
${PYTHON} -m pip install target/wheels/orjson*

PYTHONMALLOC="debug" ${PYTHON} -m pytest -vv test
```
likely benign LLM, confidence 0.90 Installs the built wheel and runs the test suite.
Reasoning
$PYTHON installs the built wheel and runs pytest. This is standard test execution in CI.
info ~~warn~~ → info by review dynamic-execution ci/macos.sh:26:1

command name is a variable (`$PYTHON`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)
```
PYTHONMALLOC="debug" ${PYTHON} -m pytest -vv test

PYTHONMALLOC="debug" ./integration/run thread
```
likely benign LLM, confidence 0.90 Runs pytest and the integration test runner.
Reasoning
$PYTHON runs pytest and a local integration script is invoked. These are normal CI test steps.
info ~~warn~~ → info by review dynamic-execution ci/manylinux.sh:9:1

pipeline feeds into `sh` — piped data is executed as shell code (ast pass, confidence 0.80)
```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- --default-toolchain "${RUST_TOOLCHAIN}" --target "${TARGET}" --profile minimal --component rust-src -y

source $HOME/.cargo/env
```
likely benign LLM, confidence 0.85 CI step that installs Rust via the official rustup script piped to sh.
Reasoning
This is the same official rustup bootstrap piped to sh, used in a manylinux CI build. It is a common and expected pattern.
info ~~warn~~ → info by review dynamic-import ci/manylinux.sh:11:1

`source` called with a dynamic path — sourcing a variable script path (ast pass, confidence 0.75)
```
source $HOME/.cargo/env

cargo fetch --target "${TARGET}" &
```
likely benign LLM, confidence 0.90 Loads the cargo environment after rustup installs it.
Reasoning
Sourcing the fixed $HOME/.cargo/env path after rustup installation is standard practice.
info ~~warn~~ → info by review dynamic-execution ci/manylinux.sh:15:1

command name is a variable (`$PYTHON`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)
```
${PYTHON} -m pip install maturin auditwheel -r test/requirements.txt

${PYTHON} -m maturin build \
```
likely benign LLM, confidence 0.90 Installs maturin and auditwheel through the configured interpreter.
Reasoning
$PYTHON is a CI-configured interpreter used to install build tools and run maturin. This is routine.
info ~~warn~~ → info by review dynamic-execution ci/manylinux.sh:17:1

command name is a variable (`$PYTHON`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)
```
${PYTHON} -m maturin build \
  --release \
  --strip \
```
likely benign LLM, confidence 0.90 Runs the maturin wheel build via the configured interpreter.
Reasoning
The configured $PYTHON runs maturin build with release flags, which is the expected build step.
info ~~warn~~ → info by review dynamic-execution ci/manylinux.sh:25:1

command name is a variable (`$PYTHON`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)
```
${PYTHON} -m auditwheel repair --plat "${ORJSON_TAG}" --only-plat target/wheels/orjson*
rm -r target/wheels/*
mv wheelhouse/* target/wheels
```
likely benign LLM, confidence 0.90 Repairs and relocates built wheels for manylinux distribution.
Reasoning
auditwheel repair and file moves operate on the build's own wheels directory. This is normal manylinux packaging.
info ~~warn~~ → info by review dynamic-execution ci/manylinux.sh:30:3

command name is a variable (`$PYTHON`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)
```
if [[ "${ORJSON_TAG}" != *"manylinux_2_39"* ]]; then
  ${PYTHON} -m pip install target/wheels/orjson*
  PYTHONMALLOC="debug" ${PYTHON} -m pytest -vv test
fi
```
likely benign LLM, confidence 0.90 Conditionally installs and tests the built wheel.
Reasoning
Inside a tag-conditional block, $PYTHON installs the wheel and runs pytest. This is ordinary CI test logic.
info ~~warn~~ → info by review dynamic-execution ci/manylinux.sh:31:3

command name is a variable (`$PYTHON`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)
```
  ${PYTHON} -m pip install target/wheels/orjson*
  PYTHONMALLOC="debug" ${PYTHON} -m pytest -vv test
fi
```
likely benign LLM, confidence 0.90 Conditionally installs and tests the built wheel.
Reasoning
This is the same conditional install and test sequence as the preceding finding, with the same CI interpreter variable.
info ~~warn~~ → info by review macro-keyword-override include/yyjson/yyjson.h:437:1

`#define _Bool` rebinds the reserved C keyword `_Bool` (token pass, confidence 0.85)
```
#       if defined(__GNUC__) && !defined(__STRICT_ANSI__)
#           define _Bool bool
#           if __cplusplus < 201103L
#               define bool bool
```
likely benign LLM, confidence 0.80 Compatibility macro remapping _Bool to bool for older GCC configurations.
Reasoning
The #define _Bool bool sits inside a GNUC, non-strict-ANSI branch, a compatibility shim for older compilers. This is a common portability idiom in vendored C headers, not hostile obfuscation.
info ~~critical~~ → info by review dynamic-execution integration/run:18:2

command name is a variable (`$_dir`) and `_dir` is assigned the output of a command — executed command determined at runtime (ast pass, confidence 0.90)
```
if [[ $to_run == *"http"* ]]; then
	"${_dir}"/http --daemon
	sleep 2
	"${_dir}"/client 8001
```
likely benign LLM, confidence 0.85 Integration test runner that executes the project's own http and client binaries from a script-derived directory.
Reasoning
The variable command is `${_dir}`, which is a directory computed from the script's own location in a CI integration runner. The snippet only launches the project's own binaries (http, client) under a test condition. Nothing shows a remote or obfuscated payload.
info ~~critical~~ → info by review dynamic-execution integration/run:20:2

command name is a variable (`$_dir`) and `_dir` is assigned the output of a command — executed command determined at runtime (ast pass, confidence 0.90)
```
	sleep 2
	"${_dir}"/client 8001
	set +e
	pkill -f 'wsgi:app' # pkill not present on all CI envs
```
likely benign LLM, confidence 0.85 Integration test step that runs the local client binary and then kills the test server.
Reasoning
Same `${_dir}` pattern as the other findings in this file. It runs the local client binary, then uses pkill to stop a test server. The pkill comment refers to CI environments, which fits test cleanup.
info ~~critical~~ → info by review dynamic-execution integration/run:32:2

command name is a variable (`$_dir`) and `_dir` is assigned the output of a command — executed command determined at runtime (ast pass, confidence 0.90)
```
if [[ $to_run == *"init"* ]]; then
	"${_dir}"/init
fi
```
likely benign LLM, confidence 0.85 Conditional invocation of a local init test binary from the integration runner.
Reasoning
`${_dir}/init` is run only when a test selector matches 'init'. This is a conditional test-harness step with no network fetch, decode, or piping, and the dynamic path is simply a script-relative directory.
info ~~warn~~ → info by review dynamic-import script/install-fedora:22:1

`source` called with a dynamic path — sourcing a variable script path (ast pass, confidence 0.75)
```
rustup-init --default-toolchain "${RUST_TOOLCHAIN}-${TARGET}" --profile minimal --component rust-src -y
source "${HOME}/.cargo/env"

mkdir -p .cargo
```
likely benign LLM, confidence 0.90 Sources the rustup environment file after installing the Rust toolchain.
Reasoning
Sourcing ${HOME}/.cargo/env right after rustup-init is the standard Rust installer idiom. The path is fixed relative to HOME and not attacker-controlled.
info ~~warn~~ → info by review dynamic-import script/install-fedora:31:1

`source` called with a dynamic path — sourcing a variable script path (ast pass, confidence 0.75)
```
uv venv --python "${PYTHON}" "${VENV}"
source "${VENV}/bin/activate"

uv pip install --upgrade "maturin>=1.10,<2" -r test/requirements.txt -r integration/requirements.txt
```
likely benign LLM, confidence 0.90 Activates the Python virtualenv that the script just created.
Reasoning
Sourcing a virtualenv activate script from a variable path created by `uv venv` in the same script is the normal way to activate a venv. No remote or obfuscated content is involved.
info ~~warn~~ → info by review decoder-decompress-payload script/pycorrectness:34:20

file imports decoder module(s) lzma and calls `.decompress()` — embedded payload decompressed at runtime (ast pass, confidence 0.75)
```
    if path.suffix == ".xz":
        contents = lzma.decompress(path.read_bytes())
    else:
        contents = path.read_bytes()
```
likely benign LLM, confidence 0.85 Developer lint helper that transparently reads optionally xz-compressed source files.
Reasoning
This is a developer checking tool that reads files and, when the suffix is .xz, decompresses them with lzma. It processes repository source files and does not execute or fetch any payload.
info ~~warn~~ → info by review decoder-decompress-payload script/pyindent:27:20

file imports decoder module(s) lzma and calls `.decompress()` — embedded payload decompressed at runtime (ast pass, confidence 0.75)
```
    if path.suffix == ".xz":
        contents = lzma.decompress(path.read_bytes())
    else:
        contents = path.read_bytes()
```
likely benign LLM, confidence 0.85 Formatting-check helper that reads optionally xz-compressed Python files.
Reasoning
Same transparent .xz read helper as the sibling scripts. It decompresses data for a formatting check and never executes it.
info ~~warn~~ → info by review decoder-decompress-payload script/pysort:26:20

file imports decoder module(s) lzma and calls `.decompress()` — embedded payload decompressed at runtime (ast pass, confidence 0.75)
```
    if path.suffix == ".xz":
        contents = lzma.decompress(path.read_bytes())
    else:
        contents = path.read_bytes()
```
likely benign LLM, confidence 0.85 Import-sorting helper that reads optionally xz-compressed Python files.
Reasoning
Same .xz read pattern as the other developer scripts. The decompressed bytes are only processed as source text.
info identifier-low-length src/serialize/writer/str/escape.rs:1:1

196 of 289 non-conventional identifiers are single-character (68%) (token pass, confidence 0.50)

info unicode-mixed-script test/test_jsonchecker.py:11:489

identifier `ģ䕧覫췯ꯍ` mixes scripts: Latin + Han + Hangul + Other (in string/comment) (raw pass, confidence 0.40)

1~!@#$%^&*()_+-={\':[,]}|;.</>?","hex":"ģ䕧覫췯ꯍ\uef4a","true":true,"false":false,"null":null,"array":[],"object":{},"address":"50 St. James Street","url":"http://www.JSON.org/","comment":"// /* <!-- --","# -- --> */":" "," s p a c e d ":[1,2,3,4,5,6,7],"compact":[1,2,3,4,5,6,7],"jsontext":"{\\"object with 1 memb

info unicode-mixed-script test/test_jsonchecker.py:11:856

identifier `쫾몾ꮘﳞ볚` mixes scripts: Hangul + Other (in string/comment) (raw pass, confidence 0.40)

&#34; \\" %22 0x22 034 &#x22;","/\\\\\\"쫾몾ꮘﳞ볚\uef4a\\b\\f\\n\\r\\t`1~!@#$%^&*()_+-=[]{}|;:\',./<>?":"A key can be any string"},0.5,98.6,99.44,1066,10.0,1.0,0.1,1.0,2.0,2.0,"rosebud"]'.encode()

info ~~warn~~ → info by review decoder-decompress-payload test/util.py:50:20

file imports decoder module(s) lzma and calls `.decompress()` — embedded payload decompressed at runtime (ast pass, confidence 0.75)
```
    if path.suffix == ".xz":
        contents = lzma.decompress(path.read_bytes())
    else:
        contents = path.read_bytes()
```
likely benign LLM, confidence 0.85 Test helper that loads optionally xz-compressed fixture files.
Reasoning
A test utility that loads fixture files, using lzma for .xz fixtures. The decompressed contents are returned as test data and not executed.

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.1.0
git clone https://github.com/ijl/orjson orjson && cd orjson
git checkout 3.13.0
disclude scan --severity info --diff 3.12.0 .