/// <summary> /// Loads the settings for the IdentityConfiguration from the application or web configuration file. /// </summary> /// <remarks> /// If there is no configuration file, or the named section does not exist, then no exception is thrown, /// instead the class is loaded with a set of default values. /// </remarks> protected void LoadConfiguration(IdentityConfigurationElement element) { if (element != null) { // // Load the claims authentication manager // if (element.ClaimsAuthenticationManager.IsConfigured) { _claimsAuthenticationManager = GetClaimsAuthenticationManager(element); } // // Load the claims authorization manager. // if (element.ClaimsAuthorizationManager.IsConfigured) { _claimsAuthorizationManager = CustomTypeElement.Resolve <ClaimsAuthorizationManager>(element.ClaimsAuthorizationManager); } // // Load the service level Security Token Handler configuration // _serviceHandlerConfiguration = LoadHandlerConfiguration(element); } // // Reads handler configuration via LoadConfiguredHandlers. Do this last. // _securityTokenHandlerCollectionManager = LoadHandlers(element); }
protected override void Initialize(RequestContext requestContext) { base.Initialize(requestContext); if (Request.Cookies["lang"] != null) { var value = Request.Cookies["lang"].Value; Thread.CurrentThread.CurrentCulture = new CultureInfo(value); Thread.CurrentThread.CurrentUICulture = new CultureInfo(value); } if (Request.Cookies["access_token"] != null) { var value = Request.Cookies["access_token"].Value; if (!string.IsNullOrEmpty(value)) { var jwtToken = new JwtSecurityToken(value); var claims = jwtToken.Claims; ClaimsIdentity claim = new ClaimsIdentity(claims); var cp = new ClaimsPrincipal(claim); var transformer = new ClaimsAuthenticationManager(); var newPrincipal = transformer.Authenticate(string.Empty, cp); Thread.CurrentPrincipal = newPrincipal; HttpContext.User = newPrincipal; } } }
public static IAppBuilder UseClaimsTransformation(this IAppBuilder app, ClaimsAuthenticationManager manager) { return(app.UseClaimsTransformation(new ClaimsTransformationOptions { ClaimsAuthenticationManager = manager })); }
public OwinAuthenticationService( UserAccountService svc, IDictionary <string, object> environment, ClaimsAuthenticationManager transformer ) : base(svc, transformer) { context = new OwinContext(environment); }
public OwinAuthenticationService( string authenticationType, UserAccountService svc, IDictionary <string, object> env, ClaimsAuthenticationManager transformer ) : base(svc, transformer) { this.authenticationType = authenticationType; context = new OwinContext(env); }
protected void LoadConfiguration(IdentityConfigurationElement element) { if (element == null) { return; } if (element.ClaimsAuthenticationManager.Type != null) { claimsAuthenticationManager = (ClaimsAuthenticationManager)Activator.CreateInstance( element.ClaimsAuthenticationManager.Type); } name = element.Name; serviceHandlerConfiguration = LoadHandlerConfiguration(element); }
public ActionResult Login(LoginModel model, string returnUrl) { if (ModelState.IsValid) { List <Claim> initialClaims = new List <Claim>(); initialClaims.Add(new Claim(ClaimTypes.Name, model.UserName)); ClaimsPrincipal claimsPrincipal = new ClaimsPrincipal(new ClaimsIdentity(initialClaims, "Forms")); ClaimsAuthenticationManager authManager = FederatedAuthentication.FederationConfiguration.IdentityConfiguration.ClaimsAuthenticationManager; authManager.Authenticate(string.Empty, claimsPrincipal); return(RedirectToLocal(returnUrl)); } // If we got this far, something failed, redisplay form ModelState.AddModelError("", "The user name or password provided is incorrect."); return(View(model)); }
public virtual void OnPostAuthenticateRequest(object sender, EventArgs args) { // TODO add the claimsPrincipal creation logic here var principal = HttpContext.Current.User as IClaimsPrincipal; if (principal == null) { principal = ClaimsPrincipal.CreateFromHttpContext(HttpContext.Current); ClaimsAuthenticationManager authenticationManager = ServiceConfiguration.ClaimsAuthenticationManager; if (authenticationManager != null && principal != null && principal.Identity != null) { principal = authenticationManager.Authenticate(HttpContext.Current.Request.Url.AbsoluteUri, principal); } HttpContext.Current.User = principal; Thread.CurrentPrincipal = principal; } }
/// <summary> /// Event handler for Application.PostAuthenticateRequest. Runs any <see cref="ClaimsAuthenticationManager"/> if one is configured. /// Tries to create a <see cref="ClaimsPrincipal"/> if none is already set. /// </summary> /// <param name="sender">Sender of this event.</param> /// <param name="args">Event arguments.</param> void OnPostAuthenticateRequest(object sender, EventArgs args) { IClaimsPrincipal icp = HttpContext.Current.User as IClaimsPrincipal; if (icp == null) { icp = ClaimsPrincipal.CreateFromHttpContext(HttpContext.Current); // // Run the Claims Authentication Manager if one is configured // ClaimsAuthenticationManager authenticationManager = ServiceConfiguration.ClaimsAuthenticationManager; if (authenticationManager != null && icp != null && icp.Identity != null) { icp = authenticationManager.Authenticate(HttpContext.Current.Request.Url.AbsoluteUri, icp); } SetPrincipal(icp); } }
public AuthenticationWrapper(UserAccountService <DAL.Entities.UserAccount> userService, ClaimsAuthenticationManager claimsAuthenticationManager) : base(userService, claimsAuthenticationManager) { }
public AuthenticationService(UserAccountService <TAccount> userService, ClaimsAuthenticationManager claimsAuthenticationManager) { this.UserAccountService = userService; this.ClaimsAuthenticationManager = claimsAuthenticationManager; }
public ClaimsTransformationHandler(ClaimsAuthenticationManager transformer, HttpConfiguration configuration) { _transfomer = transformer; InnerHandler = new HttpControllerDispatcher(configuration); }
/// <summary> /// Initializes a new instance of the <see cref="SharedKeyValidatingHandler" /> class. /// </summary> /// <param name="sharedSecretResolver">A function to resolve an account name to a shared secret.</param> /// <param name="maximumMessageAge">The maximum time period a message is considered valid for.</param> /// <param name="claimsAuthenticationManager">The claims authentication manager to use to transform claims.</param> public SharedKeyValidatingHandler(Func <string, byte[]> sharedSecretResolver, TimeSpan maximumMessageAge, ClaimsAuthenticationManager claimsAuthenticationManager) : this(sharedSecretResolver, maximumMessageAge) { this.ClaimsAuthenticationManager = claimsAuthenticationManager; }
public ClaimsTransformationHandler(ClaimsAuthenticationManager transformer, HttpConfiguration configuration) { _transfomer = transformer; InnerHandler = new HttpControllerDispatcher(configuration); }
public MongoAuthenticationService(DefaultUserAccountServiceContainer container, ClaimsAuthenticationManager claimsAuthenticationManager, IHttpContextAccessor ctxAccessor) : base(container.Service, claimsAuthenticationManager) { _context = ctxAccessor.HttpContext; }
/// <summary> /// Create a Claims Principal and a Federated Authentication Session for the authenticated user. /// </summary> /// <param name="lifetime">The period from the current time during which the token is valid. Default use the security token valid to time.</param> /// <param name="isReferenceMode">In reference mode, a simple artifact is produced during serialization and the token material is stored in the token cache that is associated with the token handler. The token cache is an instance of a class that derives from SessionSecurityTokenCache. For Web Farm scenarios, the token cache must operate across all nodes in the farm.</param> /// <param name="isPersistent">If the IsPersistent property is true, the cookie is written as a persistent cookie. Persistent cookies remain valid after the browser is closed until they expire.</param> /// <param name="claimsAuthenticationManager">Possible to add a custom ClaimsAuthenticationManager for handling claims transformation.</param> public static ClaimsPrincipal CreateSession(this Saml2AuthnResponse saml2AuthnResponse, TimeSpan?lifetime = null, bool isReferenceMode = false, bool isPersistent = false, ClaimsAuthenticationManager claimsAuthenticationManager = null) { if (Thread.CurrentPrincipal.Identity.IsAuthenticated) { throw new InvalidOperationException("There already exist an Authenticated user."); } if (saml2AuthnResponse.Status != Saml2StatusCodes.Success) { throw new InvalidOperationException($"The SAML2 Response Status is not Success, the Response Status is: {saml2AuthnResponse.Status}."); } var principal = new ClaimsPrincipal(saml2AuthnResponse.ClaimsIdentity); if (principal.Identity == null || !principal.Identity.IsAuthenticated) { throw new InvalidOperationException("No Claims Identity created from SAML2 Response."); } var transformedPrincipal = claimsAuthenticationManager != null?claimsAuthenticationManager.Authenticate(null, principal) : principal; var sessionSecurityToken = lifetime.HasValue ? new SessionSecurityToken(transformedPrincipal, lifetime.Value) : new SessionSecurityToken(transformedPrincipal, null, saml2AuthnResponse.Saml2SecurityToken.ValidFrom, saml2AuthnResponse.Saml2SecurityToken.ValidTo); sessionSecurityToken.IsReferenceMode = isReferenceMode; sessionSecurityToken.IsPersistent = isPersistent; FederatedAuthentication.SessionAuthenticationModule.AuthenticateSessionSecurityToken(sessionSecurityToken, true); return(transformedPrincipal); }
public AspNetAuthenticationService(UserAccountService <ApplicationUser> userService, ClaimsAuthenticationManager claimsAuthenticationManager, HttpContext context) : this(MembershipRebootApplicationConstants.AuthenticationType, userService, claimsAuthenticationManager, context) { }
public ClaimsTransformationHandler(ClaimsAuthenticationManager transformer) { _transfomer = transformer; }
public ClaimsTransformationHandler() { _transfomer = FederatedAuthentication.ServiceConfiguration.ClaimsAuthenticationManager; }
public AspNetAuthenticationService(string authenticationScheme, UserAccountService <ApplicationUser> userService, ClaimsAuthenticationManager claimsAuthenticationManager, HttpContext context) : base(userService, claimsAuthenticationManager) { _authenticationScheme = authenticationScheme; _context = context; }
protected AuthenticationService(IUserAccountService userService, ClaimsAuthenticationManager claimsAuthenticationManager) { UserAccountService = userService; ClaimsAuthenticationManager = claimsAuthenticationManager; }
public AuthenticationWrapper(BrockAllen.MembershipReboot.UserAccountService <UserAccount> userService, ClaimsAuthenticationManager claimsAuthenticationManager) : base(userService, claimsAuthenticationManager) { }