From 6981119a4d4d0c420574a76edd9608179002a792 Mon Sep 17 00:00:00 2001 From: dmitei Date: Tue, 10 Nov 2026 23:18:00 +0300 Subject: [PATCH 1/3] add login and registration Co-Authored-By: Claude Opus 5.5 --- .env.example | 2 + README.md | 19 ++- .../versions/1395cb8114bd_add_users.py | 38 +++++ backend/app/api/auth.py | 53 +++++++ backend/app/core/config.py | 3 + backend/app/core/security.py | 40 ++++++ backend/app/models/__init__.py | 4 +- backend/app/models/users.py | 12 ++ backend/app/schemas/auth.py | 35 +++++ backend/app/services/auth_service.py | 31 +++++ backend/main.py | 15 +- backend/pytest.ini | 3 + backend/requirements.txt | 4 +- backend/tests/conftest.py | 90 ++++++++++++ backend/tests/test_auth.py | 131 ++++++++++++++++++ frontend/src/App.tsx | 48 +++++-- frontend/src/api.ts | 48 +++++-- frontend/src/index.css | 50 +++++++ frontend/src/pages/Auth.tsx | 97 +++++++++++++ frontend/src/session.ts | 56 ++++++++ 20 files changed, 752 insertions(+), 27 deletions(-) create mode 100644 backend/alembic/versions/1395cb8114bd_add_users.py create mode 100644 backend/app/api/auth.py create mode 100644 backend/app/core/security.py create mode 100644 backend/app/models/users.py create mode 100644 backend/app/schemas/auth.py create mode 100644 backend/app/services/auth_service.py create mode 100644 backend/pytest.ini create mode 100644 backend/tests/conftest.py create mode 100644 backend/tests/test_auth.py create mode 100644 frontend/src/pages/Auth.tsx create mode 100644 frontend/src/session.ts diff --git a/.env.example b/.env.example index b78e297..6dc6983 100644 --- a/.env.example +++ b/.env.example @@ -12,3 +12,5 @@ RUL_CRITICAL=30 RUL_CLIP=125 BOT_TOKEN= CHAT_ID= +JWT_SECRET= +JWT_EXPIRE_MINUTES=1440 diff --git a/README.md b/README.md index de2d9f4..b5b7d24 100644 --- a/README.md +++ b/README.md @@ -116,6 +116,16 @@ api/v1 (эндпоинты, валидация) → services (бизнес-ло Все эндпоинты — с префиксом `/api/v1`. Документация OpenAPI: `/docs`. +### Авторизация + +Все эндпоинты, кроме `/auth/register`, `/auth/login` и `/health`, требуют заголовок `Authorization: Bearer <токен>`, без него отвечают `401`. Токен — JWT, его выдают регистрация и вход; живёт `JWT_EXPIRE_MINUTES` минут (по умолчанию сутки). Подписывается ключом `JWT_SECRET` из `.env`: сгенерировать — `python -c "import secrets; print(secrets.token_urlsafe(32))"`. Если ключ не задан, backend создаёт временный, и после его перезапуска войти придётся заново. Пароли хранятся только как bcrypt-хэш. + +| Метод | Эндпоинт | Описание | Ожидаемый latency | +| ----- | ---------------- | ------------------------------------------------------------- | ----------------- | +| POST | `/auth/register` | Регистрация по email и паролю (от 8 символов), сразу выдаёт токен; `409`, если email занят | < 500 мс | +| POST | `/auth/login` | Вход: токен; `401` при неверном email или пароле | < 500 мс | +| GET | `/auth/me` | Текущий пользователь | < 100 мс | + ### Оборудование | Метод | Эндпоинт | Описание | Ожидаемый latency | @@ -225,9 +235,16 @@ erDiagram varchar severity "info warning critical" text message } + + users { + int id PK + text email "уникальный, в нижнем регистре" + text password_hash "bcrypt" + timestamp created_at + } ``` -Ограничения и индексы: `UNIQUE (dataset, unit_number)` в `equipment`; `UNIQUE (equipment_id, cycle)` в `sensor_readings`, `physics_predictions`, `ml_predictions`; индекс `alerts (equipment_id, triggered_at DESC)`. Показания хранятся широкой таблицей: набор из 14 датчиков фиксирован, так запросы истории не требуют `PIVOT`. Для других наборов (FD002–FD004) добавляются колонки миграцией; полный список датчиков и признак `is_used` лежат в `sensor_catalog`. +Ограничения и индексы: `UNIQUE (dataset, unit_number)` в `equipment`; `UNIQUE (equipment_id, cycle)` в `sensor_readings`, `physics_predictions`, `ml_predictions`; индекс `alerts (equipment_id, triggered_at DESC)`; `UNIQUE (email)` в `users`. Показания хранятся широкой таблицей: набор из 14 датчиков фиксирован, так запросы истории не требуют `PIVOT`. Для других наборов (FD002–FD004) добавляются колонки миграцией; полный список датчиков и признак `is_used` лежат в `sensor_catalog`. При записи (40 записей/сек) все вставки идут в разные таблицы от фоновых процессов. 40 INSERT/сек — незначительная нагрузка для PostgreSQL. При чтении (~10-20 RPS) PostgreSQL будет находить строки за O(log n). Проблем не возникнет. diff --git a/backend/alembic/versions/1395cb8114bd_add_users.py b/backend/alembic/versions/1395cb8114bd_add_users.py new file mode 100644 index 0000000..ba08f3c --- /dev/null +++ b/backend/alembic/versions/1395cb8114bd_add_users.py @@ -0,0 +1,38 @@ +"""add users + +Revision ID: 1395cb8114bd +Revises: e74d5734bc65 +Create Date: 2026-11-10 23:10:55.971571 + +""" +from collections.abc import Sequence + +import sqlalchemy as sa +from alembic import op + +# revision identifiers, used by Alembic. +revision: str = '1395cb8114bd' +down_revision: str | Sequence[str] | None = 'e74d5734bc65' +branch_labels: str | Sequence[str] | None = None +depends_on: str | Sequence[str] | None = None + + +def upgrade() -> None: + """Upgrade schema.""" + # ### commands auto generated by Alembic - please adjust! ### + op.create_table('users', + sa.Column('id', sa.Integer(), nullable=False), + sa.Column('email', sa.Text(), nullable=False), + sa.Column('password_hash', sa.Text(), nullable=False), + sa.Column('created_at', sa.DateTime(), server_default=sa.text('now()'), nullable=False), + sa.PrimaryKeyConstraint('id'), + sa.UniqueConstraint('email') + ) + # ### end Alembic commands ### + + +def downgrade() -> None: + """Downgrade schema.""" + # ### commands auto generated by Alembic - please adjust! ### + op.drop_table('users') + # ### end Alembic commands ### diff --git a/backend/app/api/auth.py b/backend/app/api/auth.py new file mode 100644 index 0000000..f1b411c --- /dev/null +++ b/backend/app/api/auth.py @@ -0,0 +1,53 @@ +from typing import Annotated + +from fastapi import APIRouter, Depends, HTTPException, status +from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer + +from app.core.db import DB +from app.core.security import create_token, user_id_from_token +from app.schemas.auth import AuthOut, LoginIn, RegisterIn, UserOut +from app.services import auth_service + +router = APIRouter(prefix="/auth", tags=["Авторизация"]) + +bearer = HTTPBearer(auto_error=False, description="Токен из /auth/login или /auth/register") + +UNAUTHORIZED = {401: {"description": "Нет токена, токен неверен или просрочен"}} + + +def _unauthorized(detail: str) -> HTTPException: + return HTTPException(status.HTTP_401_UNAUTHORIZED, detail, headers={"WWW-Authenticate": "Bearer"}) + + +def get_current_user(db: DB, credentials: Annotated[HTTPAuthorizationCredentials | None, Depends(bearer)]) -> dict: + user_id = user_id_from_token(credentials.credentials) if credentials else None + user = auth_service.get_user(db, user_id) if user_id is not None else None + if user is None: + raise _unauthorized("Требуется вход в систему") + return user + + +def _session(user: dict) -> dict: + return {"access_token": create_token(user["id"]), "token_type": "bearer", "user": user} + + +@router.post("/register", response_model=AuthOut, status_code=status.HTTP_201_CREATED, + responses={409: {"description": "Email уже зарегистрирован"}}, summary="Регистрация") +def register(body: RegisterIn, db: DB): + user = auth_service.create_user(db, body.email, body.password) + if user is None: + raise HTTPException(status.HTTP_409_CONFLICT, "Пользователь с таким email уже зарегистрирован") + return _session(user) + + +@router.post("/login", response_model=AuthOut, responses=UNAUTHORIZED, summary="Вход по email и паролю") +def login(body: LoginIn, db: DB): + user = auth_service.authenticate(db, body.email, body.password) + if user is None: + raise _unauthorized("Неверный email или пароль") + return _session(user) + + +@router.get("/me", response_model=UserOut, responses=UNAUTHORIZED, summary="Текущий пользователь") +def me(user: Annotated[dict, Depends(get_current_user)]): + return user diff --git a/backend/app/core/config.py b/backend/app/core/config.py index 2c4cbd0..739b497 100644 --- a/backend/app/core/config.py +++ b/backend/app/core/config.py @@ -9,3 +9,6 @@ RUL_WARNING = int(os.getenv("RUL_WARNING")) RUL_CRITICAL = int(os.getenv("RUL_CRITICAL")) RUL_CLIP = int(os.getenv("RUL_CLIP")) + +JWT_SECRET = os.getenv("JWT_SECRET", "") +JWT_EXPIRE_MINUTES = int(os.getenv("JWT_EXPIRE_MINUTES", "1440")) diff --git a/backend/app/core/security.py b/backend/app/core/security.py new file mode 100644 index 0000000..eef5e28 --- /dev/null +++ b/backend/app/core/security.py @@ -0,0 +1,40 @@ +import logging +import secrets +from datetime import UTC, datetime, timedelta + +import bcrypt +import jwt + +from app.core.config import JWT_EXPIRE_MINUTES, JWT_SECRET + +logger = logging.getLogger("security") + +ALGORITHM = "HS256" + +if JWT_SECRET: + _secret = JWT_SECRET +else: + _secret = secrets.token_urlsafe(32) + logger.warning("JWT_SECRET не задан: сгенерирован временный ключ, после перезапуска backend войти придётся заново") + + +def hash_password(password: str) -> str: + return bcrypt.hashpw(password.encode(), bcrypt.gensalt()).decode() + + +def verify_password(password: str, password_hash: str) -> bool: + return bcrypt.checkpw(password.encode(), password_hash.encode()) + + +def create_token(user_id: int) -> str: + expires = datetime.now(UTC) + timedelta(minutes=JWT_EXPIRE_MINUTES) + return jwt.encode({"sub": str(user_id), "exp": expires}, _secret, algorithm=ALGORITHM) + + +def user_id_from_token(token: str) -> int | None: + """id пользователя из токена; None, если токен неверен или просрочен.""" + try: + payload = jwt.decode(token, _secret, algorithms=[ALGORITHM], options={"require": ["exp", "sub"]}) + return int(payload["sub"]) + except (jwt.InvalidTokenError, ValueError): + return None diff --git a/backend/app/models/__init__.py b/backend/app/models/__init__.py index 9041430..f153bad 100644 --- a/backend/app/models/__init__.py +++ b/backend/app/models/__init__.py @@ -4,6 +4,7 @@ from .physics_predictions import PhysicsPrediction from .sensor_catalog import SensorCatalog from .sensor_readings import SensorReading +from .users import User __all__ = [ "Alert", @@ -12,4 +13,5 @@ "PhysicsPrediction", "SensorCatalog", "SensorReading", -] \ No newline at end of file + "User", +] diff --git a/backend/app/models/users.py b/backend/app/models/users.py new file mode 100644 index 0000000..dd90531 --- /dev/null +++ b/backend/app/models/users.py @@ -0,0 +1,12 @@ +from sqlalchemy import Column, DateTime, Integer, Text, func + +from app.core.db import Base + + +class User(Base): + __tablename__ = "users" + + id = Column(Integer, primary_key=True) + email = Column(Text, nullable=False, unique=True) + password_hash = Column(Text, nullable=False) + created_at = Column(DateTime, nullable=False, server_default=func.now()) diff --git a/backend/app/schemas/auth.py b/backend/app/schemas/auth.py new file mode 100644 index 0000000..8506d6d --- /dev/null +++ b/backend/app/schemas/auth.py @@ -0,0 +1,35 @@ +from pydantic import BaseModel, Field, field_validator + +PASSWORD_MAX_BYTES = 72 # bcrypt не принимает пароли длиннее + + +class LoginIn(BaseModel): + email: str = Field(max_length=254, pattern=r"^[^@\s]+@[^@\s]+\.[^@\s]+$", examples=["operator@example.com"]) + password: str = Field(min_length=1) + + @field_validator("email", mode="before") + @classmethod + def normalize_email(cls, value): + return value.strip().lower() if isinstance(value, str) else value + + @field_validator("password") + @classmethod + def fits_bcrypt(cls, value: str) -> str: + if len(value.encode()) > PASSWORD_MAX_BYTES: + raise ValueError(f"пароль длиннее {PASSWORD_MAX_BYTES} байт") + return value + + +class RegisterIn(LoginIn): + password: str = Field(min_length=8, description="От 8 символов, не длиннее 72 байт в UTF-8") + + +class UserOut(BaseModel): + id: int + email: str + + +class AuthOut(BaseModel): + access_token: str = Field(description="JWT для заголовка Authorization: Bearer") + token_type: str = "bearer" + user: UserOut diff --git a/backend/app/services/auth_service.py b/backend/app/services/auth_service.py new file mode 100644 index 0000000..b826dbf --- /dev/null +++ b/backend/app/services/auth_service.py @@ -0,0 +1,31 @@ +from sqlalchemy import Connection, select +from sqlalchemy.dialects.postgresql import insert + +from app.core.security import hash_password, verify_password +from app.models.users import User + + +def create_user(db: Connection, email: str, password: str) -> dict | None: + """Новый пользователь; None, если email уже занят.""" + query = ( + insert(User) + .values(email=email, password_hash=hash_password(password)) + .on_conflict_do_nothing(index_elements=[User.email]) + .returning(User.id, User.email) + ) + row = db.execute(query).mappings().first() + db.commit() + return dict(row) if row else None + + +def authenticate(db: Connection, email: str, password: str) -> dict | None: + query = select(User.id, User.email, User.password_hash).where(User.email == email) + row = db.execute(query).mappings().first() + if row is None or not verify_password(password, row["password_hash"]): + return None + return {"id": row["id"], "email": row["email"]} + + +def get_user(db: Connection, user_id: int) -> dict | None: + row = db.execute(select(User.id, User.email).where(User.id == user_id)).mappings().first() + return dict(row) if row else None diff --git a/backend/main.py b/backend/main.py index b3376de..b687a2a 100644 --- a/backend/main.py +++ b/backend/main.py @@ -1,6 +1,7 @@ -from app.api import alerts, equipment, predict +from app.api import alerts, auth, equipment, predict +from app.api.auth import UNAUTHORIZED, get_current_user from app.core.config import CORS_ORIGINS -from fastapi import FastAPI +from fastapi import Depends, FastAPI from fastapi.middleware.cors import CORSMiddleware app = FastAPI(title="OFF-Tech: оценка состояния оборудования", version="0.1.0") @@ -8,6 +9,10 @@ app.add_middleware(CORSMiddleware, allow_origins=CORS_ORIGINS, allow_methods=["*"], allow_headers=["*"]) -app.include_router(equipment.router) -app.include_router(alerts.router) -app.include_router(predict.router) +# Данные — только с токеном; /auth/register и /auth/login открыты. +PROTECTED = [Depends(get_current_user)] + +app.include_router(auth.router) +app.include_router(equipment.router, dependencies=PROTECTED, responses=UNAUTHORIZED) +app.include_router(alerts.router, dependencies=PROTECTED, responses=UNAUTHORIZED) +app.include_router(predict.router, dependencies=PROTECTED, responses=UNAUTHORIZED) diff --git a/backend/pytest.ini b/backend/pytest.ini new file mode 100644 index 0000000..c7b23ec --- /dev/null +++ b/backend/pytest.ini @@ -0,0 +1,3 @@ +[pytest] +pythonpath = . +testpaths = tests diff --git a/backend/requirements.txt b/backend/requirements.txt index 8b88dc1..4388894 100644 --- a/backend/requirements.txt +++ b/backend/requirements.txt @@ -8,4 +8,6 @@ httpx==0.27.2 alembic==1.20.0 psycopg[binary]==3.3.6 alembic==1.20.0 -python-dotenv==1.0.1 \ No newline at end of file +python-dotenv==1.0.1 +PyJWT==2.15.1 +bcrypt==5.0.0 diff --git a/backend/tests/conftest.py b/backend/tests/conftest.py new file mode 100644 index 0000000..5410b7c --- /dev/null +++ b/backend/tests/conftest.py @@ -0,0 +1,90 @@ +import os +from datetime import date + +import pytest +from fastapi.testclient import TestClient +from sqlalchemy import insert, text + +# Тесты очищают таблицы, поэтому БД для них задаётся отдельной переменной: +# рабочий DATABASE_URL здесь намеренно не используется. +os.environ["DATABASE_URL"] = os.environ["TEST_DATABASE_URL"] +os.environ["RUL_WARNING"] = "75" +os.environ["RUL_CRITICAL"] = "30" +os.environ["RUL_CLIP"] = "125" +os.environ["JWT_SECRET"] = "test-secret-for-pytest-only-0123456789" + +TABLES = "alerts, ml_predictions, physics_predictions, sensor_readings, equipment, users" + + +@pytest.fixture +def db(): + from app.core.db import engine + + with engine.begin() as connection: + connection.execute(text(f"TRUNCATE {TABLES} RESTART IDENTITY CASCADE")) + with engine.connect() as connection: + yield connection + + +@pytest.fixture +def anon_client(db): + from main import app + + return TestClient(app) + + +@pytest.fixture +def client(db): + """Клиент вошедшего пользователя: все эндпоинты, кроме /auth, требуют токен.""" + from app.core.security import create_token + from app.models import User + from main import app + + statement = insert(User).values(email="operator@example.com", password_hash="-").returning(User.id) + user_id = db.execute(statement).scalar_one() + db.commit() + return TestClient(app, headers={"Authorization": f"Bearer {create_token(user_id)}"}) + + +@pytest.fixture +def add_equipment(db): + from app.models import Equipment + + def add(unit_number: int = 81) -> int: + statement = insert(Equipment).values( + name=f"Turbofan №{unit_number}", type="turbofan", dataset="FD001", + unit_number=unit_number, install_date=date(2024, 1, 1), + ) + equipment_id = db.execute(statement.returning(Equipment.id)).scalar_one() + db.commit() + return equipment_id + + return add + + +@pytest.fixture +def add_prediction(db): + from app.models import MlPrediction + + def add(equipment_id: int, cycle: int, rul: float) -> None: + db.execute(insert(MlPrediction).values( + equipment_id=equipment_id, cycle=cycle, predicted_rul=rul, + defect_probability=0, residual=0, model_version="test", + )) + db.commit() + + return add + + +@pytest.fixture +def add_reading(db): + from app.models import SensorReading + from app.services.equipment_service import SENSOR_CODES + + def add(equipment_id: int, cycle: int) -> dict[str, float]: + sensors = {code: float(i + cycle) for i, code in enumerate(SENSOR_CODES)} + db.execute(insert(SensorReading).values(equipment_id=equipment_id, cycle=cycle, **sensors)) + db.commit() + return sensors + + return add diff --git a/backend/tests/test_auth.py b/backend/tests/test_auth.py new file mode 100644 index 0000000..d81b24b --- /dev/null +++ b/backend/tests/test_auth.py @@ -0,0 +1,131 @@ +import re +from datetime import UTC, datetime, timedelta + +import bcrypt +import jwt +import pytest +from fastapi.routing import APIRoute +from sqlalchemy import text + +OPEN_PATHS = {"/auth/register", "/auth/login", "/health"} +CREDENTIALS = {"email": "operator@example.com", "password": "correct-horse"} + + +def protected_routes() -> list[tuple[str, str]]: + from main import app + + return sorted( + (method, re.sub(r"\{[^}]+\}", "1", route.path)) + for route in app.routes + if isinstance(route, APIRoute) and route.path not in OPEN_PATHS + for method in route.methods + ) + + +def bearer(token: str) -> dict[str, str]: + return {"Authorization": f"Bearer {token}"} + + +def test_register_returns_working_token(anon_client): + response = anon_client.post("/auth/register", json={**CREDENTIALS, "email": " Operator@Example.COM "}) + + assert response.status_code == 201 + body = response.json() + assert body["token_type"] == "bearer" + assert body["user"]["email"] == "operator@example.com" + + me = anon_client.get("/auth/me", headers=bearer(body["access_token"])) + assert me.status_code == 200 + assert me.json() == body["user"] + + +def test_password_is_stored_as_bcrypt_hash(anon_client, db): + anon_client.post("/auth/register", json=CREDENTIALS) + + stored = db.execute(text("SELECT password_hash FROM users")).scalar_one() + + assert CREDENTIALS["password"] not in stored + assert bcrypt.checkpw(CREDENTIALS["password"].encode(), stored.encode()) + + +def test_register_same_email_conflicts(anon_client): + assert anon_client.post("/auth/register", json=CREDENTIALS).status_code == 201 + + response = anon_client.post("/auth/register", json={**CREDENTIALS, "email": "OPERATOR@example.com"}) + + assert response.status_code == 409 + + +@pytest.mark.parametrize("payload", [ + {"email": "not-an-email", "password": "correct-horse"}, + {"email": "operator@example.com", "password": "short"}, + {"email": "operator@example.com", "password": "я" * 37}, # 74 байта — больше лимита bcrypt + {"email": "operator@example.com"}, +]) +def test_register_validates_input(anon_client, payload): + assert anon_client.post("/auth/register", json=payload).status_code == 422 + + +def test_login_returns_working_token(anon_client): + anon_client.post("/auth/register", json=CREDENTIALS) + + response = anon_client.post("/auth/login", json={**CREDENTIALS, "email": "Operator@example.com"}) + + assert response.status_code == 200 + assert anon_client.get("/equipment", headers=bearer(response.json()["access_token"])).status_code == 200 + + +@pytest.mark.parametrize("credentials", [ + {**CREDENTIALS, "password": "wrong-password"}, + {**CREDENTIALS, "email": "nobody@example.com"}, +]) +def test_login_rejects_wrong_credentials(anon_client, credentials): + anon_client.post("/auth/register", json=CREDENTIALS) + + response = anon_client.post("/auth/login", json=credentials) + + assert response.status_code == 401 + assert response.json()["detail"] == "Неверный email или пароль" + + +@pytest.mark.parametrize(("method", "path"), protected_routes()) +def test_api_requires_token(anon_client, method, path): + response = anon_client.request(method, path) + + assert response.status_code == 401 + assert response.headers["WWW-Authenticate"] == "Bearer" + + +def test_protected_routes_cover_api(): + routes = protected_routes() + + assert ("GET", "/equipment") in routes + assert ("GET", "/auth/me") in routes + + +def test_signed_in_client_reaches_api(client): + assert client.get("/equipment").status_code == 200 + assert client.get("/auth/me").json()["email"] == "operator@example.com" + + +def _token(secret: str, sub: str = "1", minutes: int = 5) -> str: + expires = datetime.now(UTC) + timedelta(minutes=minutes) + return jwt.encode({"sub": sub, "exp": expires}, secret, algorithm="HS256") + + +def test_rejects_bad_tokens(client): + from app.core.config import JWT_SECRET + + user_token = client.headers["Authorization"].removeprefix("Bearer ") + user_id = jwt.decode(user_token, JWT_SECRET, algorithms=["HS256"])["sub"] + bad = { + "garbage": bearer("garbage"), + "foreign secret": bearer(_token("another-secret-another-secret-0123", user_id)), + "expired": bearer(_token(JWT_SECRET, user_id, minutes=-1)), + "unknown user": bearer(_token(JWT_SECRET, "999")), + "basic scheme": {"Authorization": f"Basic {user_token}"}, + } + + for name, headers in bad.items(): + response = client.get("/equipment", headers=headers) + assert response.status_code == 401, name diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx index cb460a0..564e879 100644 --- a/frontend/src/App.tsx +++ b/frontend/src/App.tsx @@ -1,30 +1,56 @@ -import { NavLink, Route, Routes } from "react-router-dom"; +import { Navigate, NavLink, Outlet, Route, Routes, useLocation } from "react-router-dom"; import { Alerts } from "./pages/Alerts"; +import { AuthPage } from "./pages/Auth"; import { EquipmentCard } from "./pages/EquipmentCard"; import { EquipmentList } from "./pages/EquipmentList"; +import { setSession, useSession } from "./session"; export function App() { + const session = useSession(); + return ( <>
OFF-Tech - + {session && ( + <> + +
+ {session.email} + +
+ + )}
- } /> - } /> - } /> - Страница не найдена

} /> + } /> + } /> + }> + } /> + } /> + } /> + Страница не найдена

} /> +
); } + +function RequireAuth() { + const session = useSession(); + const location = useLocation(); + + if (!session) return ; + return ; +} diff --git a/frontend/src/api.ts b/frontend/src/api.ts index 5819da1..6572e7a 100644 --- a/frontend/src/api.ts +++ b/frontend/src/api.ts @@ -1,3 +1,5 @@ +import { getToken, setSession } from "./session"; + export type Status = "normal" | "warning" | "critical"; export interface Equipment { @@ -49,21 +51,53 @@ export interface Alert { message: string; } +export interface User { + id: number; + email: string; +} + +export interface AuthResponse { + access_token: string; + token_type: string; + user: User; +} + +export class ApiError extends Error { + status: number; + detail: string; + + constructor(status: number, detail: string) { + super(`${status}: ${detail}`); + this.status = status; + this.detail = detail; + } +} + const BASE = "/api"; async function request(path: string, init?: RequestInit): Promise { - const res = await fetch(BASE + path, init); + const token = getToken(); + const headers = new Headers(init?.headers); + if (token) headers.set("Authorization", `Bearer ${token}`); + const res = await fetch(BASE + path, { ...init, headers }); if (!res.ok) { + // Токен просрочен или пользователь удалён: выходим, RequireAuth откроет страницу входа. + if (res.status === 401 && token && token === getToken()) setSession(null); let detail = res.statusText; try { const body = await res.json(); if (typeof body.detail === "string") detail = body.detail; + else if (Array.isArray(body.detail)) detail = body.detail.map((d: { msg: string }) => d.msg).join("; "); } catch {} - throw new Error(`${res.status}: ${detail}`); + throw new ApiError(res.status, detail); } return res.json() as Promise; } +function postJson(body: unknown): RequestInit { + return { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) }; +} + export const api = { listEquipment: () => request("/equipment"), getEquipment: (id: number) => request(`/equipment/${id}`), @@ -71,10 +105,8 @@ export const api = { getForecast: (id: number) => request(`/equipment/${id}/forecast`), listAlerts: (limit = 100) => request(`/alerts?limit=${limit}`), alertsByEquipment: (id: number, limit = 50) => request(`/alerts/${id}?limit=${limit}`), - predict: (id: number) => - request("/predict", { - method: "POST", - headers: { "Content-Type": "application/json" }, - body: JSON.stringify({ equipment_id: id }), - }), + predict: (id: number) => request("/predict", postJson({ equipment_id: id })), + login: (email: string, password: string) => request("/auth/login", postJson({ email, password })), + register: (email: string, password: string) => + request("/auth/register", postJson({ email, password })), }; diff --git a/frontend/src/index.css b/frontend/src/index.css index 9cca51c..fd4a7fa 100644 --- a/frontend/src/index.css +++ b/frontend/src/index.css @@ -248,3 +248,53 @@ h2 { color: #2563eb; font-weight: 500; } + +.user { + margin-left: auto; + display: flex; + align-items: center; + gap: 12px; + min-width: 0; + color: #d1d5db; + font-size: 14px; +} +.user-email { + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +.auth { + max-width: 380px; + margin: 48px auto; + padding: 24px; +} +.auth form { + display: flex; + flex-direction: column; + gap: 14px; + margin: 20px 0 16px; +} +.auth label { + display: flex; + flex-direction: column; + gap: 6px; + font-size: 14px; + font-weight: 500; +} +.auth input { + padding: 8px 10px; + border: 1px solid #d1d5db; + border-radius: 6px; + font: inherit; +} +.auth input:focus { + outline: 2px solid #93c5fd; + border-color: #2563eb; +} +.auth .error { + margin: 0; +} +.auth .muted { + text-align: center; +} diff --git a/frontend/src/pages/Auth.tsx b/frontend/src/pages/Auth.tsx new file mode 100644 index 0000000..fc51e61 --- /dev/null +++ b/frontend/src/pages/Auth.tsx @@ -0,0 +1,97 @@ +import { type FormEvent, useState } from "react"; +import { Link, Navigate, useLocation } from "react-router-dom"; + +import { ApiError, api } from "../api"; +import { setSession, useSession } from "../session"; + +const PASSWORD_MIN = 8; +const PASSWORD_MAX_BYTES = 72; + +const MODES = { + login: { + title: "Вход", + submit: "Войти", + send: api.login, + other: { question: "Нет аккаунта?", link: "Зарегистрироваться", to: "/register" }, + }, + register: { + title: "Регистрация", + submit: "Зарегистрироваться", + send: api.register, + other: { question: "Уже есть аккаунт?", link: "Войти", to: "/login" }, + }, +}; + +export function AuthPage({ mode }: { mode: keyof typeof MODES }) { + const session = useSession(); + const location = useLocation(); + const [error, setError] = useState(null); + const [busy, setBusy] = useState(false); + const page = MODES[mode]; + const register = mode === "register"; + + if (session) { + const from = (location.state as { from?: string } | null)?.from ?? "/"; + return ; + } + + async function onSubmit(e: FormEvent) { + e.preventDefault(); + const form = new FormData(e.currentTarget); + const email = String(form.get("email")); + const password = String(form.get("password")); + if (register && password !== form.get("confirm")) return setError("Пароли не совпадают"); + if (register && new TextEncoder().encode(password).length > PASSWORD_MAX_BYTES) { + return setError(`Пароль слишком длинный: не больше ${PASSWORD_MAX_BYTES} байт`); + } + + setBusy(true); + setError(null); + try { + const res = await page.send(email, password); + setSession({ token: res.access_token, email: res.user.email }); + } catch (err) { + setError(err instanceof ApiError ? err.detail : "Нет связи с сервером"); + setBusy(false); + } + } + + return ( +
+

{page.title}

+
+ + + {register && ( + + )} + {error &&

{error}

} + +
+

+ {page.other.question}{" "} + + {page.other.link} + +

+
+ ); +} diff --git a/frontend/src/session.ts b/frontend/src/session.ts new file mode 100644 index 0000000..bd7fa76 --- /dev/null +++ b/frontend/src/session.ts @@ -0,0 +1,56 @@ +import { useSyncExternalStore } from "react"; + +export interface Session { + token: string; + email: string; +} + +const KEY = "offtech.session"; +const listeners = new Set<() => void>(); + +function read(): Session | null { + try { + const value = JSON.parse(localStorage.getItem(KEY) ?? "null"); + return typeof value?.token === "string" && typeof value?.email === "string" ? value : null; + } catch { + return null; + } +} + +let session = read(); + +function notify(): void { + listeners.forEach((l) => l()); +} + +export function getToken(): string | null { + return session?.token ?? null; +} + +export function setSession(next: Session | null): void { + session = next; + try { + if (next) localStorage.setItem(KEY, JSON.stringify(next)); + else localStorage.removeItem(KEY); + } catch { + } + notify(); +} + +// Вход и выход в соседней вкладке. +window.addEventListener("storage", (e) => { + if (e.key !== KEY && e.key !== null) return; + session = read(); + notify(); +}); + +export function useSession(): Session | null { + return useSyncExternalStore( + (cb) => { + listeners.add(cb); + return () => listeners.delete(cb); + }, + () => session, + () => null, + ); +} From 6bebd45beb8002dbea543cda43abe6da6c812656 Mon Sep 17 00:00:00 2001 From: mqudiee Date: Wed, 11 Nov 2026 02:52:59 +0300 Subject: [PATCH 2/3] feat: add admin-managed user accounts --- .env.example | 3 + .github/workflows/ci.yml | 21 ++ README.md | 56 +++- .../versions/b48a001_managed_accounts.py | 44 +++ backend/app/api/auth.py | 49 ++- backend/app/api/users.py | 56 ++++ backend/app/core/login_throttle.py | 45 +++ backend/app/core/security.py | 43 +-- backend/app/create_admin.py | 33 ++ backend/app/models/__init__.py | 3 +- backend/app/models/users.py | 29 +- backend/app/schemas/auth.py | 69 +++- backend/app/services/auth_service.py | 31 +- backend/main.py | 15 +- backend/tests/conftest.py | 30 +- backend/tests/test_auth.py | 297 ++++++++++++------ docker-compose.yml | 4 +- frontend/src/App.tsx | 99 +++--- frontend/src/api.ts | 23 +- frontend/src/components/PasswordField.tsx | 22 ++ frontend/src/index.css | 36 ++- frontend/src/pages/Auth.tsx | 97 ++---- frontend/src/pages/Users.tsx | 131 ++++++++ frontend/src/session.ts | 5 +- 24 files changed, 923 insertions(+), 318 deletions(-) create mode 100644 backend/alembic/versions/b48a001_managed_accounts.py create mode 100644 backend/app/api/users.py create mode 100644 backend/app/core/login_throttle.py create mode 100644 backend/app/create_admin.py create mode 100644 frontend/src/components/PasswordField.tsx create mode 100644 frontend/src/pages/Users.tsx diff --git a/.env.example b/.env.example index 6dc6983..8a3dd53 100644 --- a/.env.example +++ b/.env.example @@ -2,6 +2,8 @@ POSTGRES_USER=pdm POSTGRES_PASSWORD=pdm POSTGRES_DB=pdm POSTGRES_PORT=5432 +BACKEND_PORT=8000 +FRONTEND_PORT=5173 DATABASE_URL=postgresql+psycopg://pdm:pdm@localhost:5432/pdm SIMULATOR_WAIT_TIME=30 WORKER_POLL_INTERVAL=30 @@ -12,5 +14,6 @@ RUL_CRITICAL=30 RUL_CLIP=125 BOT_TOKEN= CHAT_ID= +# Required: persistent random signing secret, at least 32 bytes (not a user password). JWT_SECRET= JWT_EXPIRE_MINUTES=1440 diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 066a9bf..4b37909 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -64,6 +64,12 @@ jobs: working-directory: backend run: alembic check + - name: Test authentication and authorization + working-directory: backend + env: + TEST_DATABASE_URL: postgresql+psycopg://pdm:pdm@localhost:5432/pdm + run: pytest -q + model: runs-on: ubuntu-latest @@ -156,3 +162,18 @@ jobs: ML=$(psql "$PSQL_URL" -tAc "SELECT count(*) FROM ml_predictions") echo "equipment=$EQ sensor_readings=$SR ml_predictions=$ML" [ "$EQ" -eq 20 ] && [ "$SR" -gt 0 ] && [ "$ML" -eq "$SR" ] + + frontend: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-node@v4 + with: + node-version: "22" + cache: npm + cache-dependency-path: frontend/package-lock.json + - name: Install and build frontend + working-directory: frontend + run: | + npm ci + npm run build diff --git a/README.md b/README.md index b5b7d24..ddace6e 100644 --- a/README.md +++ b/README.md @@ -114,17 +114,57 @@ api/v1 (эндпоинты, валидация) → services (бизнес-ло ## Контракты API -Все эндпоинты — с префиксом `/api/v1`. Документация OpenAPI: `/docs`. +Ниже указаны пути backend. Frontend обращается к ним через прокси `/api` (например, `/api/auth/login`). Документация OpenAPI backend: `/docs`. -### Авторизация +### Авторизация и управление аккаунтами -Все эндпоинты, кроме `/auth/register`, `/auth/login` и `/health`, требуют заголовок `Authorization: Bearer <токен>`, без него отвечают `401`. Токен — JWT, его выдают регистрация и вход; живёт `JWT_EXPIRE_MINUTES` минут (по умолчанию сутки). Подписывается ключом `JWT_SECRET` из `.env`: сгенерировать — `python -c "import secrets; print(secrets.token_urlsafe(32))"`. Если ключ не задан, backend создаёт временный, и после его перезапуска войти придётся заново. Пароли хранятся только как bcrypt-хэш. +Публичной регистрации нет. Аккаунты выдаёт администратор; он вручную задаёт логин и постоянный пароль. Почтовая отправка не используется. -| Метод | Эндпоинт | Описание | Ожидаемый latency | -| ----- | ---------------- | ------------------------------------------------------------- | ----------------- | -| POST | `/auth/register` | Регистрация по email и паролю (от 8 символов), сразу выдаёт токен; `409`, если email занят | < 500 мс | -| POST | `/auth/login` | Вход: токен; `401` при неверном email или пароле | < 500 мс | -| GET | `/auth/me` | Текущий пользователь | < 100 мс | +- `employee`: оборудование, история, графики, алерты и прогнозирование. +- `admin`: все возможности сотрудника, плюс список аккаунтов, создание сотрудников, сброс их паролей и блокировка/разблокировка. +- Логин: 3–64 символа, латинские буквы, цифры, `.`, `_`, `-`. Пробелы по краям убираются, регистр приводится к нижнему. Уникальность обеспечивает PostgreSQL. +- Новый пароль: от 12 символов, не более 72 байт UTF-8 (лимит bcrypt). Пробелы, регистр и спецсимволы сохраняются. В базе хранится только bcrypt-хеш с индивидуальной солью. +- JWT выдаётся только при входе и действует `JWT_EXPIRE_MINUTES` минут (по умолчанию 1440). Для запуска обязателен постоянный `JWT_SECRET` длиной минимум 32 байта. Он не является паролем пользователя. +- На каждом защищённом запросе backend сверяет пользователя, его состояние и версию токена с базой; административные операции дополнительно проверяют роль. Данные роли из браузера не принимаются. +- Сброс пароля и изменение блокировки увеличивают `token_version`. Старые токены больше не работают, в том числе после разблокировки. Сброс пароля не разблокирует аккаунт. +- Через панель можно изменять только сотрудников. Администратора нельзя заблокировать или изменить его пароль через эти endpoints. +- Лимит входа: 10 попыток на логин и 60 на адрес за 15 минут, включая успешные попытки. Счётчики атомарные, общие для процессов backend в PostgreSQL. Ответ `429` содержит `Retry-After`. Учитывается адрес подключения, не пользовательский `X-Forwarded-For`; за обратным прокси лимит адреса может быть общим для клиентов этого прокси. + +| Метод | Путь | Доступ и действие | +| --- | --- | --- | +| POST | `/auth/login` | Публичный вход: `{ "login": "ivan.petrov", "password": "…" }` | +| GET | `/auth/me` | Текущий активный пользователь | +| GET | `/admin/users?limit=50&offset=0` | Администратор: список аккаунтов без паролей и хешей | +| POST | `/admin/users` | Администратор: `{ "login": "ivan.petrov", "password": "…" }`, создаёт только `employee` | +| PUT | `/admin/users/{id}/password` | Администратор: `{ "password": "…" }`, сброс пароля сотрудника и отзыв токенов | +| PUT | `/admin/users/{id}/status` | Администратор: `{ "is_active": false }` для блокировки, `true` для разблокировки | + +Остальные рабочие endpoints тоже требуют `Authorization: Bearer <токен>`. Без действующего токена — `401`; сотруднику на административном endpoint — `403`; занятый логин — `409`. `/auth/register` удалён, отвечает `404`. + +#### Запуск и первый администратор + +1. Скопировать `.env.example` в `.env` и заполнить настройки. Секрет подписи сгенерировать командой `python3 -c "import secrets; print(secrets.token_urlsafe(32))"` и записать в `JWT_SECRET`. Файл `.env` не коммитить. +2. Запустить `docker compose up -d --build db backend frontend`. Backend применит миграции автоматически. Для данных симулятора и расчётов отдельно запустить нужные сервисы проекта. +3. Выполнить `docker compose exec backend python -m app.create_admin`. Вручную ввести логин и дважды пароль (ввод пароля скрыт). Повторение занятого логина не изменяет существующий аккаунт. Команда доступна только имеющему доступ к серверу; не принимает пароль аргументом командной строки. +4. Открыть `http://localhost:5173` (либо порт `FRONTEND_PORT`), войти администратором. В разделе «Пользователи» создать сотрудника и лично передать ему введённые данные. + +При локальном запуске без Docker сначала выполнить `alembic upgrade head` из `backend`, затем `python -m app.create_admin` в том же окружении с настроенным `DATABASE_URL` и `JWT_SECRET`. + +Миграция `b48a001` следует за миграцией PR #48 `1395cb8114bd`. Она рассчитана на согласованное отсутствие существующих аккаунтов: если `users` не пуста, миграция остановится без удаления данных. Не применять её к базе прежней локальной реализации с другой веткой миграций. Для параллельной проверки использовать отдельную базу/Compose-проект. Порты задаются `POSTGRES_PORT`, `BACKEND_PORT`, `FRONTEND_PORT`. + +Для размещения вне локальной разработки требуется HTTPS. В этой версии сохранён способ хранения токена из #48 — localStorage; выход удаляет его из браузера, но сам по себе не отзывает скопированную копию токена. Серверный отзыв выполняется при сбросе пароля или блокировке. Администратор знает вручную заданный пароль сотрудника — это осознанное упрощение учебного проекта, обязательной смены пароля нет. + +#### Проверки + +Backend-тесты **очищают таблицы**. Указать отдельную тестовую базу: + +```bash +cd backend +DATABASE_URL=postgresql+psycopg://pdm:pdm@localhost:5432/offtech_test alembic upgrade head +TEST_DATABASE_URL=postgresql+psycopg://pdm:pdm@localhost:5432/offtech_test pytest -q +``` + +Тесты задают тестовый ключ JWT самостоятельно. Проверяют обе роли, административные операции, прямой обход UI, блокировку, отзыв токенов, параллельные изменения, валидацию и лимиты входа. Проверка миграций: `alembic check`. Проверка frontend: `cd frontend && npm ci && npm run build`. Эти проверки также добавлены в CI. ### Оборудование diff --git a/backend/alembic/versions/b48a001_managed_accounts.py b/backend/alembic/versions/b48a001_managed_accounts.py new file mode 100644 index 0000000..c5dcbf8 --- /dev/null +++ b/backend/alembic/versions/b48a001_managed_accounts.py @@ -0,0 +1,44 @@ +"""Managed accounts: logins, roles, revocable tokens and login throttling. + +Revision ID: b48a001 +Revises: 1395cb8114bd +""" +import sqlalchemy as sa +from alembic import op + +revision = "b48a001" +down_revision = "1395cb8114bd" +branch_labels = None +depends_on = None + + +def upgrade(): + # This deployment has no existing accounts. Do not silently convert real emails. + if op.get_bind().execute(sa.text("SELECT EXISTS (SELECT 1 FROM users)")).scalar(): + raise RuntimeError("Managed-account migration requires an empty users table; existing accounts need an explicit migration plan.") + op.drop_constraint("users_email_key", "users", type_="unique") + op.alter_column("users", "email", new_column_name="login", type_=sa.String(64), existing_type=sa.Text()) + op.create_unique_constraint("users_login_key", "users", ["login"]) + op.add_column("users", sa.Column("role", sa.String(16), nullable=False, server_default="employee")) + op.add_column("users", sa.Column("is_active", sa.Boolean(), nullable=False, server_default=sa.text("true"))) + op.add_column("users", sa.Column("token_version", sa.Integer(), nullable=False, server_default="0")) + op.create_check_constraint("users_role_check", "users", "role IN ('admin', 'employee')") + op.create_check_constraint("users_login_check", "users", "login ~ '^[a-z0-9._-]{3,64}$'") + op.create_table("login_attempts", + sa.Column("key", sa.String(64), primary_key=True), + sa.Column("count", sa.Integer(), nullable=False), + sa.Column("expires_at", sa.DateTime(timezone=True), nullable=False), + ) + op.create_index("ix_login_attempts_expires_at", "login_attempts", ["expires_at"]) + + +def downgrade(): + op.drop_table("login_attempts") + op.drop_constraint("users_login_check", "users", type_="check") + op.drop_constraint("users_role_check", "users", type_="check") + op.drop_column("users", "token_version") + op.drop_column("users", "is_active") + op.drop_column("users", "role") + op.drop_constraint("users_login_key", "users", type_="unique") + op.alter_column("users", "login", new_column_name="email", type_=sa.Text(), existing_type=sa.String(64)) + op.create_unique_constraint("users_email_key", "users", ["email"]) diff --git a/backend/app/api/auth.py b/backend/app/api/auth.py index f1b411c..54ad6c9 100644 --- a/backend/app/api/auth.py +++ b/backend/app/api/auth.py @@ -1,53 +1,50 @@ from typing import Annotated -from fastapi import APIRouter, Depends, HTTPException, status +from fastapi import APIRouter, Depends, HTTPException, Request from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer from app.core.db import DB -from app.core.security import create_token, user_id_from_token -from app.schemas.auth import AuthOut, LoginIn, RegisterIn, UserOut +from app.core.login_throttle import check_login_attempt +from app.core.security import create_token, identity_from_token +from app.schemas.auth import AuthOut, LoginIn, UserOut from app.services import auth_service router = APIRouter(prefix="/auth", tags=["Авторизация"]) - -bearer = HTTPBearer(auto_error=False, description="Токен из /auth/login или /auth/register") - -UNAUTHORIZED = {401: {"description": "Нет токена, токен неверен или просрочен"}} +bearer = HTTPBearer(auto_error=False, description="Токен из /auth/login") +UNAUTHORIZED = {401: {"description": "Требуется действующий токен активного пользователя"}} def _unauthorized(detail: str) -> HTTPException: - return HTTPException(status.HTTP_401_UNAUTHORIZED, detail, headers={"WWW-Authenticate": "Bearer"}) + return HTTPException(401, detail, headers={"WWW-Authenticate": "Bearer"}) def get_current_user(db: DB, credentials: Annotated[HTTPAuthorizationCredentials | None, Depends(bearer)]) -> dict: - user_id = user_id_from_token(credentials.credentials) if credentials else None - user = auth_service.get_user(db, user_id) if user_id is not None else None - if user is None: + identity = identity_from_token(credentials.credentials) if credentials else None + user = auth_service.get_user(db, identity[0]) if identity else None + if user is None or not user["is_active"] or user["token_version"] != identity[1]: raise _unauthorized("Требуется вход в систему") return user -def _session(user: dict) -> dict: - return {"access_token": create_token(user["id"]), "token_type": "bearer", "user": user} +CurrentUser = Annotated[dict, Depends(get_current_user)] -@router.post("/register", response_model=AuthOut, status_code=status.HTTP_201_CREATED, - responses={409: {"description": "Email уже зарегистрирован"}}, summary="Регистрация") -def register(body: RegisterIn, db: DB): - user = auth_service.create_user(db, body.email, body.password) - if user is None: - raise HTTPException(status.HTTP_409_CONFLICT, "Пользователь с таким email уже зарегистрирован") - return _session(user) +def require_admin(user: CurrentUser) -> dict: + if user["role"] != "admin": + raise HTTPException(403, "Доступ разрешён только администратору") + return user -@router.post("/login", response_model=AuthOut, responses=UNAUTHORIZED, summary="Вход по email и паролю") -def login(body: LoginIn, db: DB): - user = auth_service.authenticate(db, body.email, body.password) +@router.post("/login", response_model=AuthOut, responses={**UNAUTHORIZED, 429: {"description": "Лимит попыток входа"}}, + summary="Вход по логину и паролю") +def login(body: LoginIn, request: Request, db: DB): + check_login_attempt(request, body.login) + user = auth_service.authenticate(db, body.login, body.password) if user is None: - raise _unauthorized("Неверный email или пароль") - return _session(user) + raise _unauthorized("Неверный логин или пароль") + return {"access_token": create_token(user["id"], user["token_version"]), "token_type": "bearer", "user": user} @router.get("/me", response_model=UserOut, responses=UNAUTHORIZED, summary="Текущий пользователь") -def me(user: Annotated[dict, Depends(get_current_user)]): +def me(user: CurrentUser): return user diff --git a/backend/app/api/users.py b/backend/app/api/users.py new file mode 100644 index 0000000..9131968 --- /dev/null +++ b/backend/app/api/users.py @@ -0,0 +1,56 @@ +from typing import Annotated + +from fastapi import APIRouter, Depends, HTTPException, Query +from sqlalchemy import select, update + +from app.api.auth import require_admin +from app.core.db import DB +from app.core.security import hash_password +from app.models.users import User +from app.schemas.auth import CreateUserIn, ManagedUserOut, ResetPasswordIn, SetActiveIn +from app.services.auth_service import PUBLIC_COLUMNS, create_user + +router = APIRouter(prefix="/admin/users", tags=["Управление аккаунтами"], dependencies=[Depends(require_admin)], + responses={401: {"description": "Требуется вход"}, 403: {"description": "Недостаточно прав"}}) + + +@router.get("", response_model=list[ManagedUserOut]) +def list_users(db: DB, limit: Annotated[int, Query(ge=1, le=100)] = 50, + offset: Annotated[int, Query(ge=0)] = 0): + return db.execute(select(*PUBLIC_COLUMNS).order_by(User.id).limit(limit).offset(offset)).mappings().all() + + +@router.post("", response_model=ManagedUserOut, status_code=201) +def add_user(body: CreateUserIn, db: DB): + user = create_user(db, body.login, body.password) + if user is None: + raise HTTPException(409, "Этот логин уже занят") + return user + + +def employee_for_update(db: DB, user_id: int): + user = db.execute(select(User.id, User.role).where(User.id == user_id).with_for_update()).mappings().first() + if user is None: + raise HTTPException(404, "Пользователь не найден") + if user["role"] != "employee": + raise HTTPException(403, "Через панель можно изменять только аккаунты сотрудников") + + +@router.put("/{user_id}/password", status_code=204) +def reset_password(user_id: int, body: ResetPasswordIn, db: DB): + password_hash = hash_password(body.password) + employee_for_update(db, user_id) + db.execute(update(User).where(User.id == user_id).values( + password_hash=password_hash, token_version=User.token_version + 1)) + db.commit() + + +@router.put("/{user_id}/status", response_model=ManagedUserOut) +def set_active(user_id: int, body: SetActiveIn, db: DB): + employee_for_update(db, user_id) + # Invalidate tokens even on repeated status updates; unblocking never revives old tokens. + user = db.execute(update(User).where(User.id == user_id).values( + is_active=body.is_active, token_version=User.token_version + 1, + ).returning(*PUBLIC_COLUMNS)).mappings().one() + db.commit() + return user diff --git a/backend/app/core/login_throttle.py b/backend/app/core/login_throttle.py new file mode 100644 index 0000000..a37d1cf --- /dev/null +++ b/backend/app/core/login_throttle.py @@ -0,0 +1,45 @@ +from datetime import timedelta + +from fastapi import HTTPException, Request +from sqlalchemy import case, delete, func +from sqlalchemy.dialects.postgresql import insert + +from app.core.db import engine +from app.core.security import throttle_key +from app.models.users import LoginAttempt + +WINDOW_SECONDS = 15 * 60 +LOGIN_LIMIT = 10 +IP_LIMIT = 60 + + +def check_login_attempt(request: Request, login: str): + """Atomic counters shared across workers. Count all attempts, before bcrypt. + + Use the actual peer address; do not trust client-supplied forwarding headers. + Successful login does not reset limits, which would enable a bypass. + """ + identities = [("login", login, LOGIN_LIMIT), + ("ip", request.client.host if request.client else "unknown", IP_LIMIT)] + exceeded = False + retry_after = 1 + with engine.begin() as db: + db.execute(delete(LoginAttempt).where(LoginAttempt.expires_at <= func.now())) + for kind, value, limit in identities: + statement = insert(LoginAttempt).values( + key=throttle_key(kind, value), count=1, + expires_at=func.now() + timedelta(seconds=WINDOW_SECONDS), + ) + expired = LoginAttempt.expires_at <= func.now() + row = db.execute(statement.on_conflict_do_update( + index_elements=[LoginAttempt.key], + set_={"count": case((expired, 1), else_=LoginAttempt.count + 1), + "expires_at": case((expired, statement.excluded.expires_at), else_=LoginAttempt.expires_at)}, + ).returning(LoginAttempt.count, + func.extract("epoch", LoginAttempt.expires_at - func.now()).label("remaining"))).one() + if row.count > limit: + exceeded = True + retry_after = max(retry_after, int(row.remaining) + 1) + if exceeded: + raise HTTPException(429, "Слишком много попыток входа. Повторите позже.", + headers={"Retry-After": str(retry_after)}) diff --git a/backend/app/core/security.py b/backend/app/core/security.py index eef5e28..4883659 100644 --- a/backend/app/core/security.py +++ b/backend/app/core/security.py @@ -1,5 +1,5 @@ -import logging -import secrets +import hashlib +import hmac from datetime import UTC, datetime, timedelta import bcrypt @@ -7,15 +7,10 @@ from app.core.config import JWT_EXPIRE_MINUTES, JWT_SECRET -logger = logging.getLogger("security") - ALGORITHM = "HS256" - -if JWT_SECRET: - _secret = JWT_SECRET -else: - _secret = secrets.token_urlsafe(32) - logger.warning("JWT_SECRET не задан: сгенерирован временный ключ, после перезапуска backend войти придётся заново") +if len(JWT_SECRET.encode()) < 32: + raise RuntimeError("JWT_SECRET must contain at least 32 bytes; configure a persistent secret before starting the backend") +DUMMY_HASH = bcrypt.hashpw(b"dummy-password-for-timing", bcrypt.gensalt()).decode() def hash_password(password: str) -> str: @@ -23,18 +18,28 @@ def hash_password(password: str) -> str: def verify_password(password: str, password_hash: str) -> bool: - return bcrypt.checkpw(password.encode(), password_hash.encode()) + try: + return bcrypt.checkpw(password.encode(), password_hash.encode()) + except ValueError: + return False -def create_token(user_id: int) -> str: - expires = datetime.now(UTC) + timedelta(minutes=JWT_EXPIRE_MINUTES) - return jwt.encode({"sub": str(user_id), "exp": expires}, _secret, algorithm=ALGORITHM) +def create_token(user_id: int, token_version: int = 0) -> str: + now = datetime.now(UTC) + return jwt.encode({"sub": str(user_id), "ver": token_version, "iat": now, + "exp": now + timedelta(minutes=JWT_EXPIRE_MINUTES)}, JWT_SECRET, algorithm=ALGORITHM) -def user_id_from_token(token: str) -> int | None: - """id пользователя из токена; None, если токен неверен или просрочен.""" +def identity_from_token(token: str) -> tuple[int, int] | None: try: - payload = jwt.decode(token, _secret, algorithms=[ALGORITHM], options={"require": ["exp", "sub"]}) - return int(payload["sub"]) - except (jwt.InvalidTokenError, ValueError): + payload = jwt.decode(token, JWT_SECRET, algorithms=[ALGORITHM], + options={"require": ["exp", "sub", "ver", "iat"]}) + if type(payload["ver"]) is not int or payload["ver"] < 0: + return None + return int(payload["sub"]), payload["ver"] + except (jwt.InvalidTokenError, ValueError, TypeError): return None + + +def throttle_key(kind: str, value: str) -> str: + return hmac.new(JWT_SECRET.encode(), f"{kind}:{value}".encode(), hashlib.sha256).hexdigest() diff --git a/backend/app/create_admin.py b/backend/app/create_admin.py new file mode 100644 index 0000000..11f88d0 --- /dev/null +++ b/backend/app/create_admin.py @@ -0,0 +1,33 @@ +"""Run on the server: python -m app.create_admin (credentials are never command arguments).""" +from getpass import getpass + +from pydantic import ValidationError + +from app.core.db import engine +from app.schemas.auth import CreateUserIn +from app.services.auth_service import create_user + + +def main(): + try: + login = input("Логин администратора: ") + password = getpass("Пароль (от 12 символов): ") + confirm = getpass("Повторите пароль: ") + if password != confirm: + raise SystemExit("Пароли не совпадают. Аккаунт не создан.") + try: + credentials = CreateUserIn(login=login, password=password) + except ValidationError as exc: + # Never print Pydantic's input values: they may include the password. + raise SystemExit("; ".join(error["msg"] for error in exc.errors(include_input=False))) from None + with engine.connect() as db: + user = create_user(db, credentials.login, credentials.password, role="admin") + if user is None: + raise SystemExit("Логин уже занят. Существующий аккаунт не изменён.") + print(f"Администратор {user['login']} создан.") + except (EOFError, KeyboardInterrupt): + raise SystemExit("Создание отменено.") from None + + +if __name__ == "__main__": + main() diff --git a/backend/app/models/__init__.py b/backend/app/models/__init__.py index f153bad..deef55c 100644 --- a/backend/app/models/__init__.py +++ b/backend/app/models/__init__.py @@ -4,11 +4,12 @@ from .physics_predictions import PhysicsPrediction from .sensor_catalog import SensorCatalog from .sensor_readings import SensorReading -from .users import User +from .users import LoginAttempt, User __all__ = [ "Alert", "Equipment", + "LoginAttempt", "MlPrediction", "PhysicsPrediction", "SensorCatalog", diff --git a/backend/app/models/users.py b/backend/app/models/users.py index dd90531..295030f 100644 --- a/backend/app/models/users.py +++ b/backend/app/models/users.py @@ -1,12 +1,37 @@ -from sqlalchemy import Column, DateTime, Integer, Text, func +from sqlalchemy import ( + Boolean, + CheckConstraint, + Column, + DateTime, + Integer, + String, + Text, + func, + text, +) from app.core.db import Base class User(Base): __tablename__ = "users" + __table_args__ = ( + CheckConstraint("role IN ('admin', 'employee')", name="users_role_check"), + CheckConstraint("login ~ '^[a-z0-9._-]{3,64}$'", name="users_login_check"), + ) id = Column(Integer, primary_key=True) - email = Column(Text, nullable=False, unique=True) + login = Column(String(64), nullable=False, unique=True) password_hash = Column(Text, nullable=False) + role = Column(String(16), nullable=False, server_default="employee") + is_active = Column(Boolean, nullable=False, server_default=text("true")) + token_version = Column(Integer, nullable=False, server_default="0") created_at = Column(DateTime, nullable=False, server_default=func.now()) + + +class LoginAttempt(Base): + __tablename__ = "login_attempts" + + key = Column(String(64), primary_key=True) + count = Column(Integer, nullable=False) + expires_at = Column(DateTime(timezone=True), nullable=False, index=True) diff --git a/backend/app/schemas/auth.py b/backend/app/schemas/auth.py index 8506d6d..60a8983 100644 --- a/backend/app/schemas/auth.py +++ b/backend/app/schemas/auth.py @@ -1,35 +1,72 @@ -from pydantic import BaseModel, Field, field_validator +from datetime import datetime +from typing import Literal -PASSWORD_MAX_BYTES = 72 # bcrypt не принимает пароли длиннее +from pydantic import BaseModel, ConfigDict, Field, field_validator +PASSWORD_MAX_BYTES = 72 +PASSWORD_MIN = 12 -class LoginIn(BaseModel): - email: str = Field(max_length=254, pattern=r"^[^@\s]+@[^@\s]+\.[^@\s]+$", examples=["operator@example.com"]) - password: str = Field(min_length=1) - @field_validator("email", mode="before") - @classmethod - def normalize_email(cls, value): - return value.strip().lower() if isinstance(value, str) else value +class PasswordIn(BaseModel): + model_config = ConfigDict(extra="forbid") + password: str = Field(min_length=1, max_length=72, repr=False) - @field_validator("password") + @field_validator("password", mode="before") @classmethod def fits_bcrypt(cls, value: str) -> str: - if len(value.encode()) > PASSWORD_MAX_BYTES: - raise ValueError(f"пароль длиннее {PASSWORD_MAX_BYTES} байт") + if not isinstance(value, str): + return value + if len(value.encode("utf-8")) > PASSWORD_MAX_BYTES: + size = 0 + limit = 0 + for character in value: + size += len(character.encode("utf-8")) + if size > PASSWORD_MAX_BYTES: + break + limit += 1 + raise ValueError(f"Пароль слишком длинный. Сократите его до {limit} символов.") return value -class RegisterIn(LoginIn): - password: str = Field(min_length=8, description="От 8 символов, не длиннее 72 байт в UTF-8") +class LoginIn(PasswordIn): + login: str = Field(min_length=3, max_length=64, pattern=r"^[a-z0-9._-]+$") + + @field_validator("login", mode="before") + @classmethod + def normalize_login(cls, value): + if not isinstance(value, str): + return value + value = value.strip() + if not value.isascii(): + raise ValueError("В логине разрешены только латинские буквы, цифры, точка, дефис и подчёркивание") + return value.lower() + + +class CreateUserIn(LoginIn): + password: str = Field(min_length=PASSWORD_MIN, max_length=72, repr=False) + + +class ResetPasswordIn(PasswordIn): + password: str = Field(min_length=PASSWORD_MIN, max_length=72, repr=False) + + +class SetActiveIn(BaseModel): + model_config = ConfigDict(extra="forbid") + is_active: bool = Field(strict=True) class UserOut(BaseModel): id: int - email: str + login: str + role: Literal["admin", "employee"] + is_active: bool + + +class ManagedUserOut(UserOut): + created_at: datetime class AuthOut(BaseModel): - access_token: str = Field(description="JWT для заголовка Authorization: Bearer") + access_token: str token_type: str = "bearer" user: UserOut diff --git a/backend/app/services/auth_service.py b/backend/app/services/auth_service.py index b826dbf..b565820 100644 --- a/backend/app/services/auth_service.py +++ b/backend/app/services/auth_service.py @@ -1,31 +1,30 @@ from sqlalchemy import Connection, select from sqlalchemy.dialects.postgresql import insert -from app.core.security import hash_password, verify_password +from app.core.security import DUMMY_HASH, hash_password, verify_password from app.models.users import User +PUBLIC_COLUMNS = (User.id, User.login, User.role, User.is_active, User.created_at) -def create_user(db: Connection, email: str, password: str) -> dict | None: - """Новый пользователь; None, если email уже занят.""" - query = ( - insert(User) - .values(email=email, password_hash=hash_password(password)) - .on_conflict_do_nothing(index_elements=[User.email]) - .returning(User.id, User.email) - ) - row = db.execute(query).mappings().first() + +def create_user(db: Connection, login: str, password: str, *, role: str = "employee") -> dict | None: + row = db.execute(insert(User).values(login=login, password_hash=hash_password(password), role=role) + .on_conflict_do_nothing(index_elements=[User.login]) + .returning(*PUBLIC_COLUMNS)).mappings().first() db.commit() return dict(row) if row else None -def authenticate(db: Connection, email: str, password: str) -> dict | None: - query = select(User.id, User.email, User.password_hash).where(User.email == email) - row = db.execute(query).mappings().first() - if row is None or not verify_password(password, row["password_hash"]): +def authenticate(db: Connection, login: str, password: str) -> dict | None: + row = db.execute(select(*PUBLIC_COLUMNS, User.password_hash, User.token_version) + .where(User.login == login)).mappings().first() + # Always run bcrypt, including unknown logins and disabled accounts. + valid = verify_password(password, row["password_hash"] if row else DUMMY_HASH) + if row is None or not valid or not row["is_active"]: return None - return {"id": row["id"], "email": row["email"]} + return {key: value for key, value in row.items() if key != "password_hash"} def get_user(db: Connection, user_id: int) -> dict | None: - row = db.execute(select(User.id, User.email).where(User.id == user_id)).mappings().first() + row = db.execute(select(*PUBLIC_COLUMNS, User.token_version).where(User.id == user_id)).mappings().first() return dict(row) if row else None diff --git a/backend/main.py b/backend/main.py index b687a2a..e94f6c1 100644 --- a/backend/main.py +++ b/backend/main.py @@ -1,18 +1,29 @@ -from app.api import alerts, auth, equipment, predict +from app.api import alerts, auth, equipment, predict, users from app.api.auth import UNAUTHORIZED, get_current_user from app.core.config import CORS_ORIGINS from fastapi import Depends, FastAPI +from fastapi.exceptions import RequestValidationError from fastapi.middleware.cors import CORSMiddleware +from fastapi.responses import JSONResponse app = FastAPI(title="OFF-Tech: оценка состояния оборудования", version="0.1.0") app.add_middleware(CORSMiddleware, allow_origins=CORS_ORIGINS, allow_methods=["*"], allow_headers=["*"]) -# Данные — только с токеном; /auth/register и /auth/login открыты. +# Данные — только с токеном; публичный вход только через /auth/login. PROTECTED = [Depends(get_current_user)] app.include_router(auth.router) app.include_router(equipment.router, dependencies=PROTECTED, responses=UNAUTHORIZED) app.include_router(alerts.router, dependencies=PROTECTED, responses=UNAUTHORIZED) app.include_router(predict.router, dependencies=PROTECTED, responses=UNAUTHORIZED) + +app.include_router(users.router) + + +@app.exception_handler(RequestValidationError) +async def validation_error_handler(request, exc): + # Default validation responses echo submitted values, including passwords. + errors = [{"loc": error["loc"], "msg": error["msg"], "type": error["type"]} for error in exc.errors()] + return JSONResponse(status_code=422, content={"detail": errors}) diff --git a/backend/tests/conftest.py b/backend/tests/conftest.py index 5410b7c..39d29d9 100644 --- a/backend/tests/conftest.py +++ b/backend/tests/conftest.py @@ -13,7 +13,7 @@ os.environ["RUL_CLIP"] = "125" os.environ["JWT_SECRET"] = "test-secret-for-pytest-only-0123456789" -TABLES = "alerts, ml_predictions, physics_predictions, sensor_readings, equipment, users" +TABLES = "alerts, ml_predictions, physics_predictions, sensor_readings, equipment, users, login_attempts" @pytest.fixture @@ -40,7 +40,7 @@ def client(db): from app.models import User from main import app - statement = insert(User).values(email="operator@example.com", password_hash="-").returning(User.id) + statement = insert(User).values(login="operator", password_hash="-").returning(User.id) user_id = db.execute(statement).scalar_one() db.commit() return TestClient(app, headers={"Authorization": f"Bearer {create_token(user_id)}"}) @@ -88,3 +88,29 @@ def add(equipment_id: int, cycle: int) -> dict[str, float]: return sensors return add + + +@pytest.fixture(scope="session") +def password_hash(): + from app.core.security import hash_password + return hash_password("Correct-pass 123!") + + +@pytest.fixture +def account(db, password_hash): + from app.models import User + + def add(login="worker", role="employee", is_active=True): + row = db.execute(insert(User).values(login=login, role=role, is_active=is_active, + password_hash=password_hash).returning(User.id)).scalar_one() + db.commit() + return row + return add + + +@pytest.fixture +def admin_client(db, account): + from app.core.security import create_token + from main import app + user_id = account("administrator", "admin") + return TestClient(app, headers={"Authorization": f"Bearer {create_token(user_id)}"}) diff --git a/backend/tests/test_auth.py b/backend/tests/test_auth.py index d81b24b..ab9d68b 100644 --- a/backend/tests/test_auth.py +++ b/backend/tests/test_auth.py @@ -1,131 +1,232 @@ import re +from concurrent.futures import ThreadPoolExecutor from datetime import UTC, datetime, timedelta import bcrypt import jwt import pytest from fastapi.routing import APIRoute -from sqlalchemy import text +from sqlalchemy import insert, select, text, update -OPEN_PATHS = {"/auth/register", "/auth/login", "/health"} -CREDENTIALS = {"email": "operator@example.com", "password": "correct-horse"} +PASSWORD = "Correct-pass 123!" -def protected_routes() -> list[tuple[str, str]]: +def protected_routes(): from main import app + return sorted((method, re.sub(r"\{[^}]+\}", "1", route.path)) + for route in app.routes if isinstance(route, APIRoute) and route.path != "/auth/login" + for method in route.methods) - return sorted( - (method, re.sub(r"\{[^}]+\}", "1", route.path)) - for route in app.routes - if isinstance(route, APIRoute) and route.path not in OPEN_PATHS - for method in route.methods - ) - -def bearer(token: str) -> dict[str, str]: +def bearer(token): return {"Authorization": f"Bearer {token}"} -def test_register_returns_working_token(anon_client): - response = anon_client.post("/auth/register", json={**CREDENTIALS, "email": " Operator@Example.COM "}) - - assert response.status_code == 201 - body = response.json() - assert body["token_type"] == "bearer" - assert body["user"]["email"] == "operator@example.com" - - me = anon_client.get("/auth/me", headers=bearer(body["access_token"])) - assert me.status_code == 200 - assert me.json() == body["user"] - - -def test_password_is_stored_as_bcrypt_hash(anon_client, db): - anon_client.post("/auth/register", json=CREDENTIALS) - - stored = db.execute(text("SELECT password_hash FROM users")).scalar_one() - - assert CREDENTIALS["password"] not in stored - assert bcrypt.checkpw(CREDENTIALS["password"].encode(), stored.encode()) - - -def test_register_same_email_conflicts(anon_client): - assert anon_client.post("/auth/register", json=CREDENTIALS).status_code == 201 - - response = anon_client.post("/auth/register", json={**CREDENTIALS, "email": "OPERATOR@example.com"}) - - assert response.status_code == 409 - +def sign_in(client, login="worker", password=PASSWORD): + return client.post("/auth/login", json={"login": login, "password": password}) -@pytest.mark.parametrize("payload", [ - {"email": "not-an-email", "password": "correct-horse"}, - {"email": "operator@example.com", "password": "short"}, - {"email": "operator@example.com", "password": "я" * 37}, # 74 байта — больше лимита bcrypt - {"email": "operator@example.com"}, -]) -def test_register_validates_input(anon_client, payload): - assert anon_client.post("/auth/register", json=payload).status_code == 422 - -def test_login_returns_working_token(anon_client): - anon_client.post("/auth/register", json=CREDENTIALS) - - response = anon_client.post("/auth/login", json={**CREDENTIALS, "email": "Operator@example.com"}) - - assert response.status_code == 200 - assert anon_client.get("/equipment", headers=bearer(response.json()["access_token"])).status_code == 200 - - -@pytest.mark.parametrize("credentials", [ - {**CREDENTIALS, "password": "wrong-password"}, - {**CREDENTIALS, "email": "nobody@example.com"}, -]) -def test_login_rejects_wrong_credentials(anon_client, credentials): - anon_client.post("/auth/register", json=CREDENTIALS) - - response = anon_client.post("/auth/login", json=credentials) - - assert response.status_code == 401 - assert response.json()["detail"] == "Неверный email или пароль" +def test_public_registration_removed(anon_client): + assert anon_client.post("/auth/register", json={"login": "worker", "password": PASSWORD}).status_code == 404 + assert "/auth/register" not in anon_client.get("/openapi.json").json()["paths"] @pytest.mark.parametrize(("method", "path"), protected_routes()) -def test_api_requires_token(anon_client, method, path): +def test_every_api_requires_token(anon_client, method, path): response = anon_client.request(method, path) - assert response.status_code == 401 assert response.headers["WWW-Authenticate"] == "Bearer" -def test_protected_routes_cover_api(): - routes = protected_routes() +@pytest.mark.parametrize(("method", "path"), [(method, path) for method, path in protected_routes() + if path.startswith("/admin/")]) +def test_employee_cannot_use_admin_api(client, method, path): + assert client.request(method, path, json={"login": "intruder", "password": PASSWORD, + "is_active": False}).status_code == 403 - assert ("GET", "/equipment") in routes - assert ("GET", "/auth/me") in routes - -def test_signed_in_client_reaches_api(client): - assert client.get("/equipment").status_code == 200 - assert client.get("/auth/me").json()["email"] == "operator@example.com" +def test_create_and_login(admin_client, anon_client, db): + response = admin_client.post("/admin/users", json={"login": " Ivan.Petrov ", "password": PASSWORD}) + assert response.status_code == 201 + user = response.json() + assert user["login"] == "ivan.petrov" and user["role"] == "employee" and user["is_active"] + assert "password_hash" not in user and "password" not in user + hashed = db.execute(text("SELECT password_hash FROM users WHERE id=:id"), {"id": user["id"]}).scalar_one() + assert hashed != PASSWORD and bcrypt.checkpw(PASSWORD.encode(), hashed.encode()) + login = sign_in(anon_client, "IVAN.PETROV") + assert login.status_code == 200 + token = login.json()["access_token"] + assert anon_client.get("/auth/me", headers=bearer(token)).json()["login"] == "ivan.petrov" + assert anon_client.get("/equipment", headers=bearer(token)).status_code == 200 + assert anon_client.get("/alerts", headers=bearer(token)).status_code == 200 + assert anon_client.get("/admin/users", headers=bearer(token)).status_code == 403 + + +def test_admin_can_use_working_sections(admin_client, add_equipment, add_prediction, add_reading): + equipment_id = add_equipment() + add_reading(equipment_id, 1) + add_prediction(equipment_id, 1, 100) + for path in ("/equipment", f"/equipment/{equipment_id}", f"/equipment/{equipment_id}/history", + f"/equipment/{equipment_id}/forecast", "/alerts", "/auth/me", "/admin/users"): + assert admin_client.get(path).status_code == 200, path + assert admin_client.get("/auth/me").json()["role"] == "admin" + + +def test_duplicate_login_normalization(admin_client): + assert admin_client.post("/admin/users", json={"login": "Employee", "password": PASSWORD}).status_code == 201 + assert admin_client.post("/admin/users", json={"login": " employee ", "password": PASSWORD}).status_code == 409 + + +@pytest.mark.parametrize("login", ["", "ab", "a" * 65, "иван", "a b", "a@b.com", "adm\nin", "Kelvin", "foo/bar"]) +def test_invalid_logins(admin_client, login): + assert admin_client.post("/admin/users", json={"login": login, "password": PASSWORD}).status_code == 422 + + +@pytest.mark.parametrize("password", ["Qx7!", "я" * 37, "a" * 73]) +def test_invalid_passwords_never_echoed(admin_client, password): + response = admin_client.post("/admin/users", json={"login": "worker", "password": password}) + assert response.status_code == 422 + assert password not in response.text + assert all("input" not in error for error in response.json()["detail"]) + + +def test_password_preserves_spaces_case_and_symbols(admin_client, anon_client): + password = " My Str0ng! Пароль " + assert admin_client.post("/admin/users", json={"login": "worker", "password": password}).status_code == 201 + assert sign_in(anon_client, password=password).status_code == 200 + assert sign_in(anon_client, password=password.strip()).status_code == 401 + assert sign_in(anon_client, password=password.lower()).status_code == 401 + + +def test_cannot_inject_admin_role(admin_client, db): + response = admin_client.post("/admin/users", json={"login": "worker", "password": PASSWORD, "role": "admin"}) + assert response.status_code == 422 + assert db.execute(text("SELECT count(*) FROM users WHERE login='worker'")).scalar_one() == 0 + + +def test_bad_credentials_and_blocked_users_look_same(anon_client, account): + account() + account("disabled", is_active=False) + responses = [sign_in(anon_client, login, password) for login, password in + [("worker", "wrong"), ("missing", PASSWORD), ("disabled", PASSWORD)]] + assert all(response.status_code == 401 for response in responses) + assert all(response.json() == {"detail": "Неверный логин или пароль"} for response in responses) + + +def test_reset_invalidates_all_old_tokens(admin_client, anon_client, account): + user_id = account() + old_tokens = [sign_in(anon_client).json()["access_token"] for _ in range(2)] + response = admin_client.put(f"/admin/users/{user_id}/password", json={"password": "New password 456!"}) + assert response.status_code == 204 + assert sign_in(anon_client).status_code == 401 + for token in old_tokens: + assert anon_client.get("/equipment", headers=bearer(token)).status_code == 401 + new_token = sign_in(anon_client, password="New password 456!").json()["access_token"] + assert anon_client.get("/equipment", headers=bearer(new_token)).status_code == 200 + + +def test_block_unblock_does_not_revive_token(admin_client, anon_client, account): + user_id = account() + old_token = sign_in(anon_client).json()["access_token"] + assert admin_client.put(f"/admin/users/{user_id}/status", json={"is_active": False}).status_code == 200 + assert sign_in(anon_client).status_code == 401 + assert anon_client.get("/equipment", headers=bearer(old_token)).status_code == 401 + assert admin_client.put(f"/admin/users/{user_id}/status", json={"is_active": True}).status_code == 200 + assert anon_client.get("/equipment", headers=bearer(old_token)).status_code == 401 + assert sign_in(anon_client).status_code == 200 + + +def test_reset_does_not_unblock(admin_client, anon_client, account): + user_id = account(is_active=False) + assert admin_client.put(f"/admin/users/{user_id}/password", json={"password": "New password 456!"}).status_code == 204 + assert sign_in(anon_client, password="New password 456!").status_code == 401 + + +def test_admin_accounts_cannot_be_modified_from_panel(admin_client): + user_id = admin_client.get("/auth/me").json()["id"] + assert admin_client.put(f"/admin/users/{user_id}/status", json={"is_active": False}).status_code == 403 + assert admin_client.put(f"/admin/users/{user_id}/password", json={"password": PASSWORD}).status_code == 403 + assert admin_client.get("/admin/users").status_code == 200 + + +def test_missing_account(admin_client): + assert admin_client.put("/admin/users/999/password", json={"password": PASSWORD}).status_code == 404 + assert admin_client.put("/admin/users/999/status", json={"is_active": False}).status_code == 404 -def _token(secret: str, sub: str = "1", minutes: int = 5) -> str: - expires = datetime.now(UTC) + timedelta(minutes=minutes) - return jwt.encode({"sub": sub, "exp": expires}, secret, algorithm="HS256") +def test_role_loaded_from_database(admin_client, db): + from app.models import User + user_id = admin_client.get("/auth/me").json()["id"] + db.execute(update(User).where(User.id == user_id).values(role="employee")) + db.commit() + assert admin_client.get("/admin/users").status_code == 403 + assert admin_client.get("/equipment").status_code == 200 -def test_rejects_bad_tokens(client): +def test_bad_and_legacy_tokens(anon_client, account): from app.core.config import JWT_SECRET - - user_token = client.headers["Authorization"].removeprefix("Bearer ") - user_id = jwt.decode(user_token, JWT_SECRET, algorithms=["HS256"])["sub"] - bad = { - "garbage": bearer("garbage"), - "foreign secret": bearer(_token("another-secret-another-secret-0123", user_id)), - "expired": bearer(_token(JWT_SECRET, user_id, minutes=-1)), - "unknown user": bearer(_token(JWT_SECRET, "999")), - "basic scheme": {"Authorization": f"Basic {user_token}"}, - } - - for name, headers in bad.items(): - response = client.get("/equipment", headers=headers) - assert response.status_code == 401, name + user_id = account() + payload = {"sub": str(user_id), "ver": 0, "iat": datetime.now(UTC), "exp": datetime.now(UTC) + timedelta(minutes=5)} + tokens = ["garbage", jwt.encode(payload, "different-secret-for-test-0000000", algorithm="HS256"), + jwt.encode({**payload, "exp": datetime.now(UTC) - timedelta(minutes=1)}, JWT_SECRET, algorithm="HS256"), + jwt.encode({**payload, "sub": "999"}, JWT_SECRET, algorithm="HS256"), + jwt.encode({k: v for k, v in payload.items() if k != "ver"}, JWT_SECRET, algorithm="HS256"), + jwt.encode({**payload, "ver": True}, JWT_SECRET, algorithm="HS256")] + for token in tokens: + assert anon_client.get("/equipment", headers=bearer(token)).status_code == 401 + + +def test_login_throttle_and_expiry(anon_client, db): + from app.core.login_throttle import LOGIN_LIMIT + for _ in range(LOGIN_LIMIT): + assert sign_in(anon_client, password="wrong").status_code == 401 + blocked = sign_in(anon_client, "WORKER", "wrong") + assert blocked.status_code == 429 and int(blocked.headers["Retry-After"]) > 0 + db.execute(text("UPDATE login_attempts SET expires_at=now() - interval '1 second'")) + db.commit() + assert sign_in(anon_client, password="wrong").status_code == 401 + + +def test_ip_limit_even_for_different_logins(anon_client, db): + from app.core.login_throttle import IP_LIMIT + from app.core.security import throttle_key + from app.models.users import LoginAttempt + db.execute(insert(LoginAttempt).values(key=throttle_key("ip", "testclient"), count=IP_LIMIT, + expires_at=datetime.now(UTC) + timedelta(minutes=10))) + db.commit() + assert sign_in(anon_client, "another").status_code == 429 + + +def test_concurrent_duplicate_creation(admin_client, db): + def create(_): + return admin_client.post("/admin/users", json={"login": "concurrent", "password": PASSWORD}).status_code + with ThreadPoolExecutor(max_workers=2) as pool: + assert sorted(pool.map(create, range(2))) == [201, 409] + assert db.execute(text("SELECT count(*) FROM users WHERE login='concurrent'")).scalar_one() == 1 + + +def test_concurrent_reset_and_block_preserve_both_changes(admin_client, account, db): + from app.models import User + user_id = account() + def reset(): + return admin_client.put(f"/admin/users/{user_id}/password", json={"password": "New password 456!"}).status_code + def block(): + return admin_client.put(f"/admin/users/{user_id}/status", json={"is_active": False}).status_code + with ThreadPoolExecutor(max_workers=2) as pool: + futures = [pool.submit(reset), pool.submit(block)] + assert [future.result() for future in futures] == [204, 200] + user = db.execute(select(User).where(User.id == user_id)).mappings().one() + assert not user["is_active"] and user["token_version"] == 2 + assert bcrypt.checkpw(b"New password 456!", user["password_hash"].encode()) + + +def test_admin_cli(monkeypatch, anon_client, db): + from app import create_admin + monkeypatch.setattr("builtins.input", lambda _: "Bootstrap.Admin") + monkeypatch.setattr(create_admin, "getpass", lambda _: PASSWORD) + create_admin.main() + login = sign_in(anon_client, "bootstrap.admin") + assert login.status_code == 200 and login.json()["user"]["role"] == "admin" + with pytest.raises(SystemExit, match="Логин уже занят"): + create_admin.main() + assert db.execute(text("SELECT count(*) FROM users")).scalar_one() == 1 diff --git a/docker-compose.yml b/docker-compose.yml index 26f1c6a..dd67d2f 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -25,7 +25,7 @@ services: build: ./backend <<: *app-env ports: - - "8000:8000" + - "${BACKEND_PORT:-8000}:8000" depends_on: db: condition: service_healthy @@ -76,7 +76,7 @@ services: frontend: build: ./frontend ports: - - "5173:80" + - "${FRONTEND_PORT:-5173}:80" depends_on: backend: condition: service_healthy diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx index 564e879..5202fe2 100644 --- a/frontend/src/App.tsx +++ b/frontend/src/App.tsx @@ -1,56 +1,71 @@ -import { Navigate, NavLink, Outlet, Route, Routes, useLocation } from "react-router-dom"; +import { useEffect, useState } from "react"; +import { Navigate, NavLink, Outlet, Route, Routes } from "react-router-dom"; +import { api } from "./api"; import { Alerts } from "./pages/Alerts"; import { AuthPage } from "./pages/Auth"; +import { Users } from "./pages/Users"; import { EquipmentCard } from "./pages/EquipmentCard"; import { EquipmentList } from "./pages/EquipmentList"; -import { setSession, useSession } from "./session"; +import { getToken, setSession, useSession } from "./session"; export function App() { const session = useSession(); + const token = session?.token; + const [verifiedToken, setVerifiedToken] = useState(null); + const [error, setError] = useState(""); + const [retry, setRetry] = useState(0); - return ( - <> -
- OFF-Tech - {session && ( - <> - -
- {session.email} - -
- - )} -
+ useEffect(() => { + let cancelled = false; + setError(""); + if (!token) { setVerifiedToken(null); return; } + // Check the stored session with the server before rendering protected pages. + api.me().then(user => { + if (cancelled || getToken() !== token) return; + setSession({ token, login: user.login, role: user.role }); + setVerifiedToken(token); + }).catch(() => { + if (!cancelled && getToken() === token) setError("Не удалось проверить сессию. Проверьте соединение с сервером."); + }); + return () => { cancelled = true; }; + }, [token, retry]); -
- - } /> - } /> - }> - } /> - } /> - } /> - Страница не найдена

} /> -
-
-
- - ); + if (token && verifiedToken !== token) return
+ {error ?
{error} +
+ :

Проверяем сессию…

} +
; + + return <> +
+ OFF-Tech + {session && <> + +
{session.login} + +
+ } +
+
+ + } /> + }> + } /> + } /> + } /> + : } /> + + Страница не найдена

} /> +
+
+ ; } function RequireAuth() { - const session = useSession(); - const location = useLocation(); - - if (!session) return ; - return ; + return useSession() ? : ; } diff --git a/frontend/src/api.ts b/frontend/src/api.ts index 6572e7a..aad576f 100644 --- a/frontend/src/api.ts +++ b/frontend/src/api.ts @@ -53,7 +53,13 @@ export interface Alert { export interface User { id: number; - email: string; + login: string; + role: "admin" | "employee"; + is_active: boolean; +} + +export interface ManagedUser extends User { + created_at: string; } export interface AuthResponse { @@ -87,10 +93,11 @@ async function request(path: string, init?: RequestInit): Promise { try { const body = await res.json(); if (typeof body.detail === "string") detail = body.detail; - else if (Array.isArray(body.detail)) detail = body.detail.map((d: { msg: string }) => d.msg).join("; "); + else if (Array.isArray(body.detail)) detail = body.detail.map((d: { msg: string }) => d.msg.replace(/^Value error, /, "")).join("; "); } catch {} throw new ApiError(res.status, detail); } + if (res.status === 204) return undefined as T; return res.json() as Promise; } @@ -106,7 +113,13 @@ export const api = { listAlerts: (limit = 100) => request(`/alerts?limit=${limit}`), alertsByEquipment: (id: number, limit = 50) => request(`/alerts/${id}?limit=${limit}`), predict: (id: number) => request("/predict", postJson({ equipment_id: id })), - login: (email: string, password: string) => request("/auth/login", postJson({ email, password })), - register: (email: string, password: string) => - request("/auth/register", postJson({ email, password })), + login: (login: string, password: string) => request("/auth/login", postJson({ login, password })), + me: () => request("/auth/me"), + listUsers: (offset = 0) => request(`/admin/users?limit=50&offset=${offset}`), + createUser: (login: string, password: string) => + request("/admin/users", postJson({ login, password })), + resetPassword: (id: number, password: string) => + request(`/admin/users/${id}/password`, { ...postJson({ password }), method: "PUT" }), + setUserActive: (id: number, is_active: boolean) => + request(`/admin/users/${id}/status`, { ...postJson({ is_active }), method: "PUT" }), }; diff --git a/frontend/src/components/PasswordField.tsx b/frontend/src/components/PasswordField.tsx new file mode 100644 index 0000000..a777a0a --- /dev/null +++ b/frontend/src/components/PasswordField.tsx @@ -0,0 +1,22 @@ +import { type InputHTMLAttributes, useId, useState } from "react"; + +type PasswordFieldProps = Omit, "type" | "id"> & { + label: string; +}; + +export function PasswordField({ label, ...inputProps }: PasswordFieldProps) { + const id = useId(); + const [visible, setVisible] = useState(false); + + return
+ +
+ + +
+
; +} diff --git a/frontend/src/index.css b/frontend/src/index.css index fd4a7fa..734501d 100644 --- a/frontend/src/index.css +++ b/frontend/src/index.css @@ -258,7 +258,7 @@ h2 { color: #d1d5db; font-size: 14px; } -.user-email { +.user-login { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; @@ -298,3 +298,37 @@ h2 { .auth .muted { text-align: center; } + +.account-form { max-width: 600px; margin: 20px 0; } +.account-form form, .account-form label { display: flex; flex-direction: column; gap: 8px; } +.account-form form { margin-top: 16px; gap: 16px; } +.account-form input { padding: 10px; border: 1px solid #d1d5db; border-radius: 6px; font: inherit; } +.account-form input:focus { outline: 2px solid #93c5fd; } +.actions { display: flex; gap: 8px; flex-wrap: wrap; align-items: center; } +.success { padding: 12px; color: #166534; background: #dcfce7; border-radius: 6px; } +.table-scroll { overflow-x: auto; margin-top: 20px; } +.pagination { margin-top: 16px; } +@media (max-width: 720px) { + .header { height: auto; min-height: 56px; flex-wrap: wrap; gap: 12px; padding: 12px; } + .header nav { flex-wrap: wrap; } + .main { padding: 16px; } + .page-head { gap: 12px; flex-wrap: wrap; } +} + +.password-field { display: flex; flex-direction: column; gap: 6px; } +.password-control { display: flex; align-items: stretch; gap: 8px; } +.password-control input { flex: 1; width: 0; min-width: 0; } +.password-toggle { + flex-shrink: 0; + padding: 8px 12px; + border: 1px solid #d1d5db; + border-radius: 6px; + background: #f9fafb; + color: #374151; + font: inherit; + font-size: 14px; + cursor: pointer; +} +.password-toggle:hover { background: #e5e7eb; } +.password-toggle:focus-visible { outline: 2px solid #2563eb; outline-offset: 2px; } +.password-toggle:disabled { opacity: 0.6; cursor: default; } diff --git a/frontend/src/pages/Auth.tsx b/frontend/src/pages/Auth.tsx index fc51e61..381c522 100644 --- a/frontend/src/pages/Auth.tsx +++ b/frontend/src/pages/Auth.tsx @@ -1,97 +1,42 @@ import { type FormEvent, useState } from "react"; -import { Link, Navigate, useLocation } from "react-router-dom"; +import { Navigate } from "react-router-dom"; import { ApiError, api } from "../api"; +import { PasswordField } from "../components/PasswordField"; import { setSession, useSession } from "../session"; -const PASSWORD_MIN = 8; -const PASSWORD_MAX_BYTES = 72; - -const MODES = { - login: { - title: "Вход", - submit: "Войти", - send: api.login, - other: { question: "Нет аккаунта?", link: "Зарегистрироваться", to: "/register" }, - }, - register: { - title: "Регистрация", - submit: "Зарегистрироваться", - send: api.register, - other: { question: "Уже есть аккаунт?", link: "Войти", to: "/login" }, - }, -}; - -export function AuthPage({ mode }: { mode: keyof typeof MODES }) { +export function AuthPage() { const session = useSession(); - const location = useLocation(); const [error, setError] = useState(null); const [busy, setBusy] = useState(false); - const page = MODES[mode]; - const register = mode === "register"; - if (session) { - const from = (location.state as { from?: string } | null)?.from ?? "/"; - return ; - } + if (session) return ; - async function onSubmit(e: FormEvent) { - e.preventDefault(); - const form = new FormData(e.currentTarget); - const email = String(form.get("email")); + async function onSubmit(event: FormEvent) { + event.preventDefault(); + const form = new FormData(event.currentTarget); + const login = String(form.get("login")); const password = String(form.get("password")); - if (register && password !== form.get("confirm")) return setError("Пароли не совпадают"); - if (register && new TextEncoder().encode(password).length > PASSWORD_MAX_BYTES) { - return setError(`Пароль слишком длинный: не больше ${PASSWORD_MAX_BYTES} байт`); - } - setBusy(true); setError(null); try { - const res = await page.send(email, password); - setSession({ token: res.access_token, email: res.user.email }); + const res = await api.login(login, password); + setSession({ token: res.access_token, login: res.user.login, role: res.user.role }); } catch (err) { setError(err instanceof ApiError ? err.detail : "Нет связи с сервером"); + } finally { setBusy(false); } } - return ( -
-

{page.title}

-
- - - {register && ( - - )} - {error &&

{error}

} - -
-

- {page.other.question}{" "} - - {page.other.link} - -

-
- ); + return
+

Вход

+
+ + + {error &&

{error}

} + + +

Для получения аккаунта или сброса пароля обратитесь к администратору.

+
; } diff --git a/frontend/src/pages/Users.tsx b/frontend/src/pages/Users.tsx new file mode 100644 index 0000000..d78c8e3 --- /dev/null +++ b/frontend/src/pages/Users.tsx @@ -0,0 +1,131 @@ +import { type FormEvent, useEffect, useState } from "react"; +import { api, ApiError, type ManagedUser } from "../api"; + +import { PasswordField } from "../components/PasswordField"; + +const PAGE_SIZE = 50; +const PASSWORD_HINT = "От 12 символов."; +function message(error: unknown) { + return error instanceof ApiError ? error.detail : "Нет связи с сервером"; +} + +export function Users() { + const [users, setUsers] = useState([]); + const [offset, setOffset] = useState(0); + const [loading, setLoading] = useState(true); + const [reload, setReload] = useState(0); + const [error, setError] = useState(""); + const [notice, setNotice] = useState(""); + const [busy, setBusy] = useState(false); + const [editing, setEditing] = useState(null); + const [statusTarget, setStatusTarget] = useState(null); + + useEffect(() => { + let cancelled = false; + setLoading(true); + setError(""); + api.listUsers(offset).then(rows => { if (!cancelled) setUsers(rows); }) + .catch(err => { if (!cancelled) setError(message(err)); }) + .finally(() => { if (!cancelled) setLoading(false); }); + return () => { cancelled = true; }; + }, [offset, reload]); + + async function save(event: FormEvent) { + event.preventDefault(); + const form = new FormData(event.currentTarget); + const password = String(form.get("password")); + if (password !== form.get("confirm")) { setError("Пароли не совпадают"); return; } + if (new TextEncoder().encode(password).length > 72) { + let bytes = 0; + let limit = 0; + for (const character of password) { + bytes += new TextEncoder().encode(character).length; + if (bytes > 72) break; + limit++; + } + setError(`Пароль слишком длинный. Сократите его до ${limit} символов.`); + return; + } + if (!editing) return; + setBusy(true); setError(""); setNotice(""); + try { + if (editing === "new") { + const user = await api.createUser(String(form.get("login")), password); + setNotice(`Пользователь ${user.login} создан.`); + } else { + await api.resetPassword(editing.id, password); + setNotice(`Пароль пользователя ${editing.login} изменён.`); + } + setEditing(null); // Unmount the form and discard password values. + setReload(n => n + 1); + } catch (err) { setError(message(err)); } + finally { setBusy(false); } + } + + async function changeStatus() { + if (!statusTarget) return; + setBusy(true); setError(""); setNotice(""); + try { + const user = await api.setUserActive(statusTarget.id, !statusTarget.is_active); + setNotice(user.is_active ? `Пользователь ${user.login} разблокирован.` + : `Пользователь ${user.login} заблокирован.`); + setStatusTarget(null); setReload(n => n + 1); + } catch (err) { setError(message(err)); } + finally { setBusy(false); } + } + + return <> +

Пользователи

+ +
+ {error &&

{error}

} + {notice &&

{notice}

} + {editing &&
+

{editing === "new" ? "Новый пользователь" : `Новый пароль: ${editing.login}`}

+
+ {editing === "new" && } + +

{PASSWORD_HINT}

+ + {editing !== "new" &&

После смены пароля пользователю потребуется войти заново.

} +
+
+ +
} + {statusTarget &&
+

{statusTarget.is_active ? "Заблокировать" : "Разблокировать"} {statusTarget.login}?

+

{statusTarget.is_active ? "Пользователь потеряет доступ к системе." + : "Пользователь снова сможет войти с текущим паролем."}

+
+
+
} + {loading ?

Загружаем пользователей…

: <> +
+ + {users.map(user => + + + + )} +
ЛогинРольСостояниеДействия
{user.login}{user.role === "admin" ? "Администратор" : "Пользователь"}{user.is_active ? "Активен" : "Заблокирован"}{user.role === "employee" ?
+ + +
: Управление через сервер}
+ {users.length === 0 &&

На этой странице нет аккаунтов.

} + } +
+ + Страница {offset / PAGE_SIZE + 1} + + +
+ ; +} diff --git a/frontend/src/session.ts b/frontend/src/session.ts index bd7fa76..8338730 100644 --- a/frontend/src/session.ts +++ b/frontend/src/session.ts @@ -2,7 +2,8 @@ import { useSyncExternalStore } from "react"; export interface Session { token: string; - email: string; + login: string; + role: "admin" | "employee"; } const KEY = "offtech.session"; @@ -11,7 +12,7 @@ const listeners = new Set<() => void>(); function read(): Session | null { try { const value = JSON.parse(localStorage.getItem(KEY) ?? "null"); - return typeof value?.token === "string" && typeof value?.email === "string" ? value : null; + return typeof value?.token === "string" && typeof value?.login === "string" && (value.role === "admin" || value.role === "employee") ? value : null; } catch { return null; } From 15b9f2b187aa273569c6d4c7914ac4925b80c204 Mon Sep 17 00:00:00 2001 From: mqudiee Date: Wed, 11 Nov 2026 03:37:48 +0300 Subject: [PATCH 3/3] ci: rerun checks with updated PR description