/// <summary> /// Requests the authentication core. /// </summary> /// <param name="context">The context.</param> /// <param name="provider">The provider.</param> /// <param name="returnUrl">The return URL.</param> internal static void RequestAuthenticationCore(HttpContextBase context, string provider, string returnUrl) { IAuthenticationClient client = GetOAuthClient(provider); var securityManager = new OpenAuthSecurityManager(context, client, OAuthDataProvider); securityManager.RequestAuthentication(returnUrl); }
public ActionResult ExternalLoginCallback(string returnUrl) { AuthenticationResult result = OAuthWebSecurity.VerifyAuthentication(Url.Action("ExternalLoginCallback", new { ReturnUrl = returnUrl })); if (!result.IsSuccessful) { return(RedirectToAction("ExternalLoginFailure")); } var securityManager = new OpenAuthSecurityManager(HttpContext, new ProxyOAuthClient(result.Provider), new NoDbOAuthDataProvider()); if (securityManager.Login(result.ProviderUserId, false)) { return(RedirectToLocal(returnUrl)); } if (User.Identity.IsAuthenticated) { // If the current user is logged in add the new account OAuthWebSecurity.CreateOrUpdateAccount(result.Provider, result.ProviderUserId, User.Identity.Name); return(RedirectToLocal(returnUrl)); } else { // User is new, ask for their desired membership name string loginData = OAuthWebSecurity.SerializeProviderUserId(result.Provider, result.ProviderUserId); ViewBag.ProviderDisplayName = OAuthWebSecurity.GetOAuthClientData(result.Provider).DisplayName; ViewBag.ReturnUrl = returnUrl; return(View("ExternalLoginConfirmation", new RegisterExternalLoginModel { UserName = result.UserName, ExternalLoginData = loginData })); } }
internal static bool LoginCore(HttpContextBase context, string providerName, string providerUserId, bool createPersistentCookie) { var provider = GetOAuthClient(providerName); var securityManager = new OpenAuthSecurityManager(context, provider, OAuthDataProvider); return(securityManager.Login(providerUserId, createPersistentCookie)); }
public AuthenticationResult VerifyAuthentication(IAuthenticationClient client, IOpenAuthDataProvider provider, string returnUrl) { var context = new HttpContextWrapper(HttpContext.Current); var securityManager = new OpenAuthSecurityManager(context, client, provider); return(securityManager.VerifyAuthentication(returnUrl)); }
public static AuthenticationResult VerifyAuthentication() { var manager = new OpenAuthSecurityManager(new HttpContextWrapper(HttpContext.Current), ms, OAuthDataProvider.Instance); return(manager.VerifyAuthentication(Configuration.GitHubOauthRedirect)); }
public void RequestAuthentication(IAuthenticationClient client, IOpenAuthDataProvider provider, string returnUrl) { var securityManager = new OpenAuthSecurityManager( new HttpContextWrapper(HttpContext.Current), client, provider); securityManager.RequestAuthentication(returnUrl); }
//public void CreateOrUpdateUser(IUser user) //{ // // Insert a new user into the database // using (UsersContext db = new UsersContext()) // { // UserProfile user = db.UserProfiles.FirstOrDefault(u => u.UserName.ToLower() == model.UserName.ToLower()); // // Check if user already exists // if (user == null) // { // // Insert name into the profile table // db.UserProfiles.Add(new UserProfile { UserName = model.UserName }); // db.SaveChanges(); // UserService.OAuthCreateOrUpdateAccount(provider, providerUserId, model.UserName); // UserService.OAuthLogin(provider, providerUserId); // return RedirectToLocal(returnUrl); // } // else // { // ModelState.AddModelError("UserName", "IUser name already exists. Please enter a different user name."); // } // } //} protected virtual bool OAuthLoginCore(HttpContextBase context, string providerName, string providerUserId, bool createPersistentCookie) { var provider = _oAuthRegisteredClientCollection.GetOAuthClient(providerName); var securityManager = new OpenAuthSecurityManager(context, provider, this); return(securityManager.Login(providerUserId, createPersistentCookie)); }
/// <summary> /// Requests the authentication core. /// </summary> /// <param name="context">The context.</param> /// <param name="provider">The provider.</param> /// <param name="returnUrl">The return URL.</param> protected virtual void OAuthRequestAuthenticationCore(HttpContextBase context, string provider, string returnUrl) { IAuthenticationClient client = _oAuthRegisteredClientCollection.GetOAuthClient(provider); var securityManager = new OpenAuthSecurityManager(context, client, this); securityManager.RequestAuthentication(returnUrl); }
internal static AuthenticationResult VerifyAuthenticationCore( HttpContextBase context, string returnUrl ) { string providerName = OpenAuthSecurityManager.GetProviderName(context); if (String.IsNullOrEmpty(providerName)) { return(AuthenticationResult.Failed); } IAuthenticationClient client; if (TryGetOAuthClient(providerName, out client)) { var securityManager = new OpenAuthSecurityManager( context, client, OAuthDataProvider ); return(securityManager.VerifyAuthentication(returnUrl)); } else { throw new InvalidOperationException(WebResources.InvalidServiceProviderName); } }
public bool ValidateOpenAuthUser(string providerName, string providerUserID, bool createPersistentCookie) { if (string.IsNullOrEmpty(providerName)) { throw new ArgumentException(Resources.ArgumentNullOrEmpty, "providerName"); } if (string.IsNullOrEmpty(providerUserID)) { throw new ArgumentException(Resources.ArgumentNullOrEmpty, "providerUserID"); } var openAuthAccount = this.db.UserOpenAuthAccounts.SingleOrDefault(a => a.ProviderName == providerName && a.ProviderUserID == providerUserID); if (openAuthAccount == null) { return(false); } openAuthAccount.LastUsedDate = DateTime.UtcNow; this.db.SaveChanges(); var manager = new OpenAuthSecurityManager(new HttpContextWrapper(HttpContext.Current), OpenAuth.AuthenticationClients.GetByProviderName(providerName), new OpenAuthDataProvider(this.db)); return(manager.Login(providerUserID, createPersistentCookie)); }
public bool OAuthLogin(string provider, string providerUserId, bool persistCookie) { var oauthProvider = _authenticationClients[provider]; var context = _applicationEnvironment.AcquireContext(); var securityManager = new OpenAuthSecurityManager(context, oauthProvider.AuthenticationClient, this); return(securityManager.Login(providerUserId, persistCookie)); }
public static void RequestAuthentication(Kooboo.CMS.Membership.Models.Membership membership, string connectName, HttpContextBase httpContext, string returnUrl) { var client = GetAuthClient(membership, connectName); OpenAuthSecurityManager manager = new OpenAuthSecurityManager(httpContext, client.GetOpenAuthClient(), new MembershipOpenAuthDataProvider()); manager.RequestAuthentication(returnUrl); //client.RequestAuthentication(httpContext, new Uri(returnUrl)); }
public static AuthenticationResult VerifyAuthentication() { var ms = new GoogleOAuth2Client(Configuration.OauthClientId, Configuration.OauthClientSecret); var manager = new OpenAuthSecurityManager(new HttpContextWrapper(HttpContext.Current), ms, OAuthDataProvider.Instance); GoogleOAuth2Client.RewriteRequest(); return(manager.VerifyAuthentication(Configuration.OauthRedirect)); }
internal static AuthResult VerifyAuthenticationCore(Kooboo.CMS.Membership.Models.Membership membership, HttpContextBase context, string returnUrl) { IAuthClient client; string providerName = OpenAuthSecurityManager.GetProviderName(context); if (string.IsNullOrEmpty(providerName)) { return(AuthResult.Failed); } client = GetAuthClient(membership, providerName); if (client == null) { throw new InvalidOperationException("Invalid membership connect."); } OpenAuthSecurityManager manager = new OpenAuthSecurityManager(context, client.GetOpenAuthClient(), new MembershipOpenAuthDataProvider()); var result = manager.VerifyAuthentication(returnUrl); return(new AuthResult(result)); }
protected virtual AuthenticationResult OAuthVerifyAuthenticationCore(HttpContextBase context, string returnUrl) { string providerName = OpenAuthSecurityManager.GetProviderName(context); if (String.IsNullOrEmpty(providerName)) { return(AuthenticationResult.Failed); } IAuthenticationClient client; if (_oAuthRegisteredClientCollection.TryGetOAuthClient(providerName, out client)) { var securityManager = new OpenAuthSecurityManager(context, client, this); return(securityManager.VerifyAuthentication(returnUrl)); } else { throw new InvalidOperationException("InvalidServiceProviderName"); } }
public bool OAuthLogin(OAuthAccount account, bool remember) { AuthenticationClientData oauthProvider = _authenticationClients[account.Provider]; HttpContextBase context = _applicationEnvironment.AcquireContext(); var securityManager = new OpenAuthSecurityManager(context, oauthProvider.AuthenticationClient, this); bool success = securityManager.Login(account.ProviderUserId, remember); if (success) { return(true); } User user = GetUserByEmailAddress(account.Username); if (user == null) { return(false); } user.OAuthAccounts.Add(account); _userCollection.Save(user); return(securityManager.Login(account.ProviderUserId, remember)); }
// GET: /api/auth/{provider} public HttpResponseMessage Get(string provider) { HttpResponseMessage response; var result = OpenAuth.VerifyAuthentication(VirtualPathUtility.ToAbsolute("~/api/auth/" + provider)); if (!result.IsSuccessful) { response = this.Request.CreateResponse(HttpStatusCode.Redirect); response.Headers.Location = new Uri(VirtualPathUtility.ToAbsolute("~/login?auth=failed"), UriKind.Relative); return(response); } var openAuthAccount = this.db.UserOpenAuthAccounts.SingleOrDefault(a => a.ProviderName == result.Provider && a.ProviderUserID == result.ProviderUserId); if (openAuthAccount != null) { var manager = new OpenAuthSecurityManager(new HttpContextWrapper(HttpContext.Current), OpenAuth.AuthenticationClients.GetByProviderName(result.Provider), new OpenAuthDataProvider(this.db)); if (manager.Login(result.ProviderUserId, createPersistentCookie: true)) { openAuthAccount.LastUsedDate = DateTime.UtcNow; this.db.SaveChanges(); response = this.Request.CreateResponse(HttpStatusCode.Redirect); response.Headers.Location = new Uri(VirtualPathUtility.ToAbsolute("~/"), UriKind.Relative); return(response); } } if (this.User.Identity.IsAuthenticated) { var user = this.db.Users.SingleOrDefault(u => u.UserName == this.User.Identity.Name); if (user == null) { throw new InvalidOperationException(string.Format("Cannot find a user with username '{0}'.", this.User.Identity.Name)); } var dateNow = DateTime.UtcNow; this.db.UserOpenAuthAccounts.Add(new UserOpenAuthAccount { UserID = user.UserID, ProviderName = result.Provider, ProviderUserID = result.ProviderUserId, ProviderUserName = result.UserName, LastUsedDate = dateNow }); user.LastLoginDate = dateNow; user.LastActivityDate = dateNow; this.db.SaveChanges(); response = this.Request.CreateResponse(HttpStatusCode.Redirect); response.Headers.Location = new Uri(VirtualPathUtility.ToAbsolute("~/"), UriKind.Relative); return(response); } // User is new, ask for their desired membership name var loginData = CryptoUtility.Serialize("oauth", result.Provider, result.ProviderUserId, result.UserName); var url = "~/login?providerName=" + OpenAuth.GetProviderDisplayName(result.Provider) + "&userName="******"@") ? result.UserName.Substring(0, result.UserName.IndexOf("@")) : result.UserName) + "&email=" + (result.UserName.Contains("@") ? result.UserName : string.Empty) + "&externalLoginData=" + loginData; response = this.Request.CreateResponse(HttpStatusCode.Redirect); response.Headers.Location = new Uri(VirtualPathUtility.ToAbsolute(url), UriKind.Relative); return(response); }
public string GetOAuthPoviderName() { var context = new HttpContextWrapper(HttpContext.Current); return(OpenAuthSecurityManager.GetProviderName(context)); }