/

CVE-2026-46612

Severity:

HIGH RISK

(8.8)

Missing Authentication (CWE-306) in Fission storagesvc API

CVE-2026-46612

Deferred

Vulnerability type

Category:

Missing Authentication

CWE:

CWE-306

Impact:

Cross-tenant Data Exposure and Manipulation

Severity:

HIGH RISK

(8.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

The Fission storagesvc component exposes archive CRUD HTTP endpoints without enforcing any authentication or authorization checks.

Any workload that can reach the storagesvc ClusterIP can list, download, upload, or delete archives across tenants, leading to cross-tenant data exposure and tampering in multi-tenant Kubernetes environments.

Affected context

This vulnerability affects Fission deployments where the storagesvc component is reachable over the cluster network and its /v1/archive and /v1/archives endpoints are exposed on the internal HTTP router.

It is most impactful in multi-tenant or shared Kubernetes clusters where multiple teams or services rely on Fission for function packaging.

The risk materializes when cluster workloads that are not part of a given tenant can send HTTP requests to storagesvc, since the service does not perform identity checks or authorization on archive operations.

Exploit preconditions

  • Attack surface: Internal Kubernetes network, specifically the storagesvc ClusterIP and its exposed HTTP endpoints.
  • Required access: Ability to send HTTP requests to the storagesvc service (e.g., from any pod or workload in the same cluster namespace or with network reachability).
  • Trigger point: Invoking unauthenticated endpoints such as:
  • GET /v1/archive?id=<archive-id>
  • POST /v1/archive
  • DELETE /v1/archive?id=<archive-id>
  • GET /v1/archives
  • Why exploitation is possible: The HTTP router registers these archive CRUD handlers without enforcing authentication or authorization, so the service implicitly trusts any in-cluster caller.

Why this happens

The root cause is a missing authentication and authorization layer on sensitive storage APIs.

The storagesvc component directly registers archive CRUD handlers on the HTTP router, leaving them accessible to any caller capable of reaching the ClusterIP.

This aligns with CWE-306: Missing Authentication for Critical Function, where critical operations (listing, reading, writing, deleting archives) are exposed without validating the identity or permissions of the requester.

Conceptually, the design assumes a trusted internal network, but in multi-tenant Kubernetes clusters, network reachability does not equate to proper authorization boundaries.

Potential impact

  • Attackers in the same cluster may enumerate archive IDs for other tenants.
  • Attackers may download archives, potentially exposing application code or configuration contained in those archives.
  • Attackers may upload arbitrary archive content, leading to code tampering or supply-chain style manipulation of serverless functions.
  • Attackers may delete archives, causing denial of service for affected tenants' functions or applications.
  • Compromised workloads may laterally abuse this API to escalate impact across multiple Fission tenants.

General mitigation guidance

Mitigation centers on enforcing strong identity and authorization checks around storagesvc and similar internal APIs.

Useful defensive patterns include:

  • Introducing mandatory authentication at the storagesvc layer (e.g., service- or user-level identity tokens) and rejecting unauthenticated requests.
  • Applying fine-grained authorization so that archive operations are allowed only for principals associated with the owning tenant or namespace.
  • Isolating storagesvc exposure via network policies or service meshes so only authorized components can reach the API surface.
  • Designing multi-tenant boundaries that do not rely solely on "inside the cluster" trust but instead validate caller identity on every critical function.
  • Storing archives with tenant-scoped identifiers and enforcing ownership checks before performing any CRUD operation.

How teams detect issues like this

Detection strategies can focus on both code-level and runtime indicators:

  • Static analysis / code review: Flag HTTP handlers that perform state-changing or sensitive operations without preceding authentication and authorization logic, especially in shared services like storagesvc.
  • Configuration review: Inspect Kubernetes manifests, ingress rules, and service meshes to identify internal services exposing sensitive APIs without policy enforcement.
  • Runtime logging and monitoring: Enable structured logs for storagesvc requests and set alerts on anomalous patterns such as unexpected tenants accessing many archives, large numbers of deletions, or archive uploads from unusual workloads.
  • Policy enforcement: Use admission controllers or policy-as-code tools to prevent deployment of services that expose critical endpoints without authentication or that are overly permissive in network access.

Sources

SourceLink
github.comgithub.com/fission/fission/pull/3365
github.comgithub.com/fission/fission/pull/3368
github.comgithub.com/fission/fission/releases/tag/v1.23.0
github.comgithub.com/fission/fission/security/advisories/GHSA-chf8-4hv6-8pg6

Frequently asked

questions

By default, exploitation is typically limited to entities that can reach the storagesvc ClusterIP over the Kubernetes network.

If storagesvc is exposed externally through ingress or port-forwarding without additional protections, external attackers could potentially exploit it as well.

An attacker needs network-level access to the storagesvc HTTP endpoints, which commonly means running any pod or workload in the same cluster (or network segment) that can reach the ClusterIP.

No application-level credentials are required because authentication checks are missing on the affected endpoints.

The safest pattern is to require strong authentication for all critical APIs and enforce authorization decisions based on tenant or ownership context before performing any archive operations.

Additionally, restrict network access so that only the minimal set of trusted components can communicate with storagesvc.

Treat internal services as untrusted by default and consistently apply authentication and authorization to all state-changing or sensitive endpoints.

Incorporate security reviews into the design phase, use standardized middleware for auth in all services, and enforce policies that block deploying new APIs without explicit access control and network restrictions.

Find out what's already
exploitable in your codebase.