/

CVE-2026-46614

Severity:

CRITICAL RISK

(9.8)

Authorization Bypass (CWE-284) in Fission Router

CVE-2026-46614

Deferred

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-284, CWE-862

Impact:

Unauthorized Function Invocation / Remote Code Execution

Severity:

CRITICAL RISK

(9.8)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Fission's router exposed internal-style function routes on the public listener, allowing direct invocation of any function by name and namespace.

Callers who could reach the router could bypass HTTPTrigger host, path, method, and method-allow-list restrictions, leading to unauthorized code execution in the serverless environment.

Affected context

This vulnerability affects Fission deployments where the router service (typically svc/router on port 8888) is reachable by users or workloads that are not fully trusted.

It occurs because the router always registers internal-style routes (/fission-function/<name> and /fission-function/<ns>/<name>) for every Function object, regardless of whether an HTTPTrigger is configured.

These internal routes are exposed on the same listener as HTTPTriggers, allowing access paths that do not enforce the usual host, path, or method restrictions.

Exploit preconditions

  • Attack surface: Network access to the Fission router endpoint (e.g., svc/router:8888, ingress, or load balancer fronting it)
  • Required access: Ability to send HTTP requests to the router; no specific HTTPTrigger or API permissions are required beyond network reachability
  • Trigger point: Direct calls to /fission-function/<name> or /fission-function/<ns>/<name> with a valid function identifier
  • Why exploitation is possible: The router auto-registers internal-style routes for all functions on the public listener and does not apply HTTPTrigger host/path/method/method-allow-list checks to those routes

Why this happens

The core issue is an authorization design flaw where internal control-plane style endpoints are exposed on a data-plane listener without enforcing the same policy checks as user-defined triggers.

The router creates implicit routes for every Function object and mounts them on the same listener as HTTPTriggers, but only HTTPTrigger paths are bound to host, path, method, and allow-list constraints.

This maps to CWE-284: Improper Access Control and CWE-862: Missing Authorization, because the system fails to verify whether the caller is authorized to invoke a given function when using the internal-style routes.

Potential impact

  • Unauthorized invocation of serverless functions that were intended to be protected by HTTPTrigger rules
  • Execution of sensitive or administrative functions by unprivileged callers
  • Data exposure or data modification through functions that handle protected resources
  • Abuse of functions for lateral movement, service enumeration, or reconnaissance inside the cluster
  • Increased risk of denial-of-service by repeatedly invoking expensive functions

General mitigation guidance

Effective mitigation focuses on enforcing consistent access control across all invocation paths and reducing unnecessary exposure of control surfaces.

Recommended patterns include:

  • Ensuring that any internal or management-style routes are bound to separate, non-public listeners or are disabled by default
  • Applying the same authorization checks (host/path/method/method-allow-list or equivalent policies) to every endpoint capable of invoking a function
  • Restricting network exposure of the router service, for example by limiting its visibility to trusted namespaces, service meshes, or ingress layers with authentication
  • Implementing least-privilege design for function invocation, tying access to explicit triggers or policies rather than object naming alone
  • Periodically reviewing API surfaces to ensure there are no undocumented or implicit invocation paths

How teams detect issues like this

Detection efforts can focus on both configuration and behavior:

  • Configuration/code analysis:
  • Review router configuration and code paths to identify any endpoints that can invoke functions without passing through HTTPTrigger or equivalent authorization logic
  • Use static analysis or policy-as-code tools to flag cases where internal or management endpoints share listeners with public routes
  • Examine RBAC and network policies to verify that only intended parties can reach the router service
  • Operational monitoring:
  • Log and monitor requests to /fission-function/ paths, correlating invocations with expected HTTPTriggers or callers
  • Create alerts for invocations that bypass defined triggers or originate from unusual sources or namespaces
  • Use API gateways, service meshes, or WAFs to enforce and audit access control policies at the edge

Automated security testing and CI/CD-integrated checks can help detect similar authorization gaps before deployment.

Sources

SourceLink
github.comgithub.com/fission/fission/pull/3365
github.comgithub.com/fission/fission/pull/3369
github.comgithub.com/fission/fission/releases/tag/v1.23.0
github.comgithub.com/fission/fission/security/advisories/GHSA-3g33-6vg6-27m8

Frequently asked

questions

Yes, if the Fission router is exposed via an ingress, load balancer, or other public entry point, a remote attacker who can reach it can attempt to invoke functions directly using the internal-style routes.

The attacker only needs network access to the router endpoint and knowledge or guesses of function names and namespaces; they do not need a configured HTTPTrigger for the target function.

The safest pattern is to ensure that all function invocation paths are subject to the same authorization logic as HTTPTriggers, or to isolate internal invocation endpoints on non-public listeners that are only reachable by trusted control-plane components.

Prevention strategies include designing APIs with a clear separation between internal and public surfaces, enforcing centralized authorization for all code execution paths, applying network segmentation around control-plane components, and using automated reviews to detect undocumented or implicit invocation routes.

Find out what's already
exploitable in your codebase.