mirror of
https://github.com/headroomlabs-ai/headroom.git
synced 2026-11-22 15:06:14 +08:00
## Why this version Upgrade the native proxy's bounded session caches from lru 0.18.5 to 0.19.0 to retain the upstream iterator soundness correction. The official 0.19.0 changelog says "Require Sync for sendable shared iterators." In source, `Send for Iter<'a, K, V>` now requires `K: Sync, V: Sync`, replacing `K: Send, V: Send`: the iterator yields shared references, which may cross threads only when their referents are Sync. Headroom uses this crate for the shared `BetaStickyState` session beta-token union and `DriftState` structural-hash history. Both live in `Arc<Mutex<LruCache<...>>>` and are cloned into concurrent request handlers. They use String / Vec<String> / StructuralHash values; they do not transfer shared iterators across threads. Thus this updates a concurrency-sensitive dependency to its corrected upstream contract; it does not claim that current Headroom calls demonstrate an exploit or require a new API. The patch preserves the 0.19 target and adds the dependency rationale beside its declaration, removes an obsolete lru 0.12 documentation reference, and mechanically merges current main so the current security workflows and fixes are included. ## Compatibility and installation This is a pre-1.0 minor bump, so compatibility was checked rather than assumed. The only dependency introduced by lru remains hashbrown 0.17.1. The crate's MSRV is 1.85.0 in both 0.18.5 and 0.19.0; this bump does not raise it. Headroom's workspace rust-version=1.80 already understates that dependency floor; its pinned toolchain is 1.95.0, used for this validation. Correcting the workspace-wide MSRV declaration is outside this dependency patch. Native installation already builds the ONNX/image/AWS dependency stack and may fetch build dependencies and ONNX Runtime artifacts; lru adds no build script or model download. This was a fresh isolated native target build using the existing registry/artifact caches, not a clean offline-install certification. Runtime validation disables model downloads with HEADROOM_OFFLINE/HF_HUB_OFFLINE and uses only local fake upstreams, with no cloud inference or credentials. ## Validation - `cargo test -p headroom-proxy --lib cache_stabilization --locked`: 105 passed, including concurrent_unions_lose_no_tokens (8 threads, 50 updates each), LRU eviction and recency checks. - `cargo fmt --all -- --check`: passed. - `git diff --check`: passed. - `cargo test -p headroom-proxy --test integration_cache_drift --test integration_cache_control --test integration_e3_anthropic_cache_control --test integration_e4_openai_cache_key --locked`: 20 passed across four binaries (1/8/5/6). - `cargo build -p headroom-proxy --locked`: passed with Rust 1.95.0 on Windows MSVC. - `python scripts/verify_native_session_caches.py --proxy target/debug/headroom-proxy`: passed. A separately spawned native binary forwarded 12 requests to an ephemeral loopback fake Anthropic upstream without credentials. Sequential requests retained beta-a,beta-b; eight concurrent same-session requests retained all token-0 through token-7 in the next request. Logs recorded both first-seen and changed-system drift events. Both proxy and fake upstream were cleaned up. Compression interception was enabled with compression-mode off; this exercises the actual session caches and byte passthrough, not model compression or cloud behavior. - The standard-library runtime proof is committed as `scripts/verify_native_session_caches.py`; no private artifacts are required. Security/CI approval and remote branch update remain separate gates; this local proof does not certify hosted checks. Official upstream references: https://github.com/jeromefroe/lru-rs/blob/0.19.0/CHANGELOG.md and https://github.com/jeromefroe/lru-rs/blob/0.19.0/src/lib.rs . ## Reproduce the native loopback proof From the repository root, with its pinned Rust toolchain and Python 3: ```sh cargo build -p headroom-proxy --locked python scripts/verify_native_session_caches.py --proxy target/debug/headroom-proxy ``` On Windows use `--proxy target/debug/headroom-proxy.exe`. If `CARGO_TARGET_DIR` is set, pass the binary under that directory instead. Optional `--log /path/to/proxy.log` preserves logs; otherwise logs and the child working directory are temporary. The script uses only Python's standard library, strips provider/Headroom configuration environment variables, disables model egress, bypasses caller HTTP proxy settings, disables stats persistence, and starts only its own loopback fake upstream and native child. It returns nonzero on readiness, forwarding, sticky-union, or drift-event failures and cleans up its processes. This proof was rerun after making the harness portable: all 12 upstream requests passed. Current main was fetched again and remains `74277d47ecfbca349ddb99f81094c4dd30539d43`, already included in this candidate. --------- Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: JerrettDavis <mxjerrett@gmail.com>
202 lines
8.0 KiB
Python
202 lines
8.0 KiB
Python
"""Exercise native session caches against a credentialless loopback upstream.
|
|
|
|
Build: cargo build -p headroom-proxy --locked
|
|
Run: python scripts/verify_native_session_caches.py --proxy target/debug/headroom-proxy
|
|
On Windows append .exe. A custom CARGO_TARGET_DIR requires its binary path.
|
|
Only Python's standard library is required. Logs are temporary unless --log is set.
|
|
"""
|
|
|
|
import argparse
|
|
import concurrent.futures
|
|
import http.server
|
|
import json
|
|
import os
|
|
import socket
|
|
import subprocess
|
|
import tempfile
|
|
import threading
|
|
import time
|
|
import urllib.request
|
|
from pathlib import Path
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(description=__doc__)
|
|
parser.add_argument("--proxy", required=True, type=Path)
|
|
parser.add_argument("--log", type=Path, help="preserve native proxy logs here")
|
|
args = parser.parse_args()
|
|
binary = args.proxy.resolve(strict=True)
|
|
captured = []
|
|
capture_lock = threading.Lock()
|
|
|
|
class Upstream(http.server.BaseHTTPRequestHandler):
|
|
def do_POST(self):
|
|
body = self.rfile.read(int(self.headers["Content-Length"]))
|
|
with capture_lock:
|
|
captured.append((json.loads(body), self.headers.get("anthropic-beta", "")))
|
|
reply = json.dumps(
|
|
{
|
|
"id": "local",
|
|
"type": "message",
|
|
"role": "assistant",
|
|
"model": "claude-sonnet-4-20250514",
|
|
"content": [{"type": "text", "text": "local stub"}],
|
|
"stop_reason": "end_turn",
|
|
"usage": {"input_tokens": 10, "output_tokens": 2},
|
|
}
|
|
).encode()
|
|
self.send_response(200)
|
|
self.send_header("Content-Type", "application/json")
|
|
self.send_header("Content-Length", str(len(reply)))
|
|
self.end_headers()
|
|
self.wfile.write(reply)
|
|
|
|
def log_message(self, *unused):
|
|
pass
|
|
|
|
with tempfile.TemporaryDirectory(prefix="headroom-cache-proof-") as temporary:
|
|
log_path = args.log.resolve() if args.log else Path(temporary) / "proxy.log"
|
|
server = http.server.ThreadingHTTPServer(("127.0.0.1", 0), Upstream)
|
|
worker = threading.Thread(target=server.serve_forever, daemon=True)
|
|
worker.start()
|
|
# The native CLI does not publish its port when binding :0. Reserve a
|
|
# candidate briefly; readiness detects exit if another process wins it.
|
|
with socket.socket() as reservation:
|
|
reservation.bind(("127.0.0.1", 0))
|
|
port = reservation.getsockname()[1]
|
|
env = {
|
|
key: value
|
|
for key, value in os.environ.items()
|
|
if not key.upper().startswith(
|
|
(
|
|
"HEADROOM_",
|
|
"AWS_",
|
|
"ANTHROPIC_",
|
|
"OPENAI_",
|
|
"GOOGLE_",
|
|
"AZURE_",
|
|
)
|
|
)
|
|
}
|
|
env.update(
|
|
AWS_EC2_METADATA_DISABLED="true",
|
|
NO_PROXY="127.0.0.1,localhost",
|
|
HEADROOM_OFFLINE="1",
|
|
HF_HUB_OFFLINE="1",
|
|
HEADROOM_LIVE_ZONE_DISABLE_ARMS="source_code,plain_text",
|
|
)
|
|
command = [
|
|
str(binary),
|
|
"--listen",
|
|
f"127.0.0.1:{port}",
|
|
"--upstream",
|
|
f"http://127.0.0.1:{server.server_port}",
|
|
"--compression",
|
|
"--compression-mode",
|
|
"off",
|
|
"--stats",
|
|
"false",
|
|
"--log-level",
|
|
"info",
|
|
]
|
|
# Explicitly bypass caller HTTP proxy settings for all proof requests.
|
|
client = urllib.request.build_opener(urllib.request.ProxyHandler({}))
|
|
process = None
|
|
try:
|
|
with log_path.open("w", encoding="utf-8", newline="\n") as log:
|
|
process = subprocess.Popen(
|
|
command,
|
|
env=env,
|
|
cwd=temporary,
|
|
stdout=log,
|
|
stderr=subprocess.STDOUT,
|
|
)
|
|
deadline = time.monotonic() + 30
|
|
while time.monotonic() < deadline:
|
|
if process.poll() is not None:
|
|
raise RuntimeError(f"proxy exited: {process.returncode}")
|
|
try:
|
|
with client.open(f"http://127.0.0.1:{port}/healthz", timeout=1) as response:
|
|
response.read()
|
|
break
|
|
except OSError:
|
|
time.sleep(0.2)
|
|
else:
|
|
raise RuntimeError("proxy readiness timeout")
|
|
|
|
def request(system, token="", session="same"):
|
|
payload = {
|
|
"model": "claude-sonnet-4-20250514",
|
|
"max_tokens": 16,
|
|
"system": system,
|
|
"messages": [{"role": "user", "content": "hello local"}],
|
|
}
|
|
headers = {"content-type": "application/json", "x-headroom-session-id": session}
|
|
if token:
|
|
headers["anthropic-beta"] = token
|
|
outgoing = urllib.request.Request(
|
|
f"http://127.0.0.1:{port}/v1/messages",
|
|
data=json.dumps(payload).encode(),
|
|
headers=headers,
|
|
)
|
|
with client.open(outgoing, timeout=30) as response:
|
|
if (
|
|
response.status != 200
|
|
or json.load(response)["content"][0]["text"] != "local stub"
|
|
):
|
|
raise RuntimeError("unexpected forwarded response")
|
|
|
|
request("first system", "beta-a")
|
|
request("changed system", "beta-b")
|
|
request("changed system")
|
|
if captured[1][1] != "beta-a,beta-b" or captured[2][1] != "beta-a,beta-b":
|
|
raise RuntimeError(f"sequential beta union lost: {captured}")
|
|
with concurrent.futures.ThreadPoolExecutor(max_workers=8) as pool:
|
|
list(
|
|
pool.map(
|
|
lambda i: request("parallel system", f"token-{i}", "parallel"), range(8)
|
|
)
|
|
)
|
|
request("parallel system", session="parallel")
|
|
if set(captured[-1][1].split(",")) != {f"token-{i}" for i in range(8)}:
|
|
raise RuntimeError(f"concurrent beta union lost: {captured[-1]}")
|
|
if len(captured) != 12:
|
|
raise RuntimeError(f"expected 12 upstream requests, got {len(captured)}")
|
|
log.flush()
|
|
events = log_path.read_text(encoding="utf-8")
|
|
if (
|
|
"cache_drift_first_request" not in events
|
|
or "cache_drift_observed" not in events
|
|
):
|
|
raise RuntimeError("expected first-seen and changed-system drift events")
|
|
print(
|
|
json.dumps(
|
|
{
|
|
"passed": True,
|
|
"upstream_requests": len(captured),
|
|
"sequential_beta_union": captured[2][1],
|
|
"parallel_beta_tokens": sorted(captured[-1][1].split(",")),
|
|
"drift_first_seen_and_changed": True,
|
|
}
|
|
)
|
|
)
|
|
except Exception:
|
|
if log_path.exists():
|
|
print(log_path.read_text(encoding="utf-8"))
|
|
raise
|
|
finally:
|
|
if process is not None:
|
|
process.terminate()
|
|
try:
|
|
process.wait(timeout=10)
|
|
except subprocess.TimeoutExpired:
|
|
process.kill()
|
|
process.wait()
|
|
server.shutdown()
|
|
server.server_close()
|
|
worker.join(timeout=5)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|