Combiner l'utilisation de l'authentification à la fois pour les pages MVC et pour les pages API Web?

la meilleure façon d'y parvenir, est d'avoir un serveur d'autorisation (une API Web générant un token) et une consommation de token middle-ware dans votre projet MVC. IdentityServer devrait aider. Toutefois, j'ai fait comme ceci:

j'ai construit un serveur d'autorisation en utilisant JWT avec L'API Web et ASP.Net identité telle qu'expliquée ici.

une fois que vous avez fait cela, votre API Web startup.cs ressemblera à ceci:

 // Configures cookie auth for web apps and JWT for SPA,Mobile apps
 private void ConfigureOAuthTokenGeneration(IAppBuilder app)
 {
    // Configure the db context, user manager and role manager to use a single instance per request
    app.CreatePerOwinContext(ApplicationDbContext.Create);
    app.CreatePerOwinContext<ApplicationUserManager>(ApplicationUserManager.Create);
    app.CreatePerOwinContext<ApplicationRoleManager>(ApplicationRoleManager.Create);

    // Cookie for old school MVC application
    var cookieOptions = new CookieAuthenticationOptions
    {
        AuthenticationMode = AuthenticationMode.Active,
        CookieHttpOnly = true, // JavaScript should use the Bearer
        AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,                
        LoginPath = new PathString("/api/Account/Login"),
        CookieName = "AuthCookie"
    };
    // Plugin the OAuth bearer JSON Web Token tokens generation and Consumption will be here
    app.UseCookieAuthentication(cookieOptions);

    OAuthServerOptions = new OAuthAuthorizationServerOptions()
    {
        //For Dev enviroment only (on production should be AllowInsecureHttp = false)
        AllowInsecureHttp = true,
        TokenEndpointPath = new PathString("/oauth/token"),
        AccessTokenExpireTimeSpan = TimeSpan.FromDays(30),
        Provider = new CustomOAuthProvider(),                
        AccessTokenFormat = new CustomJwtFormat(ConfigurationManager.AppSettings["JWTPath"])
    };

    // OAuth 2.0 Bearer Access Token Generation
    app.UseOAuthAuthorizationServer(OAuthServerOptions);
}

vous pouvez trouver le CustomOAuthProvider et CustomJwtFormat classes ici.

j'ai écrit une logique de consommation (middleware) dans tous mes autres API (serveurs de ressources) que je voulais sécuriser en utilisant le même token. Puisque vous voulez consommer le token généré par L'API Web dans votre projet MVC, après avoir implémenté le serveur d'autorisation, vous devez:

dans votre application MVC, ajoutez ceci dans startup.cs:

public void Configuration(IAppBuilder app)
{
        ConfigureOAuthTokenConsumption(app);
}

private void ConfigureOAuthTokenConsumption(IAppBuilder app)
{
    var issuer = ConfigurationManager.AppSettings["AuthIssuer"];
    string audienceid = ConfigurationManager.AppSettings["AudienceId"];
    byte[] audiencesecret = TextEncodings.Base64Url.Decode(ConfigurationManager.AppSettings["AudienceSecret"]);

    app.UseCookieAuthentication(new CookieAuthenticationOptions { CookieName = "AuthCookie" , AuthenticationType=DefaultAuthenticationTypes.ApplicationCookie });

    //// Api controllers with an [Authorize] attribute will be validated with JWT
    app.UseJwtBearerAuthentication(
        new JwtBearerAuthenticationOptions
        {
            AuthenticationMode = AuthenticationMode.Passive,
            AuthenticationType = "JWT",
            AllowedAudiences = new[] { audienceid },
            IssuerSecurityTokenProviders = new IIssuerSecurityTokenProvider[]
            {
                new SymmetricKeyIssuerSecurityTokenProvider(issuer, audiencesecret)                           
            }

        });
}

dans votre contrôleur MVC, lorsque vous recevez le token, désérialisez - le et générez un cookie à partir du token d'accès:

AccessClaims claimsToken = new AccessClaims();
claimsToken = JsonConvert.DeserializeObject<AccessClaims>(response.Content);
claimsToken.Cookie = response.Cookies[0].Value;               
Request.Headers.Add("Authorization", "bearer " + claimsToken.access_token);
var ctx = Request.GetOwinContext();
var authenticateResult = await ctx.Authentication.AuthenticateAsync("JWT");
ctx.Authentication.SignOut("JWT");
var applicationCookieIdentity = new ClaimsIdentity(authenticateResult.Identity.Claims, DefaultAuthenticationTypes.ApplicationCookie);
ctx.Authentication.SignIn(applicationCookieIdentity);

générer une touche machine et l'ajouter dans web.config de votre API Web et ASP.Net site MVC.

avec ceci, un cookie sera créé et le [Authorize] attribut dans le site MVC et L'API Web honorera ce cookie.

P.S. j'ai fait cela avec une API Web émettant JWT (Authorization server ou Auth & resource server) et j'ai pu le consommer dans un ASP.Net site Web de MVC, Site SPA Construit en Angular, APIs sécurisé construit en python (resource server), Le printemps (resource server) et une application Android.