web-dev-qa-db-fra.com

Validation personnalisée du jeton de support ASP.NET Core JWT

Après de nombreuses lectures, j'ai trouvé un moyen d'implémenter un validateur de jeton support JWT personnalisé comme indiqué ci-dessous. 

Starup.cs Codes:

public void Configure(IApplicationBuilder app, IHostingEnvironment env, 
         ILoggerFactory loggerFactory, IApplicationLifetime appLifetime)
{
    loggerFactory.AddConsole(Configuration.GetSection("Logging"));
    loggerFactory.AddDebug();

    app.UseStaticFiles();

    app.UseIdentity();

    ConfigureAuth(app);

    app.UseMvcWithDefaultRoute();            
}

private void ConfigureAuth(IApplicationBuilder app)
    {

        var signingKey = new SymmetricSecurityKey(Encoding.ASCII.GetBytes(Configuration.GetSection("TokenAuthentication:SecretKey").Value));


        var tokenValidationParameters = new TokenValidationParameters
        {
            // The signing key must match!
            ValidateIssuerSigningKey = true,
            IssuerSigningKey = signingKey,
            // Validate the JWT Issuer (iss) claim
            ValidateIssuer = true,
            ValidIssuer = Configuration.GetSection("TokenAuthentication:Issuer").Value,
            // Validate the JWT Audience (aud) claim
            ValidateAudience = true,
            ValidAudience = Configuration.GetSection("TokenAuthentication:Audience").Value,
            // Validate the token expiry
            ValidateLifetime = true,
            // If you want to allow a certain amount of clock drift, set that here:
            ClockSkew = TimeSpan.Zero
        };

        var jwtBearerOptions = new JwtBearerOptions();
        jwtBearerOptions.AutomaticAuthenticate = true;
        jwtBearerOptions.AutomaticChallenge = true;
        jwtBearerOptions.TokenValidationParameters = tokenValidationParameters;
        jwtBearerOptions.SecurityTokenValidators.Clear();
        //below line adds the custom validator class
        jwtBearerOptions.SecurityTokenValidators.Add(new CustomJwtSecurityTokenHandler());
        app.UseJwtBearerAuthentication(jwtBearerOptions);

        var tokenProviderOptions = new TokenProviderOptions
        {
            Path = Configuration.GetSection("TokenAuthentication:TokenPath").Value,
            Audience = Configuration.GetSection("TokenAuthentication:Audience").Value,
            Issuer = Configuration.GetSection("TokenAuthentication:Issuer").Value,
            SigningCredentials = new SigningCredentials(signingKey, SecurityAlgorithms.HmacSha256)
        };

        app.UseMiddleware<TokenProviderMiddleware>(Options.Create(tokenProviderOptions));
    }

Vous trouverez ci-dessous la classe de validation personnalisée:

public class CustomJwtSecurityTokenHandler : ISecurityTokenValidator
{
    private int _maxTokenSizeInBytes = TokenValidationParameters.DefaultMaximumTokenSizeInBytes;
    private JwtSecurityTokenHandler _tokenHandler;

    public CustomJwtSecurityTokenHandler()
    {
        _tokenHandler = new JwtSecurityTokenHandler();
    }

    public bool CanValidateToken
    {
        get
        {
            return true;
        }
    }

    public int MaximumTokenSizeInBytes
    {
        get
        {
            return _maxTokenSizeInBytes;
        }

        set
        {
            _maxTokenSizeInBytes = value;
        }
    }

    public bool CanReadToken(string securityToken)
    {
        return _tokenHandler.CanReadToken(securityToken);            
    }

    public ClaimsPrincipal ValidateToken(string securityToken, TokenValidationParameters validationParameters, out SecurityToken validatedToken)
    {
        //How to access HttpContext/IP address from here?

        var principal = _tokenHandler.ValidateToken(securityToken, validationParameters, out validatedToken);

        return principal;
    }
}

En cas de jeton volé, j'aimerais ajouter une couche de sécurité supplémentaire pour valider que la demande provient du même client qui a généré le jeton. 

Des questions:

  1. Existe-t-il un moyen d’accéder à HttpContext au sein de la classe CustomJwtSecurityTokenHandler pour pouvoir ajouter des validations personnalisées en fonction du client/demandeur actuel?
  2. Existe-t-il un autre moyen de valider l'authenticité du demandeur en utilisant une telle méthode/middleware?
c#asp.netasp.net-corejwtasp.net-core-middleware
7
Sang Suantak

Dans ASP.NET Core, HttpContext pourrait être obtenu à l'aide du service IHttpContextAccessor. Utilisez DI pour passer une instance IHttpContextAccessor dans votre gestionnaire et obtenez la valeur de la propriété IHttpContextAccessor.HttpContext. 

Le service IHttpContextAccessor n'est pas enregistré par defaul, vous devez donc d'abord ajouter ce qui suit dans votre méthode Startup.ConfigureServices:

services.TryAddSingleton<IHttpContextAccessor, HttpContextAccessor>();

puis modifiez votre classe CustomJwtSecurityTokenHandler:

private readonly IHttpContextAccessor _httpContextAccessor;

public CustomJwtSecurityTokenHandler(IHttpContextAccessor httpContextAccessor)
{
    _httpContextAccessor = httpContextAccessor;
    _tokenHandler = new JwtSecurityTokenHandler();
}

... 

public ClaimsPrincipal ValidateToken(string securityToken, TokenValidationParameters validationParameters, out SecurityToken validatedToken)
{
    var httpContext = _httpContextAccessor.HttpContext;
}

Vous devez également utiliser la technique DI pour l’instanciation JwtSecurityTokenHandler. Regardez dans Dependency Injection documentation si vous êtes novice dans ce domaine.

Mise à jour: comment résoudre manuellement les dépendances (plus d'infos ici )

modifier la méthode Configure pour utiliser IServiceProvider serviceProvider:

public void Configure(IApplicationBuilder app, IHostingEnvironment env, 
         ILoggerFactory loggerFactory, IApplicationLifetime appLifetime,
         IServiceProvider serviceProvider)
{
    ...
    var httpContextAccessor = serviceProvider.GetService<IHttpContextAccessor>();
    // and extend ConfigureAuth
    ConfigureAuth(app, httpContextAccessor);
    ...
}
4
Set

Pour le validateur JWT personnalisé, j'ai créé une classe JWTCosumerProvider héritée de IOAuthBearerAuthenticationProvider. Et implémentez la méthode ValidateIdentity () pour vérifier l’identité Revendication dans laquelle j’ai stocké l’adresse IP du client en premier lieu, puis la comparer à l’adresse d’identification de la demande actuelle après celle-ci.

public Task ValidateIdentity(OAuthValidateIdentityContext context)
    {

        var requestIPAddress = context.Ticket.Identity.FindFirst(ClaimTypes.Dns)?.Value;

        if (requestIPAddress == null)
            context.SetError("Token Invalid", "The IP Address not right");

        string clientAddress = JWTHelper.GetClientIPAddress();
        if (!requestIPAddress.Equals(clientAddress))
            context.SetError("Token Invalid", "The IP Address not right");


        return Task.FromResult<object>(null);
    }

JWTHelper.GetClientIPAddress ()

internal static string GetClientIPAddress()
    {
        System.Web.HttpContext context = System.Web.HttpContext.Current;
        string ipAddress = context.Request.ServerVariables["HTTP_X_FORWARDED_FOR"];

        if (!string.IsNullOrEmpty(ipAddress))
        {
            string[] addresses = ipAddress.Split(',');
            if (addresses.Length != 0)
            {
                return addresses[0];
            }
        }

        return context.Request.ServerVariables["REMOTE_ADDR"];
    }

espérons cette aide!

0
Patrick

N'ayant pu trouver de réponse nulle part, j'ai déplacé la logique de validation relative à HttpContext à une ActionFilter.

Cependant, la solution est dispersée.

0
Sang Suantak