Comment mettre en œuvre JWT Actualiser les Jetons de asp.net de base de l'api web (pas de 3ème partie)?

Je suis dans le processus de mise en œuvre d'une api web à l'aide de asp.net de base c'est à l'aide de JWT. Je ne suis pas à l'aide d'un tiers solution comme IdentityServer4 que je suis en train d'apprendre.

J'ai obtenu la JWT configuration fonctionne, mais je suis perplexe sur la façon de mettre en œuvre l'actualisation des jetons pour quand le JWT la date d'expiration.

Ci-dessous est un exemple de code dans ma méthode Configure () à l'intérieur de démarrage.cs.

app.UseJwtBearerAuthentication(new JwtBearerOptions()
{
    AuthenticationScheme = "Jwt",
    AutomaticAuthenticate = true,
    AutomaticChallenge = true,
    TokenValidationParameters = new TokenValidationParameters()
    {
        ValidAudience = Configuration["Tokens:Audience"],
        ValidIssuer = Configuration["Tokens:Issuer"],
        ValidateIssuerSigningKey = true,
        IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Configuration["Tokens:Key"])),
        ValidateLifetime = true,
        ClockSkew = TimeSpan.Zero
    }
});

Ci-dessous est la méthode de Contrôleur utilisé pour générer le JWT. J'ai mis de l'expiration de 30 secondes pour des fins de test.

    [Route("Token")]
    [HttpPost]
    public async Task<IActionResult> CreateToken([FromBody] CredentialViewModel model)
    {
        try
        {
            var user = await _userManager.FindByNameAsync(model.Username);

            if (user != null)
            {
                if (_hasher.VerifyHashedPassword(user, user.PasswordHash, model.Password) == PasswordVerificationResult.Success)
                {
                    var userClaims = await _userManager.GetClaimsAsync(user);

                    var claims = new[]
                    {
                        new Claim(JwtRegisteredClaimNames.Sub, user.UserName),
                        new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString())
                    }.Union(userClaims);

                    var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_jwt.Key));
                    var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);

                    var token = new JwtSecurityToken(
                            issuer: _jwt.Issuer,
                            audience: _jwt.Audience,
                            claims: claims,
                            expires: DateTime.UtcNow.AddSeconds(30),
                            signingCredentials: creds
                        );

                    return Ok(new
                    {
                        access_token = new JwtSecurityTokenHandler().WriteToken(token),
                        expiration = token.ValidTo
                    });
                }
            }
        }
        catch (Exception)
        {

        }

        return BadRequest("Failed to generate token.");
    }

Serais très reconnaissant pour quelques conseils.

Le code que vous avez posté n'est pertinente que pour l'authentification des jetons d'accès, pas d'actualisation des jetons. Pouvez-vous partager le code où vous générer des jetons d'accès?
Bien sûr, j'ai ajouté le code utilisé pour générer le JWT.

OriginalL'auteur DJDJ | 2017-04-18

  1. 13

    Tout d'abord, vous devez générer un jeton d'actualisation et de persister quelque part. C'est parce que vous voulez être en mesure d'invalider si nécessaire. Si vous étiez à suivre le même schéma qu'un jeton d'accès - où toutes les données sont contenues dans le jeton d'un jeton qui se termine dans les mains de personnes peuvent l'être utilisé pour générer de nouveaux jetons d'accès pour la durée de vie du jeton d'actualisation, qui peut être un temps très long.

    Donc, ce que le diable avez-vous besoin de persister?
    Vous avez besoin d'un identifiant unique de quelques sortes ce n'est pas facile à deviner, un GUID fera l'amende juste. Vous avez également besoin de données pour être en mesure de délivrer un nouveau jeton d'accès, très probablement un nom d'utilisateur. Avoir un nom d'utilisateur vous pouvez donc ignorer la VerifyHashedPassword(...)-partie, mais pour le reste, il suffit de suivre la même logique.

    Pour obtenir un jeton d'actualisation, vous devez normalement utiliser le champ "offline_access", ce que vous fournissez dans votre modèle (CredentialViewModel) lorsqu'une demande de jeton. À la différence d'un accès normal de demande de jeton, maintenant, vous n'avez pas besoin de fournir votre nom d'utilisateur et le mot de passe, mais au lieu de l'actualisation à jeton. Lors de l'obtention d'une demande avec un jeton d'actualisation, vous la recherche de l'persisté identifiant et d'émettre un jeton de l'utilisateur trouvé.

    Suivant est le pseudo-code, pour le plaisir du chemin:

    [Route("Token")]
[HttpPost]
public async Task<IActionResult> CreateToken([FromBody] CredentialViewModel model)
{
    if (model.GrantType is "refresh_token")
    {
        //Lookup which user is tied to model.RefreshToken
        //Generate access token from the username (no password check required)
        //Return the token (access + expiration)
    }
    else if (model.GrantType is "password")
    {
        if (model.Scopes contains "offline_access")
        {
            //Generate access token
            //Generate refresh token (random GUID + model.username)
            //Persist refresh token
            //Return the complete token (access + refresh + expiration)
        }
        else
        {
            //Generate access token
            //Return the token (access + expiration)
        }
    }
}
    Je vous remercie pour votre participation!

    OriginalL'auteur naslund