public override void Reset() { IsReady = false; _authToken = null; _authExpiration = default(DateTime); ValuesStorage.Remove(KeyAuthToken); ValuesStorage.Remove(KeyAuthExpiration); }
public void OnAuthFinished(AuthResponse authResponse) { this.authCoroutine = null; if (authResponse == null || authResponse.code != 0) { Debug.Log("Ошибка логина"); } else { Toolbox.Instance.sessionId = authResponse.sessionId; Debug.Log("Логин успешен"); } }
/// <summary> /// Authentication Step 2. /// 10.3.2.2. Получение аутентификационного токена /// </summary> private AuthToken GetToken(OmsApiClient omsClient, AuthResponse authResponse, string signedData) { var url = omsClient.AuthUrl + "auth/cert/{OmsConnectionID}"; return(omsClient.Post <AuthToken>(url, new { uuid = authResponse.UUID, data = signedData, }, new[] { new Parameter("OmsConnectionID", OmsConnectionID, ParameterType.UrlSegment), })); }
public void ContinueWebAuthentication(WebAuthenticationBrokerContinuationEventArgs args) { var webResult = args.WebAuthenticationResult; if (webResult.ResponseStatus == WebAuthenticationStatus.Success) { Uri responseUri = new Uri(webResult.ResponseData.ToString()); if (!responseUri.Query.Contains("error=")) { AuthResponse authResponse = OAuth2.ParseFragment(responseUri.Fragment.Substring(1)); PlatformAdapter.Resolve <IAuthHelper>().EndLoginFlow(SalesforceConfig.LoginOptions, authResponse); } } }
private void onEventHandlerLoginSuccess(EventWatcher watcher, BaseEventArgs evtArgs) { // InputVCodeControl.DismissInputVcodeBox(); // PageManager.getInstance().PopAllPages(true); AuthResponse mObject = null; if ((evtArgs.mObject != null) && (evtArgs.mObject is AuthResponse)) { mObject = (AuthResponse)evtArgs.mObject; } //GConfigMgr.settings.strLastLoginName = this.textBoxAccount.get_Text(); //GConfigMgr.saveSetting(); Log.i("onEventHandlerLoginSuccess", "login success"); }
public Promise <AuthResponse> Auth(Auth model) { string url = string.Format("http://my.api.com/api/auth"); return(FakeHttpClient.Post <Auth, AuthResponse>(url, model, fakeResponse: () => new AuthResponse { UserId = 150, DisplayName = "Chiko", Token = "Chiko::150" }) .Then(delegate(AuthResponse x) { AuthResponse auth = x; return auth; // By doing this you will be returning - Promise<User> })); //NOTE: USE THE ONE BELOW INSTEAD! This is just for showing purposes only. //.Then(x => x.Content); }
public IActionResult Login([FromBody] LoginRequest model) { AuthResponse response = new AuthResponse(); string tokenId = string.Empty; if (userService.Login(model, out tokenId) != 0) { response.Token = tokenId; response.IsAuthenticated = true; return(Ok(response)); } return(Unauthorized()); }
private ActionResult CreateSessionFor(AuthResponse response) { if (response.Status != AuthStatus.Success) { throw new Exception("Unexpected error when validating MFA"); } var username = response.Embedded.User.Profile.Login; var createPersistentCookie = true; FormsAuthentication.SetAuthCookie(username, createPersistentCookie); // Store the most recent response in the session Session[oktaResponseKey] = response; return(RedirectToAction("CompleteMfa", "Account")); }
/// <summary> /// Callback that is invoked once the authentication request is processed or expires. /// </summary> /// <param name="request"></param> private static void OnVerificationResponse(AuthResponse request, NtkService boundApi) { /** * 3. ApprovalGranted is a convenience property, but it does not perform * signature validation. * * In a real-world scenario, you could now verify the response payload * to be sure of the received data. */ Console.WriteLine("SUCCESS: verification response: {0}", request.ApprovalGranted); Console.WriteLine("Storing keytoken {0} for user ID {1}", request.KeyToken, request.UserId); userKeyTokens.Add(request.KeyToken, request.UserId); }
private async static Task <AuthResponse> GetAuthResponse(string username, string password) { var requestModel = new AuthRequest { ApplicationId = Constants.BrightApplicationIdString, Username = username, Password = password }; var response = await _httpClient.PostAsJsonAsync($"https://api.glowmarkt.com/api/v0-1/auth", requestModel); response.EnsureSuccessStatusCode(); return(AuthResponse.FromJson(await response.Content.ReadAsStringAsync())); }
public static async Task <Task> SaveUserData(AuthResponse authResponse, string userInfo, string password, string email) { await SecureStorage.SetAsync(StorageConstants.AccessToken, authResponse.AccessToken.JwtToken); await SecureStorage.SetAsync(StorageConstants.AccessTokenExpireTime, authResponse.AccessToken.Expire.ToString()); await SecureStorage.SetAsync(StorageConstants.UserId, userInfo); await SecureStorage.SetAsync(StorageConstants.UserPassword, password); await SaveUserEmail(email); return(Task.CompletedTask); }
/// <summary> /// Performs Username/Password authentication. /// </summary> /// <exception cref="Socks5Exception">The server returned invalid or /// unexpected data, or authentication failed.</exception> private void Authenticate() { byte[] bytes = new AuthRequest(Username, Password).Serialize(); stream.Write(bytes, 0, bytes.Length); // Read the server's response. bytes = new byte[2]; stream.Read(bytes, 0, 2); AuthResponse response = AuthResponse.Deserialize(bytes); if (!response.Success) { throw new Socks5Exception("Authentication failed."); } }
private async void Landing_Loaded(object sender, RoutedEventArgs e) { _authResponse = await DoLogin(); if (!_authResponse.IsAuthenticated) { MessageBox.Show("Unable to authenticate"); } // _authResponse.UserInfo.Picture; this.Hide(); var main = new Main(); main.Show(); }
public IActionResult Login([FromBody] LoginRequest model) { AuthResponse authResponse = _authService.Login(model, IpAddress()); if (authResponse == null) { return(BadRequest("Invalid Email or Password")); } SetTokenCookie(authResponse.RefreshToken); authResponse.RefreshToken = null; return(Ok(authResponse)); }
public AuthResponse Auth(UserDTO user) { List <User> users = new List <User>(); users.Add(new User { Username = "******", Password = "******", Category = "گوشی موبایل" }); users.Add(new User { Username = "******", Password = "******", Category = "گوشی موبایل" }); users.Add(new User { Username = "******", Password = "******", Category = "گوشی موبایل", Role = "admin" }); users.Add(new User { Username = "******", Password = "******", Category = "گوشی موبایل", Brand = "اپل" }); users.Add(new User { Username = "******", Password = "******", Category = "گوشی موبایل" }); users.Add(new User { Username = "******", Password = "******", Category = "گوشی موبایل" }); users.Add(new User { Username = "******", Password = "******", Category = "گوشی موبایل" }); users.Add(new User { Username = "******", Password = "******", Category = "گوشی موبایل" }); users.Add(new User { Username = "******", Password = "******", Category = "گوشی موبایل" }); if (!string.IsNullOrEmpty(user.Username) && !string.IsNullOrEmpty(user.Password)) { User _user = users.Where(x => x.Username.ToLower() == user.Username.ToLower().Trim() && x.Password.ToLower() == user.Password.ToLower().Trim() ).FirstOrDefault(); if (user != null) { AuthResponse res = new AuthResponse { Success = true, User = _user }; return(res); } } return(new AuthResponse { Success = false, User = null }); }
public async Task <ActionResult <AuthResponse> > Login(AuthRequest loginRequest) { var user = await _userManager.FindByEmailAsync(loginRequest.UserName); if (user == null) { return(NotFound("El usuario no existe")); } var checkPwd = await _userManager.CheckPasswordAsync(user, loginRequest.Password); if (!checkPwd) { return(Unauthorized("Contraseña inválida")); } var claims = new List <Claim>() { new Claim(JwtRegisteredClaimNames.Jti, user.Id.ToString()), new Claim(JwtRegisteredClaimNames.Sub, user.UserName), new Claim(JwtRegisteredClaimNames.UniqueName, user.UserName) }; var roles = await _userManager.GetRolesAsync(user); foreach (string role in roles) { claims.Add(new Claim(ClaimTypes.Role, role)); } DateTime expiration = DateTime.Now.AddMinutes(60); var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["Tokens:Key"])); var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256); var token = new JwtSecurityToken( _configuration.GetSection("Tokens:Issuer").Get <string>(), loginRequest.AudienceKey, claims, null, expiration, creds); AuthResponse response = new AuthResponse() { Token = new JwtSecurityTokenHandler().WriteToken(token), Expiration = expiration }; return(response); }
public async Task <ActionResult <AuthResponse> > Login(LoginRequest request) { if (request is null) { throw new ArgumentNullException(nameof(request)); } var signInResult = await signInManager.PasswordSignInAsync(request.Email, request.Password, isPersistent : false, lockoutOnFailure : false); if (!signInResult.Succeeded) { logger.LogWarning("Login failed for user {UserName}", request.Email); return(BadRequest()); } var user = await userManager.FindByNameAsync(request.Email); var userClaims = await userManager.GetClaimsAsync(user); var userRoles = await userManager.GetRolesAsync(user); var claims = new[] { new Claim(JwtRegisteredClaimNames.Sid, user.Id.ToString()), new Claim(JwtRegisteredClaimNames.Sub, user.UserName), new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()), new Claim(ClaimTypes.Name, user.UserName), new Claim(JwtRegisteredClaimNames.Email, user.Email), new Claim(JwtRegisteredClaimNames.GivenName, user.FirstName), new Claim(JwtRegisteredClaimNames.FamilyName, user.LastName ?? string.Empty) }.Union(userRoles.Select(role => new Claim(ClaimTypes.Role, role))) .Union(userClaims); var symmetricSecurityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(jwtSettings.SecurityKey)); var signingCredentials = new SigningCredentials(symmetricSecurityKey, SecurityAlgorithms.HmacSha256); var jwtSecurityToken = new JwtSecurityToken( issuer: jwtSettings.Issuer, audience: jwtSettings.Audience, claims: claims, notBefore: DateTime.UtcNow, expires: DateTime.UtcNow.AddMinutes(jwtSettings.ExpirationMinutes), signingCredentials: signingCredentials ); var result = new AuthResponse(new JwtSecurityTokenHandler().WriteToken(jwtSecurityToken), jwtSecurityToken.ValidTo); return(Ok(result)); }
public override async Task SignIn(CancellationToken cancellation) { await Prepare(cancellation); if (IsReady && DateTime.Now < _authExpiration) { return; } var data = InternalUtils.GetGoogleDriveCredentials(); var clientId = data.Item1.Substring(2); var clientSecret = data.Item2.Substring(2); var code = await GetAutenficationCode(clientId, cancellation); if (cancellation.IsCancellationRequested) { return; } if (code == null) { throw new UserCancelledException(); } var response = await Request.Post <AuthResponse>(@"https://www.googleapis.com/oauth2/v4/token", new NameValueCollection { { @"code", code }, { @"client_id", clientId }, { @"client_secret", clientSecret }, { @"redirect_uri", RedirectUrl }, { @"grant_type", @"authorization_code" } }.GetQuery(), null, cancellation); if (cancellation.IsCancellationRequested) { return; } if (response == null) { throw new Exception(ToolsStrings.Uploader_CannotFinishAuthorization); } _authToken = response; _authExpiration = DateTime.Now + TimeSpan.FromSeconds(response.ExpiresIn) - TimeSpan.FromSeconds(20); ValuesStorage.SetEncrypted(KeyAuthToken, JsonConvert.SerializeObject(_authToken)); ValuesStorage.Set(KeyAuthExpiration, _authExpiration); IsReady = true; }
private async Task <bool> GetBearerTokenAsync() { var client = new HttpClient(); client.BaseAddress = new Uri(_uri); var byteArray = new UTF8Encoding().GetBytes(_key + ":" + _secret); client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(byteArray)); var formData = new List <KeyValuePair <string, string> >(); formData.Add(new KeyValuePair <string, string>("grant_type", "client_credentials")); var request = new HttpRequestMessage(HttpMethod.Post, "/iii/sierra-api/v2/token"); request.Content = new FormUrlEncodedContent(formData); try { //throw new WebException("token error bruh' Uri.", WebExceptionStatus.NameResolutionFailure); var response = await client.SendAsync(request); var payload = await response.Content.ReadAsStringAsync(); if (!response.IsSuccessStatusCode) { ApiError.Log(response); return(false); } var serializer = new JavaScriptSerializer(); AuthResponse SierraResponse = serializer.Deserialize <AuthResponse>(payload); _token_expires = DateTime.UtcNow.AddSeconds(SierraResponse.expires_in); _token = SierraResponse.access_token; } catch (Exception ex) { _token = null; ApiError.Log(ex); } finally { client.Dispose(); } // no token no init return(_token != null); }
public async Task Connect(string host, string auth, bool isSecure, string group = null, string code = null) { Hostname = host; Authentification = auth; State = "Verbinde..."; IsActive = true; try { socket = new ClientWebSocket(); socket.Options.AddSubProtocol("chat"); await socket.ConnectAsync(new Uri((isSecure ? "wss://":"ws://") + host), source.Token); int seq = SequenceNumber++; AuthRequest msg = new AuthRequest(auth, seq, group, code); ReceiveTokenSource = new CancellationTokenSource(); ProcessReceivingMessages(); await socket.SendAsync(msg.GetBytes(), WebSocketMessageType.Binary, true, source.Token); IRemoteMessage resp = await WaitForResponse(seq); if (resp is StateResponse) { StateResponse response = (StateResponse)resp; switch (response.Code) { case StateCodes.WrongKey: throw new Exception("Authentifizierung am Server fehlgeschlagen"); case StateCodes.GroupNotFound: throw new Exception("Angegebene Gruppe ist nicht auf dem Server vorhanden"); case StateCodes.WrongGroupKey: throw new Exception("Authentifizierung in der Gruppe fehlgeschlagen"); } } else if (resp is AuthResponse) { AuthResponse response = (AuthResponse)resp; Group = response.Group; } State = "Verbunden (" + Group + ")"; } catch (Exception ex) { State = ex.Message; IsActive = false; IsConnected = false; } }
public string Put(string id, [FromBody] string value) { AuthResponse auth = new AuthResponse(); CarPark location = MongoDBHelper.SearchByObjectID <CarPark>(id); if (location != null) { location.aspaces = location.aspaces + 1; MongoDBHelper.InsertEntity <CarPark>(location); auth.Status = 0; return(JsonConvert.SerializeObject(auth)); } auth.Status = 1; return(JsonConvert.SerializeObject(auth)); }
private void FailAuthentication(NetworkConnection conn, AuthResponse response) { Debug.Log("[Server] Authentication failed. Sending result to client."); conn.Send(response, 0); // must set NetworkConnection isAuthenticated = false conn.isAuthenticated = false; // disconnect the client after 1 second so that response message gets delivered StartCoroutine(DelayedDisconnect(conn, 1)); Debug.Log("[Server] Rejected connection and responded to client: " + ((PlayerData)conn.authenticationData).steamName + " - " + ((PlayerData)conn.authenticationData).id); }
public async Task Test_auth_clientsignature_success() { if (this.deribitcredentials.client_id == null || this.deribitcredentials.client_secret == null) { throw new Exception("This test requires client credentials"); } AuthResponse authresponse = await deribit.Authentication.Auth(new AuthRequest() { grant_type = GrantType.client_credentials, client_id = this.deribitcredentials.client_id, client_secret = this.deribitcredentials.client_secret, }.Sign()); Assert.That(authresponse.refresh_token, Is.Not.Null); }
private AuthResponse BuildResponse(IdentityUser user, string accessToken) { var response = new AuthResponse { AccessToken = accessToken, LoggedUser = new UserViewModel { UserId = user.Id, Username = user.UserName, Email = user.Email } }; return(response); }
public void AuthenticateConsumerNullOAuthConsumerKey() { //Arrange AuthenticateSettings obAuthSettings = new AuthenticateSettings(); obAuthSettings.OAuthConsumerKey = null; //Act IAuthenticate obAuthenticate = new Authenticate(); AuthResponse obAuthRespose = obAuthenticate.AuthenticateConsumer(obAuthSettings); //Assert // When Consumer key is null, the expected output is null Authentication Response. Assert.AreEqual(obAuthRespose, null); }
public async Task <bool> TestAuthentication() { HttpResponseMessage response = await _httpClient.GetAsync($"auth.test?token={_apiKey}"); if (!response.IsSuccessStatusCode) { return(false); } string responseContent = await response.Content.ReadAsStringAsync(); AuthResponse authResponse = JsonConvert.DeserializeObject <AuthResponse>(responseContent); return(authResponse.ok); }
private static async Task Login(string username, string password) { string json = LoginRequestData.CreateLoginRequestDataAsJson(username, password); string url = Constants.REST_MULTIDIALOGO_STAGE_HOST + "/users/login"; HttpResponseMessage response = await http.SendAsync(Utils.CreateRequest(url, null, Utils.CreateStringContent(json), "Post")); string responseContent = await response.Content.ReadAsStringAsync(); AuthResponse authResponse = JsonConvert.DeserializeObject <AuthResponse>(responseContent); Console.WriteLine("Nuovo token ricevuto: " + authResponse.GetTokenResponse().Token); StoreTokens(authResponse); }
private void SetupExchangeCodeRequest(bool succeeded = true, string accessToken = null, string refreshToken = null) { var authResponse = new AuthResponse { AccessToken = accessToken ?? Guid.NewGuid().ToString(), ExpiresIn = 10, RefreshToken = refreshToken ?? Guid.NewGuid().ToString() }; _mockRequestExecutor .Setup(x => x.ExchangeCode(It.IsAny <AccountAccessContext>())) .ReturnsAsync(succeeded ? ServiceObjectResult <AuthResponse> .Succeeded(authResponse) : ServiceObjectResult <AuthResponse> .Failed(null, new List <string> { "Value" })); }
public static IActionResult GetResponseResult(this Controller controller, AuthResponse authResponse) { switch (authResponse.AuthResponseStatus) { case AuthResponseStatus.Ok: return(controller.Ok(GetAuthData(authResponse))); case AuthResponseStatus.NotFound: return(controller.NotFound(GetAuthData(authResponse))); case AuthResponseStatus.BadRequest: default: return(controller.BadRequest(GetAuthData(authResponse))); } }
public void AuthenticateConsumerEmptyOAuthConsumerSecret() { //Arrange AuthenticateSettings obAuthSettings = new AuthenticateSettings(); obAuthSettings.OAuthConsumerSecret = string.Empty; //Act IAuthenticate obAuthenticate = new Authenticate(); AuthResponse obAuthRespose = obAuthenticate.AuthenticateConsumer(obAuthSettings); //Assert // When Consumer Secret is empty, the expected output is null Authentication Response. Assert.AreEqual(obAuthRespose, null); }
public async Task Test_auth_password_success() { if (this.deribitcredentials.username == null || this.deribitcredentials.password == null) { throw new Exception("This test requires username/password"); } AuthResponse authresponse = await deribit.Authentication.Auth(new AuthRequest() { grant_type = GrantType.password, username = this.deribitcredentials.username, password = this.deribitcredentials.password, }); Assert.That(authresponse.refresh_token, Is.Not.Null); }
public override async Task Prepare(CancellationToken cancellation) { if (IsReady && DateTime.Now < _authExpiration) return; var data = InternalUtils.GetGoogleDriveCredentials(); var clientId = data.Item1.Substring(2); var clientSecret = data.Item2.Substring(2); var enc = ValuesStorage.GetEncryptedString(KeyAuthToken); if (enc == null) return; try { _authToken = JsonConvert.DeserializeObject<AuthResponse>(enc); } catch (Exception) { Logging.Warning("Can’t load auth token"); return; } if (DateTime.Now < _authExpiration) { IsReady = true; return; } var refresh = await Request.Post<RefreshResponse>(@"https://www.googleapis.com/oauth2/v4/token", new NameValueCollection { { @"client_id", clientId }, { @"client_secret", clientSecret }, { @"refresh_token", _authToken.RefreshToken }, { @"grant_type", @"refresh_token" } }.GetQuery(), null, cancellation); if (cancellation.IsCancellationRequested) return; if (refresh == null) { ValuesStorage.Remove(KeyAuthToken); } else { _authToken.AccessToken = refresh.AccessToken; _authExpiration = DateTime.Now + TimeSpan.FromSeconds(refresh.ExpiresIn) - TimeSpan.FromSeconds(20); ValuesStorage.SetEncrypted(KeyAuthToken, JsonConvert.SerializeObject(_authToken)); ValuesStorage.Set(KeyAuthExpiration, _authExpiration); IsReady = true; } }
public void OnAuthResponse(AuthResponse response) { }
public ResponseLogin(AuthResponse resp) { Response = resp; }
public void OnAuthResponse(AuthResponse response) { throw new NotImplementedException(); }
private async Task OnExternalLoginFailure( IApplicationBuilder app, HttpContext context, string error, string authSchema) { await context.Response.WriteAsync(string.Format("External Login for {0} Failed.<br/>Error: ", authSchema)); await context.Response.WriteAsync(error); var authResponse = new AuthResponse { Success = false, Message = "Login failed" }; context.Response.Clear(); context.Response.ContentType = "application/json; charset=utf-8"; string json = JsonConvert.SerializeObject(authResponse); await context.Response.WriteAsync(json); }
public void OnAuthResponse(AuthResponse response) { Send("/AuthResponse", Serialize(response)); }
public void OnAuthResponse(AuthResponse response) { OnAuthResponseMessage authResponse = new OnAuthResponseMessage(); authResponse.payload = response; WebSocket.Send(Serialize(authResponse)); }
public void OnAuthResponse(AuthResponse response) { if (response.Success) { if (Result.SUCCESS.Equals(response.Payment.result)) { POSPayment payment = new POSPayment(response.Payment.id, response.Payment.order.id, response.Payment.employee.id, response.Payment.amount, response.Payment.tipAmount, response.Payment.cashbackAmount); if (response.IsAuth) { Store.CurrentOrder.Status = POSOrder.OrderStatus.AUTHORIZED; payment.PaymentStatus = POSPayment.Status.AUTHORIZED; } else { Store.CurrentOrder.Status = POSOrder.OrderStatus.CLOSED; payment.PaymentStatus = POSPayment.Status.PAID; } Store.CurrentOrder.AddPayment(payment); uiThread.Send(delegate (object state) { if (payment.CashBackAmount > 0) { ShowCashBackForm(payment.CashBackAmount); } RegisterTabs.SelectedIndex = 0; NewOrder(); }, null); } } else if (response.Result.Equals(ResponseCode.FAIL)) { uiThread.Send(delegate (object state) { AlertForm.Show(this, response.Reason, response.Message); PaymentReset(); }, null); } else if (response.Result.Equals(ResponseCode.CANCEL)) { uiThread.Send(delegate (object state) { AlertForm.Show(this, response.Reason, response.Message); PaymentReset(); }, null); } }
public W8049Password2(AuthResponse resp) { Response = resp; }
public void UpdateAuthContext(AuthResponse authContext) { System.Web.HttpContext.Current.Session.Add("UserContext", authContext); }
public override async Task SignIn(CancellationToken cancellation) { await Prepare(cancellation); if (IsReady && DateTime.Now < _authExpiration) return; var data = InternalUtils.GetGoogleDriveCredentials(); var clientId = data.Item1.Substring(2); var clientSecret = data.Item2.Substring(2); var code = await GetAutenficationCode(clientId, cancellation); if (cancellation.IsCancellationRequested) return; if (code == null) { throw new UserCancelledException(); } var response = await Request.Post<AuthResponse>(@"https://www.googleapis.com/oauth2/v4/token", new NameValueCollection { { @"code", code }, { @"client_id", clientId }, { @"client_secret", clientSecret }, { @"redirect_uri", RedirectUrl }, { @"grant_type", @"authorization_code" } }.GetQuery(), null, cancellation); if (cancellation.IsCancellationRequested) return; if (response == null) { throw new Exception(ToolsStrings.Uploader_CannotFinishAuthorization); } _authToken = response; _authExpiration = DateTime.Now + TimeSpan.FromSeconds(response.ExpiresIn) - TimeSpan.FromSeconds(20); ValuesStorage.SetEncrypted(KeyAuthToken, JsonConvert.SerializeObject(_authToken)); ValuesStorage.Set(KeyAuthExpiration, _authExpiration); IsReady = true; }