| CVE |
Vendors |
Products |
Updated |
CVSS v3.1 |
| flowintel contains an authorization bypass in the file-to-note conversion feature for case tasks. When a task is in a restricted workflow state (Requested, Rejected, or Request Review) within a privileged case, the conversion endpoint did not enforce elevated role requirements. Any authenticated user with basic case membership (e.g., editor or queuer) could invoke the conversion action, causing the system to read the attached file contents and create a note on the restricted task.
This bypasses the intended workflow restriction that only Admin, Case Admin, or Queue Admin roles may modify tasks in those states. An attacker with a low-privilege account in a privileged case could:
- Extract file contents into note format, potentially circumventing file-level access controls
- Create unauthorized notes that alter the task's note count, modification timestamp, and case history
- Disrupt the review/approval workflow on restricted tasks
The vulnerability requires an authenticated user with at least editor-level access to the affected case and a task in one of the restricted states.
Affected versions: flowintel < 4.1.0 |
| flowintel contains a vulnerability in the MISP correlation feature that allows unauthorized disclosure of case identifiers.
The application failed to enforce proper access controls when generating correlation lists for MISP attributes. Specifically, the system did not verify whether the requesting user had permission to view the source case or the matching cases returned in the correlation results. This lack of authorization checks allowed authenticated users to potentially discover the existence of cases they do not have access to, leading to information disclosure.
The vulnerability affects the following components:
- Case correlation logic
- API endpoints for retrieving correlation attributes
- MISP object handling
Affected versions: < 4.1.0 |
| FlowIntel contains an authorization bypass in its task management workflow. When a user reopens a completed task (by toggling its completion state or changing its status to a non-finished value) or creates a new task within a completed privileged case, the parent case is automatically revived (un-completed, status reset to Created, finish date cleared). The system failed to enforce the required Admin or Case Admin privilege check before performing this case revival side effect.
A user with basic task-level permissions (e.g., editor, queuer, or queue admin) could trigger the revival of a completed privileged case through the browser interface or the REST API, without holding the elevated role required for case-level operations. This could disrupt case lifecycle management, clear completion metadata, and potentially expose the case to further unauthorized modifications.
The vulnerability affects both the browser-based task completion/status-change endpoints and the corresponding API endpoints, as well as the task creation flow.
Affected versions: FlowIntel prior to 4.1.0. |
| flowintel contains an authorization bypass in the browser-based admin user editing interface. The edit_user view in the admin panel verified that a non-platform-admin user could only edit accounts belonging to their own organization, but it did not verify that the target account was not a platform-admin account. As a result, an authenticated user holding an organization-admin role could open the edit form for any platform-admin account and submit modifications, including changes to credentials, roles, or other account attributes.
The API layer already enforced a restriction preventing non-admin users from targeting admin accounts, but the browser-based admin view lacked the equivalent check, creating an inconsistent authorization boundary.
Impact:
- Unauthorized modification of platform-admin account data (integrity)
- Potential lockout or privilege manipulation of platform administrators (availability)
- Escalation of an organization-admin role to effectively control platform-level administration
Affected versions: flowintel prior to 4.1.0. |
| flowintel contains an authorization flaw in its user deletion functionality. Organization-scoped administrators (org admins) are able to delete platform-level administrator accounts through both the browser-based admin interface and the REST API.
The existing authorization logic verified that an org admin could only target users within their own organization, but it did not enforce the privilege hierarchy between organization admins and platform admins. As a result, an authenticated org admin could issue a deletion request against any platform-admin account belonging to the same organization, causing the target account, its sessions, and related records to be permanently removed.
Impact:
- Loss of platform-level administrative oversight
- Potential disruption of platform-wide management functions
- Removal of higher-privilege accounts that should be protected from lower-privilege roles
Affected versions: flowintel prior to 4.1.0 |
| A vulnerability exists in the flowintel application's calendar functionality that allows unauthorized access to private case data. The task calendar queries failed to enforce visibility checks on the parent case associated with tasks. Specifically, tasks assigned to a user or belonging to the user's organization were returned in calendar views (including browser and API ICS feeds) without verifying whether the user had permission to view the parent case. This allowed users to potentially discover and access details of private cases they were not authorized to view, leading to information disclosure.
The issue affected the default task visibility logic and the assigned-only task queries. The fix ensures that case visibility is rechecked in addition to task assignment or organization membership, preventing the exposure of private case data in calendar outputs.
Affected versions: flowintel < 4.1.0 |
| flowintel contains an authorization flaw in its recurring reminder notification subsystem. When a user is subscribed to recurring notifications for a case, the system does not re-verify the recipient's current access rights to that case before generating or displaying the notification.
As a result, a user who previously had access to a private case and later had that access revoked can still:
- Receive recurring reminder notifications containing case-related content.
- View stored reminder notifications in their notification list, including notification counts, even though they no longer have permission to view the underlying case.
The vulnerability affects both the notification creation path (recurring reminder generation) and the notification display path (listing and counting stored reminders). The issue arises because the authorization check performed at subscription time is not re-applied at delivery or retrieval time.
Security impact is limited to information disclosure: an unauthorized user may observe case titles, reminder messages, and associated metadata that they no longer have permission to access. No integrity or availability impact is indicated by the patch.
Affected versions: flowintel prior to 4.1.0. |
| FlowIntel's alerting module contained an authorization bypass in the alert access control logic. When an alert was linked to a private case, the system relied solely on connector ownership (user or organization) to determine access, without verifying that the requesting user still held valid membership in the associated private case.
This meant that a user who was a connector owner of an alert could continue to read alert details, review history, raw payloads, and action comments, and could perform review-status updates or case-creation actions, even after their access to the linked private case had been revoked or they were never a member of that case.
Additionally, a time-of-check to time-of-use (TOCTOU) gap existed: after a review-status update or a competing case-creation claim was committed, the response could disclose private case identifiers or review history to a user whose access had been concurrently removed by another session linking the alert to a private case.
Impact:
- Unauthorized disclosure of private case data (review comments, raw payloads, action history) through alert endpoints.
- Unauthorized modification of alert review status and creation of cases from alerts the user should no longer access.
- Leakage of a competing case identifier to an unauthorized user during concurrent case-creation races.
Affected versions: FlowIntel prior to 4.1.0. |
| flowintel is a case management application that enforces an approval workflow for tasks in privileged cases. Tasks in such cases are required to start in a Requested status, meaning they must receive explicit approval before becoming active.
A logic flaw in the task-creation path allowed tasks to be initialized with a Created status (bypassing the approval step) in two scenarios:
- When a task was created from a template and no acting user was supplied, the privileged-case check was skipped entirely, leaving the task in Created status.
- When a case was created from a template, all copied tasks were unconditionally assigned the Created status regardless of the case's privileged designation.
An authenticated user with the ability to create tasks from templates or to instantiate cases from templates could therefore place tasks directly into an active state within privileged cases, circumventing the intended approval gate. This may expose restricted case content or permit actions that should require supervisory sign-off.
Affected versions: flowintel prior to 4.1.0. |
| FlowIntel's chatbot component used a single shared MCP (Model Context Protocol) session and process-wide environment variable to pass per-user API credentials to a child process. Because the session and the ambient FLOWINTEL_API_KEY environment variable were shared across all concurrent requests, a user's authenticated identity could be applied to another user's tool invocation, or a stale/ambient credential could be inherited by a new request.
Preconditions:
- An authenticated user with access to the chatbot interface.
- Concurrent or overlapping chatbot tool invocations from different users, or a request made after another user's credentials were written to the process environment.
Impact:
- A lower-privilege user could read data belonging to a higher-privilege user (e.g., private investigation cases).
- A user whose session was invalidated (deleted, password changed, key revoked) could still operate under a previously cached ambient credential.
- The parent process environment was mutated with user-specific secrets, creating a persistent credential leak surface.
Affected versions: FlowIntel prior to 4.1.0. |
| flowintel contains an information disclosure vulnerability in its case history feature. When a user views the history of a case they are authorized to access, the history output includes references to other cases (linked, unlinked, or forked) without verifying whether the requesting user has permission to view those referenced cases. This exposes the identifiers and titles of cases that the user should not be able to discover.
The vulnerability affects multiple output paths:
- Browser-based case history view
- API history endpoint
- Plain-text history download
- Markdown history download
- Report timeline generation
An authenticated user with access to any single case can enumerate the existence and identifiers of other cases by reading the history of a case they can access. This bypasses the intended per-case access control model and may reveal the existence of sensitive investigations, their identifiers, and associated metadata to unauthorized users.
The raw audit storage is not modified; the issue is solely in the presentation layer failing to filter references to inaccessible cases before returning history data to the user.
Affected versions: flowintel prior to 4.1.0. |
| Flowintel's community data launcher script passes the admin API key as a command-line argument to a child Python helper process. On Unix-like systems, process arguments are readable by all local users via standard tools such as ps or by reading /proc/<pid>/cmdline, allowing any local user to observe the key while the helper process is running.
An attacker with local access to the host can capture the admin API key during the brief window in which the helper process is active. Possession of the key grants full administrative access to the Flowintel REST API, enabling unauthorized creation, modification, or deletion of threat intelligence data, users, roles, and organisations.
Preconditions:
- The victim must invoke the community data import or deletion command (launch.sh -tdc or -dtdc) with the API key supplied as a positional argument.
- The attacker must have a local user account on the same host and be able to observe process listings during the helper execution window.
Impact:
- Disclosure of the Flowintel admin API key to any local user.
- Subsequent full administrative control over the Flowintel instance via its REST API.
Affected: <4.1.0 |
| Flowintel's template repository subsystem did not adequately constrain file access to the configured repository base directory. Two related weaknesses existed:
- Repository registration and editing accepted arbitrary local paths without verifying they resolved inside the configured REPOSITORY_BASE_PATH, allowing an authenticated user to point a repository at any readable directory on the host.
- Manifest and template file lookups used normalized (non-canonical) path joins and a startswith-based guard that could be bypassed by symbolic links, permitting reads of files outside the intended repository.
An authenticated user with the ability to add or edit a template repository could therefore cause the application to read and return the contents of arbitrary files readable by the service account, including configuration files, credentials, or other sensitive data.
Affected: Flowintel versions prior to 4.1.0. |
| FlowIntel contains a resource exhaustion vulnerability in its file-to-note conversion feature. When a user converts an attached CSV or JSON file into a case note, the application renders the data as a Markdown table by padding every row to the maximum column count. A crafted file with a small number of filled cells but a very large number of columns (or keys) causes the application to allocate a quadratic number of padded table cells, potentially exhausting a worker process in memory or CPU.
The same issue affects nested JSON values rendered inside table cells, where pretty-printed indentation further inflates the output size.
Preconditions:
- An authenticated user with access to a case in FlowIntel
- Ability to attach and convert a CSV or JSON file to a note
Impact:
- Denial of service: exhaustion of a worker process, potentially disrupting service for other users
- No confidentiality or integrity impact
Affected versions: FlowIntel prior to 4.1.0 |
| FlowIntel contains an authorization flaw in its duplicate alert ingestion logic. When a duplicate alert is received and its content is updated, the ownership and visibility scope fields (owner user and owner organization) were not refreshed to reflect the connector's current scope. As a result, an alert that was originally created under a broader visibility scope retained that broader scope even after the connector's scope was narrowed or changed.
This means that users or organizations that should no longer have visibility into a given alert could continue to access it, because the stale ownership fields were never updated during the duplicate-update path. The issue affected all duplicate updates, including those involving alerts in terminal review states and those recovered from uniqueness conflicts.
Security impact:
- Unauthorized disclosure of security alert content to users or organizations outside the intended visibility scope.
- Stale access persists indefinitely until the alert is independently re-scoped or deleted.
Affected version: <4.1.0. |
| flowintel allows users with editor-level access to author case and task fields, including aggregated tags. When these records are exported as CSV, the field values are written verbatim into the output file.
Because no sanitisation is applied to user-supplied text before CSV serialisation, an attacker can store values that begin with spreadsheet formula triggers (such as =, +, -, @, or their fullwidth Unicode equivalents, or leading control/whitespace characters). When a victim opens the exported CSV in a spreadsheet application (e.g. Microsoft Excel, LibreOffice Calc), the stored text is interpreted and executed as a live formula rather than displayed as literal text.
This can lead to unintended data manipulation within the spreadsheet, potential data exfiltration via formula functions, or execution of downstream commands depending on the spreadsheet application and its configuration.
The vulnerability requires the victim to actively open the CSV file in a spreadsheet application; the flowintel application itself is not directly compromised.
Affected: <4.1.0 |
| flowintel contains a CSV injection vulnerability in its audit log CSV export functionality. Attacker-influenced text recorded in audit logs could be interpreted as spreadsheet formulas when an administrator opened the exported CSV file in a spreadsheet application.
The vulnerable behavior allowed an attacker who could influence audit log content (for example by generating network traffic that is captured and logged) to embed formula-like strings (such as =CMD() or =HYPERLINK()) into audit entries. When the resulting CSV export was opened in a spreadsheet application, these strings could be executed as formulas, potentially leading to data exfiltration, data manipulation, or execution of further malicious actions within the spreadsheet context.
Preconditions:
- An attacker must be able to influence content that is recorded in flowintel audit logs.
- An administrator or user must export the audit logs to CSV and open the file in a spreadsheet application that interprets formulas.
Security impact:
- Potential information disclosure from the spreadsheet or linked resources.
- Potential integrity impact on data within the spreadsheet application.
- No direct compromise of the flowintel application itself.
Affected version: <4.1.0 |
| A SQL injection vulnerability exists in a database migration script in flowintel.
The migration process reads stored connector identifier values from the database and interpolates them directly into SQL statements without parameterization. An attacker who has previously written a malicious identifier value into the affected tables can cause arbitrary SQL execution when the migration is subsequently run during an application upgrade.
- Requires prior write access to the database to plant a malicious identifier value
- Triggered automatically during a migration or upgrade operation
- Can result in unauthorized data disclosure, modification, or deletion
Affected versions: flowintel prior to 4.0.0 |
| Affected versions of Flowintel expose the /my_assignment/user API endpoint to any authenticated API user. The endpoint accepts a user_id parameter identifying the user whose assignments should be returned, but previously had no role restriction beyond general API authentication.
As a result, a lower-privileged authenticated user could potentially query another user’s assignment information by supplying that user’s identifier.
The fix changes:
method_decorators = [api_required]
to:
method_decorators = [admin_or_org_admin_required, api_required]
so only administrators or organization administrators can perform cross-user assignment queries.
Version impacted =>3.3.0 |
| Affected versions of Flowintel contain an authorization flaw in the administrative user-edit API.
The existing authorization check correctly prevented an organization administrator from editing users in another organization, but it did not prevent them from editing a full administrator within their own organization. As a result, an org admin could modify that full administrator account, including changing its password. The upstream commit explicitly describes the issue as:
“Org admin can change the password of a full admin in the same organization.”
The fix adds a higher-privilege boundary check:
if user_to_edit.is_admin(): return ... 403
so organization administrators can no longer modify full administrator accounts.
Version impacted >=3.3.0 |