Autorisieren eines Benutzers je nach den Namen der Aktion

Hier ist der Allgemeine Prozess für die Durchsetzung benutzerdefinierte Authentifizierung. Ihre situation kann in der Lage sein, um vollständig gelöst in Schritt eins, da könnte man hinzufügen, ein Anspruch für die Rolle, schmückt Ihr

1. authentifizieren durch die Schaffung einer Identität für den Benutzer

Schreiben middleware und einfügen in die pipeline über IApplicationBuilder.UseMiddleware<> ist, wie benutzerdefinierte Authentifizierung erfolgt. Dies ist, wo wir extrahieren was Informationen können später erforderlich, für die Genehmigung, und legen Sie es in eine ClaimsIdentity. Wir haben eine HttpContext hier, so dass wir ergreifen können, Infos aus dem header, cookies, angeforderte Pfad, etc. Hier ist ein Beispiel:

public class MyAuthHandler : AuthenticationHandler<MyAuthOptions>
{
   protected override Task<AuthenticationTicket> HandleAuthenticateAsync()
   {
      //grab stuff from the HttpContext
      string authHeader = Request.Headers["Authorization"] ?? "";
      string path = Request.Path.ToString() ?? "";

      //make a MyAuth identity with claims specifying what we'll validate against
      var identity = new ClaimsIdentity(new[] {
         new Claim(ClaimTypes.Authentication, authHeader),
         new Claim(ClaimTypes.Uri, path)
      }, Options.AuthenticationScheme);

      var ticket = new AuthenticationTicket(new ClaimsPrincipal(identity), 
         new AuthenticationProperties(), Options.AuthenticationScheme);
      return Task.FromResult(ticket);
   }
}

public class MyAuthOptions : AuthenticationOptions
{
   public const string Scheme = "MyAuth";
   public MyAuthOptions()
   {
      AuthenticationScheme = Scheme;
      AutomaticAuthentication = true;
   }
}

public class MyAuthMiddleware : AuthenticationMiddleware<MyAuthOptions>
{
   public MyAuthMiddleware(
               RequestDelegate next,
               IDataProtectionProvider dataProtectionProvider,
               ILoggerFactory loggerFactory,
               IUrlEncoder urlEncoder,
               IOptions<MyAuthOptions> options,
               ConfigureOptions<MyAuthOptions> configureOptions)
         : base(next, options, loggerFactory, urlEncoder, configureOptions)
   {
   }

   protected override AuthenticationHandler<MyAuthOptions> CreateHandler()
   {
      return new MyAuthHandler();
   }
}

public static class MyAuthMiddlewareAppBuilderExtensions
{
   public static IApplicationBuilder UseMyAuthAuthentication(this IApplicationBuilder app, string optionsName = "")
   {
      return app.UseMiddleware<MyAuthMiddleware>(
         new ConfigureOptions<MyAuthOptions>(o => new MyAuthOptions()) { Name = optionsName });
   }
}

Nutzen diese middleware fügen Sie diese in Startup.Configure vor dem routing: app.UseMyAuthAuthentication();

2. autorisieren durch das erzwingen von Anforderungen an die Identität

Erstellten wir eine Identität für den Benutzer, aber wir müssen noch durchgesetzt werden. Um dies zu tun müssen wir schreiben eine AuthorizationHandler wie diese:

  public class MyAuthRequirement : AuthorizationHandler<MyAuthRequirement>, IAuthorizationRequirement
  {
     public override void Handle(AuthorizationContext context, MyAuthRequirement requirement)
     {
        //grab the identity for the MyAuth authentication
        var myAuthIdentities = context.User.Identities
           .Where(x => x.AuthenticationType == MyAuthOptions.Scheme).FirstOrDefault();
        if (myAuthIdentities == null)
        {
           context.Fail();
           return;
        }

        //grab the authentication header and uri types for our identity
        var authHeaderClaim = myAuthIdentities.Claims.Where(x => x.Type == ClaimTypes.Authentication).FirstOrDefault();
        var uriClaim = context.User.Claims.Where(x => x.Type == ClaimTypes.Uri).FirstOrDefault();
        if (uriClaim == null || authHeaderClaim == null)
        {
           context.Fail();
           return;
        }

        //enforce our requirement (evaluate values from the identity/claims)
        if ( /* passes our enforcement test */ )
        {
           context.Succeed(requirement);
        }
        else
        {
           context.Fail();
        }
     }
  }

3. fügen Sie die Anforderung handler als Berechtigungs-policy

Unsere Anforderung Authentifizierung muss noch Hinzugefügt werden, um die Startup.ConfigureServices so dass es verwendet werden kann:

//add our policy to the authorization configuration
services.ConfigureAuthorization(auth =>
{
   auth.AddPolicy(MyAuthOptions.Scheme, 
      policy => policy.Requirements.Add(new MyAuthRequirement()));
});

4. verwenden Sie die Autorisierungsrichtlinie

Der Letzte Schritt ist die Durchsetzung dieser Forderung für bestimmte Aktionen, die durch die Dekoration unserer Aktion oder controller mit [Authorize("MyAuth")]. Wenn wir haben viele Controller, die jeweils mit vielen Maßnahmen, die erforderlich Durchsetzung, dann werden wir das machen wollen, eine Basis-Klasse und nur schmücken Sie, dass einzelne controller.

Ihre einfachere situation:

Jede Aktion hat eine eigene Rolle ( Role name = ControllerName.actionName> )

Wenn Sie bereits alle Ihre Aktionen, fein abgestimmt mit [Authorize(Roles = "controllername.actionname")] dann müssen Sie vermutlich nur Teil #1 oben. Fügen Sie einfach einen neuen Claim(ClaimTypes.Role, "controllername.actionname") gültig ist, für die jeweilige Anfrage.