Loading story…
A critical vulnerability, tracked as CVE-2026-26215, enables unauthenticated remote code execution (RCE) in manga-image-translator when run in shared API mode. The exposed FastAPI endpoints POST /simple_execute/{method} and POST /execute/{method} deserialize attacker-controlled request bodies using pickle.loads() without validation (CWE-502), allowing a remote attacker to execute arbitrary code in the server context by sending a crafted pickle payload.
The intended protection—a nonce-based authorization check—can be bypassed because the nonce defaults to an empty string (falsy in Python), causing the check to be skipped in typical deployments. Public reporting ties the issue to manga-image-translator beta-0.3 and earlier, and documents the vulnerable code paths in manga_translator/mode/share.py as well as associated upstream issue discussions and an advisory reference.
See affected versions and whether adversaries are exploiting it.
3 events from the most recent confirmed update back to the earliest known activity.
The unauthenticated remote code execution vulnerability in manga-image-translator was publicly disclosed with technical details and a proof of concept, and a patch was released. The disclosure described pickle.loads() use in shared-mode API endpoints and a nonce bypass caused by the default empty-string nonce.
The unsafe deserialization flaw in manga-image-translator shared API mode was assigned CVE-2026-26215. The CVE record states it was received by disclosure@vulncheck.com on 2026-02-11.
Tencent YunDing Security Lab researcher sud0why previously reported an unsafe deserialization remote code execution issue in manga-image-translator during 2025, but the report was not addressed and was later auto-closed.
Vulnerabilities, threat actors, malware, products, organizations, and breaches Mallory has linked to this story.
See whether adversaries are exploiting this yet, and where the affected versions run in your environment.
2 references tracked. Mallory keeps watching after this page renders.
cvefeed.io
Open sourcechocapikk.com
Open sourceMap indicators from this story to your assets and identify affected systems in minutes.
Every observed campaign, victim, and pivot linked to actors named in this story.
Malware, exploits, and IOCs connected to the activity described here.
YARA, Sigma, and Snort rules deployed to your SIEM as soon as they’re published.
Get matching new stories delivered to your team as they break — not the next morning.
Ask questions about this story and take action on the answers.
Other stories Mallory is tracking that overlap on entities, sources, or topic labels.
A critical vulnerability tracked as **CVE-2026-69098** affects Cinnamon's **Kotaemon** through version **0.12.0**, allowing unauthenticated remote code execution through the Gradio-exposed `/check_connection` endpoint. The flaw arises because attacker-supplied YAML or JSON is deserialized with insecure settings, letting a request include a `__type__` field that instantiates arbitrary Python classes on the server. Public reporting says the issue can be exploited without credentials, API keys, or user interaction by abusing reachable event-handler endpoints such as `/check_connection` and `/create_llm`. Attackers can reportedly set `__type__` to functions such as `subprocess.check_output` and pass arbitrary arguments to execute operating system commands with the application's privileges, creating risks of file access, database or code modification, and service disruption; the issue is classified as **CWE-502** and has been rated **critical**, with one report assigning a **CVSS 3.1 score of 10.0**.
Aug 5, 2026
A critical remote code execution (RCE) vulnerability, tracked as CVE-2025-61622, was discovered in the Apache Fory Python module, specifically affecting pyfory versions 0.12.0 through 0.12.2 and legacy pyfury versions from 0.1.0 through 0.10.3. The flaw arises from the deserialization of untrusted data, where the module's pickle fallback serializer can be triggered by a crafted data stream, leading to the execution of arbitrary code via Python's 'pickle.loads' function. This vulnerability is considered critical, with a CVSS score of 9.8, indicating a high risk of exploitation. Applications that read pyfory serialized data from untrusted sources are particularly at risk, as attackers can exploit this vector to achieve remote code execution on affected systems. The Apache security team has addressed the issue by removing the pickle fallback serializer in pyfory version 0.12.3 and later, effectively mitigating the vulnerability. Security advisories recommend immediate upgrades to the fixed version to prevent exploitation. The vulnerability was publicly disclosed on October 1, 2025, with Apache providing detailed guidance and crediting their security team for the discovery and remediation. The flaw is remotely exploitable, making it a significant concern for organizations using affected versions in production environments. No evidence of active exploitation in the wild has been reported at the time of disclosure, but the technical simplicity of the attack vector increases the urgency for patching. The vulnerability impacts any application that processes serialized data from untrusted sources using the affected pyfory or pyfury versions. Organizations are advised to audit their environments for the presence of vulnerable versions and to apply the recommended updates without delay. The security community has highlighted the risk of deserialization vulnerabilities in Python applications, emphasizing the importance of avoiding unsafe serialization mechanisms like pickle. Apache's response included not only a patch but also updated documentation warning against insecure deserialization practices. The incident underscores the ongoing risks associated with legacy serialization features in widely used open-source libraries. Security researchers have praised the transparency and speed of Apache's response to the issue. The vulnerability has been cataloged in major vulnerability databases, and security vendors have updated their detection signatures accordingly.
Jun 29, 2026
A critical remote code execution flaw tracked as **CVE-2026-68771** affects **ComfyUI v0.23.0** through unsafe deserialization in the `LoadTrainingDataset` node. An attacker can reportedly upload a crafted pickle file to the unauthenticated `POST /upload/image` endpoint and then trigger deserialization through `POST /prompt`, causing `torch.load` to process an attacker-controlled `shard_*.pkl` file. Because Python pickle deserialization can invoke arbitrary code via mechanisms such as `__reduce__`, successful exploitation can lead to command execution with the privileges of the ComfyUI process. A related ComfyUI code change shows the project hardened dataset shard loading by replacing `torch.load(f)` with `torch.load(f, weights_only=True)` in `comfy_extras/nodes_dataset.py`, limiting deserialization to weights-only data and reducing exposure to malicious serialized objects. Reported mitigations include upgrading to a version that incorporates the safer loading behavior, avoiding untrusted pickle files, and reviewing node security settings on exposed deployments.
Aug 1, 2026