Métodos fáceis para 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 terá que proteger os endpoints de tais APIs em seus propósitos. O objetivo deste envio é fornecer a você uma vantagem inicial sobre como fazê-lo.

Já mencionamos a melhor maneira de começar com APIs mínimas , a melhor maneira de usar log e injeção de dependência em APIs mínimas e a melhor maneira de dar uma olhada nas APIs mínimas em artigos anteriores. Este texto discute como podemos proteger nossos endpoints mínimos de API utilizando a autenticação JWT, ou seja, autenticação baseada principalmente em JSON Internet Tokens.

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

1. Crie um empreendimento mínimo de API no Visible Studio 2022.
2. Crie um endpoint de API no arquivo Program.cs.
3. Adicione o pacote Microsoft.AspNetCore.Authentication.JwtBearer NuGet ao nosso empreendimento.
4. Implemente a autenticação JWT no arquivo Program.cs.
5. Crie uma classe de modelo pessoal chamada Consumidor para armazenar as credenciais de login da pessoa.
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 provedores de autorização ao nosso utilitário no arquivo Program.cs.
9. Crie e valide o JSON Internet Token no arquivo Program.cs.

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

Para trabalhar com os exemplos de código oferecidos neste artigo, é melhor instalar o Visible Studio 2022 em seu sistema. Caso você ainda não tenha uma réplica, você pode baixar o Visible Studio 2022 aqui .

Crie uma API de Internet mínima do ASP.NET Core 6 no Visible Studio 2022

Primeiramente, vamos criar um empreendimento ASP.NET Core 6 no Visible Studio. Seguir estas etapas criará um novo empreendimento de API de Internet ASP.NET Core 6 no Visible Studio 2022:

1. Inicie o Visible Studio 2022 IDE.
2. Clique em “Criar novo empreendimento”.
3. Na janela “Criar novo empreendimento”, escolha “ASP.NET Core Internet API” na lista de verificação de modelos exibidos.
4. Clique em Subsequente.
5. Na janela “Configurar seu novo empreendimento”, especifique o título e a localização do novo empreendimento.
6. Opcionalmente, teste o campo de teste “Coloque resolução e empreendimento na mesma lista”, dependendo de suas preferências.
7. Clique em Subsequente.
8. Na janela “Further Data” mostrada a seguir, desmarque o campo de teste que diz “Use controllers…” porque usaremos APIs mínimas nesta instância. Deixe o “Authentication Sort” como “None” (padrão).
9. Certifique-se de que os contêineres de empacotamento de teste “Permitir Docker”, “Configurar para HTTPS” e “Permitir ajuda da API aberta” estejam desmarcados, pois não usaremos nenhuma dessas opções aqui.
10. Clique em Criar.

Usaremos esse empreendimento de API de Internet do ASP.NET Core 6 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

Se você criar um novo empreendimento mínimo de API da Internet no Visible Studio 2022, um arquivo Program.cs pode ser criado com apenas alguns traços de código padrão. Você pode substituir o código padrão pelo 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.

Caso você execute 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 ao seu empreendimento. Para fazer isso, escolha o empreendimento na janela do Resolution Explorer, clique com o botão direito do mouse e escolha “Manipular pacotes NuGet”. Na janela NuGet Bundle Supervisor, procure o pacote Microsoft.AspNetCore.Authentication.JwtBearer e configure-o.

Como alternativa, você pode configurar o pacote por meio do console NuGet Bundle Supervisor acessando o comando demonstrado 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 pode ser usada posteriormente para gerar um Token de Internet JSON. 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": { 
    "Emissor": "https://joydipkanjilal.com/", 
    "Visualizadores": "https://joydipkanjilal.com/", 
    "Chave": "Esta pode ser uma chave secreta padrão - por favor, não use na configuração 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. A ocasião TokenValidationParameters é usada 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 => { 
choice.DefaultAuthenticateScheme 
    = JwtBearerDefaults.AuthenticationScheme; 
    choice.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; 
    choice.DefaultScheme = JwtBearerDefaults.AuthenticationScheme; 
}).AddJowtBear     TokenValidationParameters     {         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 provedores de autorização ao seu utilitário, seu Program.cs também deve incluir o próximo trecho de código.

builder.Companies.AddAuthorization();

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

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

Crie um manequim de pessoa no ASP.NET Core 6

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

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

Essa classe pode ser usada para simplesmente aceitar as credenciais da pessoa como entrada.

Crie um endpoint para gerar JSON Internet Tokens

Por fim, temos que escrever o código obrigatório para gerar e validar os JWTs que usaremos para autorizar chamadas à API. Assim que um token é gerado em resposta a uma solicitação preliminar à API, você pode 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 Put que pode criar um JWT para um usuário autenticado.

app.MapPost("/safety/createToken", 
[AllowAnonymous] (Consumer person) => 
{ 
    if (person.UserName == "joydip" && person.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, pessoa.UserName),
                new Declare(JwtRegisteredClaimNames.E-mail, pessoa.UserName), 
                new Declare(JwtRegisteredClaimNames.Jti, 
                Guid.NewGuid().ToString()) 
             }), 
            Expires = DateTime.UtcNow.AddMinutes(5), 
            Issuer = emissor, 
            Viewers = visualizadores, 
            SigningCredentials = novo SigningCredentials 
            (novo SymmetricSecurityKey(chave), 
            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(); 
});

Uma instância da classe Consumer é usada para simplesmente aceitar um título de pessoa 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 terminal. 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 para 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 => { 
choice.DefaultAuthenticateScheme 
    = JwtBearerDefaults.AuthenticationScheme; 
    choice.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; 
    choice.DefaultScheme = JwtBearerDefaults.AuthenticationScheme; 
}).AddJowtBear     TokenValidationParameters
    { 
        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 (person.UserName == "joydip" && person.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, person.UserName), 
                new Declare(JwtRegisteredClaimNames. E-mail, pessoa.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

Se você enviar as credenciais pessoais para o terminal createToken usando o Postman, poderá ver o token gerado.

IDG

Esteja ciente de que fornecemos as credenciais da pessoa, ou seja, o nome da pessoa 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 a resposta HTTP 200 OK também (destacada em um retângulo verde).

Nesse caso, codificamos o título e a senha do usuário para facilitar as coisas. Na verdade, é melhor nunca codificar credenciais pessoais em um ambiente de fabricação. Uma boa opção é usar o ASP.NET Core 6 Id para lidar com contas pessoais.

Para verificar nossa implementação mínima de API aqui, usamos o Postman , uma das ferramentas populares disponíveis imediatamente 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.

Conclusão

Neste artigo, exploramos as nuances da autenticação JWT em APIs mínimas do ASP.NET Core 6, destacando um modelo de hospedagem simplificado que facilita a construção de aplicações seguras e eficientes.

Abordamos desde a criação de um projeto básico até a implementação de endpoints protegidos, enfatizando a importância de um gerenciamento adequado de credenciais e a validação de tokens. Os principais benefícios discutidos incluem a proteção robusta de dados sensíveis, a facilidade de implementação e a experiência de desenvolvimento aprimorada.

Agora é a sua vez! Aproveite o conhecimento adquirido para implementar a autenticação JWT em suas próprias APIs. Experimente as técnicas descritas e veja como elas podem fortalecer a segurança de suas aplicações. Se ainda não utilizou o Visual Studio 2022, faça o download e comece a criar!

Lembre-se: cada passo que você dá em direção à construção de aplicações mais seguras é um investimento no futuro do seu desenvolvimento. Não deixe essa oportunidade passar, comece agora e transforme suas ideias em soluções seguras e eficazes!