⚠️ Overview

CVE-2025-49844 ("RediShell") is a critical use-after-free (UAF) memory corruption vulnerability in Redis' embedded Lua scripting engine.

An authenticated user submits a specially crafted Lua script via EVAL / EVALSHA that manipulates the garbage collector, triggers a UAF during parsing/execution, escapes the Lua sandbox, and achieves arbitrary code execution on the underlying host.

The bug lurked in Redis source code for ~13 years (since early Lua integration) and affects virtually all versions with Lua enabled until patched in October 2025.

“One malicious EVAL call. Full server takeover. Redis in 2025–2026 just got interesting.”

🔥 Severity & Impact

• CVSS v3.1 Base Score: 10.0 / Critical
• Attack Vector: Network (Redis TCP port, usually 6379)
• Privileges Required: Low (any authenticated Redis user with script execution rights)
• User Interaction: None
• Exploit Maturity: Public PoCs & exploit tools released shortly after disclosure

Reality in March 2026:

• Public exploits target reverse shells, persistence, crypto-mining payloads
• High-risk in cloud environments (caching layers, session stores, queues)
• Combined with weak auth / exposed Redis → full infra compromise
• Many legacy deployments, Docker images, and managed services still vulnerable

🕵️ Discovery & Credit

• Discovered by Wiz Research team
• Reported via Pwn2Own Berlin (May 2025)
• Coordinated disclosure: October 3, 2025 (Redis advisory + patches)
• Dubbed "RediShell" by Wiz (shell-like RCE via Lua escape)

🔬 Technical Deep Dive

Redis embeds Lua 5.x for scripting (EVAL, EVALSHA, functions, etc.).
The flaw exists in Lua parser/GC interaction:

1. Attacker sends crafted Lua script via EVAL
2. During parsing (luaY_parser), a TString object is allocated but not protected on the Lua stack
3. GC runs prematurely → frees the object
4. Later code uses the freed memory → UAF primitive
5. Attacker chains this to leak memory, bypass ASLR, ROP/return-to-libc → arbitrary native code execution outside sandbox

Key fatal point: Lua sandbox was never hardened against memory corruption primitives.

📅 Timeline

🖥️ Affected Systems

Vulnerable: All Redis versions with Lua scripting enabled before the October 2025 patches
Fixed in:

• Redis 8.2.2+
• Redis 8.0.4+
• Redis 7.4.6+
• Redis 7.2.11+
• Redis 6.2.20+

Common targets in 2026:

• Cloud caching/session stores (AWS ElastiCache, Azure Cache, GCP Memorystore)
• Docker/K8s deployments with default Redis images
• Legacy apps using Redis < 7.x
• Exposed Redis instances (no auth or weak password)

Workaround (pre-patch):

• Disable Lua scripting via ACL: deny EVAL, EVALSHA, SCRIPT LOAD, etc.
• Enforce strong auth + network restrictions

💥 Public Exploit & PoC

Realistic attack flow (high-level, from public analyses):

1. Authenticate to Redis (password if required)
2. Send crafted EVAL script that triggers UAF + memory leak
3. Use leak to defeat ASLR
4. Chain ROP gadgets → spawn reverse shell / exec payload

Example one-liner skeleton (not full exploit – for illustration only):

redis-cli -h <target> -p 6379 -a password
> EVAL "crafted_lua_that_triggers_uaf_and_execs_shell" 0

Full weaponized PoCs appeared on GitHub within days (memory leak → ROP → shell).
Many include ASLR bypass, NX/DEP evasion, and persistence options.

🛡️ Check & Remediate (March 2026)

1. Check version

redis-cli INFO SERVER | grep redis_version

→ Vulnerable if < patched releases above

2. Patch immediately

• Upgrade to latest stable (8.2.x+ recommended)
• For managed services (AWS/Azure/GCP): force upgrade or confirm patch applied

3. Hardening

• Disable Lua entirely if not needed:
  root@kitploit:~

  # In redis.conf or ACL
  acl setuser default off ~* &* +@all -EVAL -EVALSHA -SCRIPT
  

• Bind to localhost / use TLS + strong auth
• Firewall: restrict TCP/6379 to trusted IPs
• Monitor for anomalous EVAL usage

📈 Status — March 2026

• Exploitation still active against unpatched cloud/legacy instances
• Redis remains ubiquitous → high-value target
• Ecosystem shift: many orgs now disable Lua scripting by default

🎓 Lessons Learned

• 13-year bugs hide in embedded interpreters
• Sandbox escape via memory corruption = instant RCE
• Authenticated does not mean safe — especially on exposed services
• Patch fast, disable risky features faster