"""Per-session token: bound to auth. Issued only when the receiver has auth
on; an authenticated token grants the session's namespaces, a wrong/absent
token is treated as anonymous (public namespaces only); no-auth clusters use
no token at all.
"""
from __future__ import annotations
from .helpers import FakeRegistry, InProcessTransport, build_store
class _Ctx:
def __init__(self, is_admin=False, namespaces=None):
self.is_admin = is_admin
self.namespaces = namespaces
class _Auth:
def __init__(self, tokens):
self._tokens = tokens
def authenticate(self, token):
if token in self._tokens:
return self._tokens[token]
raise ValueError("bad token")
def _env(dataset, name="x", origin="P", ver=1):
sid = "generic_" + name
return {
"dataset": dataset, "service_id": sid, "origin_id": origin,
"version": [ver, origin], "tombstone": False,
"payload": {"entry": {"service_id": sid, "type": "generic", "source": "api_config",
"service_data": {"name": name, "description": "d",
"inputSchema": {}, "url": None}},
"wrapped": {"id": sid, "type": "generic", "name": name,
"description": "d", "metadata": {}}},
}
def _open_body(node="A"):
return {"node_id": node, "address": node, "namespaces": [], "token": None}
def test_token_issued_only_when_auth_on(tmp_path):
t = InProcessTransport()
open_b = build_store(tmp_path, "Bopen", FakeRegistry(), t, auth_store=None)
assert open_b.handle_open(_open_body())["session_token"] is None
auth_b = build_store(tmp_path, "Bauth", FakeRegistry(), t, auth_store=_Auth({}))
tok = auth_b.handle_open(_open_body())["session_token"]
assert tok is not None and len(tok) >= 16
def _setup_authed_receiver(tmp_path, t):
rB = FakeRegistry()
rB.add_generic("secure", "b-sec")
rB.add_generic("open", "b-open")
rB.set_auth_required("secure", True)
B = build_store(tmp_path, "B", rB, t,
auth_store=_Auth({"p": _Ctx(namespaces={"secure"})}))
resp = B.handle_open({"node_id": "P", "address": "P",
"namespaces": ["secure", "open"], "token": "p"})
assert set(resp["accepted"]) == {"secure", "open"}
return B, resp["session_token"]
def test_valid_token_grants_session_wrong_token_public_only(tmp_path):
t = InProcessTransport()
B, sess = _setup_authed_receiver(tmp_path, t)
rows = B.serve_digest("P", ["secure", "open"], sess)
assert {r[0] for r in rows} == {"secure", "open"}
rows_bad = B.serve_digest("P", ["secure", "open"], "WRONG")
assert {r[0] for r in rows_bad} == {"open"}
rows_none = B.serve_digest("P", ["secure", "open"], None)
assert {r[0] for r in rows_none} == {"open"}
def test_spoofed_push_to_protected_namespace_rejected(tmp_path):
t = InProcessTransport()
B, sess = _setup_authed_receiver(tmp_path, t)
res = B.serve_updates("P", [_env("secure", "evil")], "WRONG")
assert res["accepted"] == 0 and res["rejected"] == 1
assert all(r["wrapped"]["name"] != "evil" for r in B.foreign_rows("secure"))
res = B.serve_updates("P", [_env("secure", "good")], sess)
assert res["accepted"] == 1
assert any(r["wrapped"]["name"] == "good" for r in B.foreign_rows("secure"))
def test_keepalive_requires_token_when_auth_on(tmp_path):
t = InProcessTransport()
B, sess = _setup_authed_receiver(tmp_path, t)
assert B.handle_keepalive("P", "WRONG")["ok"] is False
assert B.handle_keepalive("P", sess)["ok"] is True
def test_session_token_over_http_with_auth(cluster_auth_app):
"""End-to-end over the real HTTP stack (router reads X-Cluster-Session):
a valid session token exposes the protected namespace in /digest; an
absent token is downgraded to anonymous (public only)."""
import uuid
client, admin = cluster_auth_app
headers = {"Authorization": f"Bearer {admin}"}
ds = "secure_" + uuid.uuid4().hex[:6]
assert client.post("/api/datasets", json={"name": ds, "auth_required": True},
headers=headers).status_code == 200
sid = client.post(f"/api/datasets/{ds}/services/generic",
json={"name": "sec-svc", "description": "d"},
headers=headers).json()["service_id"]
resp = client.post("/api/cluster/sessions",
json={"node_id": "P", "address": "http://p",
"namespaces": [ds], "token": admin}).json()
assert ds in resp["accepted"]
session_token = resp["session_token"]
assert session_token
r = client.get("/api/cluster/digest",
params={"from_node": "P", "namespaces": ds},
headers={"X-Cluster-Session": session_token})
assert r.status_code == 200
assert any(row[0] == ds and row[2] == sid for row in r.json())
r = client.get("/api/cluster/digest",
params={"from_node": "P", "namespaces": ds})
assert r.status_code == 200
assert all(row[0] != ds for row in r.json())
def test_no_auth_cluster_ignores_token(tmp_path):
"""End-to-end over the in-process transport: with no auth, sync works
with no token system at all."""
t = InProcessTransport()
rA, rB = FakeRegistry(), FakeRegistry()
rA.add_generic("open", "a-svc")
rB.add_generic("open", "b-svc")
A = build_store(tmp_path, "A", rA, t)
B = build_store(tmp_path, "B", rB, t)
A.connect_peer("B")
assert A._sessions["B"].token is None
assert any(r["wrapped"]["name"] == "b-svc" for r in A.foreign_rows("open"))
assert any(r["wrapped"]["name"] == "a-svc" for r in B.foreign_rows("open"))