Summary
Determined does not properly authorize requests to generic task kill, pause, and unpause API endpoints. An authenticated attacker may control tasks owned by other users, disrupting workloads by terminating or changing their execution state.
Affected context
The issue occurs in Determined API handlers that expose generic endpoints for changing task state. It is relevant when an authenticated user can reach these endpoints and the handlers do not consistently verify that the requested task belongs to, or is otherwise accessible by, that user.
Exploit preconditions
- Attack surface: Determined API task-management endpoints
- Required access: Valid authentication credentials or an authenticated session
- Trigger point: Requests to generic task kill, pause, or unpause endpoints
- Why exploitation is possible: Authorization checks do not adequately confirm ownership or permission for the targeted task before applying the requested state change
Why this happens
The underlying flaw is an authorization gap in task-management request handlers. The endpoints process authenticated requests but fail to enforce an object-level permission check for the specific task identified by the request.
This behavior maps to CWE-862: Missing Authorization, where access to a protected operation is not adequately restricted after authentication. Authentication establishes who is making a request, but does not by itself establish that the requester may control the selected task.
Potential impact
- An attacker may terminate workloads belonging to other users.
- An attacker may pause or resume tasks without the owner's authorization.
- Workloads may experience availability and scheduling disruptions.
- Operational data, experiments, or processing pipelines could be delayed or interrupted.
- Repeated unauthorized actions could reduce trust in multi-user workload isolation.
General mitigation guidance
Mitigation generally focuses on enforcing object-level authorization consistently for every task state-changing operation.
Common defensive patterns include:
- Verify ownership, project membership, or explicit task-management permissions before changing task state.
- Apply authorization checks centrally or through shared policy enforcement rather than relying on individual handlers.
- Use deny-by-default behavior when task identity, ownership, or scope cannot be established.
- Limit task-control privileges according to user, project, and organizational roles.
- Treat client-supplied task identifiers as untrusted and resolve them against server-side authorization data.
- Maintain separate permissions for viewing tasks and performing disruptive operations.
How teams detect issues like this
Organizations can identify similar authorization gaps through:
- Static analysis and code review rules that flag state-changing handlers without object-level permission checks.
- Review of every endpoint that accepts a task, job, project, or resource identifier from the client.
- Negative authorization tests confirming that users cannot modify resources outside their permitted scope.
- API policy checks requiring explicit authorization for destructive or disruptive operations.
- Audit-log analysis for task state changes performed across ownership or project boundaries.
- Automated security review tools that compare endpoint behavior with declared authorization policies.

