Find, fix and prevent vulnerabilities in your code.

Overview

urllib3 is a HTTP library with thread-safe connection pooling, file post, and more.

Affected versions of this package are vulnerable to Allocation of Resources Without Limits or Throttling during the decompression of compressed response data. An attacker can cause excessive CPU and memory consumption by sending responses with a large number of chained compression steps.

Workaround

This vulnerability can be avoided by setting preload_content=False and ensuring that resp.headers["content-encoding"] are limited to a safe quantity before reading.

Details

Denial of Service (DoS) describes a family of attacks, all aimed at making a system inaccessible to its intended and legitimate users.

Unlike other vulnerabilities, DoS attacks usually do not aim at breaching security. Rather, they are focused on making websites and services unavailable to genuine users resulting in downtime.

One popular Denial of Service vulnerability is DDoS (a Distributed Denial of Service), an attack that attempts to clog network pipes to the system by generating a large volume of traffic from many machines.

When it comes to open source libraries, DoS vulnerabilities allow attackers to trigger such a crash or crippling of the service by using a flaw either in the application code or from the use of open source libraries.

Two common types of DoS vulnerabilities:

• High CPU/Memory Consumption- An attacker sending crafted requests that could cause the system to take a disproportionate amount of time to process. For example, commons-fileupload:commons-fileupload.

• Crash - An attacker sending crafted requests that could cause the system to crash. For Example, npm ws package

Remediation

Upgrade urllib3 to version 2.6.0 or higher.

References

• GitHub Commit

Overview

urllib3 is a HTTP library with thread-safe connection pooling, file post, and more.

Affected versions of this package are vulnerable to Improper Handling of Highly Compressed Data (Data Amplification) in the Streaming API. The ContentDecoder class can be forced to allocate disproportionate resources when processing a single chunk with very high compression, such as via the stream(), read(amt=256), read1(amt=256), read_chunked(amt=256), and readinto(b) functions.

Note: It is recommended to patch Brotli dependencies (upgrade to at least 1.2.0) if they are installed outside of urllib3 as well, to avoid other instances of the same vulnerability.

Details

Denial of Service (DoS) describes a family of attacks, all aimed at making a system inaccessible to its intended and legitimate users.

Unlike other vulnerabilities, DoS attacks usually do not aim at breaching security. Rather, they are focused on making websites and services unavailable to genuine users resulting in downtime.

One popular Denial of Service vulnerability is DDoS (a Distributed Denial of Service), an attack that attempts to clog network pipes to the system by generating a large volume of traffic from many machines.

When it comes to open source libraries, DoS vulnerabilities allow attackers to trigger such a crash or crippling of the service by using a flaw either in the application code or from the use of open source libraries.

Two common types of DoS vulnerabilities:

• High CPU/Memory Consumption- An attacker sending crafted requests that could cause the system to take a disproportionate amount of time to process. For example, commons-fileupload:commons-fileupload.

• Crash - An attacker sending crafted requests that could cause the system to crash. For Example, npm ws package

Remediation

Upgrade urllib3 to version 2.6.0 or higher.

References

• GitHub Commit

Overview

urllib3 is a HTTP library with thread-safe connection pooling, file post, and more.

Affected versions of this package are vulnerable to Improper Handling of Highly Compressed Data (Data Amplification) via the streaming API when handling HTTP redirects. An attacker can cause excessive resource consumption by serving a specially crafted compressed response that triggers decompression of large amounts of data before any read limits are enforced.

Note: This is only exploitable if content is streamed from untrusted sources with redirects enabled.

Workaround

This vulnerability can be mitigated by disabling redirects by setting redirect=False for requests to untrusted sources.

Remediation

Upgrade urllib3 to version 2.6.3 or higher.

References

• GitHub Commit

Overview

GitPython is a python library used to interact with Git repositories

Affected versions of this package are vulnerable to Directory Traversal through insufficient validation of reference paths in the creation, renaming, and deletion. An attacker can write, overwrite, move, or delete files outside the intended directory by supplying crafted reference paths to the relevant APIs.

Details

A Directory Traversal attack (also known as path traversal) aims to access files and directories that are stored outside the intended folder. By manipulating files with "dot-dot-slash (../)" sequences and its variations, or by using absolute file paths, it may be possible to access arbitrary files and directories stored on file system, including application source code, configuration, and other critical system files.

Directory Traversal vulnerabilities can be generally divided into two types:

• Information Disclosure: Allows the attacker to gain information about the folder structure or read the contents of sensitive files on the system.

st is a module for serving static files on web pages, and contains a vulnerability of this type. In our example, we will serve files from the public route.

If an attacker requests the following URL from our server, it will in turn leak the sensitive private key of the root user.

curl http://localhost:8080/public/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/root/.ssh/id_rsa

Note %2e is the URL encoded version of . (dot).

• Writing arbitrary files: Allows the attacker to create or replace existing files. This type of vulnerability is also known as Zip-Slip.

One way to achieve this is by using a malicious zip archive that holds path traversal filenames. When each filename in the zip archive gets concatenated to the target extraction folder, without validation, the final path ends up outside of the target folder. If an executable or a configuration file is overwritten with a file containing malicious code, the problem can turn into an arbitrary code execution issue quite easily.

The following is an example of a zip archive with one benign file and one malicious file. Extracting the malicious file will result in traversing out of the target folder, ending up in /root/.ssh/ overwriting the authorized_keys file:

2018-04-15 22:04:29 .....           19           19  good.txt
2018-04-15 22:04:42 .....           20           20  ../../../../../../root/.ssh/authorized_keys

Remediation

Upgrade GitPython to version 3.1.48 or higher.

References

• GitHub Advisory
• GitHub Commit
• GitHub Release

Overview

GitPython is a python library used to interact with Git repositories

Affected versions of this package are vulnerable to Arbitrary Argument Injection via the check_unsafe_options process. An attacker can execute arbitrary commands by smuggling a malicious option token inside the value of a single-character keyword argument, which bypasses the intended guard and results in the execution of attacker-supplied commands.

Remediation

Upgrade GitPython to version 3.1.54 or higher.

References

• GitHub Advisory
• GitHub Commit
• GitHub PR
• GitHub Release

Overview

GitPython is a python library used to interact with Git repositories

Affected versions of this package are vulnerable to Arbitrary Argument Injection via the check_unsafe_options process. An attacker can execute arbitrary OS commands by supplying specially crafted keyword arguments that bypass internal option guards.

Remediation

Upgrade GitPython to version 3.1.58 or higher.

References

• GitHub Advisory
• GitHub Commit
• GitHub PR
• GitHub Release

Overview

GitPython is a python library used to interact with Git repositories

Affected versions of this package are vulnerable to Arbitrary Argument Injection via the set_value process. An attacker can execute arbitrary commands by injecting specially crafted option names that are written verbatim into the configuration file, resulting in unintended directives being parsed and executed during subsequent operations.

Remediation

Upgrade GitPython to version 3.1.58 or higher.

References

• GitHub Advisory
• GitHub Commit
• GitHub PR
• GitHub Release

Overview

GitPython is a python library used to interact with Git repositories

Affected versions of this package are vulnerable to Arbitrary Code Injection through Repo.__init__ and is_git_dir in git/repo/base.py and git/repo/fun.py. An attacker can execute arbitrary commands by supplying a repository whose tracked root files make GitPython treat the working-tree root as the git directory and then placing a malicious hooks/pre-commit there. When a victim opens or clones that repository and later calls repo.index.commit(), GitPython resolves the hook path inside attacker-controlled content instead of the real .git directory. That causes the pre-commit hook to run in the victim’s process, breaking the integrity of local repository operations.

Workarounds

• Do not open or clone untrusted repositories with GitPython unless you trust their tracked root files; attacker-controlled HEAD, gitdir, commondir, and hooks/ content can be treated as repository metadata and lead to hook execution.
• Avoid calling repo.index.commit() on repositories sourced from untrusted content; this is the operation that can execute a malicious tracked hooks/pre-commit in the victim process.

Remediation

Upgrade GitPython to version 3.1.60 or higher.

References

• GitHub Commit 3.1.60
• Maintainer's Advisory

Overview

GitPython is a python library used to interact with Git repositories

Affected versions of this package are vulnerable to Command Injection via the set_value function when the section parameter is not properly validated for newline characters. An attacker can execute arbitrary code by injecting malicious section headers into the .git/config file, which can redirect core.hooksPath to an attacker-controlled directory and trigger execution when a git hook runs.

Note: This vulnerability bypasses the patch for CVE-2026-42215.

Remediation

Upgrade GitPython to version 3.1.50 or higher.

References

• GitHub Advisory
• GitHub Commit

Overview

GitPython is a python library used to interact with Git repositories

Affected versions of this package are vulnerable to Directory Traversal through Repo.clone() and Repo.clone_from() in git/repo/base.py. An attacker can create a Git repository metadata directory outside the intended clone destination by supplying a separate_git_dir option to a clone request. This lets the attacker place and populate git metadata at an arbitrary filesystem path the process can write to, which can overwrite or seed another directory with repository state and related hook files.

Details

A Directory Traversal attack (also known as path traversal) aims to access files and directories that are stored outside the intended folder. By manipulating files with "dot-dot-slash (../)" sequences and its variations, or by using absolute file paths, it may be possible to access arbitrary files and directories stored on file system, including application source code, configuration, and other critical system files.

Directory Traversal vulnerabilities can be generally divided into two types:

• Information Disclosure: Allows the attacker to gain information about the folder structure or read the contents of sensitive files on the system.

st is a module for serving static files on web pages, and contains a vulnerability of this type. In our example, we will serve files from the public route.

If an attacker requests the following URL from our server, it will in turn leak the sensitive private key of the root user.

curl http://localhost:8080/public/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/root/.ssh/id_rsa

Note %2e is the URL encoded version of . (dot).

• Writing arbitrary files: Allows the attacker to create or replace existing files. This type of vulnerability is also known as Zip-Slip.

One way to achieve this is by using a malicious zip archive that holds path traversal filenames. When each filename in the zip archive gets concatenated to the target extraction folder, without validation, the final path ends up outside of the target folder. If an executable or a configuration file is overwritten with a file containing malicious code, the problem can turn into an arbitrary code execution issue quite easily.

The following is an example of a zip archive with one benign file and one malicious file. Extracting the malicious file will result in traversing out of the target folder, ending up in /root/.ssh/ overwriting the authorized_keys file:

2018-04-15 22:04:29 .....           19           19  good.txt
2018-04-15 22:04:42 .....           20           20  ../../../../../../root/.ssh/authorized_keys

Remediation

Upgrade GitPython to version 3.1.59 or higher.

References

• GitHub Commit
• Maintainer's Advisory

Overview

GitPython is a python library used to interact with Git repositories

Affected versions of this package are vulnerable to Information Exposure in the Repo.create_remote process when attacker-controlled URLs are passed and environment variables are expanded into the URL. An attacker can obtain sensitive environment secrets by supplying a crafted URL containing environment variable references, which are then expanded and stored in configuration files and transmitted to attacker-controlled servers during subsequent network operations.

Remediation

Upgrade GitPython to version 3.1.55 or higher.

References

• GitHub Advisory
• GitHub Commit
• GitHub Release

Overview

GitPython is a python library used to interact with Git repositories

Affected versions of this package are vulnerable to Insertion of Sensitive Information Into Sent Data via Git.polish_url() in Repo.clone_from() and the stored-origin normalization path in git/repo/base.py. An attacker can make the server send secrets to an attacker-controlled host by supplying a clone URL containing $NAME, ${NAME}, or %NAME% tokens. Repo.clone_from() passes the attacker-controlled URL through Git.polish_url() before invoking git clone, so the process environment is expanded into the remote URL on native and Cygwin platforms. That exposes values such as API tokens or cloud credentials in the outbound request, causing secret leakage whenever an application accepts untrusted repository URLs.

Notes

• The issue is exploitable in the common “import repository from URL” pattern, where a server-side service accepts a user-supplied clone URL and runs Repo.clone_from() under its own environment; the leaked values come from that process environment, so secrets like deployment tokens or cloud credentials can be disclosed without any separate secret-management misconfiguration.
• The stored-origin path is also in scope: after a successful clone, GitPython persists the normalized remote URL back into the repository config, so a URL containing expansion tokens can leave the secret embedded in the saved origin metadata as well as in the outbound clone request.

Remediation

Upgrade GitPython to version 3.1.52 or higher.

References

• GitHub Commit
• GitHub PR
• Maintainer's Advisory

Overview

GitPython is a python library used to interact with Git repositories

Affected versions of this package are vulnerable to Regular Expression Denial of Service (ReDoS) via the Actor._from_string parsing in git/util.py. An attacker can exhaust CPU and stall commit metadata access by supplying a crafted commit object whose author or committer header contains a long unterminated < delimiter. When GitPython reads .author or .committer from that commit, the backtracking in Actor.name_email_regex can block single-threaded processing for an extended time, causing denial of service for services that scan or display untrusted repositories.

Details

Denial of Service (DoS) describes a family of attacks, all aimed at making a system inaccessible to its original and legitimate users. There are many types of DoS attacks, ranging from trying to clog the network pipes to the system by generating a large volume of traffic from many machines (a Distributed Denial of Service - DDoS - attack) to sending crafted requests that cause a system to crash or take a disproportional amount of time to process.

The Regular expression Denial of Service (ReDoS) is a type of Denial of Service attack. Regular expressions are incredibly powerful, but they aren't very intuitive and can ultimately end up making it easy for attackers to take your site down.

Let’s take the following regular expression as an example:

regex = /A(B|C+)+D/

This regular expression accomplishes the following:

• A The string must start with the letter 'A'
• (B|C+)+ The string must then follow the letter A with either the letter 'B' or some number of occurrences of the letter 'C' (the + matches one or more times). The + at the end of this section states that we can look for one or more matches of this section.
• D Finally, we ensure this section of the string ends with a 'D'

The expression would match inputs such as ABBD, ABCCCCD, ABCBCCCD and ACCCCCD

It most cases, it doesn't take very long for a regex engine to find a match:

$ time node -e '/A(B|C+)+D/.test("ACCCCCCCCCCCCCCCCCCCCCCCCCCCCD")'
0.04s user 0.01s system 95% cpu 0.052 total

$ time node -e '/A(B|C+)+D/.test("ACCCCCCCCCCCCCCCCCCCCCCCCCCCCX")'
1.79s user 0.02s system 99% cpu 1.812 total

The entire process of testing it against a 30 characters long string takes around ~52ms. But when given an invalid string, it takes nearly two seconds to complete the test, over ten times as long as it took to test a valid string. The dramatic difference is due to the way regular expressions get evaluated.

Most Regex engines will work very similarly (with minor differences). The engine will match the first possible way to accept the current character and proceed to the next one. If it then fails to match the next one, it will backtrack and see if there was another way to digest the previous character. If it goes too far down the rabbit hole only to find out the string doesn’t match in the end, and if many characters have multiple valid regex paths, the number of backtracking steps can become very large, resulting in what is known as catastrophic backtracking.

Let's look at how our expression runs into this problem, using a shorter string: "ACCCX". While it seems fairly straightforward, there are still four different ways that the engine could match those three C's:

1. CCC
2. CC+C
3. C+CC
4. C+C+C.

The engine has to try each of those combinations to see if any of them potentially match against the expression. When you combine that with the other steps the engine must take, we can use RegEx 101 debugger to see the engine has to take a total of 38 steps before it can determine the string doesn't match.

From there, the number of steps the engine must use to validate a string just continues to grow.

By the time the string includes 14 C's, the engine has to take over 65,000 steps just to see if the string is valid. These extreme situations can cause them to work very slowly (exponentially related to input size, as shown above), allowing an attacker to exploit this and can cause the service to excessively consume CPU, resulting in a Denial of Service.

Remediation

Upgrade GitPython to version 3.1.60 or higher.

References

• GitHub Commit 3.1.60
• Maintainer's Advisory

Overview

GitPython is a python library used to interact with Git repositories

Affected versions of this package are vulnerable to Arbitrary Argument Injection via the Repo.archive(), Repo.iter_commits(), Repo.blame(), and Git.ls_remote() call paths in git/repo/base.py, git/objects/commit.py, and git/cmd.py. An attacker can execute arbitrary Git helpers or clobber files by supplying unsafe archive/ls-remote options or a revision string such as --output=/path to iter_commits() or blame(). In Repo.archive(), caller-controlled keyword arguments are forwarded into git archive, allowing options like --exec or --output; in Git.ls_remote(), upload_pack is turned into --upload-pack without rejection. In Repo.iter_commits() and Repo.blame(), a revision value placed before -- is parsed as a Git option, letting an attacker trigger file truncation or overwrite before revision parsing fails.

Notes

• Repo.archive() is only dangerous when callers forward user-influenced remote, exec, or output values; the write-up’s command-execution and file-clobber behavior depends on those arguments being passed through as archive options, not on ordinary tree export use.
• Repo.iter_commits() and Repo.blame() are exposed to the overwrite primitive when the revision string or rev_opts can begin with -; the affected path is the revision parser’s pre--- handling, so applications that only pass fixed refs or validated commit IDs miss the issue.

Workarounds

• Use allow_unsafe_options=False (the default) on Repo.archive(), Repo.iter_commits(), Repo.blame(), and git.ls_remote() and do not pass user-controlled options such as exec, output, rev_opts, or upload_pack; this blocks attacker-supplied Git flags from reaching helper execution or file-overwrite options.
• Set allow_unsafe_protocols=False on Repo.archive() and avoid remote= values that resolve to unsafe protocols such as ext::...; this prevents git archive from invoking an arbitrary remote helper path.

Remediation

Upgrade GitPython to version 3.1.51 or higher.

References

• GitHub Commit
• GitHub PR
• Maintainer's Advisory

Overview

GitPython is a python library used to interact with Git repositories

Affected versions of this package are vulnerable to External Control of File Name or Path through the Submodule._config_parser() path in git/objects/submodule/base.py. An attacker can disclose the first line of a readable local file by supplying a malicious .gitmodules file with an [include] directive and triggering normal submodule enumeration, such as repo.submodules. The parser used for .gitmodules inherits include merging, so it follows attacker-controlled include paths during read-only processing. If the included target is not valid git-config, parsing fails with an exception that can expose the file’s contents through the error message, breaking tools that inspect untrusted repositories.

Workarounds

• Disable or avoid processing untrusted repositories’ submodule metadata with GitPython operations such as repo.submodules / Submodule.iter_items() / Submodule.config() until the library is upgraded, so attacker-controlled .gitmodules files cannot trigger include parsing against local files.

Remediation

Upgrade GitPython to version 3.1.59 or higher.

References

• GitHub Commit 3.1.59
• Maintainer's Advisory

Overview

GitPython is a python library used to interact with Git repositories

Affected versions of this package are vulnerable to Arbitrary Code Injection via the set_value function. An attacker can achieve arbitrary code execution by injecting newline characters into configuration values, which allows the creation of malicious Git configuration entries such as core.hooksPath. This enables execution of attacker-controlled scripts during Git operations that invoke hooks.

Remediation

Upgrade GitPython to version 3.1.49 or higher.

References

• GitHub Advisory
• GitHub Commit
• GitHub Release

Overview

urllib3 is a HTTP library with thread-safe connection pooling, file post, and more.

Affected versions of this package are vulnerable to Insertion of Sensitive Information Into Sent Data in urlopen() when using ProxyManager.connection_from_url() with assert_same_host=False, directly rather than via the high-level APIs including urllib3.request(), PoolManager.request(), and ProxyManager.request(). An attacker can expose headers such as Authorization, Cookie, and Proxy-Authorization by triggering cross-origin redirects, which does not properly invoke remove_headers_on_redirect.

Remediation

Upgrade urllib3 to version 2.7.0 or higher.

References

• GitHub Advisory
• GitHub Commit

Overview

GitPython is a python library used to interact with Git repositories

Affected versions of this package are vulnerable to Remote Code Execution (RCE) due to improper user input validation, which makes it possible to inject a maliciously crafted remote URL into the clone command. Exploiting this vulnerability is possible because the library makes external calls to git without sufficient sanitization of input arguments. This is only relevant when enabling the ext transport protocol.

PoC

from git import Repo
r = Repo.init('', bare=True)
r.clone_from('ext::sh -c touch% /tmp/pwned', 'tmp', multi_options=["-c protocol.ext.allow=always"])

Remediation

Upgrade GitPython to version 3.1.30 or higher.

References

• GitHub Commit
• GitHub Issue
• Vulnerable Code

Overview

GitPython is a python library used to interact with Git repositories

Affected versions of this package are vulnerable to Untrusted Search Path allowing an attacker to run any arbitrary commands through a downloaded repository with a malicious git executable.

Note: This vulnerability affects only Windows systems.

PoC

On a Windows system, create a git.exe or git executable in any directory, and import or run GitPython from that directory

python -c "import git"

The git executable from the current directory will be run.

Remediation

Upgrade GitPython to version 3.1.33 or higher.

References

• GitHub Commit
• Python Docs

Overview

GitPython is a python library used to interact with Git repositories

Affected versions of this package are vulnerable to Untrusted Search Path via the use of an untrusted search path on Windows. An attacker can execute arbitrary code by placing a malicious git.exe or bash.exe in the current directory, which may then be executed instead of the legitimate binaries when certain GitPython features are used.

Notes:

1. This is a completion of the fix for CVE-2023-40590.

2. When GitPython runs git directly rather than through a shell, the GitPython process performs the path search, and omits the current directory by setting NoDefaultCurrentDirectoryInExePath in its own environment during the Popen call.

3. GitPython sets the subprocess CWD to the root of a repository's working tree. Using a shell will run a malicious git.exe in an untrusted repository even if GitPython itself is run from a trusted location. This also applies if git.execute is called directly with shell=True or after git.USE_SHELL = True, to run any command.

4. On Windows, GitPython uses bash.exe to run hooks that appear to be scripts. However, unlike when running git, no steps are taken to avoid finding and running bash.exe in the current directory. While bash.exe is a shell, this is a separate scenario from when git is run using the unrelated Windows cmd.exe shell.

PoC

mkdir testrepo
git init testrepo
cp ... testrepo\git.exe  # Replace "..." with any executable of choice.
python -c "import git; print(git.Repo('testrepo').git.version(shell=True))"

Remediation

Upgrade GitPython to version 3.1.41 or higher.

References

• GitHub Commit
• GitHub PR

Overview

GitPython is a python library used to interact with Git repositories

Affected versions of this package are vulnerable to Arbitrary Code Injection via the Repo.init process. An attacker can execute arbitrary code by supplying a malicious template parameter that points to a directory containing executable git hooks, which are then copied into the repository and triggered on subsequent git operations. This is only exploitable if the application forwards a user-controlled template argument and the attacker is able to stage an executable hook directory at a known path.

Remediation

Upgrade GitPython to version 3.1.58 or higher.

References

• GitHub Advisory
• GitHub Commit
• GitHub PR
• GitHub Release

Overview

GitPython is a python library used to interact with Git repositories

Affected versions of this package are vulnerable to Incomplete List of Disallowed Inputs through Git.check_unsafe_options in git/cmd.py. An attacker can execute arbitrary commands by supplying abbreviated unsafe option names such as upload_p in a clone, fetch, pull, or push call, causing GitPython’s exact-match blocklist to miss the option and pass it to Git as a dangerous long-option prefix. This can run attacker-controlled programs like --upload-pack or --receive-pack under the caller’s process, leading to remote code execution in applications that forward user-controlled keyword names into GitPython operations.

Notes

• Git’s unsafe-option guard is only exercised when the host application forwards user-controlled keyword names into clone, fetch, pull, or push; fixed call sites that pass literal option names are not exposed by this variant.
• The bypass hinges on Git’s long-option prefix parsing, so abbreviated spellings like upload_p can be interpreted as blocked command-executing options even when the exact unsafe name is not used.

Remediation

Upgrade GitPython to version 3.1.51 or higher.

References

• GitHub Commit
• GitHub PR
• Maintainer's Advisory

Overview

GitPython is a python library used to interact with Git repositories

Affected versions of this package are vulnerable to Incomplete List of Disallowed Inputs via the clone_from process. An attacker can execute arbitrary commands by supplying a crafted directory containing malicious hooks as the template parameter during a clone operation. This is only exploitable if the attacker can provide a directory with executable hooks accessible to the target system, such as through shared filesystems, upload directories, or attacker-writable network paths.

Remediation

Upgrade GitPython to version 3.1.54 or higher.

References

• GitHub Advisory
• GitHub Commit
• GitHub PR
• GitHub Release

Overview

GitPython is a python library used to interact with Git repositories

Affected versions of this package are vulnerable to Improper Neutralization of Special Elements in Output Used by a Downstream Component ('Injection') through improper sanitization of section or subsection names in configuration headers. An attacker can inject arbitrary configuration directives by supplying specially crafted submodule names, leading to the execution of malicious commands during subsequent git operations.

Remediation

Upgrade GitPython to version 3.1.53 or higher.

References

• GitHub Advisory
• GitHub Commit
• GitHub Release

Overview

GitPython is a python library used to interact with Git repositories

Affected versions of this package are vulnerable to Arbitrary Argument Injection via the diff process. An attacker can overwrite or corrupt arbitrary files with attacker-influenced diff content by injecting malicious arguments into the other parameter or by supplying crafted keyword arguments, leading to unauthorized file modification at the process privilege level.

Remediation

Upgrade GitPython to version 3.1.54 or higher.

References

• GitHub Advisory
• GitHub Commit
• GitHub PR
• GitHub Release

Overview

GitPython is a python library used to interact with Git repositories

Affected versions of this package are vulnerable to Arbitrary Argument Injection via the from_tree, reset, or merge_tree process. An attacker can overwrite or destroy arbitrary files with a valid git-index blob by injecting malicious arguments into the positional parameters, leading to file corruption or loss at attacker-controlled writable locations.

Remediation

Upgrade GitPython to version 3.1.58 or higher.

References

• GitHub Advisory
• GitHub Commit
• GitHub PR
• GitHub Release

Overview

GitPython is a python library used to interact with Git repositories

Affected versions of this package are vulnerable to External Control of File Name or Path via the forwarding of unguarded options in the checkout and create functions. An attacker can overwrite arbitrary files or read arbitrary files by supplying crafted arguments to these functions, which are then passed directly to underlying git commands without proper validation.

Remediation

Upgrade GitPython to version 3.1.57 or higher.

References

• GitHub Advisory
• GitHub Commit
• GitHub PR
• GitHub Release

Overview

GitPython is a python library used to interact with Git repositories

Affected versions of this package are vulnerable to Arbitrary Argument Injection via the Repo.blame() and Repo.blame_incremental() option check in git/repo/base.py. An attacker can read local files by supplying a blame revision such as --contents=/etc/passwd or -S=/path/to/file, which git blame echoes into the blame output returned to the caller. The vulnerable guard only screened revision options against a denylist that did not include these file-reading blame options, so applications that forward user-controlled revision strings into Repo.blame() or Repo.blame_incremental() expose host-file contents at the privileges of the process.

Remediation

Upgrade GitPython to version 3.1.59 or higher.

References

• GitHub Commit 3.1.59
• Maintainer's Advisory

Overview

GitPython is a python library used to interact with Git repositories

Affected versions of this package are vulnerable to Arbitrary Argument Injection through the high-level diff API in git/diff.py and git/repo/base.py. An attacker can turn repo.index.diff(..., no_index=True) into a blind local-file content oracle by supplying --no-index together with attacker-chosen paths and an -I/--ignore-matching-lines pattern. This lets the child git process treat the supplied operands as arbitrary filesystem paths, exposing local file content through distinguishable success-or-error responses and allowing repeated queries to recover secrets readable by the process running GitPython.

Remediation

Upgrade GitPython to version 3.1.60 or higher.

References

• GitHub Commit 3.1.60
• Maintainer's Advisory

Overview

GitPython is a python library used to interact with Git repositories

Affected versions of this package are vulnerable to External Control of File Name or Path in the Repo.archive. An attacker can access arbitrary files on the filesystem by supplying specially crafted options that are not properly denied by the existing guard, such as --add-file or --add-virtual-file, which allow reading files outside the intended repository and including their contents in the generated archive.

Remediation

Upgrade GitPython to version 3.1.57 or higher.

References

• GitHub Advisory
• GitHub Commit
• GitHub PR
• GitHub Release

Overview

GitPython is a python library used to interact with Git repositories

Affected versions of this package are vulnerable to External Control of File Name or Path via the handling of submodule names in the .gitmodules configuration. An attacker can cause arbitrary directories and Git repositories to be created outside the intended working tree by supplying a crafted submodule name containing directory traversal sequences. This can lead to unauthorized modification of the filesystem and potential disruption of system integrity when a victim clones a malicious repository and initializes submodules.

Remediation

Upgrade GitPython to version 3.1.58 or higher.

References

• GitHub Advisory
• GitHub Commit
• GitHub Commit
• GitHub PR
• GitHub Release

Overview

GitPython is a python library used to interact with Git repositories

Affected versions of this package are vulnerable to External Control of File Name or Path in the remove and checkout functions. An attacker can access the contents of arbitrary files by supplying crafted arguments to these functions, causing the entire file contents to be returned in error messages.

Remediation

Upgrade GitPython to version 3.1.58 or higher.

References

• GitHub Advisory
• GitHub Commit
• GitHub PR
• GitHub Release

Overview

GitPython is a python library used to interact with Git repositories

Affected versions of this package are vulnerable to External Control of File Name or Path via the TagReference.create() function in git/refs/tag.py. An attacker can read local files by supplying a positional reference value such as --file=<path> when an application passes user-controlled input into TagReference.create(); git tag treats that value as a file-reading option and returns the file contents in the annotated tag message.

Remediation

Upgrade GitPython to version 3.1.59 or higher.

References

• GitHub Commit 3.1.59
• Maintainer's Advisory