CVE-2022-36069 in Poetry
Summary
by MITRE • 09/07/2022
Poetry is a dependency manager for Python. When handling dependencies that come from a Git repository instead of a registry, Poetry uses various commands, such as `git clone`. These commands are constructed using user input (e.g. the repository URL). When building the commands, Poetry correctly avoids Command Injection vulnerabilities by passing an array of arguments instead of a command string. However, there is the possibility that a user input starts with a dash (`-`) and is therefore treated as an optional argument instead of a positional one. This can lead to Code Execution because some of the commands have options that can be leveraged to run arbitrary executables. If a developer is exploited, the attacker could steal credentials or persist their access. If the exploit happens on a server, the attackers could use their access to attack other internal systems. Since this vulnerability requires a fair amount of user interaction, it is not as dangerous as a remotely exploitable one. However, it still puts developers at risk when dealing with untrusted files in a way they think is safe, because the exploit still works when the victim tries to make sure nothing can happen, e.g. by vetting any Git or Poetry config files that might be present in the directory. Versions 1.1.9 and 1.2.0b1 contain patches for this issue.
If you want to get best quality of vulnerability data, you may have to visit VulDB.
Analysis
by VulDB Data Team • 09/08/2022
CVE-2022-36069 represents a command injection vulnerability in Poetry, a popular Python dependency management tool that has been widely adopted in development environments. This vulnerability stems from how Poetry processes Git repository URLs when resolving dependencies, creating a path for attackers to execute arbitrary code through manipulated input parameters. The flaw occurs specifically when Poetry constructs Git commands using user-provided repository URLs, where the tool properly employs array-based argument passing to prevent traditional command injection attacks but fails to account for a critical edge case involving argument parsing. When a Git repository URL begins with a dash character, it gets interpreted as a command-line option rather than a positional argument, which can be exploited to inject malicious parameters into Git commands.
The technical implementation of this vulnerability leverages the fact that Git commands support various options that can be used to execute arbitrary code or modify command behavior in unintended ways. This type of vulnerability falls under CWE-77 and CWE-78 categories, representing command injection flaws that occur when user input is not properly sanitized before being passed to system commands. The attack vector requires user interaction, making it a local privilege escalation or supply chain attack rather than a remote code execution vulnerability, but it remains highly dangerous in development environments where trust is placed in configuration files. The vulnerability's impact extends beyond immediate code execution to include credential theft, persistence mechanisms, and potential lateral movement within internal networks, particularly when developers unknowingly process untrusted repository configurations.
The exploitation scenario typically involves an attacker crafting a malicious Git repository URL that begins with a dash character, which then gets interpreted as a Git option that can trigger arbitrary command execution. This attack is particularly insidious because it can bypass security measures that developers implement to verify configuration files, as the malicious input appears legitimate when examined through standard vetting processes. The vulnerability affects Poetry versions prior to 1.1.9 and 1.2.0b1, with patches implemented to properly sanitize input parameters and ensure that repository URLs are treated as positional arguments regardless of their starting character. From an operational perspective, this vulnerability demonstrates the critical importance of input validation and proper argument handling in security-sensitive applications, particularly those that interface with system commands or external tools. Organizations should prioritize updating their Poetry installations and implementing proper code review processes for dependency management configurations to prevent exploitation of this class of vulnerabilities. The ATT&CK framework categorizes this type of vulnerability under T1059.001 (Command and Scripting Interpreter: PowerShell) and T1027 (Obfuscated Files or Information) as it involves manipulating command execution through parameter injection techniques that can be used to establish persistence and maintain access to compromised systems.