CRLF Response Stream Injection in Valkey Lua Error Handling

Repository is a small proof-of-concept demonstrating RESP protocol injection (socket buffer poisoning) in a scenario where a web backend reuses a single Valkey/Redis TCP connection and performs incorrect/partial parsing of server replies. Structure/purpose: - backend.py: Flask app exposing three endpoints: POST/GET /api/user/role and POST /api/process. It maintains a global shared TCP socket to Valkey/Redis and manually crafts RESP commands (AUTH/SET/GET/EVAL). The vulnerable behavior is in process_script(): after sending EVAL it reads only the first line of the error reply (up to CRLF), leaving remaining bytes in the socket receive buffer. - attacker_client.py: Sends a POST to /api/process with a Lua script that raises an error whose message contains embedded CRLF and RESP bulk-string framing ("INJECTED\r\n$11\r\nhacked_user"). This causes the backend to read "-ERR INJECTED" as the error line while leaving "$11\r\nhacked_user" queued in the socket buffer. - victim_client.py: Normal client that POSTs to /api/user/role to set a role and GETs /api/user/role to retrieve it. After the attacker poisons the buffer, the victim’s subsequent GET reads the leftover "$11\r\nhacked_user" as if it were the response to GET, resulting in the victim receiving role "hacked_user". Main exploit capability: - Cross-request response smuggling on a shared Valkey/Redis connection: attacker-controlled bytes from an EVAL error reply are interpreted as the next command’s response, enabling data integrity compromise (wrong values returned) and potentially broader request/response desynchronization depending on what the backend does with subsequent replies.

Repository is a small Python proof-of-concept demonstrating RESP protocol injection / response desynchronization against a Valkey/Redis backend when an application reuses a shared TCP connection and performs incorrect/incomplete RESP parsing. Structure and purpose: - README.md: Explains the attack concept and step-by-step demo. - backend.py: Flask web app that maintains a single global TCP socket to Valkey/Redis (simulating connection pooling). Implements: - POST /api/user/role: sends raw RESP SET for key user:{username}:role. - GET /api/user/role: sends raw RESP GET and parses the response. - POST /api/process: sends raw RESP EVAL with user-supplied Lua script. The vulnerability is intentionally modeled in /api/process: it reads only the first line of the error reply (up to \r\n) and returns, leaving remaining bytes in the socket receive buffer. - attacker_client.py: Sends a malicious Lua script to /api/process that raises an error containing CRLF and a crafted RESP bulk-string header/value. This causes the backend to consume only "-ERR INJECTED\r\n" while leaving "$11\r\nhacked_user" queued. - victim_client.py: Normal client that sets role to "normal_user" and later retrieves it. After the attacker poisons the socket, the victim’s subsequent GET reads the leftover "$11\r\nhacked_user" as if it were the GET response, resulting in the backend returning role "hacked_user". Exploit capabilities: - Network-based attack via HTTP to the backend. - Protocol-level injection into RESP stream using Lua error messages (EVAL) to smuggle additional RESP frames. - Demonstrates cross-request impact on other users due to shared connection state (socket poisoning), effectively allowing an attacker to influence subsequent responses returned to victims (data integrity violation / response confusion).