Summary
OpenClaw versions prior to 2026.2.15 use the deprecated SHA-1 hash function to generate cache keys for Docker and browser sandbox identifier caches, leaving them vulnerable to collision attacks.
An attacker who can influence sandbox identifiers may craft SHA-1 collisions to poison the cache, causing one sandbox configuration to be misinterpreted as another and enabling unsafe sandbox state reuse.
Affected context
This weakness affects OpenClaw deployments that rely on cached sandbox identifiers for Docker containers and browser sandboxes.
The vulnerability is relevant where:
- Sandbox configurations are keyed by SHA-1 hashes in a shared cache
- Multiple tenants, users, or tasks share the same sandbox infrastructure
- Attackers can influence or control sandbox identifiers or configuration parameters that feed into the hash
In these contexts, a SHA-1 collision can cause the platform to associate the wrong sandbox configuration with a running instance.
Exploit preconditions
- Attack surface: Sandbox configuration and provisioning layer (Docker and browser sandboxes)
- Required access: Ability to influence or supply sandbox identifiers or configuration values that are hashed into cache keys; visibility into cache behavior or timing can further aid exploitation
- Trigger point: When OpenClaw computes SHA-1–based cache keys and looks up or stores sandbox configurations
- Why exploitation is possible: SHA-1 is susceptible to practical collision attacks, enabling an attacker to craft distinct inputs that produce the same hash, which can then cause one sandbox's configuration to be returned for another cache lookup
Why this happens
The core issue is the continued use of SHA-1, a cryptographically weak hash function, for security-sensitive cache keying of sandbox configurations.
Under CWE-327: Use of a Broken or Risky Cryptographic Algorithm, relying on SHA-1 for identity or integrity assumptions is unsafe because attackers can deliberately generate collisions.
In OpenClaw, cache keys derived from SHA-1 are assumed to uniquely identify sandbox configurations; a collision breaks this assumption and allows cache entries for one sandbox to be reused inappropriately for another, undermining sandbox isolation guarantees.
Potential impact
- Cache poisoning that causes one sandbox configuration to be applied to a different sandbox instance
- Unauthorized reuse of previously "trusted" or privileged sandbox states for untrusted workloads
- Bypassing intended sandbox isolation boundaries between tenants or sessions
- Execution of code with a more permissive or differently configured sandbox than intended
- Data exposure if a sandbox inherits access or state from a configuration associated with another user or tenant
General mitigation guidance
Effective mitigation focuses on replacing weak cryptographic primitives and tightening assumptions around cache key uniqueness.
Recommended patterns include:
- Migrating from SHA-1 to collision-resistant hash functions (e.g., SHA-256 or stronger) for all cache key derivations related to sandbox identity
- Incorporating additional entropy and contextual binding into cache keys (e.g., tenant ID, timestamp windows, configuration versioning) to reduce the chance of cross-context collisions
- Separating cache namespaces or key spaces by tenant, environment, or sandbox type to avoid cross-tenant key reuse
- Treating sandbox configuration caches as performance optimizations only, never as the sole authority for authorization or isolation decisions
- Applying least-privilege principles to sandbox profiles, so that even if a misbinding occurs, the resulting configuration is not overly permissive
How teams detect issues like this
Security teams can detect and monitor for this vulnerability class by:
- Using static analysis or code search to flag uses of SHA-1 (and other deprecated algorithms) in security-relevant code paths, especially around identity, integrity, and authorization decisions
- Adding CI/CD checks that prevent new uses of weak hash functions and require justification or security review for cryptographic changes
- Reviewing sandbox orchestration and configuration code for assumptions that hash-based cache keys are unique or collision-resistant
- Instrumenting runtime logging around cache misses/hits for sandbox configuration lookups to detect anomalous cache behavior, such as unexpected cross-tenant configuration reuse
- Periodically auditing cryptographic dependencies and policies to ensure alignment with current best practices and organizational crypto standards

