public async Task <ActionResult> Login([FromBody] AuthenticationRequest request) { if (request.Username is null || request.Password is null) { return(BadRequest()); } request.Username = request.Username.Replace(" ", string.Empty); request.Password = request.Password.Replace(" ", string.Empty); if (request.Username == string.Empty || request.Password == string.Empty) { return(BadRequest()); } User user = await context.Users.SingleOrDefaultAsync(x => x.Username == request.Username); if (user is null) { return(StatusCode(StatusCodes.Status404NotFound)); } if (!Util.CompareHash(request.Password, user.PasswordHash)) { return(StatusCode(StatusCodes.Status401Unauthorized)); } return(Ok(auth.Authenticate(request))); }
private async void Login() { //#if DEBUG // //TODO: remove this (added to simplify testing // Email = "*****@*****.**"; //Derek // Password = "******"; //#endif if (string.IsNullOrEmpty(Email) || string.IsNullOrEmpty(Password)) { MessagingCenter.Send(this, "InvalidLogin"); return; } _userInfoService.SaveUserInfo(new Models.UserInfoModel { Email = Email, Password = Password, Token = "", LastDownload = "" }); _hudProvider.DisplayProgress(AppResources.WorkingText); bool authenticated = await _authManager.Authenticate(); if (authenticated) { App.ShowHomeScreen(); } else { MessagingCenter.Send(this, "InvalidLogin"); } _hudProvider.Dismiss(); }
public async Task <ActionResult> Login([FromBody] EmailLoginInfo emailLoginInfo) { try { var user = await authenticationManager.Authenticate(emailLoginInfo); var sid = await userCookieManager.SetLoginCookie(Response, user); logger.LogInformation($"Успешный вход по логин-паролю {emailLoginInfo.Email}. sessionId {sid}"); return(Json(user)); } catch (AuthenticationFailedException) { return(Unauthorized()); } }
public async Task ClickTokenButton() { bool createResult; IsLoading = true; try { // TODO: Create Public/Private Key var result = await _authManager.CreateUserDeviceViaEmail(EmailAddress, Token, "test", "Test"); if (result != null) { var accessToken = await _authManager.Authenticate(result.UserDeviceId, result.AccessToken); createResult = accessToken != null; } else { createResult = false; } } catch (Exception ex) { ChatDebugger.SendMessageDialogAsync(ex.Message, ex); createResult = false; } IsLoading = false; RaiseEvent(createResult ? UserCreatedSuccessful : UserCreatedFailed, EventArgs.Empty); }
protected override async Task <AuthenticateResult> HandleAuthenticateAsync() { if (!Request.Headers.ContainsKey("Authorization")) { return(AuthenticateResult.Fail("Missing Authorization Header")); } try { var authHeader = AuthenticationHeaderValue.Parse(Request.Headers["Authorization"]); var credentialBytes = Convert.FromBase64String(authHeader.Parameter); var credentials = Encoding.UTF8.GetString(credentialBytes).Split(new[] { ':' }, 2); var password = credentials[1]; var userName = credentials[0]; var userPrincipal = await _authenticationManager.Authenticate(userName, password); if (userPrincipal == null) { return(AuthenticateResult.Fail("Invalid Username or Password")); } var ticket = new AuthenticationTicket(userPrincipal, Scheme.Name); return(AuthenticateResult.Success(ticket)); } catch { return(AuthenticateResult.Fail("Invalid Authorization Header")); } }
public async Task Invoke(HttpContext context) { if (FilterNonXhrRequest(context)) { return; } if (context.Session.Get <EmployeDto>(LoggedEmployeKey) == null) { var basicAuthenticationHeader = GetBasicAuthenticationHeaderValue(context); if (basicAuthenticationHeader.IsValidBasicAuthenticationHeaderValue) { try { EmployeBaseDto loggedEmploye = _authenticationManager.Authenticate(context, basicAuthenticationHeader.UserIdentifier, basicAuthenticationHeader.UserPassword); context.Session.Set(LoggedEmployeKey, loggedEmploye); } catch (Exception e) { _logger.LogError(e.StackTrace); SetUnauthorizedHeader(context); return; } } else { SetUnauthorizedHeader(context); return; } } await _next.Invoke(context); }
public IActionResult Login([FromBody] LoginDto user) { if (user == null) { return(BadRequest("Invalid client request")); } if (_authenticationManager.Authenticate(user.Username, user.Password)) { var secretKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_config["jwt:secretKey"])); var signinCredentials = new SigningCredentials(secretKey, SecurityAlgorithms.HmacSha256); var tokenOptions = new JwtSecurityToken( issuer: _config["jwt:issuer"], audience: _config["jwt:audience"], claims: new List <Claim>(), expires: DateTime.Now.AddMinutes(5), signingCredentials: signinCredentials ); var tokenString = new JwtSecurityTokenHandler().WriteToken(tokenOptions); return(Ok(tokenString)); } else { return(Unauthorized()); } }
public async Task <IActionResult> Login(LoginRequest loginRequest) { // Returns error if username or password are null if (loginRequest.Username == null || loginRequest.Password == null) { return(BadRequest("Username and password must not be null")); } // Attempts to create token, returns error if login details are incorrect Result <string> tokenResult = await _manager.Authenticate(loginRequest.Username, loginRequest.Password); if (tokenResult.Failure) { return(BadRequest(tokenResult.Error)); } // Creates and returns response LoginResponse response = new LoginResponse() { Token = tokenResult.Value, ValidUntil = DateTime.Now.AddMonths(1) }; return(Json(response)); }
public async Task <IActionResult> Login([FromBody] UserVM userParam) { if (!ModelState.IsValid) { return(BadRequest(new ErrorMessageVM() { Message = "Entered data is incorrect!" })); } else { var user = await _authenticationManager.Authenticate(userParam.Email, userParam.Password); if (user != null) { return(Ok(new { token = _authenticationManager.BuildToken(user) })); } else { return(BadRequest(new ErrorMessageVM() { Message = "Either Username or password is inccorect!" })); } } }
public async Task <ActionResult> IsValidUser(string userName, string password) { if ((await _authenticationManager.Authenticate(userName, password)) == null) { return(Forbid()); } return(Ok()); }
public IActionResult Authenticate([FromBody] AuthenticateModel model) { var user = _manager.Authenticate(model.Username, model.Password); if (user == null) { return(Unauthorized()); } return(Ok(user)); }
public IActionResult AuthenticateUser([FromBody] User user) { var token = manager.Authenticate(user); if (token == null) { return(Unauthorized()); } return(Ok(token)); }
public IActionResult Authenticate([FromBody] UserCredentials userCredentials) { var token = _authenticationManager.Authenticate(userCredentials.Username, userCredentials.Password); if (token == null) { return(Unauthorized()); // if incorrect username or password. } return(Ok(token)); }
public async Task <IActionResult> Login([FromBody] string password) { User admin = await context.Users.FindAsync(1); bool setPassword = admin.PasswordHash == "null"; if (string.IsNullOrEmpty(password)) { return(BadRequest()); } if (setPassword) { if (password.Length < 5) { return(BadRequest()); } admin.PasswordHash = Util.Hash(password); context.Entry(admin).State = EntityState.Modified; await context.SaveChangesAsync(); } if (!Util.CompareHash(password, admin.PasswordHash)) { return(StatusCode(StatusCodes.Status401Unauthorized)); } CookieBuilder authCookieBuilder = new() { IsEssential = true, SameSite = SameSiteMode.Strict, Expiration = new TimeSpan(8, 0, 0) }; var authCookieOptions = authCookieBuilder.Build(HttpContext); string token = auth.Authenticate(admin).Token; Response.Cookies.Append("AdminAuthorization", token, authCookieOptions); return(Ok()); }
public IActionResult Login([FromBody] AuthenticateRequest request) { var response = _authenticationManager.Authenticate(request); if (!response.IsSuccess) { return(Problem(title: response.Message, statusCode: response.StatusCode)); } return(Ok(response)); }
public async Task <IActionResult> Authenticate([FromBody] LoginDto loginDto) { var jwtToken = await _authenticationManager.Authenticate(loginDto); if (jwtToken == null) { return(BadRequest(new { message = "Username or password is incorrect" })); } return(Ok(jwtToken)); }
public IActionResult AuthenticateUser([FromBody] LoginDetails loginDetails) { _log4net.Info(" Http Authentication request Initiated"); var token = manager.Authenticate(loginDetails.Username, loginDetails.Password, loginDetails.LoginType); if (token == null) { return(Unauthorized()); } return(Ok(token)); }
public IActionResult AuthenticateUser([FromBody] Userdetails details) { _log4net.Info("Http Authentication Login request Initiated"); var token = manager.Authenticate(details.Email, details.Password); if (token == null) { return(Unauthorized()); } return(Ok(token)); }
public IActionResult AuthenticateUser([FromBody] Register user) { _log4net.Info(" Http Authentication request Initiated"); var token = manager.Authenticate(user.EmailId, user.Password); if (token == null) { return(Unauthorized()); } return(Ok(token)); }
public IActionResult AuthenticateUser([FromBody] UserServiceInfo user) { // _log4net.Info(" Http Authentication request Initiated"); var token = manager.Authenticate(user.Phoneno, user.Password); if (token == null) { return(Unauthorized()); } return(Ok(token)); }
public ActionResult Authenciate([FromBody] UCredential uCred) { var token = _authManager.Authenticate(uCred.Username, uCred.Password); if (token == null) { Unauthorized(); } return(Ok(token)); }
public TicketModel Post([FromBody] ApiFormInput formData) { if (formData == null) { return(new TicketModel { Errors = ApiHelper.JsonError(400, new[] { "User credentials are incomplete" }) }); } if (string.IsNullOrWhiteSpace(formData.username) && string.IsNullOrWhiteSpace(formData.password)) { return(new TicketModel { Errors = ApiHelper.JsonError(400, new[] { "Invalid login or password" }) }); } if (!_authenticationManager.Authenticate(formData.username, formData.password, out var authToken, out var refreshToken)) { return(new TicketModel { Errors = ApiHelper.JsonError(400, new[] { "Invalid login or password" }) }); } var resulTicketModel = new TicketModel { Token = authToken, RefreshToken = refreshToken }; var server = string.IsNullOrEmpty(formData.server) ? "localhost" : formData.server; SVNManager.Authorizate(server, formData.username, formData.password, _ => { }); return(resulTicketModel); }
private Dictionary <string, object> GetUserClaims(string user, string password) { string userName = GetUserName(user); string domainName = GetDomainName(user); Dictionary <string, object> userMetaData = new Dictionary <string, object>(); userMetaData.Add("user", userName); userMetaData.Add("domainName", domainName); userMetaData.Add("userName", userName); userMetaData.Add("environment", EnvironmentName); userMetaData.Add("isAuthenticated", false); userMetaData.Add("isAuthorized", false); if (!AuthenticationManager.Authenticate(userName, password, domainName)) { return(userMetaData); } userMetaData["isAuthenticated"] = true; UserIdentity userIdentity = AuthorizationManager.GetUserIdentity(userName, domainName, EnvironmentName, MarkelConfiguration.ApplicationName); if (!EnvironmentName.Equals(userIdentity?.EnvironmentName)) { throw new Exception("User Identity does not match requested environment!"); } if (userIdentity == null) { return(userMetaData); } // Successful Authentication userMetaData["isAuthorized"] = true; userMetaData.Add("application", userIdentity.ApplicationName); userMetaData.Add("applicationVersion", IOHelper.GetServerVersion()); userMetaData.Add("authTokenDate", userIdentity.AuthenticatedOn.ToString()); userMetaData.Add("authToken", userIdentity.AuthenticationToken.ToString()); userMetaData.Add("authTokenExpireDate", userIdentity.AuthenticationTokenExpiration.ToString()); userMetaData.Add("ermsHome", userIdentity.GetPath("ErmsHome")); userMetaData.Add("serviceAccount", userIdentity.IsServiceAccount.ToString()); // this better match: userMetaData.Add("userName", userIdentity.UserName); foreach (var permission in userIdentity.Permissions.Where(p => p.Value == true)) { userMetaData.Add(permission.Key, permission.Value.ToString()); } return(userMetaData); }
private UserIdentity userIdentity; // mp... 02/27/2019 - move up #endregion Constants #region Auth Managers private Dictionary <string, object> GetUserClaims(string user, string password, bool isTrustedServer) { string userName = GetUserName(user); string domainName = GetDomainName(user); if (string.IsNullOrWhiteSpace(userName)) { throw new UnauthorizedAccessException("User Name is required for Authentication!"); } Dictionary <string, object> userMetaData = new Dictionary <string, object>(); userMetaData.Add("user", userName); userMetaData.Add("domainName", domainName); userMetaData.Add("userName", userName); userMetaData.Add("environment", EnvironmentName); userMetaData.Add("isAuthenticated", false); userMetaData.Add("isAuthorized", false); if (!isTrustedServer && !AuthenticationManager.Authenticate(userName, password, domainName)) { return(userMetaData); } userMetaData["isAuthenticated"] = true; userIdentity = AuthorizationManager.GetUserIdentity(userName, domainName, EnvironmentName, MarkelConfiguration.ApplicationName); if (!EnvironmentName.Equals(userIdentity?.EnvironmentName)) { throw new Exception("User Identity does not match requested environment!"); } if (userIdentity == null) { return(userMetaData); } // Successful Authentication userMetaData["isAuthorized"] = true; userMetaData.Add("application", userIdentity.ApplicationName); userMetaData.Add("applicationVersion", IOHelper.GetServerVersion()); foreach (var permission in userIdentity.Permissions.Where(p => p.Value == true)) { userMetaData.Add(permission.Key, permission.Value.ToString()); } return(userMetaData); }
public async Task ClickLoginButton() { bool loginResult; IsLoading = true; try { loginResult = await _authManager.Authenticate(UserName, Password); } catch (LoginFailedException) { // TODO: The failure message should be bubbled up to the user; this is a different scenario than login failing due to bad credentials, and they should know that loginResult = false; } IsLoading = false; base.RaiseEvent(loginResult ? LoginSuccessful : LoginFailed, EventArgs.Empty); }
public async Task ClickLoginButton() { bool loginResult; IsLoading = true; try { loginResult = await _authManager.Authenticate(UserName, Password); } catch (LoginFailedException ex) { AwfulDebugger.SendMessageDialogAsync(ex.Message, ex); loginResult = false; } IsLoading = false; base.RaiseEvent(loginResult ? LoginSuccessful : LoginFailed, EventArgs.Empty); }
public IActionResult AuthenticateUser([FromBody] Userdetails details) { _log4net.Info("Http Authentication Login request Initiated"); var token = manager.Authenticate(details.Username, details.Password); if (token == null) { return(Unauthorized()); } TokenAndUserId tokenanduserid = new TokenAndUserId { UserId = manager.GetUserid(details.Username), Token = token }; return(Ok(tokenanduserid)); }
public ActionResult <User> Authenticate(UserCred userCred) { User user = userService.GetUserByEmail(userCred.Email); if (user.IdentityVerificationCode != null) { return(Forbid()); } else if (user.SignInRetries == 3) { string verificationCode = NewVerificationCode; user.IdentityVerificationCode = verificationCode; userService.Update(user.Id, user); var link = GetVerificationLink( VerificationType.Identity, user.Email, verificationCode); authenticationManager.SendVerificationEmail( VerificationType.Identity, link, user.Email); return(Forbid()); } var token = authenticationManager.Authenticate(userCred, user); if (token == null) { user.SignInRetries += 1; userService.Update(user.Id, user); return(Unauthorized()); } if (!user.EmailConfirmed) { return(NoContent()); } else if (user.SignInRetries > 0) { user.SignInRetries = 0; userService.Update(user.Id, user); } return(Ok(token)); }
public async Task <IActionResult> Authenticate([FromBody] Authentication request) { try { AuthenticateResponse response = await authenticationManager.Authenticate(request); if (response == null) { return(NotFound(new { message = "Username or password is incorrect" })); } return(Ok(response)); } catch (Exception) { return(BadRequest()); } }
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context) { context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { "*" }); var authenticated = await authenticationManager.Authenticate(context.UserName, context.Password); if (!authenticated) { context.SetError("invalid_grant", "The user name or password is incorrect."); return; } var identity = new ClaimsIdentity(context.Options.AuthenticationType); identity.AddClaim(new Claim("sub", context.UserName)); identity.AddClaim(new Claim("role", "user")); context.Validated(identity); }