.NET CORE 3.1 integra autenticación y autorización JWT

Language 2023-07-02 01:09:25 views: null

 Sitio web oficial: JSON Web Tokens - jwt.io JSON Web Token (JWT) es un medio seguro de URL compacto para representar reclamos que se transferirán entre dos partes. Los reclamos en un JWT están codificados como un objeto JSON que está firmado digitalmente usando JSON. Firma web (JWS) https://jwt.io/ JWT: el nombre completo es JSON Web Token, que actualmente es la solución más popular para la autenticación entre dominios, el inicio de sesión distribuido y el inicio de sesión único.

 

En términos simples, JWT es un token que puede representar la identidad del usuario, y el token JWT se puede usar para verificar la identidad del usuario en la interfaz API para confirmar si el usuario tiene permiso para acceder a la API.

Autorización: este es el escenario más común para usar JWT. Una vez que el usuario haya iniciado sesión, cada solicitud posterior incluirá el JWT, lo que permitirá al usuario acceder a las rutas, servicios y recursos permitidos por ese token.

En la autenticación, cuando un usuario inicia sesión correctamente con sus credenciales, se devuelve un token web JSON. Dado que los tokens son credenciales, se debe tener mucho cuidado para evitar problemas de seguridad. En general, no debe conservar los tokens más tiempo del necesario.

Siempre que un usuario quiera acceder a una ruta o recurso protegido, el agente de usuario debe enviar el JWT usando el modo portador, generalmente en el encabezado de Autorización , el contenido del encabezado debe verse así:

Autorización: Portador <token>

1. La aplicación solicita autorización del servidor de autorización;

2. Verifique la identidad del usuario, si la verificación es exitosa, devuelva el token;

3. La aplicación utiliza el token de acceso para acceder al recurso protegido.

 La implementación de JWT es almacenar información del usuario en el cliente y el servidor no la guarda. Cada solicitud trae el token para verificar el estado de inicio de sesión del usuario, de modo que el servicio se vuelve sin estado y el clúster de servidores es fácil de expandir.

Para obtener más conocimientos teóricos, puede consultar el sitio web oficial o consultar los artículos de los internautas relacionados, los siguientes artículos recomendados:

Consulte el paquete integrado jwt en nuget. Cabe señalar aquí que si está utilizando el marco de .NET Core 3.1, la versión del paquete debe ser 3.1.7

Microsoft.AspNetCore.Authentication.JwtBearer

Agregue la API de simulación de acceso a datos, cree un nuevo controlador ValuesController

Entre ellos, se puede acceder directamente a api/value1, y api/value2 ha agregado la etiqueta de función de verificación de permisos [Autorizar]

using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using System.Threading.Tasks;

namespace jwtWebAPI.Controllers
{
    [ApiController]
    public class ValuesController : ControllerBase
    {
        [HttpGet]
        [Route("api/values1")]
        public ActionResult<IEnumerable<string>> values1()
        {
            return new string[] { "value1", "value1" };
        }

        /**
         * 该接口用Authorize特性做了权限校验，如果没有通过权限校验，则http返回状态码为401
         * 调用该接口的正确姿势是：
         * 1.登陆，调用api/Auth接口获取到token
         * 2.调用该接口 api/value2 在请求的Header中添加参数 Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYmYiOiIxNTYwMzM1MzM3IiwiZXhwIjoxNTYwMzM3MTM3LCJodHRwOi8vc2NoZW1hcy54bWxzb2FwLm9yZy93cy8yMDA1LzA1L2lkZW50aXR5L2NsYWltcy9uYW1lIjoiemhhbmdzYW4iLCJpc3MiOiJodHRwOi8vbG9jYWxob3N0OjUwMDAiLCJhdWQiOiJodHRwOi8vbG9jYWxob3N0OjUwMDAifQ.1S-40SrA4po2l4lB_QdzON_G5ZNT4P_6U25xhTcl7hI
         * Bearer后面有空格，且后面是第一步中接口返回的token值
         * */
        [HttpGet]
        [Route("api/value2")]
        [Authorize]
        public ActionResult<IEnumerable<string>> value2()
        {
            //这是获取自定义参数的方法
            var auth = HttpContext.AuthenticateAsync().Result.Principal.Claims;
            var userName = auth.FirstOrDefault(t => t.Type.Equals(ClaimTypes.NameIdentifier))?.Value;
            return new string[] { "访问成功：这个接口登陆过的用户都可以访问", $"userName={userName}" };
        }

     
    }
}

Agregue la API que simula el inicio de sesión para generar Token y cree un nuevo controlador AuthController

Aquí hay una simulación de la verificación de inicio de sesión, que solo verifica que la contraseña del usuario no esté vacía y pasa la verificación. El entorno real mejora la lógica de verificación del usuario y la contraseña.

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.IdentityModel.Tokens;
using System;
using System.Collections.Generic;
using System.IdentityModel.Tokens.Jwt;
using System.Linq;
using System.Security.Claims;
using System.Text;
using System.Threading.Tasks;

namespace jwtWebAPI.Controllers
{
    [ApiController]
    public class AuthController : Controller
    {
        /// <summary>
        /// 通过账号+密码获取Token
        /// </summary>
        /// <param name="userName"></param>
        /// <param name="pwd"></param>
        /// <returns>Token</returns>
        [AllowAnonymous]
        [HttpGet]
        [Route("api/auth")]
        public IActionResult GetToken(string userName, string pwd)
        {
            if (!string.IsNullOrEmpty(userName))
            {
                //每次登陆动态刷新
                Const.ValidAudience = userName + pwd + DateTime.Now.ToString();
                // push the user’s name into a claim, so we can identify the user later on.
                //这里可以随意加入自定义的参数，key可以自己随便起
                var claims = new[]
                {
                    new Claim(JwtRegisteredClaimNames.Nbf,$"{new DateTimeOffset(DateTime.Now).ToUnixTimeSeconds()}") ,
                    new Claim (JwtRegisteredClaimNames.Exp,$"{new DateTimeOffset(DateTime.Now.AddMinutes(3)).ToUnixTimeSeconds()}"),
                    new Claim(ClaimTypes.NameIdentifier, userName)
                };
                //sign the token using a secret key.This secret will be shared between your API and anything that needs to check that the token is legit.
                var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Const.SecurityKey));
                var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
                //.NET Core’s JwtSecurityToken class takes on the heavy lifting and actually creates the token.
                var token = new JwtSecurityToken(
                    //颁发者
                    issuer: Const.Domain,
                    //接收者
                    audience: Const.ValidAudience,
                    //过期时间（可自行设定，注意和上面的claims内部Exp参数保持一致）
                    expires: DateTime.Now.AddMinutes(3),
                    //签名证书
                    signingCredentials: creds,
                    //自定义参数
                    claims: claims
                    );

                return Ok(new
                {
                    token = new JwtSecurityTokenHandler().WriteToken(token)
                });
            }
            else
            {
                return BadRequest(new { message = "username or password is incorrect." });
            }
        }
    }
}

El inicio agrega configuraciones relacionadas para la verificación de JWT

using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.HttpsPolicy;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Microsoft.IdentityModel.Tokens;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace jwtWebAPI
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            //添加jwt验证：
            services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
                .AddJwtBearer(options => {
                    options.TokenValidationParameters = new TokenValidationParameters
                    {
                        ValidateLifetime = true,//是否验证失效时间
                        ClockSkew = TimeSpan.FromSeconds(30),  //时间偏移量（允许误差时间）
                        ValidateAudience = true,//是否验证Audience（验证之前的token是否失效）
                        //ValidAudience = Const.GetValidudience(),//Audience
                        //这里采用动态验证的方式，在重新登陆时，刷新token，旧token就强制失效了
                        AudienceValidator = (m, n, z) =>
                        {
                            return m != null && m.FirstOrDefault().Equals(Const.ValidAudience);
                        },
                        ValidateIssuer = true,//是否验证Issuer（颁发者）
                        ValidAudience = Const.Domain,//Audience    【Const是新建的一个常量类】  接收者 
                        ValidIssuer = Const.Domain,//Issuer，这两项和前面签发jwt的设置一致      颁发者
                        ValidateIssuerSigningKey = true,//是否验证SecurityKey
                        IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Const.SecurityKey))//拿到秘钥SecurityKey
                    };
                    options.Events = new JwtBearerEvents
                    {
                        OnAuthenticationFailed = context =>
                        {
                            //Token expired
                            if (context.Exception.GetType() == typeof(SecurityTokenExpiredException))
                            {
                                context.Response.Headers.Add("Token-Expired", "true");
                            }
                            return Task.CompletedTask;
                        }
                    };
                });

            services.AddControllers();
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        { 
            //添加jwt验证
            app.UseAuthentication();

            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseHttpsRedirection();

            app.UseRouting();

            app.UseAuthorization();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
            });
        }
    }
}

Crear una clase constante Const

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace jwtWebAPI
{
    public class Const
    {
        /// <summary>
        /// 这里为了演示，写死一个密钥。实际生产环境可以从配置文件读取,这个是用网上工具随便生成的一个密钥（md5或者其他都可以）
        /// </summary>
        public const string SecurityKey = "48754F4C58F9EA428FE09D714E468211";

        /// <summary>
        /// 站点地址（颁发者、接受者），这里测试和当前本地运行网站相同，实际发到正式环境应为域名地址
        /// </summary>
        public const string Domain = "https://localhost:44345";

        /// <summary>
        /// 受理人，之所以弄成可变的是为了用接口动态更改这个值以模拟强制Token失效
        /// 真实业务场景可以在数据库或者redis存一个和用户id相关的值，生成token和验证token的时候获取到持久化的值去校验
        /// 如果重新登陆，则刷新这个值
        /// </summary>
        public static string ValidAudience;
    }
}

La prueba de autorización de inicio de sesión de JWT tuvo éxito

Se devolvió un código de estado de 401, que es No autorizado: acceso denegado debido a credenciales no válidas. Significa que la verificación JWT ha tenido efecto y nuestra interfaz ha sido protegida.

Llame a la interfaz de autorización de inicio de sesión simulada: https://localhost: 44345 /api/auth?userName=xiongze&pwd=123456

La contraseña de usuario aquí se escribe casualmente, porque solo se verifica que nuestro inicio de sesión simulado no esté vacío, por lo que todo se puede escribir.

Luego obtuvimos un valor de token en el formato de xxx.yyy.zzz. Copiamos el token.

Agregue parámetros JWT en el encabezado de solicitud de la interfaz 401 ( https://localhost:44345/api/values2 ) ahora mismo, y agregue nuestro token

Vuelva a llamar a nuestra interfaz de datos simulados, pero esta vez agregamos un encabezado, CLAVE: Valor de autorización: el valor de Bearer Tokne

Cabe señalar aquí que hay un espacio después de Bearer, y luego es el token que obtuvimos en el paso anterior.

Obtenga el valor de retorno, la autorización correcta es exitosa, admitimos parámetros de retorno personalizados, el código anterior contiene contenido relevante, como el nombre de usuario y otra información no confidencial que se puede devolver con él.

Cuando el tiempo de caducidad establecido por el token se cumpla, o se regenere un nuevo Token y no se actualice a tiempo, entonces nuestra autorización también caducará, 401,

Operación de actualización: aislamiento de autoridad de interfaz

La operación anterior significa que todos los roles con autorización de inicio de sesión exitosa pueden llamar a todas las interfaces, por lo que ahora queremos implementar restricciones de aislamiento de interfaz,

Es decir, aunque el inicio de sesión está autorizado, se accede a mi interfaz con permisos específicos.

Por ejemplo: la interfaz de eliminación solo puede ser operada por el rol de administrador, por lo que aunque otras funciones están autorizadas para iniciar sesión, no tienen permiso para llamar a la interfaz de eliminación.

Echemos un vistazo a la transformación y actualización de la operación original.

añadir clase

Cree una nueva carpeta AuthManagement , agregue la clase PolicyRequirement y la clase PolicyHandler ,

Clase de requisito de política:

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace jwtWebAPI.AuthManagement
{
    /// <summary>
    /// 权限承载实体
    /// </summary>
    public class PolicyRequirement : IAuthorizationRequirement
    {
        /// <summary>
        /// 用户权限集合
        /// </summary>
        public List<UserPermission> UserPermissions { get; private set; }
        /// <summary>
        /// 无权限action
        /// </summary>
        public string DeniedAction { get; set; }
        /// <summary>
        /// 构造
        /// </summary>
        public PolicyRequirement()
        {
            //没有权限则跳转到这个路由
            DeniedAction = new PathString("/api/nopermission");
            //用户有权限访问的路由配置,当然可以从数据库获取
            UserPermissions = new List<UserPermission> {
                              new UserPermission {  Url="/api/values3", UserName="admin"},
                          };
        }
    }

    /// <summary>
    /// 用户权限承载实体
    /// </summary>
    public class UserPermission
    {
        /// <summary>
        /// 用户名
        /// </summary>
        public string UserName { get; set; }
        /// <summary>
        /// 请求Url
        /// </summary>
        public string Url { get; set; }
    }
}

Clase PolicyHandler (tenga en cuenta la diferencia entre 2.x y 3.x)

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using System.Threading.Tasks;

namespace jwtWebAPI.AuthManagement
{
    public class PolicyHandler : AuthorizationHandler<PolicyRequirement>
    {
        private readonly IHttpContextAccessor _httpContextAccessor;
        public PolicyHandler(IHttpContextAccessor httpContextAccessor)
        {
            _httpContextAccessor = httpContextAccessor;
        }
        protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, PolicyRequirement requirement)
        {
            //赋值用户权限
            var userPermissions = requirement.UserPermissions;
            var httpContext = _httpContextAccessor.HttpContext;

            //请求Url
            var questUrl = httpContext.Request.Path.Value.ToUpperInvariant();
            //是否经过验证
            var isAuthenticated = httpContext.User.Identity.IsAuthenticated;
            if (isAuthenticated)
            {
                if (userPermissions.GroupBy(g => g.Url).Any(w => w.Key.ToUpperInvariant() == questUrl))
                {
                    //用户名
                    var userName = httpContext.User.Claims.SingleOrDefault(s => s.Type == ClaimTypes.NameIdentifier).Value;
                    if (userPermissions.Any(w => w.UserName == userName && w.Url.ToUpperInvariant() == questUrl))
                    {
                        context.Succeed(requirement);
                    }
                    else
                    {
                        无权限跳转到拒绝页面
                        //httpContext.Response.Redirect(requirement.DeniedAction);
                        return Task.CompletedTask;
                    }
                }
                else
                {
                    context.Succeed(requirement);
                }
            }
            return Task.CompletedTask;
        }
    }
}

Agregar rol especificado

Agregue parámetros personalizados a la autorización GetToken del controlador  AuthController  , de la siguiente manera

new Claim("Role", userName) //Aquí está el rol, en su lugar uso el administrador de la cuenta de inicio de sesión

Agregue un método para el acceso no autorizado en el controlador   AuthController 

[AllowAnonymous]
[HttpGet]
[Route("api/nopermission")]
public IActionResult NoPermission()
{
     return Forbid("No Permission!");
}

Modificar la configuración de inicio

Agregue el modo de autenticación de políticas, agregue el esquema JWT e inyecte el controlador de autorización en el método ConfigureServices de startup.cs 

El archivo modificado es el siguiente

using jwtWebAPI.AuthManagement;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.HttpsPolicy;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Microsoft.IdentityModel.Tokens;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace jwtWebAPI
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services
                //添加策略鉴权模式
                .AddAuthorization(options =>
                {
                    options.AddPolicy("Permission", policy => policy.Requirements.Add(new PolicyRequirement()));
                })
                //添加JWT Scheme
                .AddAuthentication(s =>
                {
                    s.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
                    s.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
                    s.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
                })
                //添加jwt验证：
                .AddJwtBearer(options => {
                    options.TokenValidationParameters = new TokenValidationParameters
                    {
                        ValidateLifetime = true,//是否验证失效时间
                        ClockSkew = TimeSpan.FromSeconds(30),  //时间偏移量（允许误差时间）
                        ValidateAudience = true,//是否验证Audience（验证之前的token是否失效）
                        //ValidAudience = Const.GetValidudience(),//Audience
                        //这里采用动态验证的方式，在重新登陆时，刷新token，旧token就强制失效了
                        AudienceValidator = (m, n, z) =>
                        {
                            return m != null && m.FirstOrDefault().Equals(Const.ValidAudience);
                        },
                        ValidateIssuer = true,//是否验证Issuer（颁发者）
                        ValidAudience = Const.Domain,//Audience    【Const是新建的一个常量类】  接收者 
                        ValidIssuer = Const.Domain,//Issuer，这两项和前面签发jwt的设置一致      颁发者
                        ValidateIssuerSigningKey = true,//是否验证SecurityKey
                        IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Const.SecurityKey))//拿到秘钥SecurityKey
                    };
                    options.Events = new JwtBearerEvents
                    {
                        OnAuthenticationFailed = context =>
                        {
                            //Token expired
                            if (context.Exception.GetType() == typeof(SecurityTokenExpiredException))
                            {
                                context.Response.Headers.Add("Token-Expired", "true");
                            }
                            return Task.CompletedTask;
                        }
                    };
                });

            //注入授权Handler
            services.AddSingleton<IAuthorizationHandler, PolicyHandler>();
            //注入获取HttpContext
            services.TryAddSingleton<IHttpContextAccessor, HttpContextAccessor>();
            services.AddControllers();
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        { 
            //添加jwt验证
            app.UseAuthentication();

            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseHttpsRedirection();

            app.UseRouting();

            app.UseAuthorization();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
            });
            
        }
    }
}

Agregar el método de acceso a la API

Agregue el método para especificar el permiso de acceso en  el controlador ValuesController , de la siguiente manera:

/**
        * 这个接口必须用admin
        **/
        [HttpGet]
        [Route("api/values3")]
        [Authorize("Permission")]
        public ActionResult<IEnumerable<string>> values3()
        {
            //这是获取自定义参数的方法
            var auth = HttpContext.AuthenticateAsync().Result.Principal.Claims;
            var userName = auth.FirstOrDefault(t => t.Type.Equals(ClaimTypes.NameIdentifier))?.Value;
            var role = auth.FirstOrDefault(t => t.Type.Equals("Role"))?.Value;

            return new string[] { "访问成功：这个接口有管理员权限才可以访问", $"userName={userName}", $"Role={role}" };
        }

Prueba de acceso con diferentes permisos

Usamos el mismo método para simular el inicio de sesión, https://localhost:44345/api/auth?userName=xiongze&pwd=123

Tenga en cuenta que la cuenta no necesita iniciar sesión primero con el administrador y luego usar el token devuelto para solicitar la interfaz que acabamos de agregar para acceder al permiso especificado. En este momento, no hay permiso para acceder, porque este es un permiso de administrador. acceso.

Usamos el mismo método para simular el inicio de sesión, https://localhost:44345/api/auth?userName=xiongze&pwd=123

Tenga en cuenta que la cuenta no necesita iniciar sesión primero con el administrador y luego usar el token devuelto para solicitar la interfaz que acabamos de agregar para acceder al permiso especificado. En este momento, no hay permiso para acceder, porque este es un permiso de administrador. acceso.

Usamos el mismo método para simular el inicio de sesión, https://localhost:44345/api/auth?userName=admin&pwd=123

La visita fue un éxito.

Dirección de reimpresión del blog: https://www.cnblogs.com/xiongze520/p/15540035.html https://www.cnblogs.com/xiongze520/p/15540035.html

Supongo que te gusta

Origin blog.csdn.net/qq_26695613/article/details/129822445
Recomendado
Clasificación
Diario
Más
2024-05-14(10)
2024-05-13(7)
2024-05-12(22)
2024-05-11(31)
2024-05-10(32)
2024-05-09(31)
2024-05-08(18)
2024-05-07(35)
2024-05-06(4)
2024-05-05(0)

Code World

© 2018 codetd.com