Files
SocialPub/PrivaPub/Services/RootUsersService.cs
T
thepraandClaude Opus 5.5 c2f439d1e9
Build / Build (push) Successful in 34s
Deploy / privapub.thepra.dev (push) Successful in 57s
Deploy / Release notes on the Releases tab (push) Successful in 3s
Every failure the server answers with names its own error code
Each refusal and failure the client API sends now starts with a code no other failure uses, such as "[ERR0030006] That
code is not valid.", so a screenshot or a report points at the exact place it came from. Nothing another program reads
changes: ActivityPub, the Mastodon API's errors, sign-in tokens and the error kinds decePubClient branches on stay as they
were. The house-rules checks move to 1.1.0.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01W4YtEJrgxG12Pc39Fai8Bd
2026-11-10 08:11:24 +01:00

613 lines
26 KiB
C#

using Microsoft.Extensions.Localization;
using MongoDB.Driver;
using MongoDB.Entities;
using PrivaPub.ClientModels;
using PrivaPub.ClientModels.User;
using PrivaPub.Models;
using PrivaPub.Models.User;
using PrivaPub.Resources;
using PrivaPub.Infrastructure.Jobs;
using PrivaPub.Models.Jobs;
using PrivaPub.StaticServices;
using System.Globalization;
using System.Text.Json;
#pragma warning disable 8603
#pragma warning disable 8625
namespace PrivaPub.Services
{
public class RootUsersService(
IJobQueue jobs,
IRootSessions sessions,
IRootRemoval removal,
IStringLocalizer<GenericRes> localizer,
ILogger<RootUsersService> logger,
IPasswordHasher passwordHasher,
DbEntities dbEntities,
AppConfigurationService appConfigurationService) : IRootUsersService
{
public const string NoMatch = "That username and password do not match.";
static string _decoy;
// a hash nobody's password matches, so an unknown login costs the same hashing as a wrong password
string Decoy => _decoy ??= passwordHasher.Hash(Convert.ToHexString(System.Security.Cryptography.RandomNumberGenerator.GetBytes(16)));
public async Task<WebResult> SignUpAsync(LoginForm signUpForm, CancellationToken token = default)
{
var result = new WebResult();
try
{
signUpForm.UserName = signUpForm.UserName.ToLower();
if (await dbEntities.RootUsers.Match(u => u.UserName == signUpForm.UserName).ExecuteAnyAsync(token))
return result.Invalidate(30001.ToCodedError(localizer["Username '{0}' already taken.", signUpForm.UserName]));
var signUpPasswordHashed = passwordHasher.Hash(signUpForm.Password);
var newUser = new RootUser
{
UserName = signUpForm.UserName,
HashedPassword = signUpPasswordHashed
};
var cultureLanguage = CultureInfo.CurrentCulture.TwoLetterISOLanguageName;
var language = await dbEntities.Languages.Match(l => l.International2Code == cultureLanguage).ExecuteFirstAsync(token);
newUser.Settings = new RootUserSettings
{
LanguageCode = language?.International2Code ?? "en",
LightThemeIndexColour = signUpForm.LightThemeIndexColour,
DarkThemeIndexColour = signUpForm.DarkThemeIndexColour,
IconsThemeIndexColour = signUpForm.IconsThemeIndexColour,
ThemeIsDarkGray = signUpForm.ThemeIsDarkGray,
ThemeIsLightGray = signUpForm.ThemeIsLightGray,
PreferSystemTheming = signUpForm.PreferSystemTheming,
ThemeIsDarkMode = signUpForm.ThemeIsDarkMode
};
await DB.Default.SaveAsync(newUser, token);
result.Data = (newUser, ToViewSettings(newUser.Settings));
return result;
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(SignUpAsync)}()");
return result.Invalidate(30002.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
public async Task<WebResult> LoginAsync(LoginForm loginForm, CancellationToken token = default)
{
var result = new WebResult();
try
{
// One answer, after the same work, whether the login is unknown, deleted or the password wrong: sign-in must not
// tell anyone which logins exist. Only someone who knows the password learns the login is banned.
loginForm.UserName = loginForm.UserName.ToLower();
var user = await dbEntities.RootUsers.Match(u => u.UserName == loginForm.UserName && u.DeletedAt == null).ExecuteFirstAsync(token);
var (verified, needsUpgrade) = passwordHasher.Check(user?.HashedPassword ?? Decoy, loginForm.Password);
if (user?.HashedPassword == default || !verified)
return result.Invalidate(30003.ToCodedError(localizer[NoMatch]));
if (user.IsBanned)
return result.Invalidate(30004.ToCodedError(localizer["User '{0}' banned.", user.UserName]));
// only a correct password learns that two-factor is on: it is asked for with a 428
if (user.Totp?.EnabledAt != default)
{
if (string.IsNullOrWhiteSpace(loginForm.OneTimeCode))
return result.Invalidate(30005.ToCodedError(localizer[TwoFactor.CodeNeeded]), StatusCodes.Status428PreconditionRequired);
if (!await TwoFactor.Consume(user, loginForm.OneTimeCode, CancellationToken.None))
return result.Invalidate(30006.ToCodedError(localizer[TwoFactor.CodeInvalid]));
}
// hashed again at today's iterations; matched on the old hash, so two sign-ins at once never undo each other
if (needsUpgrade)
{
var oldHash = user.HashedPassword;
user.HashedPassword = passwordHasher.Hash(loginForm.Password);
await DB.Default.Update<RootUser>()
.Match(u => u.ID == user.ID && u.HashedPassword == oldHash)
.Modify(u => u.HashedPassword, user.HashedPassword)
.ExecuteAsync(token);
}
var userSettingsResult = await GetUserSettingsAsync(user.ID, loginForm, token);
var userSettings = (ViewUserSettings)userSettingsResult.Data;
result.Data = (user, userSettings);
return result;
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(LoginAsync)}()");
return result.Invalidate(30007.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
public async Task<WebResult> UpdateUserSettingsAsync(ViewUserSettings userSettings, string userId, CancellationToken token = default)
{
var result = new WebResult();
try
{
var isSupportedLanguage = appConfigurationService.AppConfiguration.SupportedLanguages.Contains(userSettings.LanguageCode);
if (!isSupportedLanguage)
return result.Invalidate(30008.ToCodedError(localizer["Language code '{0}' unsupported.", userSettings.LanguageCode]));
var languageCodeExists = await dbEntities.Languages
.Match(l => l.International2Code == userSettings.LanguageCode).ExecuteAnyAsync(token);
if (!languageCodeExists)
return result.Invalidate(30009.ToCodedError(localizer["Language code '{0}' doesn't exist.", userSettings.LanguageCode]));
var language = await dbEntities.Languages.Match(l => l.International2Code == userSettings.LanguageCode)
.ExecuteFirstAsync(token);
_ = await DB.Default.Update<RootUser>()
.MatchID(userId)
.Modify(u => u.Settings.LanguageCode, language.International2Code)
.Modify(u => u.Settings.LightThemeIndexColour, userSettings.LightThemeIndexColour)
.Modify(u => u.Settings.DarkThemeIndexColour, userSettings.DarkThemeIndexColour)
.Modify(u => u.Settings.PreferSystemTheming, userSettings.PreferSystemTheming)
.Modify(u => u.Settings.ThemeIsDarkMode, userSettings.ThemeIsDarkMode)
.Modify(u => u.Settings.ThemeIsDarkGray, userSettings.ThemeIsDarkGray)
.Modify(u => u.Settings.ThemeIsLightGray, userSettings.ThemeIsLightGray)
.Modify(u => u.Settings.IconsThemeIndexColour, userSettings.IconsThemeIndexColour)
.Modify(u => u.Settings.SavedAt, DateTime.UtcNow)
.Modify(u => u.UpdatedAt, DateTime.UtcNow)
.ExecuteAsync(token);
return result;
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(UpdateUserSettingsAsync)}()");
return result.Invalidate(30010.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
public async Task<WebResult> UpdateUserPasswordAsync(UserPasswordForm userPasswordForm, string userId, CancellationToken token = default)
{
var result = new WebResult();
try
{
var user = await dbEntities.RootUsers.Match(u => u.ID == userId && u.DeletedAt == null).ExecuteFirstAsync(token);
if (user == null)
return result.Invalidate(30011.ToCodedError(localizer["Username '{0}' not found.", userId]));
var (verified, needsUpgrade) = passwordHasher.Check(user.HashedPassword, userPasswordForm.OldPassword);
if (!verified)
return result.Invalidate(30012.ToCodedError(localizer["Wrong password."]));
await DB.Default.Update<RootUser>().MatchID(user.ID)
.Modify(u => u.HashedPassword, passwordHasher.Hash(userPasswordForm.NewPassword))
.Modify(u => u.UpdatedAt, DateTime.UtcNow)
.ExecuteAsync(token);
// whoever else is signed in may be why the password changed: every session ends, and the caller gets a new one
await sessions.Revoke(user.ID, CancellationToken.None);
user = await dbEntities.RootUsers.MatchID(user.ID).ExecuteFirstAsync(token);
result.Data = (user, ToViewSettings(user.Settings));
return result;
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(UpdateUserPasswordAsync)}()");
return result.Invalidate(30013.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
public async Task<WebResult> RemoveUserAsync(UsersIds usersIds, CancellationToken token = default)
{
var result = new WebResult();
try
{
var removed = 0;
foreach (var id in usersIds.UserIdList.Distinct())
if (await removal.Remove(id, CancellationToken.None))
removed++;
if (removed == 0)
return result.Invalidate(30014.ToCodedError(localizer["User already deleted."]));
return result;
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(RemoveUserAsync)}()");
return result.Invalidate(30015.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
// A root deletes itself only with its password, so a stolen session cannot.
public async Task<WebResult> RemoveSelfAsync(string rootId, string password, CancellationToken token = default)
{
var result = new WebResult();
try
{
var user = await dbEntities.RootUsers.MatchID(rootId).Match(u => u.DeletedAt == null).ExecuteFirstAsync(token);
var (verified, _) = passwordHasher.Check(user?.HashedPassword ?? Decoy, password ?? string.Empty);
if (user?.HashedPassword == default || !verified)
return result.Invalidate(30016.ToCodedError(localizer[NoMatch]), StatusCodes.Status403Forbidden);
await removal.Remove(user.ID, CancellationToken.None);
return result;
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(RemoveSelfAsync)}()");
return result.Invalidate(30017.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
// what can't be undone asks for the password again (a persona's or a group's deletion, by its login or an administrator)
public async Task<bool> PasswordMatches(string rootId, string password, CancellationToken token = default)
{
var user = string.IsNullOrEmpty(rootId) ? default : await dbEntities.RootUsers.MatchID(rootId).Match(u => u.DeletedAt == null).ExecuteFirstAsync(token);
var (verified, _) = passwordHasher.Check(user?.HashedPassword ?? Decoy, password ?? string.Empty);
return user?.HashedPassword != default && verified;
}
public async Task<WebResult> BanUserAsync(UsersIds usersIds, CancellationToken token = default)
{
var result = new WebResult();
try
{
await DB.Default.Update<RootUser>()
.Match(u => usersIds.UserIdList.Contains(u.ID))
.Modify(u => u.IsBanned, true)
.ExecuteAsync(token);
return result;
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(BanUserAsync)}()");
return result.Invalidate(30018.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
public async Task<WebResult> UnbanUserAsync(UsersIds usersIds, CancellationToken token = default)
{
var result = new WebResult();
try
{
await DB.Default.Update<RootUser>()
.Match(u => usersIds.UserIdList.Contains(u.ID))
.Modify(u => u.IsBanned, false)
.ExecuteAsync(token);
return result;
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(UnbanUserAsync)}()");
return result.Invalidate(30019.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
public async Task<WebResult> GetUserSettingsAsync(string userId, LoginForm loginForm = default, CancellationToken token = default)
{
var result = new WebResult();
try
{
var user = await dbEntities.RootUsers.MatchID(userId).ExecuteFirstAsync(token);
if (user == default)
return result.Invalidate(30020.ToCodedError(localizer["User not found."]), StatusCodes.Status404NotFound);
if (loginForm != default && loginForm.ThemeIsDarkMode != user.Settings.ThemeIsDarkMode)
{
user.Settings.ThemeIsDarkMode = loginForm.ThemeIsDarkMode;
await DB.Default.Update<RootUser>()
.MatchID(userId)
.Modify(u => u.Settings.ThemeIsDarkMode, loginForm.ThemeIsDarkMode)
.ExecuteAsync(token);
}
result.Data = ToViewSettings(user.Settings);
return result;
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(GetUserSettingsAsync)}()");
return result.Invalidate(30021.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
public const string RecoverySent = "If that account has an email address, a recovery link is on its way. It works for one hour.";
// The same answer, after the same work, whether the account exists, has an email or can be written to: recovery must
// not tell anyone which logins or addresses exist. RecoveryJob does the rest, out of the request.
public async Task<WebResult> SetupAndSendRecoveryEmail(PasswordRecoveryForm passwordRecoveryForm, string host, CancellationToken token = default)
{
var result = new WebResult();
try
{
var userName = passwordRecoveryForm.UserName?.ToLowerInvariant();
var user = passwordRecoveryForm.IsEmailDisabled
? await dbEntities.RootUsers.Match(u => u.UserName == userName && u.DeletedAt == null).ExecuteFirstAsync(token)
: await dbEntities.RootUsers.Match(u => u.Email == passwordRecoveryForm.Email && u.IsEmailValidated && u.DeletedAt == null).ExecuteFirstAsync(token);
await jobs.Enqueue(JobKind.SendRecovery, JsonSerializer.Serialize(new RecoveryPayload(user?.ID, host)), RecoveryJob.Host,
dedupeKey: default, CancellationToken.None);
result.Data = (string)localizer[RecoverySent];
return result;
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(SetupAndSendRecoveryEmail)}()");
return result.Invalidate(30022.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
Task<EmailRecovery> LiveRecovery(string recoveryCode, CancellationToken token = default)
{
var hash = RecoveryJob.Hash(recoveryCode);
var now = DateTime.UtcNow;
return dbEntities.EmailRecoveries.Match(er => er.CodeHash == hash && er.ExpiresAt > now).ExecuteFirstAsync(token);
}
public async Task<WebResult> IsValidRecoveryCode(string recoveryCode, CancellationToken token = default)
{
var result = new WebResult();
try
{
result.Data = await LiveRecovery(recoveryCode, token) != default;
return result;
}
catch (Exception ex)
{
return result.Invalidate(30023.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
// A recovered password ends every session the root had: whoever had them may be why it was recovered.
public async Task<WebResult> ChangePassword(NewPasswordForm newPasswordForm, CancellationToken token = default)
{
var result = new WebResult();
try
{
var recovery = await LiveRecovery(newPasswordForm.RecoveryCode, token);
var user = recovery == default ? default
: await dbEntities.RootUsers.MatchID(recovery.RootUserId).Match(u => u.DeletedAt == null && !u.IsBanned).ExecuteFirstAsync(token);
if (user == default)
return result.Invalidate(30024.ToCodedError(localizer["Invalid recovery code."]), StatusCodes.Status404NotFound);
await DB.Default.Update<RootUser>().MatchID(user.ID)
.Modify(u => u.HashedPassword, passwordHasher.Hash(newPasswordForm.NewPassword))
.Modify(u => u.UpdatedAt, DateTime.UtcNow)
.ExecuteAsync(token);
await DB.Default.DeleteAsync<EmailRecovery>(er => er.RootUserId == user.ID);
await sessions.Revoke(user.ID, CancellationToken.None);
return result;
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(ChangePassword)}()");
return result.Invalidate(30025.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
static ViewUserSettings ToViewSettings(RootUserSettings settings) => new()
{
LanguageCode = settings.LanguageCode,
LightThemeIndexColour = settings.LightThemeIndexColour,
DarkThemeIndexColour = settings.DarkThemeIndexColour,
PreferSystemTheming = settings.PreferSystemTheming,
ThemeIsDarkMode = settings.ThemeIsDarkMode,
IconsThemeIndexColour = settings.IconsThemeIndexColour,
ThemeIsDarkGray = settings.ThemeIsDarkGray,
ThemeIsLightGray = settings.ThemeIsLightGray,
SavedAt = settings.SavedAt
};
public const string EmailCodeSent = "If that address can be used, a code is on its way to it. It works for one hour.";
public const string EmailCodeInvalid = "That code is not valid.";
public async Task<WebResult> AccountAsync(string rootId, CancellationToken token = default)
{
var result = new WebResult();
try
{
var user = await dbEntities.RootUsers.MatchID(rootId).Match(u => u.DeletedAt == null).ExecuteFirstAsync(token);
if (user == default)
return result.Invalidate(30026.ToCodedError(localizer["User not found."]), StatusCodes.Status404NotFound);
var now = DateTime.UtcNow;
var pending = await DB.Default.Find<EmailVerification>().Match(v => v.RootUserId == rootId && v.ExpiresAt > now).ExecuteFirstAsync(token);
result.Data = new ViewAccount
{
UserName = user.UserName,
Email = user.Email,
IsEmailValidated = user.IsEmailValidated,
PendingEmail = pending?.Email,
CreatedAt = user.CreatedAt,
TwoFactorEnabled = user.Totp?.EnabledAt != default,
RecoveryCodesLeft = user.Totp?.EnabledAt != default ? user.Totp.RecoveryCodeHashes.Count : 0
};
return result;
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(AccountAsync)}()");
return result.Invalidate(30027.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
// Only with the password, so a stolen session can't move recovery to its own inbox. The answer is the same sentence
// whether or not the address is free; EmailVerificationJob sends the code, or nothing when another login holds it.
public async Task<WebResult> RequestEmailChangeAsync(string rootId, EmailChangeForm form, CancellationToken token = default)
{
var result = new WebResult();
try
{
var user = await dbEntities.RootUsers.MatchID(rootId).Match(u => u.DeletedAt == null).ExecuteFirstAsync(token);
var (verified, _) = passwordHasher.Check(user?.HashedPassword ?? Decoy, form.Password ?? string.Empty);
if (user?.HashedPassword == default || !verified)
return result.Invalidate(30028.ToCodedError(localizer["Wrong password."]), StatusCodes.Status403Forbidden);
await DB.Default.DeleteAsync<EmailVerification>(v => v.RootUserId == user.ID);
var pending = new EmailVerification
{
RootUserId = user.ID,
Email = form.Email.Trim().ToLowerInvariant(),
ExpiresAt = DateTime.UtcNow + EmailVerification.Lifetime
};
await DB.Default.SaveAsync(pending, token);
await jobs.Enqueue(JobKind.SendEmailVerification, JsonSerializer.Serialize(new EmailVerificationPayload(pending.ID)),
EmailVerificationJob.Host, dedupeKey: default, CancellationToken.None);
result.Data = (string)localizer[EmailCodeSent];
return result;
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(RequestEmailChangeAsync)}()");
return result.Invalidate(30029.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
// One answer for every failure (wrong, expired, five tries spent, or the address verified by another login meanwhile)
public async Task<WebResult> VerifyEmailAsync(string rootId, string code, CancellationToken token = default)
{
var result = new WebResult();
try
{
var now = DateTime.UtcNow;
var pending = await DB.Default.Find<EmailVerification>().Match(v => v.RootUserId == rootId && v.ExpiresAt > now).ExecuteFirstAsync(token);
if (pending == default || string.IsNullOrEmpty(pending.CodeHash))
return result.Invalidate(30030.ToCodedError(localizer[EmailCodeInvalid]));
if (pending.CodeHash != RecoveryJob.Hash(code?.Trim()))
{
if (pending.Attempts + 1 >= EmailVerification.MaxAttempts)
await DB.Default.DeleteAsync<EmailVerification>(pending.ID);
else
await DB.Default.Update<EmailVerification>().MatchID(pending.ID).Modify(b => b.Inc(v => v.Attempts, 1)).ExecuteAsync(token);
return result.Invalidate(30031.ToCodedError(localizer[EmailCodeInvalid]));
}
await DB.Default.DeleteAsync<EmailVerification>(pending.ID);
if (await dbEntities.RootUsers.Match(u => u.Email == pending.Email && u.IsEmailValidated && u.ID != rootId && u.DeletedAt == null).ExecuteAnyAsync(token))
return result.Invalidate(30032.ToCodedError(localizer[EmailCodeInvalid]));
await DB.Default.Update<RootUser>().MatchID(rootId)
.Modify(u => u.Email, pending.Email)
.Modify(u => u.IsEmailValidated, true)
.Modify(u => u.UpdatedAt, now)
.ExecuteAsync(token);
return await AccountAsync(rootId, token);
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(VerifyEmailAsync)}()");
return result.Invalidate(30033.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
// Two-factor sign-in (TwoFactor): set up with the password, turned on by the app's first code (which also proves the
// app holds the secret), turned off with the password and a code. Turning it on ends every other session.
public async Task<WebResult> TotpSetupAsync(string rootId, string password, CancellationToken token = default)
{
var result = new WebResult();
try
{
var user = await dbEntities.RootUsers.MatchID(rootId).Match(u => u.DeletedAt == null).ExecuteFirstAsync(token);
var (verified, _) = passwordHasher.Check(user?.HashedPassword ?? Decoy, password ?? string.Empty);
if (user?.HashedPassword == default || !verified)
return result.Invalidate(30034.ToCodedError(localizer["Wrong password."]), StatusCodes.Status403Forbidden);
if (user.Totp?.EnabledAt != default)
return result.Invalidate(30035.ToCodedError(localizer["Two-factor sign-in is on already: turn it off first."]), StatusCodes.Status409Conflict);
var secret = TwoFactor.NewSecret();
await DB.Default.Update<RootUser>().MatchID(rootId)
.Modify(u => u.Totp, new RootTotp { PendingSecret = secret, PendingSince = DateTime.UtcNow })
.ExecuteAsync(token);
var uri = TwoFactor.OtpAuthUri(secret, user.UserName);
result.Data = new ViewTotpSetup { Secret = secret, OtpAuthUri = uri, QrDataUri = TwoFactor.QrDataUri(uri) };
return result;
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(TotpSetupAsync)}()");
return result.Invalidate(30036.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
public async Task<WebResult> TotpEnableAsync(string rootId, string code, CancellationToken token = default)
{
var result = new WebResult();
try
{
var user = await dbEntities.RootUsers.MatchID(rootId).Match(u => u.DeletedAt == null).ExecuteFirstAsync(token);
if (user?.Totp is not { EnabledAt: null, PendingSecret: not null } pending || pending.PendingSince < DateTime.UtcNow.AddHours(-1))
return result.Invalidate(30037.ToCodedError(localizer["Set up two-factor sign-in again: that setup expired."]), StatusCodes.Status409Conflict);
if (TwoFactor.Step(pending.PendingSecret, code) is not { } step)
return result.Invalidate(30038.ToCodedError(localizer[TwoFactor.CodeInvalid]));
var codes = TwoFactor.NewRecoveryCodes();
await DB.Default.Update<RootUser>().MatchID(rootId)
.Modify(u => u.Totp, new RootTotp
{
Secret = pending.PendingSecret,
EnabledAt = DateTime.UtcNow,
LastStep = step,
RecoveryCodeHashes = codes.Select(TwoFactor.HashRecovery).ToList()
})
.ExecuteAsync(token);
await sessions.Revoke(rootId, CancellationToken.None);
user = await dbEntities.RootUsers.MatchID(rootId).ExecuteFirstAsync(token);
result.Data = (user, ToViewSettings(user.Settings), codes);
return result;
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(TotpEnableAsync)}()");
return result.Invalidate(30039.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
public async Task<WebResult> TotpDisableAsync(string rootId, string password, string code, CancellationToken token = default)
{
var result = new WebResult();
try
{
var user = await dbEntities.RootUsers.MatchID(rootId).Match(u => u.DeletedAt == null).ExecuteFirstAsync(token);
var (verified, _) = passwordHasher.Check(user?.HashedPassword ?? Decoy, password ?? string.Empty);
if (user?.HashedPassword == default || !verified)
return result.Invalidate(30040.ToCodedError(localizer["Wrong password."]), StatusCodes.Status403Forbidden);
if (user.Totp?.EnabledAt == default)
return await AccountAsync(rootId, token);
if (!await TwoFactor.Consume(user, code, CancellationToken.None))
return result.Invalidate(30041.ToCodedError(localizer[TwoFactor.CodeInvalid]));
await DB.Default.Update<RootUser>().MatchID(rootId).Modify(u => u.Totp, null).ExecuteAsync(token);
return await AccountAsync(rootId, token);
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(TotpDisableAsync)}()");
return result.Invalidate(30042.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
public async Task<WebResult> RemoveEmailAsync(string rootId, string password, CancellationToken token = default)
{
var result = new WebResult();
try
{
var user = await dbEntities.RootUsers.MatchID(rootId).Match(u => u.DeletedAt == null).ExecuteFirstAsync(token);
var (verified, _) = passwordHasher.Check(user?.HashedPassword ?? Decoy, password ?? string.Empty);
if (user?.HashedPassword == default || !verified)
return result.Invalidate(30043.ToCodedError(localizer["Wrong password."]), StatusCodes.Status403Forbidden);
await DB.Default.Update<RootUser>().MatchID(rootId)
.Modify(u => u.Email, null)
.Modify(u => u.IsEmailValidated, false)
.Modify(u => u.UpdatedAt, DateTime.UtcNow)
.ExecuteAsync(token);
await DB.Default.DeleteAsync<EmailVerification>(v => v.RootUserId == rootId);
await DB.Default.DeleteAsync<EmailRecovery>(r => r.RootUserId == rootId);
return await AccountAsync(rootId, token);
}
catch (Exception ex)
{
logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(RemoveEmailAsync)}()");
return result.Invalidate(30044.ToCodedError(localizer["Something went wrong."]), exception: ex);
}
}
}
}