A platform for community discussion. Free, open, simple.
# frozen_string_literal: true
require "rotp"
RSpec.describe SessionController do
let(:user) { Fabricate(:user) }
let(:email_token) { Fabricate(:email_token, user: user) }
fab!(:admin)
let(:admin_email_token) { Fabricate(:email_token, user: admin) }
shared_examples "failed to continue local login" do
it "returns a forbidden response" do
expect(response).not_to be_successful
expect(response.status).to eq(403)
end
end
before { SiteSetting.hide_email_address_taken = false }
describe "#email_login_info" do
let(:email_token) do
Fabricate(:email_token, user: user, scope: EmailToken.scopes[:email_login])
end
before { SiteSetting.enable_local_logins_via_email = true }
context "when local logins via email disabled" do
before { SiteSetting.enable_local_logins_via_email = false }
it "only works for admins" do
get "/session/email-login/#{email_token.token}.json"
expect(response.status).to eq(403)
user.update(admin: true)
get "/session/email-login/#{email_token.token}.json"
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
end
end
context "when SSO enabled" do
before do
SiteSetting.discourse_connect_url = "https://www.example.com/sso"
SiteSetting.discourse_connect_secret = "x" * 10
SiteSetting.enable_discourse_connect = true
end
it "only works for admins" do
get "/session/email-login/#{email_token.token}.json"
expect(response.status).to eq(403)
user.update(admin: true)
get "/session/email-login/#{email_token.token}.json"
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
end
end
context "with missing token" do
it "returns the right response" do
get "/session/email-login"
expect(response.status).to eq(404)
end
end
context "with valid token" do
it "returns information" do
get "/session/email-login/#{email_token.token}.json"
expect(response.parsed_body["can_login"]).to eq(true)
expect(response.parsed_body["second_factor_required"]).to eq(nil)
# Does not log in the user
expect(session[:current_user_id]).to be_nil
end
it "fails when local logins via email is disabled" do
SiteSetting.enable_local_logins_via_email = false
get "/session/email-login/#{email_token.token}.json"
expect(response.status).to eq(403)
end
it "fails when local logins is disabled" do
SiteSetting.enable_local_logins = false
get "/session/email-login/#{email_token.token}.json"
expect(response.status).to eq(403)
end
context "when user has 2-factor logins" do
let!(:user_second_factor) { Fabricate(:user_second_factor_totp, user: user) }
let!(:user_second_factor_backup) { Fabricate(:user_second_factor_backup, user: user) }
it "includes that information in the response" do
get "/session/email-login/#{email_token.token}.json"
response_body_parsed = response.parsed_body
expect(response_body_parsed["can_login"]).to eq(true)
expect(response_body_parsed["second_factor_required"]).to eq(true)
expect(response_body_parsed["backup_codes_enabled"]).to eq(true)
expect(response_body_parsed["totp_enabled"]).to eq(true)
end
end
context "when user has security key enabled" do
let!(:user_security_key) { Fabricate(:user_security_key, user: user) }
it "includes that information in the response" do
get "/session/email-login/#{email_token.token}.json"
response_body_parsed = response.parsed_body
expect(response_body_parsed["can_login"]).to eq(true)
expect(response_body_parsed["security_key_required"]).to eq(true)
expect(response_body_parsed["second_factor_required"]).to eq(nil)
expect(response_body_parsed["backup_codes_enabled"]).to eq(nil)
expect(response_body_parsed["allowed_credential_ids"]).to eq(
[user_security_key.credential_id],
)
expect(response_body_parsed["challenge"]).to eq(
DiscourseWebauthn.challenge(user, request.server_session),
)
expect(DiscourseWebauthn.rp_id).to eq("localhost")
end
end
end
end
describe "#email_login" do
let(:email_token) { Fabricate(:email_token, user:, scope: EmailToken.scopes[:email_login]) }
before { SiteSetting.enable_local_logins_via_email = true }
context "when in readonly mode" do
before { Discourse.enable_readonly_mode }
it "allows admins to login" do
user.update!(admin: true)
post "/session/email-login/#{email_token.token}.json"
expect(response.status).to eq(200)
expect(session[:current_user_id]).to eq(user.id)
end
it "does not allow moderators to login" do
user.update!(moderator: true)
post "/session/email-login/#{email_token.token}.json"
expect(response.status).to eq(503)
expect(session[:current_user_id]).to eq(nil)
end
it "does not allow regular users to login" do
post "/session/email-login/#{email_token.token}.json"
expect(response.status).to eq(503)
expect(session[:current_user_id]).to eq(nil)
end
end
context "when in staff writes only mode" do
before { Discourse.enable_readonly_mode(Discourse::STAFF_WRITES_ONLY_MODE_KEY) }
it "allows admins to login" do
user.update!(admin: true)
post "/session/email-login/#{email_token.token}.json"
expect(response.status).to eq(200)
expect(session[:current_user_id]).to eq(user.id)
end
it "allows moderators to login" do
user.update!(moderator: true)
post "/session/email-login/#{email_token.token}.json"
expect(response.status).to eq(200)
expect(session[:current_user_id]).to eq(user.id)
end
it "does not allow regular users to login" do
post "/session/email-login/#{email_token.token}.json"
expect(response.status).to eq(503)
expect(session[:current_user_id]).to eq(nil)
end
end
context "when local logins via email disabled" do
before { SiteSetting.enable_local_logins_via_email = false }
it "only works for admins" do
post "/session/email-login/#{email_token.token}.json"
expect(response.status).to eq(403)
user.update(admin: true)
post "/session/email-login/#{email_token.token}.json"
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
expect(session[:current_user_id]).to eq(user.id)
end
end
context "with missing token" do
it "returns the right response" do
post "/session/email-login"
expect(response.status).to eq(404)
end
end
context "with invalid token" do
it "returns the right response" do
post "/session/email-login/adasdad.json"
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(
I18n.t("email_login.invalid_token", base_url: Discourse.base_url),
)
end
context "when token has expired" do
it "returns the expired-token error" do
email_token.update!(created_at: 999.years.ago)
post "/session/email-login/#{email_token.token}.json"
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(
I18n.t("email_login.invalid_token", base_url: Discourse.base_url),
)
end
end
end
context "with valid token" do
it "returns success" do
post "/session/email-login/#{email_token.token}.json"
expect(response.parsed_body["success"]).to eq("OK")
expect(session[:current_user_id]).to eq(user.id)
end
it "fails when local logins via email is disabled" do
SiteSetting.enable_local_logins_via_email = false
post "/session/email-login/#{email_token.token}.json"
expect(response.status).to eq(403)
expect(session[:current_user_id]).to eq(nil)
end
it "fails when local logins is disabled" do
SiteSetting.enable_local_logins = false
post "/session/email-login/#{email_token.token}.json"
expect(response.status).to eq(403)
expect(session[:current_user_id]).to eq(nil)
end
it "doesn't log in the user when not approved" do
SiteSetting.must_approve_users = true
post "/session/email-login/#{email_token.token}.json"
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(I18n.t("login.not_approved"))
expect(session[:current_user_id]).to eq(nil)
end
context "when admin IP address is not valid" do
before do
Fabricate(
:screened_ip_address,
ip_address: "111.111.11.11",
action_type: ScreenedIpAddress.actions[:allow_admin],
)
SiteSetting.use_admin_ip_allowlist = true
user.update!(admin: true)
end
it "returns the right response" do
post "/session/email-login/#{email_token.token}.json"
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(
I18n.t("login.admin_not_allowed_from_ip_address", username: user.username),
)
expect(session[:current_user_id]).to eq(nil)
end
end
context "when IP address is blocked" do
let(:permitted_ip_address) { "111.234.23.11" }
before do
Fabricate(
:screened_ip_address,
ip_address: permitted_ip_address,
action_type: ScreenedIpAddress.actions[:block],
)
end
it "returns the right response" do
ActionDispatch::Request.any_instance.stubs(:remote_ip).returns(permitted_ip_address)
post "/session/email-login/#{email_token.token}.json"
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(
I18n.t("login.not_allowed_from_ip_address", username: user.username),
)
expect(session[:current_user_id]).to eq(nil)
end
end
context "when timezone param is provided" do
let(:user) { Fabricate(:user, timezone: nil) }
it "sets the user_option timezone for the user" do
post "/session/email-login/#{email_token.token}.json",
params: {
timezone: "Australia/Melbourne",
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
expect(user.reload.user_option.timezone).to eq("Australia/Melbourne")
end
end
it "fails when user is suspended" do
user.update!(suspended_till: 2.days.from_now, suspended_at: Time.zone.now)
post "/session/email-login/#{email_token.token}.json"
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(
I18n.t("login.suspended", date: I18n.l(user.suspended_till, format: :date_only)),
)
expect(session[:current_user_id]).to eq(nil)
end
context "when user has 2-factor logins" do
let!(:user_second_factor) { Fabricate(:user_second_factor_totp, user: user) }
let!(:user_second_factor_backup) { Fabricate(:user_second_factor_backup, user: user) }
describe "errors on incorrect 2-factor" do
context "when using totp method" do
it "does not log in with incorrect two factor" do
post "/session/email-login/#{email_token.token}.json",
params: {
second_factor_token: "0000",
second_factor_method: UserSecondFactor.methods[:totp],
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(
I18n.t("login.invalid_second_factor_code"),
)
expect(session[:current_user_id]).to eq(nil)
end
end
context "when using backup code method" do
it "does not log in with incorrect backup code" do
post "/session/email-login/#{email_token.token}.json",
params: {
second_factor_token: "0000",
second_factor_method: UserSecondFactor.methods[:backup_codes],
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(
I18n.t("login.invalid_second_factor_code"),
)
expect(session[:current_user_id]).to eq(nil)
end
end
end
describe "allows successful 2-factor" do
context "when using totp method" do
it "logs in correctly" do
post "/session/email-login/#{email_token.token}.json",
params: {
second_factor_token: ROTP::TOTP.new(user_second_factor.data).now,
second_factor_method: UserSecondFactor.methods[:totp],
}
expect(response.parsed_body["success"]).to eq("OK")
expect(session[:current_user_id]).to eq(user.id)
end
end
context "when using backup code method" do
it "logs in correctly" do
post "/session/email-login/#{email_token.token}.json",
params: {
second_factor_token: "iAmValidBackupCode",
second_factor_method: UserSecondFactor.methods[:backup_codes],
}
expect(response.parsed_body["success"]).to eq("OK")
expect(session[:current_user_id]).to eq(user.id)
end
end
end
context "if the security_key_param is provided but only TOTP is enabled" do
it "does not log in the user" do
post "/session/email-login/#{email_token.token}.json",
params: {
second_factor_token: "foo",
second_factor_method: UserSecondFactor.methods[:totp],
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(I18n.t("login.invalid_second_factor_code"))
expect(session[:current_user_id]).to eq(nil)
end
end
end
context "when user has only security key enabled" do
let!(:user_security_key) do
Fabricate(
:user_security_key,
user: user,
credential_id: valid_security_key_data[:credential_id],
public_key: valid_security_key_data[:public_key],
)
end
before do
simulate_localhost_webauthn_challenge
DiscourseWebauthn.stubs(:origin).returns("http://localhost:3000")
# store challenge in server session by visiting the email login page
get "/session/email-login/#{email_token.token}.json"
end
context "when the security key params are blank and a random second factor token is provided" do
it "shows an error message and denies login" do
post "/session/email-login/#{email_token.token}.json",
params: {
second_factor_token: "XXXXXXX",
second_factor_method: UserSecondFactor.methods[:totp],
}
expect(response.status).to eq(200)
expect(session[:current_user_id]).to eq(nil)
response_body = response.parsed_body
expect(response_body["error"]).to eq(I18n.t("login.not_enabled_second_factor_method"))
end
end
context "when the security key params are invalid" do
it "shows an error message and denies login" do
post "/session/email-login/#{email_token.token}.json",
params: {
second_factor_token: {
signature: "bad_sig",
clientData: "bad_clientData",
credentialId: "bad_credential_id",
authenticatorData: "bad_authenticator_data",
},
second_factor_method: UserSecondFactor.methods[:security_key],
}
expect(response.status).to eq(200)
expect(session[:current_user_id]).to eq(nil)
response_body = response.parsed_body
expect(response_body["failed"]).to eq("FAILED")
expect(response_body["error"]).to eq(I18n.t("webauthn.validation.not_found_error"))
end
end
context "when the security key params are valid" do
it "logs the user in" do
post "/session/email-login/#{email_token.token}.json",
params: {
login: user.username,
password: "myawesomepassword",
second_factor_token: valid_security_key_auth_post_data,
second_factor_method: UserSecondFactor.methods[:security_key],
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
user.reload
expect(session[:current_user_id]).to eq(user.id)
expect(user.user_auth_tokens.count).to eq(1)
end
end
end
context "when user has security key and totp enabled" do
let!(:user_security_key) do
Fabricate(
:user_security_key,
user: user,
credential_id: valid_security_key_data[:credential_id],
public_key: valid_security_key_data[:public_key],
)
end
let!(:user_second_factor) { Fabricate(:user_second_factor_totp, user: user) }
it "doesn't allow logging in if the 2fa params are garbled" do
post "/session/email-login/#{email_token.token}.json",
params: {
second_factor_method: UserSecondFactor.methods[:totp],
second_factor_token: "blah",
}
expect(response.status).to eq(200)
expect(session[:current_user_id]).to eq(nil)
response_body = response.parsed_body
expect(response_body["error"]).to eq(I18n.t("login.invalid_second_factor_code"))
end
it "doesn't allow login if both of the 2fa params are blank" do
post "/session/email-login/#{email_token.token}.json",
params: {
second_factor_method: UserSecondFactor.methods[:totp],
second_factor_token: "",
}
expect(response.status).to eq(200)
expect(session[:current_user_id]).to eq(nil)
response_body = response.parsed_body
expect(response_body["error"]).to eq(I18n.t("login.invalid_second_factor_code"))
end
end
end
end
describe "#create_login_code" do
before { SiteSetting.enable_local_logins_via_code = true }
def honeypot_magic(params)
get "/session/hp.json"
json = response.parsed_body
params[:password_confirmation] = json["value"]
params[:challenge] = json["challenge"].reverse
params
end
it "returns a 404 when login via code is disabled" do
SiteSetting.enable_local_logins_via_code = false
post "/session/login-code.json", params: { email: user.email }
expect(response.status).to eq(404)
end
it "allows requesting a code when the upcoming change is auto-promoted without the setting being toggled" do
SiteSetting.remove_override!(:enable_local_logins_via_code)
SiteSetting.promote_upcoming_changes_on_status = "alpha"
post "/session/login-code.json", params: honeypot_magic(email: user.email)
expect(response.status).to eq(200)
expect(EmailLoginCode.for_email(user.email).count).to eq(1)
end
context "when local logins are disabled" do
before { SiteSetting.enable_local_logins = false }
it "returns a 404 because login via code is unavailable" do
post "/session/login-code.json", params: { email: user.email }
expect(response.status).to eq(404)
end
end
context "when email login is disabled" do
before { SiteSetting.enable_local_logins_via_email = false }
it "returns a 404 because login via code is unavailable" do
post "/session/login-code.json", params: { email: user.email }
expect(response.status).to eq(404)
end
end
context "when SSO is enabled" do
before do
SiteSetting.discourse_connect_url = "https://www.example.com/sso"
SiteSetting.discourse_connect_secret = "x" * 10
SiteSetting.enable_discourse_connect = true
end
it "returns a 403" do
post "/session/login-code.json", params: { email: user.email }
expect(response.status).to eq(403)
end
end
context "when the user is already logged in" do
it "redirects home without generating a code" do
sign_in(user)
post "/session/login-code.json", params: { email: user.email }
expect(response).to redirect_to("/")
expect(EmailLoginCode.count).to eq(0)
end
end
it "returns a 400 for an invalid email" do
post "/session/login-code.json", params: honeypot_magic(email: "not-an-email")
expect(response.status).to eq(400)
end
it "responds with success but no code when the honeypot fails" do
post "/session/login-code.json", params: { email: user.email }
expect(response.status).to eq(200)
expect(response.parsed_body["success"]).to eq("OK")
expect(EmailLoginCode.count).to eq(0)
end
it "generates a code and enqueues the email for an existing user" do
expect_enqueued_with(job: :send_email_login_code, args: { to_address: user.email }) do
post "/session/login-code.json", params: honeypot_magic(email: user.email)
end
expect(response.status).to eq(200)
expect(response.parsed_body["success"]).to eq("OK")
expect(EmailLoginCode.for_email(user.email).count).to eq(1)
end
context "when requesting a code for an email invite" do
let(:invite) { Fabricate(:invite, email: "[email protected]") }
it "uses the invite's email instead of a supplied email" do
expect_enqueued_with(job: :send_email_login_code, args: { to_address: invite.email }) do
post "/session/login-code.json",
params: honeypot_magic(email: "[email protected]", invite_key: invite.invite_key)
end
expect(response.status).to eq(200)
expect(response.parsed_body["success"]).to eq("OK")
expect(EmailLoginCode.for_email(invite.email).count).to eq(1)
expect(EmailLoginCode.for_email("[email protected]")).to be_empty
end
it "returns the generic success response when the invite is not redeemable" do
invite.update!(expires_at: 1.day.ago)
post "/session/login-code.json", params: honeypot_magic(invite_key: invite.invite_key)
expect(response.status).to eq(200)
expect(response.parsed_body["success"]).to eq("OK")
expect(EmailLoginCode.for_email(invite.email)).to be_empty
end
it "returns generic success without emailing a code for a normalized-only match" do
SiteSetting.normalize_emails = true
user.update!(email: "[email protected]")
invite.update!(email: "[email protected]")
expect_not_enqueued_with(job: :send_email_login_code) do
post "/session/login-code.json", params: honeypot_magic(invite_key: invite.invite_key)
end
expect(response.status).to eq(200)
expect(response.parsed_body["success"]).to eq("OK")
expect(EmailLoginCode.for_email(invite.email)).to be_empty
end
it "sends a code when the invite belongs to an existing user whose domain is blocked" do
Fabricate(:user, email: invite.email)
SiteSetting.blocked_email_domains = "example.com"
expect_enqueued_with(job: :send_email_login_code, args: { to_address: invite.email }) do
post "/session/login-code.json", params: honeypot_magic(invite_key: invite.invite_key)
end
expect(response.status).to eq(200)
expect(EmailLoginCode.for_email(invite.email).count).to eq(1)
end
end
it "does not generate a code for an address that only matches after normalization" do
SiteSetting.normalize_emails = true
user.update!(email: "[email protected]")
alias_email = "[email protected]"
expect_not_enqueued_with(job: :send_email_login_code, args: { to_address: alias_email }) do
post "/session/login-code.json", params: honeypot_magic(email: alias_email)
end
expect(response.status).to eq(200)
expect(response.parsed_body["success"]).to eq("OK")
expect(EmailLoginCode.for_email(alias_email)).to be_empty
end
it "renders the same response for existing and unknown emails" do
post "/session/login-code.json", params: honeypot_magic(email: user.email)
expect(response.status).to eq(200)
existing_email_body = response.body
post "/session/login-code.json", params: honeypot_magic(email: "[email protected]")
expect(response.status).to eq(200)
expect(response.body).to eq(existing_email_body)
end
context "when the signup IP has reached the account limit" do
let(:ip_address) { "192.0.2.1" }
before do
Fabricate(:user, ip_address:, trust_level: TrustLevel[0])
SiteSetting.max_new_accounts_per_registration_ip = 1
end
it "returns the account limit error without sending a code for any email" do
expect_not_enqueued_with(job: :send_email_login_code) do
post "/session/login-code.json",
params: honeypot_magic(email: user.email, signup: true),
env: {
REMOTE_ADDR: ip_address,
}
existing_email_response = response.parsed_body
post "/session/login-code.json",
params: honeypot_magic(email: "[email protected]", signup: true),
env: {
REMOTE_ADDR: ip_address,
}
expect(response.status).to eq(200)
expect(response.parsed_body).to eq(existing_email_response)
expect(response.parsed_body["error"]).to eq(
I18n.t(
"activerecord.errors.models.user.attributes.ip_address.max_new_accounts_per_registration_ip",
),
)
end
expect(EmailLoginCode.count).to eq(0)
end
it "continues to send login codes for existing accounts" do
expect_enqueued_with(job: :send_email_login_code, args: { to_address: user.email }) do
post "/session/login-code.json",
params: honeypot_magic(email: user.email, signup: false),
env: {
REMOTE_ADDR: ip_address,
}
end
expect(response.status).to eq(200)
expect(response.parsed_body["success"]).to eq("OK")
expect(EmailLoginCode.for_email(user.email).count).to eq(1)
end
end
context "when rate limited" do
before { RateLimiter.enable }
it "rate limits requests per IP per minute" do
3.times do |i|
post "/session/login-code.json", params: { email: "user#{i}@example.com" }
expect(response.status).to eq(200)
end
post "/session/login-code.json", params: { email: "[email protected]" }
expect(response.status).to eq(429)
end
it "rate limits requests per email" do
freeze_time
3.times do
post "/session/login-code.json", params: { email: user.email }
expect(response.status).to eq(200)
freeze_time 2.minutes.from_now
end
post "/session/login-code.json", params: { email: user.email }
expect(response.status).to eq(429)
end
end
end
describe "#verify_login_code" do
let(:login_code) { EmailLoginCode.generate!(email: user.email) }
let(:code) { login_code.code }
before { SiteSetting.enable_local_logins_via_code = true }
def begin_discourse_connect_provider_handoff
sso = DiscourseConnectBase.new
sso.nonce = "handoffnonce"
sso.sso_secret = "topsecret"
sso.return_sso_url = "http://ask.example.com/sso"
SiteSetting.enable_discourse_connect_provider = true
SiteSetting.discourse_connect_provider_secrets = "ask.example.com|#{sso.sso_secret}"
cookies[:sso_payload] = sso.payload
sso.payload
end
it "returns a 404 when login via code is disabled" do
SiteSetting.enable_local_logins_via_code = false
post "/session/login-code/verify.json", params: { email: user.email, code: "123456" }
expect(response.status).to eq(404)
end
context "when local logins are disabled" do
before { SiteSetting.enable_local_logins = false }
it "returns a 404 because login via code is unavailable" do
post "/session/login-code/verify.json", params: { email: user.email, code: "123456" }
expect(response.status).to eq(404)
end
end
context "when email login is disabled" do
before { SiteSetting.enable_local_logins_via_email = false }
it "returns a 404 because login via code is unavailable" do
post "/session/login-code/verify.json", params: { email: user.email, code: "123456" }
expect(response.status).to eq(404)
end
end
context "when SSO is enabled" do
before do
SiteSetting.discourse_connect_url = "https://www.example.com/sso"
SiteSetting.discourse_connect_secret = "x" * 10
SiteSetting.enable_discourse_connect = true
end
it "returns a 403" do
post "/session/login-code/verify.json", params: { email: user.email, code: "123456" }
expect(response.status).to eq(403)
end
end
it "redirects home when the user is already logged in" do
sign_in(user)
post "/session/login-code/verify.json", params: { email: user.email, code: "123456" }
expect(response).to redirect_to("/")
end
it "returns a 400 for a malformed code" do
post "/session/login-code/verify.json", params: { email: user.email, code: "abc" }
expect(response.status).to eq(400)
end
it "renders an error when no code was requested" do
post "/session/login-code/verify.json", params: { email: user.email, code: "123456" }
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(I18n.t("email_login_code.invalid_code"))
expect(session[:current_user_id]).to be_nil
end
it "renders an error for a wrong code" do
wrong_code = code == "000000" ? "000001" : "000000"
post "/session/login-code/verify.json", params: { email: user.email, code: wrong_code }
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(I18n.t("email_login_code.invalid_code"))
expect(session[:current_user_id]).to be_nil
end
context "when the site is archived" do
before { SiteSetting.site_archived = true }
it "still logs in an existing user with a correct code" do
post "/session/login-code/verify.json", params: { email: user.email, code: }
expect(response.status).to eq(200)
expect(response.parsed_body.dig("user", "username")).to eq(user.username)
expect(session[:current_user_id]).to eq(user.id)
expect(EmailLoginCode.active.for_email(user.email)).to be_empty
end
it "does not create an account for an unknown email" do
new_email = "[email protected]"
new_code = EmailLoginCode.generate!(email: new_email)
expect do
post "/session/login-code/verify.json",
params: {
email: new_email,
code: new_code.code,
username: "archived-new-user",
}
end.not_to change { User.count }
expect(response.status).to eq(503)
expect(response.parsed_body["errors"]).to include(I18n.t("site_archived_error"))
expect(session[:current_user_id]).to be_nil
expect(EmailLoginCode.active.for_email(new_email)).not_to be_empty
end
end
it "logs in an existing user with a correct code" do
post "/session/login-code/verify.json", params: { email: user.email, code: }
expect(response.status).to eq(200)
expect(response.parsed_body.dig("user", "username")).to eq(user.username)
expect(session[:current_user_id]).to eq(user.id)
expect(EmailLoginCode.active.for_email(user.email)).to be_empty
end
context "when verifying a code for an email invite" do
let(:invite) { Fabricate(:invite, email: "[email protected]") }
let(:topic) { Fabricate(:topic) }
let(:login_code) { EmailLoginCode.generate!(email: invite.email) }
before { invite.update!(topics: [topic]) }
it "creates a passwordless account, redeems the invite, and returns its destination" do
post "/session/login-code/verify.json",
params: {
invite_key: invite.invite_key,
email: "[email protected]",
code:,
username: "invited-person",
}
invited_user = User.find_by_email(invite.email)
expect(response.status).to eq(200)
expect(response.parsed_body["account_created"]).to eq(true)
expect(response.parsed_body["redirect_url"]).to eq(topic.relative_url)
expect(session[:current_user_id]).to eq(invited_user.id)
expect(invited_user).to be_active
expect(invited_user).to be_email_confirmed
expect(invited_user.user_password).to be_nil
expect(invite.reload).to be_redeemed
expect(login_code.reload.consumed_at).to be_present
end
it "keeps the invite and code available until a username is chosen" do
post "/session/login-code/verify.json", params: { invite_key: invite.invite_key, code: }
expect(response.status).to eq(200)
expect(response.parsed_body["username_required"]).to eq(true)
expect(User.find_by_email(invite.email)).to be_nil
expect(session[:current_user_id]).to be_nil
expect(invite.reload).not_to be_redeemed
expect(login_code.reload.consumed_at).to be_nil
end
it "returns the invitee trust level for the deferred avatar selector" do
SiteSetting.default_trust_level = 0
SiteSetting.default_invitee_trust_level = 2
post "/session/login-code/verify.json", params: { invite_key: invite.invite_key, code: }
expect(response.status).to eq(200)
expect(response.parsed_body["username_required"]).to eq(true)
expect(response.parsed_body["trust_level"]).to eq(2)
end
it "activates an existing inactive invitee and keeps them signed in" do
user.update!(email: invite.email, active: false)
post "/session/login-code/verify.json", params: { invite_key: invite.invite_key, code: }
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to be_nil
expect(invite.reload).to be_redeemed
expect(login_code.reload.consumed_at).to be_present
get "/session/current.json"
expect(response.status).to eq(200)
expect(response.parsed_body.dig("current_user", "id")).to eq(user.id)
end
it "redeems an invite addressed to an existing user's secondary email" do
Fabricate(:secondary_email, user:, email: invite.email)
post "/session/login-code/verify.json", params: { invite_key: invite.invite_key, code: }
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to be_nil
expect(invite.reload).to be_redeemed
expect(login_code.reload.consumed_at).to be_present
get "/session/current.json"
expect(response.status).to eq(200)
expect(response.parsed_body.dig("current_user", "id")).to eq(user.id)
end
it "does not consume the code when the invite expires before verification" do
invite.update!(expires_at: 1.day.ago)
post "/session/login-code/verify.json", params: { invite_key: invite.invite_key, code: }
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(I18n.t("email_login_code.invalid_code"))
expect(session[:current_user_id]).to be_nil
expect(login_code.reload.consumed_at).to be_nil
end
end
it "explains when the user has already redeemed a reusable invite without consuming the code" do
invite = Fabricate(:invite, email: nil, max_redemptions_allowed: 5)
Fabricate(:invited_user, invite:, user:)
post "/session/login-code/verify.json",
params: {
invite_key: invite.invite_key,
email: user.email,
code:,
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(I18n.t("invite.existing_user_already_redemeed"))
expect(session[:current_user_id]).to be_nil
expect(login_code.reload.consumed_at).to be_nil
end
context "when verifying a code for a domain-scoped invite" do
let(:invite) { Fabricate(:invite, email: nil, domain: "allowed.example") }
let(:login_code) { EmailLoginCode.generate!(email: "[email protected]") }
it "accepts a verified secondary email when the primary email is outside the allowed domain" do
user.update!(email: "[email protected]")
secondary_email = Fabricate(:secondary_email, user:, email: "[email protected]")
secondary_code = EmailLoginCode.generate!(email: secondary_email.email)
post "/session/login-code/verify.json",
params: {
invite_key: invite.invite_key,
email: secondary_email.email,
code: secondary_code.code,
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to be_nil
expect(invite.reload).to be_redeemed
expect(secondary_code.reload.consumed_at).to be_present
get "/session/current.json"
expect(response.status).to eq(200)
expect(response.parsed_body.dig("current_user", "id")).to eq(user.id)
end
it "rejects an email outside the allowed domain without consuming its code" do
post "/session/login-code/verify.json",
params: {
invite_key: invite.invite_key,
email: login_code.email,
code:,
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(I18n.t("email_login_code.invalid_code"))
expect(session[:current_user_id]).to be_nil
expect(login_code.reload.consumed_at).to be_nil
end
end
context "when an existing invited user has TOTP enabled" do
let(:invite) { Fabricate(:invite, email: "[email protected]") }
let(:login_code) { EmailLoginCode.generate!(email: invite.email) }
let!(:user_second_factor) { Fabricate(:user_second_factor_totp, user:) }
before { user.update!(email: invite.email) }
it "requires the second factor before redeeming the invite" do
post "/session/login-code/verify.json", params: { invite_key: invite.invite_key, code: }
expect(response.status).to eq(200)
expect(response.parsed_body["second_factor_required"]).to eq(true)
expect(session[:current_user_id]).to be_nil
expect(invite.reload).not_to be_redeemed
expect(EmailLoginCode.active.for_email(invite.email)).to contain_exactly(login_code)
post "/session/login-code/verify.json",
params: {
invite_key: invite.invite_key,
code:,
second_factor_token: ROTP::TOTP.new(user_second_factor.data).now,
second_factor_method: UserSecondFactor.methods[:totp],
}
expect(response.status).to eq(200)
expect(session[:current_user_id]).to eq(user.id)
expect(invite.reload).to be_redeemed
expect(login_code.reload.consumed_at).to be_present
end
end
it "follows a pending DiscourseConnect provider handoff for an existing user" do
begin_discourse_connect_provider_handoff
post "/session/login-code/verify.json", params: { email: user.email, code: }
expect(response.status).to eq(302)
expect(response.location).to start_with("http://ask.example.com/sso")
end
context "when a pending DiscourseConnect provider handoff meets an invite" do
let(:invite) { Fabricate(:invite, email: "[email protected]") }
let(:login_code) { EmailLoginCode.generate!(email: invite.email) }
it "hands the provider URL to a newly created account instead of the invite topic" do
invite.update!(topics: [Fabricate(:topic)])
begin_discourse_connect_provider_handoff
post "/session/login-code/verify.json",
params: {
invite_key: invite.invite_key,
code:,
username: "invited-person",
}
expect(response.status).to eq(200)
expect(response.parsed_body["account_created"]).to eq(true)
expect(response.parsed_body["redirect_url"]).to include("/session/sso_provider?sso=")
expect(cookies[:sso_payload]).to be_blank
end
it "follows the handoff for an existing user rather than dropping it" do
user.update!(email: invite.email)
begin_discourse_connect_provider_handoff
post "/session/login-code/verify.json", params: { invite_key: invite.invite_key, code: }
expect(response.status).to eq(302)
expect(response.location).to start_with("http://ask.example.com/sso")
expect(session[:current_user_id]).to eq(user.id)
expect(invite.reload).to be_redeemed
expect(cookies[:sso_payload]).to be_blank
end
end
it "does not log in with a code issued for a normalized email alias" do
SiteSetting.normalize_emails = true
user.update!(email: "[email protected]")
alias_email = "[email protected]"
alias_login_code = EmailLoginCode.generate!(email: alias_email)
post "/session/login-code/verify.json",
params: {
email: alias_email,
code: alias_login_code.code,
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(I18n.t("email_login_code.invalid_code"))
expect(session[:current_user_id]).to be_nil
expect(alias_login_code.reload.consumed_at).to be_nil
end
it "does not log in a suspended user" do
user.update!(suspended_till: 2.days.from_now, suspended_at: Time.zone.now)
post "/session/login-code/verify.json", params: { email: user.email, code: }
expect(response.status).to eq(200)
expect(response.parsed_body["reason"]).to eq("suspended")
expect(session[:current_user_id]).to be_nil
end
it "shows the pending approval result for an existing unapproved user" do
SiteSetting.must_approve_users = true
post "/session/login-code/verify.json", params: { email: user.email, code: }
expect(response.status).to eq(200)
expect(response.parsed_body).to eq("pending_approval" => true)
expect(session[:current_user_id]).to be_nil
expect(login_code.reload.consumed_at).to be_present
end
context "when the email does not belong to a user" do
let(:login_code) { EmailLoginCode.generate!(email: "[email protected]") }
it "rejects caller-supplied reserved and route-conflicting usernames without consuming the code" do
%w[MoDeRaToR ACCOUNT-CREATED].each do |username|
post "/session/login-code/verify.json",
params: {
email: "[email protected]",
code:,
username:,
}
expect(response.parsed_body["username_errors"]).to include(
I18n.t("login.reserved_username"),
),
username
expect(User.find_by_email("[email protected]")).to be_nil
expect(ReviewableUser.count).to eq(0)
expect(session[:current_user_id]).to be_nil
expect(login_code.reload.consumed_at).to be_nil
end
post "/session/login-code/verify.json",
params: {
email: "[email protected]",
code:,
username: "valid-chosen-name",
}
expect(response.parsed_body["account_created"]).to eq(true)
expect(User.find_by_email("[email protected]").username).to eq("valid-chosen-name")
end
it "rejects reserved and route-conflicting usernames on an approval continuation" do
Jobs.run_immediately!
SiteSetting.must_approve_users = true
post "/session/login-code/verify.json", params: { email: "[email protected]", code: }
signup_token = response.parsed_body["signup_token"]
%w[MoDeRaToR ACCOUNT-CREATED].each do |username|
post "/session/login-code/verify.json", params: { signup_token:, username: }
expect(response.parsed_body["error"]).to include(I18n.t("login.reserved_username"))
expect(User.find_by_email("[email protected]")).to be_nil
expect(ReviewableUser.count).to eq(0)
expect(session[:current_user_id]).to be_nil
expect(login_code.reload.consumed_at).to be_nil
end
post "/session/login-code/verify.json",
params: {
signup_token:,
username: "valid-chosen-name",
}
expect(response.parsed_body).to eq("pending_approval" => true)
expect(User.find_by_email("[email protected]").username).to eq("valid-chosen-name")
expect(ReviewableUser.count).to eq(1)
end
it "collects identity before creating a passwordless account awaiting approval" do
Jobs.run_immediately!
SiteSetting.must_approve_users = true
SiteSetting.full_name_requirement = "required_at_signup"
user_field = Fabricate(:user_field, name: "Occupation")
post "/session/login-code/verify.json", params: { email: "[email protected]", code: }
signup_token = response.parsed_body["signup_token"]
expect(response.status).to eq(200)
expect(response.parsed_body["signup_details_required"]).to eq(true)
expect(response.parsed_body["username"]).to be_nil
expect(signup_token).to be_present
expect(User.find_by_email("[email protected]")).to be_nil
expect(session[:current_user_id]).to be_nil
expect(login_code.reload.consumed_at).to be_nil
post "/session/login-code/verify.json",
params: {
signup_token:,
username: "chosen-name",
name: "Chosen Name",
user_fields: {
user_field.id => "Engineer",
},
}
new_user = User.find_by_email("[email protected]")
reviewable = ReviewableUser.find_by(target: new_user)
expect(response.status).to eq(200)
expect(response.parsed_body).to eq("pending_approval" => true)
expect(new_user).to be_active
expect(new_user).not_to be_approved
expect(new_user.username).to eq("chosen-name")
expect(new_user.name).to eq("Chosen Name")
expect(new_user.custom_fields["user_field_#{user_field.id}"]).to eq("Engineer")
expect(new_user.user_password).to be_nil
expect(reviewable.payload.slice("username", "name")).to eq(
"username" => "chosen-name",
"name" => "Chosen Name",
)
expect(session[:current_user_id]).to be_nil
expect(login_code.reload.consumed_at).to be_present
end
it "allows correcting an invalid password without consuming the verified proof" do
SiteSetting.must_approve_users = true
post "/session/login-code/verify.json", params: { email: "[email protected]", code: }
signup_token = response.parsed_body["signup_token"]
post "/session/login-code/verify.json",
params: {
signup_token:,
username: "valid-name",
password: "x" * (User.max_password_length + 1),
}
expect(response.parsed_body["error"]).to be_present
expect(User.find_by_email("[email protected]")).to be_nil
expect(login_code.reload.consumed_at).to be_nil
post "/session/login-code/verify.json",
params: {
signup_token:,
username: "valid-name",
password: "short",
}
expect(response.parsed_body["password_error"]).to be_present
expect(User.find_by_email("[email protected]")).to be_nil
expect(login_code.reload.consumed_at).to be_nil
password = "a-secure-password-42!"
post "/session/login-code/verify.json",
params: {
signup_token:,
username: "valid-name",
password:,
}
expect(response.parsed_body).to eq("pending_approval" => true)
new_user = User.find_by_email("[email protected]")
expect(new_user.username).to eq("valid-name")
expect(new_user.confirm_password?(password)).to eq(true)
expect(session[:current_user_id]).to be_nil
end
it "rejects an expired or reused signup proof" do
SiteSetting.must_approve_users = true
post "/session/login-code/verify.json", params: { email: "[email protected]", code: }
signup_token = response.parsed_body["signup_token"]
freeze_time 11.minutes.from_now do
post "/session/login-code/verify.json", params: { signup_token:, username: "too-late" }
end
expect(response.parsed_body).to eq("error" => I18n.t("email_login_code.invalid_code"))
expect(User.find_by_email("[email protected]")).to be_nil
fresh_code = EmailLoginCode.generate!(email: "[email protected]")
post "/session/login-code/verify.json",
params: {
email: "[email protected]",
code: fresh_code.code,
}
fresh_token = response.parsed_body["signup_token"]
post "/session/login-code/verify.json",
params: {
signup_token: fresh_token,
username: "created-once",
}
expect(response.parsed_body).to eq("pending_approval" => true)
post "/session/login-code/verify.json",
params: {
signup_token: fresh_token,
username: "created-twice",
}
expect(response.parsed_body).to eq("error" => I18n.t("email_login_code.invalid_code"))
expect(UserEmail.where(email: "[email protected]").count).to eq(1)
expect(session[:current_user_id]).to be_nil
end
it "does not turn a signup continuation into an existing-account login" do
SiteSetting.must_approve_users = true
post "/session/login-code/verify.json", params: { email: "[email protected]", code: }
signup_token = response.parsed_body["signup_token"]
existing_user = Fabricate(:user, email: "[email protected]")
Fabricate(:user_second_factor_totp, user: existing_user)
post "/session/login-code/verify.json",
params: {
signup_token:,
username: "should-not-login",
}
expect(response.parsed_body).to eq("error" => I18n.t("email_login_code.invalid_code"))
expect(response.body).not_to include(existing_user.username)
expect(session[:current_user_id]).to be_nil
expect(login_code.reload.consumed_at).to be_nil
end
it "keeps auto-approved domains on the immediate account creation path" do
SiteSetting.must_approve_users = true
SiteSetting.auto_approve_email_domains = "example.com"
post "/session/login-code/verify.json",
params: {
email: " [email protected] ",
code:,
username: "newuser",
}
new_user = User.find_by_email("[email protected]")
expect(response.parsed_body["account_created"]).to eq(true)
expect(new_user).to be_approved
expect(session[:current_user_id]).to eq(new_user.id)
end
it "does not allow the client to enable generated username completion" do
post "/session/login-code/verify.json",
params: {
email: "[email protected]",
code:,
generated_username: true,
}
expect(response.parsed_body["username_required"]).to eq(true)
expect(response.parsed_body["generated_username"]).to eq(false)
expect(
request.server_session[SessionController::GENERATED_USERNAME_SIGNUP_INDEX_KEY],
).to be_nil
expect(User.find_by_email("[email protected]")).to be_nil
expect(login_code.reload.consumed_at).to be_nil
end
it "rejects invalid generated candidates and falls back to manual selection after bounded retries" do
plugin_instance = Plugin::Instance.new
modifier = proc { |_, _, _, _, _| :generated }
plugin_instance.register_modifier(:email_login_code_username_mode, &modifier)
UserNameSuggester.stubs(:suggest).returns("account-created")
RandomUsernameGenerator
.expects(:generate)
.times(4)
.returns("moderator", "account-created", "admin", "account-created")
post "/session/login-code/verify.json", params: { email: "[email protected]", code: }
expect(
response.parsed_body.slice("username_required", "generated_username", "username"),
).to eq("username_required" => true, "generated_username" => false, "username" => nil)
expect(login_code.reload.consumed_at).to be_nil
ensure
if plugin_instance && modifier
DiscoursePluginRegistry.unregister_modifier(
plugin_instance,
:email_login_code_username_mode,
&modifier
)
end
end
it "returns a fresh valid candidate when a generated username becomes route-conflicting" do
plugin_instance = Plugin::Instance.new
modifier = proc { |_, _, _, _, _| :generated }
plugin_instance.register_modifier(:email_login_code_username_mode, &modifier)
UserNameSuggester.stubs(:suggest).returns("first-candidate", "second-candidate")
UsernameValidator
.stubs(:clashing_with_existing_route?)
.with("first-candidate")
.returns(false, true)
UsernameValidator
.stubs(:clashing_with_existing_route?)
.with("second-candidate")
.returns(false)
post "/session/login-code/verify.json", params: { email: "[email protected]", code: }
post "/session/login-code/verify.json",
params: {
email: "[email protected]",
code:,
username: "first-candidate",
}
expect(
response.parsed_body.slice("username_required", "generated_username", "username"),
).to eq(
"username_required" => true,
"generated_username" => true,
"username" => "second-candidate",
)
expect(login_code.reload.consumed_at).to be_nil
ensure
if plugin_instance && modifier
DiscoursePluginRegistry.unregister_modifier(
plugin_instance,
:email_login_code_username_mode,
&modifier
)
end
end
it "returns a fresh generated candidate after a collision without consuming the code" do
plugin_instance = Plugin::Instance.new
modifier = proc { |_, _, _| :generated }
plugin_instance.register_modifier(:email_login_code_username_mode, &modifier)
UserNameSuggester.stubs(:suggest).returns("first-candidate", "second-candidate")
post "/session/login-code/verify.json", params: { email: "[email protected]", code: }
Fabricate(:user, username: response.parsed_body["username"])
post "/session/login-code/verify.json",
params: {
email: "[email protected]",
code:,
username: "first-candidate",
}
expect(
response.parsed_body.slice("username_required", "generated_username", "username"),
).to eq(
"username_required" => true,
"generated_username" => true,
"username" => "second-candidate",
)
expect(User.find_by_email("[email protected]")).to be_nil
expect(login_code.reload.consumed_at).to be_nil
post "/session/login-code/verify.json",
params: {
email: "[email protected]",
code:,
username: "second-candidate",
generated_username: false,
}
expect(response.parsed_body["account_created"]).to eq(true)
expect(User.find_by_email("[email protected]").username).to eq("second-candidate")
expect(
request.server_session[SessionController::GENERATED_USERNAME_SIGNUP_INDEX_KEY],
).to be_nil
expect(
request.server_session[
"#{SessionController::GENERATED_USERNAME_SIGNUP_KEY_PREFIX}#{login_code.id}"
],
).to be_nil
ensure
if plugin_instance && modifier
DiscoursePluginRegistry.unregister_modifier(
plugin_instance,
:email_login_code_username_mode,
&modifier
)
end
end
it "clears generated proofs when a different existing account authenticates" do
plugin_instance = Plugin::Instance.new
modifier = proc { |_, _, _, _, _| :generated }
plugin_instance.register_modifier(:email_login_code_username_mode, &modifier)
post "/session/login-code/verify.json", params: { email: "[email protected]", code: }
proof_key = "#{SessionController::GENERATED_USERNAME_SIGNUP_KEY_PREFIX}#{login_code.id}"
expect(request.server_session[proof_key]).to be_present
existing_user = Fabricate(:user, email: "[email protected]")
existing_code = EmailLoginCode.generate!(email: existing_user.email)
post "/session/login-code/verify.json",
params: {
email: existing_user.email,
code: existing_code.code,
}
expect(session[:current_user_id]).to eq(existing_user.id)
expect(request.server_session[proof_key]).to be_nil
expect(
request.server_session[SessionController::GENERATED_USERNAME_SIGNUP_INDEX_KEY],
).to be_nil
ensure
if plugin_instance && modifier
DiscoursePluginRegistry.unregister_modifier(
plugin_instance,
:email_login_code_username_mode,
&modifier
)
end
end
it "returns the default trust level for the deferred avatar selector" do
SiteSetting.default_trust_level = 1
SiteSetting.default_invitee_trust_level = 2
post "/session/login-code/verify.json", params: { email: "[email protected]", code: }
expect(response.status).to eq(200)
expect(response.parsed_body["username_required"]).to eq(true)
expect(response.parsed_body["trust_level"]).to eq(1)
end
it "tells the deferred avatar selector whether the avatar can be edited" do
post "/session/login-code/verify.json", params: { email: "[email protected]", code: }
expect(response.parsed_body["can_edit_avatar"]).to eq(true)
SiteSetting.auth_overrides_avatar = true
post "/session/login-code/verify.json", params: { email: "[email protected]", code: }
expect(response.parsed_body["can_edit_avatar"]).to eq(false)
end
it "waits for username selection before creating or authenticating an account" do
User.set_callback(:create, :after, :ensure_in_trust_level_group)
post "/session/login-code/verify.json", params: { email: "[email protected]", code: }
expect(response.status).to eq(200)
expect(response.parsed_body["username_required"]).to eq(true)
expect(response.parsed_body["username"]).to be_nil
expect(response.parsed_body["avatar_template"]).to be_nil
expect(User.find_by_email("[email protected]")).to be_nil
expect(session[:current_user_id]).to be_nil
expect(login_code.reload.consumed_at).to be_nil
post "/session/login-code/verify.json",
params: {
email: "[email protected]",
code:,
username: "chosen-name",
}
expect(response.status).to eq(200)
expect(response.parsed_body["account_created"]).to eq(true)
expect(response.parsed_body["can_upload_avatar"]).to eq(true)
new_user = User.find_by_email("[email protected]")
expect(new_user).to be_active
expect(new_user.username).to eq("chosen-name")
expect(session[:current_user_id]).to eq(new_user.id)
ensure
User.skip_callback(:create, :after, :ensure_in_trust_level_group)
end
it "rejects a taken username without creating an account or consuming the code" do
Fabricate(:user, username: "chosen-name")
post "/session/login-code/verify.json",
params: {
email: "[email protected]",
code:,
username: "chosen-name",
}
expect(response.status).to eq(200)
expect(response.parsed_body["username_errors"]).to be_present
expect(User.find_by_email("[email protected]")).to be_nil
expect(session[:current_user_id]).to be_nil
expect(login_code.reload.consumed_at).to be_nil
end
it "defers a pending DiscourseConnect provider handoff until signup is complete" do
payload = begin_discourse_connect_provider_handoff
post "/session/login-code/verify.json", params: { email: "[email protected]", code: }
expect(response.parsed_body["username_required"]).to eq(true)
expect(cookies[:sso_payload]).to be_present
expect(session[:current_user_id]).to be_nil
post "/session/login-code/verify.json",
params: {
email: "[email protected]",
code:,
username: "chosen-name",
}
body = response.parsed_body
expect(body["account_created"]).to eq(true)
expect(body["redirect_url"]).to end_with("/session/sso_provider?#{payload}")
expect(cookies[:sso_payload]).to be_blank
end
it "does not derive the username from the email when email-based suggestions are off" do
SiteSetting.enable_random_usernames = true
SiteSetting.use_email_for_username_and_name_suggestions = false
post "/session/login-code/verify.json", params: { email: "[email protected]", code: }
expect(response.parsed_body["username"]).to match(/\A[A-Z][a-z]+[A-Z][a-z]+\d+\z/)
end
it "leaves the suggestion blank when random generation yields nothing" do
SiteSetting.enable_random_usernames = true
SiteSetting.use_email_for_username_and_name_suggestions = false
# Unicode words pass validation while unicode usernames are on, then
# stop being usable once the site turns them off.
SiteSetting.unicode_usernames = true
SiteSetting.random_username_adjectives = "静か"
SiteSetting.random_username_nouns = "隼"
SiteSetting.unicode_usernames = false
post "/session/login-code/verify.json", params: { email: "[email protected]", code: }
expect(response.parsed_body["username_required"]).to eq(true)
expect(response.parsed_body["username"]).to be_nil
expect(User.find_by_email("[email protected]")).to be_nil
end
it "derives the username from the email when email-based suggestions are on" do
SiteSetting.use_email_for_username_and_name_suggestions = true
post "/session/login-code/verify.json", params: { email: "[email protected]", code: }
expect(response.parsed_body["username"]).to eq("newuser")
end
it "appends a numeric suffix when the email-derived name is taken" do
SiteSetting.use_email_for_username_and_name_suggestions = true
Fabricate(:user, username: "newuser")
post "/session/login-code/verify.json", params: { email: "[email protected]", code: }
expect(response.parsed_body["username"]).to eq("newuser1")
end
context "when the email can't produce a username suggestion" do
let(:login_code) { EmailLoginCode.generate!(email: "[email protected]") }
it "suggests a random username instead of the generic fallback" do
SiteSetting.enable_random_usernames = true
SiteSetting.use_email_for_username_and_name_suggestions = true
post "/session/login-code/verify.json", params: { email: "[email protected]", code: }
expect(response.parsed_body["username_required"]).to eq(true)
expect(response.parsed_body["username"]).to match(/\A[A-Z][a-z]+[A-Z][a-z]+\d+\z/)
end
end
it "renders an error when registrations are disabled" do
SiteSetting.allow_new_registrations = false
post "/session/login-code/verify.json", params: { email: "[email protected]", code: }
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(I18n.t("login.new_registrations_disabled"))
expect(session[:current_user_id]).to be_nil
end
it "renders the account limit error when the request IP has created too many accounts" do
ip_address = "192.0.2.1"
SiteSetting.max_new_accounts_per_registration_ip = 2
2.times { Fabricate(:user, ip_address:, trust_level: TrustLevel[0]) }
post "/session/login-code/verify.json",
params: {
email: "[email protected]",
code:,
username: "chosen-name",
},
env: {
REMOTE_ADDR: ip_address,
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(
I18n.t(
"activerecord.errors.models.user.attributes.ip_address.max_new_accounts_per_registration_ip",
),
)
expect(User.find_by_email("[email protected]")).to be_nil
expect(session[:current_user_id]).to be_nil
expect(login_code.reload.consumed_at).to be_nil
end
context "when required signup fields exist" do
fab!(:user_field)
it "asks for the fields without consuming the code, then creates the user with them" do
post "/session/login-code/verify.json", params: { email: "[email protected]", code: }
expect(response.status).to eq(200)
expect(response.parsed_body["user_fields_required"]).to eq(true)
expect(session[:current_user_id]).to be_nil
expect(EmailLoginCode.active.for_email("[email protected]")).to be_present
post "/session/login-code/verify.json",
params: {
email: "[email protected]",
code:,
user_fields: {
user_field.id.to_s => "Dev",
},
}
expect(response.parsed_body["username_required"]).to eq(true)
expect(User.find_by_email("[email protected]")).to be_nil
expect(login_code.reload.consumed_at).to be_nil
post "/session/login-code/verify.json",
params: {
email: "[email protected]",
code:,
username: "chosen-name",
user_fields: {
user_field.id.to_s => "Dev",
},
}
new_user = User.find_by_email("[email protected]")
expect(new_user.custom_fields["user_field_#{user_field.id}"]).to eq("Dev")
expect(session[:current_user_id]).to eq(new_user.id)
end
it "renders an error when the required fields are missing" do
post "/session/login-code/verify.json",
params: {
email: "[email protected]",
code:,
username: "chosen-name",
user_fields: {
"0" => "",
},
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(I18n.t("login.missing_user_field"))
expect(session[:current_user_id]).to be_nil
end
end
context "when a full name is required at signup" do
before { SiteSetting.full_name_requirement = "required_at_signup" }
it "asks for the name without consuming the code, then creates the user with it" do
post "/session/login-code/verify.json", params: { email: "[email protected]", code: }
expect(response.status).to eq(200)
expect(response.parsed_body["name_required"]).to eq(true)
expect(response.parsed_body["user_fields_required"]).to eq(false)
expect(session[:current_user_id]).to be_nil
expect(EmailLoginCode.active.for_email("[email protected]")).to be_present
post "/session/login-code/verify.json",
params: {
email: "[email protected]",
code:,
name: "Jane Doe",
}
expect(response.parsed_body["username_required"]).to eq(true)
expect(User.find_by_email("[email protected]")).to be_nil
expect(login_code.reload.consumed_at).to be_nil
post "/session/login-code/verify.json",
params: {
email: "[email protected]",
code:,
username: "chosen-name",
name: "Jane Doe",
}
new_user = User.find_by_email("[email protected]")
expect(new_user.name).to eq("Jane Doe")
expect(session[:current_user_id]).to eq(new_user.id)
end
it "renders the contract errors when the name is too long" do
post "/session/login-code/verify.json",
params: {
email: "[email protected]",
code:,
username: "chosen-name",
name: "a" * 256,
}
expect(response.status).to eq(400)
expect(response.parsed_body["errors"].join).to include("Name")
expect(session[:current_user_id]).to be_nil
expect(User.find_by_email("[email protected]")).to be_nil
end
it "asks for the name again when a blank name is submitted" do
post "/session/login-code/verify.json",
params: {
email: "[email protected]",
code:,
username: "chosen-name",
name: " ",
}
expect(response.status).to eq(200)
expect(response.parsed_body["name_required"]).to eq(true)
expect(session[:current_user_id]).to be_nil
expect(User.find_by_email("[email protected]")).to be_nil
end
end
end
context "when the user has TOTP enabled" do
let!(:user_second_factor) { Fabricate(:user_second_factor_totp, user: user) }
it "requires a second factor without consuming the code" do
post "/session/login-code/verify.json", params: { email: user.email, code: }
expect(response.status).to eq(200)
expect(response.parsed_body["second_factor_required"]).to eq(true)
expect(response.parsed_body["totp_enabled"]).to eq(true)
expect(session[:current_user_id]).to be_nil
expect(EmailLoginCode.active.for_email(user.email)).to contain_exactly(login_code)
end
it "logs in with a valid TOTP token" do
post "/session/login-code/verify.json", params: { email: user.email, code: }
expect(session[:current_user_id]).to be_nil
post "/session/login-code/verify.json",
params: {
email: user.email,
code:,
second_factor_token: ROTP::TOTP.new(user_second_factor.data).now,
second_factor_method: UserSecondFactor.methods[:totp],
}
expect(response.status).to eq(200)
expect(session[:current_user_id]).to eq(user.id)
end
it "rejects an invalid TOTP token" do
post "/session/login-code/verify.json",
params: {
email: user.email,
code:,
second_factor_token: "0000",
second_factor_method: UserSecondFactor.methods[:totp],
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(I18n.t("login.invalid_second_factor_code"))
expect(session[:current_user_id]).to be_nil
end
end
end
describe "logoff support" do
it "can log off users cleanly" do
user = Fabricate(:user)
sign_in(user)
UserAuthToken.destroy_all
# we need a route that will call current user
post "/drafts.json", params: {}
expect(response.headers["Discourse-Logged-Out"]).to eq("1")
end
end
describe "#become" do
let!(:user) { Fabricate(:user) }
describe "when in production mode" do
before { Rails.env.stubs(:production?).returns(true) }
it "does not work" do
get "/session/#{user.username}/become"
expect(response.status).to eq(403)
expect(session[:current_user_id]).to be_blank
end
end
describe "when in development mode" do
before { Rails.env.stubs(:development?).returns(true) }
it "signs in as the requested user" do
get "/session/#{user.username}/become"
expect(response).to be_redirect
expect(session[:current_user_id]).to eq(user.id)
end
it "raises an error if the user is not found" do
get "/session/invalid_user/become"
expect(response.status).to eq(403)
expect(response.body).to include("User invalid_user not found")
expect(session[:current_user_id]).to be_blank
end
it "raises an error if the user is not active" do
user.update!(active: false)
get "/session/#{user.username}/become"
expect(response.status).to eq(403)
expect(response.body).to include("User #{user.username} is not active")
expect(session[:current_user_id]).to be_blank
end
it "does not replay a queued anonymous action" do
AnonymousAction.expects(:consume).never
get "/session/#{user.username}/become"
expect(response).to be_redirect
end
end
end
describe "#sso" do
before do
SiteSetting.discourse_connect_url = "http://example.com/discourse_sso"
SiteSetting.discourse_connect_secret = "shjkfdhsfkjh"
SiteSetting.enable_discourse_connect = true
end
it "redirects correctly" do
get "/session/sso"
expect(response.status).to eq(302)
expect(response.location).to start_with(SiteSetting.discourse_connect_url)
end
end
describe "#sso_login" do
before do
@sso_url = "http://example.com/discourse_sso"
@sso_secret = "shjkfdhsfkjh"
SiteSetting.discourse_connect_url = @sso_url
SiteSetting.discourse_connect_secret = @sso_secret
SiteSetting.enable_discourse_connect = true
Fabricate(:admin)
end
let(:headers) { { host: Discourse.current_hostname } }
def get_sso(return_path)
nonce = SecureRandom.hex
dso = DiscourseConnect.new(server_session:)
dso.nonce = nonce
dso.register_nonce(return_path)
sso = DiscourseConnectBase.new
sso.nonce = nonce
sso.sso_secret = @sso_secret
sso
end
context "when the configured secret is blank" do
before { SiteSetting.discourse_connect_secret = "" }
it "rejects a payload signed with an empty secret without logging in or creating a user" do
sso = get_sso("/")
sso.sso_secret = ""
sso.external_id = "1337"
sso.email = "[email protected]"
sso.name = "Some One"
sso.username = "someone"
sso.admin = true
expect {
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
}.not_to change { User.count }
expect(response.status).to eq(422)
logged_on_user = Discourse.current_user_provider.new(request.env).current_user
expect(logged_on_user).to eq(nil)
end
end
context "when in staff writes only mode" do
before { Discourse.enable_readonly_mode(Discourse::STAFF_WRITES_ONLY_MODE_KEY) }
it "allows staff to login" do
sso = get_sso("/a/")
sso.external_id = "666"
sso.email = "[email protected]"
sso.name = "Bob Bobson"
sso.username = "bob"
sso.admin = true
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
logged_on_user = Discourse.current_user_provider.new(request.env).current_user
expect(logged_on_user).not_to eq(nil)
end
it 'doesn\'t allow non-staff to login' do
sso = get_sso("/a/")
sso.external_id = "666"
sso.email = "[email protected]"
sso.name = "Bob Bobson"
sso.username = "bob"
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
logged_on_user = Discourse.current_user_provider.new(request.env).current_user
expect(logged_on_user).to eq(nil)
end
end
context "when the site is archived" do
before { SiteSetting.site_archived = true }
it "allows an existing user to log in via DiscourseConnect" do
existing = Fabricate(:user, email: "[email protected]")
Fabricate(:single_sign_on_record, user: existing, external_id: "existing-external-id")
sso = get_sso("/a/")
sso.external_id = "existing-external-id"
sso.email = "[email protected]"
sso.username = existing.username
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
expect(response.status).not_to eq(503)
logged_on_user = Discourse.current_user_provider.new(request.env).current_user
expect(logged_on_user&.id).to eq(existing.id)
end
it "does not create a new user via DiscourseConnect (archive blocks account creation)" do
sso = get_sso("/a/")
sso.external_id = "666"
sso.email = "[email protected]"
sso.name = "Bob Bobson"
sso.username = "bob"
expect do
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
end.not_to change { User.count }
logged_on_user = Discourse.current_user_provider.new(request.env).current_user
expect(logged_on_user).to eq(nil)
end
end
it "does not create superfluous auth tokens when already logged in" do
user = Fabricate(:user)
sign_in(user)
sso = get_sso("/")
sso.email = user.email
sso.external_id = "abc"
sso.username = "sam"
expect do
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
logged_on_user = Discourse.current_user_provider.new(request.env).current_user
expect(logged_on_user.id).to eq(user.id)
end.not_to change { UserAuthToken.count }
end
it "never redirects back to the SSO path" do
sso = get_sso("/session/sso?bla=1")
sso.email = user.email
sso.external_id = "abc"
sso.username = "sam"
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
expect(response).to redirect_to("/")
sso = get_sso("http://#{Discourse.current_hostname}/session/sso?bla=1")
sso.email = user.email
sso.external_id = "abc"
sso.username = "sam"
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
expect(response).to redirect_to("/")
end
it "can handle invalid sso external ids due to blank" do
sso = get_sso("/")
sso.email = "[email protected]"
sso.external_id = " "
sso.username = "sam"
logger =
track_log_messages do
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
end
expect(logger.warnings.length).to eq(0)
expect(logger.errors.length).to eq(0)
expect(logger.fatals.length).to eq(0)
expect(response.status).to eq(500)
expect(response.body).to include(I18n.t("discourse_connect.blank_id_error"))
end
it "can handle invalid sso email validation errors" do
SiteSetting.blocked_email_domains = "test.com"
sso = get_sso("/")
sso.email = "[email protected]"
sso.external_id = "123"
sso.username = "sam"
logger =
track_log_messages do
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
end
expect(logger.warnings.length).to eq(0)
expect(logger.errors.length).to eq(0)
expect(logger.fatals.length).to eq(0)
expect(response.status).to eq(500)
expect(response.body).to include(
I18n.t("discourse_connect.email_error", email: ERB::Util.html_escape("[email protected]")),
)
end
it "can handle invalid sso external ids due to banned word" do
sso = get_sso("/")
sso.email = "[email protected]"
sso.external_id = "nil"
sso.username = "sam"
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
expect(response.status).to eq(500)
end
it "can take over an account" do
user = Fabricate(:user, email: "[email protected]")
sso = get_sso("/")
sso.email = user.email
sso.external_id = "abc"
sso.username = "sam"
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
expect(response).to redirect_to("/")
logged_on_user = Discourse.current_user_provider.new(request.env).current_user
expect(logged_on_user.email).to eq(user.email)
expect(logged_on_user.single_sign_on_record.external_id).to eq("abc")
expect(logged_on_user.single_sign_on_record.external_username).to eq("sam")
# we are updating the email ... ensure auto group membership works
sign_out
SiteSetting.email_editable = false
SiteSetting.auth_overrides_email = true
group = Fabricate(:group, name: :bob, automatic_membership_email_domains: "jane.com")
sso = get_sso("/")
sso.email = "[email protected]"
sso.external_id = "abc"
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
logged_on_user = Discourse.current_user_provider.new(request.env).current_user
expect(logged_on_user.email).to eq("[email protected]")
expect(group.users.count).to eq(1)
end
def sso_for_ip_specs
sso = get_sso("/a/")
sso.external_id = "666"
sso.email = "[email protected]"
sso.name = "Sam Saffron"
sso.username = "sam"
sso
end
it "respects IP restrictions on create" do
ScreenedIpAddress.all.destroy_all
get "/"
_screened_ip =
Fabricate(
:screened_ip_address,
ip_address: request.remote_ip,
action_type: ScreenedIpAddress.actions[:block],
)
sso = sso_for_ip_specs
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
logged_on_user = Discourse.current_user_provider.new(request.env).current_user
expect(logged_on_user).to eq(nil)
end
it "respects IP restrictions on login" do
ScreenedIpAddress.all.destroy_all
get "/"
sso = sso_for_ip_specs
DiscourseConnect.parse(sso.payload, server_session:).lookup_or_create_user(request.remote_ip)
sso = sso_for_ip_specs
_screened_ip =
Fabricate(
:screened_ip_address,
ip_address: request.remote_ip,
action_type: ScreenedIpAddress.actions[:block],
)
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
logged_on_user = Discourse.current_user_provider.new(request.env).current_user
expect(logged_on_user).to be_blank
end
it "respects email restrictions" do
sso = get_sso("/a/")
sso.external_id = "666"
sso.email = "[email protected]"
sso.name = "Sam Saffron"
sso.username = "sam"
ScreenedEmail.block("[email protected]")
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
logged_on_user = Discourse.current_user_provider.new(request.env).current_user
expect(logged_on_user).to eq(nil)
end
it "allows you to create an admin account" do
sso = get_sso("/a/")
sso.external_id = "666"
sso.email = "[email protected]"
sso.name = "Sam Saffron"
sso.username = "sam"
sso.custom_fields["shop_url"] = "http://my_shop.com"
sso.custom_fields["shop_name"] = "Sam"
sso.admin = true
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
logged_on_user = Discourse.current_user_provider.new(request.env).current_user
expect(logged_on_user.admin).to eq(true)
end
it "does not redirect offsite" do
sso = get_sso("#{Discourse.base_url}//site.com/xyz")
sso.external_id = "666"
sso.email = "[email protected]"
sso.name = "Sam Saffron"
sso.username = "sam"
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
expect(response).to redirect_to("#{Discourse.base_url}//site.com/xyz")
end
it "redirects to a non-relative url" do
sso = get_sso("#{Discourse.base_url}/b/")
sso.external_id = "666"
sso.email = "[email protected]"
sso.name = "Sam Saffron"
sso.username = "sam"
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
expect(response).to redirect_to("/b/")
end
it "redirects to random url if it is allowed" do
SiteSetting.discourse_connect_allowed_redirect_domains = "gusundtrout.com|foobar.com"
sso = get_sso("https://gusundtrout.com")
sso.external_id = "666"
sso.email = "[email protected]"
sso.name = "Sam Saffron"
sso.username = "sam"
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
expect(response).to redirect_to("https://gusundtrout.com")
end
it "allows wildcard character to redirect to any domain" do
SiteSetting.discourse_connect_allowed_redirect_domains = "*|foo.com"
sso = get_sso("https://foobar.com")
sso.external_id = "666"
sso.email = "[email protected]"
sso.name = "Sam Saffron"
sso.username = "sam"
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
expect(response).to redirect_to("https://foobar.com")
end
it "does not allow wildcard character in domains" do
SiteSetting.discourse_connect_allowed_redirect_domains = "*.foobar.com|foobar.com"
sso = get_sso("https://sub.foobar.com")
sso.external_id = "666"
sso.email = "[email protected]"
sso.name = "Sam Saffron"
sso.username = "sam"
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
expect(response).to redirect_to("/")
end
it "redirects protocol-relative external return paths to root" do
sso = get_sso("//eviltrout.com")
sso.external_id = "666"
sso.email = "[email protected]"
sso.name = "Sam Saffron"
sso.username = "sam"
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
expect(response).to redirect_to("/")
end
it "redirects absolute external return paths to root" do
sso = get_sso("http://eviltrout.com")
sso.external_id = "666"
sso.email = "[email protected]"
sso.name = "Sam Saffron"
sso.username = "sam"
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
expect(response).to redirect_to("/")
end
it "creates a user but ignores auto_approve_email_domains site setting when must_approve_users site setting is not enabled" do
SiteSetting.auto_approve_email_domains = "discourse.com"
sso = get_sso("/a/")
sso.external_id = "666"
sso.email = "[email protected]"
sso.name = "Sam Saffron"
sso.username = "sam"
events =
DiscourseEvent.track_events do
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
expect(response).to redirect_to("/a/")
end
expect(events.map { |event| event[:event_name] }).to include(
:user_logged_in,
:user_first_logged_in,
)
logged_on_user = Discourse.current_user_provider.new(request.env).current_user
# ensure nothing is transient
logged_on_user = User.find(logged_on_user.id)
expect(logged_on_user.admin).to eq(false)
expect(logged_on_user.email).to eq("[email protected]")
expect(logged_on_user.name).to eq("Sam Saffron")
expect(logged_on_user.username).to eq("sam")
expect(logged_on_user.approved).to eq(false)
expect(logged_on_user.active).to eq(true)
expect(logged_on_user.single_sign_on_record.external_id).to eq("666")
expect(logged_on_user.single_sign_on_record.external_username).to eq("sam")
end
context "when must_approve_users site setting has been enabled" do
before { SiteSetting.must_approve_users = true }
it "creates a user but does not approve when user's email domain does not match a domain in auto_approve_email_domains site settings" do
SiteSetting.auto_approve_email_domains = "discourse.com"
sso = get_sso("/a/")
sso.external_id = "666"
sso.email = "[email protected]"
sso.name = "Sam Saffron"
sso.username = "sam"
expect do
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
expect(response.status).to eq(403)
expect(response.body).to include(I18n.t("discourse_connect.account_not_approved"))
end.to change { User.count }.by(1)
logged_on_user = Discourse.current_user_provider.new(request.env).current_user
expect(logged_on_user).to eq(nil)
user = User.last
expect(user.admin).to eq(false)
expect(user.email).to eq("[email protected]")
expect(user.name).to eq("Sam Saffron")
expect(user.username).to eq("sam")
expect(user.approved).to eq(false)
expect(user.active).to eq(true)
expect(user.single_sign_on_record.external_id).to eq("666")
expect(user.single_sign_on_record.external_username).to eq("sam")
end
it "creates and approves a user when user's email domain matches a domain in auto_approve_email_domains site settings" do
SiteSetting.auto_approve_email_domains = "discourse.com"
sso = get_sso("/a/")
sso.external_id = "666"
sso.email = "[email protected]"
sso.name = "Sam Saffron"
sso.username = "sam"
events =
DiscourseEvent.track_events do
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
expect(response).to redirect_to("/a/")
end
expect(events.map { |event| event[:event_name] }).to include(
:user_logged_in,
:user_first_logged_in,
)
logged_on_user = Discourse.current_user_provider.new(request.env).current_user
# ensure nothing is transient
logged_on_user = User.find(logged_on_user.id)
expect(logged_on_user.admin).to eq(false)
expect(logged_on_user.email).to eq("[email protected]")
expect(logged_on_user.name).to eq("Sam Saffron")
expect(logged_on_user.username).to eq("sam")
expect(logged_on_user.approved).to eq(true)
expect(logged_on_user.active).to eq(true)
expect(logged_on_user.single_sign_on_record.external_id).to eq("666")
expect(logged_on_user.single_sign_on_record.external_username).to eq("sam")
end
end
it "allows you to create an account" do
group = Fabricate(:group, name: :bob, automatic_membership_email_domains: "bob.com")
sso = get_sso("/a/")
sso.external_id = "666"
sso.email = "[email protected]"
sso.name = "Sam Saffron"
sso.username = "sam"
sso.custom_fields["shop_url"] = "http://my_shop.com"
sso.custom_fields["shop_name"] = "Sam"
events =
DiscourseEvent.track_events do
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
end
expect(events.map { |event| event[:event_name] }).to include(
:user_logged_in,
:user_first_logged_in,
)
expect(response).to redirect_to("/a/")
logged_on_user = Discourse.current_user_provider.new(request.env).current_user
expect(group.users.where(id: logged_on_user.id).count).to eq(1)
# ensure nothing is transient
logged_on_user = User.find(logged_on_user.id)
expect(logged_on_user.admin).to eq(false)
expect(logged_on_user.email).to eq("[email protected]")
expect(logged_on_user.name).to eq("Sam Saffron")
expect(logged_on_user.username).to eq("sam")
expect(logged_on_user.single_sign_on_record.external_id).to eq("666")
expect(logged_on_user.single_sign_on_record.external_username).to eq("sam")
expect(logged_on_user.active).to eq(true)
expect(logged_on_user.custom_fields["shop_url"]).to eq("http://my_shop.com")
expect(logged_on_user.custom_fields["shop_name"]).to eq("Sam")
expect(logged_on_user.custom_fields["bla"]).to eq(nil)
end
context "when an invitation is used" do
let(:invite) { Fabricate(:invite, email: invite_email, invited_by: Fabricate(:admin)) }
let(:invite_email) { nil }
def login_with_sso_and_invite(invite_key = invite.invite_key)
server_session["invite-key"] = invite_key
sso = get_sso("/")
sso.external_id = "666"
sso.email = "[email protected]"
sso.name = "Sam Saffron"
sso.username = "sam"
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers:
end
it "errors if the invite key is invalid" do
login_with_sso_and_invite("wrong")
expect(response.status).to eq(400)
expect(response.body).to include(I18n.t("invite.not_found", base_url: Discourse.base_url))
expect(invite.reload.redeemed?).to eq(false)
expect(User.find_by_email("[email protected]")).to eq(nil)
end
it "errors if the invite has expired" do
invite.update!(expires_at: 3.days.ago)
login_with_sso_and_invite
expect(response.status).to eq(400)
expect(response.body).to include(I18n.t("invite.expired", base_url: Discourse.base_url))
expect(invite.reload.redeemed?).to eq(false)
expect(User.find_by_email("[email protected]")).to eq(nil)
end
it "errors if the invite has been redeemed already" do
invite.update!(max_redemptions_allowed: 1, redemption_count: 1)
login_with_sso_and_invite
expect(response.status).to eq(400)
expect(response.body).to include(
I18n.t(
"invite.not_found_template",
site_name: SiteSetting.title,
base_url: Discourse.base_url,
),
)
expect(invite.reload.redeemed?).to eq(true)
expect(User.find_by_email("[email protected]")).to eq(nil)
end
it "errors if the invite is for a specific email and that email does not match the sso email" do
invite.update!(email: "[email protected]")
login_with_sso_and_invite
expect(response.status).to eq(400)
expect(response.body).to include(
I18n.t("invite.not_matching_email", base_url: Discourse.base_url),
)
expect(invite.reload.redeemed?).to eq(false)
expect(User.find_by_email("[email protected]")).to eq(nil)
end
it "allows you to create an account and redeems the invite successfully, clearing the invite-key session" do
login_with_sso_and_invite
expect(response.status).to eq(302)
expect(response).to redirect_to("/")
expect(invite.reload.redeemed?).to eq(true)
user = User.find_by_email("[email protected]")
expect(user.active).to eq(true)
expect(session[:current_user_id]).to eq(user.id)
expect(server_session["invite-key"]).to eq(nil)
end
it "creates the user account and redeems the invite but does not approve the user if must_approve_users is enabled" do
SiteSetting.must_approve_users = true
login_with_sso_and_invite
expect(response.status).to eq(403)
expect(response.body).to include(I18n.t("discourse_connect.account_not_approved"))
expect(invite.reload.redeemed?).to eq(true)
user = User.find_by_email("[email protected]")
expect(user.active).to eq(true)
expect(user.approved).to eq(false)
end
it "redirects to the topic associated to the invite" do
topic_invite = TopicInvite.create!(invite: invite, topic: Fabricate(:topic))
login_with_sso_and_invite
expect(response.status).to eq(302)
expect(response).to redirect_to(topic_invite.topic.relative_url)
end
it "adds the user to the appropriate invite groups" do
invited_group = InvitedGroup.create!(invite: invite, group: Fabricate(:group))
login_with_sso_and_invite
expect(invite.reload.redeemed?).to eq(true)
user = User.find_by_email("[email protected]")
expect(GroupUser.exists?(user: user, group: invited_group.group)).to eq(true)
end
end
context "when sso emails are not trusted" do
context "if you have not activated your account" do
it "does not log you in" do
sso = get_sso("/a/")
sso.external_id = "666"
sso.email = "[email protected]"
sso.name = "Sam Saffron"
sso.username = "sam"
sso.require_activation = true
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
logged_on_user = Discourse.current_user_provider.new(request.env).current_user
expect(logged_on_user).to eq(nil)
end
it "sends an activation email" do
sso = get_sso("/a/")
sso.external_id = "666"
sso.email = "[email protected]"
sso.name = "Sam Saffron"
sso.username = "sam"
sso.require_activation = true
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
expect(Jobs::CriticalUserEmail.jobs.size).to eq(1)
end
end
context "if you have activated your account" do
it "allows you to log in" do
sso = get_sso("/hello/world")
sso.external_id = "997"
sso.sso_url = "http://somewhere.over.com/sso_login"
sso.require_activation = true
user = Fabricate(:user)
user.create_single_sign_on_record(external_id: "997", last_payload: "")
user.stubs(:active?).returns(true)
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
logged_on_user = Discourse.current_user_provider.new(request.env).current_user
expect(user.id).to eq(logged_on_user.id)
end
end
end
it "allows login to existing account with valid nonce" do
sso = get_sso("/hello/world")
sso.external_id = "997"
sso.sso_url = "http://somewhere.over.com/sso_login"
user = Fabricate(:user)
user.create_single_sign_on_record(external_id: "997", last_payload: "")
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
user.single_sign_on_record.reload
expect(user.single_sign_on_record.last_payload).to eq(sso.unsigned_payload)
expect(response).to redirect_to("/hello/world")
logged_on_user = Discourse.current_user_provider.new(request.env).current_user
expect(user.id).to eq(logged_on_user.id)
# nonce is bad now
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
expect(response.status).to eq(419)
end
it "associates the nonce with the current session" do
sso = get_sso("/hello/world")
sso.external_id = "997"
sso.sso_url = "http://somewhere.over.com/sso_login"
user = Fabricate(:user)
user.create_single_sign_on_record(external_id: "997", last_payload: "")
# Establish a fresh session
cookies.to_hash.keys.each { |k| cookies.delete(k) }
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
expect(response.status).to eq(419)
end
context "when sso provider is enabled" do
before do
SiteSetting.enable_discourse_connect_provider = true
SiteSetting.discourse_connect_provider_secrets = %w[
*|secret,forAll
*.rainbow|wrongSecretForOverRainbow
www.random.site|secretForRandomSite
somewhere.over.rainbow|secretForOverRainbow
].join("\n")
end
it "doesn't break" do
sso = get_sso("/hello/world")
sso.external_id = "997"
sso.sso_url = "http://somewhere.over.com/sso_login"
sso.return_sso_url = "http://someurl.com"
user = Fabricate(:user)
user.create_single_sign_on_record(external_id: "997", last_payload: "")
get "/session/sso_login", params: Rack::Utils.parse_query(sso.payload), headers: headers
user.single_sign_on_record.reload
expect(user.single_sign_on_record.last_payload).to eq(sso.unsigned_payload)
expect(response).to redirect_to("/hello/world")
logged_on_user = Discourse.current_user_provider.new(request.env).current_user
expect(user.id).to eq(logged_on_user.id)
end
end
it "returns the correct error code for invalid payload" do
sso = get_sso("/hello/world")
sso.external_id = "997"
sso.sso_url = "http://somewhere.over.com/sso_login"
params = Rack::Utils.parse_query(sso.payload)
params["sso"] = "#{params["sso"]}%3C"
params["sig"] = sso.sign(params["sso"])
get "/session/sso_login", params: params, headers: headers
expect(response.status).to eq(422)
expect(response.body).to include(I18n.t("discourse_connect.payload_parse_error"))
logged_on_user = Discourse.current_user_provider.new(request.env).current_user
expect(logged_on_user).to eq(nil)
end
it "returns the correct error code for invalid signature" do
sso = get_sso("/hello/world")
sso.external_id = "997"
sso.sso_url = "http://somewhere.over.com/sso_login"
correct_params = Rack::Utils.parse_query(sso.payload)
get "/session/sso_login",
params: correct_params.merge(sig: "thisisnotthesigyouarelookingfor"),
headers: headers
expect(response.status).to eq(422)
expect(response.body).to include(I18n.t("discourse_connect.signature_error"))
expect(response.body).not_to include(correct_params["sig"]) # Check we didn't send the real sig back to the client
logged_on_user = Discourse.current_user_provider.new(request.env).current_user
expect(logged_on_user).to eq(nil)
correct_params = Rack::Utils.parse_query(sso.payload)
get "/session/sso_login",
params: correct_params.merge(sig: "thisisasignaturewith@special!characters"),
headers: headers
expect(response.status).to eq(422)
expect(response.body).not_to include(correct_params["sig"]) # Check we didn't send the real sig back to the client
logged_on_user = Discourse.current_user_provider.new(request.env).current_user
expect(logged_on_user).to eq(nil)
end
describe "local attribute override from SSO payload" do
before do
SiteSetting.email_editable = false
SiteSetting.auth_overrides_email = true
SiteSetting.auth_overrides_username = true
SiteSetting.auth_overrides_name = true
@user = Fabricate(:user)
@sso = get_sso("/hello/world")
@sso.external_id = "997"
@reversed_username = @user.username.reverse
@sso.username = @reversed_username
@sso.email = "#{@reversed_username}@garbage.org"
@reversed_name = @user.name.reverse
@sso.name = @reversed_name
@suggested_username = UserNameSuggester.suggest(@sso.username || @sso.name || @sso.email)
@suggested_name = User.suggest_name(@sso.name || @sso.username || @sso.email)
@user.create_single_sign_on_record(external_id: "997", last_payload: "")
end
it "stores the external attributes" do
get "/session/sso_login", params: Rack::Utils.parse_query(@sso.payload), headers: headers
@user.single_sign_on_record.reload
expect(@user.single_sign_on_record.external_username).to eq(@sso.username)
expect(@user.single_sign_on_record.external_email).to eq(@sso.email)
expect(@user.single_sign_on_record.external_name).to eq(@sso.name)
end
it "overrides attributes" do
get "/session/sso_login", params: Rack::Utils.parse_query(@sso.payload), headers: headers
logged_on_user = Discourse.current_user_provider.new(request.env).current_user
expect(logged_on_user.username).to eq(@suggested_username)
expect(logged_on_user.email).to eq("#{@reversed_username}@garbage.org")
expect(logged_on_user.name).to eq(@sso.name)
end
it "does not change matching attributes for an existing account" do
@sso.username = @user.username
@sso.name = @user.name
@sso.email = @user.email
get "/session/sso_login", params: Rack::Utils.parse_query(@sso.payload), headers: headers
logged_on_user = Discourse.current_user_provider.new(request.env).current_user
expect(logged_on_user.username).to eq(@user.username)
expect(logged_on_user.name).to eq(@user.name)
expect(logged_on_user.email).to eq(@user.email)
end
end
context "when in readonly mode" do
before { Discourse.enable_readonly_mode }
it "disallows requests" do
get "/session/sso_login"
expect(response.status).to eq(503)
end
end
end
describe "#sso_provider" do
let(:headers) { { host: Discourse.current_hostname } }
let(:logo_fixture) { "http://#{Discourse.current_hostname}/uploads/logo.png" }
fab!(:user) { Fabricate(:user, password: "myfrogs123ADMIN", active: true, admin: true) }
before do
stub_request(:any, %r{#{Discourse.current_hostname}/uploads}).to_return(
status: 200,
body: lambda { |request| file_from_fixtures("logo.png") },
)
SiteSetting.enable_discourse_connect_provider = true
SiteSetting.enable_discourse_connect = false
SiteSetting.enable_local_logins = true
SiteSetting.discourse_connect_provider_secrets = %w[
*|secret,forAll
*.rainbow|wrongSecretForOverRainbow
www.random.site|secretForRandomSite
somewhere.over.rainbow|oldSecretForOverRainbow
somewhere.over.rainbow|secretForOverRainbow
somewhere.over.rainbow|newSecretForOverRainbow
].join("\n")
@sso = DiscourseConnectProvider.new
@sso.nonce = "mynonce"
@sso.return_sso_url = "http://somewhere.over.rainbow/sso"
@user = user
group = Fabricate(:group)
group.add(@user)
@user.create_user_avatar!
UserAvatar.import_url_for_user(logo_fixture, @user)
UserProfile.import_url_for_user(logo_fixture, @user, is_card_background: false)
UserProfile.import_url_for_user(logo_fixture, @user, is_card_background: true)
@user.reload
@user.user_avatar.reload
@user.user_profile.reload
EmailToken.update_all(confirmed: true)
end
describe "can act as an SSO provider" do
it "successfully logs in and redirects user to return_sso_url when the user is not logged in" do
get "/session/sso_provider",
params: Rack::Utils.parse_query(@sso.payload("secretForOverRainbow"))
expect(response).to redirect_to("/login")
post "/session.json",
params: {
login: @user.username,
password: "myfrogs123ADMIN",
},
xhr: true,
headers: headers
location = response.cookies["sso_destination_url"]
# javascript code will handle redirection of user to return_sso_url
expect(location).to match(%r{^http://somewhere.over.rainbow/sso})
payload = location.split("?")[1]
sso2 = DiscourseConnectProvider.parse(payload)
expect(sso2.email).to eq(@user.email)
expect(sso2.name).to eq(@user.name)
expect(sso2.username).to eq(@user.username)
expect(sso2.external_id).to eq(@user.id.to_s)
expect(sso2.admin).to eq(true)
expect(sso2.moderator).to eq(false)
expect(sso2.groups).to eq(@user.groups.pluck(:name).join(","))
expect(sso2.avatar_url.blank?).to_not eq(true)
expect(sso2.profile_background_url.blank?).to_not eq(true)
expect(sso2.card_background_url.blank?).to_not eq(true)
expect(sso2.avatar_url).to start_with(Discourse.base_url)
expect(sso2.profile_background_url).to start_with(Discourse.base_url)
expect(sso2.card_background_url).to start_with(Discourse.base_url)
expect(sso2.confirmed_2fa).to eq(nil)
expect(sso2.no_2fa_methods).to eq(nil)
end
it "correctly logs in for secondary domain secrets" do
sign_in @user
get "/session/sso_provider",
params: Rack::Utils.parse_query(@sso.payload("newSecretForOverRainbow"))
expect(response.status).to eq(302)
redirect_uri = URI.parse(response.location)
expect(redirect_uri.host).to eq("somewhere.over.rainbow")
redirect_query = CGI.parse(redirect_uri.query)
expected_sig =
DiscourseConnectBase.sign(redirect_query["sso"][0], "newSecretForOverRainbow")
expect(redirect_query["sig"][0]).to eq(expected_sig)
get "/session/sso_provider",
params: Rack::Utils.parse_query(@sso.payload("oldSecretForOverRainbow"))
expect(response.status).to eq(302)
redirect_uri = URI.parse(response.location)
expect(redirect_uri.host).to eq("somewhere.over.rainbow")
redirect_query = CGI.parse(redirect_uri.query)
expected_sig =
DiscourseConnectBase.sign(redirect_query["sso"][0], "oldSecretForOverRainbow")
expect(redirect_query["sig"][0]).to eq(expected_sig)
end
it "fails to log in if secret is wrong" do
get "/session/sso_provider",
params: Rack::Utils.parse_query(@sso.payload("secretForRandomSite"))
expect(response.status).to eq(422)
end
it "fails with a nice error message if secret is blank" do
SiteSetting.discourse_connect_provider_secrets = ""
sso = DiscourseConnectProvider.new
sso.nonce = "mynonce"
sso.return_sso_url = "http://website.without.secret.com/sso"
get "/session/sso_provider", params: Rack::Utils.parse_query(sso.payload("aasdasdasd"))
expect(response.status).to eq(400)
expect(response.body).to eq(I18n.t("discourse_connect.missing_secret"))
end
it "returns a 422 if no return_sso_url" do
SiteSetting.discourse_connect_provider_secrets = "abcdefghij"
get "/session/sso_provider?sso=asdf&sig=abcdefghij"
expect(response.status).to eq(422)
end
it "successfully redirects user to return_sso_url when the user is logged in" do
sign_in(@user)
get "/session/sso_provider",
params: Rack::Utils.parse_query(@sso.payload("secretForOverRainbow"))
location = response.header["Location"]
expect(location).to match(%r{^http://somewhere.over.rainbow/sso})
payload = location.split("?")[1]
sso2 = DiscourseConnectProvider.parse(payload)
expect(sso2.email).to eq(@user.email)
expect(sso2.name).to eq(@user.name)
expect(sso2.username).to eq(@user.username)
expect(sso2.external_id).to eq(@user.id.to_s)
expect(sso2.admin).to eq(true)
expect(sso2.moderator).to eq(false)
expect(sso2.groups).to eq(@user.groups.pluck(:name).join(","))
expect(sso2.avatar_url.blank?).to_not eq(true)
expect(sso2.profile_background_url.blank?).to_not eq(true)
expect(sso2.card_background_url.blank?).to_not eq(true)
expect(sso2.avatar_url).to start_with(Discourse.base_url)
expect(sso2.profile_background_url).to start_with(Discourse.base_url)
expect(sso2.card_background_url).to start_with(Discourse.base_url)
expect(sso2.confirmed_2fa).to eq(nil)
expect(sso2.no_2fa_methods).to eq(nil)
end
it "fails with a nice error message if `prompt` parameter has an invalid value" do
@sso.prompt = "xyzpdq"
get "/session/sso_provider",
params: Rack::Utils.parse_query(@sso.payload("secretForOverRainbow"))
expect(response.status).to eq(400)
expect(response.body).to eq(
I18n.t("discourse_connect.invalid_parameter_value", param: "prompt"),
)
end
it "redirects browser to return_sso_url with auth failure when prompt=none is requested and the user is not logged in" do
@sso.prompt = "none"
get "/session/sso_provider",
params: Rack::Utils.parse_query(@sso.payload("secretForOverRainbow"))
location = response.header["Location"]
expect(location).to match(%r{^http://somewhere.over.rainbow/sso})
payload = location.split("?")[1]
sso2 = DiscourseConnectProvider.parse(payload)
expect(sso2.failed).to eq(true)
expect(sso2.email).to eq(nil)
expect(sso2.name).to eq(nil)
expect(sso2.username).to eq(nil)
expect(sso2.external_id).to eq(nil)
expect(sso2.admin).to eq(nil)
expect(sso2.moderator).to eq(nil)
expect(sso2.groups).to eq(nil)
expect(sso2.avatar_url).to eq(nil)
expect(sso2.profile_background_url).to eq(nil)
expect(sso2.card_background_url).to eq(nil)
expect(sso2.confirmed_2fa).to eq(nil)
expect(sso2.no_2fa_methods).to eq(nil)
end
it "handles non local content correctly" do
setup_s3
SiteSetting.s3_cdn_url = "http://cdn.com"
@user.update!(uploaded_avatar: Fabricate(:upload_s3))
@user.user_profile.update!(
profile_background_upload: Fabricate(:upload_s3),
card_background_upload: Fabricate(:upload_s3),
)
sign_in(@user)
get "/session/sso_provider",
params: Rack::Utils.parse_query(@sso.payload("secretForOverRainbow"))
location = response.header["Location"]
expect(location).to match(%r{^http://somewhere.over.rainbow/sso})
payload = location.split("?")[1]
sso2 = DiscourseConnectProvider.parse(payload)
expect(sso2.avatar_url).to start_with(SiteSetting.s3_cdn_url)
expect(sso2.profile_background_url).to start_with(SiteSetting.s3_cdn_url)
expect(sso2.card_background_url).to start_with(SiteSetting.s3_cdn_url)
end
it "successfully logs out and redirects user to return_sso_url when the user is logged in" do
sign_in(@user)
@sso.logout = true
get "/session/sso_provider",
params: Rack::Utils.parse_query(@sso.payload("secretForOverRainbow"))
location = response.header["Location"]
expect(location).to match(%r{^http://somewhere.over.rainbow/sso$})
expect(response.status).to eq(302)
expect(session[:current_user_id]).to be_blank
expect(response.cookies["_t"]).to be_blank
end
it "clears all push subscriptions on SSO single-logout" do
sign_in(@user)
Fabricate(:push_subscription, user: @user)
Fabricate(:push_subscription, user: @user)
@sso.logout = true
get "/session/sso_provider",
params: Rack::Utils.parse_query(@sso.payload("secretForOverRainbow"))
expect(@user.push_subscriptions.reload).to be_empty
end
it "successfully logs out and redirects user to return_sso_url when the user is not logged in" do
@sso.logout = true
get "/session/sso_provider",
params: Rack::Utils.parse_query(@sso.payload("secretForOverRainbow"))
location = response.header["Location"]
expect(location).to match(%r{^http://somewhere.over.rainbow/sso$})
expect(response.status).to eq(302)
expect(session[:current_user_id]).to be_blank
expect(response.cookies["_t"]).to be_blank
end
end
describe "can act as a 2FA provider" do
fab!(:user_totp) { Fabricate(:user_second_factor_totp, user: user) }
before { @sso.require_2fa = true }
it "requires the user to confirm 2FA before they are redirected to the SSO return URL" do
sign_in(user)
get "/session/sso_provider",
params: Rack::Utils.parse_query(@sso.payload("secretForOverRainbow"))
uri = URI(response.location)
expect(uri.hostname).to eq(Discourse.current_hostname)
expect(uri.path).to eq("/session/2fa")
nonce = uri.query.match(/\Anonce=([A-Za-z0-9]{32})\Z/)[1]
expect(nonce).to be_present
# attempt no. 1 to bypass 2fa
get "/session/sso_provider", params: { second_factor_nonce: nonce }
expect(response.status).to eq(401)
expect(response.parsed_body["error"]).to eq(
I18n.t("second_factor_auth.challenge_not_completed"),
)
# attempt no. 2 to bypass 2fa
get "/session/sso_provider",
params: { second_factor_nonce: nonce }.merge(
Rack::Utils.parse_query(@sso.payload("secretForOverRainbow")),
)
expect(response.status).to eq(401)
expect(response.parsed_body["error"]).to eq(
I18n.t("second_factor_auth.challenge_not_completed"),
)
# confirm 2fa
post "/session/2fa.json",
params: {
nonce: nonce,
second_factor_token: ROTP::TOTP.new(user_totp.data).now,
second_factor_method: UserSecondFactor.methods[:totp],
}
expect(response.status).to eq(200)
expect(response.parsed_body["ok"]).to eq(true)
expect(response.parsed_body["callback_method"]).to eq("GET")
expect(response.parsed_body["callback_path"]).to eq("/session/sso_provider")
expect(response.parsed_body["redirect_url"]).to be_blank
get "/session/sso_provider", params: { second_factor_nonce: nonce }
expect(response.status).to eq(200)
expect(response.parsed_body["success"]).to eq("OK")
redirect_url = response.parsed_body["redirect_url"]
expect(redirect_url).to start_with("http://somewhere.over.rainbow/sso?sso=")
sso = DiscourseConnectProvider.parse(URI(redirect_url).query)
expect(sso.confirmed_2fa).to eq(true)
expect(sso.no_2fa_methods).to eq(nil)
expect(sso.username).to eq(user.username)
expect(sso.email).to eq(user.email)
end
it "doesn't accept backup codes" do
backup_codes = user.generate_backup_codes
sign_in(user)
get "/session/sso_provider",
params: Rack::Utils.parse_query(@sso.payload("secretForOverRainbow"))
uri = URI(response.location)
expect(uri.hostname).to eq(Discourse.current_hostname)
expect(uri.path).to eq("/session/2fa")
nonce = uri.query.match(/\Anonce=([A-Za-z0-9]{32})\Z/)[1]
expect(nonce).to be_present
post "/session/2fa.json",
params: {
nonce: nonce,
second_factor_token: backup_codes.sample,
second_factor_method: UserSecondFactor.methods[:backup_codes],
}
expect(response.status).to eq(403)
get "/session/sso_provider", params: { second_factor_nonce: nonce }
expect(response.status).to eq(401)
expect(response.parsed_body["error"]).to eq(
I18n.t("second_factor_auth.challenge_not_completed"),
)
end
context "when the user has no 2fa methods" do
before do
user_totp.destroy!
user.reload
end
it "redirects the user back to the SSO return url and indicates in the payload that they do not have 2fa methods" do
sign_in(user)
get "/session/sso_provider",
params: Rack::Utils.parse_query(@sso.payload("secretForOverRainbow"))
expect(response.status).to eq(302)
redirect_url = response.location
expect(redirect_url).to start_with("http://somewhere.over.rainbow/sso?sso=")
sso = DiscourseConnectProvider.parse(URI(redirect_url).query)
expect(sso.confirmed_2fa).to eq(nil)
expect(sso.no_2fa_methods).to eq(true)
expect(sso.username).to eq(user.username)
expect(sso.email).to eq(user.email)
end
end
context "when there is no logged in user" do
it "redirects the user to login first" do
get "/session/sso_provider",
params: Rack::Utils.parse_query(@sso.payload("secretForOverRainbow"))
expect(response.status).to eq(302)
expect(response.location).to eq("http://#{Discourse.current_hostname}/login")
end
it "doesn't make the user confirm 2fa twice if they've just logged in and confirmed 2fa while doing so" do
get "/session/sso_provider",
params: Rack::Utils.parse_query(@sso.payload("secretForOverRainbow"))
post "/session.json",
params: {
login: user.username,
password: "myfrogs123ADMIN",
second_factor_token: ROTP::TOTP.new(user_totp.data).now,
second_factor_method: UserSecondFactor.methods[:totp],
},
xhr: true,
headers: headers
expect(response.status).to eq(200)
# the backend will take care of actually redirecting the user
redirect_url = response.cookies["sso_destination_url"]
expect(redirect_url).to start_with("http://somewhere.over.rainbow/sso?sso=")
sso = DiscourseConnectProvider.parse(URI(redirect_url).query)
expect(sso.confirmed_2fa).to eq(true)
expect(sso.no_2fa_methods).to eq(nil)
expect(sso.username).to eq(user.username)
expect(sso.email).to eq(user.email)
end
it "doesn't indicate the user has confirmed 2fa after they've logged in if they have no 2fa methods" do
user_totp.destroy!
user.reload
get "/session/sso_provider",
params: Rack::Utils.parse_query(@sso.payload("secretForOverRainbow"))
post "/session.json",
params: {
login: user.username,
password: "myfrogs123ADMIN",
},
xhr: true,
headers: headers
redirect_url = response.cookies["sso_destination_url"]
expect(redirect_url).to start_with("http://somewhere.over.rainbow/sso?sso=")
sso = DiscourseConnectProvider.parse(URI(redirect_url).query)
expect(sso.confirmed_2fa).to eq(nil)
expect(sso.no_2fa_methods).to eq(true)
expect(sso.username).to eq(user.username)
expect(sso.email).to eq(user.email)
end
end
end
end
describe "#create" do
context "when read only mode" do
before do
Discourse.enable_readonly_mode
EmailToken.confirm(email_token.token)
EmailToken.confirm(admin_email_token.token)
end
it "prevents login by regular users" do
post "/session.json", params: { login: user.username, password: "myawesomepassword" }
expect(response.status).not_to eq(200)
end
it "prevents login by admins" do
post "/session.json", params: { login: admin.username, password: "myawesomepassword" }
expect(response.status).not_to eq(200)
end
end
context "when in staff writes only mode" do
before do
Discourse.enable_readonly_mode(Discourse::STAFF_WRITES_ONLY_MODE_KEY)
EmailToken.confirm(email_token.token)
EmailToken.confirm(admin_email_token.token)
end
it "allows admin login" do
post "/session.json", params: { login: admin.username, password: "myawesomepassword" }
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
end
it "prevents login by regular users" do
post "/session.json", params: { login: user.username, password: "myawesomepassword" }
expect(response.status).not_to eq(200)
end
end
context "when local login is disabled" do
before do
SiteSetting.enable_local_logins = false
post "/session.json", params: { login: user.username, password: "myawesomepassword" }
end
it_behaves_like "failed to continue local login"
end
context "when SSO is enabled" do
before do
SiteSetting.discourse_connect_url = "https://www.example.com/sso"
SiteSetting.discourse_connect_secret = "x" * 10
SiteSetting.enable_discourse_connect = true
post "/session.json", params: { login: user.username, password: "myawesomepassword" }
end
it_behaves_like "failed to continue local login"
end
context "when local login via email is disabled" do
before do
SiteSetting.enable_local_logins_via_email = false
EmailToken.confirm(email_token.token)
end
it "doesn't matter, logs in correctly" do
post "/session.json", params: { login: user.username, password: "myawesomepassword" }
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
end
end
context "when email is confirmed" do
before { EmailToken.confirm(email_token.token) }
it "raises an error when the login isn't present" do
post "/session.json"
expect(response.status).to eq(400)
end
describe "invalid password" do
it "returns an error for an invalid password" do
post "/session.json", params: { login: user.username, password: "sssss" }
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(
I18n.t("login.incorrect_username_email_or_password"),
)
end
it "returns an error for an overlong password" do
User.any_instance.expects(:confirm_password?).never
post "/session.json",
params: {
login: user.username,
password: ("s" * (User.max_password_length + 1)),
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(
I18n.t("login.incorrect_username_email_or_password"),
)
end
end
describe "suspended user" do
it "returns the suspension error" do
user.suspended_till = 2.days.from_now
user.suspended_at = Time.now
user.save!
StaffActionLogger.new(user).log_user_suspend(user, "<strike>banned</strike>")
post "/session.json", params: { login: user.username, password: "myawesomepassword" }
expected_message =
I18n.t(
"login.suspended_with_reason",
date: I18n.l(user.suspended_till, format: :date_only),
reason: Rack::Utils.escape_html(user.suspend_reason),
)
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(expected_message)
end
it "when suspended forever should return an error without suspended till date" do
user.suspended_till = 101.years.from_now
user.suspended_at = Time.now
user.save!
StaffActionLogger.new(user).log_user_suspend(user, "<strike>banned</strike>")
post "/session.json", params: { login: user.username, password: "myawesomepassword" }
expected_message =
I18n.t(
"login.suspended_with_reason_forever",
reason: Rack::Utils.escape_html(user.suspend_reason),
)
expect(response.parsed_body["error"]).to eq(expected_message)
end
end
describe "deactivated user" do
it "returns the activation error" do
user.active = false
user.save!
post "/session.json", params: { login: user.username, password: "myawesomepassword" }
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(I18n.t("login.not_activated"))
end
end
describe "success by username and password" do
it "logs in correctly" do
events =
DiscourseEvent.track_events do
post "/session.json", params: { login: user.username, password: "myawesomepassword" }
end
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
expect(events.map { |event| event[:event_name] }).to contain_exactly(
:user_logged_in,
:user_first_logged_in,
)
user.reload
expect(session[:current_user_id]).to eq(user.id)
expect(user.user_auth_tokens.count).to eq(1)
expect(user.user_auth_tokens.last.authenticated_with_oauth).to be false
unhashed_token = decrypt_auth_cookie(cookies[:_t])[:token]
expect(UserAuthToken.hash_token(unhashed_token)).to eq(
user.user_auth_tokens.first.auth_token,
)
end
context "when timezone param is provided" do
let(:user) { Fabricate(:user, timezone: nil) }
it "sets the user_option timezone for the user" do
post "/session.json",
params: {
login: user.username,
password: "myawesomepassword",
timezone: "Australia/Melbourne",
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
expect(user.reload.user_option.timezone).to eq("Australia/Melbourne")
end
end
end
describe "when user's password has been marked as expired" do
before { RateLimiter.enable }
it "returns the expired-password error" do
UserPasswordExpirer.expire_user_password(user)
post "/session.json", params: { login: user.username, password: "myawesomepassword" }
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq("expired")
expect(response.parsed_body["reason"]).to eq("expired")
expect(session[:current_user_id]).to eq(nil)
end
end
context "when a user has security key-only 2FA login" do
let!(:user_security_key) do
Fabricate(
:user_security_key,
user: user,
credential_id: valid_security_key_data[:credential_id],
public_key: valid_security_key_data[:public_key],
)
end
before do
DiscourseWebauthn.stubs(:origin).returns("http://localhost:3000")
# store challenge in server session by failing login once
post "/session.json", params: { login: user.username, password: "myawesomepassword" }
server_session[
DiscourseWebauthn.session_challenge_key(user)
] = valid_security_key_challenge_data[:challenge]
end
context "when the security key params are blank and a random second factor token is provided" do
it "shows an error message and denies login" do
post "/session.json",
params: {
login: user.username,
password: "myawesomepassword",
second_factor_token: "99999999",
second_factor_method: UserSecondFactor.methods[:security_key],
}
expect(response.status).to eq(200)
expect(session[:current_user_id]).to eq(nil)
response_body = response.parsed_body
expect(response_body["failed"]).to eq("FAILED")
expect(response_body["error"]).to eq(
I18n.t("webauthn.validation.malformed_public_key_credential_error"),
)
end
end
context "when the security key params are invalid" do
it "shows an error message and denies login" do
post "/session.json",
params: {
login: user.username,
password: "myawesomepassword",
second_factor_token: {
signature: "bad_sig",
clientData: "bad_clientData",
credentialId: "bad_credential_id",
authenticatorData: "bad_authenticator_data",
},
second_factor_method: UserSecondFactor.methods[:security_key],
}
expect(response.status).to eq(200)
expect(session[:current_user_id]).to eq(nil)
response_body = response.parsed_body
expect(response_body["failed"]).to eq("FAILED")
expect(response_body["error"]).to eq(I18n.t("webauthn.validation.not_found_error"))
end
end
context "when the security key params are valid" do
it "logs the user in" do
post "/session.json",
params: {
login: user.username,
password: "myawesomepassword",
second_factor_token: valid_security_key_auth_post_data,
second_factor_method: UserSecondFactor.methods[:security_key],
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
user.reload
expect(session[:current_user_id]).to eq(user.id)
expect(user.user_auth_tokens.count).to eq(1)
post "/session.json",
params: {
login: user.username,
password: "myawesomepassword",
second_factor_token: valid_security_key_auth_post_data,
second_factor_method: UserSecondFactor.methods[:security_key],
}
expect(response.parsed_body["error"]).to eq(
I18n.t("webauthn.validation.challenge_mismatch_error"),
)
end
end
context "when the security key is disabled in the background by the user and TOTP is enabled" do
before do
user_security_key.destroy!
Fabricate(:user_second_factor_totp, user: user)
end
it "shows an error message and denies login" do
post "/session.json",
params: {
login: user.username,
password: "myawesomepassword",
second_factor_token: valid_security_key_auth_post_data,
second_factor_method: UserSecondFactor.methods[:security_key],
}
expect(response.status).to eq(200)
expect(session[:current_user_id]).to eq(nil)
response_body = response.parsed_body
expect(response_body["failed"]).to eq("FAILED")
expect(response.parsed_body["error"]).to eq(
I18n.t("login.not_enabled_second_factor_method"),
)
end
end
end
context "when user has TOTP-only 2FA login" do
let!(:user_second_factor) { Fabricate(:user_second_factor_totp, user: user) }
let!(:user_second_factor_backup) { Fabricate(:user_second_factor_backup, user: user) }
describe "when second factor token is missing" do
it "returns the missing-second-factor error" do
post "/session.json", params: { login: user.username, password: "myawesomepassword" }
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(
I18n.t("login.invalid_second_factor_method"),
)
end
end
describe "when second factor token is invalid" do
context "when using totp method" do
it "returns the invalid-TOTP error" do
post "/session.json",
params: {
login: user.username,
password: "myawesomepassword",
second_factor_token: "00000000",
second_factor_method: UserSecondFactor.methods[:totp],
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(
I18n.t("login.invalid_second_factor_code"),
)
end
end
context "when using backup code method" do
it "returns the invalid-backup-code error" do
post "/session.json",
params: {
login: user.username,
password: "myawesomepassword",
second_factor_token: "00000000",
second_factor_method: UserSecondFactor.methods[:backup_codes],
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(
I18n.t("login.invalid_second_factor_code"),
)
end
end
end
describe "when second factor token is valid" do
context "when using totp method" do
it "logs the user in with TOTP" do
post "/session.json",
params: {
login: user.username,
password: "myawesomepassword",
second_factor_token: ROTP::TOTP.new(user_second_factor.data).now,
second_factor_method: UserSecondFactor.methods[:totp],
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
user.reload
expect(session[:current_user_id]).to eq(user.id)
expect(user.user_auth_tokens.count).to eq(1)
unhashed_token = decrypt_auth_cookie(cookies[:_t])[:token]
expect(UserAuthToken.hash_token(unhashed_token)).to eq(
user.user_auth_tokens.first.auth_token,
)
end
end
context "when using backup code method" do
it "logs the user in with a backup code" do
post "/session.json",
params: {
login: user.username,
password: "myawesomepassword",
second_factor_token: "iAmValidBackupCode",
second_factor_method: UserSecondFactor.methods[:backup_codes],
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
user.reload
expect(session[:current_user_id]).to eq(user.id)
expect(user.user_auth_tokens.count).to eq(1)
unhashed_token = decrypt_auth_cookie(cookies[:_t])[:token]
expect(UserAuthToken.hash_token(unhashed_token)).to eq(
user.user_auth_tokens.first.auth_token,
)
end
end
end
end
describe "with a blocked IP" do
it "doesn't log in" do
ScreenedIpAddress.all.destroy_all
get "/"
_screened_ip = Fabricate(:screened_ip_address, ip_address: request.remote_ip)
post "/session.json",
params: {
login: "@" + user.username,
password: "myawesomepassword",
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to be_present
user.reload
expect(session[:current_user_id]).to be_nil
end
end
describe "strips leading @ symbol" do
it "sets a session id" do
post "/session.json",
params: {
login: "@" + user.username,
password: "myawesomepassword",
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
user.reload
expect(session[:current_user_id]).to eq(user.id)
end
end
describe "also allow login by email" do
it "sets a session id" do
post "/session.json", params: { login: user.email, password: "myawesomepassword" }
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
expect(session[:current_user_id]).to eq(user.id)
end
end
context "when login has leading and trailing space" do
let(:username) { " #{user.username} " }
let(:email) { " #{user.email} " }
it "strips spaces from the username" do
post "/session.json", params: { login: username, password: "myawesomepassword" }
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
end
it "strips spaces from the email" do
post "/session.json", params: { login: email, password: "myawesomepassword" }
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
end
end
describe "when the site requires approval of users" do
before { SiteSetting.must_approve_users = true }
context "with an unapproved user" do
before do
user.update_columns(approved: false)
post "/session.json", params: { login: user.email, password: "myawesomepassword" }
end
it "doesn't log in the user" do
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to be_present
expect(session[:current_user_id]).to be_blank
end
it "shows the 'not approved' error message" do
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(I18n.t("login.not_approved"))
end
end
context "with an unapproved user who is an admin" do
it "sets a session id" do
user.admin = true
user.save!
post "/session.json", params: { login: user.email, password: "myawesomepassword" }
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
expect(session[:current_user_id]).to eq(user.id)
end
end
end
context "when admins are restricted by ip address" do
before do
SiteSetting.use_admin_ip_allowlist = true
ScreenedIpAddress.all.destroy_all
end
it "is successful for admin at the ip address" do
get "/"
Fabricate(
:screened_ip_address,
ip_address: request.remote_ip,
action_type: ScreenedIpAddress.actions[:allow_admin],
)
user.admin = true
user.save!
post "/session.json", params: { login: user.username, password: "myawesomepassword" }
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
expect(session[:current_user_id]).to eq(user.id)
end
it "returns an error for admin not at the ip address" do
Fabricate(
:screened_ip_address,
ip_address: "111.234.23.11",
action_type: ScreenedIpAddress.actions[:allow_admin],
)
user.admin = true
user.save!
post "/session.json", params: { login: user.username, password: "myawesomepassword" }
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to be_present
expect(session[:current_user_id]).not_to eq(user.id)
end
it "is successful for non-admin not at the ip address" do
Fabricate(
:screened_ip_address,
ip_address: "111.234.23.11",
action_type: ScreenedIpAddress.actions[:allow_admin],
)
user.admin = false
user.save!
post "/session.json", params: { login: user.username, password: "myawesomepassword" }
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
expect(session[:current_user_id]).to eq(user.id)
end
end
end
context "when email has not been confirmed" do
def post_login
post "/session.json", params: { login: user.email, password: "myawesomepassword" }
end
it "doesn't log in the user" do
post_login
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to be_present
expect(session[:current_user_id]).to be_blank
end
it "shows the 'not activated' error message" do
post_login
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(I18n.t "login.not_activated")
end
context "when the 'must approve users' site setting is enabled" do
before { SiteSetting.must_approve_users = true }
it "shows the 'not approved' error message" do
post_login
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(I18n.t "login.not_approved")
end
end
end
context "when rate limited" do
before { RateLimiter.enable }
it "rate limits login" do
SiteSetting.max_logins_per_ip_per_hour = 2
EmailToken.confirm(email_token.token)
2.times do
post "/session.json", params: { login: user.username, password: "myawesomepassword" }
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
end
post "/session.json", params: { login: user.username, password: "myawesomepassword" }
expect(response.status).to eq(429)
json = response.parsed_body
expect(json["error_type"]).to eq("rate_limit")
end
it "rate limits second factor attempts by IP" do
6.times do |x|
post "/session.json",
params: {
login: "#{user.username}#{x}",
password: "myawesomepassword",
second_factor_token: "000000",
second_factor_method: UserSecondFactor.methods[:totp],
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to be_present
end
post "/session.json",
params: {
login: user.username,
password: "myawesomepassword",
second_factor_token: "000000",
second_factor_method: UserSecondFactor.methods[:totp],
}
expect(response.status).to eq(429)
json = response.parsed_body
expect(json["error_type"]).to eq("rate_limit")
end
it "rate limits second factor attempts by login" do
EmailToken.confirm(email_token.token)
6.times do |x|
post "/session.json",
params: {
login: user.username,
password: "myawesomepassword",
second_factor_token: "000000",
second_factor_method: UserSecondFactor.methods[:totp],
},
env: {
REMOTE_ADDR: "1.2.3.#{x}",
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
end
[
user.username + " ",
user.username.capitalize,
user.username,
].each_with_index do |username, x|
post "/session.json",
params: {
login: username,
password: "myawesomepassword",
second_factor_token: "000000",
second_factor_method: UserSecondFactor.methods[:totp],
},
env: {
REMOTE_ADDR: "1.2.4.#{x}",
}
expect(response.status).to eq(429)
json = response.parsed_body
expect(json["error_type"]).to eq("rate_limit")
end
end
end
end
describe "#destroy" do
it "removes the session variable and the auth token cookies" do
user = sign_in(Fabricate(:user))
delete "/session/#{user.username}.json"
expect(response.status).to eq(302)
expect(session[:current_user_id]).to be_blank
expect(response.cookies["_t"]).to be_blank
end
it "returns the redirect URL in the body for XHR requests" do
user = sign_in(Fabricate(:user))
delete "/session/#{user.username}.json", xhr: true
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
expect(session[:current_user_id]).to be_blank
expect(response.cookies["_t"]).to be_blank
expect(response.parsed_body["redirect_url"]).to eq("/")
end
it "redirects to /login-required when SSO and login_required" do
SiteSetting.discourse_connect_url = "https://example.com/sso"
SiteSetting.discourse_connect_secret = "x" * 10
SiteSetting.enable_discourse_connect = true
user = sign_in(Fabricate(:user))
delete "/session/#{user.username}.json", xhr: true
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
expect(response.parsed_body["redirect_url"]).to eq("/")
SiteSetting.login_required = true
user = sign_in(Fabricate(:user))
delete "/session/#{user.username}.json", xhr: true
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
expect(response.parsed_body["redirect_url"]).to eq("/login-required")
end
it "allows plugins to manipulate redirect URL" do
callback = ->(data) { data[:redirect_url] = "/myredirect/#{data[:user].username}" }
DiscourseEvent.on(:before_session_destroy, &callback)
user = sign_in(Fabricate(:user))
delete "/session/#{user.username}.json", xhr: true
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
expect(response.parsed_body["redirect_url"]).to eq("/myredirect/#{user.username}")
ensure
DiscourseEvent.off(:before_session_destroy, &callback)
end
it "includes ip and user agent in the before_session_destroy event params" do
callback_params = {}
callback = ->(data) { callback_params = data }
DiscourseEvent.on(:before_session_destroy, &callback)
user = sign_in(Fabricate(:user))
delete "/session/#{user.username}.json",
xhr: true,
headers: {
HTTP_USER_AGENT: "AwesomeBrowser",
}
expect(callback_params[:user_agent]).to eq("AwesomeBrowser")
expect(callback_params[:client_ip]).to eq("127.0.0.1")
ensure
DiscourseEvent.off(:before_session_destroy, &callback)
end
context "with return_url parameter" do
it "rejects absolute external URLs" do
user = sign_in(Fabricate(:user))
delete "/session/#{user.username}.json",
params: {
return_url: "https://evil.com/phishing",
},
xhr: true
expect(response.status).to eq(200)
expect(response.parsed_body["redirect_url"]).to eq("/")
end
it "rejects protocol-relative URLs" do
user = sign_in(Fabricate(:user))
delete "/session/#{user.username}.json",
params: {
return_url: "//evil.com/phishing",
},
xhr: true
expect(response.status).to eq(200)
expect(response.parsed_body["redirect_url"]).to eq("/")
end
it "rejects backslash variants that browsers may normalize to protocol-relative" do
user = sign_in(Fabricate(:user))
delete "/session/#{user.username}.json", params: { return_url: "/\\evil.com" }, xhr: true
expect(response.status).to eq(200)
expect(response.parsed_body["redirect_url"]).to eq("/")
end
it "rejects javascript: scheme URLs" do
user = sign_in(Fabricate(:user))
delete "/session/#{user.username}.json",
params: {
return_url: "javascript:alert(1)",
},
xhr: true
expect(response.status).to eq(200)
expect(response.parsed_body["redirect_url"]).to eq("/")
end
it "rejects external URLs for non-XHR requests" do
user = sign_in(Fabricate(:user))
delete "/session/#{user.username}.json", params: { return_url: "https://evil.com/phishing" }
expect(response.status).to eq(302)
expect(response.location).to eq("http://test.localhost/")
end
it "allows valid relative paths" do
user = sign_in(Fabricate(:user))
delete "/session/#{user.username}.json",
params: {
return_url: "/t/some-topic/123",
},
xhr: true
expect(response.status).to eq(200)
expect(response.parsed_body["redirect_url"]).to eq("/t/some-topic/123")
end
it "allows bare root path and takes precedence over logout_redirect" do
SiteSetting.logout_redirect = "/login"
user = sign_in(Fabricate(:user))
delete "/session/#{user.username}.json", params: { return_url: "/" }, xhr: true
expect(response.status).to eq(200)
expect(response.parsed_body["redirect_url"]).to eq("/")
end
end
end
describe "#one_time_password" do
context "with missing token" do
it "returns the right response" do
get "/session/otp"
expect(response.status).to eq(404)
end
end
context "with invalid token" do
it "returns the right response" do
get "/session/otp/asd1231dasd123"
expect(response.status).to eq(404)
post "/session/otp/asd1231dasd123"
expect(response.status).to eq(404)
end
context "when token is valid" do
it "displays the one-time-password form" do
token = SecureRandom.hex
Discourse.redis.setex "otp_#{token}", 10.minutes, user.username
get "/session/otp/#{token}"
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
expect(response.body).to include(
I18n.t("user_api_key.otp_confirmation.logging_in_as", username: user.username),
)
expect(Discourse.redis.get("otp_#{token}")).to eq(user.username)
expect(session[:current_user_id]).to eq(nil)
end
it "redirects an already logged-in user" do
sign_in(user)
token = SecureRandom.hex
Discourse.redis.setex "otp_#{token}", 10.minutes, user.username
get "/session/otp/#{token}"
expect(response.status).to eq(302)
expect(Discourse.redis.get("otp_#{token}")).to eq(nil)
expect(session[:current_user_id]).to eq(user.id)
end
it "authenticates the user and deletes the token" do
user = Fabricate(:user)
get "/session/current.json"
expect(response.status).to eq(404)
token = SecureRandom.hex
Discourse.redis.setex "otp_#{token}", 10.minutes, user.username
post "/session/otp/#{token}"
expect(response.status).to eq(302)
expect(response).to redirect_to("/")
expect(Discourse.redis.get("otp_#{token}")).to eq(nil)
get "/session/current.json"
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
end
end
end
end
describe "#forgot_password" do
before { SiteSetting.enable_local_logins_via_code = false }
context "when email codes are enabled" do
before { SiteSetting.enable_local_logins_via_code = true }
it "sends a password reset code to the primary email for usernames and secondary emails" do
secondary_email = Fabricate(:secondary_email, user: user)
[user.username, secondary_email.email].each do |login|
expect_enqueued_with(
job: :send_email_login_code,
args: {
to_address: user.email,
password_reset: true,
},
) { post "/session/forgot_password.json", params: { login: } }
expect(response.status).to eq(200)
expect(response.parsed_body).to include("email_code" => true, "user_found" => true)
expect(EmailLoginCode.for_email(user.email).count).to eq(1)
expect(user.email_tokens.where(scope: EmailToken.scopes[:password_reset])).to be_empty
end
end
it "expires existing password reset and unscoped email tokens when sending a code" do
reset_token = Fabricate(:email_token, user: user, scope: EmailToken.scopes[:password_reset])
unscoped_token = Fabricate(:email_token, user: user)
login_token = Fabricate(:email_token, user: user, scope: EmailToken.scopes[:email_login])
other_user_token = Fabricate(:email_token, scope: EmailToken.scopes[:password_reset])
unscoped_token.update_column(:scope, nil)
post "/session/forgot_password.json", params: { login: user.email }
expect(response.status).to eq(200)
expect(response.parsed_body["email_code"]).to eq(true)
expect(reset_token.reload).to be_expired
expect(unscoped_token.reload).to be_expired
expect(login_token.reload).not_to be_expired
expect(other_user_token.reload).not_to be_expired
end
it "sends a code when a logged-in user resets their own password" do
sign_in(user)
expect_enqueued_with(
job: :send_email_login_code,
args: {
to_address: user.email,
password_reset: true,
},
) { post "/session/forgot_password.json", params: { login: user.email } }
expect(response.status).to eq(200)
expect(response.parsed_body["email_code"]).to eq(true)
end
it "sends a link when staff reset another user's password" do
sign_in(admin)
expect_enqueued_with(
job: :critical_user_email,
args: {
type: "forgot_password",
user_id: user.id,
},
) { post "/session/forgot_password.json", params: { login: user.email } }
expect(response.status).to eq(200)
expect(response.parsed_body).not_to have_key("email_code")
expect(EmailLoginCode.password_reset.for_email(user.email)).to be_empty
end
it "returns the same response for unknown emails when account existence is hidden" do
SiteSetting.hide_email_address_taken = true
post "/session/forgot_password.json", params: { login: user.email }
known_response = response.parsed_body
expect_not_enqueued_with(job: :send_email_login_code) do
post "/session/forgot_password.json", params: { login: "[email protected]" }
end
expect(response.status).to eq(200)
expect(response.parsed_body).to eq(known_response)
expect(response.parsed_body).to include("email_code" => true)
expect(response.parsed_body).not_to have_key("user_found")
end
it "preserves password reset request rate limits" do
RateLimiter.enable
3.times { post "/session/forgot_password.json", params: { login: user.email } }
post "/session/forgot_password.json", params: { login: user.email }
expect(response.status).to eq(422)
end
end
context "when hide_email_address_taken is set" do
before { SiteSetting.hide_email_address_taken = true }
it "denies for username" do
post "/session/forgot_password.json", params: { login: user.username }
expect(response.status).to eq(400)
expect(Jobs::CriticalUserEmail.jobs.size).to eq(0)
end
it "allows for username when staff" do
sign_in(Fabricate(:admin))
post "/session/forgot_password.json", params: { login: user.username }
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
expect(Jobs::CriticalUserEmail.jobs.size).to eq(1)
end
it "allows for email" do
post "/session/forgot_password.json", params: { login: user.email }
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
expect(Jobs::CriticalUserEmail.jobs.size).to eq(1)
end
end
it "raises an error without a username parameter" do
post "/session/forgot_password.json"
expect(response.status).to eq(400)
end
it "screens blocked IP addresses" do
ScreenedIpAddress.create!(
ip_address: "100.0.0.1",
action_type: ScreenedIpAddress.actions[:block],
)
post "/session/forgot_password.json",
params: {
login: "made_up",
},
headers: {
"REMOTE_ADDR" => "100.0.0.1",
}
expect(response.parsed_body).to eq(
{ "errors" => [I18n.t("login.reset_not_allowed_from_ip_address")] },
)
end
describe "rate limiting" do
before { RateLimiter.enable }
it "rate-limits repeated password-reset requests" do
user = Fabricate(:user)
3.times do
post "/session/forgot_password.json", params: { login: user.username }
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
end
post "/session/forgot_password.json", params: { login: user.username }
expect(response.status).to eq(422)
3.times do
post "/session/forgot_password.json",
params: {
login: user.username,
},
headers: {
"REMOTE_ADDR" => "10.1.1.1",
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
end
post "/session/forgot_password.json",
params: {
login: user.username,
},
headers: {
"REMOTE_ADDR" => "100.1.1.1",
}
# not allowed, max 6 a day
expect(response.status).to eq(422)
end
end
context "for a non existant username" do
it "doesn't generate a new token for a made up username" do
expect do
post "/session/forgot_password.json", params: { login: "made_up" }
end.not_to change(EmailToken, :count)
expect(Jobs::CriticalUserEmail.jobs.size).to eq(0)
end
end
context "for an existing username" do
fab!(:user)
context "when local login is disabled" do
before do
SiteSetting.enable_local_logins = false
post "/session/forgot_password.json", params: { login: user.username }
end
it_behaves_like "failed to continue local login"
end
context "when SSO is enabled" do
before do
SiteSetting.discourse_connect_url = "https://www.example.com/sso"
SiteSetting.discourse_connect_secret = "x" * 10
SiteSetting.enable_discourse_connect = true
post "/session.json", params: { login: user.username, password: "myawesomepassword" }
end
it_behaves_like "failed to continue local login"
end
context "when local logins are disabled" do
before do
SiteSetting.enable_local_logins = false
post "/session.json", params: { login: user.username, password: "myawesomepassword" }
end
it_behaves_like "failed to continue local login"
end
context "when local logins via email are disabled" do
before { SiteSetting.enable_local_logins_via_email = false }
it "does not matter, generates a new token for a made up username" do
expect do
post "/session/forgot_password.json", params: { login: user.username }
end.to change(EmailToken, :count)
end
end
it "generates a new token for a made up username" do
expect do
post "/session/forgot_password.json", params: { login: user.username }
end.to change(EmailToken, :count)
end
it "enqueues an email" do
post "/session/forgot_password.json", params: { login: user.username }
expect(Jobs::CriticalUserEmail.jobs.size).to eq(1)
end
end
context "when doing nothing to system username" do
let(:system) { Discourse.system_user }
it "generates no token for system username" do
expect do
post "/session/forgot_password.json", params: { login: system.username }
end.not_to change(EmailToken, :count)
end
it "enqueues no email" do
post "/session/forgot_password.json", params: { login: system.username }
expect(Jobs::CriticalUserEmail.jobs.size).to eq(0)
end
end
context "for a staged account" do
let!(:staged) { Fabricate(:staged) }
it "generates no token for staged username" do
expect do
post "/session/forgot_password.json", params: { login: staged.username }
end.not_to change(EmailToken, :count)
end
it "enqueues no email" do
post "/session/forgot_password.json", params: { login: staged.username }
expect(Jobs::CriticalUserEmail.jobs.size).to eq(0)
end
end
context "when in staff writes only mode" do
before { Discourse.enable_readonly_mode(Discourse::STAFF_WRITES_ONLY_MODE_KEY) }
it "allows staff to forget their password" do
post "/session/forgot_password.json", params: { login: admin.username }
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
expect(Jobs::CriticalUserEmail.jobs.size).to eq(1)
end
it "doesn't allow non-staff to forget their password" do
post "/session/forgot_password.json", params: { login: user.username }
expect(response.status).to eq(503)
expect(Jobs::CriticalUserEmail.jobs.size).to eq(0)
end
end
end
describe "#redeem_password_reset_code" do
before { SiteSetting.enable_local_logins_via_code = true }
def request_password_reset_code
post "/session/forgot_password.json", params: { login: user.email }
Jobs::SendEmailLoginCode.jobs.last["args"].first["code"]
end
it "exchanges the code for a reset page and changes the password there" do
code = request_password_reset_code
post "/session/password-reset-code/verify.json", params: { code: }
expect(response.status).to eq(200)
reset_url = response.parsed_body["redirect_url"]
expect(reset_url).to start_with("/u/password-reset/")
expect(user.user_auth_tokens).to be_empty
get reset_url
put reset_url, params: { password: "aNewSecurePassword123!" }
expect(response.status).to eq(200)
expect(user.reload.confirm_password?("aNewSecurePassword123!")).to eq(true)
end
it "keeps login and reset codes usable only for their own flow" do
SecureRandom
.stubs(:random_number)
.with(10**EmailLoginCode::CODE_LENGTH)
.returns(123_456, 654_321)
reset_code = request_password_reset_code
get "/session/hp.json"
honeypot = response.parsed_body
post "/session/login-code.json",
params: {
email: user.email,
password_confirmation: honeypot["value"],
challenge: honeypot["challenge"].reverse,
}
login_code = Jobs::SendEmailLoginCode.jobs.last["args"].first["code"]
post "/session/password-reset-code/verify.json", params: { code: login_code }
expect(response.parsed_body["error"]).to eq(I18n.t("email_login_code.invalid_code"))
post "/session/login-code/verify.json", params: { email: user.email, code: reset_code }
expect(response.parsed_body["error"]).to eq(I18n.t("email_login_code.invalid_code"))
expect(user.user_auth_tokens).to be_empty
post "/session/password-reset-code/verify.json", params: { code: reset_code }
expect(response.parsed_body["redirect_url"]).to start_with("/u/password-reset/")
post "/session/login-code/verify.json", params: { email: user.email, code: login_code }
expect(response.status).to eq(200)
expect(response.parsed_body.dig("user", "username")).to eq(user.username)
expect(user.user_auth_tokens.count).to eq(1)
end
it "requires the existing second factor before changing the password" do
second_factor = Fabricate(:user_second_factor_totp, user:)
code = request_password_reset_code
post "/session/password-reset-code/verify.json", params: { code: }
reset_url = response.parsed_body["redirect_url"]
get reset_url
put reset_url, params: { password: "aNewSecurePassword123!" }
expect(user.reload.confirm_password?("aNewSecurePassword123!")).to eq(false)
expect(user.user_auth_tokens).to be_empty
put reset_url,
params: {
password: "aNewSecurePassword123!",
second_factor_token: ROTP::TOTP.new(second_factor.data).now,
second_factor_method: UserSecondFactor.methods[:totp],
}
expect(response.status).to eq(200)
expect(user.reload.confirm_password?("aNewSecurePassword123!")).to eq(true)
end
it "rejects a code from another browser even when its identifiers are supplied" do
code = request_password_reset_code
login_code = EmailLoginCode.for_email(user.email).sole
reset!
expect do
post "/session/password-reset-code/verify.json",
params: {
code:,
login_code_id: login_code.id,
user_id: user.id,
}
end.not_to change(EmailToken, :count)
expect(response.parsed_body["error"]).to eq(I18n.t("email_login_code.invalid_code"))
end
it "invalidates the previous code when another is requested" do
SecureRandom
.stubs(:random_number)
.with(10**EmailLoginCode::CODE_LENGTH)
.returns(123_456, 654_321)
previous_code = request_password_reset_code
code = request_password_reset_code
post "/session/password-reset-code/verify.json", params: { code: previous_code }
expect(response.parsed_body["error"]).to eq(I18n.t("email_login_code.invalid_code"))
post "/session/password-reset-code/verify.json", params: { code: }
expect(response.parsed_body["redirect_url"]).to be_present
end
it "keeps the latest code usable when a resend is rate limited" do
RateLimiter.enable
request_password_reset_code
request_password_reset_code
code = request_password_reset_code
post "/session/forgot_password.json", params: { login: user.email }
expect(response.status).to eq(422)
post "/session/password-reset-code/verify.json", params: { code: }
expect(response.status).to eq(200)
expect(response.parsed_body["redirect_url"]).to be_present
end
it "allows the code to be redeemed only once" do
code = request_password_reset_code
post "/session/password-reset-code/verify.json", params: { code: }
expect do
post "/session/password-reset-code/verify.json", params: { code: }
end.not_to change(EmailToken, :count)
expect(response.parsed_body["error"]).to eq(I18n.t("email_login_code.invalid_code"))
end
it "clears an earlier reset request when the next account is unknown" do
code = request_password_reset_code
post "/session/forgot_password.json", params: { login: "[email protected]" }
post "/session/password-reset-code/verify.json", params: { code: }
expect(response.parsed_body["error"]).to eq(I18n.t("email_login_code.invalid_code"))
expect(user.email_tokens.where(scope: EmailToken.scopes[:password_reset])).to be_empty
end
it "returns 404 when email codes are disabled" do
SiteSetting.enable_local_logins_via_code = false
post "/session/password-reset-code/verify.json", params: { code: "123456" }
expect(response.status).to eq(404)
end
it "blocks verification when local logins are disabled" do
code = request_password_reset_code
SiteSetting.enable_local_logins = false
post "/session/password-reset-code/verify.json", params: { code: }
expect(response.status).to eq(403)
expect(user.email_tokens.where(scope: EmailToken.scopes[:password_reset])).to be_empty
end
it "blocks nonstaff when staff writes only mode is enabled after requesting a code" do
code = request_password_reset_code
Discourse.enable_readonly_mode(Discourse::STAFF_WRITES_ONLY_MODE_KEY)
post "/session/password-reset-code/verify.json", params: { code: }
expect(response.status).to eq(503)
expect(user.email_tokens.where(scope: EmailToken.scopes[:password_reset])).to be_empty
end
it "rate limits verification attempts" do
RateLimiter.enable
6.times { post "/session/password-reset-code/verify.json", params: { code: "123456" } }
post "/session/password-reset-code/verify.json", params: { code: "123456" }
expect(response.status).to eq(429)
end
end
describe "#current" do
context "when not logged in" do
it "returns 404" do
get "/session/current.json"
expect(response.status).to eq(404)
end
end
context "when logged in" do
let!(:user) { sign_in(Fabricate(:user)) }
it "returns the JSON for the user" do
get "/session/current.json"
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
json = response.parsed_body
expect(json["current_user"]).to be_present
expect(json["current_user"]["id"]).to eq(user.id)
end
it "does not include a featured topic the user cannot see" do
private_category = Fabricate(:private_category, group: Fabricate(:group))
featured_topic = Fabricate(:topic, category: private_category)
user.user_profile.update!(featured_topic_id: featured_topic.id)
get "/session/current.json"
expect(response.status).to eq(200)
expect(response.parsed_body["current_user"]).not_to have_key("featured_topic")
end
end
context "when logged in as an anonymous shadow user" do
fab!(:master_user) { Fabricate(:user, trust_level: TrustLevel[3]) }
before do
SiteSetting.allow_anonymous_mode = true
SiteSetting.anonymous_posting_allowed_groups = Group::AUTO_GROUPS[:trust_level_1].to_s
end
it "stops authenticating when the master account is suspended", :aggregate_failures do
shadow_user = AnonymousShadowCreator.get(master_user)
sign_in(shadow_user)
get "/session/current.json"
expect(response.status).to eq(200)
UserSuspender.new(
master_user,
suspended_till: 1.day.from_now,
reason: "spam",
by_user: admin,
).suspend
get "/session/current.json"
expect(response.status).to eq(404)
expect(response.body).to be_blank
end
it "stops authenticating when the master account is deactivated", :aggregate_failures do
shadow_user = AnonymousShadowCreator.get(master_user)
sign_in(shadow_user)
get "/session/current.json"
expect(response.status).to eq(200)
master_user.deactivate(admin)
get "/session/current.json"
expect(response.status).to eq(404)
expect(response.body).to be_blank
end
end
end
describe "#second_factor_auth_show" do
let!(:user_second_factor) { Fabricate(:user_second_factor_totp, user: user) }
it "can work for anon" do
post "/session/2fa/test-action?username=#{user.username}", xhr: true
expect(response.status).to eq(403)
nonce = response.parsed_body["second_factor_challenge_nonce"]
get "/session/2fa.json", params: { nonce: nonce }
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
end
it "throws an error if logged in to a different user" do
sign_in user
other_user = Fabricate(:user)
post "/session/2fa/test-action?username=#{other_user.username}", xhr: true
expect(response.status).to eq(400)
expect(response.parsed_body["result"]).to eq("wrong user")
end
context "when logged in" do
before { sign_in(user) }
it "returns 404 if there is no challenge for the given nonce" do
get "/session/2fa.json", params: { nonce: "asdasdsadsad" }
expect(response.status).to eq(404)
expect(response.parsed_body["error"]).to eq(
I18n.t("second_factor_auth.challenge_not_found"),
)
end
it "returns 404 if the nonce does not match the challenge nonce" do
post "/session/2fa/test-action"
get "/session/2fa.json", params: { nonce: "wrongnonce" }
expect(response.status).to eq(404)
expect(response.parsed_body["error"]).to eq(
I18n.t("second_factor_auth.challenge_not_found"),
)
end
it "returns 401 if the challenge nonce has expired" do
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)
expect(response.parsed_body["error"]).not_to be_present
freeze_time (SecondFactor::AuthManager::MAX_CHALLENGE_AGE + 1.minute).from_now
get "/session/2fa.json", params: { nonce: nonce }
expect(response.status).to eq(401)
expect(response.parsed_body["error"]).to eq(I18n.t("second_factor_auth.challenge_expired"))
end
it "responds with challenge data" do
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)
expect(response.parsed_body["error"]).not_to be_present
challenge_data = response.parsed_body
expect(challenge_data["totp_enabled"]).to eq(true)
expect(challenge_data["backup_enabled"]).to eq(false)
expect(challenge_data["security_keys_enabled"]).to eq(false)
expect(challenge_data["passkeys_enabled"]).to eq(false)
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")
Fabricate(
:user_security_key_with_random_credential,
user: user,
name: "Enabled YubiKey",
enabled: true,
)
Fabricate(:user_second_factor_backup, user: user)
post "/session/2fa/test-action", params: { allow_backup_codes: true }, xhr: true
nonce = response.parsed_body["second_factor_challenge_nonce"]
get "/session/2fa.json", params: { nonce: nonce }
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
challenge_data = response.parsed_body
expect(challenge_data["totp_enabled"]).to eq(true)
expect(challenge_data["backup_enabled"]).to eq(true)
expect(challenge_data["security_keys_enabled"]).to eq(true)
expect(challenge_data["allowed_credential_ids"]).to be_present
expect(challenge_data["challenge"]).to be_present
expect(challenge_data["allowed_methods"]).to contain_exactly(
UserSecondFactor.methods[:totp],
UserSecondFactor.methods[:security_key],
UserSecondFactor.methods[:passkey],
UserSecondFactor.methods[:backup_codes],
)
end
context "when the user has a passkey and allow_passkeys_for_2fa is enabled" do
before { SiteSetting.allow_passkeys_for_2fa = true }
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
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 }
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(false)
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
before { SiteSetting.allow_passkeys_for_2fa = false }
let!(:passkey) { Fabricate(:passkey_with_random_credential, user: user) }
it "does not expose the passkey" do
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(false)
expect(challenge_data["allowed_credential_ids"]).to be_blank
expect(challenge_data["passkey_allowed_credential_ids"]).to be_blank
end
end
end
end
describe "#second_factor_auth_perform" do
let!(:user_second_factor) { Fabricate(:user_second_factor_totp, user: user) }
it "works as anon" do
post "/session/2fa/test-action?username=#{user.username}", xhr: true
nonce = response.parsed_body["second_factor_challenge_nonce"]
token = ROTP::TOTP.new(user_second_factor.data).now
post "/session/2fa.json",
params: {
nonce: nonce,
second_factor_method: UserSecondFactor.methods[:totp],
second_factor_token: token,
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
post "/session/2fa/test-action?username=#{user.username}",
params: {
second_factor_nonce: nonce,
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
expect(response.parsed_body["result"]).to eq("second_factor_auth_completed")
end
it "prevents use by different user" do
other_user = Fabricate(:user)
post "/session/2fa/test-action?username=#{user.username}", xhr: true
expect(response.status).to eq(403)
end
context "when signed in" do
before { sign_in(user) }
it "returns 401 if the challenge nonce has expired" do
post "/session/2fa/test-action", xhr: true
nonce = response.parsed_body["second_factor_challenge_nonce"]
freeze_time (SecondFactor::AuthManager::MAX_CHALLENGE_AGE + 1.minute).from_now
token = ROTP::TOTP.new(user_second_factor.data).now
post "/session/2fa.json",
params: {
nonce: nonce,
second_factor_method: UserSecondFactor.methods[:totp],
second_factor_token: token,
}
expect(response.status).to eq(401)
expect(response.parsed_body["error"]).to eq(I18n.t("second_factor_auth.challenge_expired"))
end
it "returns 403 if the 2FA method is not allowed" do
Fabricate(:user_second_factor_backup, user: user)
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[:backup_codes],
second_factor_token: "iAmValidBackupCode",
}
expect(response.status).to eq(403)
end
it "returns 403 if the user disables the 2FA method in the middle of the 2FA process" do
post "/session/2fa/test-action", xhr: true
nonce = response.parsed_body["second_factor_challenge_nonce"]
token = ROTP::TOTP.new(user_second_factor.data).now
user_second_factor.destroy!
post "/session/2fa.json",
params: {
nonce: nonce,
second_factor_method: UserSecondFactor.methods[:totp],
second_factor_token: token,
}
expect(response.status).to eq(403)
end
it "marks the challenge as successful if the 2fa succeeds" do
post "/session/2fa/test-action", params: { redirect_url: "/ggg" }, xhr: true
nonce = response.parsed_body["second_factor_challenge_nonce"]
token = ROTP::TOTP.new(user_second_factor.data).now
post "/session/2fa.json",
params: {
nonce: nonce,
second_factor_method: UserSecondFactor.methods[:totp],
second_factor_token: token,
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
expect(response.parsed_body["ok"]).to eq(true)
expect(response.parsed_body["callback_method"]).to eq("POST")
expect(response.parsed_body["callback_path"]).to eq("/session/2fa/test-action")
expect(response.parsed_body["redirect_url"]).to eq("/ggg")
post "/session/2fa/test-action", params: { second_factor_nonce: nonce }
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
expect(response.parsed_body["result"]).to eq("second_factor_auth_completed")
end
it "does not mark the challenge as successful if the 2fa fails" do
post "/session/2fa/test-action", params: { redirect_url: "/ggg" }, xhr: true
nonce = response.parsed_body["second_factor_challenge_nonce"]
token = ROTP::TOTP.new(user_second_factor.data).now.to_i
token += token == 999_999 ? -1 : 1
post "/session/2fa.json",
params: {
nonce: nonce,
second_factor_method: UserSecondFactor.methods[:totp],
second_factor_token: token.to_s,
}
expect(response.status).to eq(400)
expect(response.parsed_body["ok"]).to eq(false)
expect(response.parsed_body["reason"]).to eq("invalid_second_factor")
expect(response.parsed_body["error"]).to eq(I18n.t("login.invalid_second_factor_code"))
post "/session/2fa/test-action", params: { second_factor_nonce: nonce }
expect(response.status).to eq(401)
end
context "with a passkey credential" 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
user.create_or_fetch_secure_identifier
DiscourseWebauthn.stubs(:origin).returns("http://localhost:3000")
end
it "satisfies 2fa when allow_passkeys_for_2fa is enabled" do
SiteSetting.allow_passkeys_for_2fa = true
simulate_localhost_passkey_challenge
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_passkey_auth_data,
}
expect(response.status).to eq(200)
expect(response.parsed_body["ok"]).to eq(true)
end
it "is rejected when allow_passkeys_for_2fa is disabled" do
SiteSetting.allow_passkeys_for_2fa = false
simulate_localhost_passkey_challenge
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_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
passkey.update!(enabled: false)
Fabricate(:passkey_with_random_credential, user: user)
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_passkey_auth_data,
}
expect(response.status).to eq(400)
expect(response.parsed_body["error"]).to eq(I18n.t("webauthn.validation.not_found_error"))
end
end
end
end
describe "#passkey_challenge" do
it "returns a challenge for an anonymous user" do
get "/session/passkey/challenge.json"
expect(response.status).to eq(200)
expect(response.parsed_body["challenge"]).not_to eq(nil)
end
it "returns a challenge for an authenticated user" do
sign_in(user)
get "/session/passkey/challenge.json"
expect(response.status).to eq(200)
expect(response.parsed_body["challenge"]).not_to eq(nil)
end
it "reset challenge on subsequent calls" do
get "/session/passkey/challenge.json"
expect(response.status).to eq(200)
challenge1 = response.parsed_body["challenge"]
get "/session/passkey/challenge.json"
expect(response.parsed_body["challenge"]).not_to eq(challenge1)
end
it "fails if local logins are not allowed" do
SiteSetting.enable_local_logins = false
get "/session/passkey/challenge.json"
expect(response.status).to eq(403)
end
end
describe "#passkey_login" do
before { DiscourseWebauthn.stubs(:origin).returns("http://localhost:3000") }
it "returns 404 if feature is not enabled" do
SiteSetting.enable_passkeys = false
post "/session/passkey/auth.json"
expect(response.status).to eq(404)
end
context "when enable_passkeys is enabled" do
before { SiteSetting.enable_passkeys = true }
it "fails if public key param is missing" do
post "/session/passkey/auth.json"
expect(response.status).to eq(400)
json = response.parsed_body
expect(json["errors"][0]).to include("param is missing")
expect(json["errors"][0]).to include("publicKeyCredential")
end
it "fails on malformed credentials" do
post "/session/passkey/auth.json", params: { publicKeyCredential: "someboringstring" }
expect(response.status).to eq(401)
json = response.parsed_body
expect(json["errors"][0]).to eq(
I18n.t("webauthn.validation.malformed_public_key_credential_error"),
)
end
it "fails on invalid credentials" do
post "/session/passkey/auth.json",
params: {
# creds are well-formed but security key is not registered
publicKeyCredential: {
signature:
"MEYCIQDYtbfkTGHOfizXHBHltn5KOq1eC3EM6Uq4peZ0L+3wMwIhAMgzm88qOOZ7SPYh5M6zvKMjVsUAne7n9RKdN/4Bb6z8",
clientData:
"eyJ0eXBlIjoid2ViYXV0aG4uZ2V0IiwiY2hhbGxlbmdlIjoiWmpJMk16UmxNMlV3TkRSaFl6QmhNemczTURjMlpUaGhaR1l5T1dGaU5qSXpNamMxWmpCaU9EVmxNVFUzTURaaVpEaGpNVEUwTVdJeU1qRXkiLCJvcmlnaW4iOiJodHRwOi8vbG9jYWxob3N0OjMwMDAiLCJjcm9zc09yaWdpbiI6ZmFsc2x9",
authenticatorData: "SZYN5YgOjGh0NBcPZHZgW4/krrmihjLHmVzzuoMdl2MFAAAAAA==",
credentialId: "humAArAAAiZZuwFE/F9Gi4BAVTsRL/FowuzQsYTPKIk=",
},
}
expect(response.status).to eq(401)
json = response.parsed_body
expect(json["errors"][0]).to eq(I18n.t("webauthn.validation.not_found_error"))
end
context "when user has a valid registered passkey" do
let!(:passkey) do
Fabricate(
:user_security_key,
credential_id: valid_passkey_data[:credential_id],
public_key: valid_passkey_data[:public_key],
user: user,
factor_type: UserSecurityKey.factor_types[:first_factor],
last_used: nil,
name: "A key",
)
end
it "fails if local logins are not allowed" do
SiteSetting.enable_local_logins = false
post "/session/passkey/auth.json",
params: {
publicKeyCredential: valid_passkey_auth_data,
}
expect(response.status).to eq(403)
end
it "fails when the key is registered to another user" do
simulate_localhost_passkey_challenge
user.activate
user.create_or_fetch_secure_identifier
post "/session/passkey/auth.json",
params: {
publicKeyCredential:
valid_passkey_auth_data.merge(
{ userHandle: Base64.strict_encode64(SecureRandom.hex(20)) },
),
}
expect(response.status).to eq(401)
json = response.parsed_body
expect(json["errors"][0]).to eq(I18n.t("webauthn.validation.ownership_error"))
expect(session[:current_user_id]).to eq(nil)
end
it "fails when discourse connect is enabled" do
SiteSetting.discourse_connect_url = "https://www.example.com/sso"
SiteSetting.discourse_connect_secret = "x" * 10
SiteSetting.enable_discourse_connect = true
simulate_localhost_passkey_challenge
user.activate
user.create_or_fetch_secure_identifier
post "/session/passkey/auth.json",
params: {
publicKeyCredential:
valid_passkey_auth_data.merge(
{ userHandle: Base64.strict_encode64(user.secure_identifier) },
),
}
expect(response.status).to eq(403)
end
it "logs the user in" do
simulate_localhost_passkey_challenge
user.activate
user.create_or_fetch_secure_identifier
post "/session/passkey/auth.json",
params: {
publicKeyCredential:
valid_passkey_auth_data.merge(
{ userHandle: Base64.strict_encode64(user.secure_identifier) },
),
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).not_to be_present
expect(session[:current_user_id]).to eq(user.id)
end
it "does not log in a suspended user" do
simulate_localhost_passkey_challenge
user.activate
user.create_or_fetch_secure_identifier
user.update!(suspended_till: 2.days.from_now, suspended_at: Time.zone.now)
post "/session/passkey/auth.json",
params: {
publicKeyCredential:
valid_passkey_auth_data.merge(
{ userHandle: Base64.strict_encode64(user.secure_identifier) },
),
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to be_present
expect(response.parsed_body["reason"]).to eq("suspended")
expect(session[:current_user_id]).to be_nil
end
it "does not log in a user from a screened IP address" do
simulate_localhost_passkey_challenge
user.activate
user.create_or_fetch_secure_identifier
ScreenedIpAddress.all.destroy_all
get "/"
Fabricate(:screened_ip_address, ip_address: request.remote_ip)
post "/session/passkey/auth.json",
params: {
publicKeyCredential:
valid_passkey_auth_data.merge(
{ userHandle: Base64.strict_encode64(user.secure_identifier) },
),
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to be_present
expect(session[:current_user_id]).to be_nil
end
it "does not log in an unapproved user when must_approve_users is enabled" do
SiteSetting.must_approve_users = true
simulate_localhost_passkey_challenge
user.activate
user.create_or_fetch_secure_identifier
user.update_columns(approved: false)
post "/session/passkey/auth.json",
params: {
publicKeyCredential:
valid_passkey_auth_data.merge(
{ userHandle: Base64.strict_encode64(user.secure_identifier) },
),
}
expect(response.status).to eq(200)
expect(response.parsed_body["error"]).to eq(I18n.t("login.not_approved"))
expect(session[:current_user_id]).to be_nil
end
context "with a valid discourse connect provider" do
before do
sso = DiscourseConnectBase.new
sso.nonce = "mynonce"
sso.sso_secret = "topsecret"
sso.return_sso_url = "http://somewhere.over.rainbow/sso"
cookies[:sso_payload] = sso.payload
provider_uid = 12_345
UserAssociatedAccount.create!(
provider_name: "google_oauth2",
provider_uid: provider_uid,
user: user,
)
SiteSetting.enable_discourse_connect_provider = true
SiteSetting.discourse_connect_secret = sso.sso_secret
SiteSetting.discourse_connect_provider_secrets =
"somewhere.over.rainbow|#{sso.sso_secret}"
end
it "logs the user in" do
simulate_localhost_passkey_challenge
user.activate
user.create_or_fetch_secure_identifier
post "/session/passkey/auth.json",
params: {
publicKeyCredential:
valid_passkey_auth_data.merge(
{ userHandle: Base64.strict_encode64(user.secure_identifier) },
),
}
expect(response.status).to eq(302)
expect(response.location).to start_with("http://somewhere.over.rainbow/sso")
end
end
end
end
end
describe "#scopes" do
context "when not a valid api request" do
it "returns 404" do
get "/session/scopes.json"
expect(response.status).to eq(404)
end
end
context "when a valid api request" do
let(:admin) { Fabricate(:admin) }
let(:scope) do
ApiKeyScope.new(resource: "topics", action: "read", allowed_parameters: { topic_id: "3" })
end
let(:api_key) { Fabricate(:api_key, user: admin, api_key_scopes: [scope]) }
it "returns the scopes of the api key" do
get "/session/scopes.json",
headers: {
"Api-Key": api_key.key,
"Api-Username": admin.username,
}
expect(response.status).to eq(200)
json = response.parsed_body
expect(json["scopes"].size).to eq(1)
expect(json["scopes"].first["resource"]).to eq("topics")
expect(json["scopes"].first["action"]).to eq("read")
expect(json["scopes"].first["allowed_parameters"]).to eq({ topic_id: "3" }.as_json)
end
end
end
end