From 15f5523f9bfa585cf92f3958525cb5637affece7 Mon Sep 17 00:00:00 2001 From: Aleksandr Meshchryakov Date: Thu, 24 Sep 2026 13:59:55 +0200 Subject: [PATCH] Complete SSO role mapping and offline StateCorp release tooling --- .dockerignore | 16 +++ .env.example | 2 + README.md | 4 + deploy/offline/.gitignore | 6 + deploy/offline/README.md | 29 ++++ deploy/offline/build-release.sh | 84 ++++++++++++ deploy/offline/compose.yml | 125 ++++++++++++++++++ deploy/offline/env.example | 29 ++++ deploy/offline/install.sh | 70 ++++++++++ .../0010_sso_claims_and_role_management.py | 43 ++++++ src/apps/user/models.py | 9 ++ src/apps/user/sso_services.py | 94 ++++++++++++- src/settings/base.py | 4 + tests/apps/user/test_sso.py | 75 +++++++++++ 14 files changed, 589 insertions(+), 1 deletion(-) create mode 100644 .dockerignore create mode 100644 deploy/offline/.gitignore create mode 100644 deploy/offline/README.md create mode 100755 deploy/offline/build-release.sh create mode 100644 deploy/offline/compose.yml create mode 100644 deploy/offline/env.example create mode 100755 deploy/offline/install.sh create mode 100644 src/apps/user/migrations/0010_sso_claims_and_role_management.py diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000..d58b3d6 --- /dev/null +++ b/.dockerignore @@ -0,0 +1,16 @@ +.git +.venv +.env +.env.* +**/.env +**/.env.* +**/secrets +**/*.pem +**/*.key +media +staticfiles +logs +data +deploy/offline/images +deploy/offline/secrets +tests diff --git a/.env.example b/.env.example index 75071ac..5b2c7b9 100644 --- a/.env.example +++ b/.env.example @@ -32,3 +32,5 @@ SSO_SERVICE_CODE=fkc SSO_ISSUER=dvr SSO_PUBLIC_KEY_PATH= SSO_SESSION_TTL_SECONDS=7200 +SSO_GROUP_ROLE_MAP_JSON={} +SSO_MANAGE_LINKED_USER_ROLES=false diff --git a/README.md b/README.md index b2dea39..e5ed32a 100644 --- a/README.md +++ b/README.md @@ -254,3 +254,7 @@ make pre-commit Дополнительный SSO-вход включается переменной `SSO_ENABLED=true`. Публичный P-256 PEM-ключ провайдера должен быть смонтирован вне репозитория и webroot, а путь к нему передан в `SSO_PUBLIC_KEY_PATH`. Используются настройки `SSO_PROVIDER_URL`, `SSO_SERVICE_CODE` (по умолчанию `fkc`), `SSO_ISSUER` (по умолчанию `dvr`) и `SSO_SESSION_TTL_SECONDS` (по умолчанию `7200`). Перед включением зарегистрируйте callback `https:///api/v1/auth/sso/` в ИАС ЕЦП и сначала включите backend, затем frontend-кнопку. Для отката достаточно установить `SSO_ENABLED=false`; JWT-вход продолжит работать. + +`SSO_GROUP_ROLE_MAP_JSON` — JSON-объект с именами доверенных групп ИАС ЕЦП в ключах и значениями только `user` или `admin`, например `{"ias_admin":"admin"}`. Группы вне этого списка не дают повышенных прав. Созданный через SSO пользователь без группы из списка получает `user`; при последующем входе исчезнувшая admin-группа понижает его до `user`. У ранее существовавшей локальной учётной записи ручная роль сохраняется. Только явная настройка `SSO_MANAGE_LINKED_USER_ROLES=true` передаёт управление её ролью SSO. Нормализованные группы, ОКПО, тип пользователя и организация сохраняются в `SsoIdentity`, исходный JWT не сохраняется. + +Публичный PEM следует монтировать в контейнер как отдельный read-only файл и указывать его контейнерный путь в `SSO_PUBLIC_KEY_PATH`. Не размещайте PEM, реальные `.env` и токены обмена в webroot или offline-архиве. Полностью изолированная установка описана в [deploy/offline/README.md](deploy/offline/README.md). diff --git a/deploy/offline/.gitignore b/deploy/offline/.gitignore new file mode 100644 index 0000000..025c447 --- /dev/null +++ b/deploy/offline/.gitignore @@ -0,0 +1,6 @@ +release/ +.env +secrets/ +data/ +media/ +staticfiles/ diff --git a/deploy/offline/README.md b/deploy/offline/README.md new file mode 100644 index 0000000..aca430f --- /dev/null +++ b/deploy/offline/README.md @@ -0,0 +1,29 @@ +# StateCorp isolated installation + +`build-release.sh FRONTEND_CHECKOUT RELEASE_DIRECTORY RELEASE_ID` builds five +`linux/amd64` OCI image archives and an immutable release manifest. Run it on a +connected build host with Docker Buildx and `jq`; the target host needs only Docker +and Compose. The release directory can be transported as a tar archive. It contains +no database, media, private key, shared exchange token, or populated `.env`. + +On the isolated host, unpack the release, run `./install.sh install` once to create +`.env`, set strong local credentials and host names there, then run it again. Supply +the IAS ECP public PEM separately at `secrets/sso-public.pem`; only enable SSO after +validating the callback and `SSO_GROUP_ROLE_MAP_JSON` allowlist. The PEM is mounted +read-only at `/run/secrets/sso_public_key` and is not stored in the archive. + +`./install.sh health` checks Compose state and the backend readiness endpoint. +For an upgrade, retain a verified database backup separately and replace only +the release files (`compose.yml`, `env.example`, `install.sh`, `README.md`, +`release-manifest.json`, `SHA256SUMS`, and `images/`) **in the existing installation +directory**. Do not replace `.env` or `secrets/`, and do not remove the +Compose-managed database, Redis, media, or staticfiles volumes. +Then run `./install.sh upgrade`; it preserves local credentials and switches image +pins to the new release. `rollback` +reselects previous image names from `.env.previous` only; it does not reverse schema +migrations or restore a database. A full rollback requires the separate backup. + +The initial database is empty and migrations run before web/worker/Beat/frontend. +Import business data later through the encrypted exchange CLI/API; never place the +exchange package or its token inside this release. All services set +`pull_policy: never`, so installation cannot silently contact a registry. diff --git a/deploy/offline/build-release.sh b/deploy/offline/build-release.sh new file mode 100755 index 0000000..a312b0c --- /dev/null +++ b/deploy/offline/build-release.sh @@ -0,0 +1,84 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Usage: build-release.sh FRONTEND_CHECKOUT RELEASE_DIRECTORY RELEASE_ID +# The output directory must not exist and should be outside all source trees. +backend_root=$(cd "$(dirname "$0")/../.." && pwd) +frontend_root=$(cd "${1:?frontend checkout required}" && pwd) +release_dir=${2:?release directory required} +release_id=${3:?release id required} +case "$release_id" in + *[!a-zA-Z0-9._-]*|'') echo 'Invalid release id' >&2; exit 2 ;; +esac +if [[ -e "$release_dir" ]]; then + echo 'Release directory already exists; refusing to overwrite it' >&2 + exit 2 +fi +mkdir -p "$release_dir/images" +release_dir=$(cd "$release_dir" && pwd) + +web_image="ecos-state-corp-web:$release_id" +worker_image="ecos-state-corp-worker:$release_id" +frontend_image="ecos-state-corp-frontend:$release_id" +postgres_image="ecos-offline-postgres:$release_id" +redis_image="ecos-offline-redis:$release_id" + +docker buildx build --platform linux/amd64 --target runtime-web \ + -f "$backend_root/docker/Dockerfile" -t "$web_image" \ + --output "type=oci,dest=$release_dir/images/web.tar" "$backend_root" +docker buildx build --platform linux/amd64 --target runtime-celery \ + -f "$backend_root/docker/Dockerfile" -t "$worker_image" \ + --output "type=oci,dest=$release_dir/images/worker.tar" "$backend_root" +docker buildx build --platform linux/amd64 -f "$frontend_root/Dockerfile" \ + -t "$frontend_image" --output "type=oci,dest=$release_dir/images/frontend.tar" \ + "$frontend_root" + +# Resolve the upstream multi-arch tags once, then build the amd64 variant from +# the immutable manifest digest. The release records both upstream digests. +postgres_digest=$(docker buildx imagetools inspect postgres:15.10 --format '{{.Manifest.Digest}}') +redis_digest=$(docker buildx imagetools inspect redis:7.4.2-alpine --format '{{.Manifest.Digest}}') +printf 'FROM postgres@%s\n' "$postgres_digest" | docker buildx build \ + --platform linux/amd64 -f - -t "$postgres_image" \ + --output "type=oci,dest=$release_dir/images/postgres.tar" "$backend_root/deploy/offline" +printf 'FROM redis@%s\n' "$redis_digest" | docker buildx build \ + --platform linux/amd64 -f - -t "$redis_image" \ + --output "type=oci,dest=$release_dir/images/redis.tar" "$backend_root/deploy/offline" + +cp "$backend_root/deploy/offline/compose.yml" "$release_dir/compose.yml" +cp "$backend_root/deploy/offline/env.example" "$release_dir/env.example" +cp "$backend_root/deploy/offline/install.sh" "$release_dir/install.sh" +cp "$backend_root/deploy/offline/README.md" "$release_dir/README.md" +chmod +x "$release_dir/install.sh" +sed -i.bak \ + -e "s|ecos-state-corp-web:RELEASE|$web_image|" \ + -e "s|ecos-state-corp-worker:RELEASE|$worker_image|" \ + -e "s|ecos-state-corp-frontend:RELEASE|$frontend_image|" \ + -e "s|postgres:15.10|$postgres_image|" \ + -e "s|redis:7.4.2-alpine|$redis_image|" \ + "$release_dir/env.example" +rm "$release_dir/env.example.bak" + +archive_digest() { + tar -xOf "$1" index.json | jq -r '.manifests[0].digest' +} +jq -n \ + --arg release "$release_id" \ + --arg backend_commit "$(git -C "$backend_root" rev-parse HEAD)" \ + --arg frontend_commit "$(git -C "$frontend_root" rev-parse HEAD)" \ + --arg postgres_upstream "$postgres_digest" \ + --arg redis_upstream "$redis_digest" \ + --arg web "$(archive_digest "$release_dir/images/web.tar")" \ + --arg worker "$(archive_digest "$release_dir/images/worker.tar")" \ + --arg frontend "$(archive_digest "$release_dir/images/frontend.tar")" \ + --arg postgres "$(archive_digest "$release_dir/images/postgres.tar")" \ + --arg redis "$(archive_digest "$release_dir/images/redis.tar")" \ + '{release_id:$release, platform:"linux/amd64", backend_commit:$backend_commit, + frontend_commit:$frontend_commit, + upstream:{postgres:$postgres_upstream,redis:$redis_upstream}, + images:{web:$web,worker:$worker,frontend:$frontend,postgres:$postgres,redis:$redis}}' \ + > "$release_dir/release-manifest.json" +( + cd "$release_dir" + sha256sum compose.yml env.example install.sh README.md release-manifest.json images/*.tar > SHA256SUMS +) +echo "Release ready: $release_dir" diff --git a/deploy/offline/compose.yml b/deploy/offline/compose.yml new file mode 100644 index 0000000..3977086 --- /dev/null +++ b/deploy/offline/compose.yml @@ -0,0 +1,125 @@ +services: + db: + image: ${POSTGRES_IMAGE:?} + pull_policy: never + restart: unless-stopped + environment: + POSTGRES_DB: ${POSTGRES_DB:?} + POSTGRES_USER: ${POSTGRES_USER:?} + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?} + volumes: + - postgres_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:?} -d ${POSTGRES_DB:?}"] + interval: 10s + timeout: 5s + retries: 12 + redis: + image: ${REDIS_IMAGE:?} + pull_policy: never + restart: unless-stopped + command: ["redis-server", "--appendonly", "yes"] + volumes: + - redis_data:/data + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 10s + timeout: 5s + retries: 12 + migrate: + image: ${STATE_WEB_IMAGE:?} + pull_policy: never + env_file: + - path: .env + required: false + environment: + RUN_MIGRATIONS: "1" + COLLECTSTATIC_ON_MIGRATE: "1" + volumes: + - media:/app/media + - staticfiles:/app/staticfiles + secrets: + - sso_public_key + depends_on: + db: + condition: service_healthy + redis: + condition: service_healthy + command: ["migrate"] + restart: "no" + web: + image: ${STATE_WEB_IMAGE:?} + pull_policy: never + restart: unless-stopped + env_file: + - path: .env + required: false + environment: + RUN_MIGRATIONS: "0" + volumes: + - media:/app/media + - staticfiles:/app/staticfiles + secrets: + - sso_public_key + depends_on: + migrate: + condition: service_completed_successfully + healthcheck: + test: ["CMD", "curl", "-fsS", "http://localhost:8000/health/ready/"] + interval: 10s + timeout: 5s + retries: 12 + worker: + image: ${STATE_WORKER_IMAGE:?} + pull_policy: never + restart: unless-stopped + env_file: + - path: .env + required: false + environment: + RUN_MIGRATIONS: "0" + CELERY_WORKER_CONCURRENCY: "1" + volumes: + - media:/app/media + secrets: + - sso_public_key + depends_on: + web: + condition: service_healthy + command: ["celery-worker"] + beat: + image: ${STATE_WORKER_IMAGE:?} + pull_policy: never + restart: unless-stopped + env_file: + - path: .env + required: false + environment: + RUN_MIGRATIONS: "0" + secrets: + - sso_public_key + depends_on: + web: + condition: service_healthy + command: ["celery-beat"] + frontend: + image: ${STATE_FRONTEND_IMAGE:?} + pull_policy: never + restart: unless-stopped + environment: + BACKEND_UPSTREAM: web:8000 + SSO_ENABLED: ${SSO_ENABLED:-false} + SSO_AUTO_REDIRECT: ${SSO_AUTO_REDIRECT:-false} + ports: + - "${STATE_FRONTEND_PORT:-8080}:80" + depends_on: + web: + condition: service_healthy +secrets: + sso_public_key: + file: ./secrets/sso-public.pem +volumes: + postgres_data: + redis_data: + media: + staticfiles: diff --git a/deploy/offline/env.example b/deploy/offline/env.example new file mode 100644 index 0000000..93832d6 --- /dev/null +++ b/deploy/offline/env.example @@ -0,0 +1,29 @@ +# Copy to .env on the isolated host. Never put this file with actual values in a release archive. +STATE_WEB_IMAGE=ecos-state-corp-web:RELEASE +STATE_WORKER_IMAGE=ecos-state-corp-worker:RELEASE +STATE_FRONTEND_IMAGE=ecos-state-corp-frontend:RELEASE +POSTGRES_IMAGE=postgres:15.10 +REDIS_IMAGE=redis:7.4.2-alpine +POSTGRES_DB=state_corp +POSTGRES_USER=state_corp +POSTGRES_PASSWORD=CHANGE_ME +SECRET_KEY=CHANGE_ME +ALLOWED_HOSTS=localhost +BACKEND_UPSTREAM=web:8000 +DJANGO_SETTINGS_MODULE=settings.production +POSTGRES_HOST=db +POSTGRES_PORT=5432 +POSTGRES_SSLMODE=disable +REDIS_URL=redis://redis:6379/0 +REDIS_CACHE_URL=redis://redis:6379/1 +CELERY_BROKER_URL=redis://redis:6379/0 +CELERY_RESULT_BACKEND=redis://redis:6379/0 +SECURE_SSL_REDIRECT=false +SSO_ENABLED=false +SSO_AUTO_REDIRECT=false +SSO_PROVIDER_URL=https://divopk.vniicentr.ru/sso-redirect/ +SSO_SERVICE_CODE=fkc +SSO_ISSUER=dvr +SSO_PUBLIC_KEY_PATH=/run/secrets/sso_public_key +SSO_GROUP_ROLE_MAP_JSON={} +SSO_MANAGE_LINKED_USER_ROLES=false diff --git a/deploy/offline/install.sh b/deploy/offline/install.sh new file mode 100755 index 0000000..1a8ba87 --- /dev/null +++ b/deploy/offline/install.sh @@ -0,0 +1,70 @@ +#!/usr/bin/env bash +set -euo pipefail + +cd "$(dirname "$0")" +action=${1:-install} +case "$action" in + install|upgrade|rollback|health) ;; + *) echo 'Usage: install.sh {install|upgrade|rollback|health}' >&2; exit 2 ;; +esac + +if [[ "$action" == health ]]; then + docker compose --env-file .env -f compose.yml ps + docker compose --env-file .env -f compose.yml exec -T web \ + curl -fsS http://localhost:8000/health/ready/ + exit 0 +fi + +if [[ "$action" == rollback ]]; then + if [[ ! -f .env.previous ]]; then + echo 'No previous local image configuration available' >&2 + exit 2 + fi + cp .env.previous .env + chmod 600 .env + docker compose --env-file .env -f compose.yml up -d --wait + echo 'Image rollback complete. Database schema was not reversed.' + exit 0 +fi + +sha256sum -c SHA256SUMS +if [[ ! -f .env ]]; then + cp env.example .env + chmod 600 .env + echo 'Edit .env with unique local credentials, then rerun install.sh' >&2 + exit 2 +fi +if grep -q CHANGE_ME .env; then + echo 'Replace all CHANGE_ME values in .env before installation' >&2 + exit 2 +fi +if [[ "$action" == upgrade ]]; then + cp .env .env.previous + chmod 600 .env.previous + # Keep local credentials and volumes, but select the images in this release. + for key in STATE_WEB_IMAGE STATE_WORKER_IMAGE STATE_FRONTEND_IMAGE POSTGRES_IMAGE REDIS_IMAGE; do + image=$(sed -n "s/^${key}=//p" env.example | head -n 1) + if [[ -z "$image" ]] || ! grep -q "^${key}=" .env; then + echo "Missing image pin: $key" >&2 + exit 2 + fi + env_temp=$(mktemp .env.XXXXXX) + sed "s|^${key}=.*|${key}=${image}|" .env > "$env_temp" + chmod 600 "$env_temp" + mv "$env_temp" .env + done +fi +mkdir -p secrets +if [[ ! -e secrets/sso-public.pem ]]; then + : > secrets/sso-public.pem +fi +if grep -qi '^SSO_ENABLED=true$' .env && [[ ! -s secrets/sso-public.pem ]]; then + echo 'SSO requires a real public PEM in secrets/sso-public.pem' >&2 + exit 2 +fi +for archive in images/*.tar; do + docker load -i "$archive" +done +docker compose --env-file .env -f compose.yml config -q +docker compose --env-file .env -f compose.yml up -d --wait +"$0" health diff --git a/src/apps/user/migrations/0010_sso_claims_and_role_management.py b/src/apps/user/migrations/0010_sso_claims_and_role_management.py new file mode 100644 index 0000000..de3c830 --- /dev/null +++ b/src/apps/user/migrations/0010_sso_claims_and_role_management.py @@ -0,0 +1,43 @@ +from django.db import migrations, models + + +class Migration(migrations.Migration): + dependencies = [("user", "0009_ssoidentity")] + + operations = [ + migrations.AddField( + model_name="ssoidentity", + name="external_groups", + field=models.JSONField(default=list, verbose_name="external groups"), + ), + migrations.AddField( + model_name="ssoidentity", + name="okpo", + field=models.CharField(blank=True, max_length=32, verbose_name="OKPO"), + ), + migrations.AddField( + model_name="ssoidentity", + name="user_type_code", + field=models.CharField(blank=True, max_length=64, verbose_name="user type code"), + ), + migrations.AddField( + model_name="ssoidentity", + name="default_organisation", + field=models.JSONField(blank=True, null=True, verbose_name="default organisation"), + ), + migrations.AddField( + model_name="ssoidentity", + name="is_integrated_structure", + field=models.BooleanField(default=False), + ), + migrations.AddField( + model_name="ssoidentity", + name="ex_loop", + field=models.BooleanField(default=False), + ), + migrations.AddField( + model_name="ssoidentity", + name="role_managed_by_sso", + field=models.BooleanField(default=False), + ), + ] diff --git a/src/apps/user/models.py b/src/apps/user/models.py index b1aead9..ef4cc8b 100644 --- a/src/apps/user/models.py +++ b/src/apps/user/models.py @@ -122,6 +122,15 @@ class SsoIdentity(models.Model): ) issuer = models.CharField(_("issuer"), max_length=64) subject = models.CharField(_("external user id"), max_length=255) + external_groups = models.JSONField(_("external groups"), default=list) + okpo = models.CharField(_("OKPO"), max_length=32, blank=True) + user_type_code = models.CharField(_("user type code"), max_length=64, blank=True) + default_organisation = models.JSONField( + _("default organisation"), null=True, blank=True + ) + is_integrated_structure = models.BooleanField(default=False) + ex_loop = models.BooleanField(default=False) + role_managed_by_sso = models.BooleanField(default=False) last_authenticated_at = models.DateTimeField(_("last authenticated at")) created_at = models.DateTimeField(_("created at"), auto_now_add=True) updated_at = models.DateTimeField(_("updated at"), auto_now=True) diff --git a/src/apps/user/sso_services.py b/src/apps/user/sso_services.py index 8fde12f..0201ede 100644 --- a/src/apps/user/sso_services.py +++ b/src/apps/user/sso_services.py @@ -1,4 +1,5 @@ import hashlib +import json from dataclasses import dataclass from datetime import UTC, datetime from pathlib import Path @@ -17,6 +18,7 @@ from django.utils import timezone from jwt import InvalidTokenError from .models import SsoIdentity +from .services import UserService User = get_user_model() @@ -36,6 +38,50 @@ class SsoClaims: last_name: str jti: str expires_at: int + groups: tuple[str, ...] + okpo: str + user_type_code: str + default_organisation: str | dict | None + is_integrated_structure: bool + ex_loop: bool + + +def _optional_text(payload: dict, key: str, *, max_length: int) -> str: + value = payload.get(key) + if value is None: + return "" + if not isinstance(value, str) or len(value) > max_length: + raise SsoAuthenticationError("Некорректные данные SSO-пользователя.") + return value.strip() + + +def _optional_boolean(payload: dict, key: str) -> bool: + value = payload.get(key) + if value is None: + return False + if not isinstance(value, bool): + raise SsoAuthenticationError("Некорректные данные SSO-пользователя.") + return value + + +def _role_for_groups(groups: tuple[str, ...]) -> str: + try: + mapping = json.loads(settings.SSO_GROUP_ROLE_MAP_JSON) + except (TypeError, ValueError) as exc: + raise SsoAuthenticationError("Некорректная конфигурация ролей SSO.") from exc + if not isinstance(mapping, dict) or any( + not isinstance(group, str) + or not group.strip() + or role not in (UserService.ROLE_USER, UserService.ROLE_ADMIN) + for group, role in mapping.items() + ): + raise SsoAuthenticationError("Некорректная конфигурация ролей SSO.") + mapped = {mapping[group] for group in groups if group in mapping} + return ( + UserService.ROLE_ADMIN + if UserService.ROLE_ADMIN in mapped + else UserService.ROLE_USER + ) def _load_public_key(): @@ -102,6 +148,27 @@ def _validate_token_lifetime(payload: dict) -> tuple[int, int]: return issued_at, expires_at +def _normalized_groups(payload: dict) -> tuple[str, ...]: + groups = payload.get("groups", []) + if not isinstance(groups, list) or len(groups) > 100 or any( + not isinstance(group, str) or not group.strip() or len(group) > 255 + for group in groups + ): + raise SsoAuthenticationError("Некорректные группы SSO-пользователя.") + return tuple(dict.fromkeys(group.strip() for group in groups)) + + +def _default_organisation(payload: dict) -> str | dict | None: + organisation = payload.get("default_organisation") + if organisation is not None and not isinstance(organisation, str | dict): + raise SsoAuthenticationError("Некорректная организация SSO-пользователя.") + if isinstance(organisation, str) and len(organisation) > 255: + raise SsoAuthenticationError("Некорректная организация SSO-пользователя.") + if isinstance(organisation, dict) and len(json.dumps(organisation)) > 4096: + raise SsoAuthenticationError("Некорректная организация SSO-пользователя.") + return organisation + + def verify_sso_token(encoded_token: str) -> SsoClaims: """Проверяет ES256 SSO JWT и возвращает только нужные локальному сервису claims.""" payload = _decode_sso_payload(encoded_token) @@ -146,6 +213,12 @@ def verify_sso_token(encoded_token: str) -> SsoClaims: last_name=str(payload.get("last_name") or ""), jti=jti, expires_at=expires_at, + groups=_normalized_groups(payload), + okpo=_optional_text(payload, "okpo", max_length=32), + user_type_code=_optional_text(payload, "user_type_code", max_length=64), + default_organisation=_default_organisation(payload), + is_integrated_structure=_optional_boolean(payload, "is_integrated_structure"), + ex_loop=_optional_boolean(payload, "ex_loop"), ) @@ -179,6 +252,7 @@ def provision_sso_user(claims: SsoClaims): .first() ) + is_new_user = False if identity is not None: user = identity.user if not user.is_active: @@ -203,12 +277,14 @@ def provision_sso_user(claims: SsoClaims): user = User(username=claims.username, email=claims.email, is_verified=True) user.set_unusable_password() user.save() + is_new_user = True identity = SsoIdentity.objects.create( user=user, issuer=claims.issuer, subject=claims.subject, last_authenticated_at=timezone.now(), + role_managed_by_sso=is_new_user or settings.SSO_MANAGE_LINKED_USER_ROLES, ) user.username = claims.username @@ -221,5 +297,21 @@ def provision_sso_user(claims: SsoClaims): profile.last_name = claims.last_name profile.save(update_fields=["first_name", "mid_name", "last_name", "updated_at"]) identity.last_authenticated_at = timezone.now() - identity.save(update_fields=["last_authenticated_at", "updated_at"]) + identity.external_groups = list(claims.groups) + identity.okpo = claims.okpo + identity.user_type_code = claims.user_type_code + identity.default_organisation = claims.default_organisation + identity.is_integrated_structure = claims.is_integrated_structure + identity.ex_loop = claims.ex_loop + if settings.SSO_MANAGE_LINKED_USER_ROLES: + identity.role_managed_by_sso = True + identity.save( + update_fields=[ + "last_authenticated_at", "external_groups", "okpo", "user_type_code", + "default_organisation", "is_integrated_structure", "ex_loop", + "role_managed_by_sso", "updated_at", + ] + ) + if identity.role_managed_by_sso: + UserService.assign_role(user, _role_for_groups(claims.groups)) return user diff --git a/src/settings/base.py b/src/settings/base.py index 7f524fb..b9a5169 100644 --- a/src/settings/base.py +++ b/src/settings/base.py @@ -33,6 +33,10 @@ SSO_PUBLIC_KEY_PATH = os.getenv("SSO_PUBLIC_KEY_PATH", "") SSO_SESSION_TTL_SECONDS = int(os.getenv("SSO_SESSION_TTL_SECONDS", "7200")) SSO_TOKEN_MAX_AGE_SECONDS = 60 SSO_CLOCK_SKEW_SECONDS = 5 +SSO_GROUP_ROLE_MAP_JSON = os.getenv("SSO_GROUP_ROLE_MAP_JSON", "{}") +SSO_MANAGE_LINKED_USER_ROLES = ( + os.getenv("SSO_MANAGE_LINKED_USER_ROLES", "false").strip().lower() == "true" +) warnings.filterwarnings( "ignore", diff --git a/tests/apps/user/test_sso.py b/tests/apps/user/test_sso.py index 1c560d8..58c0f4f 100644 --- a/tests/apps/user/test_sso.py +++ b/tests/apps/user/test_sso.py @@ -4,6 +4,7 @@ from datetime import UTC, datetime, timedelta from urllib.parse import parse_qs, urlencode, urlsplit import jwt +from apps.user.services import UserService from cryptography.hazmat.primitives import serialization from cryptography.hazmat.primitives.asymmetric import ec from django.apps import apps @@ -135,6 +136,8 @@ class SsoCallbackViewTest(APITestCase): identity = identity_model.objects.get(user=user) self.assertEqual(identity.issuer, "dvr") self.assertEqual(identity.subject, "2564") + self.assertEqual(identity.external_groups, ["Аналитика"]) + self.assertEqual(identity.okpo, "07508753") self.assertIn("sessionid", response.cookies) self.assertIn("csrftoken", response.cookies) self.assertTrue(response.cookies["sessionid"]["secure"]) @@ -152,6 +155,78 @@ class SsoCallbackViewTest(APITestCase): self.assertEqual(current_user_response.status_code, 200) self.assertEqual(current_user_response.data["username"], "test30") + @override_settings(SSO_GROUP_ROLE_MAP_JSON='{"GK-admin":"admin"}') + def test_new_sso_user_gets_mapped_role_and_loses_it_when_group_disappears(self): + first = self._post_callback( + self._token(groups=["GK-admin", "Аналитика"], jti="admin-first") + ) + user = User.objects.get(username="test30") + self.assertEqual(first.status_code, 303) + self.assertEqual(UserService.get_user_role(user), "admin") + + second = self._post_callback( + self._token(groups=["Аналитика"], jti="admin-second") + ) + user.refresh_from_db() + self.assertEqual(second.status_code, 303) + self.assertEqual(UserService.get_user_role(user), "user") + self.assertEqual(user.sso_identity.external_groups, ["Аналитика"]) + + @override_settings(SSO_GROUP_ROLE_MAP_JSON='{"GK-admin":"admin"}') + def test_linked_local_admin_keeps_manual_role_by_default(self): + user = UserFactory.create_user( + username="test30", email="test30@example.com", is_staff=True + ) + response = self._post_callback(self._token(groups=[], jti="linked-admin")) + user.refresh_from_db() + self.assertEqual(response.status_code, 303) + self.assertEqual(UserService.get_user_role(user), "admin") + self.assertFalse(user.sso_identity.role_managed_by_sso) + + @override_settings( + SSO_GROUP_ROLE_MAP_JSON='{"GK-admin":"admin"}', + SSO_MANAGE_LINKED_USER_ROLES=True, + ) + def test_linked_local_admin_is_downgraded_when_explicitly_managed(self): + user = UserFactory.create_user( + username="test30", email="test30@example.com", is_staff=True + ) + response = self._post_callback(self._token(groups=[], jti="managed-admin")) + user.refresh_from_db() + self.assertEqual(response.status_code, 303) + self.assertEqual(UserService.get_user_role(user), "user") + self.assertTrue(user.sso_identity.role_managed_by_sso) + + def test_rejects_malformed_group_claim(self): + response = self._post_callback(self._token(groups="GK-admin")) + self.assertEqual(response.status_code, 403) + self.assertFalse(User.objects.exists()) + + def test_stores_normalized_business_claims_without_token(self): + response = self._post_callback( + self._token( + groups=[" Аналитика ", "Аналитика"], + user_type_code="expert", + default_organisation={"okpo": "07508753"}, + is_integrated_structure=True, + ex_loop=True, + ) + ) + identity = apps.get_model("user", "SsoIdentity").objects.get() + self.assertEqual(response.status_code, 303) + self.assertEqual(identity.external_groups, ["Аналитика"]) + self.assertEqual(identity.user_type_code, "expert") + self.assertEqual(identity.default_organisation, {"okpo": "07508753"}) + self.assertTrue(identity.is_integrated_structure) + self.assertTrue(identity.ex_loop) + self.assertFalse(hasattr(identity, "raw_jwt")) + + @override_settings(SSO_GROUP_ROLE_MAP_JSON='{"GK-admin":"superuser"}') + def test_rejects_invalid_role_mapping_without_creating_user(self): + response = self._post_callback(self._token(groups=["GK-admin"])) + self.assertEqual(response.status_code, 403) + self.assertFalse(User.objects.exists()) + def test_rejects_replayed_jti(self): token = self._token()