Oct 7, 2026·5 min read·21 visits
Missing validation in wger's API endpoints allows authenticated users to inject unauthorized training logs into any user's workout schedule by referencing their slot_entry ID, corrupting dynamic progressive-overload configurations.
CVE-2026-46438 is a critical Broken Object Level Authorization (BOLA) / Insecure Direct Object Reference (IDOR) vulnerability identified in the wger fitness manager prior to version 2.6. An authenticated attacker can exploit a missing authorization check on the slot_entry API parameter to inject unauthorized workout logs into another user's training schedule. This results in the corruption of the target user's automated progressive-overload calculations.
The open-source fitness manager wger exposes standard REST API endpoints to facilitate the tracking of workouts, routines, and user logs. Within its multi-tenant architecture, isolation is enforced at the controller level to prevent cross-user data interference.
In versions prior to 2.6, the api validation layer failed to enforce appropriate object-level authorization on several relational fields. Specifically, the model controller representing workout logs neglected to map parent-child relationships for the slot_entry entity.
Consequently, an authenticated user could issue requests containing database identifiers referencing assets owned by unrelated accounts. The backend accepted and committed these associations, breaking logical boundaries between tenants and enabling unauthorized state modification.
The Django REST Framework integration in wger uses a custom superclass named WgerOwnerObjectModelViewSet to automate owner-based authorization checks during model creation and modification. This controller interceptor evaluates properties provided in the API request against a registration list returned by get_owner_objects().
Prior to the implementation of the security patch, the WorkoutLogViewSet class in wger/manager/api/views.py only evaluated Routine and WorkoutSession fields for ownership validation. The slot_entry parameter, which links a specific log entry to a scheduled slot, was omitted from the list.
Because of this omission, when an authenticated client submitted a POST request containing a foreign slot_entry identifier, the system only validated ownership of the auxiliary routine identifier. The database saved the record, creating an Insecure Direct Object Reference (IDOR) state.
A secondary failure point exists in the query logic of the calculation engine located in wger/manager/models/slot_entry.py. The SlotEntry.get_config_data() method loaded all logs connected to the slot entry without validating their ownership. This design defect allowed the attacker's unauthorized records to pollute the automated training statistics generation pipeline.
To understand the technical changes, we examine the diff from the security patch applied to the code repository. The primary vulnerability resided in the registration parameters of the REST API controller.
# Vulnerable configuration in wger/manager/api/views.py
class WorkoutLogViewSet(WgerOwnerObjectModelViewSet):
def get_owner_objects(self):
return [(Routine, 'routine'), (WorkoutSession, 'session')]The patched viewset updates the return value of get_owner_objects to enforce validation checks against both the slot_entry and the recursive next_log fields.
# Patched configuration in wger/manager/api/views.py
class WorkoutLogViewSet(WgerOwnerObjectModelViewSet):
def get_owner_objects(self):
return [
(Routine, 'routine'),
(WorkoutSession, 'session'),
(SlotEntry, 'slot_entry'),
(WorkoutLog, 'next_log'),
]Furthermore, model-level security guarantees were added within the database persistence interface in wger/manager/models/log.py. This ensures that even if API controllers are bypassed, direct model updates fail authorization validation.
# Patched validation in wger/manager/models/log.py
def save(self, *args, **kwargs):
if self.routine and self.routine.user != self.user:
return
if self.slot_entry and self.slot_entry.slot.day.routine.user != self.user:
returnAn attacker requires a valid authenticated session to exploit this vulnerability. The vulnerability requires no administrative privileges and can be triggered using a standard client connection.
The attack process initiates with sequential scanning of integer identifiers associated with targeted slot_entry objects. Because these identifiers are auto-incrementing, discovery is straightforward.
Upon identifying a target identifier, the attacker constructs a POST payload specifying a legitimate routine identifier owned by the attacker alongside the target slot_entry identifier owned by the victim. The application server processes the request, bypasses checking on the slot_entry property, and logs the malicious telemetry.
The primary impact of this vulnerability is unauthorized data manipulation and integrity corruption within user profiles. Because wger automates progress tracking via calculation engines, the presence of unauthorized workout logs corrupts the statistical baseline of the targeted athlete.
Specifically, the progressive-overload scheduling module relies on historical weight and repetition limits to project upcoming goals. Injecting extreme or incorrect values forces the application to calculate unreachable targets, impairing the usability of the software.
While the vulnerability does not lead directly to arbitrary code execution or data extraction, the complete loss of multi-tenant integrity across relational workout records introduces a significant trust barrier in shared deployments.
The primary remediation mechanism is the installation of wger version 2.6. This release closes the authorization gap in the API controllers and enforces defensive validation constraints inside the underlying models.
For system administrators who cannot perform immediate platform updates, temporary relief is achievable by auditing database transactions and filtering suspicious logs. Running targeted database queries can expose instances where log records point to incompatible parent accounts.
Additionally, Web Application Firewalls (WAF) can be configured to block suspicious requests directed at the API endpoint. Inspecting incoming request bodies for mismatching parameters helps reduce the potential attack surface.
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
wger wger-project | < 2.6 | 2.6 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-862 (Missing Authorization) |
| Attack Vector | Network |
| CVSS v3.1 | 6.5 (Medium) |
| Exploit Status | Proof of Concept (PoC) available |
| Remediation | Official upgrade path to version 2.6 |
The product does not perform an authorization check when an actor attempts to access a resource or perform an action.
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.