Medium

Guard Core: Unvalidated X-Forwarded-For-derived string used as a Redis key component and interpolated into a KEYS glob pattern

  • Disclosed: 19.11.2026
  • Updated: 20.11.2026 00:17

Summary

_extract_from_forwarded_header() (guard_core/utils.py:172-181 in 3.12.0; :179 on master 08780f1) returns the selected X-Forwarded-For entry without any ipaddress validation. When that entry is attacker-controlled, an arbitrary string becomes client_ip and flows into BehaviorTracker (guard_core/handlers/behavior_handler.py:83-102), which interpolates it verbatim into both a Redis key name and a KEYS glob pattern:

python
key = f"behavior:usage:{endpoint_id}:{client_ip}"
await self.redis_handler.set_key("behavior_usage", f"{key}:{current_time}", "1", ttl=rule.window)
pattern = f"behavior_usage:{key}:*"
keys = await self.redis_handler.keys(pattern)      # blocking KEYS, O(N) over keyspace

Same shape in track_return_pattern() (behavior_handler.py:135-142). redis_handler.keys() maps to the blocking Redis KEYS command (guard_core/handlers/redis_handler.py:265-275).

Details

Three consequences, in increasing severity:

  1. Cross-client counter contamination. X-Forwarded-For: * makes the glob match every client's behavior-usage keys for the endpoint. Verified with a fake-Redis harness: a client 9.9.9.9 hit an endpoint 3 times (threshold=3 rule), then a single attacker request carrying XFF: * issued the pattern behavior_usage:behavior:usage:app.login:*:*, counted the victim's events, and tripped the rule on its first request. An embedded : also shifts which key segment is parsed as the timestamp (behavior_handler.py:94-100).
  2. Unbounded key-space growth + blocking scans. Each request creates a new unique key (f"{key}:{current_time}") and then issues a blocking KEYS scan whose cost grows with total keys — on the shared Redis instance, degrading every guard-core instance using it. Rotating arbitrary XFF strings multiplies distinct keys without bound.
  3. Error path. A tripped ban action passes the non-IP string to ip_ban_manager.ban_ip(), whose ipaddress validation raises ValueError uncaught in the behavioral processor — the request 500s.

PoC

python
import asyncio
from types import SimpleNamespace
from guard_core.models import SecurityConfig
from guard_core.utils import extract_client_ip

class CIHeaders(dict):
    def get(self, key, default=None):
        for k, v in self.items():
            if k.lower() == key.lower():
                return v
        return default

class FakeRequest:
    def __init__(self, xff):
        self.state = SimpleNamespace()
        self.client_host = "10.0.0.1"          # the TRUSTED proxy
        self.headers = CIHeaders({"X-Forwarded-For": xff})

async def main():
    config = SecurityConfig(trusted_proxies=("10.0.0.1",), enable_redis=False)
    ip = await extract_client_ip(FakeRequest("*"), config)
    print(repr(ip))        # -> '*'  (arbitrary string, no validation)

asyncio.run(main())

Then BehaviorTracker.track_endpoint_usage("app.login", "*", rule) issues KEYS behavior_usage:behavior:usage:app.login:*:* — matching other clients' keys (full fake-Redis script: poc_xff_redis.py, available on request).

Impact

Integrity and availability of the behavioral-analytics subsystem and the shared Redis instance, in deployments where the extracted XFF position is attacker-controllable. No data exposure; not reachable with default settings (trusted_proxies defaults empty).

Fix: validate the extracted XFF entry with ipaddress.ip_address() before returning it from extract_client_ip() (fall back to the connecting IP on failure); escape glob metacharacters (*?[]) in anything interpolated into a KEYS pattern — or replace the KEYS+per-request-key design with an atomic counter / Lua sliding window (the rate-limit Lua script already shows the right shape).

Affected software

Click a technology to see all vulnerabilities affecting it.

PlatformPackageVulnerable versionsFixed in
Python (PyPI) guard-core >= 1.0.0, < 3.13.0 3.13.0

References

CVSS score 5.4/10
CVSS vector
CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:C/C:N/I:L/A:L
Weakness (CWE)
CWE-20
Platform
Python (PyPI)
Package
guard-core
Disclosed
19.11.2026
Updated
20.11.2026 00:17

Sources and licenses

OSV / GitHub Advisory Database - GHSA-gm9r-hvc9-96gv - CC BY 4.0

Vulnerability history: guard-core

All published vulnerabilities of this package (Python (PyPI)), newest first. Shows whether this is a one-off slip or a package that needs watching.

Total entries
3
First → latest
11.2026 11.2026
Without a fix
0
Exploited in attacks
0

Severity breakdown

  • High 1
  • Medium 1
  • Low 1

Disclosures per year

  1. 2026: 3
  1. Guard Core: Unvalidated X-Forwarded-For-derived string used as a Redis key component and interpolated into a KEYS glob pattern this entry
    Medium · 5.4 CVE-2026-129304 >= 1.0.0, < 3.13.0 3.13.0

Know which vulnerabilities affect your application

With the DockRay integration and software inventory enabled, DockRay checks reported component versions against known vulnerabilities and notifies you about confirmed matches. Coverage depends on the supported technology and available advisory data.

Connect your application
DockRay newsletter

Application security in your inbox

Important vulnerabilities, actionable guidance and practical advice for your applications. Choose your technologies and follow what matters to your project.

  • A daily digest of new vulnerabilities, critical ones included.
  • Notifications about important updates.
  • Practical advice on application security and monitoring.

Leave empty to receive updates for every technology.

Free to subscribe. Unsubscribe with one click in any email.