238 lines
8.4 KiB
Ruby
238 lines
8.4 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
require 'spec_helper'
|
|
|
|
RSpec.describe 'Using WebAuthn Devices for Authentication', :js do
|
|
include Spec::Support::Helpers::Features::TwoFactorHelpers
|
|
let(:app_id) { "http://#{Capybara.current_session.server.host}:#{Capybara.current_session.server.port}" }
|
|
|
|
before do
|
|
WebAuthn.configuration.origin = app_id
|
|
end
|
|
|
|
it_behaves_like 'hardware device for 2fa', 'WebAuthn'
|
|
|
|
describe 'registration' do
|
|
let(:user) { create(:user) }
|
|
|
|
before do
|
|
gitlab_sign_in(user)
|
|
user.update_attribute(:otp_required_for_login, true)
|
|
end
|
|
|
|
describe 'when 2FA via OTP is enabled' do
|
|
it 'allows registering more than one device' do
|
|
visit profile_account_path
|
|
|
|
# First device
|
|
manage_two_factor_authentication
|
|
first_device = register_webauthn_device
|
|
expect(page).to have_content('Your WebAuthn device was registered')
|
|
|
|
# Second device
|
|
second_device = register_webauthn_device(name: 'My other device')
|
|
expect(page).to have_content('Your WebAuthn device was registered')
|
|
|
|
expect(page).to have_content(first_device.name)
|
|
expect(page).to have_content(second_device.name)
|
|
expect(WebauthnRegistration.count).to eq(2)
|
|
end
|
|
end
|
|
|
|
it 'allows the same device to be registered for multiple users' do
|
|
# First user
|
|
visit profile_account_path
|
|
manage_two_factor_authentication
|
|
webauthn_device = register_webauthn_device
|
|
expect(page).to have_content('Your WebAuthn device was registered')
|
|
gitlab_sign_out
|
|
|
|
# Second user
|
|
user = gitlab_sign_in(:user)
|
|
user.update_attribute(:otp_required_for_login, true)
|
|
visit profile_account_path
|
|
manage_two_factor_authentication
|
|
register_webauthn_device(webauthn_device, name: 'My other device')
|
|
expect(page).to have_content('Your WebAuthn device was registered')
|
|
|
|
expect(WebauthnRegistration.count).to eq(2)
|
|
end
|
|
|
|
context 'when there are form errors' do
|
|
let(:mock_register_js) do
|
|
<<~JS
|
|
const mockResponse = {
|
|
type: 'public-key',
|
|
id: '',
|
|
rawId: '',
|
|
response: {
|
|
clientDataJSON: '',
|
|
attestationObject: '',
|
|
},
|
|
getClientExtensionResults: () => {},
|
|
};
|
|
navigator.credentials.create = function(_) {return Promise.resolve(mockResponse);}
|
|
JS
|
|
end
|
|
|
|
it "doesn't register the device if there are errors" do
|
|
visit profile_account_path
|
|
manage_two_factor_authentication
|
|
|
|
# Have the "webauthn device" respond with bad data
|
|
page.execute_script(mock_register_js)
|
|
click_on 'Set up new device'
|
|
expect(page).to have_content('Your device was successfully set up')
|
|
click_on 'Register device'
|
|
|
|
expect(WebauthnRegistration.count).to eq(0)
|
|
expect(page).to have_content('The form contains the following error')
|
|
expect(page).to have_content('did not send a valid JSON response')
|
|
end
|
|
|
|
it 'allows retrying registration' do
|
|
visit profile_account_path
|
|
manage_two_factor_authentication
|
|
|
|
# Failed registration
|
|
page.execute_script(mock_register_js)
|
|
click_on 'Set up new device'
|
|
expect(page).to have_content('Your device was successfully set up')
|
|
click_on 'Register device'
|
|
expect(page).to have_content('The form contains the following error')
|
|
|
|
# Successful registration
|
|
register_webauthn_device
|
|
|
|
expect(page).to have_content('Your WebAuthn device was registered')
|
|
expect(WebauthnRegistration.count).to eq(1)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe 'authentication' do
|
|
let(:otp_required_for_login) { true }
|
|
let(:user) { create(:user, webauthn_xid: WebAuthn.generate_user_id, otp_required_for_login: otp_required_for_login) }
|
|
|
|
describe 'when there is only an U2F device' do
|
|
let!(:u2f_device) do
|
|
fake_device = U2F::FakeU2F.new(app_id) # "Client"
|
|
u2f = U2F::U2F.new(app_id) # "Server"
|
|
|
|
challenges = u2f.registration_requests.map(&:challenge)
|
|
device_response = fake_device.register_response(challenges[0])
|
|
device_registration_params = { device_response: device_response,
|
|
name: 'My device' }
|
|
|
|
U2fRegistration.register(user, app_id, device_registration_params, challenges)
|
|
FakeU2fDevice.new(page, 'My device', fake_device)
|
|
end
|
|
|
|
it 'falls back to U2F' do
|
|
# WebAuthn registration is automatically created with the U2fRegistration because of the after_create callback
|
|
# so we need to delete it
|
|
WebauthnRegistration.delete_all
|
|
|
|
gitlab_sign_in(user)
|
|
|
|
u2f_device.respond_to_u2f_authentication
|
|
|
|
expect(page).to have_css('.sign-out-link', visible: false)
|
|
end
|
|
end
|
|
|
|
describe 'when there is a WebAuthn device' do
|
|
let!(:webauthn_device) do
|
|
add_webauthn_device(app_id, user)
|
|
end
|
|
|
|
describe 'when 2FA via OTP is disabled' do
|
|
let(:otp_required_for_login) { false }
|
|
|
|
it 'allows logging in with the WebAuthn device' do
|
|
gitlab_sign_in(user)
|
|
|
|
webauthn_device.respond_to_webauthn_authentication
|
|
|
|
expect(page).to have_css('.sign-out-link', visible: false)
|
|
end
|
|
end
|
|
|
|
describe 'when 2FA via OTP is enabled' do
|
|
it 'allows logging in with the WebAuthn device' do
|
|
gitlab_sign_in(user)
|
|
|
|
webauthn_device.respond_to_webauthn_authentication
|
|
|
|
expect(page).to have_css('.sign-out-link', visible: false)
|
|
end
|
|
end
|
|
|
|
describe 'when a given WebAuthn device has already been registered by another user' do
|
|
describe 'but not the current user' do
|
|
let(:other_user) { create(:user, webauthn_xid: WebAuthn.generate_user_id, otp_required_for_login: otp_required_for_login) }
|
|
|
|
it 'does not allow logging in with that particular device' do
|
|
# Register other user with a different WebAuthn device
|
|
other_device = add_webauthn_device(app_id, other_user)
|
|
|
|
# Try authenticating user with the old WebAuthn device
|
|
gitlab_sign_in(user)
|
|
other_device.respond_to_webauthn_authentication
|
|
expect(page).to have_content('Authentication via WebAuthn device failed')
|
|
end
|
|
end
|
|
|
|
describe "and also the current user" do
|
|
# TODO Uncomment once WebAuthn::FakeClient supports passing credential options
|
|
# (especially allow_credentials, as this is needed to specify which credential the
|
|
# fake client should use. Currently, the first credential is always used).
|
|
# There is an issue open for this: https://github.com/cedarcode/webauthn-ruby/issues/259
|
|
it "allows logging in with that particular device" do
|
|
pending("support for passing credential options in FakeClient")
|
|
# Register current user with the same WebAuthn device
|
|
current_user = gitlab_sign_in(:user)
|
|
visit profile_account_path
|
|
manage_two_factor_authentication
|
|
register_webauthn_device(webauthn_device)
|
|
gitlab_sign_out
|
|
|
|
# Try authenticating user with the same WebAuthn device
|
|
gitlab_sign_in(current_user)
|
|
webauthn_device.respond_to_webauthn_authentication
|
|
|
|
expect(page).to have_css('.sign-out-link', visible: false)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe 'when a given WebAuthn device has not been registered' do
|
|
it 'does not allow logging in with that particular device' do
|
|
unregistered_device = FakeWebauthnDevice.new(page, 'My device')
|
|
gitlab_sign_in(user)
|
|
unregistered_device.respond_to_webauthn_authentication
|
|
|
|
expect(page).to have_content('Authentication via WebAuthn device failed')
|
|
end
|
|
end
|
|
|
|
describe 'when more than one device has been registered by the same user' do
|
|
it 'allows logging in with either device' do
|
|
first_device = add_webauthn_device(app_id, user)
|
|
second_device = add_webauthn_device(app_id, user)
|
|
|
|
# Authenticate as both devices
|
|
[first_device, second_device].each do |device|
|
|
gitlab_sign_in(user)
|
|
# register_webauthn_device(device)
|
|
device.respond_to_webauthn_authentication
|
|
|
|
expect(page).to have_css('.sign-out-link', visible: false)
|
|
|
|
gitlab_sign_out
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|