public DesignClient(ISignIn signIn, ISignUp signUp, IContacts contacts, IMessages messages)
{
SignIn = signIn;
SignUp = signUp;
Contacts = contacts;
Messages = messages;
}
private bool IsLocked(ISignIn signIn)
{
if (signIn is ISignInSupportsLockout signInSupportedLockout && signInSupportedLockout.LockoutEnd > DateTimeOffset.UtcNow)
{
return(true);
}
return(false);
}
public async Task RefreshSignInAsync(ISignIn signIn)
{
var auth = await _contextAccessor.HttpContext.AuthenticateAsync(SignInConstants.ApplicationScheme);
var authenticationMethod = auth?.Principal?.FindFirstClaimValue(ClaimTypes.AuthenticationMethod);
await SignInAsync(signIn, auth?.Properties.IsPersistent ?? false, auth?.Properties, authenticationMethod);
}
public SignupSignInViewModel(ISignIn signIn, NameOf welcomeMessage, NameOf startTrialMessage)
{
_signinState = signIn;
_welcomeMessage = welcomeMessage;
_startTrialMessage = startTrialMessage;
InitializePropertyValues();
BindPropertyChangedEvents();
SubscribeToModelEvents();
}
public LoginController(
UserManager <ApplicationUser> userManager,
SignInManager <ApplicationUser> signInManager,
IConfiguration configuration)
{
_userManager = userManager ?? throw new ArgumentNullException(nameof(userManager));
_signInManager = signInManager ?? throw new ArgumentNullException(nameof(signInManager));
_configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
_signIn = new SignIn(userManager, configuration);
}
public virtual string Generate(string purpose, ISignIn signIn)
{
if (signIn is ISignInSupportsSecurityStamp supportsSecurityStamp)
{
var token = GetBytes(supportsSecurityStamp.SecurityStamp);
var modifier = GetModifier(purpose, signIn);
return(Rfc6238AuthenticationService.GenerateCode(token, modifier).ToString("D6", CultureInfo.InvariantCulture));
}
return(String.Empty);
}
public virtual bool Validate(string purpose, string token, ISignIn signIn)
{
if (signIn is ISignInSupportsSecurityStamp supportsSecurityStamp && int.TryParse(token, out int code))
{
var securityToken = GetBytes(supportsSecurityStamp.SecurityStamp);
var modifier = GetModifier(purpose, signIn);
return(securityToken != null && Rfc6238AuthenticationService.ValidateCode(securityToken, code, modifier));
}
return(false);
}
private async Task <bool> TwoFactorSignInAsync(ISignIn signIn)
{
if (signIn is ISignInSupportsTwoFactor supportsTwoFactor &&
supportsTwoFactor.RequireTwoFactorSignIn &&
!await IsTwoFactorClientRememberedAsync(signIn.Id))
{
await TwoFactorSignInAsync(signIn.Id);
return(true);
}
return(false);
}
public IEnumerable <string> GetTwoFactorProviders(ISignIn signIn)
{
var providers = new List <string>();
foreach (var kv in _options.ProviderMap)
{
var provider = (ITokenProvider)_serviceProvider.GetService(kv.Value);
if (provider.CanGenerateTwoFactorToken(signIn))
{
providers.Add(kv.Key);
}
}
return(providers);
}
public async Task <SignInResult> ExternalSignInAsync(ISignIn signIn, string loginProvider, bool isPersistent)
{
await _contextAccessor.HttpContext.SignOutAsync(SignInConstants.ExternalScheme);
if (IsLocked(signIn))
{
return(SignInResult.LockedOut);
}
if (await TwoFactorSignInAsync(signIn))
{
return(SignInResult.TwoFactorSuccess);
}
return(await SignInAsync(signIn, isPersistent, loginProvider));
}
private async Task <SignInResult> SignInAsync(ISignIn signIn, bool isPersistent, AuthenticationProperties properties, string authenticationMethod = null)
{
var userPrincipal = await _claimsPrincipalFactory.CreateAsync(signIn);
if (authenticationMethod != null)
{
userPrincipal.Identities.First().AddClaim(new Claim(_options.ClaimsIdentityOptions.AuthenticationMethodClaimType, authenticationMethod));
}
await _contextAccessor.HttpContext.SignInAsync(
SignInConstants.ApplicationScheme,
userPrincipal,
properties ?? new AuthenticationProperties());
return(SignInResult.Success);
}
public Task <SignInResult> SignInAsync(ISignIn signIn, bool isPersistent, string authenticationMethod = null)
{
AuthenticationProperties props = null;
if (_options.AllowRememberLogin && isPersistent)
{
props = new AuthenticationProperties
{
IsPersistent = true,
ExpiresUtc = DateTimeOffset.UtcNow + _options.RememberLoginDuration,
};
}
;
return(SignInAsync(signIn, isPersistent, props, authenticationMethod));
}
public virtual bool Validate(string purpose, string token, ISignIn signIn)
{
try
{
var unprotectedData = _protector.Unprotect(Convert.FromBase64String(token));
var memoryStream = new MemoryStream(unprotectedData);
using (var reader = memoryStream.CreateReader())
{
var creationTime = reader.ReadDateTimeOffset();
if (DateTimeOffset.UtcNow > creationTime + ConfirmationTokenLifespan)
{
return(false);
}
var storedUserId = reader.ReadString();
if (storedUserId != signIn.Id)
{
return(false);
}
var storedPurpose = reader.ReadString();
if (storedPurpose != purpose)
{
return(false);
}
if (signIn is ISignInSupportsSecurityStamp supportsSecurityStamp && supportsSecurityStamp.SecurityStamp != null)
{
var storedSecurityToken = reader.ReadString();
if (storedSecurityToken != supportsSecurityStamp.SecurityStamp)
{
return(false);
}
}
return(true);
}
}
catch
{
// nothing
}
return(false);
}
public virtual string Generate(string purpose, ISignIn signIn)
{
var memoryStream = new MemoryStream();
using (var writer = memoryStream.CreateWriter())
{
writer.Write(DateTimeOffset.UtcNow);
writer.Write(signIn.Id);
writer.Write(purpose);
if (signIn is ISignInSupportsSecurityStamp supportsSecurityStamp && supportsSecurityStamp.SecurityStamp != null)
{
writer.Write(supportsSecurityStamp.SecurityStamp);
}
}
var protectedBytes = _protector.Protect(memoryStream.ToArray());
return(Convert.ToBase64String(protectedBytes));
}
public async Task <SignInResult> SignInByPasswordAsync(ISignIn signIn, string password, bool isPersistent)
{
if (IsLocked(signIn))
{
return(SignInResult.LockedOut);
}
if (signIn is ISignInSupportsPassword supportsPassword &&
supportsPassword.PasswordHash != null &&
_passwordHasher.VerifyPassword(password, supportsPassword.PasswordHash))
{
if (await TwoFactorSignInAsync(signIn))
{
return(SignInResult.TwoFactorSuccess);
}
return(await SignInAsync(signIn, isPersistent));
}
return(SignInResult.Failed);
}
public bool Validate(string purpose, string token, ISignIn signIn)
{
if (signIn is ISignInSupportsAuthenticator supportsAuthenticator)
{
var key = supportsAuthenticator.AuthenticatorToken;
if (int.TryParse(token, out int code))
{
var hash = new HMACSHA1(Base32.FromBase32(key));
var unixTimestamp = Convert.ToInt64(Math.Round((DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0)).TotalSeconds));
var timestep = Convert.ToInt64(unixTimestamp / 30);
for (int i = -2; i <= 2; i++)
{
var expectedCode = Rfc6238AuthenticationService.ComputeTotp(hash, (ulong)(timestep + i), modifier: null);
if (expectedCode == code)
{
return(true);
}
}
}
}
return(false);
}
/// <summary>
/// Constructor.
/// </summary>
public MainMenuViewModel(ISignIn signIn,
IRegionManager regionManager,
IDialogManager dialogManager,
MalinkaUser user,
MainMenuStatus menuStatus,
IContainer container)
{
this.signIn = signIn;
this.regionManager = regionManager;
this.dialogManager = dialogManager;
this.menuStatus = menuStatus;
User = user;
ShowContactsCommand = new DelegateCommand(ShowContacts);
ShowSettingsCommand = new DelegateCommand(ShowSettings);
LogOutCommand = new DelegateCommand(LogOut);
OpenMalinkaDesktopCommand = new DelegateCommand(OpenMalinkaDesktop);
Assembly assembly = Assembly.GetExecutingAssembly();
FileVersionInfo fileVersionInfo = FileVersionInfo.GetVersionInfo(assembly.Location);
Version = fileVersionInfo.ProductVersion;
}
public async Task <SignInResult> SignInByTwoFactorTokenAsync(ISignIn signIn, string tokenProvider, string token, bool isPersistent, bool rememberClient)
{
if (IsLocked(signIn))
{
return(SignInResult.LockedOut);
}
var tp = _tokenProviderManager.FindTokenProvider(tokenProvider);
if (tp != null && tp.Validate(Purpose.TwoFactor, token, signIn))
{
if (rememberClient)
{
await RememberTwoFactorClientAsync(signIn.Id);
}
await _contextAccessor.HttpContext.SignOutAsync(SignInConstants.TwoFactorUserIdScheme);
return(await SignInAsync(signIn, isPersistent, tokenProvider));
}
return(SignInResult.Failed);
}
public virtual Task <ClaimsPrincipal> CreateAsync(ISignIn signIn)
{
var claimsIdentity = new ClaimsIdentity(SignInConstants.ApplicationScheme,
_options.ClaimsIdentityOptions.NameClaimType,
_options.ClaimsIdentityOptions.RoleClaimType);
claimsIdentity.AddClaim(new Claim(_options.ClaimsIdentityOptions.IdClaimType, signIn.Id));
claimsIdentity.AddClaim(new Claim(_options.ClaimsIdentityOptions.NameClaimType, signIn.Name));
if (signIn is ISignInSupportsSecurityStamp supportsSecurityStamp && supportsSecurityStamp.SecurityStamp != null)
{
claimsIdentity.AddClaim(new Claim(_options.ClaimsIdentityOptions.SecurityStampClaimType,
supportsSecurityStamp.SecurityStamp));
}
if (signIn is ISignInSupportsRoles supportsRoles)
{
claimsIdentity.AddClaims(supportsRoles.Roles.Select(x => new Claim(_options.ClaimsIdentityOptions.RoleClaimType, x)));
}
if (signIn is ISignInSupportsClaims supportsClaims)
{
claimsIdentity.AddClaims(supportsClaims.Claims.Select(x => new Claim(x.Type, x.Value)));
}
return(Task.FromResult(new ClaimsPrincipal(claimsIdentity)));
}
/// <summary>
/// This request can be used to create a user
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='model'>
/// </param>
public static ResQYttriumWebApiModelsCreateUserResultModel CreateUser(this ISignIn operations, ResQYttriumWebApiModelsCreateUserModel model)
{
return(Task.Factory.StartNew(s => ((ISignIn)s).CreateUserAsync(model), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult());
}
/// <summary>
/// This request can be used to acquire an access token to access a specific
/// application resource for the user
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='model'>
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <ResQYttriumWebApiModelsSignInResultModel> SignInUserAsync(this ISignIn operations, ResQYttriumWebApiModelsSignInUserModel model, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.SignInUserWithHttpMessagesAsync(model, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public bool CanGenerateTwoFactorToken(ISignIn signIn)
{
return(signIn is ISignInSupportsAuthenticator supportsAuthenticator &&
!string.IsNullOrWhiteSpace(supportsAuthenticator.AuthenticatorToken));
}
public string Generate(string purpose, ISignIn signIn)
{
return(string.Empty);
}
public Presenter(ISignIn isignin)
{
iSignIn = isignin;
db = new Database();
}
public virtual bool CanGenerateTwoFactorToken(ISignIn signIn) => signIn is ISignInSupportsSecurityStamp supportsSecurityStamp && supportsSecurityStamp.SecurityStamp != null;
public virtual bool CanGenerateTwoFactorToken(ISignIn signIn)
{
return(false);
}
public SignInController(ISignIn signIn, ISignUp signUp)
{
this.signIn = signIn;
this.signUp = signUp;
}
public MyProfileController(IMyProfile myProfile, IUser user, ISignIn signIn)
{
this.user = user;
this.myProfile = myProfile;
this.signIn = signIn;
}
public EditController(IMyProfile myProfile, ISignUp signUp, ISignIn signIn)
{
this.signIn = signIn;
this.myProfile = myProfile;
this.signUp = signUp; ViewBag.RemoteValidation = "";
}
public override bool CanGenerateTwoFactorToken(ISignIn signIn) => signIn is ISignInSupportsPhoneNumber supportsPhoneNumber &&
