Make Authentik users from Apps → Authentik, with a one-time recovery link
An administrator can make a user (user name, name, optional email, groups) and gets a recovery link to send them, so they choose their own password; no password is set or seen here. Uses a separate optional "Token for making users" on the Authentik integration; reading never uses it, and it can be removed again from the page. The link is shown once and never stored or audited; the audit log records who made which user and link. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
9ca83994fb
commit
aa95d6b314
13 files changed
+892
-18
No files matched your search
@@ -3,7 +3,7 @@
|
||||
*
|
||||
* Reading only: Authentik's version (and whether a newer one exists), whether a worker is connected, how each outpost is (the proxy outpost that guards your apps, an LDAP one) —
|
||||
* how many instances report in and whether they are the right version — the certificates and their expiry, the API tokens and app passwords that expire, and how many sign-ins and
|
||||
* flows failed lately (from the events log). Nothing is sent to Authentik but GET requests for these.
|
||||
* flows failed lately (from the events log). Nothing is sent to Authentik but GET requests for these; making a user is ./users.ts, with a token of its own.
|
||||
*
|
||||
* Endpoints and field names are from Authentik's published API (`/api/v3/admin/version/`, `/admin/workers/`, `/outposts/instances/` and its `/health/`, `/crypto/certificatekeypairs/`,
|
||||
* `/core/tokens/`, `/events/events/`) and have not been checked against a live server here; every field is read defensively, and a part that cannot be read is left out.
|
||||
|
||||
@@ -0,0 +1,149 @@
|
||||
/**
|
||||
* Making a user in Authentik: the one thing this app does there that is not reading. It is kept apart from the adapter that reads (./adapter.ts, which sends nothing but GET requests with
|
||||
* the integration's own token) and it has a token of its own — `writeToken`, optional, from an account that may add users — so an Authentik that is only watched is never written to.
|
||||
*
|
||||
* Three calls: the groups to offer (`GET /core/groups/`), the user (`POST /core/users/`) and a one-time recovery link for that user (`POST /core/users/{pk}/recovery/`), which is how the
|
||||
* person gets to choose their own password: this app never sets, sees or keeps one. The link is handed back once and not stored.
|
||||
*
|
||||
* Endpoints and field names are from Authentik's published API and have not been checked against a live server here; every field is read defensively. The link is built by Authentik from
|
||||
* the address it was asked at, so it is only as good as the address in the integration.
|
||||
*/
|
||||
import { requestJson } from "../httpJson.js";
|
||||
import { withDiagLogging } from "../../services/diagLog.js";
|
||||
|
||||
export interface AuthentikUsersConfig {
|
||||
url: string;
|
||||
writeToken?: string;
|
||||
insecure?: boolean;
|
||||
}
|
||||
|
||||
export interface AuthentikGroup {
|
||||
/** A UUID. */
|
||||
id: string;
|
||||
name: string;
|
||||
/** Members of a superuser group are administrators of Authentik. */
|
||||
admin: boolean;
|
||||
}
|
||||
|
||||
export interface NewAuthentikUser {
|
||||
username: string;
|
||||
name: string;
|
||||
email?: string;
|
||||
/** Group ids. */
|
||||
groups: string[];
|
||||
}
|
||||
|
||||
export interface CreatedAuthentikUser {
|
||||
pk: number;
|
||||
username: string;
|
||||
name: string;
|
||||
}
|
||||
|
||||
/** How a call failed: `invalid` — Authentik looked at it and said no (a name taken, a bad address); `denied` — the token is not accepted or may not; `failed` — no answer, or one that makes no sense. */
|
||||
export class AuthentikUserError extends Error {
|
||||
constructor(message: string, readonly kind: "invalid" | "denied" | "failed") {
|
||||
super(message);
|
||||
}
|
||||
}
|
||||
|
||||
const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
|
||||
const PAGE = 200;
|
||||
|
||||
const obj = (v: unknown): Record<string, unknown> => (v !== null && typeof v === "object" && !Array.isArray(v) ? (v as Record<string, unknown>) : {});
|
||||
const str = (v: unknown): string | null => (typeof v === "string" && v.trim() !== "" ? v.trim() : null);
|
||||
|
||||
/** Pure: the groups of a `/core/groups/` page, by name. */
|
||||
export function parseGroups(raw: unknown): AuthentikGroup[] {
|
||||
const list = Array.isArray(raw) ? raw : Array.isArray(obj(raw).results) ? (obj(raw).results as unknown[]) : [];
|
||||
const out: AuthentikGroup[] = [];
|
||||
for (const item of list) {
|
||||
const g = obj(item);
|
||||
const id = str(g.pk);
|
||||
const name = str(g.name);
|
||||
if (!id || !name || !UUID.test(id)) continue;
|
||||
out.push({ id, name, admin: g.is_superuser === true });
|
||||
}
|
||||
return out.sort((a, b) => a.name.localeCompare(b.name));
|
||||
}
|
||||
|
||||
/** Pure: the user Authentik says it made. Null when the answer is not a user. */
|
||||
export function parseCreatedUser(raw: unknown): CreatedAuthentikUser | null {
|
||||
const u = obj(raw);
|
||||
const pk = typeof u.pk === "number" ? u.pk : Number.NaN;
|
||||
const username = str(u.username);
|
||||
if (!Number.isInteger(pk) || pk <= 0 || !username) return null;
|
||||
return { pk, username, name: str(u.name) ?? username };
|
||||
}
|
||||
|
||||
/** Pure: the link out of `/recovery/`'s answer; only a web address counts. */
|
||||
export function parseRecoveryLink(raw: unknown): string | null {
|
||||
const link = str(obj(raw).link);
|
||||
if (!link) return null;
|
||||
try {
|
||||
const url = new URL(link);
|
||||
return url.protocol === "https:" || url.protocol === "http:" ? url.toString() : null;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/** Pure: what Authentik's complaint says, in words. It answers `{"username": ["…"]}`, `{"detail": "…"}` or `{"non_field_errors": ["…"]}`; the longest it is allowed to be is a sentence or two. */
|
||||
export function describeComplaint(raw: unknown): string | null {
|
||||
const o = obj(raw);
|
||||
const parts: string[] = [];
|
||||
for (const [key, value] of Object.entries(o)) {
|
||||
const text = Array.isArray(value) ? value.filter((v): v is string => typeof v === "string").join(" ") : typeof value === "string" ? value : "";
|
||||
if (!text.trim()) continue;
|
||||
parts.push(key === "detail" || key === "non_field_errors" ? text.trim() : `${key}: ${text.trim()}`);
|
||||
}
|
||||
return parts.length > 0 ? parts.join("; ").slice(0, 300) : null;
|
||||
}
|
||||
|
||||
export interface AuthentikUsersAdapter {
|
||||
listGroups(): Promise<AuthentikGroup[]>;
|
||||
createUser(input: NewAuthentikUser): Promise<CreatedAuthentikUser>;
|
||||
recoveryLink(pk: number): Promise<string>;
|
||||
}
|
||||
|
||||
export function createAuthentikUsersAdapter(config: AuthentikUsersConfig): AuthentikUsersAdapter {
|
||||
const base = String(config.url ?? "").replace(/\/+$/, "");
|
||||
const insecure = config.insecure === true;
|
||||
const headers = { Authorization: `Bearer ${config.writeToken ?? ""}`, Accept: "application/json" };
|
||||
|
||||
async function call(method: "GET" | "POST", path: string, body?: unknown): Promise<unknown> {
|
||||
let res;
|
||||
try {
|
||||
res = await requestJson(`${base}/api/v3${path}`, { method, headers, body, insecure });
|
||||
} catch (err) {
|
||||
throw new AuthentikUserError(`Authentik could not be reached: ${err instanceof Error ? err.message : String(err)}`, "failed");
|
||||
}
|
||||
if (res.status === 401 || res.status === 403) throw new AuthentikUserError(`Authentik did not accept the token for making users (HTTP ${res.status}) — it must be an API token of an account that may add users`, "denied");
|
||||
if (res.status === 404) throw new AuthentikUserError("Authentik has no API at this address, or no such thing there — check the address", "failed");
|
||||
if (res.status === 400) throw new AuthentikUserError(describeComplaint(res.json) ?? "Authentik did not accept that", "invalid");
|
||||
if (res.status < 200 || res.status >= 300) throw new AuthentikUserError(`Authentik error: HTTP ${res.status}`, "failed");
|
||||
if (res.json === null) throw new AuthentikUserError("Authentik answered with something that isn't JSON — is the address its own?", "failed");
|
||||
return res.json;
|
||||
}
|
||||
|
||||
async function listGroups(): Promise<AuthentikGroup[]> {
|
||||
return parseGroups(await call("GET", `/core/groups/?page_size=${PAGE}&ordering=name`));
|
||||
}
|
||||
|
||||
async function createUser(input: NewAuthentikUser): Promise<CreatedAuthentikUser> {
|
||||
const body: Record<string, unknown> = { username: input.username, name: input.name, is_active: true, groups: input.groups.filter((g) => UUID.test(g)) };
|
||||
if (input.email) body.email = input.email;
|
||||
const user = parseCreatedUser(await call("POST", "/core/users/", body));
|
||||
if (!user) throw new AuthentikUserError("Authentik answered, but not with the user it made", "failed");
|
||||
return user;
|
||||
}
|
||||
|
||||
async function recoveryLink(pk: number): Promise<string> {
|
||||
if (!Number.isInteger(pk) || pk <= 0) throw new AuthentikUserError("That is not a user id", "invalid");
|
||||
// Asking for a day: a link nobody used should not stay good for weeks. A version of Authentik that does not take the duration uses its own.
|
||||
const link = parseRecoveryLink(await call("POST", `/core/users/${pk}/recovery/`, { token_duration: "days=1" }));
|
||||
if (!link) throw new AuthentikUserError("Authentik did not give a recovery link — a recovery flow has to be set for the brand (System → Brands)", "failed");
|
||||
return link;
|
||||
}
|
||||
|
||||
return withDiagLogging("authentik", { listGroups, createUser, recoveryLink });
|
||||
}
|
||||
@@ -187,6 +187,7 @@ export const INTEGRATION_FIELDS: Partial<Record<IntegrationType, IntegrationFiel
|
||||
authentik: [
|
||||
{ key: "url", label: "Authentik URL", secret: false, placeholder: "https://auth.example.lan" },
|
||||
{ key: "token", label: "API token", secret: true, type: "password", placeholder: "Directory → Tokens and App passwords, intent API Token" },
|
||||
{ key: "writeToken", label: "Token for making users (optional)", secret: true, optional: true, type: "password", placeholder: "only to make users from here; an account that may add users. Leave blank to only watch" },
|
||||
{ key: "insecure", label: "Allow self-signed certificate", secret: false, type: "checkbox" },
|
||||
],
|
||||
jellyfin: [
|
||||
|
||||
@@ -1,14 +1,71 @@
|
||||
import { Router } from "express";
|
||||
import { Router, type Response } from "express";
|
||||
import { eq } from "drizzle-orm";
|
||||
import { z } from "zod";
|
||||
import { db } from "../db/client.js";
|
||||
import { authentikState, integrations } from "../db/schema.js";
|
||||
import { requireAuth } from "../auth/middleware.js";
|
||||
import { authentikState, integrationCredentials, integrations } from "../db/schema.js";
|
||||
import { requireAuth, requireRole } from "../auth/middleware.js";
|
||||
import { decryptSecret, encryptSecret } from "../crypto.js";
|
||||
import { loadIntegrationConfig } from "../integrations/loadIntegration.js";
|
||||
import { AuthentikUserError, createAuthentikUsersAdapter, type AuthentikUsersAdapter } from "../integrations/authentik/users.js";
|
||||
import { recordAudit } from "../services/audit.js";
|
||||
import { authentikProblems, authentikSyncStatuses, certificatesOf, daysUntil, isAuthentikFresh, outpostsOf, tokensOf } from "../services/authentikSync.js";
|
||||
import { asyncHandler } from "../utils/asyncHandler.js";
|
||||
|
||||
export const authentikRouter = Router();
|
||||
authentikRouter.use(requireAuth);
|
||||
|
||||
const hasWriteToken = (config: Record<string, unknown>) => typeof config.writeToken === "string" && config.writeToken.trim() !== "";
|
||||
|
||||
/** Whether this Authentik was given a token to make users with. Never says more than that; a credential that cannot be opened counts as none. */
|
||||
async function canCreateUsers(id: number): Promise<boolean> {
|
||||
try {
|
||||
const loaded = await loadIntegrationConfig(id);
|
||||
return !!loaded && hasWriteToken(loaded.config);
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/** The adapter that makes users for one Authentik, or the answer to send when there is not one to use. Only an enabled Authentik with a token for it. */
|
||||
async function usersAdapterFor(rawId: string, res: Response): Promise<{ adapter: AuthentikUsersAdapter; id: number; name: string } | null> {
|
||||
const id = /^\d+$/.test(rawId) ? Number(rawId) : NaN;
|
||||
if (!Number.isInteger(id)) {
|
||||
res.status(400).json({ error: "invalid_id" });
|
||||
return null;
|
||||
}
|
||||
const loaded = await loadIntegrationConfig(id);
|
||||
if (!loaded) {
|
||||
res.status(404).json({ error: "not_found" });
|
||||
return null;
|
||||
}
|
||||
if (loaded.integration.type !== "authentik") {
|
||||
res.status(400).json({ error: "wrong_type" });
|
||||
return null;
|
||||
}
|
||||
if (!loaded.integration.enabled) {
|
||||
res.status(400).json({ error: "integration_disabled", message: "This Authentik is switched off." });
|
||||
return null;
|
||||
}
|
||||
if (!hasWriteToken(loaded.config)) {
|
||||
res.status(400).json({ error: "no_write_token", message: "This Authentik has no token for making users. Add one under Integrations → edit." });
|
||||
return null;
|
||||
}
|
||||
return { adapter: createAuthentikUsersAdapter(loaded.config as never), id, name: loaded.integration.name };
|
||||
}
|
||||
|
||||
/** What a failed call to Authentik is answered with: what it said when it looked and refused, a bad gateway otherwise. */
|
||||
function sendFailure(res: Response, err: unknown) {
|
||||
if (err instanceof AuthentikUserError) return res.status(err.kind === "invalid" ? 400 : 502).json({ error: `authentik_${err.kind}`, message: err.message });
|
||||
return res.status(502).json({ error: "authentik_failed", message: err instanceof Error ? err.message : String(err) });
|
||||
}
|
||||
|
||||
const newUserSchema = z.object({
|
||||
username: z.string().trim().min(1, "A user name is needed.").max(150).regex(/^[^\x00-\x1f\x7f]+$/, "A user name can't hold control characters."),
|
||||
name: z.string().trim().min(1, "A name is needed.").max(200),
|
||||
email: z.union([z.literal(""), z.string().trim().email("That is not an email address.").max(254)]).optional(),
|
||||
groups: z.array(z.string().uuid()).max(50).default([]),
|
||||
});
|
||||
|
||||
/** Every Authentik, how it is, from what the last read stored: its outposts, certificates and tokens that run out, and what is wrong. Everyone signed in can see it, like the other pages made of stored readings. */
|
||||
authentikRouter.get("/", asyncHandler(async (_req, res) => {
|
||||
const [rows, states, statuses] = await Promise.all([
|
||||
@@ -17,6 +74,7 @@ authentikRouter.get("/", asyncHandler(async (_req, res) => {
|
||||
authentikSyncStatuses(),
|
||||
]);
|
||||
const byId = new Map(states.map((s) => [s.integrationId, s]));
|
||||
const writable = new Map(await Promise.all(rows.map(async (r) => [r.id, await canCreateUsers(r.id)] as const)));
|
||||
const now = new Date();
|
||||
res.json({
|
||||
authentiks: rows.map((r) => {
|
||||
@@ -27,6 +85,7 @@ authentikRouter.get("/", asyncHandler(async (_req, res) => {
|
||||
id: r.id,
|
||||
name: r.name,
|
||||
enabled: r.enabled,
|
||||
canCreateUsers: r.enabled && writable.get(r.id) === true,
|
||||
status,
|
||||
fresh,
|
||||
state: state
|
||||
@@ -49,3 +108,72 @@ authentikRouter.get("/", asyncHandler(async (_req, res) => {
|
||||
}),
|
||||
});
|
||||
}));
|
||||
|
||||
/** The groups a new user can be put in, as the Authentik being asked has them. Only an administrator, and only where a token for making users was given. */
|
||||
authentikRouter.get("/:id/groups", requireRole("admin"), asyncHandler(async (req, res) => {
|
||||
const target = await usersAdapterFor(req.params.id, res);
|
||||
if (!target) return;
|
||||
try {
|
||||
res.json({ groups: await target.adapter.listGroups() });
|
||||
} catch (err) {
|
||||
sendFailure(res, err);
|
||||
}
|
||||
}));
|
||||
|
||||
/**
|
||||
* Makes a user and a one-time recovery link for them, which is how they choose their own password: no password passes through here. The link is in this answer and nowhere else — not stored,
|
||||
* not in the audit log. When the user is made and the link is not, the answer says so and the link is made in Authentik (the user's page → Create recovery link).
|
||||
*/
|
||||
authentikRouter.post("/:id/users", requireRole("admin"), asyncHandler(async (req, res) => {
|
||||
const parsed = newUserSchema.safeParse(req.body);
|
||||
if (!parsed.success) return res.status(400).json({ error: "invalid_body", message: parsed.error.issues[0]?.message ?? "That is not a user.", details: parsed.error.flatten() });
|
||||
const target = await usersAdapterFor(req.params.id, res);
|
||||
if (!target) return;
|
||||
|
||||
let user;
|
||||
try {
|
||||
user = await target.adapter.createUser({ username: parsed.data.username, name: parsed.data.name, email: parsed.data.email || undefined, groups: parsed.data.groups });
|
||||
} catch (err) {
|
||||
return sendFailure(res, err);
|
||||
}
|
||||
await recordAudit({
|
||||
actor: req.currentUser!,
|
||||
category: "integration",
|
||||
action: "create_authentik_user",
|
||||
targetType: "authentik_user",
|
||||
targetId: user.pk,
|
||||
detail: { integrationId: target.id, integration: target.name, username: user.username, groups: parsed.data.groups.length },
|
||||
});
|
||||
|
||||
let link: string | null = null;
|
||||
let linkError: string | null = null;
|
||||
try {
|
||||
link = await target.adapter.recoveryLink(user.pk);
|
||||
await recordAudit({ actor: req.currentUser!, category: "integration", action: "make_authentik_recovery_link", targetType: "authentik_user", targetId: user.pk, detail: { integrationId: target.id, username: user.username } });
|
||||
} catch (err) {
|
||||
linkError = err instanceof Error ? err.message : String(err);
|
||||
}
|
||||
res.set("Cache-Control", "no-store");
|
||||
res.status(201).json({ user, link, linkError });
|
||||
}));
|
||||
|
||||
/** Takes the token for making users away again, leaving the one that reads. */
|
||||
authentikRouter.delete("/:id/write-token", requireRole("admin"), asyncHandler(async (req, res) => {
|
||||
const id = /^\d+$/.test(req.params.id) ? Number(req.params.id) : NaN;
|
||||
if (!Number.isInteger(id)) return res.status(400).json({ error: "invalid_id" });
|
||||
const [row] = await db.select().from(integrations).where(eq(integrations.id, id)).limit(1);
|
||||
if (!row) return res.status(404).json({ error: "not_found" });
|
||||
if (row.type !== "authentik") return res.status(400).json({ error: "wrong_type" });
|
||||
if (row.credentialId) {
|
||||
const [cred] = await db.select().from(integrationCredentials).where(eq(integrationCredentials.id, row.credentialId)).limit(1);
|
||||
if (cred) {
|
||||
const secrets = JSON.parse(decryptSecret(cred.encryptedSecret)) as Record<string, unknown>;
|
||||
if ("writeToken" in secrets) {
|
||||
delete secrets.writeToken;
|
||||
await db.update(integrationCredentials).set({ encryptedSecret: encryptSecret(JSON.stringify(secrets)) }).where(eq(integrationCredentials.id, cred.id));
|
||||
await recordAudit({ actor: req.currentUser!, category: "integration", action: "remove_authentik_write_token", targetType: "integration", targetId: id, detail: { name: row.name } });
|
||||
}
|
||||
}
|
||||
}
|
||||
res.status(204).end();
|
||||
}));
|
||||
@@ -0,0 +1,372 @@
|
||||
/**
|
||||
* Making a user in Authentik: what its answers are read as, the three calls it takes (groups, the user, a recovery link), that a token of its own is used and the one that reads never is, the
|
||||
* admin-only routes, what is written in the audit log (never the link), and taking the token away.
|
||||
*
|
||||
* Run with: npm test --workspace server
|
||||
*/
|
||||
import { test, describe, before, after } from "node:test";
|
||||
import assert from "node:assert/strict";
|
||||
import { createServer as createHttpServer, type Server } from "node:http";
|
||||
import { mkdtempSync, rmSync } from "node:fs";
|
||||
import { tmpdir } from "node:os";
|
||||
import { join } from "node:path";
|
||||
import type { AddressInfo } from "node:net";
|
||||
|
||||
const dir = mkdtempSync(join(tmpdir(), "hm-authentik-users-"));
|
||||
process.env.DATABASE_PATH = join(dir, "test.sqlite");
|
||||
process.env.SESSION_DIR = join(dir, "sessions");
|
||||
process.env.CREDENTIALS_ENCRYPTION_KEY = "ab".repeat(32);
|
||||
|
||||
const express = (await import("express")).default;
|
||||
const { db } = await import("../src/db/client.js");
|
||||
const { users, integrations, integrationCredentials, auditLog } = await import("../src/db/schema.js");
|
||||
const { runMigrations } = await import("../src/db/migrate.js");
|
||||
const { encryptSecret } = await import("../src/crypto.js");
|
||||
const { INTEGRATION_FIELDS } = await import("../src/integrations/fieldSchemas.js");
|
||||
const { loadIntegrationConfig } = await import("../src/integrations/loadIntegration.js");
|
||||
const usersApi = await import("../src/integrations/authentik/users.js");
|
||||
const { createAuthentikAdapter } = await import("../src/integrations/authentik/adapter.js");
|
||||
const { authentikRouter } = await import("../src/routes/authentik.js");
|
||||
|
||||
await runMigrations();
|
||||
|
||||
const GROUP_A = "11111111-1111-4111-8111-111111111111";
|
||||
const GROUP_ADMIN = "22222222-2222-4222-8222-222222222222";
|
||||
|
||||
describe("what Authentik's answers are read as", () => {
|
||||
test("groups: by name, with the ones that make an administrator marked; a row without a real id or a name is left out", () => {
|
||||
const groups = usersApi.parseGroups({
|
||||
results: [
|
||||
{ pk: GROUP_ADMIN, name: "authentik Admins", is_superuser: true },
|
||||
{ pk: GROUP_A, name: "Family", is_superuser: false },
|
||||
{ pk: "not-a-uuid", name: "Broken" },
|
||||
{ pk: "33333333-3333-4333-8333-333333333333", name: " " },
|
||||
],
|
||||
});
|
||||
assert.deepEqual(groups, [{ id: GROUP_ADMIN, name: "authentik Admins", admin: true }, { id: GROUP_A, name: "Family", admin: false }]);
|
||||
assert.deepEqual(usersApi.parseGroups("nonsense"), []);
|
||||
});
|
||||
|
||||
test("the user it made needs a whole-number id and a name; the display name falls back to the user name", () => {
|
||||
assert.deepEqual(usersApi.parseCreatedUser({ pk: 7, username: "ada", name: "Ada L" }), { pk: 7, username: "ada", name: "Ada L" });
|
||||
assert.deepEqual(usersApi.parseCreatedUser({ pk: 7, username: "ada" }), { pk: 7, username: "ada", name: "ada" });
|
||||
assert.equal(usersApi.parseCreatedUser({ pk: "7", username: "ada" }), null);
|
||||
assert.equal(usersApi.parseCreatedUser({ pk: 0, username: "ada" }), null);
|
||||
assert.equal(usersApi.parseCreatedUser({ pk: 3 }), null);
|
||||
});
|
||||
|
||||
test("the link must be a web address", () => {
|
||||
assert.equal(usersApi.parseRecoveryLink({ link: "https://auth.example.lan/if/flow/recovery/?token=abc" }), "https://auth.example.lan/if/flow/recovery/?token=abc");
|
||||
assert.equal(usersApi.parseRecoveryLink({ link: "javascript:alert(1)" }), null);
|
||||
assert.equal(usersApi.parseRecoveryLink({ link: "not a url" }), null);
|
||||
assert.equal(usersApi.parseRecoveryLink({}), null);
|
||||
});
|
||||
|
||||
test("a complaint is put in words, field by field, and kept short", () => {
|
||||
assert.equal(usersApi.describeComplaint({ username: ["A user with that username already exists."] }), "username: A user with that username already exists.");
|
||||
assert.equal(usersApi.describeComplaint({ detail: "Not allowed." }), "Not allowed.");
|
||||
assert.equal(usersApi.describeComplaint({ non_field_errors: ["No recovery flow set."] }), "No recovery flow set.");
|
||||
assert.equal(usersApi.describeComplaint({ email: ["x".repeat(900)] })?.length, 300);
|
||||
assert.equal(usersApi.describeComplaint({}), null);
|
||||
assert.equal(usersApi.describeComplaint(null), null);
|
||||
});
|
||||
});
|
||||
|
||||
/** An Authentik that remembers what it was asked. */
|
||||
interface Seen {
|
||||
method: string;
|
||||
path: string;
|
||||
auth: string;
|
||||
body: string;
|
||||
}
|
||||
const seen: Seen[] = [];
|
||||
let createStatus = 201;
|
||||
let createAnswer: unknown = null;
|
||||
let recoveryStatus = 200;
|
||||
let recoveryAnswer: unknown = null;
|
||||
let nextPk = 40;
|
||||
|
||||
let fake: Server;
|
||||
let fakeUrl = "";
|
||||
|
||||
before(async () => {
|
||||
fake = createHttpServer((req, res) => {
|
||||
let body = "";
|
||||
req.on("data", (c) => (body += c));
|
||||
req.on("end", () => {
|
||||
const path = req.url ?? "";
|
||||
seen.push({ method: req.method ?? "", path, auth: String(req.headers.authorization ?? ""), body });
|
||||
const send = (status: number, json: unknown) => {
|
||||
res.writeHead(status, { "content-type": "application/json" });
|
||||
res.end(JSON.stringify(json));
|
||||
};
|
||||
if (req.method === "GET" && path.startsWith("/api/v3/core/groups/")) {
|
||||
return send(200, { results: [{ pk: GROUP_A, name: "Family", is_superuser: false }, { pk: GROUP_ADMIN, name: "authentik Admins", is_superuser: true }] });
|
||||
}
|
||||
if (req.method === "POST" && path === "/api/v3/core/users/") {
|
||||
if (createStatus !== 201) return send(createStatus, createAnswer ?? {});
|
||||
const b = JSON.parse(body) as { username: string; name: string };
|
||||
return send(201, createAnswer ?? { pk: nextPk++, username: b.username, name: b.name });
|
||||
}
|
||||
const rec = /^\/api\/v3\/core\/users\/(\d+)\/recovery\/$/.exec(path);
|
||||
if (req.method === "POST" && rec) return send(recoveryStatus, recoveryAnswer ?? { link: `${fakeUrl}/if/flow/recovery/?token=secret-${rec[1]}` });
|
||||
// What the read adapter asks: anything else answers with something that parses as empty.
|
||||
if (req.method === "GET" && path.startsWith("/api/v3/admin/version/")) return send(200, { version_current: "2025.2.1", version_latest: "2025.2.1", outdated: false });
|
||||
return send(200, { results: [] });
|
||||
});
|
||||
});
|
||||
await new Promise<void>((resolve) => fake.listen(0, "127.0.0.1", resolve));
|
||||
fakeUrl = `http://127.0.0.1:${(fake.address() as AddressInfo).port}`;
|
||||
});
|
||||
|
||||
after(() => {
|
||||
fake.close();
|
||||
});
|
||||
|
||||
const adapterFor = (writeToken = "write-tok") => usersApi.createAuthentikUsersAdapter({ url: fakeUrl, writeToken });
|
||||
|
||||
describe("the three calls", () => {
|
||||
test("the groups are asked for with the token for making users", async () => {
|
||||
seen.length = 0;
|
||||
const groups = await adapterFor().listGroups();
|
||||
assert.deepEqual(groups.map((g) => g.name), ["authentik Admins", "Family"]);
|
||||
assert.deepEqual(seen.map((s) => [s.method, s.path.split("?")[0], s.auth]), [["GET", "/api/v3/core/groups/", "Bearer write-tok"]]);
|
||||
});
|
||||
|
||||
test("a user is a POST of the name, the user name, the email if there is one and the groups — and no password", async () => {
|
||||
seen.length = 0;
|
||||
const user = await adapterFor().createUser({ username: "ada", name: "Ada L", email: "ada@example.com", groups: [GROUP_A, "not-a-uuid"] });
|
||||
assert.equal(user.username, "ada");
|
||||
assert.equal(seen.length, 1);
|
||||
assert.deepEqual([seen[0].method, seen[0].path], ["POST", "/api/v3/core/users/"]);
|
||||
const body = JSON.parse(seen[0].body);
|
||||
assert.deepEqual(body, { username: "ada", name: "Ada L", is_active: true, groups: [GROUP_A], email: "ada@example.com" });
|
||||
assert.equal("password" in body, false);
|
||||
await adapterFor().createUser({ username: "bo", name: "Bo", groups: [] });
|
||||
assert.equal("email" in JSON.parse(seen[1].body), false, "no email, no email field");
|
||||
});
|
||||
|
||||
test("the link is a POST to that user's recovery, and a user id that is not a whole number is never put in the address", async () => {
|
||||
seen.length = 0;
|
||||
const link = await adapterFor().recoveryLink(41);
|
||||
assert.match(link, /\/if\/flow\/recovery\/\?token=secret-41$/);
|
||||
assert.deepEqual(seen.map((s) => [s.method, s.path]), [["POST", "/api/v3/core/users/41/recovery/"]]);
|
||||
await assert.rejects(() => adapterFor().recoveryLink(1.5), /not a user id/);
|
||||
await assert.rejects(() => adapterFor().recoveryLink(Number.NaN), /not a user id/);
|
||||
assert.equal(seen.length, 1);
|
||||
});
|
||||
|
||||
test("what goes wrong is said in kind: refused (the words Authentik used), not accepted, nothing sensible back, nobody there", async () => {
|
||||
createStatus = 400;
|
||||
createAnswer = { username: ["A user with that username already exists."] };
|
||||
await assert.rejects(
|
||||
() => adapterFor().createUser({ username: "ada", name: "Ada", groups: [] }),
|
||||
(err: Error & { kind?: string }) => err.kind === "invalid" && /username: A user with that username already exists\./.test(err.message),
|
||||
);
|
||||
createStatus = 403;
|
||||
createAnswer = { detail: "You do not have permission." };
|
||||
await assert.rejects(
|
||||
() => adapterFor().createUser({ username: "ada", name: "Ada", groups: [] }),
|
||||
(err: Error & { kind?: string }) => err.kind === "denied" && /may add users/.test(err.message),
|
||||
);
|
||||
createStatus = 201;
|
||||
createAnswer = { nothing: "useful" };
|
||||
await assert.rejects(() => adapterFor().createUser({ username: "ada", name: "Ada", groups: [] }), /not with the user it made/);
|
||||
createAnswer = null;
|
||||
recoveryAnswer = { link: "" };
|
||||
await assert.rejects(() => adapterFor().recoveryLink(5), /recovery flow/);
|
||||
recoveryAnswer = null;
|
||||
await assert.rejects(() => usersApi.createAuthentikUsersAdapter({ url: "http://127.0.0.1:1", writeToken: "x" }).listGroups(), /could not be reached/);
|
||||
});
|
||||
});
|
||||
|
||||
describe("the integration form and the reading", () => {
|
||||
test("the token for making users is an optional secret of the Authentik integration", () => {
|
||||
const field = INTEGRATION_FIELDS.authentik!.find((f) => f.key === "writeToken");
|
||||
assert.deepEqual([field?.secret, field?.optional, field?.type], [true, true, "password"]);
|
||||
});
|
||||
|
||||
test("reading Authentik sends nothing but GET requests, with the token that reads — the one for making users is not used", async () => {
|
||||
seen.length = 0;
|
||||
await createAuthentikAdapter({ url: fakeUrl, token: "read-tok", writeToken: "write-tok" } as never).read();
|
||||
assert.ok(seen.length > 0);
|
||||
assert.deepEqual([...new Set(seen.map((s) => s.method))], ["GET"]);
|
||||
assert.deepEqual([...new Set(seen.map((s) => s.auth))], ["Bearer read-tok"]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("the routes", () => {
|
||||
let app: Server;
|
||||
let base = "";
|
||||
let withToken = 0;
|
||||
let withoutToken = 0;
|
||||
let otherType = 0;
|
||||
let off = 0;
|
||||
|
||||
const as = (sub: string) => ({ "content-type": "application/json", "x-sub": sub });
|
||||
const post = (id: number, body: unknown, sub = "admin") => fetch(`${base}/${id}/users`, { method: "POST", headers: as(sub), body: JSON.stringify(body) });
|
||||
const valid = { username: "ada", name: "Ada Lovelace", email: "ada@example.com", groups: [GROUP_A] };
|
||||
|
||||
before(async () => {
|
||||
await db.insert(users).values([
|
||||
{ oidcSub: "admin", name: "Alma", role: "admin" },
|
||||
{ oidcSub: "operator", name: "Olle", role: "operator" },
|
||||
{ oidcSub: "viewer", name: "Vic", role: "viewer" },
|
||||
]);
|
||||
const cred = (await db.insert(integrationCredentials).values({ name: "authentik:Front door", encryptedSecret: encryptSecret(JSON.stringify({ token: "read-tok", writeToken: "write-tok" })) }).returning({ id: integrationCredentials.id }))[0];
|
||||
const credOnlyRead = (await db.insert(integrationCredentials).values({ name: "authentik:Watched", encryptedSecret: encryptSecret(JSON.stringify({ token: "read-tok" })) }).returning({ id: integrationCredentials.id }))[0];
|
||||
const config = JSON.stringify({ url: fakeUrl });
|
||||
withToken = (await db.insert(integrations).values({ type: "authentik", name: "Front door", baseUrl: fakeUrl, config, credentialId: cred.id }).returning({ id: integrations.id }))[0].id;
|
||||
withoutToken = (await db.insert(integrations).values({ type: "authentik", name: "Watched", baseUrl: fakeUrl, config, credentialId: credOnlyRead.id }).returning({ id: integrations.id }))[0].id;
|
||||
off = (await db.insert(integrations).values({ type: "authentik", name: "Switched off", baseUrl: fakeUrl, config, credentialId: cred.id, enabled: false }).returning({ id: integrations.id }))[0].id;
|
||||
otherType = (await db.insert(integrations).values({ type: "jellyfin", name: "Media", baseUrl: fakeUrl, config, credentialId: cred.id }).returning({ id: integrations.id }))[0].id;
|
||||
|
||||
const a = express();
|
||||
a.use(express.json());
|
||||
a.use((req, _res, next) => {
|
||||
(req as unknown as { session: unknown }).session = { user: { sub: String(req.headers["x-sub"] ?? "viewer") } };
|
||||
next();
|
||||
});
|
||||
a.use("/api/authentik", authentikRouter);
|
||||
app = await new Promise<Server>((resolve) => {
|
||||
const s = a.listen(0, "127.0.0.1", () => resolve(s));
|
||||
});
|
||||
base = `http://127.0.0.1:${(app.address() as AddressInfo).port}/api/authentik`;
|
||||
});
|
||||
after(() => {
|
||||
app.close();
|
||||
try {
|
||||
rmSync(dir, { recursive: true, force: true });
|
||||
} catch {
|
||||
// Windows keeps the database file locked until the process exits.
|
||||
}
|
||||
});
|
||||
|
||||
test("the page says which Authentik can make users — only a yes or no, never the token — and a switched-off one cannot", async () => {
|
||||
const res = await fetch(base, { headers: as("viewer") });
|
||||
assert.equal(res.status, 200);
|
||||
const text = await res.text();
|
||||
assert.equal(/write-tok|read-tok/.test(text), false);
|
||||
const body = JSON.parse(text) as { authentiks: { id: number; canCreateUsers: boolean }[] };
|
||||
const can = Object.fromEntries(body.authentiks.map((a) => [a.id, a.canCreateUsers]));
|
||||
assert.deepEqual([can[withToken], can[withoutToken], can[off]], [true, false, false]);
|
||||
});
|
||||
|
||||
test("only an administrator makes users or sees the groups; nothing reaches Authentik for anyone else", async () => {
|
||||
seen.length = 0;
|
||||
for (const sub of ["viewer", "operator"]) {
|
||||
assert.equal((await post(withToken, valid, sub)).status, 403, sub);
|
||||
assert.equal((await fetch(`${base}/${withToken}/groups`, { headers: as(sub) })).status, 403, sub);
|
||||
assert.equal((await fetch(`${base}/${withToken}/write-token`, { method: "DELETE", headers: as(sub) })).status, 403, sub);
|
||||
}
|
||||
assert.deepEqual(seen, []);
|
||||
});
|
||||
|
||||
test("the groups come from the Authentik asked", async () => {
|
||||
seen.length = 0;
|
||||
const res = await fetch(`${base}/${withToken}/groups`, { headers: as("admin") });
|
||||
assert.equal(res.status, 200);
|
||||
const body = (await res.json()) as { groups: { name: string; admin: boolean }[] };
|
||||
assert.deepEqual(body.groups.map((g) => [g.name, g.admin]), [["authentik Admins", true], ["Family", false]]);
|
||||
assert.equal(seen[0].auth, "Bearer write-tok");
|
||||
});
|
||||
|
||||
test("a user is made with a link for them; the link is in the answer only, and the audit log says who made whom but not the link", async () => {
|
||||
seen.length = 0;
|
||||
const res = await post(withToken, valid);
|
||||
assert.equal(res.status, 201);
|
||||
assert.equal(res.headers.get("cache-control"), "no-store");
|
||||
const body = (await res.json()) as { user: { pk: number; username: string }; link: string | null; linkError: string | null };
|
||||
assert.equal(body.user.username, "ada");
|
||||
assert.match(body.link ?? "", /\/if\/flow\/recovery\/\?token=secret-/);
|
||||
assert.equal(body.linkError, null);
|
||||
assert.deepEqual(seen.map((s) => `${s.method} ${s.path}`), ["POST /api/v3/core/users/", `POST /api/v3/core/users/${body.user.pk}/recovery/`]);
|
||||
const entries = (await db.select().from(auditLog)).filter((e) => e.action === "create_authentik_user" || e.action === "make_authentik_recovery_link");
|
||||
assert.deepEqual(entries.map((e) => e.action).sort(), ["create_authentik_user", "make_authentik_recovery_link"]);
|
||||
for (const e of entries) {
|
||||
assert.deepEqual([e.category, e.targetType, e.targetId], ["integration", "authentik_user", String(body.user.pk)]);
|
||||
assert.match(e.detail ?? "", /ada/);
|
||||
assert.equal(/secret-|token|write-tok|recovery\/\?/.test(e.detail ?? ""), false, "the link and the tokens are not written down");
|
||||
}
|
||||
});
|
||||
|
||||
test("what is wrong with the form is said before Authentik is asked", async () => {
|
||||
seen.length = 0;
|
||||
for (const bad of [{ ...valid, username: " " }, { ...valid, name: "" }, { ...valid, email: "not-an-email" }, { ...valid, groups: ["not-a-uuid"] }, { ...valid, username: "a\nb" }, { name: "x" }]) {
|
||||
const res = await post(withToken, bad);
|
||||
assert.equal(res.status, 400, JSON.stringify(bad));
|
||||
assert.equal(typeof ((await res.json()) as { message: string }).message, "string");
|
||||
}
|
||||
assert.equal((await post(withToken, { ...valid, email: "" })).status, 201, "the email may be left empty");
|
||||
assert.deepEqual(seen.filter((s) => !s.path.includes("/recovery/")).length, 1, "only the valid one was passed on");
|
||||
});
|
||||
|
||||
test("an Authentik without a token for making users, a switched-off one, another kind of integration and an unknown one are not written to", async () => {
|
||||
seen.length = 0;
|
||||
const r1 = await post(withoutToken, valid);
|
||||
assert.equal(r1.status, 400);
|
||||
assert.equal(((await r1.json()) as { error: string }).error, "no_write_token");
|
||||
assert.equal(((await (await post(off, valid)).json()) as { error: string }).error, "integration_disabled");
|
||||
assert.equal(((await (await post(otherType, valid)).json()) as { error: string }).error, "wrong_type");
|
||||
assert.equal((await post(999999, valid)).status, 404);
|
||||
assert.equal((await fetch(`${base}/abc/users`, { method: "POST", headers: as("admin"), body: JSON.stringify(valid) })).status, 400);
|
||||
assert.equal((await fetch(`${base}/${withoutToken}/groups`, { headers: as("admin") })).status, 400);
|
||||
assert.deepEqual(seen, []);
|
||||
});
|
||||
|
||||
test("a name that is taken is Authentik's own words; no link is asked for", async () => {
|
||||
seen.length = 0;
|
||||
createStatus = 400;
|
||||
createAnswer = { username: ["A user with that username already exists."] };
|
||||
const res = await post(withToken, valid);
|
||||
assert.equal(res.status, 400);
|
||||
assert.match(((await res.json()) as { message: string }).message, /already exists/);
|
||||
assert.deepEqual(seen.map((s) => s.path), ["/api/v3/core/users/"]);
|
||||
createStatus = 201;
|
||||
createAnswer = null;
|
||||
});
|
||||
|
||||
test("a token that is not accepted is a bad gateway, not a refusal of the form", async () => {
|
||||
createStatus = 403;
|
||||
createAnswer = { detail: "nope" };
|
||||
const res = await post(withToken, valid);
|
||||
assert.equal(res.status, 502);
|
||||
assert.match(((await res.json()) as { message: string }).message, /did not accept the token/);
|
||||
createStatus = 201;
|
||||
createAnswer = null;
|
||||
});
|
||||
|
||||
test("a user made without a link is said so, and the user is still written down", async () => {
|
||||
recoveryStatus = 400;
|
||||
recoveryAnswer = { non_field_errors: ["No recovery flow set."] };
|
||||
const res = await post(withToken, { ...valid, username: "nolink" });
|
||||
assert.equal(res.status, 201);
|
||||
const body = (await res.json()) as { user: { pk: number }; link: string | null; linkError: string | null };
|
||||
assert.equal(body.link, null);
|
||||
assert.match(body.linkError ?? "", /No recovery flow set/);
|
||||
const entries = (await db.select().from(auditLog)).filter((e) => e.targetId === String(body.user.pk));
|
||||
assert.deepEqual(entries.map((e) => e.action), ["create_authentik_user"], "no link was made, so none is written down");
|
||||
recoveryStatus = 200;
|
||||
recoveryAnswer = null;
|
||||
});
|
||||
|
||||
test("the token for making users can be taken away; the one that reads stays, and the page says it can no longer make users", async () => {
|
||||
const res = await fetch(`${base}/${withToken}/write-token`, { method: "DELETE", headers: as("admin") });
|
||||
assert.equal(res.status, 204);
|
||||
const loaded = await loadIntegrationConfig(withToken);
|
||||
assert.equal(loaded?.config.token, "read-tok");
|
||||
assert.equal(loaded?.config.writeToken, undefined);
|
||||
const body = (await (await fetch(base, { headers: as("viewer") })).json()) as { authentiks: { id: number; canCreateUsers: boolean }[] };
|
||||
assert.equal(body.authentiks.find((a) => a.id === withToken)?.canCreateUsers, false);
|
||||
seen.length = 0;
|
||||
assert.equal((await post(withToken, valid)).status, 400);
|
||||
assert.deepEqual(seen, []);
|
||||
const entry = (await db.select().from(auditLog)).find((e) => e.action === "remove_authentik_write_token");
|
||||
assert.deepEqual([entry?.category, entry?.targetType], ["integration", "integration"]);
|
||||
// Again: nothing to take away, and nothing more is written down.
|
||||
assert.equal((await fetch(`${base}/${withToken}/write-token`, { method: "DELETE", headers: as("admin") })).status, 204);
|
||||
assert.equal((await db.select().from(auditLog)).filter((e) => e.action === "remove_authentik_write_token").length, 1);
|
||||
assert.equal((await fetch(`${base}/${otherType}/write-token`, { method: "DELETE", headers: as("admin") })).status, 400);
|
||||
assert.equal((await fetch(`${base}/999999/write-token`, { method: "DELETE", headers: as("admin") })).status, 404);
|
||||
});
|
||||
});
|
||||
Reference in new issue
Block a user