@aplons/auth 0.1.0

package/dist/errors.js

@@ -0,0 +1,80 @@
+/**
+ * Ein Fehler, der sagt, was zu tun ist.
+ *
+ * OAuth antwortet mit Kennungen wie `invalid_grant` — richtig für eine
+ * Maschine, nutzlos für den, der um drei Uhr nachts in ein Log sieht. Jeder
+ * Fehler hier trägt deshalb beides: die Kennung für den Code und einen Satz
+ * für den Menschen.
+ */
+export class AplonsError extends Error {
+    /** Die OAuth-Kennung, etwa `invalid_grant`. */
+    code;
+    /** Der HTTP-Status, wenn der Fehler von einer Antwort kam. */
+    status;
+    /** Was der Server dazu geschrieben hat. */
+    description;
+    constructor(options) {
+        super(options.message, { cause: options.cause });
+        this.name = "AplonsError";
+        this.code = options.code;
+        this.status = options.status;
+        this.description = options.description;
+    }
+}
+/**
+ * `invalid_grant` heißt bei jedem Ablauf etwas anderes.
+ *
+ * Beide Ursachen unter denselben Satz zu stellen war ein Fehler: wer eine
+ * fehlgeschlagene Erneuerung untersuchte, las etwas über einen Anmeldecode,
+ * den es in diesem Ablauf gar nicht gibt — und suchte an der falschen Stelle.
+ */
+const INVALID_GRANT = {
+    code: "Der Anmeldecode wurde schon eingelöst, ist abgelaufen, oder der " +
+        "code_verifier passt nicht zum code_challenge. Meistens: die Rückkehr " +
+        "wurde zweimal ausgeführt, etwa weil der Browser die Seite neu geladen hat.",
+    refresh: "Das Refresh-Token gilt nicht mehr. Entweder ist es abgelaufen, es wurde " +
+        "beim Abmelden entwertet, oder es wurde schon einmal eingetauscht — jedes " +
+        "Erneuern gibt ein neues aus und macht das alte ungültig. Wer das alte " +
+        "aufbewahrt und noch einmal schickt, sieht genau diesen Fehler. In allen " +
+        "Fällen hilft nur eine neue Anmeldung.",
+    allgemein: "Die vorgelegte Berechtigung gilt nicht mehr. Eine neue Anmeldung hilft.",
+};
+/** Die häufigsten Kennungen, in Worte gefasst. */
+const ERKLAERT = {
+    invalid_client: "Client-ID oder Client-Secret stimmen nicht. Bei einer öffentlichen " +
+        "Anwendung darf gar kein Secret mitgeschickt werden.",
+    invalid_request: "Der Anfrage fehlt etwas oder sie enthält etwas Widersprüchliches.",
+    unauthorized_client: "Diese Anwendung darf diesen Ablauf nicht verwenden.",
+    access_denied: "Die Anmeldung wurde abgebrochen oder das Konto hat auf diese Anwendung " +
+        "keinen Zugriff.",
+    invalid_scope: "Mindestens einer der angeforderten Bereiche ist unbekannt.",
+    server_error: "Bei Aplons ist etwas schiefgegangen. Siehe status.aplons.com.",
+};
+/** Aus einer fehlgeschlagenen Antwort einen brauchbaren Fehler machen. */
+export async function ausAntwort(antwort, wobei, ablauf = "allgemein") {
+    let code = "http_" + antwort.status;
+    let description;
+    try {
+        const koerper = (await antwort.json());
+        if (koerper.error)
+            code = koerper.error;
+        description = koerper.error_description ?? koerper.message;
+    }
+    catch {
+        // Keine JSON-Antwort. Dann bleibt der Status die ganze Auskunft — was
+        // bei einem Proxy dazwischen der häufigere Fall ist als bei uns.
+    }
+    const erklaerung = code === "invalid_grant" ? INVALID_GRANT[ablauf] : ERKLAERT[code];
+    return new AplonsError({
+        code,
+        status: antwort.status,
+        description,
+        message: [
+            `${wobei} fehlgeschlagen (${code}).`,
+            erklaerung,
+            description && description !== erklaerung ? `Server: ${description}` : null,
+        ]
+            .filter(Boolean)
+            .join(" "),
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @aplons/auth — Anmeldung über Aplons in eigenen Anwendungen.
+ *
+ * Der Kern, ohne Rahmenwerk: läuft in Node, im Browser, am Rand und in einem
+ * Worker. Für Next.js gibt es zusätzlich `@aplons/auth/next`, das die
+ * Cookie-Arbeit abnimmt.
+ *
+ * Eine einzige Abhängigkeit, `jose`, und die nur zum Prüfen von Unterschriften
+ * — dieselbe, die der Aplons-Server selbst benutzt. Alles andere macht die
+ * eingebaute Web-Crypto.
+ */
+export { AplonsAuth } from "./client.js";
+export { AplonsError } from "./errors.js";
+export { base64url, createChallenge, createState, createVerifier, gleich, } from "./pkce.js";
+export { pruefeIdToken, pruefeZugriffstoken, schluesselFuer } from "./verify.js";
+export { holeMetadaten, type Metadaten } from "./discovery.js";
+export type { AccessTokenClaims, Anmeldevorgang, AplonsOptions, IdTokenClaims, Profil, Sitzung, } from "./types.js";

package/dist/index.js

@@ -0,0 +1,16 @@
+/**
+ * @aplons/auth — Anmeldung über Aplons in eigenen Anwendungen.
+ *
+ * Der Kern, ohne Rahmenwerk: läuft in Node, im Browser, am Rand und in einem
+ * Worker. Für Next.js gibt es zusätzlich `@aplons/auth/next`, das die
+ * Cookie-Arbeit abnimmt.
+ *
+ * Eine einzige Abhängigkeit, `jose`, und die nur zum Prüfen von Unterschriften
+ * — dieselbe, die der Aplons-Server selbst benutzt. Alles andere macht die
+ * eingebaute Web-Crypto.
+ */
+export { AplonsAuth } from "./client.js";
+export { AplonsError } from "./errors.js";
+export { base64url, createChallenge, createState, createVerifier, gleich, } from "./pkce.js";
+export { pruefeIdToken, pruefeZugriffstoken, schluesselFuer } from "./verify.js";
+export { holeMetadaten } from "./discovery.js";

package/dist/next.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @aplons/auth/next — der Teil, den man sonst jedes Mal neu schreibt.
+ *
+ * Der Kern kennt keine Cookies; er weiß nichts davon, wo `verifier` und
+ * `state` zwischen zwei Aufrufen liegen. Genau dort steckt aber die Arbeit,
+ * und genau dort werden die Fehler gemacht: der Verifier im localStorage
+ * (jedes Skript auf der Seite liest ihn), der State ohne `httpOnly`, ein
+ * Cookie ohne `secure`, das über einen offenen Hotspot geht.
+ *
+ * Hier passiert das einmal richtig:
+ *
+ *   app/api/auth/[...aplons]/route.ts
+ *   ------------------------------------------------------------------
+ *   import { handhabe } from "@aplons/auth/next";
+ *
+ *   export const { GET, POST } = handhabe({
+ *     issuer: process.env.APLONS_ISSUER!,
+ *     clientId: process.env.APLONS_CLIENT_ID!,
+ *     clientSecret: process.env.APLONS_CLIENT_SECRET,
+ *     redirectUri: process.env.APLONS_REDIRECT_URI!,
+ *   });
+ *
+ * Das ergibt vier Adressen: /api/auth/login, /callback, /logout, /me.
+ *
+ * Next.js ist eine Peer-Abhängigkeit und wird hier absichtlich nicht
+ * importiert — dieses Modul kommt mit `Request` und `Response` aus, und die
+ * gibt es überall. So lässt es sich auch woanders verwenden, und wer nur den
+ * Kern will, zieht sich Next nicht mit ein.
+ */
+import { AplonsAuth } from "./client.js";
+import type { AplonsOptions, Sitzung } from "./types.js";
+export type HandlerOptions = AplonsOptions & {
+    /**
+     * Präfix, unter dem die vier Adressen liegen.
+     * Voreinstellung: aus `redirectUri` abgeleitet.
+     */
+    basePath?: string;
+    /** Wohin nach der Anmeldung, wenn nichts anderes verlangt wurde. */
+    nachAnmeldung?: string;
+    /** Wohin nach dem Abmelden. */
+    nachAbmeldung?: string;
+    /**
+     * Name des Cookies mit der Sitzung.
+     * Voreinstellung `aplons_session`.
+     */
+    cookieName?: string;
+    /**
+     * Wie die Sitzung abgelegt wird.
+     *
+     * Ohne eigene Angabe landet sie **verschlüsselt im Cookie**. Das kommt
+     * ohne Speicher aus, hat aber eine Grenze: 4 KB, und ein Widerruf wirkt
+     * erst, wenn das Zugriffstoken abläuft. Wer eine Datenbank hat, gibt hier
+     * seine eigene Ablage an.
+     */
+    speicher?: Sitzungsspeicher;
+};
+export type Sitzungsspeicher = {
+    lies(id: string): Promise<Sitzung | null>;
+    schreib(id: string, sitzung: Sitzung): Promise<void>;
+    loesche(id: string): Promise<void>;
+};
+/**
+ * Die vier Adressen.
+ *
+ * Zurückgegeben als `{ GET, POST }`, weil der App Router genau das erwartet.
+ */
+export declare function handhabe(options: HandlerOptions): {
+    GET: (request: Request) => Promise<Response>;
+    POST: (request: Request) => Promise<Response>;
+    auth: AplonsAuth;
+    sitzungAus: (request: Request) => Promise<Sitzung | null>;
+};

package/dist/next.js

@@ -0,0 +1,263 @@
+/**
+ * @aplons/auth/next — der Teil, den man sonst jedes Mal neu schreibt.
+ *
+ * Der Kern kennt keine Cookies; er weiß nichts davon, wo `verifier` und
+ * `state` zwischen zwei Aufrufen liegen. Genau dort steckt aber die Arbeit,
+ * und genau dort werden die Fehler gemacht: der Verifier im localStorage
+ * (jedes Skript auf der Seite liest ihn), der State ohne `httpOnly`, ein
+ * Cookie ohne `secure`, das über einen offenen Hotspot geht.
+ *
+ * Hier passiert das einmal richtig:
+ *
+ *   app/api/auth/[...aplons]/route.ts
+ *   ------------------------------------------------------------------
+ *   import { handhabe } from "@aplons/auth/next";
+ *
+ *   export const { GET, POST } = handhabe({
+ *     issuer: process.env.APLONS_ISSUER!,
+ *     clientId: process.env.APLONS_CLIENT_ID!,
+ *     clientSecret: process.env.APLONS_CLIENT_SECRET,
+ *     redirectUri: process.env.APLONS_REDIRECT_URI!,
+ *   });
+ *
+ * Das ergibt vier Adressen: /api/auth/login, /callback, /logout, /me.
+ *
+ * Next.js ist eine Peer-Abhängigkeit und wird hier absichtlich nicht
+ * importiert — dieses Modul kommt mit `Request` und `Response` aus, und die
+ * gibt es überall. So lässt es sich auch woanders verwenden, und wer nur den
+ * Kern will, zieht sich Next nicht mit ein.
+ */
+import { AplonsAuth } from "./client.js";
+import { AplonsError } from "./errors.js";
+const VORGANG_COOKIE = "aplons_vorgang";
+/**
+ * Die vier Adressen.
+ *
+ * Zurückgegeben als `{ GET, POST }`, weil der App Router genau das erwartet.
+ */
+export function handhabe(options) {
+    const auth = new AplonsAuth(options);
+    const basePath = options.basePath ?? ableitenBasePath(options.redirectUri);
+    const cookieName = options.cookieName ?? "aplons_session";
+    async function GET(request) {
+        const url = new URL(request.url);
+        const aktion = url.pathname.slice(basePath.length).replace(/^\/+/, "");
+        /*
+          Kein Fehler verlässt diese Funktion.
+    
+          Ein Wurf hier landet sonst als unbehandelte Ablehnung im Prozess der
+          Kundenanwendung — beim Ausprobieren hat das den Testserver schlicht
+          beendet, ohne dass irgendwo stand, warum. Ein Anmeldeknopf, der die
+          Anwendung abschießt, ist das Gegenteil von dem, was ein Paket abnehmen
+          soll. Die Meldung von AplonsError sagt bereits, was zu tun ist; sie
+          kommt hier heraus statt in einem Stapelabzug.
+        */
+        try {
+            switch (aktion) {
+                case "login":
+                    return await anmelden(request, url);
+                case "callback":
+                    return await rueckkehr(request, url);
+                case "logout":
+                    return await abmelden(request);
+                case "me":
+                    return await wer(request);
+                default:
+                    return json({ error: "not_found" }, 404);
+            }
+        }
+        catch (fehler) {
+            if (fehler instanceof AplonsError) {
+                return json({ error: fehler.code, message: fehler.message }, 500);
+            }
+            // Etwas Unerwartetes: die Meldung geht ins Log des Servers, nicht in
+            // die Antwort — dort könnte sie interne Pfade preisgeben.
+            console.error("[@aplons/auth]", fehler);
+            return json({
+                error: "unerwartet",
+                message: "Bei der Anmeldung ist etwas schiefgegangen. Siehe Serverlog.",
+            }, 500);
+        }
+    }
+    async function anmelden(request, url) {
+        const vorgang = await auth.start({
+            tenant: url.searchParams.get("tenant") ?? undefined,
+            erneutAnmelden: url.searchParams.get("prompt") === "login",
+        });
+        const antwort = weiter(vorgang.url);
+        /*
+          Verifier, State und Nonce zusammen in ein kurzlebiges Cookie.
+    
+          httpOnly, damit kein Skript sie liest; sameSite=lax, weil die Rückkehr
+          von Aplons eine Navigation von außen ist und ein `strict`-Cookie dabei
+          nicht mitgeschickt würde — der Vorgang bräche dann ausgerechnet im
+          letzten Schritt ab. Zehn Minuten: so lange braucht niemand für eine
+          Anmeldung, und was länger offen liegt, ist eher vergessen als in Arbeit.
+        */
+        setzeCookie(antwort, VORGANG_COOKIE, JSON.stringify({
+            v: vorgang.verifier,
+            s: vorgang.state,
+            n: vorgang.nonce,
+            z: url.searchParams.get("weiter") ?? options.nachAnmeldung ?? "/",
+        }), { maxAge: 600, sicher: istHttps(url) });
+        return antwort;
+    }
+    async function rueckkehr(request, url) {
+        const roh = liesCookie(request, VORGANG_COOKIE);
+        if (!roh) {
+            return fehlerSeite("Der Anmeldevorgang ist nicht mehr da. Das passiert, wenn die " +
+                "Anmeldung länger als zehn Minuten offen lag oder in einem anderen " +
+                "Browser begonnen wurde. Fang noch einmal an.");
+        }
+        let vorgang;
+        try {
+            vorgang = JSON.parse(roh);
+        }
+        catch {
+            return fehlerSeite("Der Anmeldevorgang ist unlesbar. Fang noch einmal an.");
+        }
+        let sitzung;
+        try {
+            sitzung = await auth.rueckkehr({
+                url,
+                verifier: vorgang.v,
+                state: vorgang.s,
+                nonce: vorgang.n,
+            });
+        }
+        catch (fehler) {
+            return fehlerSeite(fehler instanceof AplonsError ? fehler.message : "Die Anmeldung ist fehlgeschlagen.");
+        }
+        // Nur relative Ziele: ein „weiter"-Parameter, der auf eine fremde Adresse
+        // zeigt, macht aus der eigenen Anmeldung eine Weiterleitung für andere.
+        const ziel = vorgang.z.startsWith("/") && !vorgang.z.startsWith("//") ? vorgang.z : "/";
+        const antwort = weiter(new URL(ziel, url).toString());
+        // Der Vorgang ist erledigt; sein Cookie hat nichts mehr zu suchen.
+        loescheCookie(antwort, VORGANG_COOKIE, istHttps(url));
+        await legeSitzungAb(antwort, sitzung, istHttps(url));
+        return antwort;
+    }
+    async function abmelden(request) {
+        const sitzung = await holeSitzung(request);
+        const url = new URL(request.url);
+        if (sitzung?.refreshToken) {
+            // Das Refresh-Token gilt dreißig Tage weiter, wenn es niemand
+            // entwertet — ein gelöschtes Cookie beeindruckt es nicht.
+            await auth.widerrufen(sitzung.refreshToken).catch(() => undefined);
+        }
+        const abmeldeUrl = await auth.abmeldeUrl({
+            danach: options.nachAbmeldung
+                ? new URL(options.nachAbmeldung, url).toString()
+                : undefined,
+            idToken: sitzung?.idToken,
+        });
+        const antwort = weiter(abmeldeUrl);
+        loescheCookie(antwort, cookieName, istHttps(url));
+        if (options.speicher)
+            loescheCookie(antwort, cookieName + "_id", istHttps(url));
+        return antwort;
+    }
+    async function wer(request) {
+        const sitzung = await holeSitzung(request);
+        if (!sitzung)
+            return json({ angemeldet: false }, 401);
+        // Abgelaufen? Dann still erneuern, statt den Aufrufer abzuweisen.
+        if (sitzung.accessTokenExpiresAt.getTime() < Date.now() && sitzung.refreshToken) {
+            try {
+                const frisch = await auth.erneuern(sitzung.refreshToken);
+                const antwort = json({ angemeldet: true, konto: frisch.claims ?? null });
+                await legeSitzungAb(antwort, frisch, istHttps(new URL(request.url)));
+                return antwort;
+            }
+            catch {
+                return json({ angemeldet: false }, 401);
+            }
+        }
+        return json({ angemeldet: true, konto: sitzung.claims ?? null });
+    }
+    async function holeSitzung(request) {
+        if (options.speicher) {
+            const id = liesCookie(request, cookieName + "_id");
+            return id ? options.speicher.lies(id) : null;
+        }
+        const roh = liesCookie(request, cookieName);
+        if (!roh)
+            return null;
+        try {
+            const daten = JSON.parse(roh);
+            return { ...daten, accessTokenExpiresAt: new Date(daten.accessTokenExpiresAt) };
+        }
+        catch {
+            return null;
+        }
+    }
+    async function legeSitzungAb(antwort, sitzung, sicher) {
+        if (options.speicher) {
+            const id = crypto.randomUUID();
+            await options.speicher.schreib(id, sitzung);
+            setzeCookie(antwort, cookieName + "_id", id, { maxAge: 2592000, sicher });
+            return;
+        }
+        setzeCookie(antwort, cookieName, JSON.stringify(sitzung), {
+            maxAge: 2592000,
+            sicher,
+        });
+    }
+    /** Die Sitzung aus einer eigenen Route heraus lesen. */
+    async function sitzungAus(request) {
+        return holeSitzung(request);
+    }
+    return { GET, POST: GET, auth, sitzungAus };
+}
+// ---------------------------------------------------------------------------
+function ableitenBasePath(redirectUri) {
+    const pfad = new URL(redirectUri).pathname;
+    // .../api/auth/callback → .../api/auth
+    return pfad.replace(/\/callback\/?$/, "");
+}
+function istHttps(url) {
+    return url.protocol === "https:";
+}
+function weiter(ziel) {
+    return new Response(null, { status: 302, headers: { location: ziel } });
+}
+function json(daten, status = 200) {
+    return new Response(JSON.stringify(daten), {
+        status,
+        headers: { "content-type": "application/json" },
+    });
+}
+function fehlerSeite(text) {
+    return json({ error: "anmeldung_fehlgeschlagen", message: text }, 400);
+}
+function setzeCookie(antwort, name, wert, options) {
+    const teile = [
+        `${name}=${encodeURIComponent(wert)}`,
+        "Path=/",
+        "HttpOnly",
+        "SameSite=Lax",
+        `Max-Age=${options.maxAge}`,
+    ];
+    // Ohne HTTPS kein Secure — sonst käme das Cookie in der Entwicklung unter
+    // http://localhost gar nicht erst an, und niemand fände den Grund.
+    if (options.sicher)
+        teile.push("Secure");
+    antwort.headers.append("set-cookie", teile.join("; "));
+}
+function loescheCookie(antwort, name, sicher) {
+    setzeCookie(antwort, name, "", { maxAge: 0, sicher });
+}
+function liesCookie(request, name) {
+    const kopf = request.headers.get("cookie");
+    if (!kopf)
+        return null;
+    for (const teil of kopf.split(";")) {
+        const trenn = teil.indexOf("=");
+        if (trenn < 0)
+            continue;
+        if (teil.slice(0, trenn).trim() === name) {
+            return decodeURIComponent(teil.slice(trenn + 1));
+        }
+    }
+    return null;
+}

package/dist/pkce.d.ts

@@ -0,0 +1,48 @@
+/**
+ * PKCE — der Nachweis, dass der, der den Code einlöst, auch der ist, der ihn
+ * angefordert hat.
+ *
+ * Der Code kommt über einen Umleitungs-URL zurück und steht damit im Verlauf
+ * des Browsers, im Log jedes Proxys dazwischen und im Referer der nächsten
+ * Seite. Wer ihn dort aufliest, kann ihn ohne PKCE einlösen. Mit PKCE braucht
+ * er zusätzlich den Verifier, und der hat den Browser nie verlassen.
+ *
+ * Alles hier läuft über die eingebaute Web-Crypto — kein Paket, keine
+ * Abhängigkeit. Verfügbar in Node ab 18, in jedem Browser und am Rand.
+ */
+/**
+ * Base64 ohne die drei Zeichen, die in einem URL etwas anderes bedeuten.
+ *
+ * `+` wird in einer Formularkodierung zum Leerzeichen, `/` trennt Pfade, und
+ * `=` trennt Parameter von Werten. Ein Verifier mit diesen Zeichen kommt am
+ * anderen Ende verändert an und passt dann nicht mehr zu seinem Challenge —
+ * ein Fehler, der sich als „invalid_grant" zeigt und nach allem aussieht
+ * außer nach seiner Ursache.
+ */
+export declare function base64url(daten: ArrayBuffer | Uint8Array): string;
+/**
+ * Ein Verifier: 32 Byte Zufall, base64url — 43 Zeichen.
+ *
+ * Das ist die Untergrenze aus RFC 7636 und zugleich genug: 256 Bit Zufall
+ * lassen sich nicht raten. Die Obergrenze von 128 Zeichen brächte nichts
+ * dazu.
+ */
+export declare function createVerifier(): string;
+/** Was davon in den Anmelde-URL geht: der Hash, nie der Verifier selbst. */
+export declare function createChallenge(verifier: string): Promise<string>;
+/**
+ * Der Wert gegen fremde Anfragen (CSRF).
+ *
+ * Ohne ihn könnte jemand einen Anmeldevorgang mit *seinem* Konto beginnen und
+ * dem Opfer den Rückkehr-URL unterschieben; das Opfer wäre danach im fremden
+ * Konto angemeldet und legte dort Daten ab.
+ */
+export declare function createState(): string;
+/**
+ * Zwei Zeichenketten vergleichen, ohne über die Dauer zu verraten, ab welcher
+ * Stelle sie sich unterscheiden.
+ *
+ * Für den State ist das strenggenommen mehr, als nötig wäre — aber die
+ * Funktion steht auch für den, der sie auf etwas Empfindlicheres anwendet.
+ */
+export declare function gleich(a: string, b: string): boolean;

package/dist/pkce.js

@@ -0,0 +1,75 @@
+/**
+ * PKCE — der Nachweis, dass der, der den Code einlöst, auch der ist, der ihn
+ * angefordert hat.
+ *
+ * Der Code kommt über einen Umleitungs-URL zurück und steht damit im Verlauf
+ * des Browsers, im Log jedes Proxys dazwischen und im Referer der nächsten
+ * Seite. Wer ihn dort aufliest, kann ihn ohne PKCE einlösen. Mit PKCE braucht
+ * er zusätzlich den Verifier, und der hat den Browser nie verlassen.
+ *
+ * Alles hier läuft über die eingebaute Web-Crypto — kein Paket, keine
+ * Abhängigkeit. Verfügbar in Node ab 18, in jedem Browser und am Rand.
+ */
+/** Der Zufall, aus dem alles Weitere folgt. */
+function zufall(bytes) {
+    const puffer = new Uint8Array(bytes);
+    crypto.getRandomValues(puffer);
+    return puffer;
+}
+/**
+ * Base64 ohne die drei Zeichen, die in einem URL etwas anderes bedeuten.
+ *
+ * `+` wird in einer Formularkodierung zum Leerzeichen, `/` trennt Pfade, und
+ * `=` trennt Parameter von Werten. Ein Verifier mit diesen Zeichen kommt am
+ * anderen Ende verändert an und passt dann nicht mehr zu seinem Challenge —
+ * ein Fehler, der sich als „invalid_grant" zeigt und nach allem aussieht
+ * außer nach seiner Ursache.
+ */
+export function base64url(daten) {
+    const bytes = daten instanceof Uint8Array ? daten : new Uint8Array(daten);
+    let roh = "";
+    for (const byte of bytes)
+        roh += String.fromCharCode(byte);
+    return btoa(roh).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+/**
+ * Ein Verifier: 32 Byte Zufall, base64url — 43 Zeichen.
+ *
+ * Das ist die Untergrenze aus RFC 7636 und zugleich genug: 256 Bit Zufall
+ * lassen sich nicht raten. Die Obergrenze von 128 Zeichen brächte nichts
+ * dazu.
+ */
+export function createVerifier() {
+    return base64url(zufall(32));
+}
+/** Was davon in den Anmelde-URL geht: der Hash, nie der Verifier selbst. */
+export async function createChallenge(verifier) {
+    const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier));
+    return base64url(digest);
+}
+/**
+ * Der Wert gegen fremde Anfragen (CSRF).
+ *
+ * Ohne ihn könnte jemand einen Anmeldevorgang mit *seinem* Konto beginnen und
+ * dem Opfer den Rückkehr-URL unterschieben; das Opfer wäre danach im fremden
+ * Konto angemeldet und legte dort Daten ab.
+ */
+export function createState() {
+    return base64url(zufall(16));
+}
+/**
+ * Zwei Zeichenketten vergleichen, ohne über die Dauer zu verraten, ab welcher
+ * Stelle sie sich unterscheiden.
+ *
+ * Für den State ist das strenggenommen mehr, als nötig wäre — aber die
+ * Funktion steht auch für den, der sie auf etwas Empfindlicheres anwendet.
+ */
+export function gleich(a, b) {
+    if (a.length !== b.length)
+        return false;
+    let unterschied = 0;
+    for (let i = 0; i < a.length; i += 1) {
+        unterschied |= a.charCodeAt(i) ^ b.charCodeAt(i);
+    }
+    return unterschied === 0;
+}

package/dist/types.d.ts

@@ -0,0 +1,91 @@
+/** Wie eine Anwendung sich gegenüber Aplons ausweist. */
+export type AplonsOptions = {
+    /**
+     * Wo Aplons steht, ohne Pfad — etwa `https://auth.aplons.com`.
+     * Alles Weitere holt das Paket von dort selbst (`/.well-known/…`).
+     */
+    issuer: string;
+    clientId: string;
+    /**
+     * Nur für Anwendungen, die ein Geheimnis behalten können — also einen
+     * Server haben. Eine Anwendung, die im Browser oder auf einem Telefon
+     * läuft, lässt es weg: was dort mitgeliefert wird, ist nicht geheim, und
+     * ein „Geheimnis", das jeder auslesen kann, macht die Sache nicht sicherer,
+     * sondern nur unübersichtlich.
+     */
+    clientSecret?: string;
+    /** Wohin Aplons nach der Anmeldung zurückschickt. Muss hinterlegt sein. */
+    redirectUri: string;
+    /** Voreinstellung: openid, profile, email. */
+    scope?: string[];
+    /** Eigene fetch-Implementierung, etwa zum Testen. */
+    fetch?: typeof globalThis.fetch;
+};
+/** Was nach der Anmeldung vorliegt. */
+export type Sitzung = {
+    accessToken: string;
+    refreshToken?: string;
+    /** Zeitpunkt, nicht Dauer: eine Dauer ist ab dem Moment falsch, in dem
+     *  man sie ablegt. */
+    accessTokenExpiresAt: Date;
+    idToken?: string;
+    scope: string[];
+    /** Die geprüften Angaben aus dem ID-Token. */
+    claims?: IdTokenClaims;
+};
+export type IdTokenClaims = {
+    sub: string;
+    iss: string;
+    aud: string | string[];
+    exp: number;
+    iat: number;
+    email?: string;
+    email_verified?: boolean;
+    name?: string;
+    given_name?: string;
+    family_name?: string;
+    /** Der Mandant, zu dem das Konto gehört. */
+    tid?: string;
+    [weitere: string]: unknown;
+};
+export type AccessTokenClaims = {
+    sub: string;
+    iss: string;
+    exp: number;
+    iat: number;
+    /** Der Mandant. */
+    tid?: string;
+    /** Rollen im Mandanten. */
+    rls?: string[];
+    /** Einzelne Berechtigungen. */
+    prm?: string[];
+    /** Die Sitzung, aus der das Token stammt. */
+    sid?: string;
+    email?: string;
+    scope?: string;
+    [weitere: string]: unknown;
+};
+/** Was UserInfo zurückgibt — je nach Bereich mehr oder weniger. */
+export type Profil = {
+    sub: string;
+    email?: string;
+    email_verified?: boolean;
+    name?: string;
+    given_name?: string;
+    family_name?: string;
+    phone_number?: string;
+    /** Rollen in *dieser* Anwendung, mit dem Bereich `roles`. */
+    roles?: string[];
+    /** Die eigenen Felder dieser Anwendung, mit dem Bereich `app_profile`. */
+    app_profile?: Record<string, unknown>;
+    [weitere: string]: unknown;
+};
+/** Das, was zwischen Start und Rückkehr aufbewahrt werden muss. */
+export type Anmeldevorgang = {
+    /** Dorthin schicken. */
+    url: string;
+    /** Beides kurzlebig ablegen — und beim Rückkehr-Aufruf wieder mitgeben. */
+    verifier: string;
+    state: string;
+    nonce: string;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};