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
@@ -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();
|
||||
}));
|
||||
Reference in new issue
Block a user