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.rbindex 4544e35e98a..d20d56a9551 100644--- a/app/controllers/session_controller.rb+++ b/app/controllers/session_controller.rb@@ -538,7 +538,7 @@ class SessionController < ApplicationControllerbackup_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_2faDiscourseWebauthn.stage_challenge(user, server_session)json.merge!(diff --git a/app/models/concerns/second_factor_manager.rb b/app/models/concerns/second_factor_manager.rbindex 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 SecondFactorManagerdef 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_resultend@@ -152,6 +156,13 @@ module SecondFactorManagerelsereturn invalid_security_key_resultend+ 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+ endend# if we have gotten down to this point without being@@ -168,20 +179,28 @@ module SecondFactorManagerwhen 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?endfalseenddef 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_keyenddiff --git a/app/models/user_second_factor.rb b/app/models/user_second_factor.rbindex 854b0e143f3..cb1f598c44f 100644--- a/app/models/user_second_factor.rb+++ b/app/models/user_second_factor.rb@@ -18,8 +18,12 @@ class UserSecondFactor < ActiveRecord::Basevalidate :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)enddef totp_objectdiff --git a/config/locales/client.en.yml b/config/locales/client.en.ymlindex 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.gjsindex 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.gjsindex 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";+ }+@actionuseAnotherMethod(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}}<adiff --git a/frontend/discourse/app/controllers/second-factor-auth.js b/frontend/discourse/app/controllers/second-factor-auth.jsindex 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.jsindex 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.jsindex 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.gjsindex 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.jsindex 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.rbindex 8338b9026cc..4ae1009c878 100644--- a/lib/discourse_webauthn.rb+++ b/lib/discourse_webauthn.rb@@ -92,16 +92,23 @@ module DiscourseWebauthnserver_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)+ responseenddef self.challenge(user, server_session)diff --git a/lib/second_factor/auth_manager.rb b/lib/second_factor/auth_manager.rbindex 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],+ ],+ ).freezeenddef allow_backup_codes!diff --git a/spec/lib/concern/second_factor_manager_spec.rb b/spec/lib/concern/second_factor_manager_spec.rbindex 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 doendend- describe "#passkeys_for_2fa_enabled?" do+ describe "#passkeys_available_as_second_factor?" dobefore doSiteSetting.allow_passkeys_for_2fa = trueFabricate(:passkey_with_random_credential, user: user)endit "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)endit "is false when the global enable_passkeys kill switch is off" doSiteSetting.enable_passkeys = false- expect(user.passkeys_for_2fa_enabled?).to eq(false)+ expect(user.passkeys_available_as_second_factor?).to eq(false)endit "is false when allow_passkeys_for_2fa is off" doSiteSetting.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)endend@@ -214,7 +226,18 @@ RSpec.describe SecondFactorManager doexpect(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" doparams_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"))endendend@@ -309,7 +397,7 @@ RSpec.describe SecondFactorManager doendcontext "when both security keys and totp are enabled" do- let(:invalid_method) { 4 }+ let(:invalid_method) { 99 }let(:method) { invalid_method }before dodiff --git a/spec/lib/discourse_webauthn/discourse_webauthn_spec.rb b/spec/lib/discourse_webauthn/discourse_webauthn_spec.rbindex 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 doexpect(server_session[key]).to be_nilendend++ 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+ endenddiff --git a/spec/lib/second_factor/auth_manager_spec.rb b/spec/lib/second_factor/auth_manager_spec.rbindex 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!" doit "adds the backup codes method to the allowed methods set" domanager = create_manager(create_action)diff --git a/spec/requests/session_controller_spec.rb b/spec/requests/session_controller_spec.rbindex 4d927bd7380..c2489c91139 100644--- a/spec/requests/session_controller_spec.rb+++ b/spec/requests/session_controller_spec.rb@@ -3151,6 +3151,7 @@ RSpec.describe SessionController doexpect(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 doexpect(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" dopost "/session/2fa/test-action", xhr: truenonce = response.parsed_body["second_factor_challenge_nonce"]get "/session/2fa.json", params: { nonce: nonce }@@ -3201,11 +3203,32 @@ RSpec.describe SessionController dochallenge_data = response.parsed_bodyexpect(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_presentend++ 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],+ )+ endendcontext "when the user has a passkey and allow_passkeys_for_2fa is disabled" do@@ -3222,6 +3245,7 @@ RSpec.describe SessionController dochallenge_data = response.parsed_bodyexpect(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_blankendendend@@ -3377,7 +3401,7 @@ RSpec.describe SessionController dopost "/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 dopost "/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" doSiteSetting.allow_passkeys_for_2fa = truesimulate_localhost_passkey_challenge@@ -3414,7 +3481,7 @@ RSpec.describe SessionController dopost "/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,}