public override async Task ReceiveAsync(AuthenticationTokenReceiveContext context) { var url = string.Format(_tokenValidationEndpoint, context.Token); var response = await _client.GetAsync(url); if (response.StatusCode != HttpStatusCode.OK) { return; } var jsonString = await response.Content.ReadAsStringAsync(); var dictionary = JsonConvert.DeserializeObject<Dictionary<string, object>>(jsonString); var claims = new List<Claim>(); foreach (var item in dictionary) { var values = item.Value as IEnumerable<object>; if (values == null) { claims.Add(new Claim(item.Key, item.Value.ToString())); } else { foreach (var value in values) { claims.Add(new Claim(item.Key, value.ToString())); } } } context.SetTicket(new AuthenticationTicket(new ClaimsIdentity(claims, _authenticationType), new AuthenticationProperties())); }
public Task ReceiveAsync(AuthenticationTokenReceiveContext context) { return Task.Run(() => { Receive(context); }); }
public async Task ReceiveAsync(AuthenticationTokenReceiveContext context) { try { var allowedOrigin = context.OwinContext.Get<string>("as:clientAllowedOrigin") ?? "*"; context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { allowedOrigin }); var hashedTokenId = Helper.GetHash(context.Token); using (IRepository rep = new ApplicationRepository()) { var refreshToken = await rep.RefreshTokens.FindAsync(hashedTokenId); if (refreshToken != null) { //Get protectedTicket from refreshToken class context.DeserializeTicket(refreshToken.ProtectedTicket); var result = await rep.RefreshTokens.RemoveAsync(hashedTokenId); } } } catch (Exception e) { throw e; } }
public async Task ReceiveAsync(AuthenticationTokenReceiveContext context) { try { var hashedTokenId = HashHelper.GetHash(context.Token); using (AuthRepository authService = new AuthRepository()) { var refreshToken = authService.FindRefreshToken(hashedTokenId); if (refreshToken != null) { //Get protectedTicket from refreshToken class context.DeserializeTicket(refreshToken.ProtectedTicket); //remove token from db var result = authService.RemoveRefreshToken(hashedTokenId); } } } catch (Exception ex) { Logger.Error("Error receiving token: " + ex.InnerException); } }
public async Task ReceiveAsync(AuthenticationTokenReceiveContext context) { var allowedOrigin = context.OwinContext.Get<string>("as:clientAllowedOrigin"); if (context.OwinContext.Response.Headers.Keys.Contains("Access-Control-Allow-Origin")) { context.OwinContext.Response.Headers["Access-Control-Allow-Origin"] = allowedOrigin; } else { context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] {allowedOrigin}); } var hashedTokenId = TokenHelper.GetHash(context.Token); using (var _repo = new AuthRepository()) { var refreshToken = await _repo.FindRefreshToken(hashedTokenId); if (refreshToken != null) { //Get protectedTicket from refreshToken class context.DeserializeTicket(refreshToken.ProtectedTicket); var result = await _repo.RemoveRefreshToken(hashedTokenId); } } }
public async Task ReceiveAsync(AuthenticationTokenReceiveContext context) { //PIN lockout not yet implemented. Might integrated with account lockout or its own thing //Uncomment this to accept a post parameter called "pin" //IFormCollection form = await context.Request.ReadFormAsync(); //string submittedPin = form["PIN"]; if(!String.IsNullOrEmpty(context.Token)){ Guid refreshToken = Guid.Parse(context.Token); if(refreshToken != null){ ApplicationDbContext dbContext = context.OwinContext.Get<ApplicationDbContext>(); OAuthSession oauthSession = dbContext.OAuthSessions.SingleOrDefault(oas => oas.RefreshToken == refreshToken); OAuthClient oauthClient = context.OwinContext.Get<OAuthClient>(NicksApplicationOAuthProvider.OwinClientKey); if (oauthSession != null && oauthClient != null && oauthSession.ClientId == oauthClient.Id && oauthClient.OrganizationId == oauthSession.OrganizationId && oauthSession.IsRefreshTokenValid(refreshToken, Startup.RefreshTokenTimeSpan)) { ApplicationUserManager userManager = context.OwinContext.GetUserManager<ApplicationUserManager>(); ApplicationUser user = await userManager.FindByIdAsync(oauthSession.UserId); //Uncomment this and the closing brace to verify the PIN hash referenced above //if (userManager.PasswordHasher.VerifyHashedPassword(user.PINHash,submittedPin) == PasswordVerificationResult.Success) //{ context.OwinContext.Set<ApplicationUser>(NicksApplicationOAuthProvider.OwinUserKey, user); ClaimsIdentity oAuthIdentity = await user.GenerateUserIdentityAsync(userManager, OAuthDefaults.AuthenticationType); IDictionary<string, string> properties = new Dictionary<string, string>{ { "userName", user.UserName } }; AuthenticationTicket ticket = new AuthenticationTicket(oAuthIdentity, new AuthenticationProperties(properties)); ticket.Properties.IssuedUtc = DateTimeOffset.UtcNow; ticket.Properties.ExpiresUtc = DateTimeOffset.UtcNow.Add(Startup.OAuthOptions.AccessTokenExpireTimeSpan); context.SetTicket(ticket); //} } } } }
public async Task ReceiveAsync(AuthenticationTokenReceiveContext context) { // define o cabecalho da resposta do contexto do Owin com a permição de origem var allowedOrigin = context.OwinContext.Get<string>("as:clientAllowedOrigin"); context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { allowedOrigin }); // pega o Id do token pelo na requisição var hashedTokenId = HashHelper.GetHash(context.Token); // Identifica o Browser var userAgent = HttpContext.Current.Request.UserAgent; var userBrowser = new HttpBrowserCapabilities { Capabilities = new Hashtable { { string.Empty, userAgent } } }; var factory = new BrowserCapabilitiesFactory(); factory.ConfigureBrowserCapabilities(new NameValueCollection(), userBrowser); var browser = userBrowser.Browser; var refreshTokenDomain = DependecyConfig.Container.GetInstance<IRefreshTokenDomain>(); // busca o token na base de dados pelo id var refreshToken = await refreshTokenDomain.ReadAsync(hashedTokenId, browser); // se o token for encontrado if (refreshToken != null) { // pega os dados do ticket para deserializar e gerar um novo ticket com // as informações mapeadas do usuário que utiliza este token var ticketSerializer = new TicketSerializer(); var ticket = ticketSerializer.Deserialize(refreshToken.ProtectedTicket); context.SetTicket(ticket); // remove o token da base de dados pois em nossa lógica, permitimos apenas // um RefreshToken por usuário e aplicação cliente await refreshTokenDomain.DeleteAsync(hashedTokenId, browser); } }
public async Task ReceiveAsync(AuthenticationTokenReceiveContext context) { using (var ctx = new ApplicationDbContext()) { // Get the hash of our token var hash = Encryption.Hash(context.Token); // Find the refresh token by its hash var rt = (from r in ctx.RefreshTokens where r.Id == hash select r).SingleOrDefault(); if (rt != null) { // Get ticket from stored data context.DeserializeTicket(rt.Ticket); // Delete the token from the DB ctx.RefreshTokens.Remove(rt); // Save changes await ctx.SaveChangesAsync(); } } }
public void Receive(AuthenticationTokenReceiveContext context) { var oAuthIdentity = new ClaimsIdentity(); oAuthIdentity.AddClaim(new Claim(ClaimTypes.Name, "jeremy")); var ticket = new AuthenticationTicket(oAuthIdentity, new AuthenticationProperties()); context.SetTicket(ticket); }
/// <summary> /// /// </summary> /// <param name="context"></param> public override void Receive(AuthenticationTokenReceiveContext context) { string token; if (_refreshTokens.TryRemove(context.Token, out token)) { context.DeserializeTicket(token); } }
public void Receive(AuthenticationTokenReceiveContext context) { TicketResult result = Remove(context); if (result.Deleted) { context.SetTicket(result.Ticket); } }
public async Task ReceiveAsync(AuthenticationTokenReceiveContext context) { TicketResult result = await RemoveAsync(context); if (result.Deleted) { context.SetTicket(result.Ticket); } }
public override void Receive(AuthenticationTokenReceiveContext context) { string value; if (_codes.TryRemove(context.Token, out value)) { context.DeserializeTicket(value); } }
private void ReceiveAuthenticationCode(AuthenticationTokenReceiveContext context) { string value; if (_authCodes.TryRemove(context.Token, out value)) { context.DeserializeTicket(value); } }
public void Receive(AuthenticationTokenReceiveContext context) { AuthenticationTicket ticket; if (RefreshTokens.TryRemove(context.Token, out ticket)) { context.SetTicket(ticket); } }
public async Task ReceiveAsync(AuthenticationTokenReceiveContext context) { AuthenticationTicket ticket; if (_refreshTokens.TryRemove(context.Token, out ticket)) { context.SetTicket(ticket); } }
public void Receive(AuthenticationTokenReceiveContext context) { //TODO: before generating a new ticket, validate the ticket has not expired, and has never //been used to generate a new ticket var token = new CustomTokenFormat().Unprotect(context.Token.Replace(" ", "+")); var ticket = AuthTicketBuilder.BuildTicket(token); context.SetTicket(ticket); }
public async Task ReceiveAsync(AuthenticationTokenReceiveContext context) { context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { "*" }); await Task.Run(() => { context.DeserializeTicket(context.Token); }); }
public async Task ReceiveAsync(AuthenticationTokenReceiveContext context) { AuthenticationTicket ticket; string header = context.OwinContext.Request.Headers["Authorization"]; if (_refreshTokens.TryRemove(context.Token, out ticket)) { context.SetTicket(ticket); } }
/// <summary> /// 移除RefreshToken,在客户端使用RefreshToken请求新的AccessToken的时候自动调用 /// </summary> /// <param name="context"></param> public async override Task ReceiveAsync(AuthenticationTokenReceiveContext context) { RefreshTokenInfo token = await _clientRefreshTokenStore.GetTokenInfo(context.Token); if (token == null) { return; } context.DeserializeTicket(token.ProtectedTicket); await _clientRefreshTokenStore.Remove(context.Token); }
public void Receive(AuthenticationTokenReceiveContext context) { context.DeserializeTicket(context.Token); //var isUpdated = _usersRepository.IsRegisteredUserUpdated(context.Ticket.Identity.Claims.First(i => i.Type == ClaimTypes.NameIdentifier)); /*f (isUpdated) { context.Response.StatusCode = (int)HttpStatusCode.Forbidden; context.Response.ReasonPhrase = Exceptions.UserDataChanged; }*/ }
public override Task ReceiveAsync(AuthenticationTokenReceiveContext context) { var tokenValidator = new TokenValidator(); ClaimsPrincipal principal = tokenValidator.Validate(context.Token, _options); context.SetTicket(new AuthenticationTicket((ClaimsIdentity)principal.Identity, new AuthenticationProperties())); return base.ReceiveAsync(context); }
public override void Receive(AuthenticationTokenReceiveContext context) { var container = context.OwinContext.GetAutofacLifetimeScope(); var membershipService = container.Resolve<IAuthorizationService>(); var hashedTokenId = VaBank.Common.Security.Hash.Compute(context.Token); var token = membershipService.RevokeToken(new IdentityQuery<string>(hashedTokenId)); if (token != null) { context.DeserializeTicket(token.Value); } base.Receive(context); }
public async Task ReceiveAsync(AuthenticationTokenReceiveContext context) { //var hashedTokenId = CryptoAes.GetHash(context.Token); using (var authenticationTokenService = _dependencyResolver.GetService<IAuthenticationTokenFactory>()) { var ticket = await authenticationTokenService.IssueAuthenticationTicketAsync(context.Token); if (ticket != null) { context.SetTicket(ticket); } } }
public async Task ReceiveAsync(AuthenticationTokenReceiveContext context) { var allowedOrigin = context.OwinContext.Get<string>("as:clientAllowedOrigin"); context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { allowedOrigin }); string hashedToken = PasswordHelper.HashToken(context.Token); var authenticationClient = new AuthenticationClient(); var response = await authenticationClient.GetRefreshToken(new GetRefreshTokenRequest { HashedToken = hashedToken }); if (response.RefreshToken != null) { context.DeserializeTicket(response.RefreshToken.ProtectedTicket); await authenticationClient.DeleteRefreshToken(new DeleteRefreshTokenRequest { HashedToken = hashedToken }); } }
public virtual void Receive(AuthenticationTokenReceiveContext context) { if (OnReceiveAsync != null && OnReceive == null) { throw new InvalidOperationException(Resources.Exception_AuthenticationTokenDoesNotProvideSyncMethods); } if (OnReceive != null) { OnReceive.Invoke(context); } }
public async Task ReceiveAsync(AuthenticationTokenReceiveContext context) { context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { "*" }); context.OwinContext.Response.Headers.Add("Access-Control-Allow-Headers", new[] { "Content-Type" }); AuthenticationTicket ticket; if (_refreshTokens.TryRemove(context.Token, out ticket)) { context.SetTicket(ticket); } //return Task.FromResult<object>(null); }
public void Receive(AuthenticationTokenReceiveContext context) { var hashedTokenId = Helper.GetHash(context.Token); var appTokenService = mobSocialEngine.ActiveEngine.Resolve<IAppTokenService>(); var appToken = appTokenService.FirstOrDefault(x => x.Guid == hashedTokenId); if (appToken != null) { //Get protectedTicket from refreshToken class context.DeserializeTicket(appToken.ProtectedTicket); appTokenService.Delete(appToken); } }
public async Task ReceiveAsync(AuthenticationTokenReceiveContext context) { Guid token; if (Guid.TryParse(context.Token, out token)) { AuthenticationTicket ticket; if (_refreshTokens.TryRemove(ComputeHash(token), out ticket)) { context.SetTicket(ticket); } } }
public async Task ReceiveAsync(AuthenticationTokenReceiveContext context) { var allowedOrigin = context.OwinContext.Get<string>("as:clientAllowedOrigin"); context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { allowedOrigin }); var hashedTokenId = AuthorizationHelpers.GetHash(context.Token); var refreshToken = await _userRepository.FindRefreshTokenAsync(hashedTokenId); if (refreshToken != null) { context.DeserializeTicket(refreshToken.ProtectedTicket); await _userRepository.TryRemoveRefreshTokenAsync(hashedTokenId); } }