/

CVE-2026-28479

Severity:

HIGH RISK

(7.5)

Use of Weak Cryptography in OpenClaw Sandbox Configuration

CVE-2026-28479

Analyzed

Vulnerability type

Category:

Use of Weak Cryptography

CWE:

CWE-327

Impact:

Sandbox Escape via Cache Poisoning / Configuration Confusion

Severity:

HIGH RISK

(7.5)

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

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

Sources

SourceLink
github.comgithub.com/openclaw/openclaw/commit/559c8d9930eebb5356506ff1a8cd3dbaec92be77
github.comgithub.com/openclaw/openclaw/security/advisories/GHSA-fh3f-q9qw-93j9
vulncheck.comvulncheck.com/advisories/openclaw-cache-poisoning-via-deprecated-sha-hash-in-sandbox-configuration

Frequently asked

questions

Yes, in many deployments. If sandbox identifiers or configuration parameters are derived from or influenced by user-controlled input, a remote attacker may be able to craft values that collide under SHA-1 and thereby poison the cache.

The attacker needs the ability to influence or control the data that is hashed into the sandbox identifier cache key. This might be direct (e.g., specifying an identifier or configuration) or indirect (e.g., controlling fields that the system incorporates into the hash).

The safest approach is to replace SHA-1 with a modern, collision-resistant hash function and ensure that cache keys used for sandbox identification do not rely solely on hash uniqueness for security. Keys should be derived from robust, well-scoped identifiers, preferably bound to tenant and context.

Establish and enforce a cryptography policy that disallows deprecated primitives, add automated checks for weak algorithms, and require security review for any code that introduces or modifies cryptographic usage, particularly in components that influence isolation, identity, or authorization.

Find out what's already
exploitable in your codebase.