public async Task CreateAsync(AuthenticationTokenCreateContext context) { var clientid = context.Ticket.Properties.Dictionary["as:client_id"]; if (string.IsNullOrEmpty(clientid)) { return; } var refreshTokenId = Guid.NewGuid().ToString("n"); var refreshTokenLifeTime = context.OwinContext.Get <string>("as:clientRefreshTokenLifeTime"); var token = new RefreshTokenInfo() { TokenId = refreshTokenId.GetHash(), AppClientId = clientid, Subject = context.Ticket.Identity.Name, IssuedUtc = DateTime.UtcNow, ExpiresUtc = DateTime.UtcNow.AddMinutes(Convert.ToDouble(refreshTokenLifeTime)) }; context.Ticket.Properties.IssuedUtc = token.IssuedUtc; context.Ticket.Properties.ExpiresUtc = token.ExpiresUtc; token.ProtectedTicket = context.SerializeTicket(); var result = await ContainerManager.Resolve <IAuthRepository>().AddRefreshToken(token); if (result) { context.SetToken(refreshTokenId); } }
public Task SaveRefreshTokenAsync(RefreshTokenInfo tokenInfo) { return(Task.Factory.StartNew(() => { _configurationService.SetValue("RefreshToken", tokenInfo.RefreshToken); })); }
Task IRefreshTokenHandler.SaveRefreshTokenAsync(RefreshTokenInfo tokenInfo) { this.msAccountStatus = MSAccountStatus.Connected; return(Task.Factory.StartNew(() => { using (UsersContext db = new UsersContext()) { MSAccount msAccount = db.MSAccounts.FirstOrDefault(u => u.UserName == this.User.Identity.Name); if (msAccount != null) { if (tokenInfo.UserId != msAccount.MSUserId) { throw new LiveAuthException("invalid_user", "The account Id from the ticket does not match the current connected user."); } msAccount.RefreshToken = tokenInfo.RefreshToken; db.Entry(msAccount).State = System.Data.EntityState.Modified; } else { // Insert name into the profile table db.MSAccounts.Add(new MSAccount { MSUserId = tokenInfo.UserId, RefreshToken = tokenInfo.RefreshToken, UserName = this.User.Identity.Name }); } db.SaveChanges(); } })); }
public async Task <ResultModel <JwtResult <CoreUser> > > RefreshToken(CoreUser user) { var resultObj = new ResultModel <JwtResult <CoreUser> >(); var claims = GenerateClaims(user); //var principal = new ClaimsPrincipal(identity); var refreshTokenInfo = new RefreshTokenInfo() { UserId = user.Id, // Expired Date Refresh Token ExpiredDate = DateTime.Now.AddDays(37) }; var identifier = user.CoreCredentials.First().Identifier; var jwt = await TokenHelper.GenerateJwt(claims, _jwtFactory, identifier, _jwtOptions, new JsonSerializerSettings { Formatting = Formatting.Indented, ReferenceLoopHandling = ReferenceLoopHandling.Ignore }); var result = new JwtResult <CoreUser> { Token = jwt, RefreshToken = TokenHelper.GenerateRefreshToken(refreshTokenInfo, new JsonSerializerSettings { Formatting = Formatting.Indented, ReferenceLoopHandling = ReferenceLoopHandling.Ignore }) }; resultObj.Status = ResultStatus.Success; resultObj.ExtendData = result; _userDm.Update(user); return(resultObj); }
internal void TryRefreshToken(Action <LiveLoginResult> completionCallback) { LiveLoginResult result = new LiveLoginResult(LiveConnectSessionStatus.Unknown, null); if (this.refreshTokenHandler != null) { if (this.refreshTokenInfo == null) { this.refreshTokenHandler.RetrieveRefreshTokenAsync().ContinueWith(t => { if (t.Exception != null) { throw t.Exception; } this.refreshTokenInfo = t.Result; this.RefreshToken(completionCallback); }); return; } this.RefreshToken(completionCallback); return; } this.OnRefreshTokenCompleted(result, completionCallback); }
private void UpdateSession(LiveLoginResult result) { Debug.Assert(result != null); if (result.Session != null) { // Set the AuthClient that is needed when refreshing a token. result.Session.AuthClient = this.publicAuthClient; // We have a new session, update the public property this.loginStatus = result; this.publicAuthClient.Session = result.Session; if (this.refreshTokenHandler != null && !string.IsNullOrEmpty(result.Session.RefreshToken)) { RefreshTokenInfo refreshInfo = new RefreshTokenInfo(result.Session.RefreshToken); this.refreshTokenHandler.SaveRefreshTokenAsync(refreshInfo); } } else if (this.loginStatus.Status == LiveConnectSessionStatus.Unknown && result.Status == LiveConnectSessionStatus.NotConnected) { this.loginStatus = result; } }
public static string GenerateRefreshToken(RefreshTokenInfo model, JsonSerializerSettings serializerSettings) { var modelString = JsonConvert.SerializeObject(model, serializerSettings); var modelByte = System.Text.Encoding.UTF8.GetBytes(modelString); return(Convert.ToBase64String(modelByte)); }
private async Task <string> CustomProviderAuthentication(RefreshTokenInfo refreshTokenInfo) { try { var ret = await _mobileServiceClient.InvokeApiAsync <CustomLoginResult>( _customLoginControllerName, HttpMethod.Get, new Dictionary <string, string> { { "userId", refreshTokenInfo.UserId }, { "refreshToken", refreshTokenInfo.RefreshToken } }); if (ret != null) { _mobileServiceClient.CurrentUser = new MobileServiceUser(ret.UserId) { MobileServiceAuthenticationToken = ret.MobileServiceAuthenticationToken }; refreshTokenInfo.RefreshToken = ret.RefreshToken; _accountStoreService.StoreTokenInSecureStore(refreshTokenInfo); return(_mobileServiceClient.CurrentUser.MobileServiceAuthenticationToken); } else { return(string.Empty); } } catch (MobileServiceInvalidOperationException) { return(string.Empty); } }
public Task <bool> RemoveRefreshToken(RefreshTokenInfo refreshToken) { _repository.DeleteItem(refreshToken); var result = _unitOfWork.SaveChanges() > 0; return(Task.FromResult(result)); }
public Task <bool> RemoveRefreshToken(RefreshTokenInfo refreshToken) { if (refreshToken != null) { _efRepositiry.Delete(refreshToken); } return(Task.FromResult(_efRepositiry.SaveChanges() > 0)); }
public HttpResponseMessage RefreshToken(RefreshTokenInfo refreshTokenInfo) { Validate("RefreshToken", refreshTokenInfo.RefreshToken); Validate("ApiKey", refreshTokenInfo.ApiKey); var response = GetRefreshTokenResponse(refreshTokenInfo.RefreshToken, refreshTokenInfo.ApiKey); return(Request.CreateResponse(response.Json)); }
public void StoreTokenInSecureStore(RefreshTokenInfo user) { ClearSecureStore(); var account = new Account(user.UserId); account.Properties.Add("token", user.RefreshToken); account.Properties.Add("provider", user.Provider); _accountStore.Save(account, _serviceId); }
public Task SaveRefreshTokenAsync(RefreshTokenInfo tokenInfo) { return(Task.Factory.StartNew(() => { Console.WriteLine("------------------------"); Console.WriteLine("\r\nUserID = " + tokenInfo.UserId); Console.WriteLine("\r\nRefresh Token = " + tokenInfo.RefreshToken); Console.WriteLine("\r\n------------------------"); })); }
Task IRefreshTokenHandler.SaveRefreshTokenAsync(RefreshTokenInfo tokenInfo) { // Note: // 1) In order to receive refresh token, wl.offline_access scope is needed. // 2) Alternatively, we can persist the refresh token. return(Task.Factory.StartNew(() => { this.refreshTokenInfo = tokenInfo; })); }
Task IRefreshTokenHandler.SaveRefreshTokenAsync(RefreshTokenInfo tokenInfo) { return(Task.Factory.StartNew(() => { _refreshTokenInfo = tokenInfo; _persister.Save(new LiveToken { Value = _refreshTokenInfo.RefreshToken }); })); }
public LiveProvider(IPersister <LiveToken> persister) { persister.NotNull("persister"); _persister = persister; var token = _persister.Load(); if (token != null) { _refreshTokenInfo = new RefreshTokenInfo(token.Value); } }
//添加刷新令牌 public async Task <bool> AddRefreshToken(RefreshTokenInfo refreshToken) { var existingToken = dBContext.RefreshTokenInfo.FirstOrDefault(ti => ti.client_id == refreshToken.client_id); if (existingToken != null) { var result = await RemoveRefreshToken(existingToken); } dBContext.RefreshTokenInfo.Add(refreshToken); //var tokenInfo = await dBContext.TokenInfo.FindAsync(ID); //tokenInfo.refresh_token = refreshToken; return(await dBContext.SaveChangesAsync() > 0); }
public override async Task <bool> SaveToken(RefreshTokenInfo tokenInfo) { int result = 0; try { OAuthClientRefreshToken token = new OAuthClientRefreshToken() { Value = tokenInfo.Value, ProtectedTicket = tokenInfo.ProtectedTicket, IssuedUtc = tokenInfo.IssuedUtc, ExpiresUtc = tokenInfo.ExpiresUtc }; try { ClientRepository.UnitOfWork.BeginTransaction(); var client = ClientRepository.TrackEntities.Where(m => m.ClientId == tokenInfo.ClientId).FirstOrDefault(); ClientRepository.UnitOfWork.Commit(); if (client == null) { return(false); } token.Client = client; } catch (Exception ex) { Console.WriteLine(ex.ToString()); } UserRepository.UnitOfWork.BeginTransaction(); User user = UserRepository.TrackEntities.Where(m => m.UserName == tokenInfo.UserName).FirstOrDefault(); UserRepository.UnitOfWork.Commit(); //User user = await UserManager.FindByNameAsync(tokenInfo.UserName); //User user = await userStore.FindByNameAsync(tokenInfo.UserName); if (user == null) { return(false); } token.User = user; ClientRefreshTokenRepository.UnitOfWork.BeginTransaction(); result = await ClientRefreshTokenRepository.InsertAsync(token); ClientRefreshTokenRepository.UnitOfWork.Commit(); } catch (Exception ex) { Logger.Error("OAuthClientRefreshTokenStore.SaveToken错误:" + ex.ToString()); } return(result > 0); }
public async Task <bool> AddRefreshToken(RefreshTokenInfo token) { var existingToken = _repository.FirstOrDefault <RefreshTokenInfo>(r => r.Subject == token.Subject && r.AppClientId == token.AppClientId); if (existingToken != null) { var result = await RemoveRefreshToken(existingToken); } _repository.Insert(token); return(_unitOfWork.SaveChanges() > 0); }
Task IRefreshTokenHandler.SaveRefreshTokenAsync(RefreshTokenInfo tokenInfo) { return(Task.Factory.StartNew(() => { // Is stored in "OnSessionChanged" //this.BeginInvoke(new Action<RefreshTokenInfo> // ( // token => // { // this.txtRefreshToken.Text = token.RefreshToken; // } // ), tokenInfo); })); }
Task <RefreshTokenInfo> IRefreshTokenHandler.RetrieveRefreshTokenAsync() { return(Task.Factory.StartNew <RefreshTokenInfo>(() => { RefreshTokenInfo token = null; using (UsersContext db = new UsersContext()) { MSAccount msAccount = db.MSAccounts.FirstOrDefault(u => u.UserName == this.User.Identity.Name); if (msAccount != null) { token = new RefreshTokenInfo(msAccount.RefreshToken, msAccount.MSUserId); this.msAccountStatus = MSAccountStatus.Connected; } } return token; })); }
public Task SaveRefreshTokenAsync(RefreshTokenInfo tokenInfo) { // Note: // 1) In order to receive refresh token, wl.offline_access scope is needed. // 2) Alternatively, we can persist the refresh token. return(Task.Factory.StartNew(() => { if (File.Exists(path + "OneDrive.cloudmanager")) { File.Delete(path + "OneDrive.cloudmanager"); } if (!Directory.Exists(Path.GetDirectoryName(path + "OneDrive.cloudmanager"))) { Directory.CreateDirectory(Path.GetDirectoryName(path + "OneDrive.cloudmanager")); } File.AppendAllText(path + "OneDrive.cloudmanager", tokenInfo.RefreshToken); })); }
/// <summary> /// Sign In /// </summary> /// <param name="signInModel"></param> /// <returns></returns> public async Task <ResultModel <JwtResult <CoreUser> > > SignIn(SignInModel signInModel) { var resultObj = new ResultModel <JwtResult <CoreUser> >(); var validateResultObj = Validate(signInModel.LoginTypeCode, signInModel.Identifier, signInModel.Secret); if (validateResultObj.Status != ResultStatus.Success) { resultObj.Messages = validateResultObj.Messages; resultObj.Status = validateResultObj.Status; return(resultObj); } var user = validateResultObj.ExtendData; var claims = GenerateClaims(user); //var principal = new ClaimsPrincipal(identity); var refreshTokenInfo = new RefreshTokenInfo() { UserId = user.Id, // Expired Date Refresh Token ExpiredDate = DateTime.Now.AddDays(37) }; var jwt = await TokenHelper.GenerateJwt(claims, _jwtFactory, signInModel.Identifier, _jwtOptions, new JsonSerializerSettings { Formatting = Formatting.Indented, ReferenceLoopHandling = ReferenceLoopHandling.Ignore }); var result = new JwtResult <CoreUser> { User = user, Token = jwt, RefreshToken = TokenHelper.GenerateRefreshToken(refreshTokenInfo, new JsonSerializerSettings { Formatting = Formatting.Indented, ReferenceLoopHandling = ReferenceLoopHandling.Ignore }) }; resultObj.Status = ResultStatus.Success; resultObj.ExtendData = result; _userDm.Update(user); //result.User.CoreUserRoles.Clear(); result.User.CoreCredentials.Clear(); return(resultObj); }
private async Task <string> IdentityProviderAuthentication(RefreshTokenInfo refreshTokenInfo) { _mobileServiceClient.CurrentUser = new MobileServiceUser(refreshTokenInfo.UserId) { MobileServiceAuthenticationToken = refreshTokenInfo.RefreshToken }; try { var refreshed = await _mobileServiceClient.RefreshUserAsync(); _mobileServiceClient.CurrentUser = refreshed; refreshTokenInfo.RefreshToken = refreshed.MobileServiceAuthenticationToken; _accountStoreService.StoreTokenInSecureStore(refreshTokenInfo); return(_mobileServiceClient.CurrentUser.MobileServiceAuthenticationToken); } catch //some providers doesn't support refresh { return(IsTokenActive(_mobileServiceClient.CurrentUser.MobileServiceAuthenticationToken) ? _mobileServiceClient.CurrentUser.MobileServiceAuthenticationToken : string.Empty); } }
/// <summary> /// 创建刷新令牌 /// </summary> /// <param name="context"></param> /// <returns></returns> public async Task CreateAsync(AuthenticationTokenCreateContext context) { var clientid = context.Ticket.Properties.Dictionary["client_id"]; if (string.IsNullOrEmpty(clientid)) { return; } //真实设置refreshtoken的过期时间 var client = context.OwinContext.Get <AuthorizationInfo>("client"); var issued = DateTime.UtcNow; var expired = issued.AddMinutes(Convert.ToDouble(client.refresh_token_life_time)); context.Ticket.Properties.IssuedUtc = issued; context.Ticket.Properties.ExpiresUtc = expired; //生成 refresh_token 并存储到数据库中 string ProtectedTicket = context.SerializeTicket(); var refreshTokenId = context.OwinContext.Get <string>("refreshToken"); //创建Refresh Token对象 var refreshToken = new RefreshTokenInfo() { //以散列格式存储RefreshTokenId ID = refreshTokenId, client_id = clientid, protected_ticket = ProtectedTicket, issued = issued, expired = expired }; using (RefreshTokenInfoRepository refreshTokenInfoRepository = new RefreshTokenInfoRepository()) { var result = await refreshTokenInfoRepository.AddRefreshToken(refreshToken); if (result) { context.SetToken(refreshTokenId); } } await Task.FromResult <bool>(true); }
/// <summary> /// 获取刷新Token /// </summary> /// <param name="value">token值</param> /// <returns></returns> public override Task <RefreshTokenInfo> GetTokenInfo(string value) { RefreshTokenInfo tokenInfo = new RefreshTokenInfo(); try { tokenInfo = ClientRefreshTokenRepository.Entities.Where(m => m.Value == value).Select(m => new RefreshTokenInfo() { Value = m.Value, IssuedUtc = m.IssuedUtc, ExpiresUtc = m.ExpiresUtc, ProtectedTicket = m.ProtectedTicket, ClientId = m.Client.ClientId, UserName = m.User.UserName }).FirstOrDefault(); } catch (Exception ex) { Logger.Error("OAuthClientRefreshTokenStore.GetTokenInfo错误:" + ex.ToString()); } return(Task.FromResult(tokenInfo)); }
public Task <bool> AddRefreshToken(RefreshTokenInfo token) { _efRepositiry.Insert(token); return(Task.FromResult(_efRepositiry.SaveChanges() > 0)); }
Task IRefreshTokenHandler.SaveRefreshTokenAsync(RefreshTokenInfo tokenInfo) { // RefreshToken is saved if the property is set in the mainwindow; so no action here... return(Task.Factory.StartNew(() => { })); }
/// <summary> /// Wir speichern an dieser Stelle den Token nicht /// </summary> /// <param name="tokenInfo"></param> /// <returns></returns> public async Task SaveRefreshTokenAsync(RefreshTokenInfo tokenInfo) { await Task.Delay(0); }
Task IRefreshTokenHandler.SaveRefreshTokenAsync(RefreshTokenInfo tokenInfo) { // Note: // 1) In order to receive refresh token, wl.offline_access scope is needed. // 2) Alternatively, we can persist the refresh token. return Task.Factory.StartNew(() => { this.refreshTokenInfo = tokenInfo; }); }
Task<RefreshTokenInfo> IRefreshTokenHandler.RetrieveRefreshTokenAsync() { return Task.Factory.StartNew<RefreshTokenInfo>(() => { RefreshTokenInfo token = null; using (UsersContext db = new UsersContext()) { MSAccount msAccount = db.MSAccounts.FirstOrDefault(u => u.UserName == this.User.Identity.Name); if (msAccount != null) { token = new RefreshTokenInfo(msAccount.RefreshToken, msAccount.MSUserId); this.msAccountStatus = MSAccountStatus.Connected; } } return token; }); }
Task IRefreshTokenHandler.SaveRefreshTokenAsync(RefreshTokenInfo tokenInfo) { this.msAccountStatus = MSAccountStatus.Connected; return Task.Factory.StartNew(() => { using (UsersContext db = new UsersContext()) { MSAccount msAccount = db.MSAccounts.FirstOrDefault(u => u.UserName == this.User.Identity.Name); if (msAccount != null) { if (tokenInfo.UserId != msAccount.MSUserId) { throw new LiveAuthException("invalid_user", "The account Id from the ticket does not match the current connected user."); } msAccount.RefreshToken = tokenInfo.RefreshToken; db.Entry(msAccount).State = System.Data.EntityState.Modified; } else { // Insert name into the profile table db.MSAccounts.Add(new MSAccount { MSUserId = tokenInfo.UserId, RefreshToken = tokenInfo.RefreshToken, UserName = this.User.Identity.Name }); } db.SaveChanges(); } }); }
//删除刷新令牌 private async Task <bool> RemoveRefreshToken(RefreshTokenInfo refreshToken) { dBContext.RefreshTokenInfo.Remove(refreshToken); return(await dBContext.SaveChangesAsync() > 0); }