kent/announcer
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Pluggbar autentisering: PIN, JWT og OIDC

Browse source 
Dagens «auth» var én delt PIN i et X-Pin-header, sammenlignet med !=, og
den sa ingenting om hvem som sendte et utrop – køen viste bare IP-adressen.
Crew har et eget adminpanel som skal bli identitetsleverandør.

Modellen er én datatype og én funksjon: Principal (hvem + roller +
rettigheter) og require(action), som enten gir deg den eller stopper
forespørselen. Handlinger: view, preview, announce, stop, clear.

Tre leverandører, prøvd i rekkefølge, alle valgfrie:

- pin   X-Pin som før, men med hmac.compare_digest istedenfor ==. Rolle
        admin som standard, så eksisterende oppsett oppfører seg likt.
        Beholdt bevisst: den virker uten nett, og det er nettopp da man
        trenger å rope ut noe.
- jwt   Authorization: Bearer. HS256 med delt hemmelighet, eller
        RS256/ES256 mot panelets JWKS. Krever exp – et token uten
        utløpstid er en evig nøkkel. Roller fra et konfigurerbart claim,
        som tåler liste, streng, kommaliste og punktsti.
- oidc  Autorisasjonskode med PKCE. Discovery hentes først ved første
        innlogging, så tjenesten starter selv om panelet er nede.

En leverandør er aktiv når den står i auth.providers *eller* når den er
ferdig konfigurert. Derfor slår ANNOUNCER_PIN=1234 alene fortsatt på PIN,
slik det har virket til nå. Er ingen aktiv, er alt åpent – som før.

/auth/token?t=<jwt> er broa mens panelet mangler OIDC: panelet lenker hit
med et kortlevd token, vi setter sesjonscookie. Ett klikk, ingen PIN.
Kontrakten panelet skal oppfylle står i docs/crew-integration.md.

401 betyr «vi vet ikke hvem du er, logg inn», 403 «vi vet hvem du er, men
rollen din får ikke dette». Et gyldig token uten roller gir 403, ikke 401 –
å logge inn på nytt ville ikke hjulpet.

Samtidig:

- /api/status er lukket bak «view». Den var åpen, og lekket både
  meldingstekstene og IP-ene til alle som hadde sendt noe, til hvem som
  helst som nådde porten. IP vises nå bare for den som har «clear»; alle
  andre ser navnet.
- Køen og en revisjonslogg i logs/announcements.jsonl viser hvem som sendte
  hva. Loggen feiler aldri forespørselen – en logg som ikke lar seg skrive
  skal ikke hindre et utrop.
- Branding flyttet fra index.html til /api/config, så config.toml fra
  forrige commit faktisk brukes.
- Sesjonsnøkkel i instance/secret_key, ellers logges alle ut ved hver
  restart. SESSION_COOKIE_SECURE settes bare bak TLS: appen kjører på rå
  HTTP over LAN og NetBird, og med Secure på ville ingen klart å logge inn.

57 tester, de fleste på auth, inkludert hele OIDC-runden mot en stubbet
leverandør. Det er delen man ikke kan se etter med øyet: at en PIN virker
ser du med en gang, at et utløpt token blir avvist ser du aldri før det
smeller.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Kent 2026-10-08 15:43:35 +02:00
parent 87066bb8c2
commit d6eb811ee5
10 changed files with 2090 additions and 117 deletions
Download patch file Download diff file Expand all files Collapse all files

183
announcer.py
View file

@ -1,16 +1,19 @@
#!/usr/bin/env python3
"""Announcer – tekst inn, forhåndslytt i nettleseren, les ut på PC-ens lydutgang.
Kjøres på PC-en som er koblet til høyttaleranlegget. Alle på nettet kan åpne
sida og sende meldinger; selve avspillingen skjer alltid lokalt på denne
maskinen via pw-play (PipeWire) eller paplay.
Kjøres på PC-en som er koblet til høyttaleranlegget. Selve avspillingen skjer
alltid lokalt på denne maskinen via pw-play (PipeWire) eller paplay.
Tittel, tekst og hurtigfraser kommer fra config.py, så appen ikke er bundet til
ett arrangement. Innlogging er valgfri og settes opp i auth.py; uten
konfigurasjon er alt åpent, som før.
"""
from __future__ import annotations
import argparse
import hashlib
import io
import json
import logging
import math
import os
@ -26,12 +29,17 @@ from pathlib import Path
from flask import Flask, Response, abort, jsonify, request, send_file
import auth
import config
from auth import require
HERE = Path(__file__).resolve().parent
VOICE_DIR = Path(os.environ.get("ANNOUNCER_VOICES", HERE / "voices"))
CACHE_DIR = Path(os.environ.get("ANNOUNCER_CACHE", HERE / "cache"))
PIN = os.environ.get("ANNOUNCER_PIN", "").strip()
SINK = os.environ.get("ANNOUNCER_SINK", "").strip() # pw-play --target
MAX_CHARS = 600
CFG = config.load()
VOICE_DIR = CFG.path("voices")
CACHE_DIR = CFG.path("cache")
LOG_PATH = CFG.path("log")
SINK = str(CFG.get("audio", "sink", "")).strip() # pw-play --target
MAX_CHARS = int(CFG.app["max_chars"])
# Stemmene som tilbys i menyen. To motorer:
# edge – Microsofts nevrale stemmer via edge-tts (gratis, krever internett,
@ -65,11 +73,16 @@ VOICES_LIST: list[dict] = [
_piper("en-jenny", "Jenny (UK)", "Lokal reserve (uten nett)", "en_GB-jenny_dioco-medium"),
]
VOICES: dict[str, dict] = {v["id"]: v for v in VOICES_LIST}
DEFAULT_VOICE = "finn"
EDGE_RATE = 24000
# Konfigurerte standardvalg, men bare hvis de finnes – en skrivefeil i
# config.toml skal ikke gjøre sida ubrukelig.
DEFAULT_VOICE = CFG.app["default_voice"] if CFG.app["default_voice"] in VOICES else "finn"
DEFAULT_CHIME = CFG.app["default_chime"]
log = logging.getLogger("announcer")
app = Flask(__name__, static_folder=None)
AUTH = auth.install(app, CFG)
# --------------------------------------------------------------------------
@ -104,7 +117,7 @@ def load_voice(name: str):
# (wav/mp3/ogg/flac) i CHIME_DIR dukker opp automatisk i menyen.
# --------------------------------------------------------------------------
CHIME_DIR = Path(os.environ.get("ANNOUNCER_CHIMES", HERE / "chimes"))
CHIME_DIR = CFG.path("chimes")
def _tone(rate: int, freq: float, dur: float, vol: float = 0.35, wave_: str = "sine",
@ -305,17 +318,23 @@ class Item:
voice: str
speed: float
chime: str
sender: str
sender: str # IP-adressen forespørselen kom fra
user: str = "" # visningsnavnet til den som sendte
subject: str = "" # stabil id, f.eks. "jwt:kent"
method: str = "none"
created: float = field(default_factory=time.time)
status: str = "queued" # queued | playing | done | stopped | failed
error: str = ""
def public(self) -> dict:
def public(self, *, show_ip: bool = False) -> dict:
return {
"id": self.id,
"text": self.text,
"voice": VOICES[self.voice]["name"] if self.voice in VOICES else self.voice,
"sender": self.sender,
"user": self.user,
# IP-en er bare interessant for en admin som skal finne ut hvem
# som rotet; alle andre ser navnet.
"sender": self.sender if show_ip else "",
"created": self.created,
"status": self.status,
"error": self.error,
@ -348,10 +367,16 @@ class Player:
self.seq = 0
threading.Thread(target=self._loop, daemon=True, name="player").start()
def enqueue(self, text: str, voice: str, speed: float, chime: str, sender: str) -> Item:
def enqueue(self, text: str, voice: str, speed: float, chime: str, sender: str,
who: auth.Principal | None = None) -> Item:
with self.lock:
self.seq += 1
item = Item(self.seq, text, voice, speed, chime, sender)
item = Item(
self.seq, text, voice, speed, chime, sender,
user=who.name if who else "",
subject=who.subject if who else "",
method=who.method if who else "none",
)
self.history.append(item)
del self.history[:-50]
self.q.put(item)
@ -373,12 +398,13 @@ class Player:
item.status = "stopped"
self.stop()
def snapshot(self) -> dict:
def snapshot(self, *, show_ip: bool = False) -> dict:
with self.lock:
return {
"current": self.current.public() if self.current else None,
"queued": [i.public() for i in self.history if i.status == "queued"],
"history": [i.public() for i in reversed(self.history) if i.status not in ("queued", "playing")][:15],
"current": self.current.public(show_ip=show_ip) if self.current else None,
"queued": [i.public(show_ip=show_ip) for i in self.history if i.status == "queued"],
"history": [i.public(show_ip=show_ip) for i in reversed(self.history)
if i.status not in ("queued", "playing")][:15],
}
def _loop(self) -> None:
@ -409,6 +435,9 @@ class Player:
with self.lock:
self.current = None
self.proc = None
audit("played", id=item.id, status=item.status, error=item.error,
subject=item.subject, name=item.user, method=item.method,
ip=item.sender, text=item.text, voice=item.voice)
player = Player()
@ -419,9 +448,34 @@ player = Player()
# --------------------------------------------------------------------------
def check_pin() -> None:
if PIN and request.headers.get("X-Pin", "") != PIN:
abort(401)
MAX_LOG_BYTES = 5_000_000
_log_lock = threading.Lock()
def audit(action: str, **fields) -> None:
"""Én JSON-linje per hendelse, så man i ettertid kan se hvem som sendte hva.
Append-only og rullerer ved 5 MB. Feiler aldri forespørselen – en logg som
ikke lar seg skrive skal ikke hindre et utrop.
"""
rec = {"ts": round(time.time(), 3), "action": action,
**{k: v for k, v in fields.items() if v not in ("", None)}}
line = json.dumps(rec, ensure_ascii=False)
try:
with _log_lock:
LOG_PATH.parent.mkdir(parents=True, exist_ok=True)
if LOG_PATH.exists() and LOG_PATH.stat().st_size > MAX_LOG_BYTES:
LOG_PATH.replace(LOG_PATH.with_name(LOG_PATH.name + ".1"))
with LOG_PATH.open("a", encoding="utf-8") as fh:
fh.write(line + "\n")
except OSError as e:
log.warning("fikk ikke skrevet til %s: %s", LOG_PATH, e)
def who(p: auth.Principal) -> dict:
"""Identitetsfeltene audit() vil ha."""
return {"subject": p.subject, "name": p.name, "method": p.method,
"ip": request.remote_addr or ""}
def parse_request() -> tuple[str, str, float, str]:
@ -439,9 +493,9 @@ def parse_request() -> tuple[str, str, float, str]:
except (TypeError, ValueError):
abort(400, "Ugyldig hastighet")
speed = max(0.6, min(1.6, speed))
chime = data.get("chime", "dingdong")
chime = data.get("chime", DEFAULT_CHIME)
if chime is True:
chime = "dingdong"
chime = DEFAULT_CHIME
elif chime is False or chime is None:
chime = "none"
chime = str(chime)
@ -456,58 +510,86 @@ def index() -> Response:
@app.get("/api/config")
def config() -> Response:
def client_config() -> Response:
"""Alt sida trenger for å tegne seg selv: branding, menyer og hvem du er.
Svarer alltid 200, også med feil PIN – her spør klienten «hvem er jeg?»,
og da er svaret «ikke innlogget», ikke en feil.
"""
me = auth.current()
return jsonify(
{
"app": {
"title": CFG.app["title"],
"subtitle": CFG.app["subtitle"],
"accent": CFG.app["accent"],
"idle_text": CFG.app["idle_text"],
"message_placeholder": CFG.app["message_placeholder"],
"quick_phrases": list(CFG.app["quick_phrases"]),
},
"voices": [{"id": v["id"], "name": v["name"], "group": v["group"], "engine": v["engine"]} for v in VOICES_LIST],
"default_voice": DEFAULT_VOICE,
"chimes": list_chimes(),
"default_chime": "dingdong",
"default_chime": DEFAULT_CHIME,
"max_chars": MAX_CHARS,
"pin_required": bool(PIN),
"auth": {
**AUTH.describe(),
"user": None if me.anonymous else me.public(),
"can": sorted(me.permissions),
"error": auth.error(),
},
}
)
@app.post("/api/preview")
def preview() -> Response:
check_pin()
me = require("preview")
text, voice, speed, chime = parse_request()
try:
path = synthesize(text, voice, speed, chime)
except Exception as e: # noqa: BLE001
log.exception("syntese feilet")
audit("preview", **who(me), text=text, voice=voice, error=str(e)[:200])
abort(502, f"Syntese feilet ({VOICES[voice]['name']}): {e}. Prøv en lokal reserve-stemme.")
audit("preview", **who(me), text=text, voice=voice)
return send_file(path, mimetype="audio/wav", max_age=3600)
@app.post("/api/announce")
def announce() -> Response:
check_pin()
me = require("announce")
text, voice, speed, chime = parse_request()
sender = request.remote_addr or "?"
item = player.enqueue(text, voice, speed, chime, sender)
log.info("kø #%d fra %s: %s", item.id, sender, text)
return jsonify(item.public())
item = player.enqueue(text, voice, speed, chime, sender, me)
log.info("kø #%d fra %s (%s): %s", item.id, item.user or sender, sender, text)
audit("announce", **who(me), id=item.id, text=text, voice=voice,
speed=speed, chime=chime)
return jsonify(item.public(show_ip=me.can("clear")))
@app.post("/api/stop")
def stop() -> Response:
check_pin()
me = require("stop")
player.stop()
audit("stop", **who(me))
return jsonify({"ok": True})
@app.post("/api/clear")
def clear() -> Response:
check_pin()
me = require("clear")
player.clear()
audit("clear", **who(me))
return jsonify({"ok": True})
@app.get("/api/status")
def status() -> Response:
return jsonify(player.snapshot())
# Lukket bak «view»: køen inneholder meldingstekstene og IP-ene til dem
# som har sendt noe, og det er ikke noe alle utenfra skal få se.
me = require("view")
return jsonify(player.snapshot(show_ip=me.can("clear")))
@app.errorhandler(400)
@ -522,19 +604,40 @@ def bad_gateway(e): # noqa: ANN001
@app.errorhandler(401)
def unauthorized(e): # noqa: ANN001
return jsonify({"error": "Feil PIN"}), 401
return jsonify({"error": e.description, "login": True}), 401
@app.errorhandler(403)
def forbidden(e): # noqa: ANN001
return jsonify({"error": e.description}), 403
@app.errorhandler(404)
def not_found(e): # noqa: ANN001
# Klienten snakker JSON med /api og /auth, og skal ikke få en HTML-side
# tilbake og tolke den som en feilmelding.
if request.path.startswith(("/api/", "/auth/")):
msg = e.description or ""
if not msg or "requested URL" in msg:
msg = "Finnes ikke"
return jsonify({"error": msg}), 404
return e
def main() -> None:
ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
ap.add_argument("--host", default="0.0.0.0")
ap.add_argument("--port", type=int, default=int(os.environ.get("ANNOUNCER_PORT", 8090)))
ap.add_argument("--host", default=CFG.get("server", "host", "0.0.0.0"))
ap.add_argument("--port", type=int, default=int(CFG.get("server", "port", 8090)))
args = ap.parse_args()
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
logging.getLogger("werkzeug").setLevel(logging.WARNING)
ensure_voices()
load_voice("no_NO-talesyntese-medium") # varm opp reserven
log.info("klar på http://%s:%d (PIN: %s, sink: %s)", args.host, args.port, "på" if PIN else "av", SINK or "standard")
if CFG.source:
log.info("konfigurasjon fra %s", CFG.source)
methods = ", ".join(m["method"] for m in AUTH.describe()["methods"]) or "åpen (ingen innlogging)"
log.info("klar på http://%s:%d (auth: %s, sink: %s)",
args.host, args.port, methods, SINK or "standard")
app.run(host=args.host, port=args.port, threaded=True)