Saku0512
Source-scoped identity with 7 associated PoCs and 7 linked vulnerabilities.
Exploit catalog results
Showing 7 PoCs on this page
GitHubSaku0512/CVE-2026-9086-poc
Repository PoCStars: 1Created 2026-08-10ScannerCVE-2026-90864 files
Analysis
Technical assessment
A Python script that authenticates to a Keycloak Admin REST API, creates a client with a mixed-case prohibited redirect URI, and checks whether the server accepts (vulnerable) or rejects (fixed) the URI. It does not open the URI or execute JavaScript.
Backdoor review
No backdoor observed in reviewed code
The PoC demonstrates a known CVE-2026-9086 XSS vulnerability by registering a mixed-case redirect URI via the Keycloak Admin REST API and checking the response. The Python script (exploit.py) only performs API calls to authenticate, create a client, and verify the stored URI; it does not open the URI, execute JavaScript, establish persistence, or contact any external system. The README files explicitly state the PoC never opens the registered URI or executes JavaScript. No concealed, deceptive, or operator-directed harmful behavior is present in the reviewed text.
Classification basis and observed behavior
Classification basis
The artifact's primary operation is to check whether a Keycloak instance accepts a mixed-case prohibited URI, reporting 'VULNERABLE' or 'FIXED' based on the server response. It does not deliver a payload to a victim, trigger XSS execution, or exploit the vulnerability for impact. The README explicitly states 'The PoC never opens the registered URI or executes JavaScript' and the script docstring confirms it 'never opens the URI or executes its contents'. This is consistent with a scanner that validates exposure rather than an exploit that exercises the vulnerability.
README.en.md:20exploit.py:5-6exploit.py:203-215Requirements
- Administrative credentials with manage-client permission or access to client registration endpoints
README.en.md:39-40 - A running Keycloak instance accessible over the network
exploit.py:129-131
Observed behavior
- Obtains an administrator access token via the password grant type
exploit.py:50-76 - Creates a client with a mixed-case javascript: or data: redirect URI
exploit.py:79-102 - Checks the HTTP response status to determine if the URI was accepted (201) or rejected (400)
exploit.py:187-218 - On acceptance, retrieves the created client and verifies the crafted URI was stored
exploit.py:105-119 - Does not open a browser, navigate to the stored URI, or execute JavaScript
README.en.md:20exploit.py:5-6
Behaviors behind the backdoor verdict
Observables
- Api Endpoint
- Payload withheldThe script obtains an admin token from the local Keycloak instance.
exploit.py:51 - Api Endpoint
- Payload withheldThe script creates a client with the crafted redirect URI on the local Keycloak instance.
exploit.py:86 - Payload
- Payload withheldMixed-case javascript: URI used to test the validation bypass; never executed by the PoC.
exploit.py:21 - Payload
- Payload withheldMixed-case data: URI used to test the validation bypass; never executed by the PoC.
exploit.py:22-25
What the analysis did not establish
- One file (docker-compose.yml) is omitted from the evidence; its content is not available for analysis.
- The evidence does not include the execution output or network traffic, so the scanner's behavior is inferred from source code and documentation only.
- One file (docker-compose.yml, 549 bytes) was present in the artifact but not included as readable text; its content was not reviewed.
- Binary files were not present, so no binary analysis was performed.
This review is limited to the supplied PoC code and context. It does not assert that the code works or is safe to execute.
GitHubSaku0512/CVE-2026-71557-poc
Repository PoCStars: 0Created 2026-08-08ExploitCVE-2026-715576 files
Analysis
Technical assessment
A Go proof-of-concept that exploits CVE-2026-71557, a path traversal vulnerability in go-git. It creates a temporary filesystem-backed Git storage, writes a marker to .git/config, then calls SetReference with a crafted reference name containing directory traversal sequences (payload withheld) to overwrite .git/config, demonstrating the vulnerability.
Backdoor review
No backdoor observed in reviewed code
The PoC demonstrates the CVE-2026-71557 path traversal vulnerability by calling the go-git API to overwrite a dummy .git/config file within a temporary directory. All operations are confined to a local sandbox, and no concealed executable behavior, persistence, credential theft, or unrelated payloads are present in the reviewed source code.
Classification basis and observed behavior
Classification basis
The code directly exercises the vulnerable API (SetReference) with a malicious reference name to overwrite a file outside the intended directory, which is the definition of an exploit. It does not merely check for the vulnerability; it actively triggers the path traversal to modify .git/config.
poc.go:18poc.go:62-63poc.go:83-85README.en.md:7-8Requirements
- Go 1.25 or later, or a Go installation with automatic toolchain download
README.en.md:65-66 - Network access for the initial module download
README.en.md:66
Observed behavior
- Creates a temporary directory and initializes filesystem-backed Git storage
poc.go:37-55 - Writes a harmless marker to .git/config
poc.go:57-60 - Calls SetReference with a crafted reference name containing path traversal (payload withheld) to overwrite .git/config
poc.go:18poc.go:62-63 - Verifies that the reference hash replaced the marker, confirming the vulnerability
poc.go:64-71poc.go:83-85
Behaviors behind the backdoor verdict
Observables
- Path Traversal Payload
- Payload withheldCrafted reference name used to trigger the vulnerability and overwrite .git/config.
poc.go:18 - Temporary Directory Usage
- Payload withheldThe PoC creates a temporary directory for the test repository, isolating its effects from the host system.
poc.go:37 - Cleanup Behavior
- Payload withheldThe temporary directory is automatically removed unless the -keep flag is used, preventing persistent changes.
poc.go:44
What the analysis did not establish
- Two files (scripts/run-version-matrix.sh and one other) are omitted from the evidence; their content is not provided.
- The evidence does not include the go.sum file, which may be needed to verify module integrity.
- The PoC targets a local temporary directory and does not demonstrate the full attack chain involving a malicious Git server.
- Two text files (scripts/run-version-matrix.sh and go.sum) were omitted from the evidence packet and were not reviewed.
- The review is limited to static analysis of the provided source code; no dynamic analysis or execution was performed.
This review is limited to the supplied PoC code and context. It does not assert that the code works or is safe to execute.
GitHubSaku0512/CVE-2026-54761-poc
Repository PoCStars: 0Created 2026-06-19ExploitCVE-2026-547616 files
Analysis
Technical assessment
The artifact is a Proof of Concept (PoC) exploit for payload withheld. It provides a script and Kubernetes manifests to create a local kind cluster running a vulnerable version of Traefik (v3.7.1) and demonstrates a crossProviderNamespaces bypass. The exploit route uses multiple weighted backendRefs to expose the internal api@internal service from an unauthorized namespace, while a control route with a single backendRef is correctly blocked.
Backdoor review
No backdoor observed in reviewed code
The supplied evidence consists of documentation and a Kubernetes manifest for a payload withheld proof-of-concept. The README files describe the vulnerability and how to run the PoC in a local kind cluster. The gateway-exploit.yaml manifest defines namespaces, a deployment, a service, a ReferenceGrant, a Gateway, and two HTTPRoutes that demonstrate the authorization bypass. No backdoor, deceptive payload, or concealed operator-directed harm is present in the reviewed text. The artifact is a straightforward educational PoC that exploits the described CVE against a local Traefik instance.
Classification basis and observed behavior
Classification basis
The artifact is classified as an exploit because it includes a complete, executable script and Kubernetes manifests designed to actively exercise the vulnerability by deploying a vulnerable Traefik instance and triggering the bypass to expose an internal service. The README explicitly describes it as a 'Proof of Concept' that demonstrates the vulnerability in an isolated environment.
README.en.md:6README.en.md:60-69README.en.md:100-108Requirements
- Ability to create an HTTPRoute in an unauthorized namespace and a matching ReferenceGrant in an authorized namespace.
README.en.md:8 - Traefik Kubernetes Gateway provider configured with a crossProviderNamespaces allowlist.
README.en.md:66
Observed behavior
- Creates a local kind cluster with Traefik v3.7.1 and Gateway API CRDs.
README.en.md:62-66 - Deploys a control HTTPRoute with a single backendRef to api@internal from the 'attacker' namespace, which is expected to return a 404 error.
README.en.md:94-98 - Deploys an exploit HTTPRoute with multiple weighted backendRefs, including api@internal, from the 'attacker' namespace, which successfully exposes the Traefik API.
README.en.md:100-108 - The exploit route's backendRefs include a TraefikService pointing to api@internal in the 'trusted' namespace and a regular Service in the 'attacker' namespace.
external-repro-kind/gateway-exploit.yaml:116-127
Behaviors behind the backdoor verdict
Observables
- Cve Reference
- Payload withheldThe artifact is a PoC for this specific Traefik vulnerability, as stated in the README files.
README.en.md:6 - Execution Instruction
- Payload withheldThe README instructs the user to run a shell script to reproduce the vulnerability in a local kind cluster. The script itself is not included in the reviewed evidence.
README.en.md:80-82 - Kubernetes Manifest
- Payload withheldThis manifest creates the resources needed to demonstrate the CVE, including an HTTPRoute that bypasses the crossProviderNamespaces allowlist.
external-repro-kind/gateway-exploit.yaml:1-127
What the analysis did not establish
- The evidence packet does not include the content of the shell script 'run-kind-repro.sh' or the YAML files 'kind-config.yaml' and 'traefik-v371.yaml', which are necessary for the full end-to-end reproduction. Only the README files and the 'gateway-exploit.yaml' manifest are provided.
- The run-kind-repro.sh script and other YAML files (kind-config.yaml, traefik-v371.yaml) are not included in the reviewed text. Their contents are unknown and could contain backdoor behavior not visible in the supplied evidence.
- Binary files are reported as present but not analyzed; their contents are unknown.
- The review is limited to the supplied text evidence and does not verify the safety of executing the PoC.
This review is limited to the supplied PoC code and context. It does not assert that the code works or is safe to execute.
GitHubSaku0512/CVE-2026-54686-poc
Repository PoCStars: 0Created 2026-06-16ScannerCVE-2026-546863 files
Analysis
Technical assessment
The artifact is a local Python script that simulates Warp's DCS lifecycle hook processing to demonstrate whether spoofed CWD and SSH metadata hooks are accepted (vulnerable mode) or rejected (fixed mode). It does not connect to Warp, send network traffic, or execute attacker-controlled commands; it only checks the modeled behavior.
Backdoor review
No backdoor observed in reviewed code
The PoC consists of two README files and a single Python script (poc.py) that locally simulates the CVE-2026-54686 vulnerability. The script does not connect to any network service, does not execute arbitrary commands, and does not contain any concealed or deceptive behavior. It only demonstrates how missing session-ID validation could allow spoofed DCS hooks to alter in-memory terminal model state. No backdoor, trojan, or suspicious behavior is present.
Classification basis and observed behavior
Classification basis
The script does not exploit a live Warp instance; it only simulates the vulnerable and fixed behavior locally to check whether spoofed hooks would be accepted or rejected. This is a scanner that validates the vulnerability condition without exercising it against a real target.
poc.py:1-10README.en.md:18-22Requirements
- Python 3 runtime
README.en.md:71-75
Observed behavior
- Simulates a vulnerable Warp model that accepts spoofed Precmd and SSH DCS hooks without session_id validation, updating internal CWD and SSH metadata state.
poc.py:44-56poc.py:57-80poc.py:152-178poc.py:181-210 - Simulates a fixed Warp model that rejects state-mutating DCS hooks with missing or unregistered session_id values.
poc.py:57-80poc.py:148-149 - Prints VULNERABLE or FIXED status messages based on whether the simulated model accepted or rejected the spoofed hooks.
poc.py:223-232
Behaviors behind the backdoor verdict
Observables
- Script Behavior
- Payload withheldThe script's docstring and code confirm it does not interact with Warp, open SSH connections, or execute attacker-controlled commands.
poc.py:2-9 - Script Behavior
- Payload withheldNo imports of networking, subprocess, or persistence-related modules are present.
poc.py:14-18 - Script Behavior
- Payload withheldNo hidden functionality or conditional malicious behavior is triggered by any argument combination.
poc.py:261-296
What the analysis did not establish
- The artifact is a simulation and does not demonstrate exploitation against a real Warp terminal.
- No network or process interaction is performed; the code only models internal state changes.
- Only the three text files (README.en.md, README.md, poc.py) were provided; no binary or other files exist in the repository according to the evidence metadata.
This review is limited to the supplied PoC code and context. It does not assert that the code works or is safe to execute.
GitHubSaku0512/CVE-2026-48732-poc
Repository PoCStars: 0Created 2026-06-10ScannerCVE-2026-487323 files
Analysis
Technical assessment
The artifact is a local simulation that demonstrates the vulnerable command construction pattern for CVE-2026-48732. It builds a shell command using an attacker-controlled path, executes it locally, and checks for a marker file to confirm whether command injection occurred. It does not connect to Warp or SSH, and only validates the injection pattern in a controlled local environment.
Backdoor review
No backdoor observed in reviewed code
The PoC simulates the CVE-2026-48732 command injection locally using a marker file. All code is readable Python that constructs and executes a shell command derived from a hardcoded malicious path. No concealed payload, persistence, credential theft, or unrelated remote access is present. The script only creates a user-specified marker file to demonstrate the injection.
Classification basis and observed behavior
Classification basis
The artifact's primary operation is to locally simulate the vulnerable command pattern and check for a marker file to confirm injection behavior. It does not exploit a live Warp instance or SSH connection; it only validates the vulnerability pattern. This matches the definition of a scanner (code that checks for a vulnerability without exploiting it).
poc.py:5-7poc.py:115poc.py:124-127README.en.md:57Requirements
- Python 3 must be installed to run the simulation script.
README.en.md:57
Observed behavior
- The script constructs a malicious working directory path containing a single quote to break out of the cd argument and inject a touch command.
poc.py:99-101 - The script executes the generated command locally via /bin/sh and checks whether a marker file was created.
poc.py:115poc.py:124-127 - The script does not connect to Warp or any remote SSH host; it only simulates the vulnerable command construction locally.
README.en.md:57
Behaviors behind the backdoor verdict
Observables
- File Creation
- Payload withheldThe script creates a marker file to confirm command injection. This is the stated PoC behavior and not a backdoor.
poc.py:20poc.py:99-101poc.py:124-127 - Shell Execution
- Payload withheldThe script executes the constructed command locally via /bin/sh. This is the core of the PoC demonstration and is clearly documented.
poc.py:51-57poc.py:115
What the analysis did not establish
- The evidence does not include any binary files or network captures; analysis is based solely on the provided source code and documentation.
- The script is a local simulation and does not demonstrate exploitation against a live Warp instance or remote SSH host.
- Review is limited to the three supplied text files; no binary or external network content was analyzed.
- The script's use of subprocess.run with a constructed command could be dangerous if the marker path were attacker-controlled, but the default marker is hardcoded and the script does not accept arbitrary commands.
This review is limited to the supplied PoC code and context. It does not assert that the code works or is safe to execute.
GitHubSaku0512/CVE-2026-54088-poc
Repository PoCStars: 0Created 2026-06-03ExploitCVE-2026-540886 files
Analysis
Technical assessment
Python script (exploit.py) sends a crafted POST request to /api/login with a command injection payload in the username field to achieve pre-authentication RCE on File Browser <= 2.63.5.
Backdoor review
No backdoor observed in reviewed code
The supplied evidence consists of two README files (English and Japanese) and a Python exploit script (exploit.py). All content describes and implements a proof-of-concept for CVE-2026-54088, a pre-authentication command injection in File Browser's Hook Authentication feature. The exploit sends a crafted login request with a shell command in the username field to trigger the vulnerability. No concealed, deceptive, or unrelated harmful behavior was observed. The script's actions are limited to sending the described exploit payload and printing status messages; it does not establish persistence, exfiltrate data, or execute any hidden payload.
Classification basis and observed behavior
Classification basis
The artifact includes a Python script (exploit.py) that actively sends a crafted request to trigger the vulnerability and execute an attacker-supplied command on the target, which is the definition of an exploit.
exploit.py:1-82README.en.md:4Requirements
- Target must be running File Browser <= 2.63.5 with Hook Authentication configured with a vulnerable command (e.g., sh -c $USERNAME).
README.en.md:6README.en.md:52-58
Observed behavior
- Constructs a JSON payload with a username containing a shell command followed by '; echo hook.action=block'.
exploit.py:39-43 - Sends an unauthenticated HTTP POST request to the /api/login endpoint with the malicious payload.
exploit.py:48-53 - Checks the HTTP response status and prints verification instructions for the injected command's side effect.
exploit.py:55-78
Behaviors behind the backdoor verdict
Observables
- Url
- Payload withheldTarget endpoint for the exploit payload, consistent with the described CVE.
exploit.py:37 - Command Injection Payload
- Payload withheldThe injected username payload that triggers the command injection vulnerability.
exploit.py:39
What the analysis did not establish
- Only three of six repository files were provided as text; the remaining three files (likely docker-compose.yml, Dockerfile, init script) are omitted, so the full exploit environment setup cannot be verified.
- The evidence packet reports complete_artifact_coverage as false, meaning not all files in the repository were analyzed.
- Three additional files in the repository (total 6 files, 3 text files omitted) were not included in the evidence packet and were not reviewed. Their content is unknown.
- Binary files were flagged as metadata-only and not analyzed; however, none were identified in this packet.
This review is limited to the supplied PoC code and context. It does not assert that the code works or is safe to execute.
GitHubSaku0512/CVE-2026-40176-poc
Repository PoCStars: 2Created 2026-04-16ExploitCVE-2026-401764 files
Analysis
Technical assessment
The artifact is a Proof of Concept exploit for CVE-2026-40176, a command injection vulnerability in Composer's Perforce driver. It includes a PHP script (poc.php) that reproduces the vulnerable command generation logic and executes a malicious command via system(), creating a file to confirm code execution.
Backdoor review
No backdoor observed in reviewed code
The repository is a straightforward Proof of Concept for CVE-2026-40176. It contains documentation and a PHP script that reproduces the reported command injection vulnerability. The script constructs and executes a command using the same unsanitized concatenation pattern described in the CVE. The payload demonstrated is the benign 'payload withheld' command, which is consistent with the educational purpose stated in the disclaimers. No concealed, deceptive, or unrelated harmful behavior was observed.
Classification basis and observed behavior
Classification basis
The artifact contains executable code (poc.php) that actively exercises the vulnerability by generating and executing a malicious command via system(), which is the defining characteristic of an exploit. The README files explicitly describe it as a Proof of Concept and provide instructions to run the script to confirm RCE.
poc.php:69-75README.en.md:1-4Requirements
- PHP must be installed to run the PoC script.
README.en.md:41-42 - The victim must run the PoC script (poc.php) or a Composer command on a project containing the malicious composer.json.
README.en.md:66-72
Observed behavior
- The poc.php script constructs a shell command by concatenating attacker-controlled input (a malicious port string containing '; payload withheld #') without escaping.
poc.php:40-50 - The script executes the constructed command using system(), which passes it to the system shell, causing the injected 'touch' command to run.
poc.php:69-75 - The script checks for the existence of '/tmp/pwned_rce_confirmed' to confirm successful command execution, then cleans up the file.
poc.php:77-82
Behaviors behind the backdoor verdict
Observables
- Command Execution
- Payload withheldThe PoC script executes the generated command, which includes the injected 'payload withheld' payload. This is the expected behavior for demonstrating the vulnerability.
poc.php:75 - Payload
- Payload withheldThe injected command is a benign file creation used to confirm successful exploitation. It is documented in the README files and hardcoded in both composer.json and poc.php.
composer.json:6poc.php:59
What the analysis did not establish
- The evidence does not include the actual vulnerable Composer source code; the PoC reproduces the vulnerable logic in a standalone class.
- The PoC uses system() directly, while the real Composer vulnerability involves ProcessExecutor::execute(), but the shell injection mechanism is analogous.
This review is limited to the supplied PoC code and context. It does not assert that the code works or is safe to execute.