fix(security): cross-event authz, SSE ticket flow, account hardening, audit logs

Follow-up to the comprehensive code review. Five batches:

1. Cross-event authorization: host_delete_upload, unban_user, and
   host_delete_comment now scope by auth.event_id. Adds
   Upload::find_by_id_and_event / soft_delete_in_event and a
   Comment::soft_delete_in_event variant that joins through upload.

2. Token exposure: SSE auth no longer puts the JWT in the URL.
   New /api/v1/stream/ticket endpoint mints a short-lived single-use
   ticket bound to the session; the EventSource passes ?ticket=...
   instead. Refuse to start in APP_ENV=production with the dev JWT
   sentinel; warn loudly otherwise.

3. Account hardening: per-IP+name rate limit on /recover (mitigates
   targeted lockout DoS), per-IP rate limit on /admin/login, random
   32-char admin recovery PIN (replaces "0000"), structured tracing
   events for wrong PIN, lockout, failed admin login, ban/unban/role
   change/pin-reset/host-delete.

4. DoS / correctness: comment listing paginated (LIMIT 50 + ?before=
   cursor), hashtag extraction whitelisted to ASCII alnum+underscore
   (≤40 chars) with unit tests, display_name / caption / comment body
   length validated in chars rather than bytes.

5. Cleanup: session-touch failures now logged, DATABASE_MAX_CONNECTIONS
   env var (default 10).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

backend/src/handlers/sse.rs

@@ -3,32 +3,51 @@ use std::time::Duration;
 
 use axum::extract::{Query, State};
 use axum::response::sse::{Event, KeepAlive, Sse};
+use axum::Json;
 use futures::stream::Stream;
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use tokio_stream::wrappers::BroadcastStream;
 use tokio_stream::StreamExt;
 
-use crate::auth::jwt;
+use crate::auth::middleware::AuthUser;
 use crate::error::AppError;
 use crate::models::session::Session;
 use crate::state::AppState;
 
 #[derive(Deserialize)]
 pub struct SseQuery {
-    pub token: String,
+    pub ticket: String,
 }
 
-/// SSE stream endpoint. Accepts JWT via query param since EventSource
-/// doesn't support custom headers.
+#[derive(Serialize)]
+pub struct StreamTicketResponse {
+    pub ticket: String,
+}
+
+/// Mint a short-lived single-use SSE ticket. The browser's `EventSource` cannot
+/// send an `Authorization` header, so the alternative used to be passing the JWT
+/// as `?token=...` — which leaks the bearer token into access logs, referer
+/// headers, and browser history. The client now exchanges its Bearer token for
+/// an opaque ticket via this endpoint and passes that on the stream open.
+pub async fn issue_ticket(
+    State(state): State<AppState>,
+    auth: AuthUser,
+) -> Json<StreamTicketResponse> {
+    let ticket = state.sse_tickets.issue(auth.token_hash);
+    Json(StreamTicketResponse { ticket })
+}
+
+/// SSE stream endpoint. Authenticates via a single-use ticket (see
+/// [`issue_ticket`]) — never the raw JWT.
 pub async fn stream(
     State(state): State<AppState>,
     Query(q): Query<SseQuery>,
 ) -> Result<Sse<impl Stream<Item = Result<Event, Infallible>>>, AppError> {
-    // Verify token
-    let _claims = jwt::verify_token(&q.token, &state.config.jwt_secret)
-        .map_err(|_| AppError::Unauthorized("Token ungültig.".into()))?;
+    let token_hash = state
+        .sse_tickets
+        .consume(&q.ticket)
+        .ok_or_else(|| AppError::Unauthorized("Ticket ungültig oder abgelaufen.".into()))?;
 
-    let token_hash = jwt::hash_token(&q.token);
     Session::find_by_token_hash(&state.pool, &token_hash)
         .await
         .map_err(|e| AppError::Internal(e.into()))?