Update beta.mdx

Added explanation of what our next versions are, clarified step to run upgrade commands, linked to Release Notes page.

Signed-off-by: Tana M Berry <tanamarieberry@yahoo.com>

.github/dependabot.yml

@@ -6,8 +6,6 @@ updates:
       interval: daily
       time: "04:00"
     open-pull-requests-limit: 10
-    reviewers:
-      - "@goauthentik/core"
     commit-message:
       prefix: "ci:"
   - package-ecosystem: gomod
@@ -16,8 +14,6 @@ updates:
       interval: daily
       time: "04:00"
     open-pull-requests-limit: 10
-    reviewers:
-      - "@goauthentik/core"
     commit-message:
       prefix: "core:"
   - package-ecosystem: npm
@@ -26,8 +22,6 @@ updates:
       interval: daily
       time: "04:00"
     open-pull-requests-limit: 10
-    reviewers:
-      - "@goauthentik/core"
     commit-message:
       prefix: "web:"
   - package-ecosystem: npm
@@ -36,8 +30,6 @@ updates:
       interval: daily
       time: "04:00"
     open-pull-requests-limit: 10
-    reviewers:
-      - "@goauthentik/core"
     commit-message:
       prefix: "website:"
   - package-ecosystem: pip
@@ -46,8 +38,6 @@ updates:
       interval: daily
       time: "04:00"
     open-pull-requests-limit: 10
-    reviewers:
-      - "@goauthentik/core"
     commit-message:
       prefix: "core:"
   - package-ecosystem: docker
@@ -56,7 +46,5 @@ updates:
       interval: daily
       time: "04:00"
     open-pull-requests-limit: 10
-    reviewers:
-      - "@goauthentik/core"
     commit-message:
       prefix: "core:"

.github/pull_request_template.md

@@ -1,10 +1,10 @@
 <!--
 👋 Hello there! Welcome.
 
-Please check the [Contributing guidelines](https://github.com/goauthentik/authentik/blob/main/CONTRIBUTING.md#how-can-i-contribute).
+Please check the [Contributing guidelines](https://goauthentik.io/developer-docs/#how-can-i-contribute).
 -->
 
-# Details
+## Details
 
 -   **Does this resolve an issue?**
     Resolves #
@@ -19,6 +19,21 @@ Please check the [Contributing guidelines](https://github.com/goauthentik/authen
 
 -   Adds breaking change which causes \<issue\>.
 
-## Additional
+## Checklist
 
-Any further notes or comments you want to make.
+-   [ ] Local tests pass (`ak test authentik/`)
+-   [ ] The code has been formatted (`make lint-fix`)
+
+If an API change has been made
+
+-   [ ] The API schema has been updated (`make gen-build`)
+
+If changes to the frontend have been made
+
+-   [ ] The code has been formatted (`make web`)
+-   [ ] The translation files have been updated (`make i18n-extract`)
+
+If applicable
+
+-   [ ] The documentation has been updated
+-   [ ] The documentation has been formatted (`make website`)

.github/workflows/translation-advice.yml

@@ -0,0 +1,34 @@
+name: authentik-translation-advice
+
+on:
+  pull_request:
+    branches:
+      - main
+    paths:
+      - "!**"
+      - "locale/**"
+      - "web/src/locales/**"
+
+jobs:
+  post-comment:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Find Comment
+        uses: peter-evans/find-comment@v2
+        id: fc
+        with:
+          issue-number: ${{ github.event.pull_request.number }}
+          comment-author: "github-actions[bot]"
+          body-includes: authentik translations instructions
+      - name: Create or update comment
+        uses: peter-evans/create-or-update-comment@v3
+        with:
+          comment-id: ${{ steps.fc.outputs.comment-id }}
+          issue-number: ${{ github.event.pull_request.number }}
+          edit-mode: replace
+          body: |
+            ### authentik translations instructions
+
+            Thanks for your pull request!
+
+            authentik translations are handled using [Transifex](https://explore.transifex.com/authentik/authentik/). Please edit translations over there and they'll be included automatically.

.github/workflows/translation-compile.yml

@@ -3,10 +3,7 @@ on:
   push:
     branches: [main]
     paths:
-      - "/locale/"
-  pull_request:
-    paths:
-      - "/locale/"
+      - "locale/**"
   workflow_dispatch:
 
 env:
@@ -24,7 +21,7 @@ jobs:
       - name: Setup authentik env
         uses: ./.github/actions/setup
       - name: run compile
-        run: poetry run ./manage.py compilemessages
+        run: poetry run ak compilemessages
       - name: Create Pull Request
         uses: peter-evans/create-pull-request@v5
         id: cpr

CODEOWNERS

@@ -0,0 +1,2 @@
+*   @goauthentik/core
+website/docs/security/**    @goauthentik/security

CONTRIBUTING.md

@@ -1,188 +0,0 @@
-# Contributing to authentik
-
-:+1::tada: Thanks for taking the time to contribute! :tada::+1:
-
-The following is a set of guidelines for contributing to authentik and its components, which are hosted in the [goauthentik Organization](https://github.com/goauthentik) on GitHub. These are mostly guidelines, not rules. Use your best judgment, and feel free to propose changes to this document in a pull request.
-
-#### Table Of Contents
-
-[Code of Conduct](#code-of-conduct)
-
-[I don't want to read this whole thing, I just have a question!!!](#i-dont-want-to-read-this-whole-thing-i-just-have-a-question)
-
-[What should I know before I get started?](#what-should-i-know-before-i-get-started)
-
--   [The components](#the-components)
--   [authentik's structure](#authentiks-structure)
-
-[How Can I Contribute?](#how-can-i-contribute)
-
--   [Reporting Bugs](#reporting-bugs)
--   [Suggesting Enhancements](#suggesting-enhancements)
--   [Your First Code Contribution](#your-first-code-contribution)
--   [Help with the Docs](#help-with-the-docs)
--   [Pull Requests](#pull-requests)
-
-[Styleguides](#styleguides)
-
--   [Git Commit Messages](#git-commit-messages)
--   [Python Styleguide](#python-styleguide)
--   [Documentation Styleguide](#documentation-styleguide)
-
-## Code of Conduct
-
-Basically, don't be a dickhead. This is an open-source non-profit project, that is made in the free time of Volunteers. If there's something you dislike or think can be done better, tell us! We'd love to hear any suggestions for improvement.
-
-## I don't want to read this whole thing I just have a question!!!
-
-Either [create a question on GitHub](https://github.com/goauthentik/authentik/issues/new?assignees=&labels=question&template=question.md&title=) or join [the Discord server](https://goauthentik.io/discord)
-
-## What should I know before I get started?
-
-### The components
-
-authentik consists of a few larger components:
-
--   _authentik_ the actual application server, is described below.
--   _outpost-proxy_ is a Go application based on a forked version of oauth2_proxy, which does identity-aware reverse proxying.
--   _outpost-ldap_ is a Go LDAP server that uses the _authentik_ application server as its backend
--   _web_ is the web frontend, both for administrating and using authentik. It is written in TypeScript using lit-html and the PatternFly CSS Library.
--   _website_ is the Website/documentation, which uses docusaurus.
-
-### authentik's structure
-
-authentik is at it's very core a Django project. It consists of many individual django applications. These applications are intended to separate concerns, and they may share code between each other.
-
-These are the current packages:
-<a id="authentik-packages"/>
-
-```
-authentik
-├── admin - Administrative tasks and APIs, no models (Version updates, Metrics, system tasks)
-├── api - General API Configuration (Routes, Schema and general API utilities)
-├── blueprints - Handle managed models and their state.
-├── core - Core authentik functionality, central routes, core Models
-├── crypto - Cryptography, currently used to generate and hold Certificates and Private Keys
-├── events - Event Log, middleware and signals to generate signals
-├── flows - Flows, the FlowPlanner and the FlowExecutor, used for all flows for authentication, authorization, etc
-├── lib - Generic library of functions, few dependencies on other packages.
-├── outposts - Configure and deploy outposts on kubernetes and docker.
-├── policies - General PolicyEngine
-│   ├── dummy - A Dummy policy used for testing
-│   ├── event_matcher - Match events based on different criteria
-│   ├── expiry - Check when a user's password was last set
-│   ├── expression - Execute any arbitrary python code
-│   ├── password - Check a password against several rules
-│   └── reputation - Check the user's/client's reputation
-├── providers
-│   ├── ldap - Provide LDAP access to authentik users/groups using an outpost
-│   ├── oauth2 - OIDC-compliant OAuth2 provider
-│   ├── proxy - Provides an identity-aware proxy using an outpost
-│   └── saml - SAML2 Provider
-├── recovery - Generate keys to use in case you lock yourself out
-├── root - Root django application, contains global settings and routes
-├── sources
-│   ├── ldap - Sync LDAP users from OpenLDAP or Active Directory into authentik
-│   ├── oauth - OAuth1 and OAuth2 Source
-│   ├── plex - Plex source
-│   └── saml - SAML2 Source
-├── stages
-│   ├── authenticator_duo - Configure a DUO authenticator
-│   ├── authenticator_static - Configure TOTP backup keys
-│   ├── authenticator_totp - Configure a TOTP authenticator
-│   ├── authenticator_validate - Validate any authenticator
-│   ├── authenticator_webauthn - Configure a WebAuthn authenticator
-│   ├── captcha - Make the user pass a captcha
-│   ├── consent - Let the user decide if they want to consent to an action
-│   ├── deny - Static deny, can be used with policies
-│   ├── dummy - Dummy stage to test
-│   ├── email - Send the user an email and block execution until they click the link
-│   ├── identification - Identify a user with any combination of fields
-│   ├── invitation - Invitation system to limit flows to certain users
-│   ├── password - Password authentication
-│   ├── prompt - Arbitrary prompts
-│   ├── user_delete - Delete the currently pending user
-│   ├── user_login - Login the currently pending user
-│   ├── user_logout - Logout the currently pending user
-│   └── user_write - Write any currenetly pending data to the user.
-└── tenants - Soft tennancy, configure defaults and branding per domain
-```
-
-This django project is running in gunicorn, which spawns multiple workers and threads. Gunicorn is run from a lightweight Go application which reverse-proxies it, handles static files and will eventually gain more functionality as more code is migrated to go.
-
-There are also several background tasks which run in Celery, the root celery application is defined in `authentik.root.celery`.
-
-## How Can I Contribute?
-
-### Reporting Bugs
-
-This section guides you through submitting a bug report for authentik. Following these guidelines helps maintainers and the community understand your report, reproduce the behavior, and find related reports.
-
-Whenever authentik encounters an error, it will be logged as an Event with the type `system_exception`. This event type has a button to directly open a pre-filled GitHub issue form.
-
-This form will have the full stack trace of the error that occurred and shouldn't contain any sensitive data.
-
-### Suggesting Enhancements
-
-This section guides you through submitting an enhancement suggestion for authentik, including completely new features and minor improvements to existing functionality. Following these guidelines helps maintainers and the community understand your suggestion and find related suggestions.
-
-When you are creating an enhancement suggestion, please fill in [the template](https://github.com/goauthentik/authentik/issues/new?assignees=&labels=enhancement&template=feature_request.md&title=), including the steps that you imagine you would take if the feature you're requesting existed.
-
-### Your First Code Contribution
-
-#### Local development
-
-authentik can be run locally, all though depending on which part you want to work on, different pre-requisites are required.
-
-This is documented in the [developer docs](https://goauthentik.io/developer-docs/?utm_source=github)
-
-### Help with the Docs
-Contributions to the technical documentation are greatly appreciated. Open a PR if you have improvements to make or new content to add. If you have questions or suggestions about the documentation, open an Issue. No contribution is too small.
-
-### Pull Requests
-
-The process described here has several goals:
-
--   Maintain authentik's quality
--   Fix problems that are important to users
--   Engage the community in working toward the best possible authentik
--   Enable a sustainable system for authentik's maintainers to review contributions
-
-Please follow these steps to have your contribution considered by the maintainers:
-
-1. Follow the [styleguides](#styleguides)
-2. After you submit your pull request, verify that all [status checks](https://help.github.com/articles/about-status-checks/) are passing <details><summary>What if the status checks are failing?</summary>If a status check is failing, and you believe that the failure is unrelated to your change, please leave a comment on the pull request explaining why you believe the failure is unrelated. A maintainer will re-run the status check for you. If we conclude that the failure was a false positive, then we will open an issue to track that problem with our status check suite.</details>
-3. Ensure your Code has tests. While it is not always possible to test every single case, the majority of the code should be tested.
-
-While the prerequisites above must be satisfied prior to having your pull request reviewed, the reviewer(s) may ask you to complete additional design work, tests, or other changes before your pull request can be ultimately accepted.
-
-## Styleguides
-
-### PR naming
-
--   Use the format of `<package>: <verb> <description>`
-    -   See [here](#authentik-packages) for `package`
-    -   Example: `providers/saml2: fix parsing of requests`
-
-### Git Commit Messages
-
--   Use the format of `<package>: <verb> <description>`
-    -   See [here](#authentik-packages) for `package`
-    -   Example: `providers/saml2: fix parsing of requests`
--   Reference issues and pull requests liberally after the first line
--   Naming of commits within a PR does not need to adhere to the guidelines as we squash merge PRs
-
-### Python Styleguide
-
-All Python code is linted with [black](https://black.readthedocs.io/en/stable/), [PyLint](https://www.pylint.org/) and [isort](https://pycqa.github.io/isort/).
-
-authentik runs on Python 3.9 at the time of writing this.
-
--   Use native type-annotations wherever possible.
--   Add meaningful docstrings when possible.
--   Ensure any database migrations work properly from the last stable version (this is checked via CI)
--   If your code changes central functions, make sure nothing else is broken.
-
-### Documentation Styleguide
-
--   Use [MDX](https://mdxjs.com/) whenever appropriate.

CONTRIBUTING.md

@@ -0,0 +1 @@
+website/developer-docs/index.md

Dockerfile

@@ -31,7 +31,7 @@ RUN pip install --no-cache-dir poetry && \
     poetry export -f requirements.txt --dev --output requirements-dev.txt
 
 # Stage 4: Build go proxy
-FROM docker.io/golang:1.20.3-bullseye AS go-builder
+FROM docker.io/golang:1.20.4-bullseye AS go-builder
 
 WORKDIR /work
 
@@ -47,11 +47,12 @@ COPY ./go.sum /work/go.sum
 RUN go build -o /work/authentik ./cmd/server/
 
 # Stage 5: MaxMind GeoIP
-FROM docker.io/maxmindinc/geoipupdate:v5.0 as geoip
+FROM ghcr.io/maxmind/geoipupdate:v5.1 as geoip
 
 ENV GEOIPUPDATE_EDITION_IDS="GeoLite2-City"
 ENV GEOIPUPDATE_VERBOSE="true"
 
+USER root
 RUN --mount=type=secret,id=GEOIPUPDATE_ACCOUNT_ID \
     --mount=type=secret,id=GEOIPUPDATE_LICENSE_KEY \
     mkdir -p /usr/share/GeoIP && \
@@ -84,8 +85,6 @@ RUN apt-get update && \
     apt-get install -y --no-install-recommends libxmlsec1-openssl libmaxminddb0 && \
     # Required for bootstrap & healtcheck
     apt-get install -y --no-install-recommends runit && \
-    # Required for outposts
-    apt-get install -y --no-install-recommends openssh-client && \
     pip install --no-cache-dir -r /requirements.txt && \
     apt-get remove --purge -y build-essential pkg-config libxmlsec1-dev && \
     apt-get autoremove --purge -y && \
@@ -93,9 +92,8 @@ RUN apt-get update && \
     rm -rf /tmp/* /var/lib/apt/lists/* /var/tmp/ && \
     adduser --system --no-create-home --uid 1000 --group --home /authentik authentik && \
     mkdir -p /certs /media /blueprints && \
-    chown authentik:authentik /certs /media && \
-    chmod g+w /etc/ssh/ssh_config.d/ && \
-    chgrp authentik /etc/ssh/ssh_config.d/
+    mkdir -p /authentik/.ssh && \
+    chown authentik:authentik /certs /media /authentik/.ssh
 
 COPY ./authentik/ /authentik
 COPY ./pyproject.toml /

Makefile

@@ -206,6 +206,8 @@ install: web-install website-install
 
 dev-reset:
 	dropdb -U postgres -h localhost authentik
+	# Also remove the test-db if it exists
+	dropdb -U postgres -h localhost test_authentik || true
 	createdb -U postgres -h localhost authentik
 	redis-cli -n 0 flushall
 	make migrate

authentik/admin/urls.py

@@ -0,0 +1,22 @@
+"""API URLs"""
+from django.urls import path
+
+from authentik.admin.api.meta import AppsViewSet
+from authentik.admin.api.metrics import AdministrationMetricsViewSet
+from authentik.admin.api.system import SystemView
+from authentik.admin.api.tasks import TaskViewSet
+from authentik.admin.api.version import VersionView
+from authentik.admin.api.workers import WorkerView
+
+api_urlpatterns = [
+    ("admin/system_tasks", TaskViewSet, "admin_system_tasks"),
+    ("admin/apps", AppsViewSet, "apps"),
+    path(
+        "admin/metrics/",
+        AdministrationMetricsViewSet.as_view(),
+        name="admin_metrics",
+    ),
+    path("admin/version/", VersionView.as_view(), name="admin_version"),
+    path("admin/workers/", WorkerView.as_view(), name="admin_workers"),
+    path("admin/system/", SystemView.as_view(), name="admin_system"),
+]

authentik/api/v3/urls.py

@@ -1,269 +1,50 @@
 """api v3 urls"""
+from importlib import import_module
+
 from django.urls import path
+from django.urls.resolvers import URLPattern
 from django.views.decorators.cache import cache_page
 from drf_spectacular.views import SpectacularAPIView
 from rest_framework import routers
+from structlog.stdlib import get_logger
 
-from authentik.admin.api.meta import AppsViewSet
-from authentik.admin.api.metrics import AdministrationMetricsViewSet
-from authentik.admin.api.system import SystemView
-from authentik.admin.api.tasks import TaskViewSet
-from authentik.admin.api.version import VersionView
-from authentik.admin.api.workers import WorkerView
 from authentik.api.v3.config import ConfigView
 from authentik.api.views import APIBrowserView
-from authentik.blueprints.api import BlueprintInstanceViewSet
-from authentik.core.api.applications import ApplicationViewSet
-from authentik.core.api.authenticated_sessions import AuthenticatedSessionViewSet
-from authentik.core.api.devices import AdminDeviceViewSet, DeviceViewSet
-from authentik.core.api.groups import GroupViewSet
-from authentik.core.api.propertymappings import PropertyMappingViewSet
-from authentik.core.api.providers import ProviderViewSet
-from authentik.core.api.sources import SourceViewSet, UserSourceConnectionViewSet
-from authentik.core.api.tokens import TokenViewSet
-from authentik.core.api.users import UserViewSet
-from authentik.crypto.api import CertificateKeyPairViewSet
-from authentik.events.api.events import EventViewSet
-from authentik.events.api.notification_mappings import NotificationWebhookMappingViewSet
-from authentik.events.api.notification_rules import NotificationRuleViewSet
-from authentik.events.api.notification_transports import NotificationTransportViewSet
-from authentik.events.api.notifications import NotificationViewSet
-from authentik.flows.api.bindings import FlowStageBindingViewSet
-from authentik.flows.api.flows import FlowViewSet
-from authentik.flows.api.stages import StageViewSet
-from authentik.flows.views.executor import FlowExecutorView
-from authentik.flows.views.inspector import FlowInspectorView
-from authentik.outposts.api.outposts import OutpostViewSet
-from authentik.outposts.api.service_connections import (
-    DockerServiceConnectionViewSet,
-    KubernetesServiceConnectionViewSet,
-    ServiceConnectionViewSet,
-)
-from authentik.policies.api.bindings import PolicyBindingViewSet
-from authentik.policies.api.policies import PolicyViewSet
-from authentik.policies.dummy.api import DummyPolicyViewSet
-from authentik.policies.event_matcher.api import EventMatcherPolicyViewSet
-from authentik.policies.expiry.api import PasswordExpiryPolicyViewSet
-from authentik.policies.expression.api import ExpressionPolicyViewSet
-from authentik.policies.password.api import PasswordPolicyViewSet
-from authentik.policies.reputation.api import ReputationPolicyViewSet, ReputationViewSet
-from authentik.providers.ldap.api import LDAPOutpostConfigViewSet, LDAPProviderViewSet
-from authentik.providers.oauth2.api.providers import OAuth2ProviderViewSet
-from authentik.providers.oauth2.api.scopes import ScopeMappingViewSet
-from authentik.providers.oauth2.api.tokens import (
-    AccessTokenViewSet,
-    AuthorizationCodeViewSet,
-    RefreshTokenViewSet,
-)
-from authentik.providers.proxy.api import ProxyOutpostConfigViewSet, ProxyProviderViewSet
-from authentik.providers.radius.api import RadiusOutpostConfigViewSet, RadiusProviderViewSet
-from authentik.providers.saml.api.property_mapping import SAMLPropertyMappingViewSet
-from authentik.providers.saml.api.providers import SAMLProviderViewSet
-from authentik.providers.scim.api.property_mapping import SCIMMappingViewSet
-from authentik.providers.scim.api.providers import SCIMProviderViewSet
-from authentik.sources.ldap.api import LDAPPropertyMappingViewSet, LDAPSourceViewSet
-from authentik.sources.oauth.api.source import OAuthSourceViewSet
-from authentik.sources.oauth.api.source_connection import UserOAuthSourceConnectionViewSet
-from authentik.sources.plex.api.source import PlexSourceViewSet
-from authentik.sources.plex.api.source_connection import PlexSourceConnectionViewSet
-from authentik.sources.saml.api.source import SAMLSourceViewSet
-from authentik.sources.saml.api.source_connection import UserSAMLSourceConnectionViewSet
-from authentik.stages.authenticator_duo.api import (
-    AuthenticatorDuoStageViewSet,
-    DuoAdminDeviceViewSet,
-    DuoDeviceViewSet,
-)
-from authentik.stages.authenticator_sms.api import (
-    AuthenticatorSMSStageViewSet,
-    SMSAdminDeviceViewSet,
-    SMSDeviceViewSet,
-)
-from authentik.stages.authenticator_static.api import (
-    AuthenticatorStaticStageViewSet,
-    StaticAdminDeviceViewSet,
-    StaticDeviceViewSet,
-)
-from authentik.stages.authenticator_totp.api import (
-    AuthenticatorTOTPStageViewSet,
-    TOTPAdminDeviceViewSet,
-    TOTPDeviceViewSet,
-)
-from authentik.stages.authenticator_validate.api import AuthenticatorValidateStageViewSet
-from authentik.stages.authenticator_webauthn.api import (
-    AuthenticateWebAuthnStageViewSet,
-    WebAuthnAdminDeviceViewSet,
-    WebAuthnDeviceViewSet,
-)
-from authentik.stages.captcha.api import CaptchaStageViewSet
-from authentik.stages.consent.api import ConsentStageViewSet, UserConsentViewSet
-from authentik.stages.deny.api import DenyStageViewSet
-from authentik.stages.dummy.api import DummyStageViewSet
-from authentik.stages.email.api import EmailStageViewSet
-from authentik.stages.identification.api import IdentificationStageViewSet
-from authentik.stages.invitation.api import InvitationStageViewSet, InvitationViewSet
-from authentik.stages.password.api import PasswordStageViewSet
-from authentik.stages.prompt.api import PromptStageViewSet, PromptViewSet
-from authentik.stages.user_delete.api import UserDeleteStageViewSet
-from authentik.stages.user_login.api import UserLoginStageViewSet
-from authentik.stages.user_logout.api import UserLogoutStageViewSet
-from authentik.stages.user_write.api import UserWriteStageViewSet
-from authentik.tenants.api import TenantViewSet
+from authentik.lib.utils.reflection import get_apps
+
+LOGGER = get_logger()
 
 router = routers.DefaultRouter()
 router.include_format_suffixes = False
 
-router.register("admin/system_tasks", TaskViewSet, basename="admin_system_tasks")
-router.register("admin/apps", AppsViewSet, basename="apps")
+_other_urls = []
+for _authentik_app in get_apps():
+    try:
+        api_urls = import_module(f"{_authentik_app.name}.urls")
+    except (ModuleNotFoundError, ImportError):
+        continue
+    if not hasattr(api_urls, "api_urlpatterns"):
+        continue
+    urls: list = getattr(api_urls, "api_urlpatterns")
+    for url in urls:
+        if isinstance(url, URLPattern):
+            _other_urls.append(url)
+        else:
+            router.register(*url)
+    LOGGER.debug(
+        "Mounted API URLs",
+        app_name=_authentik_app.name,
+    )
 
-router.register("core/authenticated_sessions", AuthenticatedSessionViewSet)
-router.register("core/applications", ApplicationViewSet)
-router.register("core/groups", GroupViewSet)
-router.register("core/users", UserViewSet)
-router.register("core/user_consent", UserConsentViewSet)
-router.register("core/tokens", TokenViewSet)
-router.register("core/tenants", TenantViewSet)
-
-router.register("outposts/instances", OutpostViewSet)
-router.register("outposts/service_connections/all", ServiceConnectionViewSet)
-router.register("outposts/service_connections/docker", DockerServiceConnectionViewSet)
-router.register("outposts/service_connections/kubernetes", KubernetesServiceConnectionViewSet)
-router.register("outposts/proxy", ProxyOutpostConfigViewSet)
-router.register("outposts/ldap", LDAPOutpostConfigViewSet)
-router.register("outposts/radius", RadiusOutpostConfigViewSet)
-
-router.register("flows/instances", FlowViewSet)
-router.register("flows/bindings", FlowStageBindingViewSet)
-
-router.register("crypto/certificatekeypairs", CertificateKeyPairViewSet)
-
-router.register("events/events", EventViewSet)
-router.register("events/notifications", NotificationViewSet)
-router.register("events/transports", NotificationTransportViewSet)
-router.register("events/rules", NotificationRuleViewSet)
-
-router.register("managed/blueprints", BlueprintInstanceViewSet)
-
-router.register("sources/all", SourceViewSet)
-router.register("sources/user_connections/all", UserSourceConnectionViewSet)
-router.register("sources/user_connections/oauth", UserOAuthSourceConnectionViewSet)
-router.register("sources/user_connections/plex", PlexSourceConnectionViewSet)
-router.register("sources/user_connections/saml", UserSAMLSourceConnectionViewSet)
-router.register("sources/ldap", LDAPSourceViewSet)
-router.register("sources/saml", SAMLSourceViewSet)
-router.register("sources/oauth", OAuthSourceViewSet)
-router.register("sources/plex", PlexSourceViewSet)
-
-router.register("policies/all", PolicyViewSet)
-router.register("policies/bindings", PolicyBindingViewSet)
-router.register("policies/expression", ExpressionPolicyViewSet)
-router.register("policies/event_matcher", EventMatcherPolicyViewSet)
-router.register("policies/password_expiry", PasswordExpiryPolicyViewSet)
-router.register("policies/password", PasswordPolicyViewSet)
-router.register("policies/reputation/scores", ReputationViewSet)
-router.register("policies/reputation", ReputationPolicyViewSet)
-
-router.register("providers/all", ProviderViewSet)
-router.register("providers/ldap", LDAPProviderViewSet)
-router.register("providers/proxy", ProxyProviderViewSet)
-router.register("providers/oauth2", OAuth2ProviderViewSet)
-router.register("providers/saml", SAMLProviderViewSet)
-router.register("providers/scim", SCIMProviderViewSet)
-router.register("providers/radius", RadiusProviderViewSet)
-
-router.register("oauth2/authorization_codes", AuthorizationCodeViewSet)
-router.register("oauth2/refresh_tokens", RefreshTokenViewSet)
-router.register("oauth2/access_tokens", AccessTokenViewSet)
-
-router.register("propertymappings/all", PropertyMappingViewSet)
-router.register("propertymappings/ldap", LDAPPropertyMappingViewSet)
-router.register("propertymappings/saml", SAMLPropertyMappingViewSet)
-router.register("propertymappings/scope", ScopeMappingViewSet)
-router.register("propertymappings/notification", NotificationWebhookMappingViewSet)
-router.register("propertymappings/scim", SCIMMappingViewSet)
-
-router.register("authenticators/all", DeviceViewSet, basename="device")
-router.register("authenticators/duo", DuoDeviceViewSet)
-router.register("authenticators/sms", SMSDeviceViewSet)
-router.register("authenticators/static", StaticDeviceViewSet)
-router.register("authenticators/totp", TOTPDeviceViewSet)
-router.register("authenticators/webauthn", WebAuthnDeviceViewSet)
-router.register(
-    "authenticators/admin/all",
-    AdminDeviceViewSet,
-    basename="admin-device",
-)
-router.register(
-    "authenticators/admin/duo",
-    DuoAdminDeviceViewSet,
-    basename="admin-duodevice",
-)
-router.register(
-    "authenticators/admin/sms",
-    SMSAdminDeviceViewSet,
-    basename="admin-smsdevice",
-)
-router.register(
-    "authenticators/admin/static",
-    StaticAdminDeviceViewSet,
-    basename="admin-staticdevice",
-)
-router.register("authenticators/admin/totp", TOTPAdminDeviceViewSet, basename="admin-totpdevice")
-router.register(
-    "authenticators/admin/webauthn",
-    WebAuthnAdminDeviceViewSet,
-    basename="admin-webauthndevice",
-)
-
-router.register("stages/all", StageViewSet)
-router.register("stages/authenticator/duo", AuthenticatorDuoStageViewSet)
-router.register("stages/authenticator/sms", AuthenticatorSMSStageViewSet)
-router.register("stages/authenticator/static", AuthenticatorStaticStageViewSet)
-router.register("stages/authenticator/totp", AuthenticatorTOTPStageViewSet)
-router.register("stages/authenticator/validate", AuthenticatorValidateStageViewSet)
-router.register("stages/authenticator/webauthn", AuthenticateWebAuthnStageViewSet)
-router.register("stages/captcha", CaptchaStageViewSet)
-router.register("stages/consent", ConsentStageViewSet)
-router.register("stages/deny", DenyStageViewSet)
-router.register("stages/email", EmailStageViewSet)
-router.register("stages/identification", IdentificationStageViewSet)
-router.register("stages/invitation/invitations", InvitationViewSet)
-router.register("stages/invitation/stages", InvitationStageViewSet)
-router.register("stages/password", PasswordStageViewSet)
-router.register("stages/prompt/prompts", PromptViewSet)
-router.register("stages/prompt/stages", PromptStageViewSet)
-router.register("stages/user_delete", UserDeleteStageViewSet)
-router.register("stages/user_login", UserLoginStageViewSet)
-router.register("stages/user_logout", UserLogoutStageViewSet)
-router.register("stages/user_write", UserWriteStageViewSet)
-
-router.register("stages/dummy", DummyStageViewSet)
-router.register("policies/dummy", DummyPolicyViewSet)
 
 urlpatterns = (
     [
         path("", APIBrowserView.as_view(), name="schema-browser"),
     ]
     + router.urls
+    + _other_urls
     + [
-        path(
-            "admin/metrics/",
-            AdministrationMetricsViewSet.as_view(),
-            name="admin_metrics",
-        ),
-        path("admin/version/", VersionView.as_view(), name="admin_version"),
-        path("admin/workers/", WorkerView.as_view(), name="admin_workers"),
-        path("admin/system/", SystemView.as_view(), name="admin_system"),
         path("root/config/", ConfigView.as_view(), name="config"),
-        path(
-            "flows/executor/<slug:flow_slug>/",
-            FlowExecutorView.as_view(),
-            name="flow-executor",
-        ),
-        path(
-            "flows/inspector/<slug:flow_slug>/",
-            FlowInspectorView.as_view(),
-            name="flow-inspector",
-        ),
         path("schema/", cache_page(86400)(SpectacularAPIView.as_view()), name="schema"),
     ]
 )

authentik/blueprints/api.py

@@ -49,7 +49,8 @@ class BlueprintInstanceSerializer(ModelSerializer):
         context = self.instance.context if self.instance else {}
         valid, logs = Importer(content, context).validate()
         if not valid:
-            raise ValidationError(_("Failed to validate blueprint"), *[x["msg"] for x in logs])
+            text_logs = "\n".join([x["event"] for x in logs])
+            raise ValidationError(_("Failed to validate blueprint: %(logs)s" % {"logs": text_logs}))
         return content
 
     def validate(self, attrs: dict) -> dict:

authentik/blueprints/management/commands/make_blueprint_schema.py

@@ -1,12 +1,17 @@
 """Generate JSON Schema for blueprints"""
-from json import dumps, loads
-from pathlib import Path
+from json import dumps
+from typing import Any
 
 from django.core.management.base import BaseCommand, no_translations
+from django.db.models import Model
+from drf_jsonschema_serializer.convert import field_to_converter
+from rest_framework.fields import Field, JSONField, UUIDField
+from rest_framework.serializers import Serializer
 from structlog.stdlib import get_logger
 
-from authentik.blueprints.v1.importer import is_model_allowed
+from authentik.blueprints.v1.importer import SERIALIZER_CONTEXT_BLUEPRINT, is_model_allowed
 from authentik.blueprints.v1.meta.registry import registry
+from authentik.lib.models import SerializerModel
 
 LOGGER = get_logger()
 
@@ -16,21 +21,142 @@ class Command(BaseCommand):
 
     schema: dict
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.schema = {
+            "$schema": "http://json-schema.org/draft-07/schema",
+            "$id": "https://goauthentik.io/blueprints/schema.json",
+            "type": "object",
+            "title": "authentik Blueprint schema",
+            "required": ["version", "entries"],
+            "properties": {
+                "version": {
+                    "$id": "#/properties/version",
+                    "type": "integer",
+                    "title": "Blueprint version",
+                    "default": 1,
+                },
+                "metadata": {
+                    "$id": "#/properties/metadata",
+                    "type": "object",
+                    "required": ["name"],
+                    "properties": {
+                        "name": {"type": "string"},
+                        "labels": {"type": "object", "additionalProperties": {"type": "string"}},
+                    },
+                },
+                "context": {
+                    "$id": "#/properties/context",
+                    "type": "object",
+                    "additionalProperties": True,
+                },
+                "entries": {
+                    "type": "array",
+                    "items": {
+                        "oneOf": [],
+                    },
+                },
+            },
+            "$defs": {},
+        }
+
     @no_translations
     def handle(self, *args, **options):
         """Generate JSON Schema for blueprints"""
-        path = Path(__file__).parent.joinpath("./schema_template.json")
-        with open(path, "r", encoding="utf-8") as _template_file:
-            self.schema = loads(_template_file.read())
-        self.set_model_allowed()
-        self.stdout.write(dumps(self.schema, indent=4))
+        self.build()
+        self.stdout.write(dumps(self.schema, indent=4, default=Command.json_default))
 
-    def set_model_allowed(self):
-        """Set model enum"""
-        model_names = []
+    @staticmethod
+    def json_default(value: Any) -> Any:
+        """Helper that handles gettext_lazy strings that JSON doesn't handle"""
+        return str(value)
+
+    def build(self):
+        """Build all models into the schema"""
         for model in registry.get_models():
+            if model._meta.abstract:
+                continue
             if not is_model_allowed(model):
                 continue
-            model_names.append(f"{model._meta.app_label}.{model._meta.model_name}")
-        model_names.sort()
-        self.schema["properties"]["entries"]["items"]["properties"]["model"]["enum"] = model_names
+            model_instance: Model = model()
+            if not isinstance(model_instance, SerializerModel):
+                continue
+            serializer = model_instance.serializer(
+                context={
+                    SERIALIZER_CONTEXT_BLUEPRINT: False,
+                }
+            )
+            model_path = f"{model._meta.app_label}.{model._meta.model_name}"
+            self.schema["properties"]["entries"]["items"]["oneOf"].append(
+                self.template_entry(model_path, serializer)
+            )
+
+    def template_entry(self, model_path: str, serializer: Serializer) -> dict:
+        """Template entry for a single model"""
+        model_schema = self.to_jsonschema(serializer)
+        model_schema["required"] = []
+        def_name = f"model_{model_path}"
+        def_path = f"#/$defs/{def_name}"
+        self.schema["$defs"][def_name] = model_schema
+        return {
+            "type": "object",
+            "required": ["model", "identifiers"],
+            "properties": {
+                "model": {"const": model_path},
+                "id": {"type": "string"},
+                "state": {
+                    "type": "string",
+                    "enum": ["absent", "present", "created"],
+                    "default": "present",
+                },
+                "conditions": {"type": "array", "items": {"type": "boolean"}},
+                "attrs": {"$ref": def_path},
+                "identifiers": {"$ref": def_path},
+            },
+        }
+
+    def field_to_jsonschema(self, field: Field) -> dict:
+        """Convert a single field to json schema"""
+        if isinstance(field, Serializer):
+            result = self.to_jsonschema(field)
+        else:
+            try:
+                converter = field_to_converter[field]
+                result = converter.convert(field)
+            except KeyError:
+                if isinstance(field, JSONField):
+                    result = {"type": "object", "additionalProperties": True}
+                elif isinstance(field, UUIDField):
+                    result = {"type": "string", "format": "uuid"}
+                else:
+                    raise
+        if field.label:
+            result["title"] = field.label
+        if field.help_text:
+            result["description"] = field.help_text
+        return self.clean_result(result)
+
+    def clean_result(self, result: dict) -> dict:
+        """Remove enumNames from result, recursively"""
+        result.pop("enumNames", None)
+        for key, value in result.items():
+            if isinstance(value, dict):
+                result[key] = self.clean_result(value)
+        return result
+
+    def to_jsonschema(self, serializer: Serializer) -> dict:
+        """Convert serializer to json schema"""
+        properties = {}
+        required = []
+        for name, field in serializer.fields.items():
+            if field.read_only:
+                continue
+            sub_schema = self.field_to_jsonschema(field)
+            if field.required:
+                required.append(name)
+            properties[name] = sub_schema
+
+        result = {"type": "object", "properties": properties}
+        if required:
+            result["required"] = required
+        return result

authentik/blueprints/management/commands/schema_template.json

@@ -1,105 +0,0 @@
-{
-    "$schema": "http://json-schema.org/draft-07/schema",
-    "$id": "http://example.com/example.json",
-    "type": "object",
-    "title": "authentik Blueprint schema",
-    "default": {},
-    "required": [
-        "version",
-        "entries"
-    ],
-    "properties": {
-        "version": {
-            "$id": "#/properties/version",
-            "type": "integer",
-            "title": "Blueprint version",
-            "default": 1
-        },
-        "metadata": {
-            "$id": "#/properties/metadata",
-            "type": "object",
-            "required": [
-                "name"
-            ],
-            "properties": {
-                "name": {
-                    "type": "string"
-                },
-                "labels": {
-                    "type": "object"
-                }
-            }
-        },
-        "context": {
-            "$id": "#/properties/context",
-            "type": "object",
-            "additionalProperties": true
-        },
-        "entries": {
-            "type": "array",
-            "items": {
-                "$id": "#entry",
-                "type": "object",
-                "required": [
-                    "model"
-                ],
-                "properties": {
-                    "model": {
-                        "type": "string",
-                        "enum": [
-                            "placeholder"
-                        ]
-                    },
-                    "id": {
-                        "type": "string"
-                    },
-                    "state": {
-                        "type": "string",
-                        "enum": [
-                            "absent",
-                            "present",
-                            "created"
-                        ],
-                        "default": "present"
-                    },
-                    "conditions": {
-                        "type": "array",
-                        "items": {
-                            "type": "boolean"
-                        }
-                    },
-                    "attrs": {
-                        "type": "object",
-                        "properties": {
-                            "name": {
-                                "type": "string",
-                                "description": "Commonly available field, may not exist on all models"
-                            }
-                        },
-                        "default": {},
-                        "additionalProperties": true
-                    },
-                    "identifiers": {
-                        "type": "object",
-                        "default": {},
-                        "properties": {
-                            "pk": {
-                                "description": "Commonly available field, may not exist on all models",
-                                "anyOf": [
-                                    {
-                                        "type": "number"
-                                    },
-                                    {
-                                        "type": "string",
-                                        "format": "uuid"
-                                    }
-                                ]
-                            }
-                        },
-                        "additionalProperties": true
-                    }
-                }
-            }
-        }
-    }
-}

authentik/blueprints/migrations/0003_alter_blueprintinstance_name.py

@@ -0,0 +1,31 @@
+# Generated by Django 4.1.7 on 2023-04-28 10:49
+
+from django.db import migrations, models
+
+from authentik.lib.migrations import fallback_names
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("authentik_blueprints", "0002_blueprintinstance_content"),
+    ]
+
+    operations = [
+        migrations.RunPython(fallback_names("authentik_blueprints", "blueprintinstance", "name")),
+        migrations.AlterField(
+            model_name="blueprintinstance",
+            name="name",
+            field=models.TextField(unique=True),
+        ),
+        migrations.AlterField(
+            model_name="blueprintinstance",
+            name="managed",
+            field=models.TextField(
+                default=None,
+                help_text="Objects that are managed by authentik. These objects are created and updated automatically. This flag only indicates that an object can be overwritten by migrations. You can still modify the objects via the API, but expect changes to be overwritten in a later update.",
+                null=True,
+                unique=True,
+                verbose_name="Managed by authentik",
+            ),
+        ),
+    ]

authentik/blueprints/models.py

@@ -17,20 +17,20 @@ LOGGER = get_logger()
 
 
 class BlueprintRetrievalFailed(SentryIgnoredException):
-    """Error raised when we're unable to fetch the blueprint contents, whether it be HTTP files
+    """Error raised when we are unable to fetch the blueprint contents, whether it be HTTP files
     not being accessible or local files not being readable"""
 
 
 class ManagedModel(models.Model):
-    """Model which can be managed by authentik exclusively"""
+    """Model that can be managed by authentik exclusively"""
 
     managed = models.TextField(
         default=None,
         null=True,
         verbose_name=_("Managed by authentik"),
         help_text=_(
-            "Objects which are managed by authentik. These objects are created and updated "
-            "automatically. This is flag only indicates that an object can be overwritten by "
+            "Objects that are managed by authentik. These objects are created and updated "
+            "automatically. This flag only indicates that an object can be overwritten by "
             "migrations. You can still modify the objects via the API, but expect changes "
             "to be overwritten in a later update."
         ),
@@ -57,7 +57,7 @@ class BlueprintInstance(SerializerModel, ManagedModel, CreatedUpdatedModel):
 
     instance_uuid = models.UUIDField(primary_key=True, editable=False, default=uuid4)
 
-    name = models.TextField()
+    name = models.TextField(unique=True)
     metadata = models.JSONField(default=dict)
     path = models.TextField(default="", blank=True)
     content = models.TextField(default="", blank=True)

authentik/blueprints/tests/fixtures/conditional_fields.yaml

@@ -0,0 +1,41 @@
+version: 1
+metadata:
+  name: test conditional fields
+  labels:
+    blueprints.goauthentik.io/description: |
+      Some models have conditional fields that are only allowed in blueprint contexts
+      - Token (key)
+      - Application (icon)
+      - Source (icon)
+      - Flow (background)
+entries:
+  - model: authentik_core.token
+    identifiers:
+      identifier: %(uid)s-token
+    attrs:
+      key: %(uid)s
+      user: %(user)s
+      intent: api
+  - model: authentik_core.application
+    identifiers:
+      slug: %(uid)s-app
+    attrs:
+      name: %(uid)s-app
+      icon: https://goauthentik.io/img/icon.png
+  - model: authentik_sources_oauth.oauthsource
+    identifiers:
+      slug: %(uid)s-source
+    attrs:
+      name: %(uid)s-source
+      provider_type: azuread
+      consumer_key: %(uid)s
+      consumer_secret: %(uid)s
+      icon: https://goauthentik.io/img/icon.png
+  - model: authentik_flows.flow
+    identifiers:
+      slug: %(uid)s-flow
+    attrs:
+      name: %(uid)s-flow
+      title: %(uid)s-flow
+      designation: authentication
+      background: https://goauthentik.io/img/icon.png

authentik/blueprints/tests/test_v1_api.py

@@ -67,4 +67,7 @@ class TestBlueprintsV1API(APITestCase):
             },
         )
         self.assertEqual(res.status_code, 400)
-        self.assertJSONEqual(res.content.decode(), {"content": ["Failed to validate blueprint"]})
+        self.assertJSONEqual(
+            res.content.decode(),
+            {"content": ["Failed to validate blueprint: Invalid blueprint version"]},
+        )

authentik/blueprints/tests/test_v1_conditional_fields.py

@@ -0,0 +1,47 @@
+"""Test blueprints v1"""
+from django.test import TransactionTestCase
+
+from authentik.blueprints.v1.importer import Importer
+from authentik.core.models import Application, Token
+from authentik.core.tests.utils import create_test_admin_user
+from authentik.flows.models import Flow
+from authentik.lib.generators import generate_id
+from authentik.lib.tests.utils import load_fixture
+from authentik.sources.oauth.models import OAuthSource
+
+
+class TestBlueprintsV1ConditionalFields(TransactionTestCase):
+    """Test Blueprints conditional fields"""
+
+    def setUp(self) -> None:
+        user = create_test_admin_user()
+        self.uid = generate_id()
+        import_yaml = load_fixture("fixtures/conditional_fields.yaml", uid=self.uid, user=user.pk)
+
+        importer = Importer(import_yaml)
+        self.assertTrue(importer.validate()[0])
+        self.assertTrue(importer.apply())
+
+    def test_token(self):
+        """Test token"""
+        token = Token.objects.filter(identifier=f"{self.uid}-token").first()
+        self.assertIsNotNone(token)
+        self.assertEqual(token.key, self.uid)
+
+    def test_application(self):
+        """Test application"""
+        app = Application.objects.filter(slug=f"{self.uid}-app").first()
+        self.assertIsNotNone(app)
+        self.assertEqual(app.meta_icon, "https://goauthentik.io/img/icon.png")
+
+    def test_source(self):
+        """Test source"""
+        source = OAuthSource.objects.filter(slug=f"{self.uid}-source").first()
+        self.assertIsNotNone(source)
+        self.assertEqual(source.icon, "https://goauthentik.io/img/icon.png")
+
+    def test_flow(self):
+        """Test flow"""
+        flow = Flow.objects.filter(slug=f"{self.uid}-flow").first()
+        self.assertIsNotNone(flow)
+        self.assertEqual(flow.background, "https://goauthentik.io/img/icon.png")

authentik/blueprints/urls.py

@@ -0,0 +1,6 @@
+"""API URLs"""
+from authentik.blueprints.api import BlueprintInstanceViewSet
+
+api_urlpatterns = [
+    ("managed/blueprints", BlueprintInstanceViewSet),
+]

authentik/blueprints/v1/importer.py

@@ -299,7 +299,7 @@ class Importer:
         orig_import = deepcopy(self.__import)
         if self.__import.version != 1:
             self.logger.warning("Invalid blueprint version")
-            return False, []
+            return False, [{"event": "Invalid blueprint version"}]
         with (
             transaction_rollback(),
             capture_logs() as logs,

authentik/blueprints/v1/tasks.py

@@ -101,7 +101,10 @@ def blueprints_find():
     """Find blueprints and return valid ones"""
     blueprints = []
     root = Path(CONFIG.y("blueprints_dir"))
-    for path in root.glob("**/*.yaml"):
+    for path in root.rglob("**/*.yaml"):
+        # Check if any part in the path starts with a dot and assume a hidden file
+        if any(part for part in path.parts if part.startswith(".")):
+            continue
         LOGGER.debug("found blueprint", path=str(path))
         with open(path, "r", encoding="utf-8") as blueprint_file:
             try:

authentik/core/api/applications.py

@@ -11,7 +11,7 @@ from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import OpenApiParameter, OpenApiResponse, extend_schema
 from guardian.shortcuts import get_objects_for_user
 from rest_framework.decorators import action
-from rest_framework.fields import ReadOnlyField, SerializerMethodField
+from rest_framework.fields import CharField, ReadOnlyField, SerializerMethodField
 from rest_framework.parsers import MultiPartParser
 from rest_framework.request import Request
 from rest_framework.response import Response
@@ -23,6 +23,7 @@ from structlog.testing import capture_logs
 
 from authentik.admin.api.metrics import CoordinateSerializer
 from authentik.api.decorators import permission_required
+from authentik.blueprints.v1.importer import SERIALIZER_CONTEXT_BLUEPRINT
 from authentik.core.api.providers import ProviderSerializer
 from authentik.core.api.used_by import UsedByMixin
 from authentik.core.models import Application, User
@@ -51,6 +52,9 @@ class ApplicationSerializer(ModelSerializer):
 
     launch_url = SerializerMethodField()
     provider_obj = ProviderSerializer(source="get_provider", required=False, read_only=True)
+    backchannel_providers_obj = ProviderSerializer(
+        source="backchannel_providers", required=False, read_only=True, many=True
+    )
 
     meta_icon = ReadOnlyField(source="get_meta_icon")
 
@@ -61,6 +65,11 @@ class ApplicationSerializer(ModelSerializer):
             user = self.context["request"].user
         return app.get_launch_url(user)
 
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        if SERIALIZER_CONTEXT_BLUEPRINT in self.context:
+            self.fields["icon"] = CharField(source="meta_icon", required=False)
+
     class Meta:
         model = Application
         fields = [
@@ -69,6 +78,8 @@ class ApplicationSerializer(ModelSerializer):
             "slug",
             "provider",
             "provider_obj",
+            "backchannel_providers",
+            "backchannel_providers_obj",
             "launch_url",
             "open_in_new_tab",
             "meta_launch_url",
@@ -80,6 +91,7 @@ class ApplicationSerializer(ModelSerializer):
         ]
         extra_kwargs = {
             "meta_icon": {"read_only": True},
+            "backchannel_providers": {"required": False},
         }
 
 

authentik/core/api/propertymappings.py

@@ -93,7 +93,6 @@ class PropertyMappingViewSet(
                 {
                     "name": subclass._meta.verbose_name,
                     "description": subclass.__doc__,
-                    # pyright: reportGeneralTypeIssues=false
                     "component": subclass().component,
                     "model_name": subclass._meta.model_name,
                 }

authentik/core/api/providers.py

@@ -1,5 +1,7 @@
 """Provider API Views"""
 from django.utils.translation import gettext_lazy as _
+from django_filters.filters import BooleanFilter
+from django_filters.filterset import FilterSet
 from drf_spectacular.utils import extend_schema
 from rest_framework import mixins
 from rest_framework.decorators import action
@@ -20,12 +22,13 @@ class ProviderSerializer(ModelSerializer, MetaNameSerializer):
 
     assigned_application_slug = ReadOnlyField(source="application.slug")
     assigned_application_name = ReadOnlyField(source="application.name")
+    assigned_backchannel_application_slug = ReadOnlyField(source="backchannel_application.slug")
+    assigned_backchannel_application_name = ReadOnlyField(source="backchannel_application.name")
 
     component = SerializerMethodField()
 
     def get_component(self, obj: Provider) -> str:  # pragma: no cover
         """Get object component so that we know how to edit the object"""
-        # pyright: reportGeneralTypeIssues=false
         if obj.__class__ == Provider:
             return ""
         return obj.component
@@ -41,6 +44,8 @@ class ProviderSerializer(ModelSerializer, MetaNameSerializer):
             "component",
             "assigned_application_slug",
             "assigned_application_name",
+            "assigned_backchannel_application_slug",
+            "assigned_backchannel_application_name",
             "verbose_name",
             "verbose_name_plural",
             "meta_model_name",
@@ -50,6 +55,22 @@ class ProviderSerializer(ModelSerializer, MetaNameSerializer):
         }
 
 
+class ProviderFilter(FilterSet):
+    """Filter for groups"""
+
+    application__isnull = BooleanFilter(
+        field_name="application",
+        lookup_expr="isnull",
+    )
+    backchannel_only = BooleanFilter(
+        method="filter_backchannel_only",
+    )
+
+    def filter_backchannel_only(self, queryset, name, value):
+        """Only return backchannel providers"""
+        return queryset.filter(is_backchannel=value)
+
+
 class ProviderViewSet(
     mixins.RetrieveModelMixin,
     mixins.DestroyModelMixin,
@@ -61,9 +82,7 @@ class ProviderViewSet(
 
     queryset = Provider.objects.none()
     serializer_class = ProviderSerializer
-    filterset_fields = {
-        "application": ["isnull"],
-    }
+    filterset_class = ProviderFilter
     search_fields = [
         "name",
         "application__name",
@@ -79,6 +98,8 @@ class ProviderViewSet(
         data = []
         for subclass in all_subclasses(self.queryset.model):
             subclass: Provider
+            if subclass._meta.abstract:
+                continue
             data.append(
                 {
                     "name": subclass._meta.verbose_name,

authentik/core/api/sources.py

@@ -5,16 +5,18 @@ from django_filters.rest_framework import DjangoFilterBackend
 from drf_spectacular.utils import OpenApiResponse, extend_schema
 from rest_framework import mixins
 from rest_framework.decorators import action
+from rest_framework.fields import CharField, ReadOnlyField, SerializerMethodField
 from rest_framework.filters import OrderingFilter, SearchFilter
 from rest_framework.parsers import MultiPartParser
 from rest_framework.request import Request
 from rest_framework.response import Response
-from rest_framework.serializers import ModelSerializer, ReadOnlyField, SerializerMethodField
+from rest_framework.serializers import ModelSerializer
 from rest_framework.viewsets import GenericViewSet
 from structlog.stdlib import get_logger
 
 from authentik.api.authorization import OwnerFilter, OwnerSuperuserPermissions
 from authentik.api.decorators import permission_required
+from authentik.blueprints.v1.importer import SERIALIZER_CONTEXT_BLUEPRINT
 from authentik.core.api.used_by import UsedByMixin
 from authentik.core.api.utils import MetaNameSerializer, TypeCreateSerializer
 from authentik.core.models import Source, UserSourceConnection
@@ -40,11 +42,15 @@ class SourceSerializer(ModelSerializer, MetaNameSerializer):
 
     def get_component(self, obj: Source) -> str:
         """Get object component so that we know how to edit the object"""
-        # pyright: reportGeneralTypeIssues=false
         if obj.__class__ == Source:
             return ""
         return obj.component
 
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        if SERIALIZER_CONTEXT_BLUEPRINT in self.context:
+            self.fields["icon"] = CharField(required=False)
+
     class Meta:
         model = Source
         fields = [
@@ -139,7 +145,6 @@ class SourceViewSet(
                 component = subclass.__bases__[0]().component
             else:
                 component = subclass().component
-            # pyright: reportGeneralTypeIssues=false
             data.append(
                 {
                     "name": subclass._meta.verbose_name,

authentik/core/api/used_by.py

@@ -56,7 +56,6 @@ class UsedByMixin:
     # pylint: disable=too-many-locals
     def used_by(self, request: Request, *args, **kwargs) -> Response:
         """Get a list of all objects that use this object"""
-        # pyright: reportGeneralTypeIssues=false
         model: Model = self.get_object()
         used_by = []
         shadows = []

authentik/core/apps.py

@@ -11,7 +11,6 @@ class AuthentikCoreConfig(ManagedAppConfig):
     label = "authentik_core"
     verbose_name = "authentik Core"
     mountpoint = ""
-    ws_mountpoint = "authentik.core.urls"
     default = True
 
     def reconcile_load_core_signals(self):

authentik/core/migrations/0029_provider_backchannel_applications_and_more.py

@@ -0,0 +1,82 @@
+# Generated by Django 4.1.7 on 2023-04-30 17:56
+
+import django.db.models.deletion
+from django.apps.registry import Apps
+from django.db import DatabaseError, InternalError, ProgrammingError, migrations, models
+from django.db.backends.base.schema import BaseDatabaseSchemaEditor
+
+
+def backport_is_backchannel(apps: Apps, schema_editor: BaseDatabaseSchemaEditor):
+    from authentik.core.models import BackchannelProvider
+
+    for model in BackchannelProvider.__subclasses__():
+        try:
+            for obj in model.objects.all():
+                obj.is_backchannel = True
+                obj.save()
+        except (DatabaseError, InternalError, ProgrammingError):
+            # The model might not have been migrated yet/doesn't exist yet
+            # so we don't need to worry about backporting the data
+            pass
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("authentik_core", "0028_provider_authentication_flow"),
+        ("authentik_providers_ldap", "0002_ldapprovider_bind_mode"),
+        ("authentik_providers_scim", "0006_rename_parent_group_scimprovider_filter_group"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="provider",
+            name="backchannel_application",
+            field=models.ForeignKey(
+                default=None,
+                help_text="Accessed from applications; optional backchannel providers for protocols like LDAP and SCIM.",
+                null=True,
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="backchannel_providers",
+                to="authentik_core.application",
+            ),
+        ),
+        migrations.AddField(
+            model_name="provider",
+            name="is_backchannel",
+            field=models.BooleanField(default=False),
+        ),
+        migrations.RunPython(backport_is_backchannel),
+        migrations.AlterField(
+            model_name="propertymapping",
+            name="managed",
+            field=models.TextField(
+                default=None,
+                help_text="Objects that are managed by authentik. These objects are created and updated automatically. This flag only indicates that an object can be overwritten by migrations. You can still modify the objects via the API, but expect changes to be overwritten in a later update.",
+                null=True,
+                unique=True,
+                verbose_name="Managed by authentik",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="source",
+            name="managed",
+            field=models.TextField(
+                default=None,
+                help_text="Objects that are managed by authentik. These objects are created and updated automatically. This flag only indicates that an object can be overwritten by migrations. You can still modify the objects via the API, but expect changes to be overwritten in a later update.",
+                null=True,
+                unique=True,
+                verbose_name="Managed by authentik",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="token",
+            name="managed",
+            field=models.TextField(
+                default=None,
+                help_text="Objects that are managed by authentik. These objects are created and updated automatically. This flag only indicates that an object can be overwritten by migrations. You can still modify the objects via the API, but expect changes to be overwritten in a later update.",
+                null=True,
+                unique=True,
+                verbose_name="Managed by authentik",
+            ),
+        ),
+    ]

authentik/core/models.py

@@ -270,6 +270,20 @@ class Provider(SerializerModel):
 
     property_mappings = models.ManyToManyField("PropertyMapping", default=None, blank=True)
 
+    backchannel_application = models.ForeignKey(
+        "Application",
+        default=None,
+        null=True,
+        on_delete=models.CASCADE,
+        help_text=_(
+            "Accessed from applications; optional backchannel providers for protocols "
+            "like LDAP and SCIM."
+        ),
+        related_name="backchannel_providers",
+    )
+
+    is_backchannel = models.BooleanField(default=False)
+
     objects = InheritanceManager()
 
     @property
@@ -292,6 +306,26 @@ class Provider(SerializerModel):
         return str(self.name)
 
 
+class BackchannelProvider(Provider):
+    """Base class for providers that augment other providers, for example LDAP and SCIM.
+    Multiple of these providers can be configured per application, they may not use the application
+    slug in URLs as an application may have multiple instances of the same
+    type of Backchannel provider
+
+    They can use the application's policies and metadata"""
+
+    @property
+    def component(self) -> str:
+        raise NotImplementedError
+
+    @property
+    def serializer(self) -> type[Serializer]:
+        raise NotImplementedError
+
+    class Meta:
+        abstract = True
+
+
 class Application(SerializerModel, PolicyBindingModel):
     """Every Application which uses authentik for authentication/identification/authorization
     needs an Application record. Other authentication types can subclass this Model to

authentik/core/signals.py

@@ -6,11 +6,11 @@ from django.contrib.sessions.backends.cache import KEY_PREFIX
 from django.core.cache import cache
 from django.core.signals import Signal
 from django.db.models import Model
-from django.db.models.signals import post_save, pre_delete
+from django.db.models.signals import post_save, pre_delete, pre_save
 from django.dispatch import receiver
 from django.http.request import HttpRequest
 
-from authentik.core.models import Application, AuthenticatedSession
+from authentik.core.models import Application, AuthenticatedSession, BackchannelProvider
 
 # Arguments: user: User, password: str
 password_changed = Signal()
@@ -54,3 +54,11 @@ def authenticated_session_delete(sender: type[Model], instance: "AuthenticatedSe
     """Delete session when authenticated session is deleted"""
     cache_key = f"{KEY_PREFIX}{instance.session_key}"
     cache.delete(cache_key)
+
+
+@receiver(pre_save)
+def backchannel_provider_pre_save(sender: type[Model], instance: Model, **_):
+    """Ensure backchannel providers have is_backchannel set to true"""
+    if not isinstance(instance, BackchannelProvider):
+        return
+    instance.is_backchannel = True

authentik/core/tests/test_applications_api.py

@@ -139,6 +139,8 @@ class TestApplicationsAPI(APITestCase):
                             "verbose_name": "OAuth2/OpenID Provider",
                             "verbose_name_plural": "OAuth2/OpenID Providers",
                         },
+                        "backchannel_providers": [],
+                        "backchannel_providers_obj": [],
                         "launch_url": f"https://goauthentik.io/{self.user.username}",
                         "meta_launch_url": "https://goauthentik.io/%(username)s",
                         "open_in_new_tab": True,
@@ -189,6 +191,8 @@ class TestApplicationsAPI(APITestCase):
                             "verbose_name": "OAuth2/OpenID Provider",
                             "verbose_name_plural": "OAuth2/OpenID Providers",
                         },
+                        "backchannel_providers": [],
+                        "backchannel_providers_obj": [],
                         "launch_url": f"https://goauthentik.io/{self.user.username}",
                         "meta_launch_url": "https://goauthentik.io/%(username)s",
                         "open_in_new_tab": True,
@@ -210,6 +214,8 @@ class TestApplicationsAPI(APITestCase):
                         "policy_engine_mode": "any",
                         "provider": None,
                         "provider_obj": None,
+                        "backchannel_providers": [],
+                        "backchannel_providers_obj": [],
                         "slug": "denied",
                     },
                 ],

authentik/core/tests/test_models.py

@@ -53,9 +53,8 @@ def provider_tester_factory(test_model: type[Stage]) -> Callable:
     def tester(self: TestModels):
         model_class = None
         if test_model._meta.abstract:  # pragma: no cover
-            model_class = test_model.__bases__[0]()
-        else:
-            model_class = test_model()
+            return
+        model_class = test_model()
         self.assertIsNotNone(model_class.component)
 
     return tester

authentik/core/tests/test_token_api.py

@@ -77,6 +77,7 @@ class TestTokenAPI(APITestCase):
 
     def test_list(self):
         """Test Token List (Test normal authentication)"""
+        Token.objects.all().delete()
         token_should: Token = Token.objects.create(
             identifier="test", expiring=False, user=self.user
         )
@@ -88,6 +89,7 @@ class TestTokenAPI(APITestCase):
 
     def test_list_admin(self):
         """Test Token List (Test with admin auth)"""
+        Token.objects.all().delete()
         self.client.force_login(self.admin)
         token_should: Token = Token.objects.create(
             identifier="test", expiring=False, user=self.user

authentik/core/urls.py

@@ -7,12 +7,22 @@ from django.urls import path
 from django.views.decorators.csrf import ensure_csrf_cookie
 from django.views.generic import RedirectView
 
+from authentik.core.api.applications import ApplicationViewSet
+from authentik.core.api.authenticated_sessions import AuthenticatedSessionViewSet
+from authentik.core.api.devices import AdminDeviceViewSet, DeviceViewSet
+from authentik.core.api.groups import GroupViewSet
+from authentik.core.api.propertymappings import PropertyMappingViewSet
+from authentik.core.api.providers import ProviderViewSet
+from authentik.core.api.sources import SourceViewSet, UserSourceConnectionViewSet
+from authentik.core.api.tokens import TokenViewSet
+from authentik.core.api.users import UserViewSet
 from authentik.core.views import apps, impersonate
 from authentik.core.views.debug import AccessDeniedView
 from authentik.core.views.interface import FlowInterfaceView, InterfaceView
 from authentik.core.views.session import EndSessionView
 from authentik.root.asgi_middleware import SessionMiddleware
 from authentik.root.messages.consumer import MessageConsumer
+from authentik.root.middleware import ChannelsLoggingMiddleware
 
 urlpatterns = [
     path(
@@ -68,9 +78,30 @@ urlpatterns = [
     ),
 ]
 
+api_urlpatterns = [
+    ("core/authenticated_sessions", AuthenticatedSessionViewSet),
+    ("core/applications", ApplicationViewSet),
+    ("core/groups", GroupViewSet),
+    ("core/users", UserViewSet),
+    ("core/tokens", TokenViewSet),
+    ("sources/all", SourceViewSet),
+    ("sources/user_connections/all", UserSourceConnectionViewSet),
+    ("providers/all", ProviderViewSet),
+    ("propertymappings/all", PropertyMappingViewSet),
+    ("authenticators/all", DeviceViewSet, "device"),
+    (
+        "authenticators/admin/all",
+        AdminDeviceViewSet,
+        "admin-device",
+    ),
+]
+
 websocket_urlpatterns = [
     path(
-        "ws/client/", CookieMiddleware(SessionMiddleware(AuthMiddleware(MessageConsumer.as_asgi())))
+        "ws/client/",
+        ChannelsLoggingMiddleware(
+            CookieMiddleware(SessionMiddleware(AuthMiddleware(MessageConsumer.as_asgi())))
+        ),
     ),
 ]
 

authentik/crypto/api.py

@@ -160,6 +160,7 @@ class CertificateKeyPairSerializer(ModelSerializer):
             "managed",
         ]
         extra_kwargs = {
+            "managed": {"read_only": True},
             "key_data": {"write_only": True},
             "certificate_data": {"write_only": True},
         }

authentik/crypto/migrations/0004_alter_certificatekeypair_name.py

@@ -0,0 +1,31 @@
+# Generated by Django 4.1.7 on 2023-04-28 10:49
+
+from django.db import migrations, models
+
+from authentik.lib.migrations import fallback_names
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("authentik_crypto", "0003_certificatekeypair_managed"),
+    ]
+
+    operations = [
+        migrations.RunPython(fallback_names("authentik_crypto", "certificatekeypair", "name")),
+        migrations.AlterField(
+            model_name="certificatekeypair",
+            name="name",
+            field=models.TextField(unique=True),
+        ),
+        migrations.AlterField(
+            model_name="certificatekeypair",
+            name="managed",
+            field=models.TextField(
+                default=None,
+                help_text="Objects that are managed by authentik. These objects are created and updated automatically. This flag only indicates that an object can be overwritten by migrations. You can still modify the objects via the API, but expect changes to be overwritten in a later update.",
+                null=True,
+                unique=True,
+                verbose_name="Managed by authentik",
+            ),
+        ),
+    ]

authentik/crypto/models.py

@@ -26,7 +26,7 @@ class CertificateKeyPair(SerializerModel, ManagedModel, CreatedUpdatedModel):
 
     kp_uuid = models.UUIDField(primary_key=True, editable=False, default=uuid4)
 
-    name = models.TextField()
+    name = models.TextField(unique=True)
     certificate_data = models.TextField(help_text=_("PEM-encoded Certificate data"))
     key_data = models.TextField(
         help_text=_(

authentik/crypto/tests.py

@@ -37,20 +37,22 @@ class TestCrypto(APITestCase):
         keypair = create_test_cert()
         self.assertTrue(
             CertificateKeyPairSerializer(
+                instance=keypair,
                 data={
                     "name": keypair.name,
                     "certificate_data": keypair.certificate_data,
                     "key_data": keypair.key_data,
-                }
+                },
             ).is_valid()
         )
         self.assertFalse(
             CertificateKeyPairSerializer(
+                instance=keypair,
                 data={
                     "name": keypair.name,
                     "certificate_data": "test",
                     "key_data": "test",
-                }
+                },
             ).is_valid()
         )
 
@@ -246,7 +248,6 @@ class TestCrypto(APITestCase):
             with open(f"{temp_dir}/foo.bar/privkey.pem", "w+", encoding="utf-8") as _key:
                 _key.write(builder.private_key)
             with CONFIG.patch("cert_discovery_dir", temp_dir):
-                # pyright: reportGeneralTypeIssues=false
                 certificate_discovery()  # pylint: disable=no-value-for-parameter
         keypair: CertificateKeyPair = CertificateKeyPair.objects.filter(
             managed=MANAGED_DISCOVERED % "foo"

authentik/crypto/urls.py

@@ -0,0 +1,6 @@
+"""API URLs"""
+from authentik.crypto.api import CertificateKeyPairViewSet
+
+api_urlpatterns = [
+    ("crypto/certificatekeypairs", CertificateKeyPairViewSet),
+]

authentik/events/models.py

@@ -219,13 +219,13 @@ class Event(SerializerModel, ExpiringModel):
             self.context["http_request"] = {
                 "path": request.path,
                 "method": request.method,
-                "args": QueryDict(request.META.get("QUERY_STRING", "")),
+                "args": cleanse_dict(QueryDict(request.META.get("QUERY_STRING", ""))),
             }
             # Special case for events created during flow execution
             # since they keep the http query within a wrapped query
             if QS_QUERY in self.context["http_request"]["args"]:
                 wrapped = self.context["http_request"]["args"][QS_QUERY]
-                self.context["http_request"]["args"] = QueryDict(wrapped)
+                self.context["http_request"]["args"] = cleanse_dict(QueryDict(wrapped))
         if hasattr(request, "tenant"):
             tenant: Tenant = request.tenant
             # Because self.created only gets set on save, we can't use it's value here
@@ -353,6 +353,9 @@ class NotificationTransport(SerializerModel):
             "user_email": notification.user.email,
             "user_username": notification.user.username,
         }
+        if notification.event and notification.event.user:
+            default_body["event_user_email"] = notification.event.user.get("email", None)
+            default_body["event_user_username"] = notification.event.user.get("username", None)
         if self.webhook_mapping:
             default_body = sanitize_item(
                 self.webhook_mapping.evaluate(
@@ -391,6 +394,14 @@ class NotificationTransport(SerializerModel):
             },
         ]
         if notification.event:
+            if notification.event.user:
+                fields.append(
+                    {
+                        "title": _("Event user"),
+                        "value": str(notification.event.user.get("username")),
+                        "short": True,
+                    },
+                )
             for key, value in notification.event.context.items():
                 if not isinstance(value, str):
                     continue
@@ -429,7 +440,13 @@ class NotificationTransport(SerializerModel):
     def send_email(self, notification: "Notification") -> list[str]:
         """Send notification via global email configuration"""
         subject = "authentik Notification: "
-        key_value = {}
+        key_value = {
+            "user_email": notification.user.email,
+            "user_username": notification.user.username,
+        }
+        if notification.event and notification.event.user:
+            key_value["event_user_email"] = notification.event.user.get("email", None)
+            key_value["event_user_username"] = notification.event.user.get("username", None)
         if notification.event:
             subject += notification.event.action
             for key, value in notification.event.context.items():
@@ -453,7 +470,6 @@ class NotificationTransport(SerializerModel):
         try:
             from authentik.stages.email.tasks import send_mail
 
-            # pyright: reportGeneralTypeIssues=false
             return send_mail(mail.__dict__)  # pylint: disable=no-value-for-parameter
         except (SMTPException, ConnectionError, OSError) as exc:
             raise NotificationTransportError(exc) from exc

authentik/events/tests/test_event.py

@@ -1,17 +1,25 @@
 """event tests"""
+from urllib.parse import urlencode
 
 from django.contrib.contenttypes.models import ContentType
-from django.test import TestCase
+from django.test import RequestFactory, TestCase
+from django.views.debug import SafeExceptionReporterFilter
 from guardian.shortcuts import get_anonymous_user
 
 from authentik.core.models import Group
 from authentik.events.models import Event
+from authentik.flows.views.executor import QS_QUERY
+from authentik.lib.generators import generate_id
 from authentik.policies.dummy.models import DummyPolicy
+from authentik.tenants.models import Tenant
 
 
 class TestEvents(TestCase):
     """Test Event"""
 
+    def setUp(self) -> None:
+        self.factory = RequestFactory()
+
     def test_new_with_model(self):
         """Create a new Event passing a model as kwarg"""
         test_model = Group.objects.create(name="test")
@@ -40,3 +48,58 @@ class TestEvents(TestCase):
         model_content_type = ContentType.objects.get_for_model(temp_model)
         self.assertEqual(event.context.get("model").get("app"), model_content_type.app_label)
         self.assertEqual(event.context.get("model").get("pk"), temp_model.pk.hex)
+
+    def test_from_http_basic(self):
+        """Test plain from_http"""
+        event = Event.new("unittest").from_http(self.factory.get("/"))
+        self.assertEqual(
+            event.context, {"http_request": {"args": {}, "method": "GET", "path": "/"}}
+        )
+
+    def test_from_http_clean_querystring(self):
+        """Test cleansing query string"""
+        request = self.factory.get(f"/?token={generate_id()}")
+        event = Event.new("unittest").from_http(request)
+        self.assertEqual(
+            event.context,
+            {
+                "http_request": {
+                    "args": {"token": SafeExceptionReporterFilter.cleansed_substitute},
+                    "method": "GET",
+                    "path": "/",
+                }
+            },
+        )
+
+    def test_from_http_clean_querystring_flow(self):
+        """Test cleansing query string (nested query string like flow executor)"""
+        nested_qs = {"token": generate_id()}
+        request = self.factory.get(f"/?{QS_QUERY}={urlencode(nested_qs)}")
+        event = Event.new("unittest").from_http(request)
+        self.assertEqual(
+            event.context,
+            {
+                "http_request": {
+                    "args": {"token": SafeExceptionReporterFilter.cleansed_substitute},
+                    "method": "GET",
+                    "path": "/",
+                }
+            },
+        )
+
+    def test_from_http_tenant(self):
+        """Test from_http tenant"""
+        # Test tenant
+        request = self.factory.get("/")
+        tenant = Tenant(domain="test-tenant")
+        setattr(request, "tenant", tenant)
+        event = Event.new("unittest").from_http(request)
+        self.assertEqual(
+            event.tenant,
+            {
+                "app": "authentik_tenants",
+                "model_name": "tenant",
+                "name": "Tenant test-tenant",
+                "pk": tenant.pk.hex,
+            },
+        )

authentik/events/tests/test_transports.py

@@ -52,6 +52,8 @@ class TestEventTransports(TestCase):
                     "severity": "alert",
                     "user_email": self.user.email,
                     "user_username": self.user.username,
+                    "event_user_email": self.user.email,
+                    "event_user_username": self.user.username,
                 },
             )
 
@@ -107,6 +109,7 @@ class TestEventTransports(TestCase):
                                     "value": self.user.username,
                                     "short": True,
                                 },
+                                {"short": True, "title": "Event user", "value": self.user.username},
                                 {"title": "foo", "value": "bar,"},
                             ],
                             "footer": f"authentik {get_full_version()}",

authentik/events/urls.py

@@ -0,0 +1,14 @@
+"""API URLs"""
+from authentik.events.api.events import EventViewSet
+from authentik.events.api.notification_mappings import NotificationWebhookMappingViewSet
+from authentik.events.api.notification_rules import NotificationRuleViewSet
+from authentik.events.api.notification_transports import NotificationTransportViewSet
+from authentik.events.api.notifications import NotificationViewSet
+
+api_urlpatterns = [
+    ("events/events", EventViewSet),
+    ("events/notifications", NotificationViewSet),
+    ("events/transports", NotificationTransportViewSet),
+    ("events/rules", NotificationRuleViewSet),
+    ("propertymappings/notification", NotificationWebhookMappingViewSet),
+]

authentik/flows/api/flows.py

@@ -6,7 +6,7 @@ from django.utils.translation import gettext as _
 from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import OpenApiResponse, extend_schema
 from rest_framework.decorators import action
-from rest_framework.fields import BooleanField, DictField, ListField, ReadOnlyField
+from rest_framework.fields import BooleanField, CharField, DictField, ListField, ReadOnlyField
 from rest_framework.parsers import MultiPartParser
 from rest_framework.request import Request
 from rest_framework.response import Response
@@ -16,7 +16,7 @@ from structlog.stdlib import get_logger
 
 from authentik.api.decorators import permission_required
 from authentik.blueprints.v1.exporter import FlowExporter
-from authentik.blueprints.v1.importer import Importer
+from authentik.blueprints.v1.importer import SERIALIZER_CONTEXT_BLUEPRINT, Importer
 from authentik.core.api.used_by import UsedByMixin
 from authentik.core.api.utils import CacheSerializer, LinkSerializer, PassiveSerializer
 from authentik.events.utils import sanitize_dict
@@ -52,6 +52,11 @@ class FlowSerializer(ModelSerializer):
         """Get export URL for flow"""
         return reverse("authentik_api:flow-export", kwargs={"slug": flow.slug})
 
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        if SERIALIZER_CONTEXT_BLUEPRINT in self.context:
+            self.fields["background"] = CharField(required=False)
+
     class Meta:
         model = Flow
         fields = [

authentik/flows/api/stages.py

@@ -27,7 +27,6 @@ class StageSerializer(ModelSerializer, MetaNameSerializer):
 
     def get_component(self, obj: Stage) -> str:
         """Get object type so that we know how to edit the object"""
-        # pyright: reportGeneralTypeIssues=false
         if obj.__class__ == Stage:
             return ""
         return obj.component

authentik/flows/challenge.py

@@ -182,5 +182,4 @@ class HttpChallengeResponse(JsonResponse):
     """Subclass of JsonResponse that uses the `DataclassEncoder`"""
 
     def __init__(self, challenge, **kwargs) -> None:
-        # pyright: reportGeneralTypeIssues=false
         super().__init__(challenge.data, encoder=DataclassEncoder, **kwargs)

authentik/flows/urls.py

@@ -1,8 +1,17 @@
 """flow urls"""
 from django.urls import path
 
+from authentik.flows.api.bindings import FlowStageBindingViewSet
+from authentik.flows.api.flows import FlowViewSet
+from authentik.flows.api.stages import StageViewSet
 from authentik.flows.models import FlowDesignation
-from authentik.flows.views.executor import CancelView, ConfigureFlowInitView, ToDefaultFlow
+from authentik.flows.views.executor import (
+    CancelView,
+    ConfigureFlowInitView,
+    FlowExecutorView,
+    ToDefaultFlow,
+)
+from authentik.flows.views.inspector import FlowInspectorView
 
 urlpatterns = [
     path(
@@ -22,3 +31,19 @@ urlpatterns = [
         name="configure",
     ),
 ]
+
+api_urlpatterns = [
+    ("flows/instances", FlowViewSet),
+    ("flows/bindings", FlowStageBindingViewSet),
+    ("stages/all", StageViewSet),
+    path(
+        "flows/executor/<slug:flow_slug>/",
+        FlowExecutorView.as_view(),
+        name="flow-executor",
+    ),
+    path(
+        "flows/inspector/<slug:flow_slug>/",
+        FlowInspectorView.as_view(),
+        name="flow-inspector",
+    ),
+]

authentik/lib/config.py

@@ -177,7 +177,6 @@ class ConfigLoader:
         # Walk each component of the path
         path_parts = path.split(sep)
         for comp in path_parts[:-1]:
-            # pyright: reportGeneralTypeIssues=false
             if comp not in root:
                 root[comp] = {}
             root = root.get(comp, {})

authentik/lib/default.yml

@@ -31,7 +31,7 @@ log_level: info
 
 error_reporting:
   enabled: false
-  sentry_dsn: https://151ba72610234c4c97c5bcff4e1cffd8@o4504163616882688.ingest.sentry.io/4504163677503489
+  sentry_dsn: https://151ba72610234c4c97c5bcff4e1cffd8@authentik.error-reporting.a7k.io/4504163677503489
   environment: customer
   send_pii: false
   sample_rate: 0.1
@@ -77,8 +77,8 @@ geoip: "/geoip/GeoLite2-City.mmdb"
 footer_links: []
 
 default_user_change_name: true
-default_user_change_email: true
-default_user_change_username: true
+default_user_change_email: false
+default_user_change_username: false
 
 gdpr_compliance: true
 cert_discovery_dir: /certs

authentik/outposts/api/service_connections.py

@@ -31,7 +31,6 @@ class ServiceConnectionSerializer(ModelSerializer, MetaNameSerializer):
 
     def get_component(self, obj: OutpostServiceConnection) -> str:
         """Get object type so that we know how to edit the object"""
-        # pyright: reportGeneralTypeIssues=false
         if obj.__class__ == OutpostServiceConnection:
             return ""
         return obj.component
@@ -77,7 +76,6 @@ class ServiceConnectionViewSet(
         data = []
         for subclass in all_subclasses(self.queryset.model):
             subclass: OutpostServiceConnection
-            # pyright: reportGeneralTypeIssues=false
             data.append(
                 {
                     "name": subclass._meta.verbose_name,

authentik/outposts/apps.py

@@ -24,7 +24,6 @@ class AuthentikOutpostConfig(ManagedAppConfig):
     label = "authentik_outposts"
     verbose_name = "authentik Outpost"
     default = True
-    ws_mountpoint = "authentik.outposts.urls"
 
     def reconcile_load_outposts_signals(self):
         """Load outposts signals"""

authentik/outposts/controllers/docker.py

@@ -1,5 +1,4 @@
 """Docker controller"""
-from subprocess import SubprocessError  # nosec
 from time import sleep
 from typing import Optional
 from urllib.parse import urlparse
@@ -10,6 +9,7 @@ from docker import DockerClient as UpstreamDockerClient
 from docker.errors import DockerException, NotFound
 from docker.models.containers import Container
 from docker.utils.utils import kwargs_from_env
+from paramiko.ssh_exception import SSHException
 from structlog.stdlib import get_logger
 from yaml import safe_dump
 
@@ -58,9 +58,8 @@ class DockerClient(UpstreamDockerClient, BaseClient):
                 super().__init__(
                     base_url=connection.url,
                     tls=tls_config,
-                    use_ssh_client=True,
                 )
-            except SubprocessError as exc:
+            except SSHException as exc:
                 if self.ssh:
                     self.ssh.cleanup()
                 raise ServiceConnectionInvalid(exc) from exc

authentik/outposts/docker_ssh.py

@@ -7,7 +7,8 @@ from docker.errors import DockerException
 
 from authentik.crypto.models import CertificateKeyPair
 
-SSH_CONFIG_DIR = Path("/etc/ssh/ssh_config.d/")
+HEADER = "### Managed by authentik"
+FOOTER = "### End Managed by authentik"
 
 
 def opener(path, flags):
@@ -27,54 +28,70 @@ class DockerInlineSSH:
 
     key_path: str
     config_path: Path
+    header: str
 
     def __init__(self, host: str, keypair: CertificateKeyPair) -> None:
         self.host = host
         self.keypair = keypair
-        self.config_path = SSH_CONFIG_DIR / Path(self.host + ".conf")
-        with open(self.config_path, "w", encoding="utf-8") as _config:
-            if not _config.writable():
-                # SSH Config file already exists and there's no header from us, meaning that it's
-                # been externally mapped into the container for more complex configs
-                raise SSHManagedExternallyException(
-                    "SSH Config exists and does not contain authentik header"
-                )
+        self.config_path = Path("~/.ssh/config").expanduser()
+        if self.config_path.exists() and HEADER not in self.config_path.read_text(encoding="utf-8"):
+            # SSH Config file already exists and there's no header from us, meaning that it's
+            # been externally mapped into the container for more complex configs
+            raise SSHManagedExternallyException(
+                "SSH Config exists and does not contain authentik header"
+            )
         if not self.keypair:
             raise DockerException("keypair must be set for SSH connections")
+        self.header = f"{HEADER} - {self.host}\n"
 
-    def write_config(self, key_path: str):
+    def write_config(self, key_path: str) -> bool:
         """Update the local user's ssh config file"""
-        with open(self.config_path, "w", encoding="utf-8") as ssh_config:
+        with open(self.config_path, "a+", encoding="utf-8") as ssh_config:
+            if self.header in ssh_config.readlines():
+                return False
             ssh_config.writelines(
                 [
+                    self.header,
                     f"Host {self.host}\n",
-                    f"    IdentityFile {str(key_path)}\n",
+                    f"    IdentityFile {key_path}\n",
                     "    StrictHostKeyChecking No\n",
                     "    UserKnownHostsFile /dev/null\n",
+                    f"{FOOTER}\n",
                     "\n",
                 ]
             )
+        return True
 
-    def write_key(self) -> Path:
+    def write_key(self):
         """Write keypair's private key to a temporary file"""
         path = Path(gettempdir(), f"{self.keypair.pk}_private.pem")
         with open(path, "w", encoding="utf8", opener=opener) as _file:
             _file.write(self.keypair.key_data)
-        return path
+        return str(path)
 
     def write(self):
         """Write keyfile and update ssh config"""
         self.key_path = self.write_key()
-        try:
-            self.write_config(self.key_path)
-        except OSError:
+        was_written = self.write_config(self.key_path)
+        if not was_written:
             self.cleanup()
 
     def cleanup(self):
         """Cleanup when we're done"""
         try:
             os.unlink(self.key_path)
-            os.unlink(self.config_path)
+            with open(self.config_path, "r", encoding="utf-8") as ssh_config:
+                start = 0
+                end = 0
+                lines = ssh_config.readlines()
+                for idx, line in enumerate(lines):
+                    if line == self.header:
+                        start = idx
+                    if start != 0 and line == f"{FOOTER}\n":
+                        end = idx
+            with open(self.config_path, "w+", encoding="utf-8") as ssh_config:
+                lines = lines[:start] + lines[end + 2 :]
+                ssh_config.writelines(lines)
         except OSError:
             # If we fail deleting a file it doesn't matter that much
             # since we're just in a container

authentik/outposts/migrations/0020_alter_outpost_type.py

@@ -17,4 +17,15 @@ class Migration(migrations.Migration):
                 default="proxy",
             ),
         ),
+        migrations.AlterField(
+            model_name="outpost",
+            name="managed",
+            field=models.TextField(
+                default=None,
+                help_text="Objects that are managed by authentik. These objects are created and updated automatically. This flag only indicates that an object can be overwritten by migrations. You can still modify the objects via the API, but expect changes to be overwritten in a later update.",
+                null=True,
+                unique=True,
+                verbose_name="Managed by authentik",
+            ),
+        ),
     ]

authentik/outposts/models.py

@@ -128,7 +128,7 @@ class OutpostServiceConnection(models.Model):
     @property
     def state_key(self) -> str:
         """Key used to save connection state in cache"""
-        return f"outpost_service_connection_{self.pk.hex}"
+        return f"goauthentik.io/outposts/service_connection_state/{self.pk.hex}"
 
     @property
     def state(self) -> OutpostServiceConnectionState:
@@ -278,7 +278,7 @@ class Outpost(SerializerModel, ManagedModel):
     @property
     def state_cache_prefix(self) -> str:
         """Key by which the outposts status is saved"""
-        return f"goauthentik.io/outposts/{self.uuid.hex}_state"
+        return f"goauthentik.io/outposts/state/{self.uuid.hex}"
 
     @property
     def state(self) -> list["OutpostState"]:
@@ -433,19 +433,19 @@ class OutpostState:
     @staticmethod
     def for_outpost(outpost: Outpost) -> list["OutpostState"]:
         """Get all states for an outpost"""
-        keys = cache.keys(f"{outpost.state_cache_prefix}_*")
+        keys = cache.keys(f"{outpost.state_cache_prefix}/*")
         if not keys:
             return []
         states = []
         for key in keys:
-            instance_uid = key.replace(f"{outpost.state_cache_prefix}_", "")
+            instance_uid = key.replace(f"{outpost.state_cache_prefix}/", "")
             states.append(OutpostState.for_instance_uid(outpost, instance_uid))
         return states
 
     @staticmethod
     def for_instance_uid(outpost: Outpost, uid: str) -> "OutpostState":
         """Get state for a single instance"""
-        key = f"{outpost.state_cache_prefix}_{uid}"
+        key = f"{outpost.state_cache_prefix}/{uid}"
         default_data = {"uid": uid, "channel_ids": []}
         data = cache.get(key, default_data)
         if isinstance(data, str):
@@ -458,10 +458,10 @@ class OutpostState:
 
     def save(self, timeout=OUTPOST_HELLO_INTERVAL):
         """Save current state to cache"""
-        full_key = f"{self._outpost.state_cache_prefix}_{self.uid}"
+        full_key = f"{self._outpost.state_cache_prefix}/{self.uid}"
         return cache.set(full_key, asdict(self), timeout=timeout)
 
     def delete(self):
         """Manually delete from cache, used on channel disconnect"""
-        full_key = f"{self._outpost.state_cache_prefix}_{self.uid}"
+        full_key = f"{self._outpost.state_cache_prefix}/{self.uid}"
         cache.delete(full_key)

authentik/outposts/tasks.py

@@ -45,7 +45,7 @@ from authentik.providers.proxy.controllers.kubernetes import ProxyKubernetesCont
 from authentik.root.celery import CELERY_APP
 
 LOGGER = get_logger()
-CACHE_KEY_OUTPOST_DOWN = "outpost_teardown_%s"
+CACHE_KEY_OUTPOST_DOWN = "goauthentik.io/outposts/teardown/%s"
 
 
 def controller_for_outpost(outpost: Outpost) -> Optional[type[BaseController]]:
@@ -148,6 +148,8 @@ def outpost_controller(
     except (ControllerException, ServiceConnectionInvalid) as exc:
         self.set_status(TaskResult(TaskResultStatus.ERROR).with_error(exc))
     else:
+        if from_cache:
+            cache.delete(CACHE_KEY_OUTPOST_DOWN % outpost_pk)
         self.set_status(TaskResult(TaskResultStatus.SUCCESSFUL, logs))
 
 

authentik/outposts/urls.py

@@ -1,8 +1,22 @@
 """Outpost Websocket URLS"""
 from django.urls import path
 
+from authentik.outposts.api.outposts import OutpostViewSet
+from authentik.outposts.api.service_connections import (
+    DockerServiceConnectionViewSet,
+    KubernetesServiceConnectionViewSet,
+    ServiceConnectionViewSet,
+)
 from authentik.outposts.channels import OutpostConsumer
+from authentik.root.middleware import ChannelsLoggingMiddleware
 
 websocket_urlpatterns = [
-    path("ws/outpost/<uuid:pk>/", OutpostConsumer.as_asgi()),
+    path("ws/outpost/<uuid:pk>/", ChannelsLoggingMiddleware(OutpostConsumer.as_asgi())),
+]
+
+api_urlpatterns = [
+    ("outposts/instances", OutpostViewSet),
+    ("outposts/service_connections/all", ServiceConnectionViewSet),
+    ("outposts/service_connections/docker", DockerServiceConnectionViewSet),
+    ("outposts/service_connections/kubernetes", KubernetesServiceConnectionViewSet),
 ]

authentik/policies/api/policies.py

@@ -40,7 +40,6 @@ class PolicySerializer(ModelSerializer, MetaNameSerializer):
 
     def get_component(self, obj: Policy) -> str:  # pragma: no cover
         """Get object component so that we know how to edit the object"""
-        # pyright: reportGeneralTypeIssues=false
         if obj.__class__ == Policy:
             return ""
         return obj.component
@@ -50,7 +49,6 @@ class PolicySerializer(ModelSerializer, MetaNameSerializer):
         return obj.bindings.count() + obj.promptstage_set.count()
 
     def to_representation(self, instance: Policy):
-        # pyright: reportGeneralTypeIssues=false
         if instance.__class__ == Policy or not self._resolve_inheritance:
             return super().to_representation(instance)
         return dict(instance.serializer(instance=instance, resolve_inheritance=False).data)

authentik/policies/denied.py

@@ -19,7 +19,6 @@ class AccessDeniedResponse(TemplateResponse):
     error_message: Optional[str] = None
     policy_result: Optional[PolicyResult] = None
 
-    # pyright: reportGeneralTypeIssues=false
     def __init__(self, request: HttpRequest, template="policies/denied.html") -> None:
         super().__init__(request, template)
         self.title = _("Access denied")

authentik/policies/dummy/urls.py

@@ -0,0 +1,4 @@
+"""API URLs"""
+from authentik.policies.dummy.api import DummyPolicyViewSet
+
+api_urlpatterns = [("policies/dummy", DummyPolicyViewSet)]

authentik/policies/engine.py

@@ -74,7 +74,6 @@ class PolicyEngine:
 
     def _check_policy_type(self, binding: PolicyBinding):
         """Check policy type, make sure it's not the root class as that has no logic implemented"""
-        # pyright: reportGeneralTypeIssues=false
         if binding.policy is not None and binding.policy.__class__ == Policy:
             raise PolicyEngineException(f"Policy '{binding.policy}' is root type")
 

authentik/policies/event_matcher/urls.py

@@ -0,0 +1,4 @@
+"""API URLs"""
+from authentik.policies.event_matcher.api import EventMatcherPolicyViewSet
+
+api_urlpatterns = [("policies/event_matcher", EventMatcherPolicyViewSet)]

authentik/policies/expiry/urls.py

@@ -0,0 +1,4 @@
+"""API URLs"""
+from authentik.policies.expiry.api import PasswordExpiryPolicyViewSet
+
+api_urlpatterns = [("policies/password_expiry", PasswordExpiryPolicyViewSet)]

authentik/policies/expression/urls.py

@@ -0,0 +1,4 @@
+"""API URLs"""
+from authentik.policies.expression.api import ExpressionPolicyViewSet
+
+api_urlpatterns = [("policies/expression", ExpressionPolicyViewSet)]

authentik/policies/migrations/0007_policybindingmodel_policy_engine_mode.py

@@ -15,8 +15,8 @@ class Migration(migrations.Migration):
             name="policy_engine_mode",
             field=models.TextField(
                 choices=[
-                    ("all", "ALL, all policies must pass"),
-                    ("any", "ANY, any policy must pass"),
+                    ("all", "all, all policies must pass"),
+                    ("any", "any, any policy must pass"),
                 ],
                 default="all",
             ),
@@ -27,8 +27,8 @@ class Migration(migrations.Migration):
             name="policy_engine_mode",
             field=models.TextField(
                 choices=[
-                    ("all", "ALL, all policies must pass"),
-                    ("any", "ANY, any policy must pass"),
+                    ("all", "all, all policies must pass"),
+                    ("any", "any, any policy must pass"),
                 ],
                 default="any",
             ),

authentik/policies/models.py

@@ -19,10 +19,8 @@ from authentik.policies.types import PolicyRequest, PolicyResult
 class PolicyEngineMode(models.TextChoices):
     """Decide how results of multiple policies should be combined."""
 
-    # pyright: reportGeneralTypeIssues=false
-    MODE_ALL = "all", _("ALL, all policies must pass")  # type: "PolicyEngineMode"
-    # pyright: reportGeneralTypeIssues=false
-    MODE_ANY = "any", _("ANY, any policy must pass")  # type: "PolicyEngineMode"
+    MODE_ALL = "all", _("all, all policies must pass")  # type: "PolicyEngineMode"
+    MODE_ANY = "any", _("any, any policy must pass")  # type: "PolicyEngineMode"
 
 
 class PolicyBindingModel(models.Model):

authentik/policies/password/urls.py

@@ -0,0 +1,4 @@
+"""API URLs"""
+from authentik.policies.password.api import PasswordPolicyViewSet
+
+api_urlpatterns = [("policies/password", PasswordPolicyViewSet)]

authentik/policies/reputation/urls.py

@@ -0,0 +1,7 @@
+"""API URLs"""
+from authentik.policies.reputation.api import ReputationPolicyViewSet, ReputationViewSet
+
+api_urlpatterns = [
+    ("policies/reputation/scores", ReputationViewSet),
+    ("policies/reputation", ReputationPolicyViewSet),
+]

authentik/policies/signals.py

@@ -5,7 +5,9 @@ from django.dispatch import receiver
 from structlog.stdlib import get_logger
 
 from authentik.core.api.applications import user_app_cache_key
+from authentik.core.models import Group, User
 from authentik.policies.apps import GAUGE_POLICIES_CACHED
+from authentik.policies.models import Policy, PolicyBinding, PolicyBindingModel
 from authentik.policies.types import CACHE_PREFIX
 from authentik.root.monitoring import monitoring_set
 
@@ -18,12 +20,14 @@ def monitoring_set_policies(sender, **kwargs):
     GAUGE_POLICIES_CACHED.set(len(cache.keys(f"{CACHE_PREFIX}_*") or []))
 
 
-@receiver(post_save)
+@receiver(post_save, sender=Policy)
+@receiver(post_save, sender=PolicyBinding)
+@receiver(post_save, sender=PolicyBindingModel)
+@receiver(post_save, sender=Group)
+@receiver(post_save, sender=User)
 def invalidate_policy_cache(sender, instance, **_):
     """Invalidate Policy cache when policy is updated"""
-    from authentik.policies.models import Policy, PolicyBinding
-
-    if isinstance(instance, Policy):
+    if sender == Policy:
         total = 0
         for binding in PolicyBinding.objects.filter(policy=instance):
             prefix = f"{CACHE_PREFIX}{binding.policy_binding_uuid.hex}_{binding.policy.pk.hex}*"

authentik/policies/urls.py

@@ -0,0 +1,8 @@
+"""API URLs"""
+from authentik.policies.api.bindings import PolicyBindingViewSet
+from authentik.policies.api.policies import PolicyViewSet
+
+api_urlpatterns = [
+    ("policies/all", PolicyViewSet),
+    ("policies/bindings", PolicyBindingViewSet),
+]

authentik/providers/ldap/api.py

@@ -1,5 +1,5 @@
 """LDAPProvider API Views"""
-from rest_framework.fields import CharField, ListField
+from rest_framework.fields import CharField, ListField, SerializerMethodField
 from rest_framework.serializers import ModelSerializer
 from rest_framework.viewsets import ModelViewSet, ReadOnlyModelViewSet
 
@@ -54,9 +54,15 @@ class LDAPProviderViewSet(UsedByMixin, ModelViewSet):
 class LDAPOutpostConfigSerializer(ModelSerializer):
     """LDAPProvider Serializer"""
 
-    application_slug = CharField(source="application.slug")
+    application_slug = SerializerMethodField()
     bind_flow_slug = CharField(source="authorization_flow.slug")
 
+    def get_application_slug(self, instance: LDAPProvider) -> str:
+        """Prioritise backchannel slug over direct application slug"""
+        if instance.backchannel_application:
+            return instance.backchannel_application.slug
+        return instance.application.slug
+
     class Meta:
         model = LDAPProvider
         fields = [

authentik/providers/ldap/models.py

@@ -5,7 +5,7 @@ from django.db import models
 from django.utils.translation import gettext_lazy as _
 from rest_framework.serializers import Serializer
 
-from authentik.core.models import Group, Provider
+from authentik.core.models import BackchannelProvider, Group
 from authentik.crypto.models import CertificateKeyPair
 from authentik.outposts.models import OutpostModel
 
@@ -17,7 +17,7 @@ class APIAccessMode(models.TextChoices):
     CACHED = "cached"
 
 
-class LDAPProvider(OutpostModel, Provider):
+class LDAPProvider(OutpostModel, BackchannelProvider):
     """Allow applications to authenticate against authentik's users using LDAP."""
 
     base_dn = models.TextField(

authentik/providers/ldap/urls.py

@@ -0,0 +1,7 @@
+"""API URLs"""
+from authentik.providers.ldap.api import LDAPOutpostConfigViewSet, LDAPProviderViewSet
+
+api_urlpatterns = [
+    ("outposts/ldap", LDAPOutpostConfigViewSet),
+    ("providers/ldap", LDAPProviderViewSet),
+]

authentik/providers/oauth2/id_token.py

@@ -26,6 +26,7 @@ class SubModes(models.TextChoices):
 
     HASHED_USER_ID = "hashed_user_id", _("Based on the Hashed User ID")
     USER_ID = "user_id", _("Based on user ID")
+    USER_UUID = "user_uuid", _("Based on user UUID")
     USER_USERNAME = "user_username", _("Based on the username")
     USER_EMAIL = (
         "user_email",
@@ -96,6 +97,8 @@ class IDToken:
             id_token.sub = token.user.uid
         elif provider.sub_mode == SubModes.USER_ID:
             id_token.sub = str(token.user.pk)
+        elif provider.sub_mode == SubModes.USER_UUID:
+            id_token.sub = str(token.user.uuid)
         elif provider.sub_mode == SubModes.USER_EMAIL:
             id_token.sub = token.user.email
         elif provider.sub_mode == SubModes.USER_USERNAME:

authentik/providers/oauth2/migrations/0016_alter_refreshtoken_token.py

@@ -0,0 +1,46 @@
+# Generated by Django 4.1.7 on 2023-05-06 16:18
+
+from django.db import migrations, models
+
+import authentik.providers.oauth2.models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        (
+            "authentik_providers_oauth2",
+            "0015_accesstoken_auth_time_authorizationcode_auth_time_and_more",
+        ),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="refreshtoken",
+            name="token",
+            field=models.TextField(
+                default=authentik.providers.oauth2.models.generate_client_secret
+            ),
+        ),
+        migrations.AlterField(
+            model_name="oauth2provider",
+            name="sub_mode",
+            field=models.TextField(
+                choices=[
+                    ("hashed_user_id", "Based on the Hashed User ID"),
+                    ("user_id", "Based on user ID"),
+                    ("user_uuid", "Based on user UUID"),
+                    ("user_username", "Based on the username"),
+                    (
+                        "user_email",
+                        "Based on the User's Email. This is recommended over the UPN method.",
+                    ),
+                    (
+                        "user_upn",
+                        "Based on the User's UPN, only works if user has a 'upn' attribute set. Use this method only if you have different UPN and Mail domains.",
+                    ),
+                ],
+                default="hashed_user_id",
+                help_text="Configure what data should be used as unique User Identifier. For most cases, the default should be fine.",
+            ),
+        ),
+    ]

authentik/providers/oauth2/models.py

@@ -382,7 +382,7 @@ class AccessToken(SerializerModel, ExpiringModel, BaseGrantModel):
 class RefreshToken(SerializerModel, ExpiringModel, BaseGrantModel):
     """OAuth2 Refresh Token, opaque"""
 
-    token = models.TextField(default=generate_key)
+    token = models.TextField(default=generate_client_secret)
     _id_token = models.TextField(verbose_name=_("ID Token"))
 
     @property

authentik/providers/oauth2/tests/test_userinfo.py

@@ -92,5 +92,5 @@ class TestUserinfo(OAuthTestCase):
         self.assertTrue(events.exists())
         self.assertEqual(
             events.first().context["message"],
-            "Failed to evaluate property-mapping: name 'q' is not defined",
+            "Failed to evaluate property-mapping: 'test'",
         )

authentik/providers/oauth2/tests/utils.py

@@ -25,7 +25,6 @@ class OAuthTestCase(TestCase):
     def setUpClass(cls) -> None:
         cls.keypair = create_test_cert()
         super().setUpClass()
-        cls.maxDiff = None
 
     def assert_non_none_or_unset(self, container: dict, key: str):
         """Check that a key, if set, is not none"""

authentik/providers/oauth2/urls.py

@@ -2,6 +2,13 @@
 from django.urls import path
 from django.views.generic.base import RedirectView
 
+from authentik.providers.oauth2.api.providers import OAuth2ProviderViewSet
+from authentik.providers.oauth2.api.scopes import ScopeMappingViewSet
+from authentik.providers.oauth2.api.tokens import (
+    AccessTokenViewSet,
+    AuthorizationCodeViewSet,
+    RefreshTokenViewSet,
+)
 from authentik.providers.oauth2.views.authorize import AuthorizationFlowInitView
 from authentik.providers.oauth2.views.device_backchannel import DeviceView
 from authentik.providers.oauth2.views.introspection import TokenIntrospectionView
@@ -51,3 +58,11 @@ urlpatterns = [
         name="provider-info",
     ),
 ]
+
+api_urlpatterns = [
+    ("providers/oauth2", OAuth2ProviderViewSet),
+    ("propertymappings/scope", ScopeMappingViewSet),
+    ("oauth2/authorization_codes", AuthorizationCodeViewSet),
+    ("oauth2/refresh_tokens", RefreshTokenViewSet),
+    ("oauth2/access_tokens", AccessTokenViewSet),
+]

authentik/providers/oauth2/utils.py

@@ -202,5 +202,4 @@ class HttpResponseRedirectScheme(HttpResponseRedirect):
         **kwargs: Any,
     ) -> None:
         self.allowed_schemes = allowed_schemes or ["http", "https", "ftp"]
-        # pyright: reportGeneralTypeIssues=false
         super().__init__(redirect_to, *args, **kwargs)

authentik/providers/oauth2/views/userinfo.py

@@ -82,9 +82,11 @@ class UserInfoView(View):
             except PropertyMappingExpressionException as exc:
                 Event.new(
                     EventAction.CONFIGURATION_ERROR,
-                    message=f"Failed to evaluate property-mapping: {str(exc)}",
+                    message=f"Failed to evaluate property-mapping: '{scope.name}'",
+                    provider=provider,
                     mapping=scope,
                 ).from_http(self.request)
+                LOGGER.warning("Failed to evaluate property mapping", exc=exc)
             if value is None:
                 continue
             if not isinstance(value, dict):

authentik/providers/proxy/urls.py

@@ -0,0 +1,7 @@
+"""API URLs"""
+from authentik.providers.proxy.api import ProxyOutpostConfigViewSet, ProxyProviderViewSet
+
+api_urlpatterns = [
+    ("outposts/proxy", ProxyOutpostConfigViewSet),
+    ("providers/proxy", ProxyProviderViewSet),
+]

authentik/providers/radius/urls.py

@@ -0,0 +1,7 @@
+"""API URLs"""
+from authentik.providers.radius.api import RadiusOutpostConfigViewSet, RadiusProviderViewSet
+
+api_urlpatterns = [
+    ("outposts/radius", RadiusOutpostConfigViewSet),
+    ("providers/radius", RadiusProviderViewSet),
+]

authentik/providers/saml/processors/assertion.py

@@ -108,9 +108,11 @@ class AssertionProcessor:
                 # Value error can be raised when assigning invalid data to an attribute
                 Event.new(
                     EventAction.CONFIGURATION_ERROR,
-                    message=f"Failed to evaluate property-mapping: {str(exc)}",
+                    message=f"Failed to evaluate property-mapping: '{mapping.name}'",
+                    provider=self.provider,
                     mapping=mapping,
                 ).from_http(self.http_request)
+                LOGGER.warning("Failed to evaluate property mapping", exc=exc)
                 continue
         return attribute_statement
 
@@ -185,9 +187,14 @@ class AssertionProcessor:
             except PropertyMappingExpressionException as exc:
                 Event.new(
                     EventAction.CONFIGURATION_ERROR,
-                    message=f"Failed to evaluate property-mapping: {str(exc)}",
+                    message=(
+                        "Failed to evaluate property-mapping: "
+                        f"'{self.provider.name_id_mapping.name}'",
+                    ),
+                    provider=self.provider,
                     mapping=self.provider.name_id_mapping,
                 ).from_http(self.http_request)
+                LOGGER.warning("Failed to evaluate property mapping", exc=exc)
                 return name_id
         if name_id.attrib["Format"] == SAML_NAME_ID_FORMAT_EMAIL:
             name_id.text = self.http_request.user.email

authentik/providers/saml/tests/test_auth_n_request.py

@@ -261,5 +261,5 @@ class TestAuthNRequest(TestCase):
         self.assertTrue(events.exists())
         self.assertEqual(
             events.first().context["message"],
-            "Failed to evaluate property-mapping: name 'q' is not defined",
+            "Failed to evaluate property-mapping: 'test'",
         )

authentik/providers/saml/urls.py

@@ -1,6 +1,8 @@
 """authentik SAML IDP URLs"""
 from django.urls import path
 
+from authentik.providers.saml.api.property_mapping import SAMLPropertyMappingViewSet
+from authentik.providers.saml.api.providers import SAMLProviderViewSet
 from authentik.providers.saml.views import metadata, slo, sso
 
 urlpatterns = [
@@ -39,3 +41,8 @@ urlpatterns = [
         name="metadata-download",
     ),
 ]
+
+api_urlpatterns = [
+    ("propertymappings/saml", SAMLPropertyMappingViewSet),
+    ("providers/saml", SAMLProviderViewSet),
+]

authentik/providers/scim/clients/base.py

@@ -2,19 +2,12 @@
 from typing import Generic, TypeVar
 
 from pydantic import ValidationError
-from pydanticscim.service_provider import (
-    Bulk,
-    ChangePassword,
-    Filter,
-    Patch,
-    ServiceProviderConfiguration,
-    Sort,
-)
 from requests import RequestException, Session
 from structlog.stdlib import get_logger
 
 from authentik.lib.utils.http import get_http_session
-from authentik.providers.scim.clients.exceptions import SCIMRequestException
+from authentik.providers.scim.clients.exceptions import ResourceMissing, SCIMRequestException
+from authentik.providers.scim.clients.schema import ServiceProviderConfiguration
 from authentik.providers.scim.models import SCIMProvider
 
 T = TypeVar("T")
@@ -22,18 +15,6 @@ T = TypeVar("T")
 SchemaType = TypeVar("SchemaType")
 
 
-def default_service_provider_config() -> ServiceProviderConfiguration:
-    """Fallback service provider configuration"""
-    return ServiceProviderConfiguration(
-        patch=Patch(supported=False),
-        bulk=Bulk(supported=False),
-        filter=Filter(supported=False),
-        changePassword=ChangePassword(supported=False),
-        sort=Sort(supported=False),
-        authenticationSchemes=[],
-    )
-
-
 class SCIMClient(Generic[T, SchemaType]):
     """SCIM Client"""
 
@@ -73,6 +54,8 @@ class SCIMClient(Generic[T, SchemaType]):
             raise SCIMRequestException(None) from exc
         self.logger.debug("scim request", path=path, method=method, **kwargs)
         if response.status_code >= 400:
+            if response.status_code == 404:
+                raise ResourceMissing(response)
             self.logger.warning(
                 "Failed to send SCIM request", path=path, method=method, response=response.text
             )
@@ -83,7 +66,7 @@ class SCIMClient(Generic[T, SchemaType]):
 
     def get_service_provider_config(self):
         """Get Service provider config"""
-        default_config = default_service_provider_config()
+        default_config = ServiceProviderConfiguration.default()
         try:
             return ServiceProviderConfiguration.parse_obj(
                 self._request("GET", "/ServiceProviderConfig")

authentik/providers/scim/clients/exceptions.py

@@ -41,3 +41,8 @@ class SCIMRequestException(SentryIgnoredException):
         except ValidationError:
             pass
         return super().__str__()
+
+
+class ResourceMissing(SCIMRequestException):
+    """Error raised when the provider raises a 404, meaning that we
+    should delete our internal ID and re-create the object"""

authentik/providers/scim/clients/group.py

@@ -2,7 +2,7 @@
 from deepmerge import always_merger
 from pydantic import ValidationError
 from pydanticscim.group import GroupMember
-from pydanticscim.responses import PatchOp, PatchOperation, PatchRequest
+from pydanticscim.responses import PatchOp, PatchOperation
 
 from authentik.core.exceptions import PropertyMappingExpressionException
 from authentik.core.models import Group
@@ -10,8 +10,13 @@ from authentik.events.models import Event, EventAction
 from authentik.lib.utils.errors import exception_to_string
 from authentik.policies.utils import delete_none_keys
 from authentik.providers.scim.clients.base import SCIMClient
-from authentik.providers.scim.clients.exceptions import StopSync
+from authentik.providers.scim.clients.exceptions import (
+    ResourceMissing,
+    SCIMRequestException,
+    StopSync,
+)
 from authentik.providers.scim.clients.schema import Group as SCIMGroupSchema
+from authentik.providers.scim.clients.schema import PatchRequest
 from authentik.providers.scim.models import SCIMGroup, SCIMMapping, SCIMUser
 
 
@@ -23,15 +28,11 @@ class SCIMGroupClient(SCIMClient[Group, SCIMGroupSchema]):
         scim_group = SCIMGroup.objects.filter(provider=self.provider, group=obj).first()
         if not scim_group:
             return self._create(obj)
-        scim_group = self.to_scim(obj)
-        scim_group.id = scim_group.id
-        return self._request(
-            "PUT",
-            f"/Groups/{scim_group.id}",
-            data=scim_group.json(
-                exclude_unset=True,
-            ),
-        )
+        try:
+            return self._update(obj, scim_group)
+        except ResourceMissing:
+            scim_group.delete()
+            return self._create(obj)
 
     def delete(self, obj: Group):
         """Delete group"""
@@ -81,12 +82,15 @@ class SCIMGroupClient(SCIMClient[Group, SCIMGroupSchema]):
 
         users = list(obj.users.order_by("id").values_list("id", flat=True))
         connections = SCIMUser.objects.filter(provider=self.provider, user__pk__in=users)
+        members = []
         for user in connections:
-            scim_group.members.append(
+            members.append(
                 GroupMember(
                     value=user.id,
                 )
             )
+        if members:
+            scim_group.members = members
         return scim_group
 
     def _create(self, group: Group):
@@ -101,13 +105,37 @@ class SCIMGroupClient(SCIMClient[Group, SCIMGroupSchema]):
         )
         SCIMGroup.objects.create(provider=self.provider, group=group, id=response["id"])
 
-    def _patch(
-        self,
-        group_id: str,
-        *ops: PatchOperation,
-    ):
-        req = PatchRequest(Operations=ops)
-        self._request("PATCH", f"/Groups/{group_id}", data=req.json(exclude_unset=True))
+    def _update(self, group: Group, connection: SCIMGroup):
+        """Update existing group"""
+        scim_group = self.to_scim(group)
+        scim_group.id = connection.id
+        try:
+            return self._request(
+                "PUT",
+                f"/Groups/{scim_group.id}",
+                data=scim_group.json(
+                    exclude_unset=True,
+                ),
+            )
+        except ResourceMissing:
+            # Resource missing is handled by self.write, which will re-create the group
+            raise
+        except SCIMRequestException:
+            # Some providers don't support PUT on groups, so this is mainly a fix for the initial
+            # sync, send patch add requests for all the users the group currently has
+            users = list(group.users.order_by("id").values_list("id", flat=True))
+            self._patch_add_users(group, users)
+            # Also update the group name
+            return self._patch(
+                scim_group.id,
+                PatchOperation(
+                    op=PatchOp.replace,
+                    value={
+                        "id": connection.id,
+                        "displayName": group.name,
+                    },
+                ),
+            )
 
     def update_group(self, group: Group, action: PatchOp, users_set: set[int]):
         """Update a group, either using PUT to replace it or PATCH if supported"""
@@ -116,7 +144,25 @@ class SCIMGroupClient(SCIMClient[Group, SCIMGroupSchema]):
                 return self._patch_add_users(group, users_set)
             if action == PatchOp.remove:
                 return self._patch_remove_users(group, users_set)
-        return self.write(group)
+        try:
+            return self.write(group)
+        except SCIMRequestException as exc:
+            if self._config.is_fallback:
+                # Assume that provider does not support PUT and also doesn't support
+                # ServiceProviderConfig, so try PATCH as a fallback
+                if action == PatchOp.add:
+                    return self._patch_add_users(group, users_set)
+                if action == PatchOp.remove:
+                    return self._patch_remove_users(group, users_set)
+            raise exc
+
+    def _patch(
+        self,
+        group_id: str,
+        *ops: PatchOperation,
+    ):
+        req = PatchRequest(Operations=ops)
+        self._request("PATCH", f"/Groups/{group_id}", data=req.json())
 
     def _patch_add_users(self, group: Group, users_set: set[int]):
         """Add users in users_set to group"""
@@ -133,6 +179,8 @@ class SCIMGroupClient(SCIMClient[Group, SCIMGroupSchema]):
                 "id", flat=True
             )
         )
+        if len(user_ids) < 1:
+            return
         self._patch(
             scim_group.id,
             PatchOperation(
@@ -157,6 +205,8 @@ class SCIMGroupClient(SCIMClient[Group, SCIMGroupSchema]):
                 "id", flat=True
             )
         )
+        if len(user_ids) < 1:
+            return
         self._patch(
             scim_group.id,
             PatchOperation(

authentik/providers/scim/clients/schema.py

@@ -1,17 +1,54 @@
 """Custom SCIM schemas"""
 from typing import Optional
 
-from pydanticscim.group import Group as SCIMGroupSchema
-from pydanticscim.user import User as SCIMUserSchema
+from pydanticscim.group import Group as BaseGroup
+from pydanticscim.responses import PatchRequest as BasePatchRequest
+from pydanticscim.service_provider import Bulk, ChangePassword, Filter, Patch
+from pydanticscim.service_provider import (
+    ServiceProviderConfiguration as BaseServiceProviderConfiguration,
+)
+from pydanticscim.service_provider import Sort
+from pydanticscim.user import User as BaseUser
 
 
-class User(SCIMUserSchema):
+class User(BaseUser):
     """Modified User schema with added externalId field"""
 
     externalId: Optional[str] = None
 
 
-class Group(SCIMGroupSchema):
+class Group(BaseGroup):
     """Modified Group schema with added externalId field"""
 
     externalId: Optional[str] = None
+
+
+class ServiceProviderConfiguration(BaseServiceProviderConfiguration):
+    """ServiceProviderConfig with fallback"""
+
+    _is_fallback: Optional[bool] = False
+
+    @property
+    def is_fallback(self) -> bool:
+        """Check if this service provider config was retrieved from the API endpoint
+        or a fallback was used"""
+        return self._is_fallback
+
+    @staticmethod
+    def default() -> "ServiceProviderConfiguration":
+        """Get default configuration, which doesn't support any optional features as fallback"""
+        return ServiceProviderConfiguration(
+            patch=Patch(supported=False),
+            bulk=Bulk(supported=False),
+            filter=Filter(supported=False),
+            changePassword=ChangePassword(supported=False),
+            sort=Sort(supported=False),
+            authenticationSchemes=[],
+            _is_fallback=True,
+        )
+
+
+class PatchRequest(BasePatchRequest):
+    """PatchRequest which correctly sets schemas"""
+
+    schemas: tuple[str] = ["urn:ietf:params:scim:api:messages:2.0:PatchOp"]

authentik/providers/scim/clients/user.py

@@ -8,7 +8,7 @@ from authentik.events.models import Event, EventAction
 from authentik.lib.utils.errors import exception_to_string
 from authentik.policies.utils import delete_none_keys
 from authentik.providers.scim.clients.base import SCIMClient
-from authentik.providers.scim.clients.exceptions import StopSync
+from authentik.providers.scim.clients.exceptions import ResourceMissing, StopSync
 from authentik.providers.scim.clients.schema import User as SCIMUserSchema
 from authentik.providers.scim.models import SCIMMapping, SCIMUser
 
@@ -21,7 +21,11 @@ class SCIMUserClient(SCIMClient[User, SCIMUserSchema]):
         scim_user = SCIMUser.objects.filter(provider=self.provider, user=obj).first()
         if not scim_user:
             return self._create(obj)
-        return self._update(obj, scim_user)
+        try:
+            return self._update(obj, scim_user)
+        except ResourceMissing:
+            scim_user.delete()
+            return self._create(obj)
 
     def delete(self, obj: User):
         """Delete user"""

authentik/providers/scim/management/commands/scim_sync.py

@@ -0,0 +1,23 @@
+"""SCIM Sync"""
+from django.core.management.base import BaseCommand
+from structlog.stdlib import get_logger
+
+from authentik.providers.scim.models import SCIMProvider
+from authentik.providers.scim.tasks import scim_sync
+
+LOGGER = get_logger()
+
+
+class Command(BaseCommand):
+    """Run sync for an SCIM Provider"""
+
+    def add_arguments(self, parser):
+        parser.add_argument("providers", nargs="+", type=str)
+
+    def handle(self, **options):
+        for provider_name in options["providers"]:
+            provider = SCIMProvider.objects.filter(name=provider_name).first()
+            if not provider:
+                LOGGER.warning("Provider does not exist", name=provider_name)
+                continue
+            scim_sync.delay(provider.pk).get()

authentik/providers/scim/models.py

@@ -5,10 +5,16 @@ from django.utils.translation import gettext_lazy as _
 from guardian.shortcuts import get_anonymous_user
 from rest_framework.serializers import Serializer
 
-from authentik.core.models import USER_ATTRIBUTE_SA, Group, PropertyMapping, Provider, User
+from authentik.core.models import (
+    USER_ATTRIBUTE_SA,
+    BackchannelProvider,
+    Group,
+    PropertyMapping,
+    User,
+)
 
 
-class SCIMProvider(Provider):
+class SCIMProvider(BackchannelProvider):
     """SCIM 2.0 provider to create users and groups in external applications"""
 
     exclude_users_service_account = models.BooleanField(default=False)

authentik/providers/scim/tasks.py

@@ -1,9 +1,9 @@
 """SCIM Provider tasks"""
-from typing import Any
+from typing import Any, Optional
 
 from celery.result import allow_join_result
 from django.core.paginator import Paginator
-from django.db.models import Model
+from django.db.models import Model, QuerySet
 from django.utils.text import slugify
 from django.utils.translation import gettext_lazy as _
 from pydanticscim.responses import PatchOp
@@ -35,7 +35,7 @@ def client_for_model(provider: SCIMProvider, model: Model) -> SCIMClient:
 @CELERY_APP.task()
 def scim_sync_all():
     """Run sync for all providers"""
-    for provider in SCIMProvider.objects.all():
+    for provider in SCIMProvider.objects.filter(backchannel_application__isnull=False):
         scim_sync.delay(provider.pk)
 
 
@@ -94,7 +94,16 @@ def scim_sync_users(page: int, provider_pk: int):
                     }
                 )
             )
-        except StopSync:
+        except StopSync as exc:
+            LOGGER.warning("Stopping sync", exc=exc)
+            messages.append(
+                _(
+                    "Stopping sync due to error: %(error)s"
+                    % {
+                        "error": str(exc),
+                    }
+                )
+            )
             break
     return messages
 
@@ -126,7 +135,16 @@ def scim_sync_group(page: int, provider_pk: int):
                     }
                 )
             )
-        except StopSync:
+        except StopSync as exc:
+            LOGGER.warning("Stopping sync", exc=exc)
+            messages.append(
+                _(
+                    "Stopping sync due to error: %(error)s"
+                    % {
+                        "error": str(exc),
+                    }
+                )
+            )
             break
     return messages
 
@@ -139,8 +157,22 @@ def scim_signal_direct(model: str, pk: Any, raw_op: str):
     if not instance:
         return
     operation = PatchOp(raw_op)
-    for provider in SCIMProvider.objects.all():
+    for provider in SCIMProvider.objects.filter(backchannel_application__isnull=False):
         client = client_for_model(provider, instance)
+        # Check if the object is allowed within the provider's restrictions
+        queryset: Optional[QuerySet] = None
+        if isinstance(instance, User):
+            queryset = provider.get_user_qs()
+        if isinstance(instance, Group):
+            queryset = provider.get_group_qs()
+        if not queryset:
+            continue
+
+        # The queryset we get from the provider must include the instance we've got given
+        # otherwise ignore this provider
+        if not queryset.filter(pk=instance.pk).exists():
+            continue
+
         try:
             if operation == PatchOp.add:
                 client.write(instance)
@@ -156,7 +188,14 @@ def scim_signal_m2m(group_pk: str, action: str, pk_set: list[int]):
     group = Group.objects.filter(pk=group_pk).first()
     if not group:
         return
-    for provider in SCIMProvider.objects.all():
+    for provider in SCIMProvider.objects.filter(backchannel_application__isnull=False):
+        # Check if the object is allowed within the provider's restrictions
+        queryset: QuerySet = provider.get_group_qs()
+        # The queryset we get from the provider must include the instance we've got given
+        # otherwise ignore this provider
+        if not queryset.filter(pk=group_pk).exists():
+            continue
+
         client = SCIMGroupClient(provider)
         try:
             operation = None

authentik/providers/scim/tests/test_client.py

@@ -3,9 +3,11 @@ from django.test import TestCase
 from requests_mock import Mocker
 
 from authentik.blueprints.tests import apply_blueprint
+from authentik.core.models import Application
 from authentik.lib.generators import generate_id
 from authentik.providers.scim.clients.base import SCIMClient
 from authentik.providers.scim.models import SCIMMapping, SCIMProvider
+from authentik.providers.scim.tasks import scim_sync_all
 
 
 class SCIMClientTests(TestCase):
@@ -18,6 +20,11 @@ class SCIMClientTests(TestCase):
             url="https://localhost",
             token=generate_id(),
         )
+        self.app: Application = Application.objects.create(
+            name=generate_id(),
+            slug=generate_id(),
+        )
+        self.app.backchannel_providers.add(self.provider)
         self.provider.property_mappings.add(
             SCIMMapping.objects.get(managed="goauthentik.io/providers/scim/user")
         )
@@ -76,3 +83,7 @@ class SCIMClientTests(TestCase):
             SCIMClient(self.provider)
             self.assertEqual(mock.call_count, 1)
             self.assertEqual(mock.request_history[0].method, "GET")
+
+    def test_scim_sync_all(self):
+        """test scim_sync_all task"""
+        scim_sync_all()

authentik/providers/scim/tests/test_group.py

@@ -7,7 +7,7 @@ from jsonschema import validate
 from requests_mock import Mocker
 
 from authentik.blueprints.tests import apply_blueprint
-from authentik.core.models import Group, User
+from authentik.core.models import Application, Group, User
 from authentik.lib.generators import generate_id
 from authentik.providers.scim.models import SCIMMapping, SCIMProvider
 
@@ -26,6 +26,11 @@ class SCIMGroupTests(TestCase):
             url="https://localhost",
             token=generate_id(),
         )
+        self.app: Application = Application.objects.create(
+            name=generate_id(),
+            slug=generate_id(),
+        )
+        self.app.backchannel_providers.add(self.provider)
         self.provider.property_mappings.set(
             [SCIMMapping.objects.get(managed="goauthentik.io/providers/scim/user")]
         )

authentik/providers/scim/tests/test_membership.py

@@ -4,9 +4,9 @@ from guardian.shortcuts import get_anonymous_user
 from requests_mock import Mocker
 
 from authentik.blueprints.tests import apply_blueprint
-from authentik.core.models import Group, User
+from authentik.core.models import Application, Group, User
 from authentik.lib.generators import generate_id
-from authentik.providers.scim.clients.base import default_service_provider_config
+from authentik.providers.scim.clients.schema import ServiceProviderConfiguration
 from authentik.providers.scim.models import SCIMMapping, SCIMProvider
 from authentik.providers.scim.tasks import scim_sync
 
@@ -15,6 +15,7 @@ class SCIMMembershipTests(TestCase):
     """SCIM Membership tests"""
 
     provider: SCIMProvider
+    app: Application
 
     def setUp(self) -> None:
         # Delete all users and groups as the mocked HTTP responses only return one ID
@@ -30,6 +31,11 @@ class SCIMMembershipTests(TestCase):
             url="https://localhost",
             token=generate_id(),
         )
+        self.app: Application = Application.objects.create(
+            name=generate_id(),
+            slug=generate_id(),
+        )
+        self.app.backchannel_providers.add(self.provider)
         self.provider.property_mappings.set(
             [SCIMMapping.objects.get(managed="goauthentik.io/providers/scim/user")]
         )
@@ -39,7 +45,7 @@ class SCIMMembershipTests(TestCase):
 
     def test_member_add(self):
         """Test member add"""
-        config = default_service_provider_config()
+        config = ServiceProviderConfiguration.default()
         config.patch.supported = True
         user_scim_id = generate_id()
         group_scim_id = generate_id()
@@ -117,13 +123,14 @@ class SCIMMembershipTests(TestCase):
                             "path": "members",
                             "value": [{"value": user_scim_id}],
                         }
-                    ]
+                    ],
+                    "schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"],
                 },
             )
 
     def test_member_remove(self):
         """Test member remove"""
-        config = default_service_provider_config()
+        config = ServiceProviderConfiguration.default()
         config.patch.supported = True
         user_scim_id = generate_id()
         group_scim_id = generate_id()
@@ -201,7 +208,8 @@ class SCIMMembershipTests(TestCase):
                             "path": "members",
                             "value": [{"value": user_scim_id}],
                         }
-                    ]
+                    ],
+                    "schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"],
                 },
             )
 
@@ -227,6 +235,7 @@ class SCIMMembershipTests(TestCase):
                             "path": "members",
                             "value": [{"value": user_scim_id}],
                         }
-                    ]
+                    ],
+                    "schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"],
                 },
             )