dulwich 1.2.19

Source: https://github.com/dulwich/dulwich
Tag scanned: dulwich-1.2.19
Compared with: dulwich-1.2.18 (0 signals introduced since)
Files: 280 scanned, 105 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 0 warn · 51 info
Scan time: 32.8 s
LLM review: Reviewed by claude-haiku-5-5 (Anthropic): 43 of 43 warn and critical signals; 43 demoted to info.
Disclude version: 4.1.0
Scanned (UTC): 2026-10-22 12:30

Signals

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

info ~~warn~~ → info by review decoder-decompress-payload contrib/swift.py:280:52

file imports decoder module(s) zlib and calls `.decompress()` — embedded payload decompressed at runtime (ast pass, confidence 0.75)
```
        if isinstance(obj, bytes):
            return cast(dict[str, Any], json.loads(zlib.decompress(obj)))
        else:
            f: BinaryIO = obj
```
likely benign LLM, confidence 0.85 Decompresses cached bytes with zlib and parses the result as JSON.
Reasoning
zlib.decompress of a bytes object followed by json.loads looks like ordinary cache or object-store deserialization. Decompression alone is not a payload-delivery pattern, and nothing in the snippet is hidden or executed.
info ~~warn~~ → info by review encoding-base64 contrib/test_paramiko_vendor.py:213:1

base64-like blob (1592 bytes over 25 lines, compression ratio 0.77) (raw pass, confidence 0.60)
```
-----BEGIN RSA PRIVATE KEY-----
MIIEpAIBAAKCAQEAy/L1sSYAzxsMprtNXW4u/1jGXXkQmQ2xtmKVlR+RlIL3a1BH
bzTpPlZyjltAAwzIP8XRh0iJFKz5y3zSQChhX47ZGN0NvQsVct8R+YwsUonwfAJ+
JN0KBKKvC8fPHlzqBr3gX+ZxqsFH934tQ6wdQPH5eQWtdM8L826lMsH1737uyTGk
```
likely benign LLM, confidence 0.75 A PEM-encoded RSA private key block in a paramiko vendor test file.
Reasoning
The raw base64 blob is an RSA private key in PEM form inside a test module. This is a committed test fixture rather than obfuscation, though a real key in a repo is worth noting.
info ~~warn~~ → info by review encoding-base64 contrib/test_paramiko_vendor.py:241:1

base64-like blob (1592 bytes over 25 lines, compression ratio 0.77) (raw pass, confidence 0.60)
```
-----BEGIN RSA PRIVATE KEY-----
MIIEpAIBAAKCAQEAxvREKSElPOm/0z/nPO+j5rk2tjdgGcGc7We1QZ6TRXYLu7nN
GeEFIL4p8N1i6dmB+Eydt7xqCU79MWD6Yy4prFe1+/K1wCDUxIbFMxqQcX5zjJzd
i8j8PbcaUlVhP/OkjtkSxrXaGDO1BzfdV4iEBtTV/2l3zmLKJlt3jnOHLczP24CB
```
likely benign LLM, confidence 0.75 A second PEM-encoded RSA private key block in the same paramiko test file.
Reasoning
Same pattern as the other key block: a PEM RSA key in a test file, consistent with test fixture material rather than hidden payload.
info ~~warn~~ → info by review dynamic-execution contrib/test_release_robot.py:342:9

`exec` called on a non-literal expression (ast pass, confidence 0.70)
```
        }
        exec(
            compile(
                "if __name__ == '__main__':\n    if len(sys.argv) > 1:\n        _PROJDIR = sys.argv[1]\n    else:\n        _PROJDIR = PROJDIR\n    print(get_current_version(projdir=_PROJDIR))",
```
likely benign LLM, confidence 0.70 exec of a compiled literal snippet that prints the current version.
Reasoning
The exec/compile argument is a literal string defining a small __main__ block for a release script. The unusual exec is odd, but the code is static and does nothing hidden or malicious.
info ~~warn~~ → info by review dynamic-execution contrib/test_release_robot.py:368:9

`exec` called on a non-literal expression (ast pass, confidence 0.70)
```
        }
        exec(
            compile(
                "if __name__ == '__main__':\n    if len(sys.argv) > 1:\n        _PROJDIR = sys.argv[1]\n    else:\n        _PROJDIR = PROJDIR\n    print(get_current_version(projdir=_PROJDIR))",
```
likely benign LLM, confidence 0.70 Second exec of the same literal version-printing snippet.
Reasoning
Repeats the same literal exec/compile snippet. It is static code in a release helper, not a runtime-determined payload.
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.75 Launches the user's configured pager command through a shell.
Reasoning
Popen with shell=True runs the pager command from git configuration or environment. Running a configured pager through the shell is a conventional git-tool pattern, and the snippet shows no obfuscation.
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 Imports a named dependency module to read its version for diagnostics.
Reasoning
__import__ on a dependency name inside a version-reporting routine. The names come from a known dependency list, so this is a common diagnostic pattern, not obfuscated execution.
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.70 Runs a configured filter command through the shell with extra environment variables.
Reasoning
subprocess.run with shell=True executes a filter command with extra env, which is the standard way git filter/driver commands run. The command comes from repository configuration, which is expected for this tool.
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.92 Decompresses and parses a git object fetched over dumb HTTP.
Reasoning
zlib.decompress of a fetched git object followed by header parsing is the normal way to read git loose objects. Nothing suggests a 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.75 Starts a configured filter process through the shell.
Reasoning
Popen with shell=True runs a configured process filter command, as git's clean/smudge filter mechanism does. The command is supplied by config, and the snippet shows no obfuscation.
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.75 Runs a configured merge driver command through the shell.
Reasoning
subprocess.run with shell=True executes a configured merge driver command, a documented git feature. The snippet is consistent with normal tool behavior.
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.93 Bounded zlib decompression of git object data with overrun detection.
Reasoning
zlib.decompressobj with a max_size limit is a careful bounded decompression of git object data, a legitimate parsing pattern with explicit overrun handling.
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.93 Streaming zlib decompression of pack file data.
Reasoning
zlib.decompressobj streaming decompression of pack data is standard git pack-file reading, with no hidden payload or execution.
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 Decompresses base85-encoded git binary patch data inside a patch parser.
Reasoning
zlib.decompress applied to git binary patch data via git_base85_decode is the standard way git binary diffs are stored. The error handling is ordinary. Nothing suggests a hidden payload.
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.75 Runs the user's rebase exec command through the shell.
Reasoning
Interactive rebase 'exec' todo entries are user-authored commands that git itself runs through a shell, so shell=True mirrors designed behavior. It is an injection-prone pattern, but the command source is the local user's rebase file, not a remote or hidden source.
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.75 Runs the configured default-key command through the shell to fetch a signing key.
Reasoning
The shell command comes from the user's configured default GPG key command, as with git's gpg.program setting. It is a designed feature rather than a hidden or obfuscated invocation.
info ~~warn~~ → info by review dynamic-execution fuzzing/oss-fuzz-scripts/container-environment-bootstrap.sh:79:1

pipeline feeds into `sh` — piped data is executed as shell code (ast pass, confidence 0.80)
```
# Install the Rust toolchain so the Rust extensions can be built in build.sh.
curl https://sh.rustup.rs -sSf | sh -s -- --default-toolchain nightly --profile minimal -y

# The OSS-Fuzz base image has outdated dependencies by default so we upgrade them below.
```
likely benign LLM, confidence 0.70 Installs the Rust toolchain by piping the rustup bootstrap script to sh.
Reasoning
Piping the official rustup installer from sh.rustup.rs into sh is the documented install method for Rust. It is a supply-chain trust risk in principle, but it is visible, expected, and targets the legitimate Rust vendor domain.

info unicode-homoglyph tests/compat/test_check_ignore.py:1202:57

identifier `mixed_тест` contains homoglyph candidates: е (0435)→e, с (0441)→c (in string/comment) (raw pass, confidence 0.35)

        try:
            self._write_gitignore("тест*\n*.测试\nmixed_тест*\n")
            self._create_file("тест.txt")
            self._create_file("файл.测试")

info unicode-mixed-script tests/compat/test_check_ignore.py:1202:57

identifier `mixed_тест` mixes scripts: Latin + Cyrillic (in string/comment) (raw pass, confidence 0.40)

        try:
            self._write_gitignore("тест*\n*.测试\nmixed_тест*\n")
            self._create_file("тест.txt")
            self._create_file("файл.测试")

info unicode-homoglyph tests/compat/test_check_ignore.py:1206:32

identifier `mixed_тест` contains homoglyph candidates: е (0435)→e, с (0441)→c (in string/comment) (raw pass, confidence 0.35)

            self._create_file("normal.txt")
            self._create_file("mixed_тест.log")

            paths = ["тест.txt", "файл.测试", "normal.txt", "mixed_тест.log"]

info unicode-mixed-script tests/compat/test_check_ignore.py:1206:32

identifier `mixed_тест` mixes scripts: Latin + Cyrillic (in string/comment) (raw pass, confidence 0.40)

            self._create_file("normal.txt")
            self._create_file("mixed_тест.log")

            paths = ["тест.txt", "файл.测试", "normal.txt", "mixed_тест.log"]

info unicode-homoglyph tests/compat/test_check_ignore.py:1208:72

identifier `mixed_тест` contains homoglyph candidates: е (0435)→e, с (0441)→c (in string/comment) (raw pass, confidence 0.35)
```
            paths = ["тест.txt", "файл.测试", "normal.txt", "mixed_тест.log"]

            # Get both quoted and unquoted results from dulwich
```

info unicode-mixed-script tests/compat/test_check_ignore.py:1208:72

identifier `mixed_тест` mixes scripts: Latin + Cyrillic (in string/comment) (raw pass, confidence 0.40)


            paths = ["тест.txt", "файл.测试", "normal.txt", "mixed_тест.log"]

            # Get both quoted and unquoted results from dulwich

info unicode-homoglyph tests/compat/test_check_ignore.py:1230:70

identifier `mixed_тест` contains homoglyph candidates: е (0435)→e, с (0441)→c (in string/comment) (raw pass, confidence 0.35)

            # Verify unquoted paths contain the expected files
            expected_unquoted = {"тест.txt", "файл.测试", "mixed_тест.log"}
            self.assertEqual(unquoted_ignored, expected_unquoted)
        except (UnicodeEncodeError, OSError):

info unicode-mixed-script tests/compat/test_check_ignore.py:1230:70

identifier `mixed_тест` mixes scripts: Latin + Cyrillic (in string/comment) (raw pass, confidence 0.40)

            # Verify unquoted paths contain the expected files
            expected_unquoted = {"тест.txt", "файл.测试", "mixed_тест.log"}
            self.assertEqual(unquoted_ignored, expected_unquoted)
        except (UnicodeEncodeError, OSError):

info ~~warn~~ → info by review decoder-decompress-payload tests/compat/test_client.py:831:41

file imports decoder module(s) base64, binascii and calls `.decompress()` — embedded payload decompressed at runtime (ast pass, confidence 0.75)
```
                    try:
                        authorization = base64.decodestring(authorization[1])
                    except binascii.Error:
                        pass
```
likely benign LLM, confidence 0.90 Decodes a basic-auth credential in a test client.
Reasoning
base64.decodestring is a deprecated but ordinary call used to parse HTTP basic auth in a compatibility test. There is no payload execution, and the binascii.Error handler is routine.
info ~~warn~~ → info by review encoding-base64 tests/porcelain/__init__.py:155:1

base64-like blob (4900 bytes over 77 lines, compression ratio 0.75) (raw pass, confidence 0.60)
```
lQVYBGBjIyIBDADAwydvMPQqeEiK54FG1DHwT5sQejAaJOb+PsOhVa4fLcKsrO3F
g5CxO+/9BHCXAr8xQAtp/gOhDN05fyK3MFyGlL9s+Cd8xf34S3R4rN/qbF0oZmaa
FW0MuGnniq54HINs8KshadVn1Dhi/GYSJ588qNFRl/qxFTYAk+zaGsgX/QgFfy0f
```
likely benign LLM, confidence 0.85 Base64 OpenPGP-style key or signature fixture in a test module.
Reasoning
The blob starts with lQ, the typical header of an OpenPGP packet, and sits in a test package that exercises git signing or porcelain features. It is test fixture data, not an obfuscated payload.
info ~~warn~~ → info by review encoding-base64 tests/porcelain/__init__.py:241:1

base64-like blob (4917 bytes over 78 lines, compression ratio 0.76) (raw pass, confidence 0.60)
```
lQVYBGBjI0ABDADGWBRp+t02emfzUlhrc1psqIhhecFm6Em0Kv33cfDpnfoMF1tK
Yy/4eLYIR7FmpdbFPcDThFNHbXJzBi00L1mp0XQE2l50h/2bDAAgREdZ+NVo5a7/
RSZjauNU1PxW6pnXMehEh1tyIQmV78jAukaakwaicrpIenMiFUN3fAKHnLuFffA6
```
likely benign LLM, confidence 0.85 Base64 OpenPGP-style key fixture in a test module.
Reasoning
Same structure as the other fixture in this file, with the lQ OpenPGP header. It is test data for signing or key handling.
info ~~warn~~ → info by review payload-bytes-literal tests/test_objects.py:297:5

concatenated bytes literal contains 117 `\xNN` escapes (100% of content) — binary payload shape (ast pass, confidence 0.85)
```
small_buffer_zlib_object = (
    b"\x48\x89\x15\xcc\x31\x0e\xc2\x30\x0c\x40\x51\xe6"
    b"\x9c\xc2\x3b\xaa\x64\x37\xc4\xc1\x12\x42\x5c\xc5"
    b"\x49\xac\x52\xd4\x92\xaa\x78\xe1\xf6\x94\xed\xeb"
```
likely benign LLM, confidence 0.90 Hex-escaped zlib-compressed git object fixture for object-parsing tests.
Reasoning
The byte sequence begins with 0x48 0x89, which is zlib-compressed data, and the variable name small_buffer_zlib_object says it is a test vector for git object parsing. Hex escapes are the normal way to write binary fixtures.
info ~~warn~~ → info by review encoding-base64 tests/test_objects.py:450:1

base64-like blob (724 bytes over 12 lines, compression ratio 0.79) (raw pass, confidence 0.60)
```
iQIcBAABCgAGBQJULCdfAAoJEACAbyvXKaRXuKwP/RyP9PA49uAvu8tQVCC/uBa8
vi975+xvO14R8Pp8k2nps7lSxCdtCd+xVT1VRHs0wNhOZo2YCVoU1HATkPejqSeV
NScTHcxnk4/+bxyfk14xvJkNp7FlQ3npmBkA+lbV0Ubr33rvtIE5jiJPyz+SgWAg
```
likely benign LLM, confidence 0.90 Base64 PGP signature fixture in an object test.
Reasoning
The iQIc header is an OpenPGP signature packet, and the file is a test for signature handling. The 0.79 compression ratio fits base64 of binary test data.
info ~~warn~~ → info by review encoding-base64 tests/test_objects.py:475:2

base64-like blob (724 bytes over 12 lines, compression ratio 0.79) (raw pass, confidence 0.60)
```
 
 iQIcBAABCgAGBQJULCdfAAoJEACAbyvXKaRXuKwP/RyP9PA49uAvu8tQVCC/uBa8
 vi975+xvO14R8Pp8k2nps7lSxCdtCd+xVT1VRHs0wNhOZo2YCVoU1HATkPejqSeV
 NScTHcxnk4/+bxyfk14xvJkNp7FlQ3npmBkA+lbV0Ubr33rvtIE5jiJPyz+SgWAg
```
likely benign LLM, confidence 0.90 Repeated base64 PGP signature fixture in an object test.
Reasoning
This is the same PGP signature fixture as at line 450, indented into a different test. It is test data.
info ~~warn~~ → info by review encoding-base64 tests/test_objects.py:529:2

base64-like blob (88 bytes over 2 lines, compression ratio 1.06) (raw pass, confidence 0.60)
```
 
 iD8DBQBGiAaAF3YsRnbiHLsRAitMAKCiLboJkQECM/jpYsY3WPfvUgLXkACgg3ql
 OK2XeQOiEeXtT76rV4t2WR4=
 =ivrA
```
likely benign LLM, confidence 0.90 ASCII-armored PGP signature fixture in an object test.
Reasoning
The iD8DBQ header and =ivrA armor checksum mark a standard ASCII-armored PGP signature. It is a test fixture for signature parsing.
info ~~warn~~ → info by review encoding-base64 tests/test_objects.py:567:2

base64-like blob (88 bytes over 2 lines, compression ratio 1.06) (raw pass, confidence 0.60)
```
 
 iD8DBQBGiAaAF3YsRnbiHLsRAitMAKCiLboJkQECM/jpYsY3WPfvUgLXkACgg3ql
 OK2XeQOiEeXtT76rV4t2WR4=
 =ivrA
```
likely benign LLM, confidence 0.90 Repeated ASCII-armored PGP signature fixture in an object test.
Reasoning
Identical armored PGP signature fixture to the one at line 529, used in another test. It is test data.
info ~~warn~~ → info by review encoding-base64 tests/test_objects.py:580:2

base64-like blob (88 bytes over 2 lines, compression ratio 1.06) (raw pass, confidence 0.60)
```
 
 iD8DBQBGiAaAF3YsRnbiHLsRAitMAKCiLboJkQECM/jpYsY3WPfvUgLXkACgg3ql
 OK2XeQOiEeXtT76rV4t2WR4=
 =ivrA
```
likely benign LLM, confidence 0.90 Repeated ASCII-armored PGP signature fixture in an object test.
Reasoning
Identical armored PGP signature fixture again, in a further test. It is test data.
info ~~warn~~ → info by review encoding-base64 tests/test_objects.py:811:2

base64-like blob (724 bytes over 12 lines, compression ratio 0.79) (raw pass, confidence 0.60)
```
 
 iQIcBAABCgAGBQJULCdfAAoJEACAbyvXKaRXuKwP/RyP9PA49uAvu8tQVCC/uBa8
 vi975+xvO14R8Pp8k2nps7lSxCdtCd+xVT1VRHs0wNhOZo2YCVoU1HATkPejqSeV
 NScTHcxnk4/+bxyfk14xvJkNp7FlQ3npmBkA+lbV0Ubr33rvtIE5jiJPyz+SgWAg
```
likely benign LLM, confidence 0.97 Base64-encoded PGP key/signature material used as test fixture data.
Reasoning
The blob is a PGP public key block (base64 with 'iQIcBAAB...' header typical of PGP signatures/keys) inside a test fixture file for a git library; this is test data, not obfuscation.
info ~~warn~~ → info by review encoding-base64 tests/test_objects.py:839:1

base64-like blob (724 bytes over 12 lines, compression ratio 0.79) (raw pass, confidence 0.60)
```
iQIcBAABCgAGBQJULCdfAAoJEACAbyvXKaRXuKwP/RyP9PA49uAvu8tQVCC/uBa8
vi975+xvO14R8Pp8k2nps7lSxCdtCd+xVT1VRHs0wNhOZo2YCVoU1HATkPejqSeV
NScTHcxnk4/+bxyfk14xvJkNp7FlQ3npmBkA+lbV0Ubr33rvtIE5jiJPyz+SgWAg
```
likely benign LLM, confidence 0.97 Duplicate PGP base64 fixture in a test module.
Reasoning
Same PGP base64 fixture repeated in the objects test file; legitimate test data for signature handling.
info ~~warn~~ → info by review encoding-base64 tests/test_objects.py:866:2

base64-like blob (389 bytes over 7 lines, compression ratio 0.84) (raw pass, confidence 0.60)
```
 
 wsBcBAABCAAQBQJXI80ZCRA6pcNDcVZ70gAAarcIABs72xRX3FWeox349nh6ucJK
 CtwmBTusez2Zwmq895fQEbZK7jpaGO5TRO4OvjFxlRo0E08UFx3pxZHSpj6bsFeL
 hHsDXnCaotphLkbgKKRdGZo7tDqM84wuEDlh4MwNe7qlFC7bYLDyysc81ZX5lpMm
```
likely benign LLM, confidence 0.96 PGP base64 fixture for signed-commit tests.
Reasoning
Another PGP key/signature block in a test of a git object library; expected for testing commit signature parsing.
info ~~warn~~ → info by review encoding-base64 tests/test_objects.py:883:1

base64-like blob (389 bytes over 7 lines, compression ratio 0.84) (raw pass, confidence 0.60)
```
wsBcBAABCAAQBQJXI80ZCRA6pcNDcVZ70gAAarcIABs72xRX3FWeox349nh6ucJK
CtwmBTusez2Zwmq895fQEbZK7jpaGO5TRO4OvjFxlRo0E08UFx3pxZHSpj6bsFeL
hHsDXnCaotphLkbgKKRdGZo7tDqM84wuEDlh4MwNe7qlFC7bYLDyysc81ZX5lpMm
```
likely benign LLM, confidence 0.96 Repeated PGP base64 fixture in test file.
Reasoning
Duplicate of the PGP fixture block; legitimate test data.
info ~~warn~~ → info by review encoding-base64 tests/test_objects.py:915:1

base64-like blob (192 bytes over 3 lines, compression ratio 0.91) (raw pass, confidence 0.60)
```
iQIcBAABCgAGBQJULCdfAAoJEACAbyvXKaRXuKwP/RyP9PA49uAvu8tQVCC/uBa8
vi975+xvO14R8Pp8k2nps7lSxCdtCd+xVT1VRHs0wNhOZo2YCVoU1HATkPejqSeV
NScTHcxnk4/+bxyfk14xvJkNp7FlQ3npmBkA+lbV0Ubr33rvtIE5jiJPyz+SgWAg
```
likely benign LLM, confidence 0.96 PGP signature base64 fixture in test code.
Reasoning
PGP base64 signature fixture with standard armor structure; test data for a git library.
info ~~warn~~ → info by review encoding-base64 tests/test_objects.py:939:1

base64-like blob (128 bytes over 2 lines, compression ratio 0.92) (raw pass, confidence 0.60)
```
        ssh_sig = b"""-----BEGIN SSH SIGNATURE-----
U1NIU0lHAAAAAQAAADMAAAALc3NoLWVkMjU1MTkAAAAgJwKO3yOmR5JlXCyN5bys
ZTpDKBGsVP6ydcKdZxAvJlUAAAAEZmlsZQAAAAAAAAAGc2hhNTEyAAAAUwAAAAtz
-----END SSH SIGNATURE-----"""
```
likely benign LLM, confidence 0.96 SSH signature fixture in a test file.
Reasoning
Armored SSH signature block (BEGIN SSH SIGNATURE) inside a test for signed tag/commit handling; standard format test data.
info ~~warn~~ → info by review encoding-base64 tests/test_objects.py:1547:1

base64-like blob (88 bytes over 2 lines, compression ratio 1.06) (raw pass, confidence 0.60)
```
iD8DBQBGiAaAF3YsRnbiHLsRAitMAKCiLboJkQECM/jpYsY3WPfvUgLXkACgg3ql
OK2XeQOiEeXtT76rV4t2WR4=
=ivrA
```
likely benign LLM, confidence 0.96 Armored PGP fixture fragment in tests.
Reasoning
Short PGP base64 block with checksum line (=ivrA) is a standard armored fixture; benign test data.
info ~~warn~~ → info by review encoding-base64 tests/test_objects.py:1704:1

base64-like blob (88 bytes over 2 lines, compression ratio 1.06) (raw pass, confidence 0.60)
```
iD8DBQBGiAaAF3YsRnbiHLsRAitMAKCiLboJkQECM/jpYsY3WPfvUgLXkACgg3ql
OK2XeQOiEeXtT76rV4t2WR4=
=ivrA
```
likely benign LLM, confidence 0.96 Repeated armored PGP fixture in tests.
Reasoning
Duplicate of the armored PGP fixture; benign test data.
info ~~warn~~ → info by review encoding-base64 tests/test_objects.py:1725:1

base64-like blob (128 bytes over 2 lines, compression ratio 0.92) (raw pass, confidence 0.60)
```
-----BEGIN SSH SIGNATURE-----
U1NIU0lHAAAAAQAAADMAAAALc3NoLWVkMjU1MTkAAAAgJwKO3yOmR5JlXCyN5bys
ZTpDKBGsVP6ydcKdZxAvJlUAAAAEZmlsZQAAAAAAAAAGc2hhNTEyAAAAUwAAAAtz
-----END SSH SIGNATURE-----
```
likely benign LLM, confidence 0.96 Repeated SSH signature fixture in tests.
Reasoning
Duplicate SSH signature armor fixture; benign test data.
info ~~warn~~ → info by review payload-bytes-literal tests/test_patch.py:563:13

concatenated bytes literal contains 32 `\xNN` escapes (100% of content) — binary payload shape (ast pass, confidence 0.85)
```
        b1 = Blob.from_string(
            b"\x89\x50\x4e\x47\x0d\x0a\x1a\x0a"
            b"\x00\x00\x00\x0d\x49\x48\x44\x52"
            b"\x00\x00\x01\xd5\x00\x00\x00\x9f"
```
likely benign LLM, confidence 0.97 PNG header bytes used to construct a binary test blob.
Reasoning
A PNG file header (\x89PNG\r\n\x1a\n, IHDR) written as bytes literal to build a test blob for diff/patch handling of binary files; legitimate test data.
info ~~warn~~ → info by review payload-bytes-literal tests/test_patch.py:569:13

concatenated bytes literal contains 32 `\xNN` escapes (100% of content) — binary payload shape (ast pass, confidence 0.85)
```
        b2 = Blob.from_string(
            b"\x89\x50\x4e\x47\x0d\x0a\x1a\x0a"
            b"\x00\x00\x00\x0d\x49\x48\x44\x52"
            b"\x00\x00\x01\xd5\x00\x00\x00\x9f"
```
likely benign LLM, confidence 0.97 PNG bytes literal for binary diff test.
Reasoning
Same PNG byte fixture used for a second test blob in patch tests; benign.
info ~~warn~~ → info by review payload-bytes-literal tests/test_patch.py:607:13

concatenated bytes literal contains 32 `\xNN` escapes (100% of content) — binary payload shape (ast pass, confidence 0.85)
```
        b1 = Blob.from_string(
            b"\x89\x50\x4e\x47\x0d\x0a\x1a\x0a"
            b"\x00\x00\x00\x0d\x49\x48\x44\x52"
            b"\x00\x00\x01\xd5\x00\x00\x00\x9f"
```
likely benign LLM, confidence 0.97 PNG bytes literal in patch test.
Reasoning
Repeated PNG binary fixture in patch tests; legitimate binary-file test data.
info ~~warn~~ → info by review payload-bytes-literal tests/test_patch.py:613:13

concatenated bytes literal contains 32 `\xNN` escapes (100% of content) — binary payload shape (ast pass, confidence 0.85)
```
        b2 = Blob.from_string(
            b"\x89\x50\x4e\x47\x0d\x0a\x1a\x0a"
            b"\x00\x00\x00\x0d\x49\x48\x44\x52"
            b"\x00\x00\x01\xd5\x00\x00\x00\x9f"
```
likely benign LLM, confidence 0.97 PNG bytes literal in patch test.
Reasoning
Repeated PNG binary fixture for blob comparison in tests; benign.
info ~~warn~~ → info by review payload-bytes-literal tests/test_patch.py:635:13

concatenated bytes literal contains 32 `\xNN` escapes (100% of content) — binary payload shape (ast pass, confidence 0.85)
```
        b2 = Blob.from_string(
            b"\x89\x50\x4e\x47\x0d\x0a\x1a\x0a"
            b"\x00\x00\x00\x0d\x49\x48\x44\x52"
            b"\x00\x00\x01\xd5\x00\x00\x00\x9f"
```
likely benign LLM, confidence 0.97 PNG bytes literal in patch test.
Reasoning
Repeated PNG binary fixture in patch tests; benign test data.
info ~~warn~~ → info by review payload-bytes-literal tests/test_patch.py:656:13

concatenated bytes literal contains 32 `\xNN` escapes (100% of content) — binary payload shape (ast pass, confidence 0.85)
```
        b1 = Blob.from_string(
            b"\x89\x50\x4e\x47\x0d\x0a\x1a\x0a"
            b"\x00\x00\x00\x0d\x49\x48\x44\x52"
            b"\x00\x00\x01\xd5\x00\x00\x00\x9f"
```
likely benign LLM, confidence 0.95 Test fixture embedding PNG header bytes as a blob for a patch test.
Reasoning
The bytes literal begins with the PNG file signature (\x89PNG\r\n\x1a\n) followed by IHDR chunk bytes, which is a test fixture for creating a PNG blob in a dulwich-style Git patch test. Binary test data is expected in this context and there is no execution or hidden behavior.
info ~~warn~~ → info by review decoder-decompress-payload tests/test_patch.py:1574:38

file imports decoder module(s) zlib and calls `.decompress()` — embedded payload decompressed at runtime (ast pass, confidence 0.75)
```
        self.assertEqual(13, len(decoded))
        self.assertEqual(b"a\0c\0d", zlib.decompress(decoded))
        decoded = git_base85_decode(b"Kcmb<ms0083<N)#j\n")
        self.assertEqual(11, len(decoded))
```
likely benign LLM, confidence 0.95 Unit test decompressing a small known fixture to verify git base85 decoding.
Reasoning
zlib.decompress is applied to a literal expected value in a unit test, asserting that the decoded git base85 output equals b'a\0c\0d'. The data is a small known fixture, not a runtime-embedded payload being executed; this is ordinary test code in a Git library.
info ~~warn~~ → info by review encoding-base64 tests/test_signature.py:587:77

base64-like blob (68 bytes, compression ratio 1.16) (raw pass, confidence 0.60)
```
        test_content = 'valid-after="20260104" test@example.com ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIOMqqnkVzrm0SdG6UOoqKLsabgH5C9okWi0dh2l9GKJl'
        f = io.StringIO(test_content)
        signers = list(sshsig.allowed_signers.load_allowed_signers_file(f))
```
likely benign LLM, confidence 0.95 Test fixture containing an SSH ed25519 public key in an allowed_signers file.
Reasoning
The base64-like blob is an ssh-ed25519 public key string inside an allowed_signers test fixture, with the key type and standard base64 encoding of the key blob. It is a legitimate test input for parsing allowed signers files.

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/dulwich/dulwich dulwich && cd dulwich
git checkout dulwich-1.2.19
disclude scan --severity info --diff dulwich-1.2.18 .