Skip to content

A platform for community discussion. Free, open, simple.

DEV: Split passkey and security key WebAuthn ceremonies for 2FA (#40817)

Rafael dos Santos Silva0c90e25e4712
diff --git a/app/controllers/session_controller.rb b/app/controllers/session_controller.rb
index 4544e35e98a..d20d56a9551 100644
--- a/app/controllers/session_controller.rb
+++ b/app/controllers/session_controller.rb
@@ -538,7 +538,7 @@ class SessionController < ApplicationController
backup_enabled: user.backup_codes_enabled?,
allowed_methods: challenge[:allowed_methods],
)
- passkeys_for_2fa = user.passkeys_for_2fa_enabled?
+ passkeys_for_2fa = user.passkeys_available_as_second_factor?
if user.security_keys_enabled? || passkeys_for_2fa
DiscourseWebauthn.stage_challenge(user, server_session)
json.merge!(
diff --git a/app/models/concerns/second_factor_manager.rb b/app/models/concerns/second_factor_manager.rb
index cf3d78649a7..7edd962584b 100644
--- a/app/models/concerns/second_factor_manager.rb
+++ b/app/models/concerns/second_factor_manager.rb
@@ -78,16 +78,20 @@ module SecondFactorManager
)&.exists?
end
- def passkeys_for_2fa_enabled?
+ def passkeys_available_as_second_factor?
SiteSetting.allow_passkeys_for_2fa && SiteSetting.enable_passkeys &&
!SiteSetting.enable_discourse_connect && SiteSetting.enable_local_logins &&
- security_keys&.where(factor_type: UserSecurityKey.factor_types[:first_factor])&.exists?
+ security_keys&.where(
+ factor_type: UserSecurityKey.factor_types[:first_factor],
+ enabled: true,
+ )&.exists?
end
+ alias_method :passkeys_for_2fa_enabled?, :passkeys_available_as_second_factor?
- # Passkey-as-2FA (`passkeys_for_2fa_enabled?`) is intentionally excluded:
- # it only satisfies `/session/2fa`. Password login, email login, and password
- # reset have no passkey UI yet, so counting passkeys here would make those
- # flows skip 2FA for passkey-only users.
+ # Passkey-as-2FA (`passkeys_available_as_second_factor?`) is intentionally
+ # excluded: it only satisfies `/session/2fa`. Password login, email login,
+ # and password reset have no passkey UI yet, so counting passkeys here would
+ # make those flows skip 2FA for passkey-only users.
def has_any_second_factor_methods_enabled?
totp_enabled? || security_keys_enabled?
end
@@ -115,7 +119,7 @@ module SecondFactorManager
def authenticate_second_factor(params, server_session)
ok_result = SecondFactorAuthenticationResult.new(true)
if !security_keys_enabled? && !totp_or_backup_codes_enabled? &&
- (!passkeys_for_2fa_enabled? || params[:second_factor_method].blank?)
+ (!passkeys_available_as_second_factor? || params[:second_factor_method].blank?)
return ok_result
end
@@ -152,6 +156,13 @@ module SecondFactorManager
else
return invalid_security_key_result
end
+ when UserSecondFactor.methods[:passkey]
+ if authenticate_passkey(server_session, second_factor_token)
+ ok_result.used_2fa_method = UserSecondFactor.methods[:passkey]
+ return ok_result
+ else
+ return invalid_security_key_result
+ end
end
# if we have gotten down to this point without being
@@ -168,20 +179,28 @@ module SecondFactorManager
when UserSecondFactor.methods[:backup_codes]
return backup_codes_enabled?
when UserSecondFactor.methods[:security_key]
- return security_keys_enabled? || passkeys_for_2fa_enabled?
+ return security_keys_enabled?
+ when UserSecondFactor.methods[:passkey]
+ return passkeys_available_as_second_factor?
end
false
end
def authenticate_security_key(server_session, security_key_credential)
- factor_types = [UserSecurityKey.factor_types[:second_factor]]
- factor_types << UserSecurityKey.factor_types[:first_factor] if passkeys_for_2fa_enabled?
+ ::DiscourseWebauthn::AuthenticationService.new(
+ self,
+ security_key_credential,
+ session: server_session,
+ factor_type: [UserSecurityKey.factor_types[:second_factor]],
+ ).authenticate_security_key
+ end
+ def authenticate_passkey(server_session, security_key_credential)
::DiscourseWebauthn::AuthenticationService.new(
self,
security_key_credential,
session: server_session,
- factor_type: factor_types,
+ factor_type: [UserSecurityKey.factor_types[:first_factor]],
).authenticate_security_key
end
diff --git a/app/models/user_second_factor.rb b/app/models/user_second_factor.rb
index 854b0e143f3..cb1f598c44f 100644
--- a/app/models/user_second_factor.rb
+++ b/app/models/user_second_factor.rb
@@ -18,8 +18,12 @@ class UserSecondFactor < ActiveRecord::Base
validate :count_per_user_does_not_exceed_limit, on: :create
+ # `passkey` is a virtual method: passkeys live in `user_security_keys`
+ # (factor_type first_factor), never in this table. The enum value exists so
+ # the `second_factor_method` wire param can distinguish the passkey WebAuthn
+ # ceremony (user verification required) from the security key one.
def self.methods
- @methods ||= Enum.new(totp: 1, backup_codes: 2, security_key: 3)
+ @methods ||= Enum.new(totp: 1, backup_codes: 2, security_key: 3, passkey: 4)
end
def totp_object
diff --git a/config/locales/client.en.yml b/config/locales/client.en.yml
index 1682ac5a0cc..58ca03c3e19 100644
--- a/config/locales/client.en.yml
+++ b/config/locales/client.en.yml
@@ -2933,10 +2933,11 @@ en:
second_factor_backup_description: "Please enter one of your backup codes:"
second_factor: "Log in using Authenticator app"
security_key_description: "When you have your physical security key or compatible mobile device prepared press the Authenticate with Security Key button below."
- security_key_or_passkey_description: "When you have your security key, passkey, or compatible mobile device prepared press the button below."
security_key_alternative: "Try another way"
security_key_authenticate: "Authenticate with Security Key"
- security_key_or_passkey_authenticate: "Authenticate with security key or passkey"
+ passkey_2fa_description: "Verify your identity with your passkey."
+ use_passkey: "Use passkey"
+ use_security_key: "Use security key"
security_key_not_allowed_error: "The security key authentication process either timed out or was cancelled."
security_key_no_matching_credential_error: "No matching credentials could be found in the provided security key."
security_key_support_missing_error: "Your current device or browser does not support the use of security keys. Please use a different method."
@@ -3013,6 +3014,7 @@ en:
totp: "Use an authenticator app instead"
backup_code: "Use a backup code instead"
security_key: "Use a security key instead"
+ passkey: "Use a passkey instead"
no_login_methods:
title: "No login methods"
description: "No login methods are configured. Administrators can visit <a href='%{adminLoginPath}' target='_blank'>%{adminLoginPath}</a> to reconfigure the site."
diff --git a/frontend/discourse/app/components/second-factor-form.gjs b/frontend/discourse/app/components/second-factor-form.gjs
index 9aa92f8654f..706d60f7f83 100644
--- a/frontend/discourse/app/components/second-factor-form.gjs
+++ b/frontend/discourse/app/components/second-factor-form.gjs
@@ -16,6 +16,8 @@ export default class SecondFactorForm extends Component {
return i18n("login.second_factor_title");
case SECOND_FACTOR_METHODS.SECURITY_KEY:
return i18n("login.second_factor_title");
+ case SECOND_FACTOR_METHODS.PASSKEY:
+ return i18n("login.second_factor_title");
case SECOND_FACTOR_METHODS.BACKUP_CODE:
return i18n("login.second_factor_backup_title");
}
@@ -28,6 +30,8 @@ export default class SecondFactorForm extends Component {
return i18n("login.second_factor_description");
case SECOND_FACTOR_METHODS.SECURITY_KEY:
return i18n("login.security_key_description");
+ case SECOND_FACTOR_METHODS.PASSKEY:
+ return i18n("login.passkey_2fa_description");
case SECOND_FACTOR_METHODS.BACKUP_CODE:
return i18n("login.second_factor_backup_description");
}
diff --git a/frontend/discourse/app/components/security-key-form.gjs b/frontend/discourse/app/components/security-key-form.gjs
index 130c34f65ce..38af17a501c 100644
--- a/frontend/discourse/app/components/security-key-form.gjs
+++ b/frontend/discourse/app/components/security-key-form.gjs
@@ -6,6 +6,22 @@ import DButton from "discourse/ui-kit/d-button";
import { i18n } from "discourse-i18n";
export default class SecurityKeyForm extends Component {
+ get showSecurityKeyButton() {
+ // when the granular args aren't passed, keep the legacy single-button
+ // rendering driven by `@action`
+ return this.args.securityKeysEnabled ?? true;
+ }
+
+ get securityKeyAction() {
+ return this.args.securityKeyAction ?? this.args.action;
+ }
+
+ get securityKeyLabel() {
+ return this.args.passkeysEnabled
+ ? "login.use_security_key"
+ : "login.security_key_authenticate";
+ }
+
@action
useAnotherMethod(event) {
event.preventDefault();
@@ -21,13 +37,24 @@ export default class SecurityKeyForm extends Component {
<template>
<div id="security-key">
- <DButton
- @action={{@action}}
- @icon="key"
- @label="login.security_key_authenticate"
- id="security-key-authenticate-button"
- class="btn-large btn-primary"
- />
+ {{#if @passkeysEnabled}}
+ <DButton
+ @action={{@passkeyAction}}
+ @icon="user"
+ @label="login.use_passkey"
+ id="passkey-authenticate-button"
+ class="btn-large btn-primary"
+ />
+ {{/if}}
+ {{#if this.showSecurityKeyButton}}
+ <DButton
+ @action={{this.securityKeyAction}}
+ @icon="key"
+ @label={{this.securityKeyLabel}}
+ id="security-key-authenticate-button"
+ class="btn-large {{if @passkeysEnabled 'btn-default' 'btn-primary'}}"
+ />
+ {{/if}}
<p>
{{#if @otherMethodAllowed}}
<a
diff --git a/frontend/discourse/app/controllers/second-factor-auth.js b/frontend/discourse/app/controllers/second-factor-auth.js
index e29af39d466..3993b3dd5f6 100644
--- a/frontend/discourse/app/controllers/second-factor-auth.js
+++ b/frontend/discourse/app/controllers/second-factor-auth.js
@@ -7,12 +7,13 @@ import { getWebauthnCredential } from "discourse/lib/webauthn";
import { SECOND_FACTOR_METHODS } from "discourse/models/user";
import { i18n } from "discourse-i18n";
-const { TOTP, BACKUP_CODE, SECURITY_KEY } = SECOND_FACTOR_METHODS;
+const { TOTP, BACKUP_CODE, SECURITY_KEY, PASSKEY } = SECOND_FACTOR_METHODS;
export default class SecondFactorAuthController extends Controller {
TOTP = TOTP;
BACKUP_CODE = BACKUP_CODE;
SECURITY_KEY = SECURITY_KEY;
+ PASSKEY = PASSKEY;
queryParams = ["nonce"];
message = null;
loadError = false;
@@ -31,9 +32,9 @@ export default class SecondFactorAuthController extends Controller {
return this.model?.backup_enabled;
}
- @computed("model.security_keys_enabled", "model.passkeys_enabled")
+ @computed("model.security_keys_enabled")
get securityKeysEnabled() {
- return this.model?.security_keys_enabled || this.model?.passkeys_enabled;
+ return this.model?.security_keys_enabled;
}
@computed("model.passkeys_enabled")
@@ -41,13 +42,6 @@ export default class SecondFactorAuthController extends Controller {
return this.model?.passkeys_enabled;
}
- @computed("passkeysEnabled")
- get securityKeyAuthenticateLabel() {
- return this.passkeysEnabled
- ? "login.security_key_or_passkey_authenticate"
- : "login.security_key_authenticate";
- }
-
@computed("model.allowed_methods")
get allowedMethods() {
return this.model?.allowed_methods;
@@ -68,6 +62,11 @@ export default class SecondFactorAuthController extends Controller {
return this.shownSecondFactorMethod === SECURITY_KEY;
}
+ @computed("shownSecondFactorMethod")
+ get showPasskeyForm() {
+ return this.shownSecondFactorMethod === PASSKEY;
+ }
+
@computed("shownSecondFactorMethod")
get showBackupCodesForm() {
return this.shownSecondFactorMethod === BACKUP_CODE;
@@ -90,8 +89,14 @@ export default class SecondFactorAuthController extends Controller {
);
}
+ @computed("allowedMethods.[]", "passkeysEnabled")
+ get passkeysAvailable() {
+ return this.passkeysEnabled && this.allowedMethods.includes(PASSKEY);
+ }
+
@computed(
"userSelectedMethod",
+ "passkeysAvailable",
"securityKeysAvailable",
"totpAvailable",
"backupCodesAvailable"
@@ -100,7 +105,9 @@ export default class SecondFactorAuthController extends Controller {
if (this.userSelectedMethod !== null) {
return this.userSelectedMethod;
} else {
- if (this.securityKeysAvailable) {
+ if (this.passkeysAvailable) {
+ return PASSKEY;
+ } else if (this.securityKeysAvailable) {
return SECURITY_KEY;
} else if (this.totpAvailable) {
return TOTP;
@@ -114,12 +121,21 @@ export default class SecondFactorAuthController extends Controller {
@computed(
"shownSecondFactorMethod",
+ "passkeysAvailable",
"securityKeysAvailable",
"totpAvailable",
"backupCodesAvailable"
)
get alternativeMethods() {
const alts = [];
+ if (this.passkeysAvailable && this.shownSecondFactorMethod !== PASSKEY) {
+ alts.push({
+ id: PASSKEY,
+ translationKey: "login.second_factor_toggle.passkey",
+ class: "passkey",
+ });
+ }
+
if (
this.securityKeysAvailable &&
this.shownSecondFactorMethod !== SECURITY_KEY
@@ -160,20 +176,22 @@ export default class SecondFactorAuthController extends Controller {
return i18n("login.second_factor_title");
case SECURITY_KEY:
return i18n("login.second_factor_title");
+ case PASSKEY:
+ return i18n("login.second_factor_title");
case BACKUP_CODE:
return i18n("login.second_factor_backup_title");
}
}
- @computed("shownSecondFactorMethod", "passkeysEnabled")
+ @computed("shownSecondFactorMethod")
get secondFactorDescription() {
switch (this.shownSecondFactorMethod) {
case TOTP:
return i18n("login.second_factor_description");
case SECURITY_KEY:
- return this.passkeysEnabled
- ? i18n("login.security_key_or_passkey_description")
- : i18n("login.security_key_description");
+ return i18n("login.security_key_description");
+ case PASSKEY:
+ return i18n("login.passkey_2fa_description");
case BACKUP_CODE:
return i18n("login.second_factor_backup_description");
}
@@ -207,9 +225,9 @@ export default class SecondFactorAuthController extends Controller {
}
maybeAutoTriggerPasskey() {
- if (this.passkeysEnabled && !this.autoTriggeredPasskey) {
+ if (this.passkeysAvailable && !this.autoTriggeredPasskey) {
this.set("autoTriggeredPasskey", true);
- this.authenticateSecurityKey({ silent: true });
+ this.authenticatePasskey({ silent: true });
}
}
@@ -263,20 +281,35 @@ export default class SecondFactorAuthController extends Controller {
}
@action
- authenticateSecurityKey(options = {}) {
- const silent = options?.silent === true;
+ authenticateSecurityKey() {
getWebauthnCredential(
this.model.challenge,
this.model.allowed_credential_ids,
(credentialData) => {
this.verifySecondFactor({ second_factor_token: credentialData });
},
+ (errorMessage) => {
+ this.displayError(errorMessage);
+ },
+ { userVerification: "discouraged" }
+ );
+ }
+
+ @action
+ authenticatePasskey(options = {}) {
+ const silent = options?.silent === true;
+ getWebauthnCredential(
+ this.model.challenge,
+ this.model.passkey_allowed_credential_ids,
+ (credentialData) => {
+ this.verifySecondFactor({ second_factor_token: credentialData });
+ },
(errorMessage) => {
if (!silent) {
this.displayError(errorMessage);
}
},
- { userVerification: this.passkeysEnabled ? "preferred" : "discouraged" }
+ { userVerification: "required" }
);
}
diff --git a/frontend/discourse/app/lib/webauthn.js b/frontend/discourse/app/lib/webauthn.js
index e0d0e83a67b..6f8cb64de69 100644
--- a/frontend/discourse/app/lib/webauthn.js
+++ b/frontend/discourse/app/lib/webauthn.js
@@ -67,9 +67,9 @@ export function getWebauthnCredential(
challenge: challengeBuffer,
allowCredentials,
timeout: 60000, // this is just a hint
- // "discouraged" for plain 2FA (security keys), "preferred" when passkeys
- // may be present so the browser prompts for UV on passkey credentials
- // while still allowing non-UV security keys.
+ // "discouraged" for second-factor security keys, "required" for
+ // passkey ceremonies (matching the server-side validation for
+ // first-factor credentials).
userVerification,
},
signal: WebauthnAbortHandler.signal(),
diff --git a/frontend/discourse/app/models/user.js b/frontend/discourse/app/models/user.js
index 0fcc5f91c64..62d0f83f128 100644
--- a/frontend/discourse/app/models/user.js
+++ b/frontend/discourse/app/models/user.js
@@ -55,6 +55,7 @@ export const SECOND_FACTOR_METHODS = {
TOTP: 1,
BACKUP_CODE: 2,
SECURITY_KEY: 3,
+ PASSKEY: 4,
};
export const MAX_SECOND_FACTOR_NAME_LENGTH = 300;
diff --git a/frontend/discourse/app/templates/second-factor-auth.gjs b/frontend/discourse/app/templates/second-factor-auth.gjs
index 7961b488580..830987b83b5 100644
--- a/frontend/discourse/app/templates/second-factor-auth.gjs
+++ b/frontend/discourse/app/templates/second-factor-auth.gjs
@@ -18,12 +18,22 @@ export default <template>
<p class="action-description">{{@controller.customDescription}}</p>
{{/if}}
<p>{{@controller.secondFactorDescription}}</p>
- {{#if @controller.showSecurityKeyForm}}
+ {{#if @controller.showPasskeyForm}}
+ <div id="security-key">
+ <DButton
+ @action={{@controller.authenticatePasskey}}
+ @icon="user"
+ @label="login.use_passkey"
+ id="passkey-authenticate-button"
+ class="btn-large btn-primary"
+ />
+ </div>
+ {{else if @controller.showSecurityKeyForm}}
<div id="security-key">
<DButton
@action={{@controller.authenticateSecurityKey}}
@icon="key"
- @label={{@controller.securityKeyAuthenticateLabel}}
+ @label="login.security_key_authenticate"
id="security-key-authenticate-button"
class="btn-large btn-primary"
/>
diff --git a/frontend/discourse/tests/acceptance/second-factor-auth-test.js b/frontend/discourse/tests/acceptance/second-factor-auth-test.js
index 21526530bbd..0b41a2b4e09 100644
--- a/frontend/discourse/tests/acceptance/second-factor-auth-test.js
+++ b/frontend/discourse/tests/acceptance/second-factor-auth-test.js
@@ -6,10 +6,11 @@ import {
waitUntil,
} from "@ember/test-helpers";
import { test } from "qunit";
+import sinon from "sinon";
import { SECOND_FACTOR_METHODS } from "discourse/models/user";
import { acceptance } from "discourse/tests/helpers/qunit-helpers";
-const { TOTP, BACKUP_CODE, SECURITY_KEY } = SECOND_FACTOR_METHODS;
+const { TOTP, BACKUP_CODE, SECURITY_KEY, PASSKEY } = SECOND_FACTOR_METHODS;
const RESPONSES = {
failed: {
@@ -46,8 +47,38 @@ const RESPONSES = {
security_keys_enabled: true,
allowed_methods: [BACKUP_CODE],
},
+ okpasskeyonly: {
+ totp_enabled: false,
+ backup_enabled: false,
+ security_keys_enabled: false,
+ passkeys_enabled: true,
+ passkey_allowed_credential_ids: ["cGFzc2tleS1jcmVkZW50aWFs"],
+ challenge: "somechallenge",
+ allowed_methods: [TOTP, BACKUP_CODE, SECURITY_KEY, PASSKEY],
+ },
+ okmixedwebauthn: {
+ totp_enabled: false,
+ backup_enabled: false,
+ security_keys_enabled: true,
+ passkeys_enabled: true,
+ allowed_credential_ids: ["c2VjdXJpdHkta2V5LWNyZWRlbnRpYWw="],
+ passkey_allowed_credential_ids: ["cGFzc2tleS1jcmVkZW50aWFs"],
+ challenge: "somechallenge",
+ allowed_methods: [TOTP, BACKUP_CODE, SECURITY_KEY, PASSKEY],
+ },
};
+function stubWebauthnCredentialGet() {
+ const calls = [];
+ sinon.stub(navigator.credentials, "get").callsFake((options) => {
+ calls.push(options);
+ const error = new Error("credential get cancelled in tests");
+ error.name = "NotAllowedError";
+ return Promise.reject(error);
+ });
+ return calls;
+}
+
Object.keys(RESPONSES).forEach((k) => {
if (k.startsWith("ok")) {
const response = RESPONSES[k];
@@ -245,6 +276,76 @@ acceptance("Second Factor Auth Page", function (needs) {
.exists("backup code is now shown as an alternative method");
});
+ test("passkey-only account", async function (assert) {
+ stubWebauthnCredentialGet();
+
+ await visit("/session/2fa?nonce=okpasskeyonly");
+ assert
+ .dom("#passkey-authenticate-button")
+ .exists("passkey is the default method");
+ assert
+ .dom("#security-key-authenticate-button")
+ .doesNotExist("security key button is not shown without a security key");
+ assert
+ .dom(".toggle-second-factor-method")
+ .doesNotExist("no alternative methods are shown");
+ });
+
+ test("mixed passkey and security key account", async function (assert) {
+ stubWebauthnCredentialGet();
+
+ await visit("/session/2fa?nonce=okmixedwebauthn");
+ assert
+ .dom("#passkey-authenticate-button")
+ .exists("passkey is the default method");
+ assert
+ .dom("#security-key-authenticate-button")
+ .doesNotExist("security key form is not shown while passkey is selected");
+ assert
+ .dom(".toggle-second-factor-method.security-key")
+ .exists("security key is offered as an alternative method");
+
+ await click(".toggle-second-factor-method.security-key");
+ assert
+ .dom("#security-key-authenticate-button")
+ .exists("security key form is now shown");
+ assert
+ .dom("#passkey-authenticate-button")
+ .doesNotExist("passkey form is no longer shown");
+ assert
+ .dom(".toggle-second-factor-method.passkey")
+ .exists("passkey is offered as an alternative method");
+ });
+
+ test("passkey and security key ceremonies use separate options", async function (assert) {
+ const calls = stubWebauthnCredentialGet();
+
+ await visit("/session/2fa?nonce=okmixedwebauthn");
+ assert.strictEqual(
+ calls.length,
+ 1,
+ "the passkey ceremony was auto-triggered on load"
+ );
+ assert.strictEqual(
+ calls[0].publicKey.userVerification,
+ "required",
+ "the passkey ceremony requires user verification"
+ );
+ assert.strictEqual(
+ calls[0].publicKey.allowCredentials.length,
+ 1,
+ "the passkey ceremony only includes passkey credentials"
+ );
+
+ await click(".toggle-second-factor-method.security-key");
+ await click("#security-key-authenticate-button");
+ assert.strictEqual(
+ calls[1].publicKey.userVerification,
+ "discouraged",
+ "the security key ceremony discourages user verification"
+ );
+ });
+
test("2FA action description", async function (assert) {
await visit("/session/2fa?nonce=ok111111");
diff --git a/lib/discourse_webauthn.rb b/lib/discourse_webauthn.rb
index 8338b9026cc..4ae1009c878 100644
--- a/lib/discourse_webauthn.rb
+++ b/lib/discourse_webauthn.rb
@@ -92,16 +92,23 @@ module DiscourseWebauthn
server_session.delete(session_challenge_key(user))
end
+ # Returns separate allow-lists per WebAuthn ceremony: `allowed_credential_ids`
+ # for second-factor security keys (user verification discouraged) and
+ # `passkey_allowed_credential_ids` for passkeys used as 2FA (user
+ # verification required). Both ceremonies share the same staged challenge;
+ # the server validates the asserted credential against the intended ceremony.
def self.allowed_credentials(user, server_session, include_passkeys: false)
has_security_keys = user.security_keys_enabled?
- has_passkeys = include_passkeys && user.passkeys_for_2fa_enabled?
+ has_passkeys = include_passkeys && user.passkeys_available_as_second_factor?
return {} if !has_security_keys && !has_passkeys
- credential_ids = []
- credential_ids.concat(user.second_factor_security_key_credential_ids) if has_security_keys
- credential_ids.concat(user.passkey_credential_ids) if has_passkeys
-
- { allowed_credential_ids: credential_ids, challenge: challenge(user, server_session) }
+ response = {}
+ if has_security_keys
+ response[:allowed_credential_ids] = user.second_factor_security_key_credential_ids
+ end
+ response[:passkey_allowed_credential_ids] = user.passkey_credential_ids if has_passkeys
+ response[:challenge] = challenge(user, server_session)
+ response
end
def self.challenge(user, server_session)
diff --git a/lib/second_factor/auth_manager.rb b/lib/second_factor/auth_manager.rb
index ccee211a457..b7b33faa397 100644
--- a/lib/second_factor/auth_manager.rb
+++ b/lib/second_factor/auth_manager.rb
@@ -158,7 +158,13 @@ class SecondFactor::AuthManager
@target_user = target_user
@action = action
@allowed_methods =
- Set.new([UserSecondFactor.methods[:totp], UserSecondFactor.methods[:security_key]]).freeze
+ Set.new(
+ [
+ UserSecondFactor.methods[:totp],
+ UserSecondFactor.methods[:security_key],
+ UserSecondFactor.methods[:passkey],
+ ],
+ ).freeze
end
def allow_backup_codes!
diff --git a/spec/lib/concern/second_factor_manager_spec.rb b/spec/lib/concern/second_factor_manager_spec.rb
index 2bee9851153..05ed5a99201 100644
--- a/spec/lib/concern/second_factor_manager_spec.rb
+++ b/spec/lib/concern/second_factor_manager_spec.rb
@@ -164,24 +164,36 @@ RSpec.describe SecondFactorManager do
end
end
- describe "#passkeys_for_2fa_enabled?" do
+ describe "#passkeys_available_as_second_factor?" do
before do
SiteSetting.allow_passkeys_for_2fa = true
Fabricate(:passkey_with_random_credential, user: user)
end
it "is true when both setting flags are on" do
- expect(user.passkeys_for_2fa_enabled?).to eq(true)
+ expect(user.passkeys_available_as_second_factor?).to eq(true)
end
it "is false when the global enable_passkeys kill switch is off" do
SiteSetting.enable_passkeys = false
- expect(user.passkeys_for_2fa_enabled?).to eq(false)
+ expect(user.passkeys_available_as_second_factor?).to eq(false)
end
it "is false when allow_passkeys_for_2fa is off" do
SiteSetting.allow_passkeys_for_2fa = false
- expect(user.passkeys_for_2fa_enabled?).to eq(false)
+ expect(user.passkeys_available_as_second_factor?).to eq(false)
+ end
+
+ it "is false when the user only has disabled passkeys" do
+ user
+ .security_keys
+ .where(factor_type: UserSecurityKey.factor_types[:first_factor])
+ .update_all(enabled: false)
+ expect(user.passkeys_available_as_second_factor?).to eq(false)
+ end
+
+ it "is aliased as passkeys_for_2fa_enabled? for compatibility" do
+ expect(user.passkeys_for_2fa_enabled?).to eq(true)
end
end
@@ -214,7 +226,18 @@ RSpec.describe SecondFactorManager do
expect(user.authenticate_second_factor(params, server_session).ok).to eq(true)
end
- it "validates the credential when a method is submitted" do
+ it "validates the credential when the passkey method is submitted" do
+ params_with_method = {
+ second_factor_method: UserSecondFactor.methods[:passkey],
+ second_factor_token: {
+ credentialId: "missing",
+ },
+ }
+ result = user.authenticate_second_factor(params_with_method, server_session)
+ expect(result.ok).to eq(false)
+ end
+
+ it "rejects the security key method because passkeys are not security keys" do
params_with_method = {
second_factor_method: UserSecondFactor.methods[:security_key],
second_factor_token: {
@@ -223,6 +246,71 @@ RSpec.describe SecondFactorManager do
}
result = user.authenticate_second_factor(params_with_method, server_session)
expect(result.ok).to eq(false)
+ expect(result.error).to eq(I18n.t("login.not_enabled_second_factor_method"))
+ end
+ end
+ end
+
+ context "with the passkey ceremony" do
+ let!(:passkey) do
+ Fabricate(
+ :user_security_key,
+ user: user,
+ credential_id: valid_passkey_data[:credential_id],
+ public_key: valid_passkey_data[:public_key],
+ factor_type: UserSecurityKey.factor_types[:first_factor],
+ )
+ end
+
+ before do
+ SiteSetting.allow_passkeys_for_2fa = true
+ simulate_localhost_passkey_challenge
+ DiscourseWebauthn.stage_challenge(user, server_session)
+ DiscourseWebauthn.stubs(:origin).returns("http://localhost:3000")
+ end
+
+ context "when the passkey assertion is valid" do
+ let(:params) do
+ {
+ second_factor_token: valid_passkey_auth_data,
+ second_factor_method: UserSecondFactor.methods[:passkey],
+ }
+ end
+
+ it "returns OK and sets used_2fa_method to passkey" do
+ result = user.authenticate_second_factor(params, server_session)
+ expect(result.ok).to eq(true)
+ expect(result.used_2fa_method).to eq(UserSecondFactor.methods[:passkey])
+ end
+ end
+
+ context "when a passkey assertion is posted as the security key method" do
+ let(:params) do
+ {
+ second_factor_token: valid_passkey_auth_data,
+ second_factor_method: UserSecondFactor.methods[:security_key],
+ }
+ end
+
+ it "is rejected with an ownership error" do
+ result = user.authenticate_second_factor(params, server_session)
+ expect(result.ok).to eq(false)
+ expect(result.error).to eq(I18n.t("webauthn.validation.ownership_error"))
+ end
+ end
+
+ context "when a security key assertion is posted as the passkey method" do
+ let(:params) do
+ {
+ second_factor_token: valid_security_key_auth_post_data,
+ second_factor_method: UserSecondFactor.methods[:passkey],
+ }
+ end
+
+ it "is rejected with an ownership error" do
+ result = user.authenticate_second_factor(params, server_session)
+ expect(result.ok).to eq(false)
+ expect(result.error).to eq(I18n.t("webauthn.validation.ownership_error"))
end
end
end
@@ -309,7 +397,7 @@ RSpec.describe SecondFactorManager do
end
context "when both security keys and totp are enabled" do
- let(:invalid_method) { 4 }
+ let(:invalid_method) { 99 }
let(:method) { invalid_method }
before do
diff --git a/spec/lib/discourse_webauthn/discourse_webauthn_spec.rb b/spec/lib/discourse_webauthn/discourse_webauthn_spec.rb
index e4c1e001f26..6b6504d64a8 100644
--- a/spec/lib/discourse_webauthn/discourse_webauthn_spec.rb
+++ b/spec/lib/discourse_webauthn/discourse_webauthn_spec.rb
@@ -45,4 +45,52 @@ RSpec.describe DiscourseWebauthn do
expect(server_session[key]).to be_nil
end
end
+
+ describe ".allowed_credentials" do
+ let(:server_session) { ServerSession.new("some-prefix") }
+
+ before do
+ SiteSetting.allow_passkeys_for_2fa = true
+ described_class.stage_challenge(user, server_session)
+ end
+
+ it "returns an empty hash when the user has no webauthn credentials" do
+ expect(described_class.allowed_credentials(user, server_session)).to eq({})
+ end
+
+ it "returns only security key ids for a user with a security key" do
+ key = Fabricate(:user_security_key_with_random_credential, user: user)
+ response = described_class.allowed_credentials(user, server_session)
+
+ expect(response[:allowed_credential_ids]).to contain_exactly(key.credential_id)
+ expect(response).not_to have_key(:passkey_allowed_credential_ids)
+ expect(response[:challenge]).to be_present
+ end
+
+ it "does not include passkeys unless include_passkeys is passed" do
+ Fabricate(:passkey_with_random_credential, user: user)
+
+ expect(described_class.allowed_credentials(user, server_session)).to eq({})
+ end
+
+ it "returns passkey ids separately from security key ids" do
+ key = Fabricate(:user_security_key_with_random_credential, user: user)
+ passkey = Fabricate(:passkey_with_random_credential, user: user)
+
+ response = described_class.allowed_credentials(user, server_session, include_passkeys: true)
+
+ expect(response[:allowed_credential_ids]).to contain_exactly(key.credential_id)
+ expect(response[:passkey_allowed_credential_ids]).to contain_exactly(passkey.credential_id)
+ expect(response[:challenge]).to be_present
+ end
+
+ it "does not include passkey ids when allow_passkeys_for_2fa is disabled" do
+ SiteSetting.allow_passkeys_for_2fa = false
+ Fabricate(:passkey_with_random_credential, user: user)
+
+ expect(
+ described_class.allowed_credentials(user, server_session, include_passkeys: true),
+ ).to eq({})
+ end
+ end
end
diff --git a/spec/lib/second_factor/auth_manager_spec.rb b/spec/lib/second_factor/auth_manager_spec.rb
index e59f4807815..6de6eefc2bf 100644
--- a/spec/lib/second_factor/auth_manager_spec.rb
+++ b/spec/lib/second_factor/auth_manager_spec.rb
@@ -45,6 +45,17 @@ RSpec.describe SecondFactor::AuthManager do
[challenge[:nonce], server_session]
end
+ describe "#allowed_methods" do
+ it "allows totp, security keys and passkeys by default" do
+ manager = create_manager(create_action)
+ expect(manager.allowed_methods).to contain_exactly(
+ UserSecondFactor.methods[:totp],
+ UserSecondFactor.methods[:security_key],
+ UserSecondFactor.methods[:passkey],
+ )
+ end
+ end
+
describe "#allow_backup_codes!" do
it "adds the backup codes method to the allowed methods set" do
manager = create_manager(create_action)
diff --git a/spec/requests/session_controller_spec.rb b/spec/requests/session_controller_spec.rb
index 4d927bd7380..c2489c91139 100644
--- a/spec/requests/session_controller_spec.rb
+++ b/spec/requests/session_controller_spec.rb
@@ -3151,6 +3151,7 @@ RSpec.describe SessionController do
expect(challenge_data["allowed_methods"]).to contain_exactly(
UserSecondFactor.methods[:totp],
UserSecondFactor.methods[:security_key],
+ UserSecondFactor.methods[:passkey],
)
expect(challenge_data["description"]).to eq("this is description for test action")
@@ -3175,6 +3176,7 @@ RSpec.describe SessionController do
expect(challenge_data["allowed_methods"]).to contain_exactly(
UserSecondFactor.methods[:totp],
UserSecondFactor.methods[:security_key],
+ UserSecondFactor.methods[:passkey],
UserSecondFactor.methods[:backup_codes],
)
end
@@ -3192,7 +3194,7 @@ RSpec.describe SessionController do
)
end
- it "exposes the passkey credentials and a webauthn challenge" do
+ it "exposes the passkey credentials separately from security keys" do
post "/session/2fa/test-action", xhr: true
nonce = response.parsed_body["second_factor_challenge_nonce"]
get "/session/2fa.json", params: { nonce: nonce }
@@ -3201,11 +3203,32 @@ RSpec.describe SessionController do
challenge_data = response.parsed_body
expect(challenge_data["passkeys_enabled"]).to eq(true)
expect(challenge_data["security_keys_enabled"]).to eq(false)
- expect(challenge_data["allowed_credential_ids"]).to include(
+ expect(challenge_data["allowed_credential_ids"]).to be_blank
+ expect(challenge_data["passkey_allowed_credential_ids"]).to contain_exactly(
valid_passkey_data[:credential_id],
)
expect(challenge_data["challenge"]).to be_present
end
+
+ it "keeps the allow-lists disjoint when the user also has a security key" do
+ Fabricate(:user_security_key_with_random_credential, user: user, name: "YubiKey")
+
+ post "/session/2fa/test-action", xhr: true
+ nonce = response.parsed_body["second_factor_challenge_nonce"]
+ get "/session/2fa.json", params: { nonce: nonce }
+
+ expect(response.status).to eq(200)
+ challenge_data = response.parsed_body
+ expect(challenge_data["passkeys_enabled"]).to eq(true)
+ expect(challenge_data["security_keys_enabled"]).to eq(true)
+ expect(challenge_data["passkey_allowed_credential_ids"]).to contain_exactly(
+ valid_passkey_data[:credential_id],
+ )
+ expect(challenge_data["allowed_credential_ids"]).to be_present
+ expect(challenge_data["allowed_credential_ids"]).not_to include(
+ valid_passkey_data[:credential_id],
+ )
+ end
end
context "when the user has a passkey and allow_passkeys_for_2fa is disabled" do
@@ -3222,6 +3245,7 @@ RSpec.describe SessionController do
challenge_data = response.parsed_body
expect(challenge_data["passkeys_enabled"]).to eq(false)
expect(challenge_data["allowed_credential_ids"]).to be_blank
+ expect(challenge_data["passkey_allowed_credential_ids"]).to be_blank
end
end
end
@@ -3377,7 +3401,7 @@ RSpec.describe SessionController do
post "/session/2fa.json",
params: {
nonce: nonce,
- second_factor_method: UserSecondFactor.methods[:security_key],
+ second_factor_method: UserSecondFactor.methods[:passkey],
second_factor_token: valid_passkey_auth_data,
}
@@ -3395,13 +3419,56 @@ RSpec.describe SessionController do
post "/session/2fa.json",
params: {
nonce: nonce,
- second_factor_method: UserSecondFactor.methods[:security_key],
+ second_factor_method: UserSecondFactor.methods[:passkey],
second_factor_token: valid_passkey_auth_data,
}
expect(response.status).to eq(403)
end
+ it "rejects a passkey assertion posted as the security key ceremony" do
+ SiteSetting.allow_passkeys_for_2fa = true
+ simulate_localhost_passkey_challenge
+ Fabricate(:user_security_key_with_random_credential, user: user, name: "YubiKey")
+
+ post "/session/2fa/test-action", xhr: true
+ nonce = response.parsed_body["second_factor_challenge_nonce"]
+
+ post "/session/2fa.json",
+ params: {
+ nonce: nonce,
+ second_factor_method: UserSecondFactor.methods[:security_key],
+ second_factor_token: valid_passkey_auth_data,
+ }
+
+ expect(response.status).to eq(400)
+ expect(response.parsed_body["error"]).to eq(I18n.t("webauthn.validation.ownership_error"))
+ end
+
+ it "rejects a security key assertion posted as the passkey ceremony" do
+ SiteSetting.allow_passkeys_for_2fa = true
+ simulate_localhost_passkey_challenge
+ Fabricate(
+ :user_security_key,
+ user: user,
+ public_key: valid_security_key_data[:public_key],
+ credential_id: valid_security_key_data[:credential_id],
+ )
+
+ post "/session/2fa/test-action", xhr: true
+ nonce = response.parsed_body["second_factor_challenge_nonce"]
+
+ post "/session/2fa.json",
+ params: {
+ nonce: nonce,
+ second_factor_method: UserSecondFactor.methods[:passkey],
+ second_factor_token: valid_security_key_auth_post_data,
+ }
+
+ expect(response.status).to eq(400)
+ expect(response.parsed_body["error"]).to eq(I18n.t("webauthn.validation.ownership_error"))
+ end
+
it "rejects an assertion from a disabled passkey even when the user has another enabled passkey" do
SiteSetting.allow_passkeys_for_2fa = true
simulate_localhost_passkey_challenge
@@ -3414,7 +3481,7 @@ RSpec.describe SessionController do
post "/session/2fa.json",
params: {
nonce: nonce,
- second_factor_method: UserSecondFactor.methods[:security_key],
+ second_factor_method: UserSecondFactor.methods[:passkey],
second_factor_token: valid_passkey_auth_data,
}