web-dev-qa-db-fra.com

Comment utiliser JWT dans l'application MVC pour l'authentification et l'autorisation?

J'avais prévu d'utiliser ASP.NET Identity 2.0 dans une application ASP.NET MVC pour l'authentification et l'autorisation.

Référer le lien ci-dessous

jeton Web JSON dans l’API Web ASP.NET 2 avec Owin

J'ai pu créer un jeton d'accès (JWT) pour l'utilisateur valide, c.-à-d. Lorsque l'utilisateur se connecte à l'application, je vais valider l'utilisateur avec le nom et le mot de passe, puis émettre un jeton Web JSON pour cet utilisateur valide.

J'ai lu dans certains articles que nous devons passer le jeton porteur dans les en-têtes pour chaque demande de validation de l'utilisateur pour l'authentification. Dans MVC, nous fournirons l'attribut Authorize pour les méthodes à protéger, comme indiqué ci-dessous…

      public class UserController : BaseHRAppController
      {
            [Authorize]
            public ActionResult Index()
            {          
               return View();
            }
       }

Comment dire à mon application MVC d'utiliser JWT pour valider l'utilisateur?

Je souhaite que mon application MVC valide l'utilisateur à l'aide de JWT chaque fois qu'il tente d'accéder à la méthode avec l'attribut authorize. Depuis que je vais utiliser AJAX appels dans de nombreuses pages pour accéder à la méthode présente dans le contrôleur MVC, je ne pense pas qu'il soit bon de passer un jeton à chaque AJAX J'ai besoin d'aide pour accomplir l'authentification et l'autorisation de manière efficace en utilisant ASP.NET Identity dans une application MVC.

Actuellement, je ne sais pas comment utiliser ce jeton JWT pour l'authentification et l'autorisation dans une application MVC.

c#asp.net-mvc-4authenticationauthorizationasp.net-identity
37
SDK

Pour que MVC puisse comprendre quoi que ce soit à propos de votre JWT, vous devez essentiellement le dire :-). Commencez par installer le paquet Jwt à partir de nuget:

Install-Package Microsoft.Owin.Security.Jwt

Ouvrez ensuite votre fichier Startup.cs et ajoutez une nouvelle fonction qui indiquera à MVC comment utiliser JWT. Aux bases, votre démarrage ressemblera à quelque chose comme:

using System.Configuration;
using Microsoft.Owin;
using Microsoft.Owin.Security;
using Microsoft.Owin.Security.DataHandler.Encoder;
using Microsoft.Owin.Security.Jwt;
using Owin;

[Assembly: OwinStartupAttribute(typeof(TOMS.Frontend.Startup))]
namespace TOMS.Frontend
{
    public partial class Startup
    {
        public void Configuration(IAppBuilder app)
        {
            ConfigureAuth(app);
            ConfigureOAuthTokenConsumption(app);
        }

        private void ConfigureOAuthTokenConsumption(IAppBuilder app)
        {
            var issuer = ConfigurationManager.AppSettings["Issuer"];
            var audienceId = ConfigurationManager.AppSettings["AudienceId"];
            var audienceSecret = TextEncodings.Base64Url.Decode(ConfigurationManager.AppSettings["AudienceSecret"]);

            // Api controllers with an [Authorize] attribute will be validated with JWT
            app.UseJwtBearerAuthentication(new JwtBearerAuthenticationOptions
            {
                AuthenticationMode = AuthenticationMode.Active,
                AllowedAudiences = new[] { audienceId },
                IssuerSecurityTokenProviders = new IIssuerSecurityTokenProvider[]
                {
                    new SymmetricKeyIssuerSecurityTokenProvider(issuer, audienceSecret) 
                }
            });
        }
    }
}

Vous remarquerez que je place l'émetteur, audienceId et audienceSecret dans mon fichier Web.config. (Ces valeurs doivent correspondre à celles de votre serveur de ressources). Aussi, vous voudrez peut-être vous assurer d'avoir un System.IdentityModel.Tokens.Jwt en cours d'exécution:

Update-package System.IdentityModel.Tokens.Jwt

Avec ceux-ci définis, vous pouvez décorer votre action de contrôleur avec l'attribut [Autoriser] et jouer au ballon.

Jouer à la balle signifie bien sûr que votre requête javascript sera renvoyée à l'action de votre contrôleur protégé:

//assuming you placed the token in a sessionStorage variable called tokenKey when it came back from your Authorization Server
    var token = sessionStorage.getItem(tokenKey);
    var headers = {};
    if (token) {
        headers.Authorization = 'Bearer ' + token;
    }

    $.ajax({
        type: 'GET',
        url: 'CONTROLLER/ACTION',
        headers: headers
    }).done(function (data) {
        self.result(data);
    }).fail(showError);

UPDATE À propos, si vous souhaitez ajouter les valeurs dans votre fichier web.config afin de les récupérer comme je l'ai fait ci-dessus; ajoutez-les simplement sous les AppSettings:

<configuration>
 <appSettings>
    <add key="Issuer" value="YOUR_ISSUER" />
    <add key="AudienceId" value="YOUR_AUDIENCEID" />
    <add key="AudienceSecret" value="YOUR_AUDIENCESECRET" />
 </appSettings>
</configuration>

... bien sûr, remplacer les "valeurs" par les vôtres

43
Houdini Sutherland

Je ne sais pas si vous avez résolu le problème, mais j'avais un problème similaire et j'ai décidé de stocker le jeton à l'aide de FormsAuthentication, ce qui m'a permis de chiffrer le jeton. À chaque demande, le cookie a été renvoyé, puis décrypté. récupérez le fichier JWT, puis extrayez les rôles/revendications, puis utilisez-les pour créer un identité principal qui me permettrait de décorer mes méthodes de contrôleur avec [Authorize (Role = "blah, blah")].

Voici un exemple de code ci-dessous.

Une fois que vous avez récupéré le jeton Web JSON de l’API après la connexion, vous pouvez utiliser quelque chose comme:

var returnedToken = (TokenResponse)result.ReturnedObject;
var ticket = new FormsAuthenticationTicket(1, model.Email, DateTime.Now, ConvertUnitToDateTime(returnedToken.expires_in), true, returnedToken.access_token);
string encryptedTicket = FormsAuthentication.Encrypt(ticket);
var cookie = new HttpCookie(FormsAuthentication.FormsCookieName, encryptedTicket);
cookie.HttpOnly = true;
Response.Cookies.Add(cookie)

Certaines de mes propres classes et méthodes ont été créées, mais cela vous donnera l’idée générale que vous stockez le jeton d’accès JWT ainsi que la date d’expiration dans votre cookie FormsAuthentication.

Ensuite, le cookie est transmis avec chaque demande et dans votre fichier Global.asax, vous pouvez avoir une méthode pour authentifier la demande:

protected void Application_AuthenticateRequest(Object sender, EventArgs e)
{
    HttpCookie authCookie = Request.Cookies[FormsAuthentication.FormsCookieName];
    if (authCookie != null)
    {
        //Extract the forms authentication cookie
        FormsAuthenticationTicket authTicket = FormsAuthentication.Decrypt(authCookie.Value);

        JwtSecurityToken jwTok = TokenHelper.GetJWTokenFromCookie(authCookie); 

        // Create the IIdentity instance
        IIdentity id = new FormsIdentity(authTicket);

        // Create the IPrinciple instance
        IPrincipal principal = new GenericPrincipal(id, TokenHelper.GetRolesFromToken(jwTok).ToArray());

        // Set the context user
        Context.User = principal;
    }
}

Ainsi, cette méthode permet de déchiffrer le cookie afin d’obtenir le jeton d’accès JWT que vous pouvez ensuite décoder à l’aide de la bibliothèque System.IdentityModel.Tokens.Jwt de Microsoft, puis utiliser ces rôles et cet ID pour générer le principal et l’identité de l’utilisateur qui crée votre identité. utilisateur avec les rôles.

Ensuite, ces rôles peuvent être validés par rapport à l'attribut [Autoriser].

11
reverence12389