Summary
Boxlite's sandbox service previously failed to restrict Linux kernel capabilities inside OCI containers, allowing processes to remount read-only directories as read-write.
Under these conditions, malicious code running in a Box can gain unintended write access to host-exposed or protected paths, enabling arbitrary file modification and full sandbox escape scenarios.
Affected context
This vulnerability affects Boxlite environments where untrusted code is executed inside OCI containers with default or overly permissive Linux capabilities.
It is especially relevant when host directories, shared volumes, or system paths are mounted as read-only into containers under the assumption that they cannot be modified.
In such setups, the lack of capability restrictions enables containerized processes to change mount options at runtime and bypass the intended read-only protection.
Exploit preconditions
- Attack surface: Code executing within a Boxlite-managed OCI container.
- Required access: Ability to run or influence code inside the Box (e.g., a user-submitted job, CI task, or multi-tenant workload).
- Trigger point: Execution of filesystem operations that remount a read-only directory as read-write inside the container.
- Why exploitation is possible: The container is granted kernel capabilities that allow remounting filesystems, so the assumed read-only mounts are enforced only by configuration, not by effective privilege boundaries.
Why this happens
The root cause lies in misconfigured and overly broad Linux capability assignment for containers created by Boxlite.
Instead of running untrusted workloads under a least-privilege capability set, the environment allowed capabilities that can alter mount options, such as remounting filesystems.
This maps to CWE-284: Improper Access Control, where the system fails to enforce proper authorization over sensitive operations—in this case, low-level kernel capabilities that directly affect file system protections.
Potential impact
- Malicious code may remount read-only directories as read-write within the container.
- Attackers could modify, replace, or delete files that were assumed to be immutable, including configuration, scripts, or binaries.
- Sandboxed workloads can potentially tamper with shared volumes used by other tenants or system components.
- In some deployments, this could lead to privilege escalation, data corruption, or a full sandbox escape, depending on what directories are mounted.
General mitigation guidance
Mitigation generally focuses on enforcing strict least-privilege capability sets and hardening filesystem isolation for untrusted containers.
Common defensive patterns include:
- Dropping all non-essential Linux capabilities by default and whitelisting only what each workload strictly requires.
- Using security profiles (such as seccomp, AppArmor, or SELinux policies) to restrict privileged filesystem operations, including remounts.
- Ensuring that read-only mounts are backed by mechanisms that cannot be overridden from inside the container, and avoiding exposing sensitive host paths.
- Segregating untrusted workloads into isolated namespaces and nodes, combined with minimal privileges and dedicated volumes.
How teams detect issues like this
Effective detection typically combines configuration review with runtime monitoring:
- Static checks on container runtime and orchestration policies to flag containers that run with broad or default capability sets.
- Code and infrastructure-as-code reviews focused on identifying missing
cap-dropdirectives or permissive security profiles. - Runtime observability that records mount and remount operations initiated by containerized processes, raising alerts for unexpected changes to read-only paths.
- Automated security scanners or policy-as-code tools that enforce organization-wide standards for container capabilities and sandbox configurations before deployment.

