public async Task <LoginResponse> Refresh(RefreshRequest request) { // Извлекаем их токена дату до которой он действителен и Id пользователя var securityHandler = new JwtSecurityTokenHandler(); var refreshTokenRaw = securityHandler.ReadJwtToken(request.RefreshToken); var validTo = refreshTokenRaw.ValidTo; var userId = Guid.Parse(refreshTokenRaw.Subject); // Достаем из базы пользователя на которого ссылается токен var user = await _userRepo.GetItem(userId); // Проверка на то, что пользователь существует, у него есть такой токен и он не протух. if (user == null || user.RefreshToken != request.RefreshToken || validTo < DateTime.Now) { throw new ArgumentException("Bad Refresh JWT-token"); } // Генерируем пару токенов var loginResponse = CreateTokensPair(user); // Запись Refresh токена в базу к соответствующему пользователю user.UpdateRefreshToken(loginResponse.RefreshToken); await _userRepo.Update(user); return(loginResponse); }
public async Task <ActionResult> RefreshAsync(RefreshRequest refreshRequest, ModelStateDictionary modelState) { if (!modelState.IsValid) { return(BadRequestModelState(modelState)); } bool isValidRefreshToken = _refreshTokenValidator.Validate(refreshRequest.RefreshToken); if (!isValidRefreshToken) { return(new BadRequestObjectResult(new ErrorResponse("Invalid refresh token."))); } RefreshToken refreshTokenDTO = await _refreshTokenRepository.GetByTokenAsync(refreshRequest.RefreshToken); if (refreshTokenDTO == null) { return(new NotFoundObjectResult(new ErrorResponse("Invalid refresh token."))); } await _refreshTokenRepository.DeleteAsync(refreshTokenDTO.Id); Account account = await _accountService.GetAsync(refreshTokenDTO.AccountId); if (account == null) { return(new NotFoundObjectResult(new ErrorResponse("Account not found."))); } AuthenticatedAccountResponse response = await _authenticator.AuthenticateAsync(account); return(new OkObjectResult(response)); }
public async Task <IActionResult> Refresh([FromBody] RefreshRequest refreshRequest) { if (!ModelState.IsValid) { return(BadRequestModelState()); } bool isValidRefreshToken = _refreshTokenValidator.Validate(refreshRequest.RefreshToken); if (!isValidRefreshToken) { return(BadRequest(new ErrorResponse("Invalid refresh token."))); } RefreshToken refreshTokenDTO = await _refreshTokenRepository.GetByToken(refreshRequest.RefreshToken); if (refreshTokenDTO == null) { return(NotFound(new ErrorResponse("Invalid refresh token."))); } await _refreshTokenRepository.Delete(refreshTokenDTO.Id); User user = await _userRepository.FindByIdAsync(refreshTokenDTO.UserId.ToString()); if (user == null) { return(NotFound(new ErrorResponse("User not found."))); } AuthenticatedUserResponse response = await _authenticator.Authenticate(user); return(Ok(response)); }
public async Task <IResponse> RefreshAccessToken(RefreshRequest request) { var user = _context.Users.FirstOrDefault(f => f.Email == request.Email); if (user == null) { return new GenericResponse { Code = (int)HttpStatusCode.BadRequest, Status = (int)StatusCode.UserMissing } } ; //Check if the refresh token is still valid. if (string.IsNullOrWhiteSpace(request.RefreshToken) || await Task.Factory.StartNew(() => _cache.Get(request.RefreshToken, request.Email) == null)) { return new GenericResponse { Code = (int)HttpStatusCode.BadRequest, Status = (int)StatusCode.RefreshTokenInvalid } } ; var response = CreateAccessToken(user); return(new RefreshResponse { Code = (int)HttpStatusCode.OK, Status = (int)StatusCode.OkWithContent, AccessToken = response.AccessToken, AccessTokenExpiryDateUtc = response.AccessTokenExpiryDateUtc }); }
public ActionResult <RefreshRequest> Refresh([FromBody] RefreshRequest refreshRequest) { DealingWithRefreshToken dealingWithRefreshToken = new DealingWithRefreshToken(); string refreshToken = Request.Headers["Authorization"].ToString().Split(" ")[1]; refreshRequest.RefreshToken = refreshToken; int userId = dealingWithRefreshToken.GetUserIdFromAccessToken(refreshRequest.AccessToken, _jwtSettings.SecretKey); Users userFromDbViaAccessToken = _context.Users.FirstOrDefault(u => u.Id == userId); TblRefreshToken refreshTokenUser = _context.TblRefreshToken .Where(rt => rt.RefreshToken == refreshToken) .OrderByDescending(x => x.ExpiryDate) .FirstOrDefault(); if (userFromDbViaAccessToken != null && dealingWithRefreshToken.ValidateRefreshToken(refreshTokenUser, userFromDbViaAccessToken, refreshToken)) { UserDTO userWithTokens = _mapper.Map <UserDTO>(userFromDbViaAccessToken); userWithTokens.Token = GenerateJWT.CreateJWT(userFromDbViaAccessToken.Id, _jwtSettings.SecretKey, DateTime.UtcNow.AddSeconds(_expiryTimeSeconds)); RefreshRequest userTokens = new RefreshRequest(); var userFromDb = _context.TblRefreshToken.FirstOrDefault(x => x.User.RegistrationToken == refreshRequest.AccessToken); userFromDb.User.RegistrationToken = userWithTokens.Token; string newRefreshToken = Guid.NewGuid().ToString(); userFromDb.RefreshToken = newRefreshToken; _context.SaveChanges(); userTokens.AccessToken = userWithTokens.Token; userTokens.RefreshToken = newRefreshToken; return(Ok(userTokens)); } return(null); }
public async Task <IActionResult> Refresh(RefreshRequest request) { User user = await dbContext.Users.FirstOrDefaultAsync(it => it.RefreshToken.Equals(request.RefreshToken, StringComparison.OrdinalIgnoreCase)); if (user == null) { // The refresh token presented by the client is invalid. return(Unauthorized()); } // The refresh token was accepted. // Security Note: We don't need to regenerate the refresh token // since the owner has already been authenticated. // An impersonating JWT bearer will only have access util token // expiry. // The JWT bearer will only have the refresh token under // the scenario that they have the account credentials. RefreshResponse response = new RefreshResponse() { Token = CreateTokenFor(user) }; return(Ok(response)); }
private async Task LoadAuthors() { var authors = (await BookStoreService.GetAllAsync("authors")); authors = null; if (authors == null) { var accessToken = await LocalStorageService.GetItemAsync <string>("accessToken"); var refreshToken = await LocalStorageService.GetItemAsync <string>("refreshToken"); var refreshRequest = new RefreshRequest { AccessToken = accessToken, RefreshToken = refreshToken }; var user = (await UserService.RefreshAccessTokenAsync(refreshRequest)) as UserWithToken; if (user != null) { await LocalStorageService.SetItemAsync("accessToken", user.AccessToken); authors = (await BookStoreService.GetAllAsync("authors")); } } Authors = authors != null?authors.OrderByDescending(a => a.AuthorId).ToList() : new List <Author>(); StateHasChanged(); }
// on met à jour le token grâce au refresh_token public async Task <bool> RefreshToken() { using (HttpClient client = new HttpClient()) { try { HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, "https://td-api.julienmialon.com/auth/refresh"); RefreshRequest refreshToken = new RefreshRequest(Barrel.Current.Get <LoginResult>(key: "Login").RefreshToken); string data = JsonConvert.SerializeObject(refreshToken); request.Content = new StringContent(data, Encoding.UTF8, "application/json"); HttpResponseMessage response = await client.SendAsync(request); if (response.IsSuccessStatusCode) { var contentResponse = await response.Content.ReadAsStringAsync(); Response <LoginResult> res = JsonConvert.DeserializeObject <Response <LoginResult> >(contentResponse); Barrel.Current.Add(key: "Login", data: res.Data, expireIn: TimeSpan.FromDays(1)); return(true); } else { return(false); } } catch (HttpRequestException e) { Console.WriteLine(e.Message); return(false); } } }
public async Task <TimeSpan> RefreshAllocationAsync( TimeSpan lifetime, CancellationToken cancellationToken = default(CancellationToken)) { await EnsureConnection(); NetworkStream stream = _control.GetStream(); var request = new RefreshRequest((int)lifetime.TotalSeconds); await SendMessageAsync(stream, request, cancellationToken); StunMessage response = await ReceiveMessage(request.TransactionId); if (response is RefreshSuccessResponse success) { return(TimeSpan.FromSeconds(success.Lifetime)); } else if ( response is RefreshErrorResponse error && error.ErrorCode == 438) { // Retry refreshing when stale nonce error(438) occurred. Nonce = error.Nonce; return(await RefreshAllocationAsync(lifetime)); } throw new TurnClientException("RefreshRequest failed.", response); }
/// <inheritdoc /> Task <ApiResponse <AuthResponse> > IIdentityAPI.RefreshToken(RefreshRequest refreshRequest) { var arguments = new object[] { refreshRequest }; var func = requestBuilder.BuildRestResultFuncForMethod("RefreshToken", new Type[] { typeof(RefreshRequest) }); return((Task <ApiResponse <AuthResponse> >)func(Client, arguments)); }
public void HandleLayerButtonClick(ArItem item) { if (item != null && !IsEmpty(item.layerName) && !IsEmpty(item.url)) { Debug.Log("HandleLayerButtonClick " + item.itemName); RefreshRequest = new RefreshRequest { url = item.url, layerName = item.layerName, latitude = FixedDeviceLatitude, longitude = FixedDeviceLongitude }; } if (MenuEnabled.HasValue && MenuEnabled.Value) { HeaderButton.SetActive(_headerButtonActivated); MenuButton.SetActive(MenuEnabled.HasValue && MenuEnabled.Value); LayerPanel.SetActive(false); if (_layerScrollList != null) { _layerScrollList.RemoveButtons(); } } }
public async Task <bool> Refresh() { try { client = new HttpClient(); RefreshRequest refreshRequest = new RefreshRequest(Barrel.Current.Get <LoginResult>("Login").RefreshToken); string data = JsonConvert.SerializeObject(refreshRequest); var contentRequest = new StringContent(data, Encoding.UTF8, "application/json"); var uri = new Uri(string.Format("https://td-api.julienmialon.com/auth/refresh", string.Empty)); var response = await client.PostAsync(uri, contentRequest); if (response.IsSuccessStatusCode) { //Console.WriteLine("Test API REUSSI" + " " + response.StatusCode); var res = await response.Content.ReadAsStringAsync(); Response <LoginResult> jsonRes = JsonConvert.DeserializeObject <Response <LoginResult> >(res); Barrel.Current.Add("Login", jsonRes.Data, TimeSpan.FromDays(1)); return(true); } else { //Console.WriteLine("Test API RATEE" + " " + response.StatusCode +" " + response.RequestMessage + " " + response.ReasonPhrase); return(false); } } catch (Exception e) { Console.WriteLine(@" ERROR {0}", e.Message); return(false); } }
private void CoreDispatcher_AcceleratorKeyActivated(CoreDispatcher sender, AcceleratorKeyEventArgs e) { if ((e.EventType == CoreAcceleratorKeyEventType.SystemKeyDown || e.EventType == CoreAcceleratorKeyEventType.KeyDown)) { var coreWindow = Windows.UI.Xaml.Window.Current.CoreWindow; var downState = CoreVirtualKeyStates.Down; var virtualKey = e.VirtualKey; bool winKey = ((coreWindow.GetKeyState(VirtualKey.LeftWindows) & downState) == downState || (coreWindow.GetKeyState(VirtualKey.RightWindows) & downState) == downState); bool altKey = (coreWindow.GetKeyState(VirtualKey.Menu) & downState) == downState; bool controlKey = (coreWindow.GetKeyState(VirtualKey.Control) & downState) == downState; bool shiftKey = (coreWindow.GetKeyState(VirtualKey.Shift) & downState) == downState; // raise keydown actions var keyDown = new KeyboardEventArgs { AltKey = altKey, Character = ToChar(virtualKey, shiftKey), ControlKey = controlKey, EventArgs = e, ShiftKey = shiftKey, VirtualKey = virtualKey }; try { KeyDown?.Invoke(keyDown); } catch { } // Handle F5 to refresh content if (virtualKey == VirtualKey.F5) { bool noModifiers = !altKey && !controlKey && !shiftKey; RefreshRequest?.Invoke(keyDown); } } }
Task <TokenResponse> ITrueLayerAuthApi.RenewAuthToken(RefreshRequest req) => Post(new Dictionary <string, string> { { "grant_type", "refresh_token" }, { "client_id", req.ClientId }, { "client_secret", req.ClientSecret }, { "refresh_token", req.RefreshToken }, });
public void RefreshWithInvalidCredentials() { RefreshRequest refreshRequest = null; Refresh("foo", "bar", ref refreshRequest); Assert.False(refreshRequest.WasSuccessful); }
public async Task <IActionResult> RefreshToken([FromBody] RefreshRequest request) { return(await Action <RefreshTokenCommand, RefreshTokenCommandParameter, LoginResponse>(new RefreshTokenCommandParameter { RefreshToken = request.RefreshToken, ClientId = request.ClientId, ClientSecret = request.ClientSecret })); }
public async Task <RefreshResponse> ServiceRefreshRow(RefreshRequest message) { IRefreshOperationsUseCaseFactory factory = ServiceContainer.RefreshOperationsUseCaseFactory; IRefreshOperationsUseCase uc = factory.Create(this, (err) => { _OnError(err); return(GetFriendlyErrorMessage(err)); }); IResponsePresenter <RefreshResponse, RefreshResponse> output = ServiceContainer.GetRequiredService <IResponsePresenter <RefreshResponse, RefreshResponse> >(); bool res = await uc.Handle(message, output); return(output.Response); }
public async Task <ActionResult> Refresh([FromBody] RefreshRequest request) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } await _refreshTokenUseCase.Handle(new RefreshTokenRequest(request.AccessToken, request.RefreshToken, _authSettings.SecretKey), _refreshTokenPresenter); return(_refreshTokenPresenter.ContentResult); }
public RefreshRequestTests() { var request = new RefreshRequest() { Force = true, IgnoreUnavailable = true }; var response = this._client.Refresh(request); this._status = response.ConnectionStatus; }
public async Task <IActionResult> Refresh([FromBody] RefreshRequest request) { try { return(Ok(await userService.RefreshAccessToken(request.Username, request.AccessToken, request.RefreshToken))); } catch (ForbiddenException) { return(Forbid()); } }
public IActionResult Refresh(RefreshRequest request) { JwtSecurityToken oldJWT = new JwtSecurityToken(request.oldJWT); /* Get login of the user from the old token */ string rawIndex = oldJWT.Claims .ToList() .Find(e => e.Type.Equals(ClaimTypes.Name)) .ToString(); var indexData = rawIndex.Split(" "); string index = indexData[^ 1][..^ 0];
public void Refresh() { LoginRequest request = new LoginRequest(connection, "*****@*****.**", "7CujD&pg4nh"); LoginResponse response = request.Send(); Assert.AreEqual(response.StatusCode, System.Net.HttpStatusCode.OK); RefreshRequest request2 = new RefreshRequest(connection, response.refresh_token); RefreshResponse response2 = request2.Send(); Assert.AreEqual(response2.StatusCode, System.Net.HttpStatusCode.OK); }
public void HandleInputPanelClosed(float?latitude, float?longitude) { Debug.Log("HandleInputPanelClosed lat " + latitude + " lon " + longitude); RefreshRequest = new RefreshRequest { url = ArpoiseDirectoryUrl, layerName = ArpoiseDirectoryLayer, latitude = latitude, longitude = longitude }; }
public async Task <IActionResult> Refresh([FromBody] RefreshRequest request) { var refreshData = _mapper.Map <RefreshData>(request); var authResponse = await _authService.RefreshTokenAsync(refreshData); if (authResponse.Success) { return(Ok(_mapper.Map <AuthSuccessResponse>(authResponse))); } return(BadRequest(_mapper.Map <AuthFailedResponse>(authResponse))); }
public async Task <Response <LoginResponse> > Refresh(string refreshToken, string clientId, string clientSecret) { RefreshRequest refreshRequest = new RefreshRequest { ClientId = clientId, ClientSecret = clientSecret, RefreshToken = refreshToken }; string content = JsonConvert.SerializeObject(refreshRequest); return(await _apiService.Post <Response <LoginResponse> >(Urls.REFRESH_TOKEN, content)); }
public async Task <ActionResult <UserWithToken> > RefreshAccessToken([FromBody] RefreshRequest refreshRequest) { var user = await GetUserFromAccessToken(refreshRequest.AccessToken); if (user != null && ValidateRefreshToken(user, refreshRequest.RefreshToken)) { var userWithToken = new UserWithToken(user); userWithToken.AccessToken = GenerateAccessToken(user.UserId); return(userWithToken); } return(null); }
public JWTResponse RefreshToken(RefreshRequest refresh) {//token refreshing using (var client = new SqlConnection("Data Source = db-mssql.pjwstk.edu.pl; Initial Catalog = s16796; Integrated Security = True")) { using (var command = new SqlCommand()) { command.Connection = client; client.Open(); var transaction = client.BeginTransaction(); command.Transaction = transaction; command.CommandText = "Select IndexNumber FROM Student where Refresh_Token=@refresh"; command.Parameters.AddWithValue("refresh", refresh.RefreshToken); var dr = command.ExecuteReader(); command.Parameters.Clear(); if (dr.Read()) { var index = dr["IndexNumber"].ToString(); dr.Close(); var claims = new[] { new Claim("IndexNumber", index), new Claim(ClaimTypes.Role, "employee") }; var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["SecretKey"])); var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256); var token = new JwtSecurityToken ( issuer: "Gakko", audience: "Students", claims: claims, expires: DateTime.Now.AddMinutes(10), signingCredentials: creds ); command.CommandText = "UPDATE Student SET Refresh_Token = @refresh WHERE IndexNumber = @login"; var refreshtok = Guid.NewGuid().ToString(); command.Parameters.AddWithValue("login", index); command.Parameters.AddWithValue("refresh", refreshtok); command.ExecuteNonQuery(); transaction.Commit(); return(new JWTResponse { Token = new JwtSecurityTokenHandler().WriteToken(token), RefreshToken = refreshtok }); } else { return(null); } } } }
public IActionResult RefreshToken(RefreshRequest request) { var token = _JWTauthService.RefreshToken(request); if (token != null) { return(Ok(token)); } else { return(NotFound("No token like that found in database")); } }
public async Task <ActionResult <UserWithTocken> > Refresh([FromBody] RefreshRequest request) { Users user = await GetUserFromToken(request.Token); if (user == null || !await ValidateRefreshToken(user.Id, request.RefreshToken)) { return(null); } UserWithTocken result = new UserWithTocken(user); result.Token = GenerateJWTToken(user.Id, user.Roles); return(result); }
public async Task <ActionResult <BaseResponse <JWTToken> > > Refresh([FromBody] RefreshRequest tokens) { var newTokens = await _authService.Refresh(tokens); if (newTokens == null) { return(Forbid()); } return(Ok(new BaseResponse <JWTToken>() { Data = newTokens, Succes = true })); }