CVE-2026-81662 in Flowintel
Summary
by MITRE • 08/27/2026
Affected versions of Flowintel improperly trust configuration keys supplied to the alerts settings update endpoint. While configuration values were normalized to Python literals, the corresponding keys were used directly when constructing and replacing lines in conf/config_module.py.
The vulnerable code used requester-controlled keys in both the regular expression and the generated assignment:
f'{key} = {py_val}'
and appended an assignment if the key was not already present. The modified Python configuration module was subsequently reloaded using importlib.reload(). This creates a code-generation boundary in which specially crafted configuration keys can alter the Python source structure and result in execution of attacker-controlled Python statements.
Version impacted >=3.3.0
If you want to get best quality of vulnerability data, you may have to visit VulDB.
Analysis
by VulDB Data Team • 08/27/2026
The vulnerability identified in Flowintel versions 3.3.0 and later represents a critical server-side request forgery combined with code injection flaws, specifically categorized under CWE-94 Improper Control of Generation of Code (Code Injection) and CWE-200 Exposure of Sensitive Information to an Unauthorized Actor if the configuration contains secrets. The root cause lies in the improper trust placed in user-supplied input within the alerts settings update endpoint. While the application correctly normalizes the values provided by users into safe Python literals, it fails to apply similar validation or sanitization logic to the keys associated with those configurations. This asymmetry creates a dangerous attack surface where an attacker can manipulate the structural integrity of the configuration file rather than just its data content.
The technical mechanism of exploitation relies on the application's method for persisting and loading configuration changes. When a request is received, the system constructs a Python assignment statement using the raw, requester-controlled key concatenated with the sanitized value in the format f'{key} = {py_val}'. This string is then used to either replace an existing line or append a new one within the conf/config_module.py file. Crucially, after modifying this source code file, the application utilizes importlib.reload() to dynamically reload the module into memory without restarting the service. This dynamic reloading feature, while convenient for development and hot-patching scenarios, effectively turns the configuration update endpoint into an arbitrary code execution vector when combined with unsanitized keys.
An attacker can exploit this flaw by supplying a specially crafted key that contains Python syntax elements such as semicolons, newlines, or function calls. For instance, if an attacker provides a key like "test; import os", the resulting line written to the configuration file becomes "test; import os = value". When importlib.reload() executes this modified module, it parses and compiles the Python code, thereby executing the injected commands within the context of the running application process. This allows for remote code execution with the privileges of the Flowintel service account, potentially leading to full system compromise, data exfiltration, or lateral movement within the network environment.
From a threat intelligence perspective, this vulnerability aligns with MITRE ATT&CK techniques related to Command and Scripting Interpreter abuse (T1059) and Defense Evasion through masquerading as legitimate configuration files (T1036). The ability to inject arbitrary Python code via a web endpoint bypasses traditional input validation controls that focus solely on value sanitization, highlighting the necessity of validating both keys and values in dynamic code generation scenarios. This type of vulnerability is particularly severe because it does not require authentication if the alerts settings endpoint is publicly accessible or if session hijacking has occurred, making it a high-risk target for automated scanning tools.
Mitigation strategies must address both immediate remediation and long-term architectural improvements. The most effective fix involves implementing strict allow-listing for configuration keys to ensure that only predefined, safe identifiers are accepted by the update endpoint. Alternatively, applying rigorous input validation using regular expressions or dedicated sanitization libraries can strip out any non-alphanumeric characters except those strictly necessary for valid Python variable names. Developers should also avoid using importlib.reload() in production environments due to its inherent risks; instead, configuration changes should trigger a controlled service restart or use a safer dynamic loading mechanism that does not execute arbitrary code from user-controlled strings. Additionally, applying the principle of least privilege ensures that even if exploitation occurs, the impact is contained by restricting the permissions of the process running Flowintel.