A maneira correta de implementar a autenticação JWT no ASP.NET Core 6

O ASP.NET Core 6 apresenta um modelo simplificado de hospedagem na Internet que nos permite construir APIs leves com dependências mínimas. Naturalmente, você normalmente deve proteger os endpoints de tais APIs em suas funções. O objetivo deste envio é fornecer a você uma vantagem inicial sobre como fazê-lo.

Mencionamos dicas sobre como começar com APIs mínimas , dicas sobre como usar log e injeção de dependência em APIs mínimas e dicas sobre como verificar APIs mínimas em artigos anteriores. Este texto discute como protegeremos nossos endpoints de API mínimos utilizando autenticação JWT, ou seja, autenticação baseada principalmente em JSON Net Tokens.

Para proteger uma API mínima utilizando autenticação JWT, vamos observar estas etapas:

1. Crie uma missão de API mínima no Visible Studio 2022.
2. Crie um endpoint de API no arquivo Program.cs.
3. Adicione o pacote Microsoft.AspNetCore.Authentication.JwtBearer NuGet à nossa missão.
4. Implemente a autenticação JWT no arquivo Program.cs.
5. Crie uma classe de modelo de consumidor chamada Pessoa para armazenar as credenciais de login do consumidor.
6. Especifique uma chave secreta no arquivo appsettings.json.
7. Especifique as configurações de autenticação JWT no arquivo Program.cs.
8. Adicione middleware de empresas de autorização ao nosso software no arquivo Program.cs.
9. Crie e valide o JSON Net Token no arquivo Program.cs.

Esteja ciente de que todos os exemplos de código comprovados neste envio, além da classe Person manequim, devem fazer parte de Program.cs. A classe manequim Person deve fazer parte do arquivo Person.cs.

Para trabalhar com os exemplos de código oferecidos neste artigo, você deve instalar o Visible Studio 2022 em seu sistema. Se você ainda não possui uma cópia, poderá obter o Visible Studio 2022 aqui .

Crie uma missão de API de rede mínima do ASP.NET Core 6 no Visible Studio 2022

Primeiro, vamos criar uma missão ASP.NET Core 6 no Visible Studio. Seguir estas etapas criará uma nova missão ASP.NET Core 6 Net API no Visible Studio 2022:

1. Inicie o Visible Studio 2022 IDE.
2. Clique em “Criar nova missão”.
3. Na janela “Criar nova missão”, escolha “ASP.NET Core Net API” na lista de modelos exibidos.
4. Clique em Subsequente.
5. Na janela “Configurar sua nova missão”, especifique o título e o posicionamento da nova missão.
6. Opcionalmente, teste o campo de teste “Coloque a resposta e a missão na lista idêntica”, dependendo de suas preferências.
7. Clique em Subsequente.
8. Na janela “Mais informações” mostrada a seguir, desmarque o campo de teste que diz “Usar controladores…”, pois usaremos APIs mínimas nesta instância. Deixe o “Classificação de Autenticação” como “Nenhum” (padrão).
9. Certifique-se de que os contêineres de teste “Permitir Docker”, “Configurar para HTTPS” e “Permitir assistência API aberta” estejam desmarcados, pois não usaremos nenhuma dessas opções aqui.
10. Clique em Criar.

Usaremos essa missão da API do ASP.NET Core 6 Net para criar um endpoint de API mínimo e implementar a autenticação JWT para ele nas seções subsequentes deste texto.

Crie um ponto de extremidade HTTP Get no ASP.NET Core 6

Enquanto você cria uma nova missão mínima da API da rede no Visible Studio 2022, um arquivo Program.cs deve ser criado com vários vestígios de código padrão. Você pode alterar o código padrão com o próximo trecho de código para facilitar as coisas e ainda fornecer uma maneira de verificar sua API.

var builder = WebApplication.CreateBuilder(args); 
var app = builder.Construct(); 
app.MapGet("/safety/getMessage", 
() => "Hey World!").RequireAuthorization(); 
app.Run();

Esteja ciente do uso da metodologia de extensão RequireAuthorization aqui. Isso ajuda você a proteger suas rotas usando apólices de seguro de autorização e força você a fornecer informações de autenticação ao ligar para este endpoint. O middleware de autorização usará essas informações para validar a solicitação para o contexto de execução atual.

Se você executar este endpoint sem esta informação, você encontrará um erro HTTP 401 Unauthorized, conforme comprovado na Determinação 1.

IDG

Configurar o pacote JwtBearer NuGet

Agora adicione o pacote Microsoft.AspNetCore.Authentication.JwtBearer NuGet à sua missão. Para fazer isso, escolha a missão na janela do Resolution Explorer, clique com o botão direito do mouse e escolha “Handle NuGet Packages”. Na janela NuGet Bundle Supervisor, procure o pacote Microsoft.AspNetCore.Authentication.JwtBearer e configure-o.

Como alternativa, você poderá configurar o pacote por meio do console NuGet Bundle Supervisor entrando no comando comprovado abaixo.

PM> Set up-Bundle Microsoft.AspNetCore.Authentication.JwtBearer

Especifique uma chave secreta no arquivo appsettings.json

Em seguida, crie uma parte no arquivo appsettings.json para as informações do emissor, dos visualizadores e da chave. Esta informação será usada posteriormente para gerar um JSON Net Token. Esteja ciente de que você pode dar qualquer título a esta parte que você precisa; Vou usar o título “Jwt” para conforto. 

Adicione as próximas informações no arquivo appsettings.json.

  "Jwt": { 
    "Issuer": "https://joydipkanjilal.com/", 
    "Viewers": "https://joydipkanjilal.com/", 
    "Key": "É uma chave secreta padrão - por favor, não uso em ambientes de fabricação.'" 
  }

Especifique as configurações de autenticação no arquivo Program.cs

A metodologia AddAuthenication no arquivo Program.cs é usada para configurar a autenticação JWT no momento em que o dispositivo é iniciado. Ele especifica o esquema de autenticação como JwtBearer. Além disso, a decisão pela metodologia AddJwtBearer ajuda a configurar os parâmetros do token.

Os valores Issuer, Viewers e Key são aprendidos no arquivo de configuração appsettings.json. O evento TokenValidationParameters é usado para apontar se as informações do emissor, dos visualizadores, da chave e do tempo de vida devem ser validadas ou não.

Builder.companies.addauthentication ( Choices => { 
Choices.DefaultAuthenticatesCheme     = JWTBearerDefaults.authenticationsCheme 
    ; 
    Choices.DefaultChallengesCheme 
    = JwtBeerDefault.authenticationsCheme     ;         ValidIssuer = builder.Configuration["Jwt:Issuer"],         ValidAudience = builder.Configuration["Jwt:Audience"],         IssuerSigningKey = new SymmetricSecurityKey         (Encoding.UTF8.GetBytes(builder.Configuration["Jwt:Key"])),         ValidateIssuer = verdadeiro,         ValidateAudience = verdadeiro,










        ValidateLifetime = false, 
        ValidateIssuerSigningKey = true 
    }; 
});

Para adicionar empresas de autorização ao seu software, seu Program.cs também precisa incluir o próximo trecho de código.

builder.Companies.AddAuthorization();

Seu Program.cs também precisa adotar as próximas estratégias para permitir recursos de autenticação e autorização.

app.UseAuthentication(); 
app.UseAuthorization();

Crie um manequim de consumidor no ASP.NET Core 6

Vamos precisar de uma categoria para armazenar as credenciais de login do consumidor ou clientes. Crie uma categoria denominada Pessoa em um arquivo com o título idêntico com uma extensão .cs. Em seguida, insira o próximo código.

public class Person 
{ 
    public string UserName { get; definir; } 
    senha public string { get; definir; } 
}

Esta classe deve ser usada apenas para aceitar as credenciais do consumidor como entrada.

Crie um endpoint para gerar JSON Net Tokens

Por fim, temos que escrever o código necessário para gerar e validar os JWTs que usaremos para autorizar chamadas à API. Assim que um token for gerado em resposta a uma solicitação preliminar à API, você poderá copiá-lo e usá-lo para autorização em todas as solicitações subsequentes.

Agora, escreva o próximo código no arquivo Program.cs para criar um novo ponto de extremidade HTTP Publish que pode criar um JWT para um consumidor autenticado.

app.MapPost("/safety/createToken", 
[AllowAnonymous] (Pessoa consumidor) => 
{ 
    if (consumer.UserName == "joydip" && consumer.Password == "joydip123") 
    { 
        var emissor = builder.Configuration[" Jwt:Issuer"]; 
        var viewers = builder.Configuration["Jwt:Audience"]; 
        var key = Encoding.ASCII.GetBytes 
        (builder.Configuration["Jwt:Key"]); 
        var tokenDescriptor = new SecurityTokenDescriptor 
        { 
            Topic = new ClaimsIdentity(new[] 
            { 
                new Declare("Id", Guid.NewGuid().ToString()), 
                new Declare(JwtRegisteredClaimNames.Sub, consumer.UserName),
                new Declare(JwtRegisteredClaimNames.Electronic mail, consumer.UserName), 
                new Declare(JwtRegisteredClaimNames.Jti, 
                Guid.NewGuid().ToString()) 
             }), 
            Expires = DateTime.UtcNow.AddMinutes(5), 
            Issuer = emissor, 
            Viewers = visualizadores, 
            SigningCredentials = novo SigningCredentials 
            (novo SymmetricSecurityKey(key), 
            SecurityAlgorithms.HmacSha512Signature) 
        }; 
        var tokenHandler = new JwtSecurityTokenHandler(); 
        var token = tokenHandler.CreateToken(tokenDescriptor); 
        var jwtToken = tokenHandler.WriteToken(token);
        var stringToken = tokenHandler.WriteToken(token); 
        return Outcomes.Ok(stringToken); 
    } 
    return Outcomes.Unauthorized(); 
});

Um evento da classe Person é usado apenas para receber um título de usuário e uma senha fornecida a este endpoint. Esteja ciente do atributo AllowAnonymous. Isso é usado para especificar que não queremos um teste de autorização neste endpoint. O emissor, os visualizadores e a chave são aprendidos com o arquivo de configuração. Cada um deles é usado para criar o token, que agora especificamos que expirará em 5 minutos.

Todo o código de fornecimento para Program.cs

Aqui está todo o código fonte do arquivo Program.cs em sua referência.

utilizando Microsoft.AspNetCore.Authentication.JwtBearer; 
utilizando Microsoft.AspNetCore.Authorization; 
utilizando Microsoft.IdentityModel.Tokens; 
utilizando System.IdentityModel.Tokens.Jwt; 
utilizando System.Safety.Claims; 
utilizando conteúdo System.Textual; 
var builder = WebApplication.CreateBuilder(args); Builder.companies.addauthentication ( Choices => 
{ 
Choices.DefaultAuthenticatesCheme     = JWTBearerDefaults.authenticationsCheme 
    ; 
    Choices.DefaultChallengesCheme 
    = JWTBeerDefaults.authenticationsCheme;



    { 
        ValidIssuer = builder.Configuration["Jwt:Issuer"], 
        ValidAudience = builder.Configuration["Jwt:Audience"], 
        IssuerSigningKey = new SymmetricSecurityKey 
            (Encoding.UTF8.GetBytes(builder.Configuration["Jwt:Key"])) , 
        ValidateIssuer = verdadeiro, 
        ValidateAudience = verdadeiro, 
        ValidateLifetime = falso, 
        ValidateIssuerSigningKey = verdadeiro 
    }; 
}); 
builder.Companies.AddAuthorization(); 
var app = builder.Construct(); 
app.UseHttpsRedirection(); 
app.MapGet("/safety/getMessage", () => "Hey World!").RequireAuthorization(); 
app.MapPost("/safety/createToken",

{ 
    if (consumer.UserName == "joydip" && consumer.Password == "joydip123") 
    { 
        var emissor = builder.Configuration["Jwt:Issuer"]; 
        var visualizadores = builder.Configuration["Jwt:Audience"]; 
        var key = Encoding.ASCII.GetBytes 
        (builder.Configuration["Jwt:Key"]); 
        var tokenDescriptor = new SecurityTokenDescriptor 
        { 
            Topic = new ClaimsIdentity(new[] 
            { 
                new Declare("Id", Guid.NewGuid().ToString()), 
                new Declare(JwtRegisteredClaimNames.Sub, consumer.UserName), 
                new Declare(JwtRegisteredClaimNames. Correio eletrônico, consumidor.UserName),
                new Declare(JwtRegisteredClaimNames.Jti, 
                Guid.NewGuid().ToString()) 
             }), 
            Expires = DateTime.UtcNow.AddMinutes(5), 
            Issuer = emissor, 
            Viewers = visualizadores, 
            SigningCredentials = new SigningCredentials 
            (new SymmetricSecurityKey(key), 
            SecurityAlgorithms.HmacSha512Signature) 
        }; 
        var tokenHandler = new JwtSecurityTokenHandler(); 
        var token = tokenHandler.CreateToken(tokenDescriptor); 
        var jwtToken = tokenHandler.WriteToken(token); 
        var stringToken = tokenHandler.WriteToken(token); 
        return Outcomes.Ok(stringToken);
    } 
    return Outcomes.Unauthorized(); 
}); 
app.UseAuthentication(); 
app.UseAuthorization(); 
app.Run();

Autenticação JWT em movimento

Enquanto você envia as credenciais do consumidor para o endpoint createToken usando o Postman, você poderá ver o token gerado.

IDG

Esteja ciente de que fornecemos as credenciais do cliente, ou seja, o nome do cliente e a senha, no corpo da solicitação.

Agora, nomeie o endpoint HTTP Get que criamos anteriormente e mova o token gerado como um token de portador dentro do cabeçalho da solicitação. Caso seu token gerado seja legítimo, você verá a mensagem comprovada na Determinação 3.

IDG

Como você pode ver na Determinação 3, a mensagem de texto “Hey World!” é exibido porque o token que entregamos é legítimo. Observe também a resposta HTTP 200 OK (destacada em um retângulo verde).

Nesse caso, codificamos o nome do usuário e a senha para facilitar as coisas. Afinal, você não deve de forma alguma codificar credenciais de consumidor em um ambiente de fabricação. Uma boa opção é usar a Identificação do ASP.NET Core 6 para lidar com contas de consumidores.

Para verificar nossa implementação mínima de API aqui, usamos Postman , um dos instrumentos padrão cruciais disponíveis enquanto falamos para verificar APIs. Para verificar seus endpoints mínimos de API, você também pode usar o Swagger , um kit de ferramentas que facilita o fornecimento de uma ilustração gráfica de sua API.