diff --git a/BeatSaberModManager/Program.cs b/BeatSaberModManager/Program.cs
index ec6de75..77b86ce 100644
--- a/BeatSaberModManager/Program.cs
+++ b/BeatSaberModManager/Program.cs
@@ -156,7 +156,7 @@ internal static class AssetProvidersModule;
         [Register<ModsViewModel>(Scope.SingleInstance)]
         [Register<LegacyGameVersionsViewModel>(Scope.SingleInstance)]
         [Register<SettingsViewModel>(Scope.SingleInstance)]
-        [Register(typeof(SteamAuthenticationViewModel), Scope.SingleInstance, typeof(SteamAuthenticationViewModel), typeof(ISteamAuthenticator))]
+        [Register<SteamAuthenticationViewModel>(Scope.SingleInstance)]
         [Register<AssetInstallWindowViewModel>(Scope.SingleInstance)]
         internal static class ViewModelModule;
 
diff --git a/BeatSaberModManager/Resources/Localization/de.axaml b/BeatSaberModManager/Resources/Localization/de.axaml
index d23edd4..88761d1 100644
--- a/BeatSaberModManager/Resources/Localization/de.axaml
+++ b/BeatSaberModManager/Resources/Localization/de.axaml
@@ -87,6 +87,9 @@
     <sys:String x:Key="SteamGuardCodeView:SubmitButton">Absenden</sys:String>
     <sys:String x:Key="SteamGuardCodeView:CancelButton">Cancel</sys:String>
 
+    <sys:String x:Key="SteamDeviceConfirmationView:ConfirmLogin">Benutze die Steam App, um deine Anmeldung zu bestätigen</sys:String>
+    <sys:String x:Key="SteamDeviceConfirmationView:Title">Anmeldung Bestätigen</sys:String>
+
     <sys:String x:Key="Status:Installing">Installiere:</sys:String>
     <sys:String x:Key="Status:Uninstalling">Deinstalliere:</sys:String>
     <sys:String x:Key="Status:Completed">Installation abgeschlossen</sys:String>
diff --git a/BeatSaberModManager/Resources/Localization/en.axaml b/BeatSaberModManager/Resources/Localization/en.axaml
index f3c97b7..1885cbb 100644
--- a/BeatSaberModManager/Resources/Localization/en.axaml
+++ b/BeatSaberModManager/Resources/Localization/en.axaml
@@ -87,6 +87,9 @@
     <sys:String x:Key="SteamGuardCodeView:SubmitButton">Submit</sys:String>
     <sys:String x:Key="SteamGuardCodeView:CancelButton">Cancel</sys:String>
 
+    <sys:String x:Key="SteamDeviceConfirmationView:ConfirmLogin">Use the Steam mobile app to confirm your sign in</sys:String>
+    <sys:String x:Key="SteamDeviceConfirmationView:Title">Confirm Login</sys:String>
+
     <sys:String x:Key="Status:Installing">Installing:</sys:String>
     <sys:String x:Key="Status:Uninstalling">Uninstalling:</sys:String>
     <sys:String x:Key="Status:Completed">Installation completed</sys:String>
diff --git a/BeatSaberModManager/Services/Implementations/GameVersions/Steam/SteamLegacyGameVersionInstaller.cs b/BeatSaberModManager/Services/Implementations/GameVersions/Steam/SteamLegacyGameVersionInstaller.cs
index ada9f66..41da9cd 100644
--- a/BeatSaberModManager/Services/Implementations/GameVersions/Steam/SteamLegacyGameVersionInstaller.cs
+++ b/BeatSaberModManager/Services/Implementations/GameVersions/Steam/SteamLegacyGameVersionInstaller.cs
@@ -16,20 +16,26 @@
 namespace BeatSaberModManager.Services.Implementations.GameVersions.Steam
 {
     /// <inheritdoc />
-    public class SteamLegacyGameVersionInstaller(Steam3Session steam3Session, ISteamAuthenticator steamAuthenticator, ILogger logger) : ILegacyGameVersionInstaller
+    public class SteamLegacyGameVersionInstaller(Steam3Session steam3Session, ILogger logger) : ILegacyGameVersionInstaller
     {
         /// <inheritdoc />
-        public async Task<string?> InstallLegacyGameVersionAsync(IGameVersion gameVersion, CancellationToken cancellationToken, IProgress<double>? progress = null)
+        public async Task<string?> InstallLegacyGameVersionAsync(IGameVersion gameVersion, ILegacyGameVersionAuthenticator authenticator, CancellationToken cancellationToken, IProgress<double>? progress = null)
         {
             ArgumentNullException.ThrowIfNull(gameVersion);
-            if (gameVersion is not SteamGameVersion steamLegacyGameVersion)
+            if (gameVersion is not SteamGameVersion steamLegacyGameVersion || authenticator is not ISteamAuthenticator steamAuthenticator)
                 return null;
             string appDataDirPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
             string legacyGameVersionsDirPath = Path.Join(appDataDirPath, ThisAssembly.Info.Product, "LegacyGameVersions", gameVersion.GameVersion);
             DownloadConfig downloadConfig = new() { InstallDirectory = legacyGameVersionsDirPath, MaxDownloads = 3 };
-            await steam3Session.LoginAsync(steamAuthenticator, cancellationToken).ConfigureAwait(false);
-            if (cancellationToken.IsCancellationRequested)
+            try
+            {
+                await steam3Session.LoginAsync(steamAuthenticator, cancellationToken).ConfigureAwait(false);
+            }
+            catch (TaskCanceledException)
+            {
                 return null;
+            }
+
             ContentDownloader contentDownloader = new(downloadConfig, steam3Session);
             List<(uint DepotId, ulong ManifestId)> depotManifestIds = [(620981, steamLegacyGameVersion.ManifestId)];
             try
@@ -51,7 +57,6 @@ public class SteamLegacyGameVersionInstaller(Steam3Session steam3Session, ISteam
         /// <inheritdoc />
         public Task<bool> UninstallLegacyGameVersionAsync(IGameVersion gameVersion)
         {
-            // TODO: doesn't work
             ArgumentNullException.ThrowIfNull(gameVersion);
             if (gameVersion is not SteamGameVersion)
                 return Task.FromResult(false);
diff --git a/BeatSaberModManager/Services/Interfaces/ILegacyGameVersionAuthenticator.cs b/BeatSaberModManager/Services/Interfaces/ILegacyGameVersionAuthenticator.cs
new file mode 100644
index 0000000..1b3d245
--- /dev/null
+++ b/BeatSaberModManager/Services/Interfaces/ILegacyGameVersionAuthenticator.cs
@@ -0,0 +1,9 @@
+namespace BeatSaberModManager.Services.Interfaces
+{
+    /// <summary>
+    /// TODO
+    /// </summary>
+#pragma warning disable CA1040
+    public interface ILegacyGameVersionAuthenticator;
+#pragma warning restore CA1040
+}
diff --git a/BeatSaberModManager/Services/Interfaces/ILegacyGameVersionInstaller.cs b/BeatSaberModManager/Services/Interfaces/ILegacyGameVersionInstaller.cs
index e02999c..5412e73 100644
--- a/BeatSaberModManager/Services/Interfaces/ILegacyGameVersionInstaller.cs
+++ b/BeatSaberModManager/Services/Interfaces/ILegacyGameVersionInstaller.cs
@@ -16,10 +16,11 @@ public interface ILegacyGameVersionInstaller
         /// 
         /// </summary>
         /// <param name="gameVersion"></param>
+        /// <param name="authenticator"></param>
         /// <param name="cancellationToken"></param>
         /// <param name="progress"></param>
         /// <returns></returns>
-        Task<string?> InstallLegacyGameVersionAsync(IGameVersion gameVersion, CancellationToken cancellationToken, IProgress<double>? progress = null);
+        Task<string?> InstallLegacyGameVersionAsync(IGameVersion gameVersion, ILegacyGameVersionAuthenticator authenticator, CancellationToken cancellationToken, IProgress<double>? progress = null);
 
         /// <summary>
         /// 
diff --git a/BeatSaberModManager/ViewModels/LegacyGameVersionsViewModel.cs b/BeatSaberModManager/ViewModels/LegacyGameVersionsViewModel.cs
index b111a64..c4d6de1 100644
--- a/BeatSaberModManager/ViewModels/LegacyGameVersionsViewModel.cs
+++ b/BeatSaberModManager/ViewModels/LegacyGameVersionsViewModel.cs
@@ -20,7 +20,7 @@ namespace BeatSaberModManager.ViewModels
     /// <summary>
     /// TODO
     /// </summary>
-    public sealed class LegacyGameVersionsViewModel : ViewModelBase
+    public sealed class LegacyGameVersionsViewModel : ViewModelBase, IDisposable
     {
         private readonly IGameInstallLocator _gameInstallLocator;
         private readonly IInstallDirValidator _installDirValidator;
@@ -32,6 +32,8 @@ public sealed class LegacyGameVersionsViewModel : ViewModelBase
         private readonly ObservableAsPropertyHelper<bool> _canUninstall;
         private readonly ObservableAsPropertyHelper<LegacyGameVersionsTab[]> _legacyGameVersions;
 
+        private CancellationTokenSource? _installLegacyVersionCts;
+
         /// <summary>
         /// TODO
         /// </summary>
@@ -145,9 +147,12 @@ public GameVersionViewModel? SelectedGameVersion
 
         private async Task<IReadOnlyList<GameVersionViewModel>?> GetLegacyGameVersionsAsync()
         {
-            IReadOnlyList<IGameVersion>? availableGameVersions = await _legacyGameVersionProvider.GetAvailableGameVersionsAsync().ConfigureAwait(false);
-            IReadOnlyList<IGameVersion>? installedLegacyGameVersions = await _legacyGameVersionProvider.GetInstalledLegacyGameVersionsAsync().ConfigureAwait(false);
-            IGameVersion? installedStoreVersion = await _gameInstallLocator.LocateGameInstallAsync().ConfigureAwait(false);
+            Task<IReadOnlyList<IGameVersion>?> t1 = _legacyGameVersionProvider.GetAvailableGameVersionsAsync();
+            Task<IReadOnlyList<IGameVersion>?> t2 = _legacyGameVersionProvider.GetInstalledLegacyGameVersionsAsync();
+            Task<IGameVersion?> t3 = _gameInstallLocator.LocateGameInstallAsync();
+            IReadOnlyList<IGameVersion>? availableGameVersions = await t1.ConfigureAwait(false);
+            IReadOnlyList<IGameVersion>? installedLegacyGameVersions = await t2.ConfigureAwait(false);
+            IGameVersion? installedStoreVersion = await t3.ConfigureAwait(false);
             List<IGameVersion> allInstalledGameVersions = installedLegacyGameVersions?.ToList() ?? [];
             if (installedStoreVersion is not null)
                 allInstalledGameVersions.Insert(0, installedStoreVersion);
@@ -166,11 +171,12 @@ public GameVersionViewModel? SelectedGameVersion
 
         private async Task<bool> InstallSelectedLegacyGameVersionAsync()
         {
+            _installLegacyVersionCts?.Dispose();
+            _installLegacyVersionCts = new CancellationTokenSource();
             GameVersionViewModel selectedGameVersion = SelectedGameVersion!;
             StatusProgress.Report(new ProgressInfo(StatusType.Installing, selectedGameVersion.GameVersion.GameVersion));
-            using CancellationTokenSource cts = new();
-            using IDisposable subscription = SteamAuthenticationViewModel.CancelCommand.Subscribe(_ => cts.Cancel());
-            string? installDir = await _legacyGameVersionInstaller.InstallLegacyGameVersionAsync(selectedGameVersion.GameVersion, cts.Token, StatusProgress).ConfigureAwait(false);
+            using IDisposable subscription = SteamAuthenticationViewModel.CancelCommand.Subscribe(_ => _installLegacyVersionCts.Cancel());
+            string? installDir = await Task.Run(() => _legacyGameVersionInstaller.InstallLegacyGameVersionAsync(selectedGameVersion.GameVersion, SteamAuthenticationViewModel, _installLegacyVersionCts.Token, StatusProgress)).ConfigureAwait(false);
             if (installDir is null)
             {
                 StatusProgress.Report(new ProgressInfo(StatusType.Failed, null));
@@ -205,5 +211,12 @@ private void MarkStoreVersionAsInstalled(IGameVersion storeVersion, IEnumerable<
                 break;
             }
         }
+
+        /// <inheritdoc />
+        public void Dispose()
+        {
+            _installLegacyVersionCts?.Cancel();
+            _installLegacyVersionCts?.Dispose();
+        }
     }
 }
diff --git a/BeatSaberModManager/ViewModels/SteamAuthenticationViewModel.cs b/BeatSaberModManager/ViewModels/SteamAuthenticationViewModel.cs
index 5ef132c..06c692a 100644
--- a/BeatSaberModManager/ViewModels/SteamAuthenticationViewModel.cs
+++ b/BeatSaberModManager/ViewModels/SteamAuthenticationViewModel.cs
@@ -5,6 +5,8 @@
 using System.Threading;
 using System.Threading.Tasks;
 
+using BeatSaberModManager.Services.Interfaces;
+
 using LibDepotDownloader;
 
 using ReactiveUI;
@@ -17,11 +19,13 @@ namespace BeatSaberModManager.ViewModels
     /// <summary>
     /// 
     /// </summary>
-    public sealed class SteamAuthenticationViewModel : ViewModelBase, ISteamAuthenticator, IDisposable
+    public sealed class SteamAuthenticationViewModel : ViewModelBase, ILegacyGameVersionAuthenticator, ISteamAuthenticator, IDisposable
     {
         private readonly Steam3Session _session;
 
-        private CancellationTokenSource? _cancellationTokenSource;
+        private CancellationTokenSource? _credentialsAuthSessionCts;
+        private CancellationTokenSource? _qrAuthSessionCts;
+        private CancellationTokenSource? _deviceConfirmationCts;
 
         /// <summary>
         /// 
@@ -32,27 +36,32 @@ public SteamAuthenticationViewModel(Steam3Session session)
             _session = session;
             IObservable<bool> canLogin = this.WhenAnyValue(static x => x.Username, static x => x.Password)
                 .Select(static x => !string.IsNullOrWhiteSpace(x.Item1) && !string.IsNullOrWhiteSpace(x.Item2));
-            LoginCommand = ReactiveCommand.CreateFromTask(LoginWithCredentialsAsync, canLogin);
-            CancelCommand = ReactiveCommand.Create(() => _cancellationTokenSource?.Cancel());
+            LoginCommand = ReactiveCommand.Create(() => { _qrAuthSessionCts?.Cancel(); }, canLogin);
+            CancelCommand = ReactiveCommand.Create(() => { _credentialsAuthSessionCts?.Cancel(); _qrAuthSessionCts?.Cancel(); });
             IObservable<bool> canSubmitSteamGuardCode = this.WhenAnyValue(static x => x.SteamGuardCode)
                 .Select(static code => code is not null && code.Length == 5);
             SubmitSteamGuardCodeCommand = ReactiveCommand.Create(() => SteamGuardCode!, canSubmitSteamGuardCode);
         }
 
         /// <summary>
-        /// TODO
+        /// 
+        /// </summary>
+        public Interaction<CancellationToken, Unit> AuthenticateInteraction { get; } = new(RxApp.MainThreadScheduler);
+
+        /// <summary>
+        /// 
         /// </summary>
-        public Interaction<Unit, AuthPollResult?> AuthenticateSteamInteraction { get; } = new(RxApp.MainThreadScheduler);
+        public Interaction<CancellationToken, Unit> DeviceConfirmationInteraction { get; } = new(RxApp.MainThreadScheduler);
 
         /// <summary>
         /// 
         /// </summary>
-        public Interaction<bool, string> GetSteamGuardCodeInteraction { get; } = new(RxApp.MainThreadScheduler);
+        public Interaction<Unit, string?> GetDeviceCodeInteraction { get; } = new(RxApp.MainThreadScheduler);
 
         /// <summary>
         /// 
         /// </summary>
-        public ReactiveCommand<Unit, AuthPollResult?> LoginCommand { get; }
+        public ReactiveCommand<Unit, Unit> LoginCommand { get; }
 
         /// <summary>
         /// 
@@ -108,6 +117,17 @@ public bool RememberPassword
 
         private bool _rememberPassword;
 
+        /// <summary>
+        /// 
+        /// </summary>
+        public bool IsPasswordInvalid
+        {
+            get => _isPasswordInvalid;
+            set => this.RaiseAndSetIfChanged(ref _isPasswordInvalid, value);
+        }
+
+        private bool _isPasswordInvalid;
+
         /// <summary>
         /// 
         /// </summary>
@@ -120,82 +140,74 @@ public string? SteamGuardCode
         private string? _steamGuardCode;
 
         /// <inheritdoc />
-        public Task<string> GetDeviceCodeAsync(bool previousCodeWasIncorrect) => GetSteamGuardCodeInteraction.Handle(previousCodeWasIncorrect).ToTask();
+        public void Dispose()
+        {
+            _credentialsAuthSessionCts?.Dispose();
+            _qrAuthSessionCts?.Dispose();
+            _deviceConfirmationCts?.Dispose();
+        }
 
         /// <inheritdoc />
-        public Task<string> GetEmailCodeAsync(string email, bool previousCodeWasIncorrect) => throw new System.NotImplementedException();
+        public Task<string> GetDeviceCodeAsync(bool previousCodeWasIncorrect) => GetDeviceCodeInteraction.Handle(Unit.Default).ToTask()!;
 
         /// <inheritdoc />
-        public Task<bool> AcceptDeviceConfirmationAsync() => Task.FromResult(false);
-
-        /// <summary>
-        /// 
-        /// </summary>
-        /// <returns></returns>
-        public Task<AuthPollResult?> AuthenticateAsync() => AuthenticateSteamInteraction.Handle(Unit.Default).ToTask();
+        public Task<string> GetEmailCodeAsync(string email, bool previousCodeWasIncorrect) => throw new NotImplementedException();
 
-        /// <summary>
-        /// 
-        /// </summary>
-        /// <returns></returns>
-        public Task<AuthPollResult?> StartAuthenticationAsync()
+        /// <inheritdoc />
+        public Task<bool> AcceptDeviceConfirmationAsync()
         {
-            _cancellationTokenSource?.Dispose();
-            _cancellationTokenSource = new CancellationTokenSource();
+            if (_qrAuthSessionCts!.IsCancellationRequested)
+                DeviceConfirmationInteraction.Handle(_deviceConfirmationCts!.Token).Subscribe();
 
-            return Observable.StartAsync(LoginWithQrCodeAsync)
-                .Merge(LoginCommand)
-                .FirstAsync()
-                .ToTask();
+            return Task.FromResult(true);
         }
 
         /// <inheritdoc />
-        public void Dispose()
+        public async Task<AuthPollResult?> AuthenticateAsync()
         {
-            _cancellationTokenSource?.Dispose();
-        }
+            _credentialsAuthSessionCts?.Dispose();
+            _qrAuthSessionCts?.Dispose();
+            _deviceConfirmationCts?.Dispose();
+            _credentialsAuthSessionCts = new CancellationTokenSource();
+            _qrAuthSessionCts = new CancellationTokenSource();
+            _deviceConfirmationCts = new CancellationTokenSource();
 
-        private async Task<AuthPollResult?> LoginWithCredentialsAsync()
-        {
-            AuthSessionDetails details = new()
-            {
-                Authenticator = this,
-                Username = Username,
-                Password = Password,
-                IsPersistentSession = RememberPassword
-            };
+            IsPasswordInvalid = false;
 
-            CredentialsAuthSession authSession = await _session.SteamClient.Authentication.BeginAuthSessionViaCredentialsAsync(details).ConfigureAwait(false);
+            AuthenticateInteraction.Handle(_deviceConfirmationCts.Token).Subscribe();
+
+            AuthSessionDetails details = new() { Authenticator = this };
 
             try
             {
-                AuthPollResult result = await authSession.PollingWaitForResultAsync(_cancellationTokenSource!.Token).ConfigureAwait(false);
-                await _cancellationTokenSource.CancelAsync().ConfigureAwait(false);
+                QrAuthSession authSession = await _session.SteamClient.Authentication.BeginAuthSessionViaQRAsync(details).ConfigureAwait(false);
+                LoginChallenge = authSession.ChallengeURL;
+                authSession.ChallengeURLChanged += () => LoginChallenge = authSession.ChallengeURL;
+                AuthPollResult result = await authSession.PollingWaitForResultAsync(_qrAuthSessionCts.Token).ConfigureAwait(false);
+                await _deviceConfirmationCts.CancelAsync().ConfigureAwait(false);
                 return result;
             }
-            catch (TaskCanceledException)
-            {
-                return null;
-            }
-        }
+            catch (TaskCanceledException) { }
 
-        private async Task<AuthPollResult?> LoginWithQrCodeAsync()
-        {
-            AuthSessionDetails details = new()
-            {
-                Authenticator = this
-            };
+            if (_credentialsAuthSessionCts.IsCancellationRequested)
+                return null;
 
-            QrAuthSession authSession = await _session.SteamClient.Authentication.BeginAuthSessionViaQRAsync(details).ConfigureAwait(false);
-            LoginChallenge = authSession.ChallengeURL;
-            authSession.ChallengeURLChanged += () => LoginChallenge = authSession.ChallengeURL;
+            details.Username = Username;
+            details.Password = Password;
+            details.IsPersistentSession = RememberPassword;
 
             try
             {
-                AuthPollResult result = await authSession.PollingWaitForResultAsync(_cancellationTokenSource!.Token).ConfigureAwait(false);
-                await _cancellationTokenSource.CancelAsync().ConfigureAwait(false);
+                CredentialsAuthSession authSession = await _session.SteamClient.Authentication.BeginAuthSessionViaCredentialsAsync(details).ConfigureAwait(false);
+                AuthPollResult result = await authSession.PollingWaitForResultAsync(_credentialsAuthSessionCts.Token).ConfigureAwait(false);
+                await _deviceConfirmationCts.CancelAsync().ConfigureAwait(false);
                 return result;
             }
+            catch (AuthenticationException)
+            {
+                IsPasswordInvalid = true;
+                return null;
+            }
             catch (TaskCanceledException)
             {
                 return null;
diff --git a/BeatSaberModManager/Views/Converters/IsPasswordInvalidColorConverter.cs b/BeatSaberModManager/Views/Converters/IsPasswordInvalidColorConverter.cs
new file mode 100644
index 0000000..ffa99bb
--- /dev/null
+++ b/BeatSaberModManager/Views/Converters/IsPasswordInvalidColorConverter.cs
@@ -0,0 +1,27 @@
+using System;
+using System.Globalization;
+
+using Avalonia.Data.Converters;
+using Avalonia.Media;
+
+
+namespace BeatSaberModManager.Views.Converters
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class IsPasswordInvalidColorConverter : IValueConverter
+    {
+        /// <inheritdoc />
+        public object Convert(object? value, Type targetType, object? parameter, CultureInfo culture)
+        {
+            if (value is not bool isPasswordInvalid)
+                throw new InvalidCastException();
+            return isPasswordInvalid ? Brushes.Red : Brushes.Transparent;
+        }
+
+        /// <inheritdoc />
+        public object ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture) =>
+            throw new InvalidOperationException();
+    }
+}
diff --git a/BeatSaberModManager/Views/Dialogs/SteamGuardCodeView.axaml b/BeatSaberModManager/Views/Dialogs/SteamGuardCodeView.axaml
index 8428e09..5f4d994 100644
--- a/BeatSaberModManager/Views/Dialogs/SteamGuardCodeView.axaml
+++ b/BeatSaberModManager/Views/Dialogs/SteamGuardCodeView.axaml
@@ -7,12 +7,12 @@
              x:Class="BeatSaberModManager.Views.Dialogs.SteamGuardCodeView"
              x:DataType="vm:SteamAuthenticationViewModel">
 
-    <Grid>
-        <Grid ColumnDefinitions="*, *">
+    <Grid RowDefinitions="*, *">
+        <Grid Grid.Row="0" ColumnDefinitions="*, *">
             <Label Grid.Column="0" Content="{DynamicResource SteamLoginView:AccountNameLabel}" />
             <Label Grid.Column="1" Content="{Binding Username}" />
         </Grid>
-        <TextBox Text="{Binding SteamGuardCode}" MaxLength="5" BorderBrush="Red" />
+        <TextBox Grid.Row="1" Text="{Binding SteamGuardCode}" MaxLength="5" MaxLines="1" />
     </Grid>
 
 </UserControl>
diff --git a/BeatSaberModManager/Views/Dialogs/SteamLoginView.axaml b/BeatSaberModManager/Views/Dialogs/SteamLoginView.axaml
index 405a46f..4d501d2 100644
--- a/BeatSaberModManager/Views/Dialogs/SteamLoginView.axaml
+++ b/BeatSaberModManager/Views/Dialogs/SteamLoginView.axaml
@@ -4,16 +4,21 @@
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
              xmlns:vm="using:BeatSaberModManager.ViewModels"
              xmlns:qr="using:Avalonia.Labs.Qr"
+             xmlns:converters="using:BeatSaberModManager.Views.Converters"
              mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
              x:Class="BeatSaberModManager.Views.Dialogs.SteamLoginView"
              x:DataType="vm:SteamAuthenticationViewModel">
 
+    <UserControl.Resources>
+        <converters:IsPasswordInvalidColorConverter x:Key="IsPasswordValidColorConverter" />
+    </UserControl.Resources>
+
     <Grid ColumnDefinitions="3*, 2*, 3*">
         <Grid Grid.Column="0" RowDefinitions="*, Auto, Auto, Auto, Auto, *">
             <Label Grid.Row="1" Content="{DynamicResource SteamLoginView:UsernameLabel}" />
             <TextBox Grid.Row="2" Text="{Binding Username}" />
             <Label Grid.Row="3" Content="{DynamicResource SteamLoginView:PasswordLabel}" />
-            <TextBox Grid.Row="4" Text="{Binding Password}" PasswordChar="*" Classes="revealPasswordButton" />
+            <TextBox Grid.Row="4" Text="{Binding Password}" PasswordChar="*" Classes="revealPasswordButton" BorderBrush="{Binding IsPasswordInvalid, Converter={StaticResource IsPasswordValidColorConverter}}" />
             <Grid Grid.Row="5" ColumnDefinitions="*, 20">
                 <Label Grid.Column="0" VerticalAlignment="Center" Content="{DynamicResource SteamLoginView:RememberPasswordLabel}" />
                 <CheckBox Grid.Column="1" IsChecked="{Binding RememberPassword}" />
diff --git a/BeatSaberModManager/Views/Pages/LegacyGameVersionsPage.axaml.cs b/BeatSaberModManager/Views/Pages/LegacyGameVersionsPage.axaml.cs
index 16a343a..71e6889 100644
--- a/BeatSaberModManager/Views/Pages/LegacyGameVersionsPage.axaml.cs
+++ b/BeatSaberModManager/Views/Pages/LegacyGameVersionsPage.axaml.cs
@@ -1,17 +1,17 @@
 using System;
-using System.Reactive.Threading.Tasks;
+using System.Reactive;
+using System.Threading;
 using System.Threading.Tasks;
 
 using Avalonia.Controls;
 using Avalonia.Labs.Controls;
 using Avalonia.ReactiveUI;
+using Avalonia.Threading;
 using Avalonia.VisualTree;
 
 using BeatSaberModManager.ViewModels;
 using BeatSaberModManager.Views.Dialogs;
 
-using SteamKit2.Authentication;
-
 
 namespace BeatSaberModManager.Views.Pages
 {
@@ -33,47 +33,60 @@ public LegacyGameVersionsPage(LegacyGameVersionsViewModel viewModel)
             ArgumentNullException.ThrowIfNull(viewModel);
             InitializeComponent();
             ViewModel = viewModel;
-            viewModel.SteamAuthenticationViewModel.AuthenticateSteamInteraction.RegisterHandler(async context =>
+            viewModel.SteamAuthenticationViewModel.AuthenticateInteraction.RegisterHandler(async context => context.SetOutput(await ShowAuthenticateSteamDialogAsync(context.Input).ConfigureAwait(false)));
+            viewModel.SteamAuthenticationViewModel.GetDeviceCodeInteraction.RegisterHandler(async context => context.SetOutput(await ShowSteamGuardCodeDialogAsync().ConfigureAwait(false)));
+            viewModel.SteamAuthenticationViewModel.DeviceConfirmationInteraction.RegisterHandler(async context => context.SetOutput(await ShowDeviceConfirmationDialogAsync(context.Input).ConfigureAwait(false)));
+        }
+
+        private async Task<string?> ShowSteamGuardCodeDialogAsync()
+        {
+            Window window = (VisualRoot as Window)!;
+            SteamGuardCodeView steamGuardCodeView = new() { DataContext = ViewModel!.SteamAuthenticationViewModel };
+            ContentDialog dialog = new()
             {
-                Window window = (VisualRoot as Window)!;
-                SteamLoginView steamLoginView = new() { DataContext = viewModel.SteamAuthenticationViewModel };
-                ContentDialog dialog = new()
-                {
-                    Content = steamLoginView,
-                    Title = this.FindResource("SteamLoginView:Title") as string,
-                    PrimaryButtonText = this.FindResource("SteamLoginView:LoginButton") as string,
-                    PrimaryButtonCommand = viewModel.SteamAuthenticationViewModel.LoginCommand,
-                    SecondaryButtonText = this.FindResource("SteamLoginView:CancelButton") as string,
-                    SecondaryButtonCommand = viewModel.SteamAuthenticationViewModel.CancelCommand
-                };
+                Content = steamGuardCodeView,
+                Title = this.FindResource("SteamGuardCodeView:Title") as string,
+                PrimaryButtonText = this.FindResource("SteamGuardCodeView:SubmitButton") as string,
+                PrimaryButtonCommand = ViewModel.SteamAuthenticationViewModel.SubmitSteamGuardCodeCommand,
+                SecondaryButtonText = this.FindResource("SteamGuardCodeView:CancelButton") as string,
+                SecondaryButtonCommand = ViewModel.SteamAuthenticationViewModel.CancelCommand
+            };
 
-                Task<ContentDialogResult> task = dialog.ShowAsync(window);
-                AuthPollResult? authenticationResult = await viewModel.SteamAuthenticationViewModel.StartAuthenticationAsync().ConfigureAwait(true);
-                context.SetOutput(authenticationResult);
-                dialog.Hide();
-                await task.ConfigureAwait(false);
-            });
+            ContentDialogResult result = await dialog.ShowAsync(window).ConfigureAwait(true);
+            return result == ContentDialogResult.Primary ? ViewModel.SteamAuthenticationViewModel.SteamGuardCode : null;
+        }
 
-            viewModel.SteamAuthenticationViewModel.GetSteamGuardCodeInteraction.RegisterHandler(async context =>
+        private async Task<Unit> ShowAuthenticateSteamDialogAsync(CancellationToken cancellationToken)
+        {
+            Window window = (VisualRoot as Window)!;
+            SteamLoginView steamLoginView = new() { DataContext = ViewModel!.SteamAuthenticationViewModel };
+            ContentDialog dialog = new()
+            {
+                Content = steamLoginView,
+                Title = this.FindResource("SteamLoginView:Title") as string,
+                PrimaryButtonText = this.FindResource("SteamLoginView:LoginButton") as string,
+                PrimaryButtonCommand = ViewModel.SteamAuthenticationViewModel.LoginCommand,
+                SecondaryButtonText = this.FindResource("SteamLoginView:CancelButton") as string,
+                SecondaryButtonCommand = ViewModel.SteamAuthenticationViewModel.CancelCommand
+            };
+
+            using IDisposable subscription = cancellationToken.Register(() => Dispatcher.UIThread.Post(() => dialog.Hide()));
+            await dialog.ShowAsync(window).ConfigureAwait(true);
+            return Unit.Default;
+        }
+
+        private async Task<Unit> ShowDeviceConfirmationDialogAsync(CancellationToken cancellationToken)
+        {
+            Window window = (VisualRoot as Window)!;
+            ContentDialog dialog = new()
             {
-                Window window = (VisualRoot as Window)!;
-                SteamGuardCodeView steamGuardCodeView = new() { DataContext = viewModel.SteamAuthenticationViewModel };
-                ContentDialog dialog = new()
-                {
-                    Content = steamGuardCodeView,
-                    Title = this.FindResource("SteamGuardView:Title") as string,
-                    PrimaryButtonText = this.FindResource("SteamGuardView:SubmitButton") as string,
-                    PrimaryButtonCommand = viewModel.SteamAuthenticationViewModel.LoginCommand,
-                    SecondaryButtonText = this.FindResource("SteamGuardView:CancelButton") as string,
-                    SecondaryButtonCommand = viewModel.SteamAuthenticationViewModel.CancelCommand
-                };
+                Content = this.FindResource("SteamDeviceConfirmationView:ConfirmLogin") as string,
+                Title = this.FindResource("SteamDeviceConfirmationView:Title") as string
+            };
 
-                Task<ContentDialogResult> task = dialog.ShowAsync(window);
-                string code = await viewModel.SteamAuthenticationViewModel.SubmitSteamGuardCodeCommand.ToTask().ConfigureAwait(true);
-                context.SetOutput(code);
-                dialog.Hide();
-                await task.ConfigureAwait(false);
-            });
+            using IDisposable subscription = cancellationToken.Register(() => Dispatcher.UIThread.Post(() => dialog.Hide()));
+            await dialog.ShowAsync(window).ConfigureAwait(true);
+            return Unit.Default;
         }
 
         // Hack that forces the selected item to become highlighted again after switching tabs