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 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
}));
}
