• C# 高级 ＜一＞

    JWT：全称是JSON Web Token是目前最流行的跨域身份验证、分布式登录、单点登录等解决方案。

     通俗地来讲，JWT是能代表用户身份的令牌，可以使用JWT令牌在api接口中校验用户的身份以确认用户是否有访问api的权限。

    授权：这是使用JWT的最常见方案。一旦用户登录，每个后续请求将包括JWT，允许用户访问该令牌允许的路由，服务和资源。

    在身份验证中，当用户使用其凭据成功登录时，将返回JSON Web令牌。由于令牌是凭证，因此必须非常小心以防止出现安全问题。一般情况下，您不应该将令牌保留的时间超过要求。

    每当用户想要访问受保护的路由或资源时，用户代理应该使用承载模式发送JWT，通常在Authorization标头中，标题的内容应如下所示：

    Authorization: Bearer

    1、应用程序向授权服务器请求授权；

    2、校验用户身份，校验成功，返回token；

    3、应用程序使用访问令牌访问受保护的资源。

     JWT的实现方式是将用户信息存储在客户端，服务端不进行保存。每次请求都把令牌带上以校验用户登录状态，这样服务就变成了无状态的，服务器集群也很好扩展。

    更多理论知识可以查看官网，或者查看相关网友的文章，如下推荐文章：

    在nuget里面引用jwt集成的程序包，这里需要注意的是，如果你用的是.NET Core 3.1的框架的话，程序包版本选择3.1.7

    Microsoft.AspNetCore.Authentication.JwtBearer

    添加数据访问模拟api，新建控制器ValuesController

    其中api/value1是可以直接访问的，api/value2添加了权限校验特性标签 [Authorize]

    1. using Microsoft.AspNetCore.Authentication;
    2. using Microsoft.AspNetCore.Authorization;
    3. using Microsoft.AspNetCore.Mvc;
    4. using System;
    5. using System.Collections.Generic;
    6. using System.Linq;
    7. using System.Security.Claims;
    8. using System.Threading.Tasks;
    9.  
    10. namespace jwtWebAPI.Controllers
    11. {
    12.     [ApiController]
    13.     public class ValuesController : ControllerBase
    14.     {
    15.         [HttpGet]
    16.         [Route("api/values1")]
    17.         public ActionResult<IEnumerable<string>> values1()
    18.         {
    19.             return new string[] { "value1", "value1" };
    20.         }
    21.  
    22.         /**
    23.          * 该接口用Authorize特性做了权限校验，如果没有通过权限校验，则http返回状态码为401
    24.          * 调用该接口的正确姿势是：
    25.          * 1.登陆，调用api/Auth接口获取到token
    26.          * 2.调用该接口 api/value2 在请求的Header中添加参数 Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYmYiOiIxNTYwMzM1MzM3IiwiZXhwIjoxNTYwMzM3MTM3LCJodHRwOi8vc2NoZW1hcy54bWxzb2FwLm9yZy93cy8yMDA1LzA1L2lkZW50aXR5L2NsYWltcy9uYW1lIjoiemhhbmdzYW4iLCJpc3MiOiJodHRwOi8vbG9jYWxob3N0OjUwMDAiLCJhdWQiOiJodHRwOi8vbG9jYWxob3N0OjUwMDAifQ.1S-40SrA4po2l4lB_QdzON_G5ZNT4P_6U25xhTcl7hI
    27.          * Bearer后面有空格，且后面是第一步中接口返回的token值
    28.          * */
    29.         [HttpGet]
    30.         [Route("api/value2")]
    31.         [Authorize]
    32.         public ActionResult<IEnumerable<string>> value2()
    33.         {
    34.             //这是获取自定义参数的方法
    35.             var auth = HttpContext.AuthenticateAsync().Result.Principal.Claims;
    36.             var userName = auth.FirstOrDefault(t => t.Type.Equals(ClaimTypes.NameIdentifier))?.Value;
    37.             return new string[] { "访问成功：这个接口登陆过的用户都可以访问", $"userName={userName}" };
    38.         }
    39.  
    40.      
    41.     }
    42. }

    添加模拟登陆生成Token的api，新建控制器AuthController

    这里模拟一下登陆校验，只验证了用户密码不为空即通过校验，真实环境完善校验用户和密码的逻辑。

    1. using Microsoft.AspNetCore.Authorization;
    2. using Microsoft.AspNetCore.Mvc;
    3. using Microsoft.IdentityModel.Tokens;
    4. using System;
    5. using System.Collections.Generic;
    6. using System.IdentityModel.Tokens.Jwt;
    7. using System.Linq;
    8. using System.Security.Claims;
    9. using System.Text;
    10. using System.Threading.Tasks;
    11.  
    12. namespace jwtWebAPI.Controllers
    13. {
    14.     [ApiController]
    15.     public class AuthController : Controller
    16.     {
    17.         /// <summary>
    18.         /// 通过账号+密码获取Token
    19.         /// </summary>
    20.         /// <param name="userName"></param>
    21.         /// <param name="pwd"></param>
    22.         /// <returns>Token</returns>
    23.         [AllowAnonymous]
    24.         [HttpGet]
    25.         [Route("api/auth")]
    26.         public IActionResult GetToken(string userName, string pwd)
    27.         {
    28.             if (!string.IsNullOrEmpty(userName))
    29.             {
    30.                 //每次登陆动态刷新
    31.                 Const.ValidAudience = userName + pwd + DateTime.Now.ToString();
    32.                 // push the user’s name into a claim, so we can identify the user later on.
    33.                 //这里可以随意加入自定义的参数，key可以自己随便起
    34.                 var claims = new[]
    35.                 {
    36.                     new Claim(JwtRegisteredClaimNames.Nbf,$"{new DateTimeOffset(DateTime.Now).ToUnixTimeSeconds()}") ,
    37.                     new Claim (JwtRegisteredClaimNames.Exp,$"{new DateTimeOffset(DateTime.Now.AddMinutes(3)).ToUnixTimeSeconds()}"),
    38.                     new Claim(ClaimTypes.NameIdentifier, userName)
    39.                 };
    40.                 //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.
    41.                 var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Const.SecurityKey));
    42.                 var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
    43.                 //.NET Core’s JwtSecurityToken class takes on the heavy lifting and actually creates the token.
    44.                 var token = new JwtSecurityToken(
    45.                     //颁发者
    46.                     issuer: Const.Domain,
    47.                     //接收者
    48.                     audience: Const.ValidAudience,
    49.                     //过期时间（可自行设定，注意和上面的claims内部Exp参数保持一致）
    50.                     expires: DateTime.Now.AddMinutes(3),
    51.                     //签名证书
    52.                     signingCredentials: creds,
    53.                     //自定义参数
    54.                     claims: claims
    55.                     );
    56.  
    57.                 return Ok(new
    58.                 {
    59.                     token = new JwtSecurityTokenHandler().WriteToken(token)
    60.                 });
    61.             }
    62.             else
    63.             {
    64.                 return BadRequest(new { message = "username or password is incorrect." });
    65.             }
    66.         }
    67.     }
    68. }

    Startup添加JWT验证的相关配置

    1. using Microsoft.AspNetCore.Authentication.JwtBearer;
    2. using Microsoft.AspNetCore.Builder;
    3. using Microsoft.AspNetCore.Hosting;
    4. using Microsoft.AspNetCore.HttpsPolicy;
    5. using Microsoft.AspNetCore.Mvc;
    6. using Microsoft.Extensions.Configuration;
    7. using Microsoft.Extensions.DependencyInjection;
    8. using Microsoft.Extensions.Hosting;
    9. using Microsoft.Extensions.Logging;
    10. using Microsoft.IdentityModel.Tokens;
    11. using System;
    12. using System.Collections.Generic;
    13. using System.Linq;
    14. using System.Text;
    15. using System.Threading.Tasks;
    16.  
    17. namespace jwtWebAPI
    18. {
    19.     public class Startup
    20.     {
    21.         public Startup(IConfiguration configuration)
    22.         {
    23.             Configuration = configuration;
    24.         }
    25.  
    26.         public IConfiguration Configuration { get; }
    27.  
    28.         // This method gets called by the runtime. Use this method to add services to the container.
    29.         public void ConfigureServices(IServiceCollection services)
    30.         {
    31.             //添加jwt验证：
    32.             services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    33.                 .AddJwtBearer(options => {
    34.                     options.TokenValidationParameters = new TokenValidationParameters
    35.                     {
    36.                         ValidateLifetime = true,//是否验证失效时间
    37.                         ClockSkew = TimeSpan.FromSeconds(30),  //时间偏移量（允许误差时间）
    38.                         ValidateAudience = true,//是否验证Audience（验证之前的token是否失效）
    39.                         //ValidAudience = Const.GetValidudience(),//Audience
    40.                         //这里采用动态验证的方式，在重新登陆时，刷新token，旧token就强制失效了
    41.                         AudienceValidator = (m, n, z) =>
    42.                         {
    43.                             return m != null && m.FirstOrDefault().Equals(Const.ValidAudience);
    44.                         },
    45.                         ValidateIssuer = true,//是否验证Issuer（颁发者）
    46.                         ValidAudience = Const.Domain,//Audience    【Const是新建的一个常量类】  接收者 
    47.                         ValidIssuer = Const.Domain,//Issuer，这两项和前面签发jwt的设置一致      颁发者
    48.                         ValidateIssuerSigningKey = true,//是否验证SecurityKey
    49.                         IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Const.SecurityKey))//拿到秘钥SecurityKey
    50.                     };
    51.                     options.Events = new JwtBearerEvents
    52.                     {
    53.                         OnAuthenticationFailed = context =>
    54.                         {
    55.                             //Token expired
    56.                             if (context.Exception.GetType() == typeof(SecurityTokenExpiredException))
    57.                             {
    58.                                 context.Response.Headers.Add("Token-Expired", "true");
    59.                             }
    60.                             return Task.CompletedTask;
    61.                         }
    62.                     };
    63.                 });
    64.  
    65.             services.AddControllers();
    66.         }
    67.  
    68.         // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
    69.         public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    70.         { 
    71.             //添加jwt验证
    72.             app.UseAuthentication();
    73.  
    74.             if (env.IsDevelopment())
    75.             {
    76.                 app.UseDeveloperExceptionPage();
    77.             }
    78.  
    79.             app.UseHttpsRedirection();
    80.  
    81.             app.UseRouting();
    82.  
    83.             app.UseAuthorization();
    84.  
    85.             app.UseEndpoints(endpoints =>
    86.             {
    87.                 endpoints.MapControllers();
    88.             });
    89.         }
    90.     }
    91. }

    创建常量类Const

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Threading.Tasks;
    5.  
    6. namespace jwtWebAPI
    7. {
    8.     public class Const
    9.     {
    10.         /// <summary>
    11.         /// 这里为了演示，写死一个密钥。实际生产环境可以从配置文件读取,这个是用网上工具随便生成的一个密钥（md5或者其他都可以）
    12.         /// </summary>
    13.         public const string SecurityKey = "48754F4C58F9EA428FE09D714E468211";
    14.  
    15.         /// <summary>
    16.         /// 站点地址（颁发者、接受者），这里测试和当前本地运行网站相同，实际发到正式环境应为域名地址
    17.         /// </summary>
    18.         public const string Domain = "https://localhost:44345";
    19.  
    20.         /// <summary>
    21.         /// 受理人，之所以弄成可变的是为了用接口动态更改这个值以模拟强制Token失效
    22.         /// 真实业务场景可以在数据库或者redis存一个和用户id相关的值，生成token和验证token的时候获取到持久化的值去校验
    23.         /// 如果重新登陆，则刷新这个值
    24.         /// </summary>
    25.         public static string ValidAudience;
    26.     }
    27. }

    JWT登录授权测试成功

    返回了状态码401，也就是未经授权:访问由于凭据无效被拒绝。 说明JWT校验生效了，我们的接口收到了保护。

    调用模拟登陆授权接口：https://localhost:44345/api/auth?userName=xiongze&pwd=123456

    这里的用户密码是随便写的，因为我们模拟登陆只是校验了下非空，因此写什么都能通过。

    然后我们得到了一个xxx.yyy.zzz 格式的 token 值。我们把token复制出来。

    在刚才401的接口（https://localhost:44345/api/values2）请求header中添加JWT的参数，把我们的token加上去

    再次调用我们的模拟数据接口，但是这次我们加了一个header，KEY：Authorization     Value：Bearer Tokne的值

    这里需要注意 Bearer 后面是有一个空格的，然后就是我们上一步获取到的token，

    得到返回值，正确授权成功，我们是支持自定义返回参数的，上面代码里面有相关内容，比如用户名这些不敏感的信息可以带着返回。

    等token设置的过期时间到了，或者重新生成了新的Token，没有及时更新，那么我们的授权也到期，401，

    升级操作：接口权限隔离

    上面的操作是所有登录授权成功的角色都可以进行调用所有接口，那么我们现在想要进行接口隔离限制，

    也就是说，虽然授权登录了，但是我这个接口是指定权限访问的。

    比如说：删除接口只能管理员角色操作，那么其他角色虽然授权登录了，但是没有权限调用删除接口。

    我们在原来的操作进行改造升级看一下。

    添加类

    新建一个AuthManagement文件夹，添加PolicyRequirement类和PolicyHandler类，

    PolicyRequirement类：

    1. using Microsoft.AspNetCore.Authorization;
    2. using Microsoft.AspNetCore.Http;
    3. using System;
    4. using System.Collections.Generic;
    5. using System.Linq;
    6. using System.Threading.Tasks;
    7.  
    8. namespace jwtWebAPI.AuthManagement
    9. {
    10.     /// <summary>
    11.     /// 权限承载实体
    12.     /// </summary>
    13.     public class PolicyRequirement : IAuthorizationRequirement
    14.     {
    15.         /// <summary>
    16.         /// 用户权限集合
    17.         /// </summary>
    18.         public List<UserPermission> UserPermissions { get; private set; }
    19.         /// <summary>
    20.         /// 无权限action
    21.         /// </summary>
    22.         public string DeniedAction { get; set; }
    23.         /// <summary>
    24.         /// 构造
    25.         /// </summary>
    26.         public PolicyRequirement()
    27.         {
    28.             //没有权限则跳转到这个路由
    29.             DeniedAction = new PathString("/api/nopermission");
    30.             //用户有权限访问的路由配置,当然可以从数据库获取
    31.             UserPermissions = new List<UserPermission> {
    32.                               new UserPermission {  Url="/api/values3", UserName="admin"},
    33.                           };
    34.         }
    35.     }
    36.  
    37.     /// <summary>
    38.     /// 用户权限承载实体
    39.     /// </summary>
    40.     public class UserPermission
    41.     {
    42.         /// <summary>
    43.         /// 用户名
    44.         /// </summary>
    45.         public string UserName { get; set; }
    46.         /// <summary>
    47.         /// 请求Url
    48.         /// </summary>
    49.         public string Url { get; set; }
    50.     }
    51. }

    PolicyHandler类(注意2.x和3.x的区别)

    1. using Microsoft.AspNetCore.Authorization;
    2. using Microsoft.AspNetCore.Http;
    3. using System;
    4. using System.Collections.Generic;
    5. using System.Linq;
    6. using System.Security.Claims;
    7. using System.Threading.Tasks;
    8.  
    9. namespace jwtWebAPI.AuthManagement
    10. {
    11.     public class PolicyHandler : AuthorizationHandler<PolicyRequirement>
    12.     {
    13.         private readonly IHttpContextAccessor _httpContextAccessor;
    14.         public PolicyHandler(IHttpContextAccessor httpContextAccessor)
    15.         {
    16.             _httpContextAccessor = httpContextAccessor;
    17.         }
    18.         protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, PolicyRequirement requirement)
    19.         {
    20.             //赋值用户权限
    21.             var userPermissions = requirement.UserPermissions;
    22.             var httpContext = _httpContextAccessor.HttpContext;
    23.  
    24.             //请求Url
    25.             var questUrl = httpContext.Request.Path.Value.ToUpperInvariant();
    26.             //是否经过验证
    27.             var isAuthenticated = httpContext.User.Identity.IsAuthenticated;
    28.             if (isAuthenticated)
    29.             {
    30.                 if (userPermissions.GroupBy(g => g.Url).Any(w => w.Key.ToUpperInvariant() == questUrl))
    31.                 {
    32.                     //用户名
    33.                     var userName = httpContext.User.Claims.SingleOrDefault(s => s.Type == ClaimTypes.NameIdentifier).Value;
    34.                     if (userPermissions.Any(w => w.UserName == userName && w.Url.ToUpperInvariant() == questUrl))
    35.                     {
    36.                         context.Succeed(requirement);
    37.                     }
    38.                     else
    39.                     {
    40.                         无权限跳转到拒绝页面
    41.                         //httpContext.Response.Redirect(requirement.DeniedAction);
    42.                         return Task.CompletedTask;
    43.                     }
    44.                 }
    45.                 else
    46.                 {
    47.                     context.Succeed(requirement);
    48.                 }
    49.             }
    50.             return Task.CompletedTask;
    51.         }
    52.     }
    53. }

    添加指定角色

    在 AuthController 控制器的GetToken授权加入自定义的参数，如下

    new Claim("Role", userName)  //这里是角色，我使用登录账号admin代替

     在 AuthController 控制器里面添加无权限访问的方法

    1. [AllowAnonymous]
    2. [HttpGet]
    3. [Route("api/nopermission")]
    4. public IActionResult NoPermission()
    5. {
    6.      return Forbid("No Permission!");
    7. }

    2023-12.19日补充

    在需要jwt验证控制器上添加 [ApiAuthorizeFilterAttribute] 特性

    新建ApiAuthorizeFilterAttribute 过滤器类 并继承ActionFilterAttribute类，每次请求都要经过，在OnActionExecuting验证token是否有效

    1. using HBAirWebAPI.Controllers;
    2. using Microsoft.AspNetCore.Authorization;
    3. using Microsoft.AspNetCore.Mvc;
    4. using Microsoft.AspNetCore.Mvc.Controllers;
    5. using Microsoft.AspNetCore.Mvc.Filters;
    6. using Microsoft.IdentityModel.Tokens;
    7. using Sys.Model;
    8. using System;
    9. using System.Collections.Generic;
    10. using System.IdentityModel.Tokens.Jwt;
    11. using System.Linq;
    12. using System.Security.Claims;
    13. using System.Threading.Tasks;
    14.  
    15. namespace HBAirWebAPI.Common
    16. {
    17.     public class ApiAuthorizeFilterAttribute : ActionFilterAttribute
    18.     {
    19.         public override void OnActionExecuting(ActionExecutingContext context)
    20.         {
    21.             Microsoft.AspNetCore.Http.IHeaderDictionary dic = context.HttpContext.Request.Headers;
    22.             var token = dic["Authorization"].ToString();
    23.             if (token == null)
    24.             {
    25.                 context.Result = new OkObjectResult(new { code = 401, messge = "用户权限已失效!" });
    26.             }
    27.             else
    28.             {
    29.                 //token = token.Replace("Bearer", "").Trim();string secretKey, string issuer, string audience
    30.                 //检验token  JWT 签名有效、时间有效.
    31.                 ClaimsPrincipal jwtUsr = ClaimsPrincipals.ValidateToken(token, ConfigurationManager.GetSection("Authentication:SecurityKey"), ConfigurationManager.GetSection("Authentication:Issure"), ConfigurationManager.GetSection("Authentication:Audience"));
    32.                 if (jwtUsr == null)
    33.                 {
    34.                     context.Result = new OkObjectResult(new { code = 401, messge = "用户权限已失效!" });
    35.                 }
    36.  
    37.             }
    38.             // 如果不是一个控制器方法则直接返回
    39.             if (!(context.ActionDescriptor is ControllerActionDescriptor action))
    40.             {
    41.                 return;
    42.             }
    43.  
    44.             var controllerActionDescriptor = context.ActionDescriptor as Microsoft.AspNetCore.Mvc.Controllers.ControllerActionDescriptor;
    45.             如果控制器上加了[AllowAnonymous]，就跳过权限检查
    46.             if (controllerActionDescriptor.ControllerTypeInfo.IsDefined(typeof(AllowAnonymousAttribute), true))
    47.             {
    48.                 return;
    49.             }
    50.             //如果方法上加了[AllowAnonymous]，就跳过权限检查
    51.             if (action.MethodInfo.GetCustomAttributes(typeof(AllowAnonymousAttribute), false).Any())
    52.                 return;
    53.  
    54.         }
    55.  
    56.  
    57.  
    58.     }
    59. }

    其中ClaimsPrincipals类代码如下：

    1.  
    2. using Microsoft.IdentityModel.Tokens;
    3. using System;
    4. using System.Collections.Generic;
    5. using System.IdentityModel.Tokens.Jwt;
    6. using System.Linq;
    7. using System.Security.Claims;
    8. using System.Text;
    9. using System.Threading.Tasks;
    10.  
    11. namespace HBAirWebAPI.Common
    12. {
    13.     public class ClaimsPrincipals
    14.     {
    15.         public static ClaimsPrincipal ValidateToken(string token, string secretKey, string issuer, string audience)
    16.         {
    17.             var validationParameters = new TokenValidationParameters
    18.             {
    19.                 ValidateIssuerSigningKey = true,
    20.                 IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(secretKey)),
    21.                 ValidateIssuer = true,
    22.                 ValidIssuer = issuer,
    23.                 ValidateAudience = true,
    24.                 ValidAudience = audience,
    25.                 ValidateLifetime = true,
    26.             };
    27.  
    28.             var handler = new JwtSecurityTokenHandler();
    29.             ClaimsPrincipal principal;
    30.             try
    31.             {
    32.                 principal = handler.ValidateToken(token, validationParameters, out _);
    33.  
    34.                 // You can access the claims of the token using:
    35.                 //principal.Claims
    36.  
    37.                 return principal;
    38.             }
    39.             catch (Exception ex)
    40.             {
    41.                 // Token validation failed
    42.                 return null;
    43.             }
    44.         }
    45.     }
    46. }

     ClaimsPrincipals.ValidateToken 方法验证是否有效。无效则不通过。不能调用接口。

    2023-12.19日补充 结束

    修改Startup配置

    在startup.cs的ConfigureServices 方法里面添加策略鉴权模式、添加JWT Scheme、注入授权Handler 

    修改后的文件如下

    1. using jwtWebAPI.AuthManagement;
    2. using Microsoft.AspNetCore.Authentication.JwtBearer;
    3. using Microsoft.AspNetCore.Authorization;
    4. using Microsoft.AspNetCore.Builder;
    5. using Microsoft.AspNetCore.Hosting;
    6. using Microsoft.AspNetCore.Http;
    7. using Microsoft.AspNetCore.HttpsPolicy;
    8. using Microsoft.AspNetCore.Mvc;
    9. using Microsoft.Extensions.Configuration;
    10. using Microsoft.Extensions.DependencyInjection;
    11. using Microsoft.Extensions.DependencyInjection.Extensions;
    12. using Microsoft.Extensions.Hosting;
    13. using Microsoft.Extensions.Logging;
    14. using Microsoft.IdentityModel.Tokens;
    15. using System;
    16. using System.Collections.Generic;
    17. using System.Linq;
    18. using System.Text;
    19. using System.Threading.Tasks;
    20.  
    21. namespace jwtWebAPI
    22. {
    23.     public class Startup
    24.     {
    25.         public Startup(IConfiguration configuration)
    26.         {
    27.             Configuration = configuration;
    28.         }
    29.  
    30.         public IConfiguration Configuration { get; }
    31.  
    32.         // This method gets called by the runtime. Use this method to add services to the container.
    33.         public void ConfigureServices(IServiceCollection services)
    34.         {
    35.             services
    36.                 //添加策略鉴权模式
    37.                 .AddAuthorization(options =>
    38.                 {
    39.                     options.AddPolicy("Permission", policy => policy.Requirements.Add(new PolicyRequirement()));
    40.                 })
    41.                 //添加JWT Scheme
    42.                 .AddAuthentication(s =>
    43.                 {
    44.                     s.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
    45.                     s.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
    46.                     s.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
    47.                 })
    48.                 //添加jwt验证：
    49.                 .AddJwtBearer(options => {
    50.                     options.TokenValidationParameters = new TokenValidationParameters
    51.                     {
    52.                         ValidateLifetime = true,//是否验证失效时间
    53.                         ClockSkew = TimeSpan.FromSeconds(30),  //时间偏移量（允许误差时间）
    54.                         ValidateAudience = true,//是否验证Audience（验证之前的token是否失效）
    55.                         //ValidAudience = Const.GetValidudience(),//Audience
    56.                         //这里采用动态验证的方式，在重新登陆时，刷新token，旧token就强制失效了
    57.                         AudienceValidator = (m, n, z) =>
    58.                         {
    59.                             return m != null && m.FirstOrDefault().Equals(Const.ValidAudience);
    60.                         },
    61.                         ValidateIssuer = true,//是否验证Issuer（颁发者）
    62.                         ValidAudience = Const.Domain,//Audience    【Const是新建的一个常量类】  接收者 
    63.                         ValidIssuer = Const.Domain,//Issuer，这两项和前面签发jwt的设置一致      颁发者
    64.                         ValidateIssuerSigningKey = true,//是否验证SecurityKey
    65.                         IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Const.SecurityKey))//拿到秘钥SecurityKey
    66.                     };
    67.                     options.Events = new JwtBearerEvents
    68.                     {
    69.                         OnAuthenticationFailed = context =>
    70.                         {
    71.                             //Token expired
    72.                             if (context.Exception.GetType() == typeof(SecurityTokenExpiredException))
    73.                             {
    74.                                 context.Response.Headers.Add("Token-Expired", "true");
    75.                             }
    76.                             return Task.CompletedTask;
    77.                         }
    78.                     };
    79.                 });
    80.  
    81.             //注入授权Handler
    82.             services.AddSingleton<IAuthorizationHandler, PolicyHandler>();
    83.             //注入获取HttpContext
    84.             services.TryAddSingleton<IHttpContextAccessor, HttpContextAccessor>();
    85.             services.AddControllers();
    86.         }
    87.  
    88.         // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
    89.         public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    90.         { 
    91.             //添加jwt验证
    92.             app.UseAuthentication();
    93.  
    94.             if (env.IsDevelopment())
    95.             {
    96.                 app.UseDeveloperExceptionPage();
    97.             }
    98.  
    99.             app.UseHttpsRedirection();
    100.  
    101.             app.UseRouting();
    102.  
    103.             app.UseAuthorization();
    104.  
    105.             app.UseEndpoints(endpoints =>
    106.             {
    107.                 endpoints.MapControllers();
    108.             });
    109.             
    110.         }
    111.     }
    112. }

    添加api访问的方法

    在 ValuesController控制器添加指定权限访问的方法，如下：

    1. /**
    2.         * 这个接口必须用admin
    3.         **/
    4.         [HttpGet]
    5.         [Route("api/values3")]
    6.         [Authorize("Permission")]
    7.         public ActionResult<IEnumerable<string>> values3()
    8.         {
    9.             //这是获取自定义参数的方法
    10.             var auth = HttpContext.AuthenticateAsync().Result.Principal.Claims;
    11.             var userName = auth.FirstOrDefault(t => t.Type.Equals(ClaimTypes.NameIdentifier))?.Value;
    12.             var role = auth.FirstOrDefault(t => t.Type.Equals("Role"))?.Value;
    13.  
    14.             return new string[] { "访问成功：这个接口有管理员权限才可以访问", $"userName={userName}", $"Role={role}" };
    15.         }

     不同权限测试访问

    我们同样的方法去模拟登录，https://localhost:44345/api/auth?userName=xiongze&pwd=123

    注意，账号先不用admin登录，然后用返回的token去请求我们刚刚添加的指定权限访问的接口，这个时候是没有权限访问的，因为这个是admin权限访问。

    我们同样的方法去模拟登录，https://localhost:44345/api/auth?userName=xiongze&pwd=123

    注意，账号先不用admin登录，然后用返回的token去请求我们刚刚添加的指定权限访问的接口，这个时候是没有权限访问的，因为这个是admin权限访问。

    我们同样的方法去模拟登录，https://localhost:44345/api/auth?userName=admin&pwd=123

    访问成功。

    完结。。。

  • 相关阅读:
    吴恩达2022机器学习专项课程C2W2：实验SoftMax
    RocketMQ的架构设计
    【二分查找】leetcode 240. 搜索二维矩阵 II
    SQL获取当前年月的每一天
    MySQL客户端与服务端建立连接抓包分析
    oradebug current_sql
    超实用！产品经理如何提高自己的工作效率？
    第一章《初学者问题大集合》第6节：IntelliJ IDEA的下载与安装
    Angular 怎么封装基础组件？
    LeetCode - 102. 二叉树的层序遍历；110. 平衡二叉树；098. 验证二叉搜索树
  • 原文地址：https://blog.csdn.net/qq_26695613/article/details/134051442