Summary
Fission's Container Executor previously allowed tenants to supply a full Function.spec.podspec that was merged directly into the executor-generated pod specification.
If misused in a multi-tenant or shared-cluster setup, this can let a user influence pod-level settings and potentially escalate privileges or escape intended isolation boundaries.
Affected context
This vulnerability affects Fission deployments using the Container Executor in Kubernetes environments where multiple tenants or workloads share the same cluster.
It is relevant when users are allowed to define or influence Function.spec.podspec and the executor merges that podspec into its own without strict normalization or policy enforcement.
The risk is higher in clusters that rely on the executor to enforce pod-level security controls, such as resource limits, security contexts, or namespace isolation.
Exploit preconditions
- Attack surface: Fission API or any interface where users can create or update Functions using the Container Executor.
- Required access: Ability to submit or modify
Functionresources and provide aspec.podspec(typically authenticated tenant/user access). - Trigger point: Creation or update of a Function that results in the executor merging user-supplied podspec into the executor-generated podspec and creating a Deployment.
- Why exploitation is possible: User-controlled pod-level configuration is merged with privileged or trusted executor configuration without sufficiently constraining which fields can be overridden, enabling unintended privilege or security-context changes.
Why this happens
The root cause lies in improper privilege and authorization management when composing Kubernetes pod specifications.
By allowing a tenant to supply Function.spec.podspec and merging it directly into the executor-generated podspec, the system blurs the boundary between trusted control-plane configuration and untrusted tenant input.
This corresponds to CWE-269: Improper Privilege Management and CWE-284: Improper Access Control, because a lower-privileged user can influence security-sensitive pod attributes (such as capabilities, host access, or service accounts) that should remain under strict operator control.
At an abstract level, the insecure pattern is granting untrusted users the ability to partially control infrastructure-level configuration objects that determine their own execution privileges.
Potential impact
- Tenants may increase the privileges of their function pods beyond intended limits (e.g., elevated capabilities or permissions).
- Tenants could select or influence service accounts to access additional cluster resources.
- Tenants might weaken or bypass security settings such as read-only root filesystems, seccomp, or pod security controls.
- Cross-tenant isolation boundaries could be reduced, enabling lateral movement or data access that should be restricted.
- Cluster operators may lose confidence in the enforcement of security policies applied via the executor.
General mitigation guidance
Effective mitigation focuses on separating trusted cluster configuration from untrusted tenant input and constraining what users can control.
Typical defensive patterns include:
- Treating all tenant-supplied pod specifications as untrusted and normalizing them through a strict allowlist of permitted fields and values.
- Using a fixed, operator-managed pod template for function execution and exposing only limited, high-level configuration knobs (e.g., memory/CPU, environment variables) instead of raw podspec access.
- Enforcing Kubernetes admission policies (such as Pod Security Standards, PSP replacements, or custom admission controllers) to prevent privilege elevation regardless of what the executor generates.
- Running executor components with least privilege and ensuring that any service accounts used by function pods have minimal, role-based access to cluster resources.
- Documenting clear boundaries around what tenants can configure and designing APIs that avoid passing infrastructure-level configuration through user-controlled structures.
How teams detect issues like this
Detection efforts can focus on both configuration review and runtime analysis:
- Use static analysis or policy-as-code tools (e.g., Open Policy Agent, Kyverno, or Gatekeeper) to flag Deployments or pods generated by the executor that violate baseline security policies (privileged, hostPath mounts, hostNetwork, elevated capabilities, or unexpected service accounts).
- Implement admission webhooks that log or reject pod specifications where annotations or labels indicate they originate from Fission functions but request disallowed security settings.
- Perform targeted code review of executor logic that merges user-supplied podspecs with system pod templates, ensuring only safe fields are propagated.
- Monitor cluster audit logs and controller logs for patterns of function-created Deployments that request unusual privileges or deviate from the expected execution profile.

