dulwich 1.2.19

Source: https://github.com/dulwich/dulwich
Artifact scanned: dulwich-1.2.19-py3-none-any.whl (wheel · 738.0 KB · SHA-256 efe585c9c2a9…)
Compared with: dulwich-1.2.17-py3-none-any.whl (0 signals introduced since)
Files: 89 scanned, 5 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 0 warn · 11 info
Scan time: 9.8 s
LLM review: Reviewed by claude-haiku-5-5 (Anthropic): 11 of 11 warn and critical signals; 11 demoted to info.
Disclude version: 4.3.0
Scanned (UTC): 2026-10-23 11:51

Signals

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

info ~~critical~~ → info by review dynamic-execution dulwich/cli.py:952:38

`subprocess.Popen` with `shell=True` and a non-literal command — runtime-determined shell invocation (ast pass, confidence 0.85)
```
                pager_cmd = self._get_pager_command()
                self.pager_process = subprocess.Popen(
                    pager_cmd,
                    shell=True,
```
likely benign LLM, confidence 0.85 Launches the configured pager command through a shell for CLI output.
Reasoning
The shell=True Popen runs the pager command, which comes from the user's git/dulwich configuration or the PAGER environment variable. Running a configured pager through a shell is the standard git-style pattern and is not hidden or attacker-controlled in this snippet.
info ~~critical~~ → info by review dynamic-import dulwich/cli.py:5301:26

`__import__` called on a non-literal expression (ast pass, confidence 0.70)
```
            try:
                module = __import__(dep)
                version = getattr(module, "__version__", "(unknown)")
                logger.info("  %s: %s [%s]", dep, version, dep_type)
```
likely benign LLM, confidence 0.80 Dynamically imports dependency modules to print their version numbers.
Reasoning
__import__ is applied to a loop variable from a fixed list of dependency names used to report versions in a diagnostics command. The input is not attacker-supplied in the snippet, so this is a dynamic import for reporting only.
info ~~critical~~ → info by review dynamic-execution dulwich/cli.py:6476:22

`subprocess.run` with `shell=True` and a non-literal command — runtime-determined shell invocation (ast pass, confidence 0.85)
```
                filter_env.update(extra_env)
            result = subprocess.run(
                cmd,
                shell=True,
```
likely benign LLM, confidence 0.80 Runs a configured git filter command through a shell.
Reasoning
The shell=True subprocess.run executes a filter command configured by the user in git config (filter drivers), which matches git's own behavior. The snippet shows no obfuscation or hidden payload.
info ~~warn~~ → info by review decoder-decompress-payload dulwich/dumb.py:146:24

file imports decoder module(s) zlib and calls `.decompress()` — embedded payload decompressed at runtime (ast pass, confidence 0.75)
```
        # Decompress and parse the object
        decompressed = zlib.decompress(compressed)

        # Parse header
```
likely benign LLM, confidence 0.90 Decompresses a fetched git object before parsing its header.
Reasoning
zlib.decompress on fetched git object data is the normal way to parse git loose or packed objects. It is not an embedded or hidden payload.
info ~~critical~~ → info by review dynamic-execution dulwich/filters.py:171:33

`subprocess.Popen` with `shell=True` and a non-literal command — runtime-determined shell invocation (ast pass, confidence 0.85)
```
            try:
                self._process = subprocess.Popen(
                    self.process_cmd,
                    shell=True,
```
likely benign LLM, confidence 0.80 Starts a configured git filter process through a shell.
Reasoning
The Popen with shell=True runs the configured long-running filter process command (git filter.process), a documented git feature. The command comes from repository or user configuration rather than being hidden in the code.
info ~~critical~~ → info by review dynamic-execution dulwich/merge_drivers.py:139:26

`subprocess.run` with `shell=True` and a non-literal command — runtime-determined shell invocation (ast pass, confidence 0.85)
```
            try:
                result = subprocess.run(
                    cmd,
                    shell=True,
```
likely benign LLM, confidence 0.80 Runs a configured custom merge driver command through a shell.
Reasoning
The subprocess.run with shell=True executes a merge driver command taken from git configuration, as git does for custom merge drivers. Nothing in the snippet is obfuscated.
info ~~warn~~ → info by review decoder-decompress-payload dulwich/objects.py:194:13

file imports decoder module(s) binascii, zlib and calls `.decompress()` — embedded payload decompressed at runtime (ast pass, confidence 0.75)
```
    """
    dcomp = zlib.decompressobj()
    # +1 so overrun surfaces as unconsumed_tail rather than being truncated.
    dcomped = dcomp.decompress(string, max_size + 1)
```
likely benign LLM, confidence 0.90 Bounded zlib decompression of git object content.
Reasoning
zlib.decompressobj with a max size limit is the standard bounded decompression used when reading git object data. The max_size guard is a defensive measure.
info ~~warn~~ → info by review decoder-decompress-payload dulwich/pack.py:634:18

file imports decoder module(s) binascii, zlib and calls `.decompress()` — embedded payload decompressed at runtime (ast pass, confidence 0.75)
```
        raise ValueError("non-negative zlib data stream size expected")
    decomp_obj = zlib.decompressobj()

    comp_chunks = []
```
likely benign LLM, confidence 0.90 Decompresses zlib data streams stored in git pack files.
Reasoning
zlib.decompressobj is used to read zlib streams inside git pack files, which is required by the pack format. The snippet shows ordinary stream handling.
info ~~warn~~ → info by review decoder-decompress-payload dulwich/patch.py:1760:19

file imports decoder module(s) base64, zlib and calls `.decompress()` — embedded payload decompressed at runtime (ast pass, confidence 0.75)
```
    try:
        decoded = zlib.decompress(git_base85_decode(data))
    except (ValueError, zlib.error) as e:
        raise ValueError(f"Failed to decode binary patch: {e}")
```
likely benign LLM, confidence 0.90 Decodes a git binary patch payload from base85 and zlib.
Reasoning
Decoding a git binary patch (base85 then zlib) is the documented binary diff format. The error handling is ordinary.
info ~~critical~~ → info by review dynamic-execution dulwich/rebase.py:1197:21

`subprocess.run` with `shell=True` and a non-literal command — runtime-determined shell invocation (ast pass, confidence 0.85)
```
                try:
                    subprocess.run(entry.arguments, shell=True, check=True)
                except subprocess.CalledProcessError as e:
                    # Command failed, pause rebase
```
likely benign LLM, confidence 0.80 Runs an 'exec' line from an interactive rebase todo through a shell.
Reasoning
The shell=True run executes 'exec' commands from the rebase todo list, which mirrors git rebase's exec feature. The user supplies these commands in their own rebase plan, and the snippet has no hidden or obfuscated behavior.
info ~~critical~~ → info by review dynamic-execution dulwich/signature.py:1223:26

`subprocess.run` with `shell=True` and a non-literal command — runtime-determined shell invocation (ast pass, confidence 0.85)
```
                # Run the default key command to get the key
                result = subprocess.run(
                    self.default_key_command,
                    shell=True,
```
likely benign LLM, confidence 0.80 Runs the configured default-key command through a shell to fetch a signing key.
Reasoning
The shell=True run executes the user's configured default key command to obtain a signing key, a configurable feature in signing setups. Nothing in the snippet is hidden or obfuscated.

Reproduce This Scan

Run disclude locally to verify. These commands scan the published file; the "new in this release" marks come from comparing it with the previous release's file, which they don't repeat. 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.3.0
curl -fsSL -o dulwich-1.2.19-py3-none-any.whl https://files.pythonhosted.org/packages/f3/f1/f8abd5626e413c356a70aef0804893895dbc75de770cec87dba72302c577/dulwich-1.2.19-py3-none-any.whl
printf '%s  %s\n' efe585c9c2a921a26136dc2fba785faafb16d5eed39ea6d40c5dd1cd8140f0a3 dulwich-1.2.19-py3-none-any.whl | shasum -a 256 -c -
unzip -q dulwich-1.2.19-py3-none-any.whl -d pkg
disclude scan --untrusted --severity info pkg