From 419c249411d84e9bdbee028dbd52b7fd1d859970 Mon Sep 17 00:00:00 2001 From: vasyukova Date: Fri, 6 Nov 2026 00:54:55 +0300 Subject: [PATCH] =?UTF-8?q?=D0=9E=D0=B1=D0=BD=D0=BE=D0=B2=D0=B8=D0=BB?= =?UTF-8?q?=D0=B0=20python-=D0=BA=D0=BE=D0=B4=20=D0=BE=D1=81=D0=BD=D0=BE?= =?UTF-8?q?=D0=B2=D0=BD=D0=BE=D0=B3=D0=BE=20=D0=BF=D1=80=D0=B8=D0=BB=D0=BE?= =?UTF-8?q?=D0=B6=D0=B5=D0=BD=D0=B8=D1=8F.=20=D0=A2=D0=B0=D0=BA=D0=B6?= =?UTF-8?q?=D0=B5=20=D0=BE=D0=B1=D0=BD=D0=BE=D0=B2=D0=B8=D0=BB=D0=B0=20col?= =?UTF-8?q?lector.yaml?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- infra/otel/collector.yaml | 8 +++++++ src/app/api/auth.py | 45 +++++++++++++++++++++++++++++++++++-- src/app/main.py | 22 ++++++++++++++++++ src/app/storage/postgres.py | 38 ++++++++++++++++++------------- src/app/telemetry.py | 27 +++++++++++++++++++--- 5 files changed, 120 insertions(+), 20 deletions(-) diff --git a/infra/otel/collector.yaml b/infra/otel/collector.yaml index 29810ad..491f5d9 100644 --- a/infra/otel/collector.yaml +++ b/infra/otel/collector.yaml @@ -3,8 +3,16 @@ receivers: protocols: http: endpoint: 0.0.0.0:4318 + tls: + cert_file: /certs/collector-server.crt + key_file: /certs/collector-server.key + client_ca_file: /certs/ca.crt grpc: endpoint: 0.0.0.0:4317 + tls: + cert_file: /certs/collector-server.crt + key_file: /certs/collector-server.key + client_ca_file: /certs/ca.crt processors: # Level-4: ограничение RAM и batch, чтобы не расти бесконечно при diff --git a/src/app/api/auth.py b/src/app/api/auth.py index 03c57a6..5fe2e56 100644 --- a/src/app/api/auth.py +++ b/src/app/api/auth.py @@ -1,9 +1,9 @@ import base64 import binascii import os +import time -from fastapi import APIRouter, Depends, HTTPException, Request -from fastapi.security import HTTPBasic, HTTPBasicCredentials +from fastapi import APIRouter, HTTPException, Request from ..models.schemas import Session from ..storage.postgres import storage @@ -13,6 +13,10 @@ router = APIRouter(prefix="/api/v1/auth", tags=["auth"]) DEFAULT_TTL_SECONDS = 3600 +# --- lab7: ограничение частоты входов (общее для реплик через Redis) --- +LOGIN_WINDOW_SECONDS = int(os.environ.get("LOGIN_WINDOW_SECONDS", "60")) +LOGIN_MAX_ATTEMPTS = int(os.environ.get("LOGIN_MAX_ATTEMPTS", "10")) + def _ttl_seconds() -> int: try: @@ -47,6 +51,42 @@ def _parse_basic_header(request: Request) -> tuple[str, str] | None: return username, password +def _login_rate_limit_key(request: Request) -> str: + """Ключ лимита: username + IP клиента (за LB — X-Forwarded-For).""" + parsed = _parse_basic_header(request) + username = parsed[0] if parsed else "-" + fwd = request.headers.get("X-Forwarded-For", "") + ip = fwd.split(",")[0].strip() if fwd else (request.client.host if request.client else "-") + return "loginrl:%s:%s" % (username, ip) + + +def _check_login_rate_limit(request: Request) -> None: + """Счётчик попыток в Redis. При превышении — 429 с Retry-After.""" + try: + from ..storage.sessions import _redis_client + r = _redis_client() + except RuntimeError: + # Redis недоступен — полагаемся на доступность БД; не блокируем вход. + return + key = _login_rate_limit_key(request) + try: + current = r.incr(key) + if current == 1: + r.expire(key, LOGIN_WINDOW_SECONDS) + if current > LOGIN_MAX_ATTEMPTS: + ttl = r.ttl(key) + raise HTTPException( + status_code=429, + detail="rate_limited", + headers={"Retry-After": str(max(1, int(ttl) if ttl and ttl > 0 else LOGIN_WINDOW_SECONDS))}, + ) + except HTTPException: + raise + except Exception: + # Ошибка Redis в счётчике не должна блокировать вход целиком. + return + + @router.post( path="/sessions", summary="Вход: Basic username:password; выдаёт сессию", @@ -54,6 +94,7 @@ def _parse_basic_header(request: Request) -> tuple[str, str] | None: status_code=201, ) def create_session(request: Request) -> Session: + _check_login_rate_limit(request) parsed = _parse_basic_header(request) if parsed is None: raise HTTPException(status_code=401, detail="unauthorized") diff --git a/src/app/main.py b/src/app/main.py index 6514053..f994bd0 100644 --- a/src/app/main.py +++ b/src/app/main.py @@ -24,6 +24,8 @@ from .telemetry import init_telemetry, INSTANCE_ID, meter, tracer logging.basicConfig(level=logging.INFO, stream=sys.stdout) logger = logging.getLogger("app") +MAX_REQUEST_BODY_BYTES = int(os.environ.get("MAX_REQUEST_BODY_BYTES", "10485760")) + @asynccontextmanager async def lifespan(app: FastAPI): @@ -113,6 +115,22 @@ async def observability_middleware(request: Request, call_next): started = time.monotonic() route = _route_template(request.url.path) + # lab7: раннее ограничение размера запроса (Content-Length). + cl = request.headers.get("content-length") + if cl is not None: + try: + if int(cl) > MAX_REQUEST_BODY_BYTES: + response = JSONResponse( + status_code=413, + content={"error": {"code": "payload_too_large", + "message": "payload_too_large", + "request_id": request_id}}, + headers={"X-Request-Id": request_id, "X-Instance-Id": INSTANCE_ID}, + ) + return response + except ValueError: + pass + # http.request — INTERNAL child текущего (SERVER) span, созданного OTel # auto-instrumentation. Parent берётся из активного контекста: входящий # traceparent уже извлечён ASGI middleware. @@ -258,6 +276,10 @@ if __name__ == "__main__": host="0.0.0.0", port=8080, log_level="info", + ssl_ca_certs=os.environ.get("TLS_CA_FILE"), + ssl_certfile=os.environ.get("TLS_CERT_FILE"), + ssl_keyfile=os.environ.get("TLS_KEY_FILE"), + ssl_cert_reqs=int(os.environ.get("MTLS_REQUIRE", "0")), # 2 = CERT_REQUIRED ) server = uvicorn.Server(config) diff --git a/src/app/storage/postgres.py b/src/app/storage/postgres.py index a36b768..1d03894 100644 --- a/src/app/storage/postgres.py +++ b/src/app/storage/postgres.py @@ -20,26 +20,22 @@ def now_utc() -> datetime: return datetime.now(timezone.utc) -# --- Password KDF (stdlib scrypt) --- -_SCRYPT_N = 2 ** 14 -_SCRYPT_R = 8 -_SCRYPT_P = 1 -_SCRYPT_DKLEN = 32 +# --- Password KDF (lab7: Argon2id, с rehash со старого scrypt) --- +from .passwords import hash_password as _argon_hash, verify_password as _argon_verify, needs_rehash as _argon_needs_rehash def _hash_password(password: str) -> str: - salt = secrets.token_bytes(16) - dk = hashlib.scrypt( - password.encode("utf-8"), - salt=salt, - n=_SCRYPT_N, r=_SCRYPT_R, p=_SCRYPT_P, dklen=_SCRYPT_DKLEN, - ) - return "scrypt$%d$%d$%d$%s$%s" % ( - _SCRYPT_N, _SCRYPT_R, _SCRYPT_P, salt.hex(), dk.hex(), - ) + """Новый пароль хранится только как Argon2id encoded-hash.""" + return _argon_hash(password) def _verify_password(password: str, stored: str) -> bool: + """Проверяет Argon2id; старый scrypt-хэш тоже принимается (для rehash).""" + if not stored: + return False + if stored.startswith("$argon2id$"): + return _argon_verify(password, stored) + # Совместимость с ранее сохранёнными scrypt-хэшами (одноразово). try: scheme, n, r, p, salt_hex, dk_hex = stored.split("$") if scheme != "scrypt": @@ -142,8 +138,20 @@ class PostgresStorage: row = cur.fetchone() if row is None: return None - if not _verify_password(password, row[4]): + stored = row[4] + if not _verify_password(password, stored): return None + # lab7: rehash старого/устаревшего хэша при успешном входе. + if not stored.startswith("$argon2id$") or _argon_needs_rehash(stored): + try: + cur.execute( + "UPDATE users SET password_hash = %s WHERE id = %s", + (_argon_hash(password), row[0]), + ) + conn.commit() + except Exception: + # Rehash не должен ломать успешный вход. + conn.rollback() return _row_to_user(row[:4]) # ---------- Сессии ---------- diff --git a/src/app/telemetry.py b/src/app/telemetry.py index 01efa89..f8d3ed5 100644 --- a/src/app/telemetry.py +++ b/src/app/telemetry.py @@ -43,9 +43,26 @@ def _resource(service_name: str, service_version: str) -> Resource: ) +def _otel_cert_kwargs() -> dict: + """mTLS к Collector (lab7): server CA + client identity (api/worker).""" + kwargs = {} + server_ca = os.environ.get("OTEL_EXPORTER_OTLP_CERTIFICATE", "/certs/ca.crt") + client_cert = os.environ.get("OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE", "") + client_key = os.environ.get("OTEL_EXPORTER_OTLP_CLIENT_KEY", "") + if server_ca and os.path.exists(server_ca): + kwargs["certificate_file"] = server_ca + if client_cert and os.path.exists(client_cert): + kwargs["client_certificate_file"] = client_cert + if client_key and os.path.exists(client_key): + kwargs["client_key_file"] = client_key + return kwargs + + def _build_trace_provider(resource: Resource) -> TracerProvider: provider = TracerProvider(resource=resource) - exporter = OTLPSpanExporter(endpoint=_endpoint() + "/v1/traces", timeout=5) + exporter = OTLPSpanExporter( + endpoint=_endpoint() + "/v1/traces", timeout=5, **_otel_cert_kwargs() + ) provider.add_span_processor( BatchSpanProcessor(exporter, max_queue_size=2048, max_export_batch_size=512, @@ -56,7 +73,9 @@ def _build_trace_provider(resource: Resource) -> TracerProvider: def _build_meter_provider(resource: Resource) -> MeterProvider: reader = PeriodicExportingMetricReader( - OTLPMetricExporter(endpoint=_endpoint() + "/v1/metrics", timeout=5), + OTLPMetricExporter( + endpoint=_endpoint() + "/v1/metrics", timeout=5, **_otel_cert_kwargs() + ), export_interval_millis=5000, ) return MeterProvider(resource=resource, metric_readers=[reader]) @@ -66,7 +85,9 @@ def _build_logger_provider(resource: Resource) -> LoggerProvider: provider = LoggerProvider(resource=resource) provider.add_log_record_processor( BatchLogRecordProcessor( - OTLPLogExporter(endpoint=_endpoint() + "/v1/logs", timeout=5), + OTLPLogExporter( + endpoint=_endpoint() + "/v1/logs", timeout=5, **_otel_cert_kwargs() + ), max_queue_size=2048, max_export_batch_size=512, schedule_delay_millis=2000,