237 lines
11 KiB
Python
237 lines
11 KiB
Python
#!/usr/bin/env python3
|
|
"""Does the sliding session with a hard ceiling work? - D18 / T13.1 (checked in T13.6).
|
|
|
|
T13.1 shipped with its done-when list unchecked and no test of its own; the old
|
|
session tests had no idea about idle time. This is that test.
|
|
|
|
1. Continuous activity keeps a session alive past 30 minutes, but never past the
|
|
absolute ceiling (AUTH_SESSION_HOURS) measured from the ORIGINAL sign-in.
|
|
2. A session idle for more than 30 minutes is refused on its next request.
|
|
3. The cookie is not rewritten on every request (the refresh is throttled).
|
|
4. A token from before this shipped (no login_at) still gets a hard ceiling,
|
|
from its iat.
|
|
5. A refresh carries identity and login_at forward unchanged.
|
|
6. The two variables are documented, and both defaults are flagged as proposed.
|
|
|
|
Self-contained: throwaway SQLite, in-process test client, no network, no browser.
|
|
Exit 0 all passed, 1 a failure.
|
|
"""
|
|
import os
|
|
import re
|
|
import sys
|
|
import tempfile
|
|
from datetime import datetime, timedelta, timezone
|
|
|
|
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
|
sys.path.insert(0, ROOT)
|
|
os.environ["DATABASE_URL"] = "sqlite:///" + os.path.join(tempfile.mkdtemp(prefix="wp-idle-"), "t.db").replace("\\", "/")
|
|
os.environ["AUTH_SECRET_KEY"] = "session-idle-check-secret-not-for-production"
|
|
os.environ.pop("AUTH_IDLE_MINUTES", None)
|
|
os.environ.pop("AUTH_SESSION_HOURS", None)
|
|
|
|
import jwt # noqa: E402
|
|
from fastapi.testclient import TestClient # noqa: E402
|
|
|
|
from server import app as appmod, auth, models # noqa: E402
|
|
from server.db import Base, SessionLocal, engine # noqa: E402
|
|
|
|
if not hasattr(auth, "maybe_refresh_token"):
|
|
print("SKIP: T13.1 (sliding session) is not on this branch. It waits for T14.1.")
|
|
sys.exit(0)
|
|
|
|
fails = 0
|
|
|
|
|
|
def chk(label, ok, extra=""):
|
|
global fails
|
|
print(("PASS " if ok else "FAIL ") + label + (f" [{extra}]" if (extra and not ok) else ""))
|
|
if not ok:
|
|
fails += 1
|
|
|
|
|
|
Base.metadata.create_all(bind=engine)
|
|
with SessionLocal() as db:
|
|
db.add(models.User(id="u1", username="alice", email="a@x.test", role=auth.ROLE_ADMIN))
|
|
db.commit()
|
|
USER = db.get(models.User, "u1")
|
|
db.expunge(USER)
|
|
|
|
# A route the auth gate covers. NOT /api/auth/me: everything under /api/auth/ is
|
|
# exempt from the gate (auth._EXEMPT_PREFIXES), so no session refresh happens there
|
|
# and a probe on it would pass without testing anything.
|
|
PROBE = "/api/projects"
|
|
IDLE = auth.IDLE_MINUTES
|
|
CEIL_H = auth.SESSION_HOURS
|
|
NOW = datetime.now(timezone.utc)
|
|
|
|
|
|
def mint(login_at=None, iat=None, exp=None, **extra):
|
|
"""A token with exactly the claims given (None = leave the claim out)."""
|
|
p = {"sub": "u1", "username": "alice", "role": auth.ROLE_ADMIN, "ver": 0}
|
|
if iat is not None:
|
|
p["iat"] = iat
|
|
if login_at is not None:
|
|
p["login_at"] = login_at.timestamp()
|
|
if exp is not None:
|
|
p["exp"] = exp
|
|
p.update(extra)
|
|
return jwt.encode(p, auth.SECRET_KEY, algorithm=auth.JWT_ALG)
|
|
|
|
|
|
def raw_claims(tok):
|
|
return jwt.decode(tok, auth.SECRET_KEY, algorithms=[auth.JWT_ALG], options={"verify_exp": False, "verify_iat": False, "verify_nbf": False})
|
|
|
|
|
|
class FakeClock(datetime):
|
|
_now = NOW
|
|
|
|
@classmethod
|
|
def now(cls, tz=None):
|
|
return cls._now
|
|
|
|
|
|
real_dt = auth.datetime
|
|
|
|
|
|
def at(t):
|
|
FakeClock._now = t
|
|
auth.datetime = FakeClock
|
|
|
|
|
|
def real():
|
|
auth.datetime = real_dt
|
|
|
|
|
|
print("defaults: idle %d min, ceiling %d h" % (IDLE, CEIL_H))
|
|
|
|
# ── 1. continuous activity, then the ceiling ──────────────────────────────────
|
|
print("\n1. continuous activity stays alive past 30 minutes, but is cut off at the ceiling")
|
|
at(NOW)
|
|
tok = auth.create_token(USER)
|
|
c = raw_claims(tok)
|
|
chk("a new token carries login_at", "login_at" in c)
|
|
chk("a new token expires one idle window out, not at the ceiling",
|
|
abs(c["exp"] - (NOW + timedelta(minutes=IDLE)).timestamp()) < 2)
|
|
login_at = NOW
|
|
cur = c
|
|
alive_past_30 = False
|
|
rewrites = 0
|
|
last_exp = cur["exp"]
|
|
t = NOW
|
|
STEP = timedelta(minutes=1) # an active user: a request every minute
|
|
end = NOW + timedelta(hours=CEIL_H + 2)
|
|
cut_off_at = None
|
|
while t < end:
|
|
t += STEP
|
|
at(t)
|
|
if cur["exp"] <= t.timestamp(): # the session already lapsed
|
|
cut_off_at = t
|
|
break
|
|
if t - NOW > timedelta(minutes=IDLE):
|
|
alive_past_30 = True
|
|
new = auth.maybe_refresh_token(cur)
|
|
if new:
|
|
rewrites += 1
|
|
cur = raw_claims(new)
|
|
last_exp = cur["exp"]
|
|
real()
|
|
chk("with a request every minute the session is alive well past 30 minutes", alive_past_30)
|
|
chk("it is never extended past the ceiling (last exp <= login + %d h)" % CEIL_H,
|
|
last_exp <= (login_at + timedelta(hours=CEIL_H)).timestamp() + 1,
|
|
str(datetime.fromtimestamp(last_exp, timezone.utc)))
|
|
chk("it IS cut off once the ceiling is reached, however active the session",
|
|
cut_off_at is not None and cut_off_at <= login_at + timedelta(hours=CEIL_H) + timedelta(minutes=IDLE) + STEP,
|
|
str(cut_off_at))
|
|
chk("the claims after the last refresh still carry the ORIGINAL login_at",
|
|
abs(cur["login_at"] - login_at.timestamp()) < 1)
|
|
steps = int((CEIL_H * 60) / 1)
|
|
chk("the cookie was rewritten far less often than once per request (%d rewrites for ~%d requests)" % (rewrites, steps),
|
|
0 < rewrites < steps / 5, f"{rewrites}/{steps}")
|
|
|
|
# ── 2. idle ───────────────────────────────────────────────────────────────────
|
|
print("\n2. a session idle for more than %d minutes is refused on its next request" % IDLE)
|
|
client = TestClient(appmod.app)
|
|
idle_tok = mint(login_at=NOW - timedelta(minutes=IDLE + 1), iat=NOW - timedelta(minutes=IDLE + 1),
|
|
exp=NOW - timedelta(minutes=1))
|
|
client.cookies.set(auth.COOKIE_NAME, idle_tok)
|
|
r = client.get(PROBE)
|
|
chk("an idle session gets 401", r.status_code == 401, r.status_code)
|
|
live_tok = mint(login_at=NOW - timedelta(minutes=5), iat=NOW - timedelta(minutes=5),
|
|
exp=NOW + timedelta(minutes=IDLE - 5))
|
|
client.cookies.clear()
|
|
client.cookies.set(auth.COOKIE_NAME, live_tok)
|
|
chk("a session inside the window gets 200", client.get(PROBE).status_code == 200)
|
|
|
|
# ── 3. throttle ───────────────────────────────────────────────────────────────
|
|
print("\n3. the cookie is not rewritten on every request")
|
|
fresh = auth.create_token(USER)
|
|
client.cookies.clear()
|
|
client.cookies.set(auth.COOKIE_NAME, fresh)
|
|
cookies_set = 0
|
|
for _ in range(20):
|
|
r = client.get(PROBE)
|
|
if "set-cookie" in r.headers and auth.COOKIE_NAME in r.headers["set-cookie"]:
|
|
cookies_set += 1
|
|
chk("20 rapid requests on a fresh session: 0 cookie rewrites", cookies_set == 0, cookies_set)
|
|
|
|
aged = mint(login_at=NOW - timedelta(minutes=20), iat=NOW - timedelta(minutes=20),
|
|
exp=NOW + timedelta(minutes=2)) # 2 minutes of idle window left
|
|
client.cookies.clear()
|
|
client.cookies.set(auth.COOKIE_NAME, aged)
|
|
r = client.get(PROBE)
|
|
chk("an aged session gets a refreshed cookie on its next request",
|
|
r.status_code == 200 and auth.COOKIE_NAME in r.headers.get("set-cookie", ""))
|
|
m = re.search(auth.COOKIE_NAME + r"=([^;]+)", r.headers.get("set-cookie", ""))
|
|
newc = raw_claims(m.group(1)) if m else {}
|
|
chk("the refreshed cookie keeps the original login_at",
|
|
abs(newc.get("login_at", 0) - (NOW - timedelta(minutes=20)).timestamp()) < 1)
|
|
client.cookies.clear()
|
|
client.cookies.set(auth.COOKIE_NAME, m.group(1) if m else "")
|
|
r2 = client.get(PROBE)
|
|
chk("...and the very next request does not rewrite it again", auth.COOKIE_NAME not in r2.headers.get("set-cookie", ""))
|
|
|
|
# ── 4. tokens from before D18 ─────────────────────────────────────────────────
|
|
print("\n4. a token with no login_at still gets a hard ceiling (via iat)")
|
|
old = {"sub": "u1", "username": "alice", "role": auth.ROLE_ADMIN, "ver": 0,
|
|
"iat": (NOW - timedelta(hours=CEIL_H + 1)).timestamp(),
|
|
"exp": (NOW + timedelta(hours=3)).timestamp()} # the old flat 12 h exp, still valid
|
|
chk("past its iat-based ceiling: no refresh, the old exp is not extended", auth.maybe_refresh_token(old) is None)
|
|
young = {"sub": "u1", "username": "alice", "role": auth.ROLE_ADMIN, "ver": 0,
|
|
"iat": (NOW - timedelta(hours=1)).timestamp(),
|
|
"exp": (NOW + timedelta(minutes=2)).timestamp()}
|
|
ref = auth.maybe_refresh_token(young)
|
|
rc = raw_claims(ref) if ref else {}
|
|
chk("inside the ceiling: refreshed, and login_at is taken from iat (not 'now')",
|
|
bool(ref) and abs(rc["login_at"] - young["iat"]) < 1)
|
|
chk("the refreshed token cannot outlive iat + ceiling",
|
|
bool(ref) and rc["exp"] <= young["iat"] + CEIL_H * 3600 + 1)
|
|
nothing = {"sub": "u1", "username": "alice", "role": auth.ROLE_ADMIN, "ver": 0,
|
|
"exp": (NOW + timedelta(minutes=2)).timestamp()}
|
|
chk("no login_at and no iat: no refresh, and no crash", auth.maybe_refresh_token(nothing) is None)
|
|
junk = dict(young, login_at="not-a-number")
|
|
chk("an unparseable login_at falls back to iat, no crash", auth.maybe_refresh_token(junk) is not None)
|
|
|
|
# ── 5. identity carried forward ───────────────────────────────────────────────
|
|
print("\n5. a refresh carries the identity forward unchanged")
|
|
src = {"sub": "u9", "username": "zed", "role": "project_admin", "ver": 7,
|
|
"iat": (NOW - timedelta(minutes=20)).timestamp(),
|
|
"login_at": (NOW - timedelta(minutes=20)).timestamp(),
|
|
"exp": (NOW + timedelta(minutes=2)).timestamp()}
|
|
rc = raw_claims(auth.maybe_refresh_token(src))
|
|
chk("sub, username, role, ver are unchanged",
|
|
(rc["sub"], rc["username"], rc["role"], rc["ver"]) == ("u9", "zed", "project_admin", 7))
|
|
|
|
# ── 6. documentation ──────────────────────────────────────────────────────────
|
|
print("\n6. the two variables are documented, defaults flagged as proposed")
|
|
env = open(os.path.join(ROOT, "server", ".env.example"), encoding="utf-8").read()
|
|
dep = open(os.path.join(ROOT, "DEPLOYMENT.md"), encoding="utf-8").read()
|
|
for name in ("AUTH_IDLE_MINUTES", "AUTH_SESSION_HOURS"):
|
|
chk(f"{name} is in .env.example", name in env)
|
|
chk(f"{name} is in DEPLOYMENT.md", name in dep)
|
|
chk(".env.example calls the defaults proposed, not confirmed", re.search(r"propos", env, re.I) is not None)
|
|
chk("DEPLOYMENT.md calls the defaults proposed, not confirmed", re.search(r"propos", dep, re.I) is not None)
|
|
|
|
print()
|
|
print("ALL PASSED" if not fails else f"{fails} FAILED")
|
|
sys.exit(0 if not fails else 1)
|