Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 2 additions & 0 deletions .env.example
Original file line number Diff line number Diff line change
Expand Up @@ -11,6 +11,8 @@ FABLE_CORS_ORIGINS=[]
FABLE_MAX_REQUEST_BODY_BYTES=262144
FABLE_INGESTION_API_KEY=
FORWARDED_ALLOW_IPS=127.0.0.1
# Optional comma-separated CIDRs/IPs of trusted reverse proxies for client IP extraction
FABLE_TRUSTED_PROXY_CIDRS=
FABLE_AUTH_RATE_WINDOW_SECONDS=900
FABLE_AUTH_REGISTER_LIMIT_PER_IP=5
FABLE_AUTH_LOGIN_LIMIT_PER_IP=60
Expand Down
24 changes: 18 additions & 6 deletions backend/api/v1/endpoints/auth.py
Original file line number Diff line number Diff line change
@@ -1,4 +1,5 @@
from fastapi import APIRouter, BackgroundTasks, Header, HTTPException, Request, status
from fastapi import APIRouter, BackgroundTasks, Header, HTTPException, Request, Response, status
from core.rate_limit import extract_client_ip
from schemas import (
RegisterRequest,
LoginRequest,
Expand All @@ -23,13 +24,13 @@

@router.post("/auth/register", response_model=AuthResponse, status_code=status.HTTP_201_CREATED)
def register(req: RegisterRequest, request: Request):
client_host = request.client.host if request.client else "unknown"
client_host = extract_client_ip(request)
enforce_auth_rate_limit("register", client_host)
return auth_service.register_user(req)

@router.post("/auth/login", response_model=AuthResponse)
def login(req: LoginRequest, request: Request):
client_host = request.client.host if request.client else "unknown"
client_host = extract_client_ip(request)
enforce_auth_rate_limit("login", client_host, req.email)
return auth_service.login_user(req)

Expand All @@ -48,7 +49,7 @@ def request_password_reset(
detail="Password recovery is temporarily unavailable.",
) from error

client_host = request.client.host if request.client else "unknown"
client_host = extract_client_ip(request)
enforce_auth_rate_limit("password_reset", client_host, payload.email)
token = auth_service.issue_password_reset_token(payload.email)
if token is not None:
Expand All @@ -64,8 +65,11 @@ def request_password_reset(


@router.post("/auth/password-reset/confirm", status_code=status.HTTP_204_NO_CONTENT)
def confirm_password_reset(payload: PasswordResetConfirmRequest):
def confirm_password_reset(payload: PasswordResetConfirmRequest, request: Request):
client_host = extract_client_ip(request)
enforce_auth_rate_limit("password_reset_confirm", client_host, payload.token[:16])
auth_service.reset_password_with_token(payload.token, payload.new_password)
return Response(status_code=status.HTTP_204_NO_CONTENT)

@router.get("/auth/me", response_model=UserDTO)
def get_me(authorization: str = Header(None)):
Expand All @@ -82,10 +86,18 @@ def get_my_stories(authorization: str = Header(None)):
@router.patch("/auth/me", response_model=UserDTO)
def update_me(req: ProfileUpdateRequest, authorization: str = Header(None)):
auth_service.get_current_user_from_header(authorization)
token = authorization.split(" ", 1)[1]
token = authorization.split(" ", 1)[1].strip()
return auth_service.update_current_user(token, req)


@router.delete("/auth/me", status_code=status.HTTP_204_NO_CONTENT)
def delete_me(authorization: str = Header(None)):
auth_service.get_current_user_from_header(authorization)
token = authorization.split(" ", 1)[1].strip()
auth_service.delete_current_user(token)
return Response(status_code=status.HTTP_204_NO_CONTENT)


@router.post("/auth/me/reading-sessions", status_code=status.HTTP_204_NO_CONTENT)
def record_reading_session(
request: ReadingSessionRequest,
Expand Down
22 changes: 20 additions & 2 deletions backend/api/v1/endpoints/stories.py
Original file line number Diff line number Diff line change
@@ -1,15 +1,16 @@
from datetime import datetime
from typing import Optional
from uuid import UUID
from fastapi import APIRouter, Header, Query, status
from fastapi import APIRouter, Header, Query, Response, status

from schemas import (
StoryDTO,
ChapterDTO,
GenreDTO,
WriterDTO,
UpdateFeedDTO,
CreateStoryRequest
CreateStoryRequest,
UpdateStoryRequest,
)
from services import auth_service, story_service

Expand Down Expand Up @@ -59,3 +60,20 @@ def get_story_chapter_by_number(story_id: UUID, chapter_number: int):
def create_story(payload: CreateStoryRequest, authorization: str = Header(None)):
user = auth_service.get_current_user_from_header(authorization)
return story_service.create_story(payload, author=user.name, owner_user_id=user.id)


@router.patch("/stories/{story_id}", response_model=StoryDTO)
def update_story(
story_id: UUID,
payload: UpdateStoryRequest,
authorization: str = Header(None),
):
user = auth_service.get_current_user_from_header(authorization)
return story_service.update_story(story_id, payload, owner_user_id=user.id)


@router.delete("/stories/{story_id}", status_code=status.HTTP_204_NO_CONTENT)
def delete_story(story_id: UUID, authorization: str = Header(None)):
user = auth_service.get_current_user_from_header(authorization)
story_service.delete_story(story_id, owner_user_id=user.id)
return Response(status_code=status.HTTP_204_NO_CONTENT)
31 changes: 31 additions & 0 deletions backend/core/database.py
Original file line number Diff line number Diff line change
Expand Up @@ -308,6 +308,8 @@ def init_db():
""")
conn.execute("CREATE INDEX IF NOT EXISTS idx_account_shelf_owner_device ON account_shelf_items (owner_user_id, device_id);")
conn.execute("CREATE INDEX IF NOT EXISTS idx_account_shelf_story ON account_shelf_items (story_id);")
conn.execute("CREATE INDEX IF NOT EXISTS idx_stories_owner_created ON stories (owner_user_id, created_at_utc DESC);")
conn.execute("CREATE INDEX IF NOT EXISTS idx_shelf_story_owner ON account_shelf_items (story_id, owner_user_id);")
conn.execute("""
CREATE TABLE IF NOT EXISTS reading_sessions (
owner_user_id TEXT NOT NULL,
Expand Down Expand Up @@ -337,6 +339,35 @@ def init_db():
_add_column_if_missing(conn, "users", "handle", "TEXT NOT NULL DEFAULT ''")
_add_column_if_missing(conn, "users", "bio", "TEXT NOT NULL DEFAULT ''")
conn.execute("CREATE INDEX IF NOT EXISTS idx_users_email ON users (email);")
duplicate_handles = conn.execute(
"""
SELECT LOWER(handle) AS lowered_handle
FROM users
WHERE handle <> ''
GROUP BY LOWER(handle)
HAVING COUNT(*) > 1
"""
).fetchall()
for duplicate in duplicate_handles:
rows = conn.execute(
"""
SELECT id, handle
FROM users
WHERE LOWER(handle) = ?
ORDER BY created_at_utc ASC, id ASC
""",
(duplicate["lowered_handle"],),
).fetchall()
for row in rows[1:]:
suffix = row["id"].replace("-", "")[:6]
base = row["handle"][:33]
conn.execute(
"UPDATE users SET handle = ? WHERE id = ?",
(f"{base}_{suffix}", row["id"]),
)
conn.execute(
"CREATE UNIQUE INDEX IF NOT EXISTS idx_users_handle_lower ON users (LOWER(handle)) WHERE handle <> '';"
)
conn.execute("""
CREATE TABLE IF NOT EXISTS user_sessions (
token_hash TEXT PRIMARY KEY,
Expand Down
127 changes: 114 additions & 13 deletions backend/core/rate_limit.py
Original file line number Diff line number Diff line change
@@ -1,12 +1,13 @@
from __future__ import annotations

import hashlib
import ipaddress
import math
import os
import time
import threading
import math
import hashlib
import time
from collections import deque
from typing import Tuple, Dict, Optional, Union
from typing import Callable, Dict, Optional, Tuple, Union
from core.database import get_db, lock_transaction_key
from starlette.middleware.base import BaseHTTPMiddleware
from starlette.concurrency import run_in_threadpool
Expand All @@ -15,6 +16,75 @@
from core.settings import load_rate_limit_enabled


def _load_trusted_proxy_networks() -> tuple[ipaddress._BaseNetwork, ...]:
raw_cidrs = os.environ.get("FABLE_TRUSTED_PROXY_CIDRS", "").strip()
if not raw_cidrs:
return ()
networks: list[ipaddress._BaseNetwork] = []
for raw_cidr in raw_cidrs.split(","):
candidate = raw_cidr.strip()
if not candidate:
continue
try:
networks.append(ipaddress.ip_network(candidate, strict=False))
except ValueError:
continue
return tuple(networks)


def _parse_ip(raw_ip: Optional[str]) -> Optional[ipaddress._BaseAddress]:
if not raw_ip:
return None
candidate = raw_ip.strip()
if not candidate:
return None
# Strip optional port on IPv4 like "203.0.113.1:1234" or bracketed IPv6 "[::1]:1234"
if candidate.startswith("[") and "]" in candidate:
candidate = candidate[1:candidate.index("]")]
elif candidate.count(":") == 1 and "." in candidate:
candidate = candidate.split(":", 1)[0]
try:
return ipaddress.ip_address(candidate)
except ValueError:
return None


def _is_trusted_proxy(raw_ip: Optional[str], networks: tuple[ipaddress._BaseNetwork, ...]) -> bool:
if not networks:
return False
parsed = _parse_ip(raw_ip)
if parsed is None:
return False
return any(parsed in network for network in networks)


def extract_client_ip(request: Request) -> str:
"""Resolve the client IP, honoring forwarded headers only from trusted proxy CIDRs."""
peer_host = request.client.host if request.client and request.client.host else ""
trusted_networks = _load_trusted_proxy_networks()

if trusted_networks and _is_trusted_proxy(peer_host, trusted_networks):
forwarded_for = request.headers.get("x-forwarded-for", "")
if forwarded_for:
hops = [part.strip() for part in forwarded_for.split(",") if part.strip()]
for hop in reversed(hops):
parsed = _parse_ip(hop)
if parsed is None:
break
if not any(parsed in network for network in trusted_networks):
return str(parsed)
if hops:
parsed_first = _parse_ip(hops[0])
if parsed_first is not None:
return str(parsed_first)

real_ip = _parse_ip(request.headers.get("x-real-ip"))
if real_ip is not None:
return str(real_ip)

return peer_host or "127.0.0.1"


class SlidingWindowRateLimiter:
"""
Thread-safe in-memory sliding window rate limiter.
Expand Down Expand Up @@ -110,6 +180,10 @@ def __init__(
self._max_client_buckets = max_client_buckets
self._last_capacity_cleanup = 0.0
self._cleanup_lock = threading.Lock()
self._reset_hooks: list[Callable[[], None]] = []

def add_reset_hook(self, hook: Callable[[], None]) -> None:
self._reset_hooks.append(hook)

def is_allowed(self, client_id: str, tier: str = "general") -> Tuple[bool, int]:
limit, window = self.limits.get(tier, self.limits["general"])
Expand Down Expand Up @@ -196,6 +270,8 @@ def reset(self) -> None:
self._last_capacity_cleanup = 0.0
finally:
connection.close()
for hook in self._reset_hooks:
hook()


# Shared singleton instance configured via environment variables
Expand All @@ -210,16 +286,37 @@ def reset(self) -> None:

class RateLimitMiddleware(BaseHTTPMiddleware):
"""
FastAPI / Starlette middleware enforcing sliding-window rate limiting.
FastAPI / Starlette middleware enforcing rate limiting.
Uses an in-memory sliding-window fast path for safe read-only requests (GET/HEAD/OPTIONS)
and the shared database token-bucket limiter for mutating requests.
Rejects throttled requests with HTTP 429 and standard Retry-After header.
"""
READ_ONLY_METHODS = frozenset({"GET", "HEAD", "OPTIONS"})

def __init__(
self,
app,
rate_limiter: Optional[Union[SlidingWindowRateLimiter, SharedTokenBucketRateLimiter]] = None,
read_rate_limiter: Optional[SlidingWindowRateLimiter] = None,
):
super().__init__(app)
self.rate_limiter = rate_limiter or limiter
if read_rate_limiter is not None:
self.read_rate_limiter = read_rate_limiter
elif isinstance(self.rate_limiter, SlidingWindowRateLimiter):
self.read_rate_limiter = self.rate_limiter
else:
auth_limit, auth_window = self.rate_limiter.limits.get("auth", (10, 60))
general_limit, general_window = self.rate_limiter.limits.get("general", (60, 60))
self.read_rate_limiter = SlidingWindowRateLimiter(
auth_limit=auth_limit,
auth_window=auth_window,
general_limit=general_limit,
general_window=general_window,
max_client_buckets=getattr(self.rate_limiter, "_max_client_buckets", 10_000),
)
if isinstance(self.rate_limiter, SharedTokenBucketRateLimiter):
self.rate_limiter.add_reset_hook(self.read_rate_limiter.reset)
self.exempt_paths = {
"/api/v1/health",
"/docs",
Expand All @@ -236,19 +333,23 @@ async def dispatch(self, request: Request, call_next):
if path in self.exempt_paths:
return await call_next(request)

# Uvicorn rewrites request.client only for peers trusted by FORWARDED_ALLOW_IPS.
# Never use X-Forwarded-For directly because clients can supply it themselves.
client_ip = request.client.host if request.client and request.client.host else "127.0.0.1"
client_ip = extract_client_ip(request)

# Credential checks and durable ingestion writes use the stricter tier.
sensitive_path = path.startswith(("/api/v1/auth", "/api/v1/stories/ingest"))
tier = "auth" if sensitive_path else "general"

allowed, retry_after = await run_in_threadpool(
self.rate_limiter.is_allowed,
client_ip,
tier,
)
is_read_only = request.method.upper() in self.READ_ONLY_METHODS
if is_read_only:
if hasattr(self.rate_limiter, "limits"):
self.read_rate_limiter.limits = dict(self.rate_limiter.limits)
allowed, retry_after = self.read_rate_limiter.is_allowed(client_ip, tier)
else:
allowed, retry_after = await run_in_threadpool(
self.rate_limiter.is_allowed,
client_ip,
tier,
)
if not allowed:
return JSONResponse(
status_code=429,
Expand Down
2 changes: 2 additions & 0 deletions backend/schemas.py
Original file line number Diff line number Diff line change
Expand Up @@ -8,6 +8,7 @@
WriterDTO,
UpdateFeedDTO,
CreateStoryRequest,
UpdateStoryRequest,
ShelfSyncItemDTO,
ShelfSyncPayload,
ShelfSyncResponse,
Expand All @@ -23,6 +24,7 @@
"WriterDTO",
"UpdateFeedDTO",
"CreateStoryRequest",
"UpdateStoryRequest",
"ShelfSyncItemDTO",
"ShelfSyncPayload",
"ShelfSyncResponse",
Expand Down
2 changes: 2 additions & 0 deletions backend/schemas/__init__.py
Original file line number Diff line number Diff line change
Expand Up @@ -5,6 +5,7 @@
WriterDTO,
UpdateFeedDTO,
CreateStoryRequest,
UpdateStoryRequest,
ShelfSyncItemDTO,
ShelfSyncPayload,
ShelfSyncResponse,
Expand All @@ -27,6 +28,7 @@
"WriterDTO",
"UpdateFeedDTO",
"CreateStoryRequest",
"UpdateStoryRequest",
"ShelfSyncItemDTO",
"ShelfSyncPayload",
"ShelfSyncResponse",
Expand Down
Loading
Loading