ASP.NET Core教程-Configuration（配置）-JWT

2022-11-13 11:47 762人阅读评论(0)

更新记录
转载请注明出处：
2022年11月10日发布。
2022年11月8日从笔记迁移到博客。

JWT 基础

JWT 是什么(What is JWT)

JSON Web Token(JWT)是目前最流行的跨域身份验证解决方案。JWT的官网地址：https://jwt.io/。通俗地来讲，JWT是能代表用户身份的令牌，可以使用JWT令牌在api接口中校验用户的身份以确认用户是否有访问api的权限。JWT中包含了身份认证必须的参数以及用户自定义的参数，JWT可以使用秘密(使用HMAC算法)或使用RSA或ECDSA的公钥/私钥对进行签名。JWT stands for JSON Web Token. This token is used to create an access token for an application. JWT is an open standard (RFC 7519) for securely transmitting information between parties as a JSON object. The purpose of using JWT is not to hide data but to ensure the user’s authenticity that is requesting the data. JWT is signed and encoded, not encrypted.

JWT 作用、适合场景

授权：这是使用JWT的最常见方案。一旦用户登录，每个后续请求将包括JWT，允许用户访问该令牌允许的路由，服务和资源。Single Sign On是一种现在广泛使用JWT的功能，因为它的开销很小，并且能够在不同的域中轻松使用。
信息交换：JSON Web令牌是在各方之间安全传输信息的好方法。因为JWT可以签名 - 例如，使用公钥/私钥对 - 您可以确定发件人是他们所说的人。此外，由于使用标头和有效负载计算签名，您还可以验证内容是否未被篡改。

JWT 与传统 Session 身份校验对比

传统 Session 身份验证扩展性(scaling)不好。单机当然没有问题，如果是服务器集群，或者是跨域的服务导向架构，就要求 session 数据共享，每台服务器都能够读取 session。如果session存储的节点挂了，那么整个服务都会瘫痪，体验相当不好，风险也很高。

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

JWT 令牌结构(JWT Structure)

在紧凑的形式中，JSON Web Tokens由dot(.)分隔的三个部分组成，它们是：

Header　头
Payload　有效载荷
Signature　签名

That is a header, payload and a signature . This 3 parts is separated by a columns.

HEADER.PAYLOAD.SIGNATURE

Header 部分
Header 部分是一个JSON对象，主要包含 token 的元数据，标头通常由两部分组成：令牌的类型，即JWT，以及正在使用的签名算法。例如：HMAC SHA256或RSA。实例：

Payload 部分
Payload 部分也是一个 JSON 对象，用来存放实际需要传递的数据。主要包含声明信息(Claims)，是整个 JWT 中的核心数据。这些声明数据是key-value对的数据结构。通常如用户名，角色等信息，过期日期等，注意：数据是未加密的，不建议存放敏感信息。

Claims的实体一般包含用户和一些元数据，这些claims分成三种类型：

reserved claims：预定义的一些声明，并不是强制的但是推荐，它们包括 iss (issuer), exp (expiration time), sub (subject),aud(audience) 等(这里都使用三个字母的原因是保证 JWT 的紧凑)。
public claims: 公有声明，这个部分可以随便定义，但是要注意和 IANA JSON Web Token 冲突。
private claims: 私有声明，这个部分是共享被认定信息中自定义部分。

Payload 实例：

{"name":"admin","exp":1578645536,"iss":"webapi.cn","aud":"WebApi"}

JWT 规定了7个官方标准字段：


   
    
     
      
     
     
      
       iss (issuer)：签发人
      
     
    
     
      
     
     
      
       exp (expiration time)：过期时间
      
     
    
     
      
     
     
      
       sub (subject)：主题
      
     
    
     
      
     
     
      
       aud (audience)：受众
      
     
    
     
      
     
     
      
       nbf (Not Before)：生效时间
      
     
    
     
      
     
     
      
       iat (Issued At)：签发时间
      
     
    
     
      
     
     
      
       jti (JWT ID)：编号

除了官方字段，还可以在这个部分定义私有字段：


   
    
     
      
     
     
      
       {
      
     
    
     
      
     
     
      
         "sub": "1234567890",
      
     
    
     
      
     
     
      
         "name": "John Doe",
      
     
    
     
      
     
     
      
         "admin": true
      
     
    
     
      
     
     
      
       }

Signature 部分
Signature 部分是对 Header 和 Payload 两部分的签名，防止数据篡改。签名用于验证消息在此过程中未被更改，并且，在使用私钥签名的令牌的情况下，它还可以验证JWT的发件人是否是它所声称的人。生成签名也很简单，首先，需要指定一个密钥(Secret)。这个密钥只有服务器才知道，不能泄露给用户。然后，使用 Header 里面指定的签名算法(默认是 HMAC SHA256)，按照下面的公式产生签名。加密过程如下。


   
    
     
      
     
     
      
       HMACSHA256(
      
     
    
     
      
     
     
      
         base64UrlEncode(Header) + "." +
      
     
    
     
      
     
     
      
         base64UrlEncode(Payload),
      
     
    
     
      
     
     
      
         Secret)

签名生成后，使用 Base64进行编码，使用.号将三个部分连接起来即可。输出是三个由点分隔的Base64-URL字符串，可以在HTML和HTTP环境中轻松传递。

Base64(Header).Base64(Payload).Signature

JSON Web令牌如何工作？

在身份验证中，当用户使用其凭据成功登录时，将返回JSON Web令牌。由于令牌是凭证，因此必须非常小心以防止出现安全问题。一般情况下，不应该将令牌保留的时间超过要求。每当用户想要访问受保护的路由或资源时，用户代理应该使用承载模式发送 JWT，通常在 Authorization标头中。标题的内容应如下所示：

Authorization: Bearer <token>

在某些情况下，这可以是无状态授权机制。服务器的受保护路由将检查Authorization标头中的有效JWT ，如果存在，则允许用户访问受保护资源。如果JWT包含必要的数据，则可以减少查询数据库以进行某些操作的需要，尽管可能并非总是如此。如果在标Authorization头中发送令牌，则跨域资源共享(CORS)将不会成为问题，因为它不使用cookie。

下图显示了如何获取JWT并用于访问API或资源：

应用程序向授权服务器请求授权
校验用户身份，校验成功，返回token
应用程序使用访问令牌访问受保护的资源

认证(authentication)与授权(authorization)

认证(authentication)与授权(authorization)，它们经常在一起工作，所以有时候会分不清楚。并且这两个英文单词长得也像兄弟。举例来说，我刷门禁卡进入公司，门禁【认证】了我是这里的员工，可以进入；但进入公司以后，我并不是所有房间都可以进，比如“机房重地，闲人免进”，我能进入哪些房间，需要公司的【授权】。这就是认证和授权的区别。

ASP.NET Core 配置 JWT

JWT 认证授权流程

本质就是将用户的 Id 或者唯一编号放在 Token 中，每次请求都会发送到服务器端(消费端)。服务器端拿到 Token 解析后，拿到用户的唯一 Id，然后用认证功能去进行对该 Id 处理，比如获得该 Id 对应的用户是否有指定 Role 的权限、单独的权限等。如果有权限，则放行该请求，否则拒绝该请求。

需要用到的包

Microsoft.AspNetCore.Authentication.JwtBearer
官方地址：https://www.nuget.org/packages/Microsoft.AspNetCore.Authentication.JwtBearer/

安装包(Install JWT Packages)


   
    
     
      
     
     
      
       dotnet add package Microsoft.AspNetCore.Authentication.JwtBearer
      
     
    
     
      
     
     
      
       dotnet add package System.IdentityModel.Tokens.Jwt

建立 Authorization 文件夹存放认证相关的特性

创建 AllowAnonymousAttribute.cs 文件

自定义 [AllowAnonymous] 属性用于允许匿名访问使用 [Authorize] 属性修饰的控制器的指定操作方法。它用于用户控制器以允许匿名访问注册和登录操作方法。如果操作方法使用 [AllowAnonymous] 修饰，则会跳过授权认证。


   
    
     
      
     
     
      
       using System;
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
      
       namespace PandaCMS.Authorization
      
     
    
     
      
     
     
      
       {
      
     
    
     
      
     
     
          
       /// <summary>
      
     
    
     
      
     
     
          
       /// 允许匿名访问
      
     
    
     
      
     
     
          
       /// </summary>
      
     
    
     
      
     
     
      
           [AttributeUsage(AttributeTargets.Method)]
      
     
    
     
      
     
     
      
           public 
       class AllowAnonymousAttribute : Attribute
      
     
    
     
      
     
     
      
           { }
      
     
    
     
      
     
     
      
       }

创建 AuthorizeAttribute.cs 文件

自定义 [Authorize] 属性用于限制对控制器或指定操作方法的访问。只有经过授权的请求才能访问使用 [Authorize] 属性修饰的操作方法。当控制器用 [Authorize] 属性修饰时，所有操作方法都仅限于授权请求，除了用自定义 [AllowAnonymous] 属性修饰的方法。

授权由 OnAuthorization 方法执行，该方法检测的内容是可以自定义的，通过则可以访问控制器和动作，不通过则返回 401 Unauthorized 响应。下面代码中主要验证了从JwtMiddleware中传来的context.HttpContext.Items["User"]是否存在，用户是否有访问指定URL的权限。


   
    
     
      
     
     
      
       using Microsoft.AspNetCore.Http;
      
     
    
     
      
     
     
      
       using Microsoft.AspNetCore.Mvc;
      
     
    
     
      
     
     
      
       using Microsoft.AspNetCore.Mvc.Filters;
      
     
    
     
      
     
     
      
       using System;
      
     
    
     
      
     
     
      
       using System.Linq;
      
     
    
     
      
     
     
      
       using PandaCMS.Data.Models.UserManagement;
      
     
    
     
      
     
     
      
       using PandaCMS.Authorization;
      
     
    
     
      
     
     
      
       using PandaCMS.ServiceInterface.UserManagement;
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
      
       namespace PandaCMS.Authorization
      
     
    
     
      
     
     
      
       {
      
     
    
     
      
     
     
      
           [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
      
     
    
     
      
     
     
      
           public 
       class AuthorizeAttribute : Attribute, IAuthorizationFilter
      
     
    
     
      
     
     
      
           {
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 开始验证
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
              
       /// <param name="context"></param>
      
     
    
     
      
     
     
      
               public 
       void 
       OnAuthorization
       (AuthorizationFilterContext context)
      
     
    
     
      
     
     
      
               {
      
     
    
     
      
     
     
                  
       //如果有[AllowAnonymous]修饰，则跳过验证
      
     
    
     
      
     
     
      
                   var allowAnonymous = context.ActionDescriptor.EndpointMetadata.OfType<AllowAnonymousAttribute>().Any();
      
     
    
     
      
     
     
                  
       if (allowAnonymous)
      
     
    
     
      
     
     
      
                   {
      
     
    
     
      
     
     
                      
       return;
      
     
    
     
      
     
     
      
                   }
      
     
    
     
      
     
     
                      
      
     
    
     
      
     
     
                  
       //获得在JWT中间件中设置的UserId值
      
     
    
     
      
     
     
      
                   object userId = context.HttpContext.Items[
       "UserId"];
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
                  
       //如果UserId值不存在，就返回权限不足
      
     
    
     
      
     
     
                  
       if (userId == null)
      
     
    
     
      
     
     
      
                   {
      
     
    
     
      
     
     
      
                       context.Result = new JsonResult(new { message = 
       "Unauthorized" }) { StatusCode = StatusCodes.Status401Unauthorized };
      
     
    
     
      
     
     
                      
       return;
      
     
    
     
      
     
     
      
                   }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
                  
       //用户请求的Url
      
     
    
     
      
     
     
      
                   var requestUrl = context.HttpContext.Request.Path.Value;
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
                  
       //获得用户服务
      
     
    
     
      
     
     
      
                   IUserService userService = (IUserService)context.HttpContext.RequestServices.GetService(typeof(IUserService));
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
                  
       //权限验证
      
     
    
     
      
     
     
                  
       bool havePermission = userService.CheckUserHaveApiPermission(Guid.Parse(userId.ToString()), requestUrl);
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
                  
       if (!havePermission)
      
     
    
     
      
     
     
      
                   {
      
     
    
     
      
     
     
                      
       //无权限，就返回权限不足
      
     
    
     
      
     
     
      
                       context.Result = new JsonResult(new { message = 
       "Unauthorized" }) { StatusCode = StatusCodes.Status401Unauthorized };
      
     
    
     
      
     
     
                      
       return;
      
     
    
     
      
     
     
      
                   }
      
     
    
     
      
     
     
      
               }
      
     
    
     
      
     
     
      
           }
      
     
    
     
      
     
     
      
       }

建立Middleware文件夹存放认证中间件

创建JwtMiddleware.cs 文件

自定义 JWT 中间件从请求 Authorization 标头(如果有)中提取 JWT 令牌，并使用 jwtService.ValidateToken(token) 方法对其进行验证。如果验证成功，则返回令牌中的用户 ID，并将经过身份验证的用户对象附加到 HttpContext.Items 集合以使其可在当前请求的范围内访问。如果令牌验证失败或没有令牌，则仅允许请求访问公共(匿名)路由，因为没有附加到 HTTP 上下文的经过身份验证的用户对象。检查用户对象是否附加的授权逻辑位于自定义授权属性中，如果授权失败则返回 401 Unauthorized 响应。


   
    
     
      
     
     
      
       using Microsoft.AspNetCore.Http;
      
     
    
     
      
     
     
      
       using Microsoft.Extensions.Options;
      
     
    
     
      
     
     
      
       using System.Linq;
      
     
    
     
      
     
     
      
       using System.Threading.Tasks;
      
     
    
     
      
     
     
      
       using PandaCMS.ServiceInterface.UserManagement;
      
     
    
     
      
     
     
      
       using PandaCMS.Service.UserManagement;
      
     
    
     
      
     
     
      
       using PandaCMS.ServiceInterface.AuthorizationManagement;
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
      
       namespace PandaCMS.Authorization
      
     
    
     
      
     
     
      
       {
      
     
    
     
      
     
     
          
       /// <summary>
      
     
    
     
      
     
     
          
       /// JWT权限验证中间件
      
     
    
     
      
     
     
          
       /// </summary>
      
     
    
     
      
     
     
      
           public 
       class JwtMiddleware
      
     
    
     
      
     
     
      
           {
      
     
    
     
      
     
     
      
               private readonly RequestDelegate _next;
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
      
               public 
       JwtMiddleware
       (RequestDelegate next)
      
     
    
     
      
     
     
      
               {
      
     
    
     
      
     
     
      
                   _next = next;
      
     
    
     
      
     
     
      
               }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 执行中间件
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
              
       /// <param name="context"></param>
      
     
    
     
      
     
     
              
       /// <param name="userService"></param>
      
     
    
     
      
     
     
              
       /// <param name="jwtService"></param>
      
     
    
     
      
     
     
              
       /// <returns></returns>
      
     
    
     
      
     
     
      
               public async Task 
       Invoke
       (HttpContext context, IUserService userService, IJwtService jwtService)
      
     
    
     
      
     
     
      
               {
      
     
    
     
      
     
     
                  
       //从HTTP Header中提取Authorization参数(Token)
      
     
    
     
      
     
     
                  
       string token = context.Request.Headers[
       "Authorization"].FirstOrDefault()?.Split(
       " ").Last() ?? 
       "";
      
     
    
     
      
     
     
                  
      
     
    
     
      
     
     
                  
       //如果Token不存在，则直接跳过
      
     
    
     
      
     
     
                  
       if(
       string.IsNullOrWhiteSpace(token))
      
     
    
     
      
     
     
      
                   {
      
     
    
     
      
     
     
      
                       await _next(context);
      
     
    
     
      
     
     
      
                   }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
                  
       //先检查服务器段是否已经废除了该Token
      
     
    
     
      
     
     
                  
       //如果废除了，就直接跳过
      
     
    
     
      
     
     
                  
       if (jwtService.TokenIsBeInvalidationByServer(token))
      
     
    
     
      
     
     
      
                   {
      
     
    
     
      
     
     
      
                       await _next(context);
      
     
    
     
      
     
     
      
                   }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
                  
       //验证Token
      
     
    
     
      
     
     
                  
       if (!jwtService.ValidateToken(token))
      
     
    
     
      
     
     
      
                   {
      
     
    
     
      
     
     
      
                       await _next(context);
      
     
    
     
      
     
     
      
                   }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
                  
       //验证成功，把用户Id放在HTTP上下文对象中
      
     
    
     
      
     
     
      
                   context.Items[
       "UserId"] = jwtService.GetUserId();
      
     
    
     
      
     
     
      
                   await _next(context);
      
     
    
     
      
     
     
      
               }
      
     
    
     
      
     
     
      
           }
      
     
    
     
      
     
     
      
       }

建立Services 文件夹存放用户和认证相关的服务

创建 JwtService 服务

JwtService 类包含用于生成和验证 JWT 令牌的方法。GenerateToken() 方法生成一个 JWT 令牌。ValidateToken() 方法用于验证 JWT


   
    
     
      
     
     
      
       using Microsoft.Extensions.Options;
      
     
    
     
      
     
     
      
       using Microsoft.IdentityModel.Tokens;
      
     
    
     
      
     
     
      
       using System;
      
     
    
     
      
     
     
      
       using System.IdentityModel.Tokens.Jwt;
      
     
    
     
      
     
     
      
       using System.Linq;
      
     
    
     
      
     
     
      
       using System.Security.Claims;
      
     
    
     
      
     
     
      
       using System.Text;
      
     
    
     
      
     
     
      
       using PandaCMS.Data.Models.UserManagement;
      
     
    
     
      
     
     
      
       using PandaCMS.ServiceInterface.AuthorizationManagement;
      
     
    
     
      
     
     
      
       using Microsoft.Extensions.Configuration;
      
     
    
     
      
     
     
      
       using PandaCMS.Data.DbContexts;
      
     
    
     
      
     
     
      
       using PandaCMS.Data.Models.AuthorizationManagement;
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
      
       namespace PandaCMS.Service.AuthorizationManagement
      
     
    
     
      
     
     
      
       {
      
     
    
     
      
     
     
          
       /// <summary>
      
     
    
     
      
     
     
          
       /// JWT认证服务
      
     
    
     
      
     
     
          
       /// </summary>
      
     
    
     
      
     
     
      
           public 
       class JwtService : IJwtService
      
     
    
     
      
     
     
      
           {
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 配置对象(注入)
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
      
               private IConfiguration Configuration { get; 
       set; }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 数据库上下文(注入)
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
      
               private PandaCMSDbContext PandaCMSDbContext  { get; 
       set; }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 用户Id
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
      
               public Guid UserId { get; private 
       set; }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// JWT Token字符串
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
      
               public 
       string JwtToken { get; private 
       set; }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 构造函数
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
              
       /// <param name="configuration"></param>
      
     
    
     
      
     
     
      
               public 
       JwtService
       (IConfiguration configuration, PandaCMSDbContext pandaCMSDbContext)
      
     
    
     
      
     
     
      
               {
      
     
    
     
      
     
     
                  
       //初始化
      
     
    
     
      
     
     
      
                   this.Configuration = configuration;
      
     
    
     
      
     
     
      
                   this.PandaCMSDbContext = pandaCMSDbContext;
      
     
    
     
      
     
     
      
               }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 生成Token
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
              
       /// <param name="userId"></param>
      
     
    
     
      
     
     
              
       /// <returns></returns>
      
     
    
     
      
     
     
      
               public 
       string 
       GenerateToken
       (Guid userId)
      
     
    
     
      
     
     
      
               {
      
     
    
     
      
     
     
                  
       // generate token that is valid for 7 days
      
     
    
     
      
     
     
      
                   var tokenHandler = new JwtSecurityTokenHandler();
      
     
    
     
      
     
     
                  
       //JWT key
      
     
    
     
      
     
     
      
                   var key = Encoding.ASCII.GetBytes(this.Configuration[
       "Authorization:JwtAuth:Key"]);
      
     
    
     
      
     
     
                  
      
     
    
     
      
     
     
                  
       //Token 描述
      
     
    
     
      
     
     
      
                   var tokenDescriptor = new SecurityTokenDescriptor
      
     
    
     
      
     
     
      
                   {
      
     
    
     
      
     
     
                      
       //Token负载
      
     
    
     
      
     
     
      
                       Subject = new ClaimsIdentity(new[] { 
      
     
    
     
      
     
     
                          
       //用户Id
      
     
    
     
      
     
     
      
                           new Claim(
       "UserId", userId.ToString()),
      
     
    
     
      
     
     
      
                       }),
      
     
    
     
      
     
     
                      
       //发布人
      
     
    
     
      
     
     
      
                       Issuer = this.Configuration[
       "Authorization:JwtAuth:Issuer"],
      
     
    
     
      
     
     
                      
       //受众人
      
     
    
     
      
     
     
      
                       Audience = this.Configuration[
       "Authorization:JwtAuth:Audience"],
      
     
    
     
      
     
     
                      
       //过期时间
      
     
    
     
      
     
     
      
                       Expires = DateTime.UtcNow.AddDays(
       int.Parse(this.Configuration[
       "Authorization:JwtAuth:ExpiresDay"])),
      
     
    
     
      
     
     
                      
       //签名
      
     
    
     
      
     
     
      
                       SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
      
     
    
     
      
     
     
      
                   };
      
     
    
     
      
     
     
                  
      
     
    
     
      
     
     
                  
       //创建Token字符串
      
     
    
     
      
     
     
      
                   var token = tokenHandler.CreateToken(tokenDescriptor);
      
     
    
     
      
     
     
                  
       return tokenHandler.WriteToken(token);
      
     
    
     
      
     
     
      
               }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 验证Token
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
              
       /// <param name="token"></param>
      
     
    
     
      
     
     
              
       /// <returns></returns>
      
     
    
     
      
     
     
      
               public 
       bool 
       ValidateToken
       (string token)
      
     
    
     
      
     
     
      
               {
      
     
    
     
      
     
     
                  
       //如果 Token 是空的直接返回
      
     
    
     
      
     
     
                  
       if (token == null)
      
     
    
     
      
     
     
      
                   {
      
     
    
     
      
     
     
                      
       return 
       false;
      
     
    
     
      
     
     
      
                   }
      
     
    
     
      
     
     
                  
      
     
    
     
      
     
     
                  
       //验证 Token
      
     
    
     
      
     
     
      
                   var tokenHandler = new JwtSecurityTokenHandler();
      
     
    
     
      
     
     
      
                   var key = Encoding.ASCII.GetBytes(this.Configuration[
       "Authorization:JwtAuth:Key"]);
      
     
    
     
      
     
     
      
                   try
      
     
    
     
      
     
     
      
                   {
      
     
    
     
      
     
     
      
                       tokenHandler.ValidateToken(token, new TokenValidationParameters
      
     
    
     
      
     
     
      
                       {
      
     
    
     
      
     
     
      
                           ValidateIssuerSigningKey = 
       true,
      
     
    
     
      
     
     
      
                           IssuerSigningKey = new SymmetricSecurityKey(key),
      
     
    
     
      
     
     
                          
       //验证签发者
      
     
    
     
      
     
     
      
                           ValidateIssuer = 
       true,
      
     
    
     
      
     
     
                          
       //验证使用者
      
     
    
     
      
     
     
      
                           ValidateAudience = 
       true,
      
     
    
     
      
     
     
                          
       //签发者信息
      
     
    
     
      
     
     
      
                           ValidIssuer = this.Configuration[
       "Authorization:JwtAuth:Issuer"],
      
     
    
     
      
     
     
                          
       //使用者信息
      
     
    
     
      
     
     
      
                           ValidAudience = this.Configuration[
       "Authorization:JwtAuth:Audience"],
      
     
    
     
      
     
     
                          
       //验证Token生命周期
      
     
    
     
      
     
     
      
                           ValidateLifetime = 
       true,
      
     
    
     
      
     
     
                          
       // set clockskew to zero so tokens expire exactly at token expiration time (instead of 5 minutes later)
      
     
    
     
      
     
     
      
                           ClockSkew = TimeSpan.Zero
      
     
    
     
      
     
     
      
                       }, out SecurityToken validatedToken);
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
                      
       //转成Token对象
      
     
    
     
      
     
     
      
                       var jwtToken = (JwtSecurityToken)validatedToken;
      
     
    
     
      
     
     
                      
       //获得Token中的用户Id
      
     
    
     
      
     
     
      
                       this.UserId = Guid.Parse(jwtToken.Claims.First(x => x.Type == 
       "UserId").Value);
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
                      
       //设置Token字符串
      
     
    
     
      
     
     
      
                       this.JwtToken = token;
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
                      
       // return user id from JWT token if validation successful
      
     
    
     
      
     
     
                      
       return 
       true;
      
     
    
     
      
     
     
      
                   }
      
     
    
     
      
     
     
      
                   catch
      
     
    
     
      
     
     
      
                   {
      
     
    
     
      
     
     
                      
       // return false if validation fails
      
     
    
     
      
     
     
                      
       return 
       false;
      
     
    
     
      
     
     
      
                   }
      
     
    
     
      
     
     
      
               }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 获得用户Id
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
              
       /// <returns></returns>
      
     
    
     
      
     
     
      
               public Guid 
       GetUserId
       ()
      
     
    
     
      
     
     
      
               {
      
     
    
     
      
     
     
                  
       return this.UserId;
      
     
    
     
      
     
     
      
               }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 获得Token字符串
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
              
       /// <returns></returns>
      
     
    
     
      
     
     
      
               public 
       string 
       GetToken
       ()
      
     
    
     
      
     
     
      
               {
      
     
    
     
      
     
     
                  
       return this.JwtToken;
      
     
    
     
      
     
     
      
               }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 使指定的Token失效
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
              
       /// <param name="jwtToken">Token字符串</param>
      
     
    
     
      
     
     
              
       /// <returns></returns>
      
     
    
     
      
     
     
      
               public async Task<
       bool> 
       InvalidationUserTokenByServer
       (string jwtToken)
      
     
    
     
      
     
     
      
               {
      
     
    
     
      
     
     
                  
       //把Token存入数据库，表示失效
      
     
    
     
      
     
     
      
                   this.PandaCMSDbContext.JwtTokenInvaildModels
      
     
    
     
      
     
     
      
                                       .Add(new JwtTokenInvaildModel() { 
      
     
    
     
      
     
     
      
                                           InvalidToken = jwtToken, Id = new Guid() 
      
     
    
     
      
     
     
      
                                       });
      
     
    
     
      
     
     
                  
       return await this.PandaCMSDbContext.SaveChangesAsync() > 
       0;
      
     
    
     
      
     
     
      
               }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 检测Token是否已经被废除了
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
              
       /// <param name="jwtToken">Token字符串</param>
      
     
    
     
      
     
     
              
       /// <returns></returns>
      
     
    
     
      
     
     
      
               public 
       bool 
       TokenIsBeInvalidationByServer
       (string jwtToken)
      
     
    
     
      
     
     
      
               {
      
     
    
     
      
     
     
                  
       //检测是否在失效的模型中存在
      
     
    
     
      
     
     
                  
       bool isInvalid = this.PandaCMSDbContext.JwtTokenInvaildModels
      
     
    
     
      
     
     
      
                                                           .Where(item => item.InvalidToken == jwtToken)
      
     
    
     
      
     
     
      
                                                           .Count() > 
       0;
      
     
    
     
      
     
     
                  
       return isInvalid;
      
     
    
     
      
     
     
      
               }
      
     
    
     
      
     
     
      
           }
      
     
    
     
      
     
     
      
       }

创建 UserService 服务


   
    
     
      
     
     
      
       using PandaCMS.Data.Models.UserManagement;
      
     
    
     
      
     
     
      
       using PandaCMS.ServiceInterface.UserManagement;
      
     
    
     
      
     
     
      
       using PandaCMS.Data.Models.AuthorizationManagement;
      
     
    
     
      
     
     
      
       using Microsoft.EntityFrameworkCore;
      
     
    
     
      
     
     
      
       using Microsoft.EntityFrameworkCore.SqlServer;
      
     
    
     
      
     
     
      
       using PandaCMS.Data.DbContexts;
      
     
    
     
      
     
     
      
       using PandaCMS.Data.Models.UserManagement;
      
     
    
     
      
     
     
      
       using PandaCMS.ServiceInterface.AuthorizationManagement;
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
      
       namespace PandaCMS.Service.UserManagement
      
     
    
     
      
     
     
      
       {
      
     
    
     
      
     
     
          
       /// <summary>
      
     
    
     
      
     
     
          
       /// 用户服务
      
     
    
     
      
     
     
          
       /// </summary>
      
     
    
     
      
     
     
      
           public 
       class UserService: IUserService
      
     
    
     
      
     
     
      
           {
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 数据库上下文(注入)
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
      
               public PandaCMSDbContext PandaCMSDbContext { get; 
       set; }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 构造函数
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
              
       /// <param name="pandaCMSDbContext"></param>
      
     
    
     
      
     
     
      
               public 
       UserService
       (PandaCMSDbContext pandaCMSDbContext)
      
     
    
     
      
     
     
      
               {
      
     
    
     
      
     
     
      
                   this.PandaCMSDbContext = pandaCMSDbContext;
      
     
    
     
      
     
     
      
               }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 增加用户
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
              
       /// <param name="user">用户模型</param>
      
     
    
     
      
     
     
              
       /// <returns></returns>
      
     
    
     
      
     
     
      
               public 
       bool 
       AddUser
       (UserModel user)
      
     
    
     
      
     
     
      
               {
      
     
    
     
      
     
     
                  
       return 
       true;
      
     
    
     
      
     
     
      
               }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 删除用户
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
              
       /// <param name="userId">用户Id</param>
      
     
    
     
      
     
     
              
       /// <returns></returns>
      
     
    
     
      
     
     
      
               public 
       bool 
       DeleteUser
       (Guid userId)
      
     
    
     
      
     
     
      
               {
      
     
    
     
      
     
     
                  
       return 
       true;
      
     
    
     
      
     
     
      
               }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 更新用户信息
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
              
       /// <param name="userId">用户Id</param>
      
     
    
     
      
     
     
              
       /// <param name="userModel">用户信息</param>
      
     
    
     
      
     
     
              
       /// <returns></returns>
      
     
    
     
      
     
     
      
               public 
       bool 
       UpdateUserInfo
       (Guid userId, UserModel userModel)
      
     
    
     
      
     
     
      
               {
      
     
    
     
      
     
     
                  
       return 
       true;
      
     
    
     
      
     
     
      
               }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 重置密码
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
              
       /// <param name="userId">用户Id</param>
      
     
    
     
      
     
     
              
       /// <param name="oldHashedPassword">旧密码(已哈希)</param>
      
     
    
     
      
     
     
              
       /// <param name="newHashedPassword">新密码(已哈希)</param>
      
     
    
     
      
     
     
              
       /// <returns></returns>
      
     
    
     
      
     
     
      
               public 
       bool 
       ResetPassword
       (Guid userId, string oldHashedPassword, string newHashedPassword)
      
     
    
     
      
     
     
      
               {
      
     
    
     
      
     
     
                  
       return 
       true;
      
     
    
     
      
     
     
      
               }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 获得所有用户
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
              
       /// <returns></returns>
      
     
    
     
      
     
     
      
               public IEnumerable<UserModel> 
       GetAllUser
       ()
      
     
    
     
      
     
     
      
               {
      
     
    
     
      
     
     
                  
       return new List<UserModel>();
      
     
    
     
      
     
     
      
               }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 获得用户信息通过用户Id
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
              
       /// <param name="userId">用户Id</param>
      
     
    
     
      
     
     
              
       /// <returns></returns>
      
     
    
     
      
     
     
      
               public UserModel 
       GetUserById
       (Guid userId)
      
     
    
     
      
     
     
      
               {
      
     
    
     
      
     
     
                  
      
     
    
     
      
     
     
                  
       return new UserModel();
      
     
    
     
      
     
     
      
               }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 获得用户的所有API权限
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
              
       /// <param name="userId">用户Id</param>
      
     
    
     
      
     
     
              
       /// <returns></returns>
      
     
    
     
      
     
     
      
               public IEnumerable<ApiPermissionItemModel> 
       GetUserAllApiPermission
       (Guid userId)
      
     
    
     
      
     
     
      
               {
      
     
    
     
      
     
     
                  
       return new List<ApiPermissionItemModel>();
      
     
    
     
      
     
     
      
               }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 获得用户的Id，通过用户的账号
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
              
       /// <param name="account">用户的账号</param>
      
     
    
     
      
     
     
              
       /// <returns></returns>
      
     
    
     
      
     
     
      
               public async Task<Guid> 
       GetUserId
       (string account)
      
     
    
     
      
     
     
      
               {
      
     
    
     
      
     
     
      
                    Guid userId = await this.PandaCMSDbContext.UserModels.Where(item => item.Account == account)
      
     
    
     
      
     
     
      
                                               .Select(item=>item.Id)
      
     
    
     
      
     
     
      
                                               .FirstOrDefaultAsync();
      
     
    
     
      
     
     
                  
       return userId;
      
     
    
     
      
     
     
      
               }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 验证用户的账号和密码
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
              
       /// <param name="account">账号</param>
      
     
    
     
      
     
     
              
       /// <param name="passwordHashed">密码(Hashed)</param>
      
     
    
     
      
     
     
              
       /// <returns></returns>
      
     
    
     
      
     
     
      
               public 
       bool 
       CheckUserLogin
       (string account, string passwordHashed)
      
     
    
     
      
     
     
      
               {
      
     
    
     
      
     
     
                  
       bool isExists = this.PandaCMSDbContext.UserModels
      
     
    
     
      
     
     
      
                                           .Where(item => item.Account == account && item.PasswordHashed == passwordHashed)
      
     
    
     
      
     
     
      
                                           .Count() > 
       0;
      
     
    
     
      
     
     
                  
       return isExists;
      
     
    
     
      
     
     
      
               }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 检测用户是否有指定的API URL权限
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
              
       /// <param name="UserId">用户Id</param>
      
     
    
     
      
     
     
              
       /// <param name="apiUrl">API URL字符串</param>
      
     
    
     
      
     
     
              
       /// <returns></returns>
      
     
    
     
      
     
     
      
               public 
       bool 
       CheckUserHaveApiPermission
       (Guid UserId, string apiUrl)
      
     
    
     
      
     
     
      
               {
      
     
    
     
      
     
     
      
                   var apiPermissionItemModels = this.PandaCMSDbContext.ApiPermissionItemModels.FromSqlRaw(
      
     
    
     
      
     
     
      
                       $@
       "SELECT [Id],[Url]
      
     
    
     
      
     
     
      
        FROM [ApiPermissionItemModels]
      
     
    
     
      
     
     
      
        WHERE [Id] IN (
      
     
    
     
      
     
     
      
        SELECT
      
     
    
     
      
     
     
      
        [ApiPermissionItemModelsId] 
      
     
    
     
      
     
     
      
        FROM
      
     
    
     
      
     
     
      
        [ApiPermissionGroupModelApiPermissionItemModel] 
      
     
    
     
      
     
     
      
        WHERE
      
     
    
     
      
     
     
      
        [ApiPermissionGroupModelsId] IN ( 
      
     
    
     
      
     
     
      
        SELECT
      
     
    
     
      
     
     
      
        [BelongApiPermissionGroupModelsId]
      
     
    
     
      
     
     
      
        FROM
      
     
    
     
      
     
     
      
        [ApiPermissionGroupModelRoleModel] 
      
     
    
     
      
     
     
      
        WHERE
      
     
    
     
      
     
     
      
        [RoleModelsId] IN (
      
     
    
     
      
     
     
      
        SELECT [RolesId]
      
     
    
     
      
     
     
      
        FROM [RoleModelUserModel]
      
     
    
     
      
     
     
      
        WHERE [BelongUsersId] = '{@UserId}'
      
     
    
     
      
     
     
      
        )
      
     
    
     
      
     
     
      
        )
      
     
    
     
      
     
     
      
        )");
      
     
    
     
      
     
     
                  
      
     
    
     
      
     
     
      
                   var result = apiPermissionItemModels
      
     
    
     
      
     
     
      
                       .Where(item => item.Url.ToLower() == apiUrl.Trim().ToLower())
      
     
    
     
      
     
     
      
                       .Count() > 
       0;
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
                  
       return result;
      
     
    
     
      
     
     
      
               }
      
     
    
     
      
     
     
      
           }
      
     
    
     
      
     
     
      
       }

创建 UsersController.cs 控制器文件

使用 [Authorize] 属性保护控制器操作，但登录(Login) 和注册(Register)方法除外，它们允许通过在每个操作方法上使用 [AllowAnonymous] 属性覆盖控制器上的 [Authorize] 属性来允许公共访问。


   
    
     
      
     
     
      
       using PandaCMS.Authorization;
      
     
    
     
      
     
     
      
       using Microsoft.AspNetCore.Mvc;
      
     
    
     
      
     
     
      
       using PandaCMS.ViewModels.UserManagement;
      
     
    
     
      
     
     
      
       using PandaCMS.ServiceInterface.UserManagement;
      
     
    
     
      
     
     
      
       using PandaCMS.ServiceInterface.AuthorizationManagement;
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
      
       namespace PandaCMS.Web.API.Controllers
      
     
    
     
      
     
     
      
       {
      
     
    
     
      
     
     
      
           [ApiController]
      
     
    
     
      
     
     
      
           [Authorize]
      
     
    
     
      
     
     
      
           [Route(
       "[controller]")]
      
     
    
     
      
     
     
      
           public 
       class UserController : ControllerBase
      
     
    
     
      
     
     
      
           {
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 日志服务(注入)
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
      
               private readonly ILogger<UserController> _logger;
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 用户服务(注入)
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
      
               private IUserService UserService { get; 
       set; }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 权限认证服务(注入)
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
      
               private IJwtService JwtService { get; 
       set; }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 构造函数
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
              
       /// <param name="logger"></param>
      
     
    
     
      
     
     
              
       /// <param name="userService"></param>
      
     
    
     
      
     
     
      
               public 
       UserController
       (ILogger<UserController> logger, IUserService userService, IJwtService jwtService)
      
     
    
     
      
     
     
      
               {
      
     
    
     
      
     
     
                  
       //初始化
      
     
    
     
      
     
     
      
                   _logger = logger;
      
     
    
     
      
     
     
      
                   this.UserService = userService;
      
     
    
     
      
     
     
      
                   this.JwtService = jwtService;
      
     
    
     
      
     
     
      
               }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 用户登录
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
              
       /// <param name="loginRequestViewModel"></param>
      
     
    
     
      
     
     
              
       /// <returns></returns>
      
     
    
     
      
     
     
      
               [HttpPost(
       "Login")]
      
     
    
     
      
     
     
      
               [AllowAnonymous]
      
     
    
     
      
     
     
      
               public async Task<IActionResult> 
       Login
       ([FromForm] LoginRequestViewModel loginRequestViewModel)
      
     
    
     
      
     
     
      
               {
      
     
    
     
      
     
     
                  
       //验证用户名和密码
      
     
    
     
      
     
     
                  
       bool checkResult = this.UserService.CheckUserLogin(loginRequestViewModel.Account, loginRequestViewModel.Password);
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
                  
       if (checkResult)
      
     
    
     
      
     
     
      
                   {
      
     
    
     
      
     
     
                      
       //获得用户Id
      
     
    
     
      
     
     
      
                       Guid userId = await this.UserService.GetUserId(loginRequestViewModel.Account);
      
     
    
     
      
     
     
                      
       //生成Token
      
     
    
     
      
     
     
                      
       string token = this.JwtService.GenerateToken(userId);
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
                      
       return this.Ok(new LoginResonseViewModel()
      
     
    
     
      
     
     
      
                       {
      
     
    
     
      
     
     
      
                           JwtToken = token,
      
     
    
     
      
     
     
      
                           Account = userId.ToString()
      
     
    
     
      
     
     
      
                       });
      
     
    
     
      
     
     
      
                   }
      
     
    
     
      
     
     
                  
       else
      
     
    
     
      
     
     
      
                   {
      
     
    
     
      
     
     
                      
       return this.BadRequest(new
      
     
    
     
      
     
     
      
                       {
      
     
    
     
      
     
     
      
                           Msg = 
       "用户名或密码有误。"
      
     
    
     
      
     
     
      
                       });
      
     
    
     
      
     
     
      
                   }
      
     
    
     
      
     
     
      
               }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 退出登录
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
              
       /// <returns></returns>
      
     
    
     
      
     
     
      
               [HttpGet(
       "LoginOut")]
      
     
    
     
      
     
     
      
               public async Task<IActionResult> 
       LoginOut
       ()
      
     
    
     
      
     
     
      
               {
      
     
    
     
      
     
     
                  
       bool isSuccess = await this.JwtService.InvalidationUserTokenByServer(this.JwtService.GetToken());
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
                  
       if(isSuccess)
      
     
    
     
      
     
     
      
                   {
      
     
    
     
      
     
     
                      
       return this.Ok(new
      
     
    
     
      
     
     
      
                       {
      
     
    
     
      
     
     
      
                           msg = 
       "success",
      
     
    
     
      
     
     
      
                           code = 
       666
      
     
    
     
      
     
     
      
                       });
      
     
    
     
      
     
     
      
                   }
      
     
    
     
      
     
     
                  
       else
      
     
    
     
      
     
     
      
                   {
      
     
    
     
      
     
     
                      
       return this.BadRequest(new
      
     
    
     
      
     
     
      
                       {
      
     
    
     
      
     
     
      
                           msg = 
       "error",
      
     
    
     
      
     
     
      
                           code = 
       555
      
     
    
     
      
     
     
      
                       });
      
     
    
     
      
     
     
      
                   }
      
     
    
     
      
     
     
                  
      
     
    
     
      
     
     
      
               }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
              
       /// <summary>
      
     
    
     
      
     
     
              
       /// 更新Token
      
     
    
     
      
     
     
              
       /// </summary>
      
     
    
     
      
     
     
              
       /// <param name="updateTokenRequestViewModel"></param>
      
     
    
     
      
     
     
              
       /// <returns></returns>
      
     
    
     
      
     
     
      
               [HttpPost(
       "UpdateToken")]
      
     
    
     
      
     
     
      
               public async Task<IActionResult> 
       UpdateToken
       ()
      
     
    
     
      
     
     
      
               {
      
     
    
     
      
     
     
                  
      
     
    
     
      
     
     
                  
       //先把旧的Token废除
      
     
    
     
      
     
     
                  
       if(!await this.JwtService.InvalidationUserTokenByServer(this.JwtService.GetToken()))
      
     
    
     
      
     
     
      
                   {
      
     
    
     
      
     
     
                      
       return BadRequest(new UpdateTokenResponseViewModel()
      
     
    
     
      
     
     
      
                       {
      
     
    
     
      
     
     
      
                           Code = 
       "555",
      
     
    
     
      
     
     
      
                           Message = 
       "Error:废除旧Token出错",
      
     
    
     
      
     
     
      
                           NewToken = 
       ""
      
     
    
     
      
     
     
      
                       });
      
     
    
     
      
     
     
      
                   }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
                  
       //生成新Token
      
     
    
     
      
     
     
                  
       string newToken = this.JwtService.GenerateToken(this.JwtService.GetUserId());
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
                  
       return Ok(new UpdateTokenResponseViewModel()
      
     
    
     
      
     
     
      
                   {
      
     
    
     
      
     
     
      
                       Code = 
       "666",
      
     
    
     
      
     
     
      
                       Message = 
       "Success",
      
     
    
     
      
     
     
      
                       NewToken = newToken
      
     
    
     
      
     
     
      
                   });
      
     
    
     
      
     
     
      
               }
      
     
    
     
      
     
     
      
           }
      
     
    
     
      
     
     
      
       }

配置服务、中间件、配置文件

安装 system.identitymodel.tokens.jwt 包

dotnet add package system.identitymodel.tokens.jwt

完整的 Program.cs 文件


   
    
     
      
     
     
      
       //引入命名空间
      
     
    
     
      
     
     
      
       using Microsoft.IdentityModel.Tokens;
      
     
    
     
      
     
     
      
       using System.Text;
      
     
    
     
      
     
     
      
       using PandaCMS.Authorization;
      
     
    
     
      
     
     
      
       using Microsoft.AspNetCore.Authorization;
      
     
    
     
      
     
     
      
       using PandaCMS.Data.DbContexts;
      
     
    
     
      
     
     
      
       using Microsoft.EntityFrameworkCore;
      
     
    
     
      
     
     
      
       using Microsoft.EntityFrameworkCore.Design;
      
     
    
     
      
     
     
      
       using Microsoft.EntityFrameworkCore.SqlServer;
      
     
    
     
      
     
     
      
       using PandaCMS.Service.UserManagement;
      
     
    
     
      
     
     
      
       using PandaCMS.ServiceInterface.UserManagement;
      
     
    
     
      
     
     
      
       using PandaCMS.Service.AuthorizationManagement;
      
     
    
     
      
     
     
      
       using PandaCMS.ServiceInterface.AuthorizationManagement;
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
      
       var builder = WebApplication.CreateBuilder(args);
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
      
       // Add services to the container.
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
      
       //注册数据库上下文服务
      
     
    
     
      
     
     
      
       builder.Services.AddDbContext<PandaCMSDbContext>(options =>
      
     
    
     
      
     
     
      
       {
      
     
    
     
      
     
     
          
       //注册Sql Server
      
     
    
     
      
     
     
      
           options.UseSqlServer(builder.Configuration.GetConnectionString(
       "SqlServerConnectionStrings"));
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
          
       //注册MySQL
      
     
    
     
      
     
     
          
       //ToDo:MySQL的版本号，放到配置文件中
      
     
    
     
      
     
     
          
       //options.UseMySql(builder.Configuration.GetConnectionString("MySqlConnectionString"), new MySqlServerVersion(new Version(10, 4, 17))); 
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
          
       //注册SQLite
      
     
    
     
      
     
     
          
       //options.UseSqlite(builder.Configuration.GetConnectionString("Sqlite"));
      
     
    
     
      
     
     
      
       });
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
      
       //注册自定义服务
      
     
    
     
      
     
     
      
       builder.Services.AddScoped<IJwtService, JwtService>();
      
     
    
     
      
     
     
      
       builder.Services.AddScoped<IUserService, UserService>();
      
     
    
     
      
     
     
      
       builder.Services.AddScoped<IRoleService, RoleService>();
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
      
       builder.Services.AddControllers();
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
      
       // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
      
     
    
     
      
     
     
      
       builder.Services.AddEndpointsApiExplorer();
      
     
    
     
      
     
     
      
       builder.Services.AddSwaggerGen();
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
      
       var app = builder.Build();
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
      
       // Configure the HTTP request pipeline.
      
     
    
     
      
     
     
      
       if (app.Environment.IsDevelopment())
      
     
    
     
      
     
     
      
       {
      
     
    
     
      
     
     
      
           app.UseSwagger();
      
     
    
     
      
     
     
      
           app.UseSwaggerUI();
      
     
    
     
      
     
     
      
       }
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
      
       app.UseHttpsRedirection();
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
      
       //启用JWT中间件
      
     
    
     
      
     
     
      
       app.UseMiddleware<JwtMiddleware>();
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
      
       app.MapControllers();
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
      
       app.Run();

配置文件 appsettings.json


   
    
     
      
     
     
      
       {
      
     
    
     
      
     
     
      
         "Logging": {
      
     
    
     
      
     
     
      
           "LogLevel": {
      
     
    
     
      
     
     
      
             "Default": "Information",
      
     
    
     
      
     
     
      
             "Microsoft.AspNetCore": "Warning"
      
     
    
     
      
     
     
      
           }
      
     
    
     
      
     
     
      
         },
      
     
    
     
      
     
     
      
         "AllowedHosts": "*",
      
     
    
     
      
     
     
       
      
     
    
     
      
     
     
      
         "ConnectionStrings": {
      
     
    
     
      
     
     
      
           "SqlServerConnectionStrings": "Server=127.0.0.1;Database=PandaCMS;User Id=sa;Password=1Q;",
      
     
    
     
      
     
     
      
           "MySqlConnectionString": "server=127.0.0.1;database=PandaCMS;uid=root;password=1Q;",
      
     
    
     
      
     
     
      
           "Sqlite": "Data Source=PandaCMS.db;"
      
     
    
     
      
     
     
      
         },
      
     
    
     
      
     
     
      
         "Authorization": {
      
     
    
     
      
     
     
      
           "JwtAuth": {
      
     
    
     
      
     
     
      
             "Key": "wwwpanda666comKey",
      
     
    
     
      
     
     
      
             "ValidateAudience": true,
      
     
    
     
      
     
     
      
             "ValidateIssuer": true,
      
     
    
     
      
     
     
      
             "Issuer": "panda666.com",
      
     
    
     
      
     
     
      
             "Audience": "panda666.com",
      
     
    
     
      
     
     
      
             "ExpiresDay": "7"
      
     
    
     
      
     
     
      
           },
      
     
    
     
      
     
     
      
           "DeniedAction": "/api/nopermission"
      
     
    
     
      
     
     
      
         }
      
     
    
     
      
     
     
      
       }

参考文档

https://jasonwatmore.com/post/2021/05/25/net-5-simple-api-for-authentication-registration-and-user-management

转载：https://blog.csdn.net/weixin_38304160/article/details/127782615

查看评论

小言_互联网的博客