keycloakify 10.0.4 → 10.1.0-rc.0

package/src/bin/shared/{downloadKeycloakDefaultTheme.ts → downloadKeycloakDefaultTheme/downloadKeycloakDefaultTheme.ts}

@@ -1,8 +1,10 @@
-import { join as pathJoin, relative as pathRelative } from "path";
-import { type BuildContext } from "./buildContext";
+import { join as pathJoin, relative as pathRelative, sep as pathSep } from "path";
+import { type BuildContext } from "../buildContext";
 import { assert } from "tsafe/assert";
-import { LAST_KEYCLOAK_VERSION_WITH_ACCOUNT_V1 } from "./constants";
-import { downloadAndExtractArchive } from "../tools/downloadAndExtractArchive";
+import { LAST_KEYCLOAK_VERSION_WITH_ACCOUNT_V1 } from "../constants";
+import { downloadAndExtractArchive } from "../../tools/downloadAndExtractArchive";
+import { getThisCodebaseRootDirPath } from "../../tools/getThisCodebaseRootDirPath";
+import * as fsPr from "fs/promises";
 
 export type BuildContextLike = {
     cacheDirPath: string;
@@ -20,6 +22,8 @@ export async function downloadKeycloakDefaultTheme(params: {
     let kcNodeModulesKeepFilePaths: Set<string> | undefined = undefined;
     let kcNodeModulesKeepFilePaths_lastAccountV1: Set<string> | undefined = undefined;
 
+    let areExtraAssetsFor24Copied = false;
+
     const { extractedDirPath } = await downloadAndExtractArchive({
         url: `https://repo1.maven.org/maven2/org/keycloak/keycloak-themes/${keycloakVersion}/keycloak-themes-${keycloakVersion}.jar`,
         cacheDirPath: buildContext.cacheDirPath,
@@ -32,8 +36,6 @@ export async function downloadKeycloakDefaultTheme(params: {
                 return;
             }
 
-            const { readFile, writeFile } = params;
-
             skip_keycloak_v2: {
                 if (!fileRelativePath.startsWith(pathJoin("keycloak.v2"))) {
                     break skip_keycloak_v2;
@@ -42,6 +44,8 @@ export async function downloadKeycloakDefaultTheme(params: {
                 return;
             }
 
+            const { readFile, writeFile } = params;
+
             last_account_v1_transformations: {
                 if (LAST_KEYCLOAK_VERSION_WITH_ACCOUNT_V1 !== keycloakVersion) {
                     break last_account_v1_transformations;
@@ -168,6 +172,42 @@ export async function downloadKeycloakDefaultTheme(params: {
                 }
             }
 
+            copy_extra_assets: {
+                if (keycloakVersion !== "24.0.4") {
+                    break copy_extra_assets;
+                }
+
+                if (areExtraAssetsFor24Copied) {
+                    break copy_extra_assets;
+                }
+
+                const extraAssetsDirPath = pathJoin(
+                    getThisCodebaseRootDirPath(),
+                    "src",
+                    "bin",
+                    __dirname.split(`${pathSep}bin${pathSep}`)[1],
+                    "extra-assets"
+                );
+
+                await Promise.all(
+                    ["webauthnAuthenticate.js", "passkeysConditionalAuth.js"].map(
+                        async fileBasename =>
+                            writeFile({
+                                fileRelativePath: pathJoin(
+                                    "base",
+                                    "login",
+                                    "resources",
+                                    "js",
+                                    fileBasename
+                                ),
+                                modifiedData: await fsPr.readFile(
+                                    pathJoin(extraAssetsDirPath, fileBasename)
+                                )
+                            })
+                    )
+                );
+            }
+
             skip_unused_resources: {
                 if (keycloakVersion !== "24.0.4") {
                     break skip_unused_resources;

package/src/bin/shared/downloadKeycloakDefaultTheme/extra-assets/passkeysConditionalAuth.js

@@ -0,0 +1,79 @@
+import { base64url } from "rfc4648";
+import { returnSuccess, returnFailure } from "./webauthnAuthenticate.js";
+
+export function initAuthenticate(input) {
+    // Check if WebAuthn is supported by this browser
+    if (!window.PublicKeyCredential) {
+        returnFailure(input.errmsg);
+        return;
+    }
+    if (input.isUserIdentified || typeof PublicKeyCredential.isConditionalMediationAvailable === "undefined") {
+        document.getElementById("kc-form-passkey-button").style.display = 'block';
+    } else {
+        tryAutoFillUI(input);
+    }
+}
+
+function doAuthenticate(input) {
+    // Check if WebAuthn is supported by this browser
+    if (!window.PublicKeyCredential) {
+        returnFailure(input.errmsg);
+        return;
+    }
+
+    const publicKey = {
+        rpId : input.rpId,
+        challenge: base64url.parse(input.challenge, { loose: true })
+    };
+
+    publicKey.allowCredentials = !input.isUserIdentified ? [] : getAllowCredentials();
+
+    if (input.createTimeout !== 0) {
+        publicKey.timeout = input.createTimeout * 1000;
+    }
+
+    if (input.userVerification !== 'not specified') {
+        publicKey.userVerification = input.userVerification;
+    }
+
+    return navigator.credentials.get({
+        publicKey: publicKey,
+        ...input.additionalOptions
+    });
+}
+
+async function tryAutoFillUI(input) {
+    const isConditionalMediationAvailable = await PublicKeyCredential.isConditionalMediationAvailable();
+    if (isConditionalMediationAvailable) {
+        document.getElementById("kc-form-login").style.display = "block";
+        input.additionalOptions = { mediation: 'conditional'};
+        try {
+            const result = await doAuthenticate(input);
+            returnSuccess(result);
+        } catch (error) {
+            returnFailure(error);
+        }
+    } else {
+        document.getElementById("kc-form-passkey-button").style.display = 'block';
+    }
+}
+
+function getAllowCredentials() {
+    const allowCredentials = [];
+    const authnUse = document.forms['authn_select'].authn_use_chk;
+    if (authnUse !== undefined) {
+        if (authnUse.length === undefined) {
+            allowCredentials.push({
+                id: base64url.parse(authnUse.value, {loose: true}),
+                type: 'public-key',
+            });
+        } else {
+            authnUse.forEach((entry) =>
+                allowCredentials.push({
+                    id: base64url.parse(entry.value, {loose: true}),
+                    type: 'public-key',
+                }));
+        }
+    }
+    return allowCredentials;
+}

package/src/bin/shared/downloadKeycloakDefaultTheme/extra-assets/webauthnAuthenticate.js

@@ -0,0 +1,82 @@
+import { base64url } from "rfc4648";
+
+export async function authenticateByWebAuthn(input) {
+    if (!input.isUserIdentified) {
+        try {
+            const result = await doAuthenticate([], input.challenge, input.userVerification, input.rpId, input.createTimeout, input.errmsg);
+            returnSuccess(result);
+        } catch (error) {
+            returnFailure(error);
+        }
+        return;
+    }
+    checkAllowCredentials(input.challenge, input.userVerification, input.rpId, input.createTimeout, input.errmsg);
+}
+
+async function checkAllowCredentials(challenge, userVerification, rpId, createTimeout, errmsg) {
+    const allowCredentials = [];
+    const authnUse = document.forms['authn_select'].authn_use_chk;
+    if (authnUse !== undefined) {
+        if (authnUse.length === undefined) {
+            allowCredentials.push({
+                id: base64url.parse(authnUse.value, {loose: true}),
+                type: 'public-key',
+            });
+        } else {
+            authnUse.forEach((entry) =>
+                allowCredentials.push({
+                    id: base64url.parse(entry.value, {loose: true}),
+                    type: 'public-key',
+                }));
+        }
+    }
+    try {
+        const result = await doAuthenticate(allowCredentials, challenge, userVerification, rpId, createTimeout, errmsg);
+        returnSuccess(result);
+    } catch (error) {
+        returnFailure(error);
+    }
+}
+
+function doAuthenticate(allowCredentials, challenge, userVerification, rpId, createTimeout, errmsg) {
+    // Check if WebAuthn is supported by this browser
+    if (!window.PublicKeyCredential) {
+        returnFailure(errmsg);
+        return;
+    }
+
+    const publicKey = {
+        rpId : rpId,
+        challenge: base64url.parse(challenge, { loose: true })
+    };
+
+    if (createTimeout !== 0) {
+        publicKey.timeout = createTimeout * 1000;
+    }
+
+    if (allowCredentials.length) {
+        publicKey.allowCredentials = allowCredentials;
+    }
+
+    if (userVerification !== 'not specified') {
+        publicKey.userVerification = userVerification;
+    }
+
+    return navigator.credentials.get({publicKey});
+}
+
+export function returnSuccess(result) {
+    document.getElementById("clientDataJSON").value = base64url.stringify(new Uint8Array(result.response.clientDataJSON), { pad: false });
+    document.getElementById("authenticatorData").value = base64url.stringify(new Uint8Array(result.response.authenticatorData), { pad: false });
+    document.getElementById("signature").value = base64url.stringify(new Uint8Array(result.response.signature), { pad: false });
+    document.getElementById("credentialId").value = result.id;
+    if (result.response.userHandle) {
+        document.getElementById("userHandle").value = base64url.stringify(new Uint8Array(result.response.userHandle), { pad: false });
+    }
+    document.getElementById("webauth").submit();
+}
+
+export function returnFailure(err) {
+    document.getElementById("error").value = err;
+    document.getElementById("webauth").submit();
+}

package/src/bin/shared/downloadKeycloakDefaultTheme/index.ts

@@ -0,0 +1 @@
+export * from "./downloadKeycloakDefaultTheme";

package/src/login/DefaultPage.tsx

@@ -40,6 +40,8 @@ const LoginRecoveryAuthnCodeInput = lazy(() => import("keycloakify/login/pages/L
 const LoginResetOtp = lazy(() => import("keycloakify/login/pages/LoginResetOtp"));
 const LoginX509Info = lazy(() => import("keycloakify/login/pages/LoginX509Info"));
 const WebauthnError = lazy(() => import("keycloakify/login/pages/WebauthnError"));
+const LoginPasskeysConditionalAuthenticate = lazy(() => import("keycloakify/login/pages/LoginPasskeysConditionalAuthenticate"));
+const LoginIdpLinkConfirmOverride = lazy(() => import("keycloakify/login/pages/LoginIdpLinkConfirmOverride"));
 
 type DefaultPageProps = PageProps<KcContext, I18n> & {
     UserProfileFormFields: LazyOrNot<(props: UserProfileFormFieldsProps) => JSX.Element>;
@@ -121,6 +123,10 @@ export default function DefaultPage(props: DefaultPageProps) {
                         return <LoginX509Info kcContext={kcContext} {...rest} />;
                     case "webauthn-error.ftl":
                         return <WebauthnError kcContext={kcContext} {...rest} />;
+                    case "login-passkeys-conditional-authenticate.ftl":
+                        return <LoginPasskeysConditionalAuthenticate kcContext={kcContext} {...rest} />;
+                    case "login-idp-link-confirm-override.ftl":
+                        return <LoginIdpLinkConfirmOverride kcContext={kcContext} {...rest} />;
                 }
                 assert<Equals<typeof kcContext, never>>(false);
             })()}

package/src/login/KcContext/KcContext.ts

@@ -59,7 +59,9 @@ export type KcContext =
     | KcContext.LoginRecoveryAuthnCodeInput
     | KcContext.LoginResetOtp
     | KcContext.LoginX509Info
-    | KcContext.WebauthnError;
+    | KcContext.WebauthnError
+    | KcContext.LoginPasskeysConditionalAuthenticate
+    | KcContext.LoginIdpLinkConfirmOverride;
 
 assert<KcContext["themeType"] extends ThemeType ? true : false>();
 
@@ -577,6 +579,40 @@ export declare namespace KcContext {
         pageId: "webauthn-error.ftl";
         isAppInitiatedAction?: boolean;
     };
+
+    export type LoginPasskeysConditionalAuthenticate = Common & {
+        pageId: "login-passkeys-conditional-authenticate.ftl";
+        realm: {
+            registrationAllowed: boolean;
+            password: boolean;
+        };
+        url: {
+            registrationUrl: string;
+        };
+        registrationDisabled: boolean;
+        isUserIdentified: boolean | "true" | "false";
+        challenge: string;
+        userVerification: string;
+        rpId: string;
+        createTimeout: number | string;
+
+        authenticators?: {
+            authenticators: WebauthnAuthenticate.WebauthnAuthenticator[];
+        };
+        shouldDisplayAuthenticators?: boolean;
+        usernameHidden?: boolean;
+        login: {
+            username?: string;
+        };
+    };
+
+    export type LoginIdpLinkConfirmOverride = Common & {
+        pageId: "login-idp-link-confirm-override.ftl";
+        url: {
+            loginRestartFlowUrl: string;
+        };
+        idpDisplayName: string;
+    };
 }
 
 export type UserProfile = {

package/src/login/KcContext/kcContextMocks.ts

@@ -567,6 +567,39 @@ export const kcContextMocks = [
         pageId: "webauthn-error.ftl",
         ...kcContextCommonMock,
         isAppInitiatedAction: true
+    }),
+    id<KcContext.LoginPasskeysConditionalAuthenticate>({
+        pageId: "login-passkeys-conditional-authenticate.ftl",
+        ...kcContextCommonMock,
+        url: {
+            ...kcContextCommonMock.url,
+            registrationUrl: "#"
+        },
+        realm: {
+            ...kcContextCommonMock.realm,
+            password: true,
+            registrationAllowed: true
+        },
+        registrationDisabled: false,
+        isUserIdentified: "false",
+        challenge: "",
+        userVerification: "not specified",
+        rpId: "",
+        createTimeout: "0",
+        authenticators: {
+            authenticators: []
+        },
+        shouldDisplayAuthenticators: false,
+        login: {}
+    }),
+    id<KcContext.LoginIdpLinkConfirmOverride>({
+        pageId: "login-idp-link-confirm-override.ftl",
+        ...kcContextCommonMock,
+        url: {
+            ...kcContextCommonMock.url,
+            loginRestartFlowUrl: "#"
+        },
+        idpDisplayName: "Google"
     })
 ];
 

package/src/login/i18n/messages_defaultSet/ca.ts

@@ -325,29 +325,6 @@ const messages= {
   "confirmAccountLinking": "Confirmeu l'enllaçat del compte {0} del proveïdor d'identitat {1} amb el vostre compte.",
   "confirmEmailAddressVerification": "Confirmeu la validesa de l'adreça de correu electrònic {0}.",
   "confirmExecutionOfActions": "Completeu les accions següents",
-  "locale_ar": "àrab",
-  "locale_ca": "català",
-  "locale_cs": "txec",
-  "locale_da": "danès",
-  "locale_de": "alemany",
-  "locale_en": "anglès",
-  "locale_es": "castellà",
-  "locale_fi": "finès",
-  "locale_fr": "francès",
-  "locale_hu": "hongarès",
-  "locale_it": "italià",
-  "locale_ja": "japonès",
-  "locale_lt": "lituà",
-  "locale_lv": "letó",
-  "locale_nl": "neerlandès",
-  "locale_no": "noruec",
-  "locale_pl": "polonès",
-  "locale_pt-BR": "portuguès (Brasil)",
-  "locale_ru": "rus",
-  "locale_sk": "eslovè",
-  "locale_sv": "suec",
-  "locale_tr": "turc",
-  "locale_zh-CN": "xinès simplificat",
   "backToApplication": "« Torna a l'aplicació",
   "missingParameterMessage": "Manquen paràmetres\\: {0}",
   "clientNotFoundMessage": "No s'ha trobat el client.",

package/src/login/i18n/messages_defaultSet/cs.ts

@@ -396,23 +396,23 @@ const messages= {
   "recovery-codes-download-file-description": "Kódy pro obnovu jsou hesla pro jednorázové použití, pomocí kterých se můžete přihlásit bez přístupu k autentikátoru.",
   "recovery-codes-download-file-date": "Tyto kódy byly generovány",
   "recovery-codes-label-default": "Kódy pro obnovu",
-  "webauthn-display-name": "Bezpečnostní klíč",
-  "webauthn-help-text": "Použijte k přihlášení bezpečnostní klíč.",
-  "webauthn-passwordless-display-name": "Bezpečnostní klíč",
-  "webauthn-passwordless-help-text": "Použijte bezpečnostní klíč k přihlášení bez hesla.",
-  "webauthn-login-title": "Přihlášení bezpečnostním klíčem",
-  "webauthn-registration-title": "Registrace bezpečnostního klíče",
-  "webauthn-available-authenticators": "Dostupné bezpečnostní klíče",
+  "webauthn-display-name": "Přístupový klíč",
+  "webauthn-help-text": "Použijte k přihlášení přístupový klíč.",
+  "webauthn-passwordless-display-name": "Přístupový klíč",
+  "webauthn-passwordless-help-text": "Použijte přístupový klíč k přihlášení bez hesla.",
+  "webauthn-login-title": "Přihlášení přístupovým klíčem",
+  "webauthn-registration-title": "Registrace přístupového klíče",
+  "webauthn-available-authenticators": "Dostupné přístupové klíče",
   "webauthn-unsupported-browser-text": "WebAuthn není v tomto prohlížeči podporováno. Zkuste jiný prohlížeč nebo kontaktujte svého administrátora.",
-  "webauthn-doAuthenticate": "Přihlášení bezpečnostním klíčem",
+  "webauthn-doAuthenticate": "Přihlášení přístupovým klíčem",
   "webauthn-createdAt-label": "Vytvořeno",
-  "webauthn-error-title": "Chyba bezpečnostního klíče",
-  "webauthn-error-registration": "Selhala registrace vašeho bezpečnostního klíče.<br/> {0}",
-  "webauthn-error-api-get": "Selhalo přihlášení pomocí bezpečnostního klíče.<br/> {0}",
-  "webauthn-error-different-user": "První přihlášený uživatel není totožný s uživatelem přihlášeným pomocí bezpečnostního klíče.",
-  "webauthn-error-auth-verification": "Nevalidní výsledek přihlášení pomocí bezpečnostního klíče.<br/> {0}",
-  "webauthn-error-register-verification": "Nevalidní výsledek registrace bezpečnostního klíče.<br/> {0}",
-  "webauthn-error-user-not-found": "Neznámý uživatel přihlášen pomocí bezpečnostního klíče.",
+  "webauthn-error-title": "Chyba přístupového klíče",
+  "webauthn-error-registration": "Selhala registrace vašeho přístupového klíče.<br/> {0}",
+  "webauthn-error-api-get": "Selhalo přihlášení pomocí přístupového klíče.<br/> {0}",
+  "webauthn-error-different-user": "První přihlášený uživatel není totožný s uživatelem přihlášeným pomocí přístupového klíče.",
+  "webauthn-error-auth-verification": "Nevalidní výsledek přihlášení pomocí přístupového klíče.<br/> {0}",
+  "webauthn-error-register-verification": "Nevalidní výsledek registrace přístupového klíče.<br/> {0}",
+  "webauthn-error-user-not-found": "Neznámý uživatel přihlášen pomocí přístupového klíče.",
   "identity-provider-redirector": "Propojit s jiným poskytovatelem identit",
   "identity-provider-login-label": "Nebo se přihlaste pomocí",
   "idp-email-verification-display-name": "Ověření e-mailu",
@@ -435,6 +435,7 @@ const messages= {
   "logoutConfirmHeader": "Chcete se odhlásit?",
   "doLogout": "Odhlásit",
   "readOnlyUsernameMessage": "Nemůžete aktualizovat své uživatelské jméno, protože je pouze pro čtení.",
+  "error-invalid-multivalued-size": "Atribut {0} musí mít nejméně {1} {1,choice,0#hodnot|1#hodnotu|1<hodnoty|4<hodnot} a nejvíce {2} {2,choice,0#hodnot|1#hodnotu|1<hodnoty|4<hodnot}.",
   "shouldBeEqual": "{0} by měl být roven {1}",
   "shouldBeDifferent": "{0} by měl být odlišný od {1}",
   "shouldMatchPattern": "Vzor by měl odpovídat: `/{0}/`",

package/src/login/i18n/messages_defaultSet/da.ts

@@ -281,8 +281,6 @@ const messages= {
   "invalidPasswordMessage": "Ugyldig adangskode.",
   "missingTotpDeviceNameMessage": "Angiv venligst et udstyrsnavn.",
   "nestedFirstBrokerFlowMessage": "{0} brugeren {1} er ikke forbundet til nogen kendt bruger.",
-  "locale_cs": "Čeština",
-  "locale_pl": "Polish",
   "openshift.scope.user_info": "Brugerinformation",
   "openshift.scope.user_check-access": "Brugeradgangsinformation",
   "openshift.scope.user_full": "Fuld adgang",