.Net Core中进行Jwt验证

授权JWT类JwtHelper.cs

    /// <summary>
    /// 授权JWT类
    /// </summary>
    public class JwtHelper
    {
        private readonly IConfiguration _configuration;

        /// <summary>
        /// Token配置
        /// </summary>
        /// <param name="configuration"></param>
        public JwtHelper(IConfiguration configuration)
        {
            _configuration = configuration;
        }

        /// <summary>
        /// 创建Token 这里面可以保存自己想要的信息
        /// </summary>
        /// <param name="user_id"></param>
        /// <param name="mobile"></param>
        /// <returns></returns>
        public string CreateToken(string user_id)
        {
            // 1. 定义需要使用到的Claims
            var claims = new Claim[]
            {
                new Claim("user_id", user_id),            
                /* 可以保存自己想要信息，传参进来即可           
                new Claim("limit", "limit"),            
                */
            };

            // 2. 从 appsettings.json 中读取SecretKey
            var secretKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["Jwt:SecretKey"]));

            // 3. 选择加密算法
            var algorithm = SecurityAlgorithms.HmacSha256;

            // 4. 生成Credentials
            var signingCredentials = new SigningCredentials(secretKey, algorithm);

            // 5. 根据以上，生成token
            var jwtSecurityToken = new JwtSecurityToken(
               issuer: _configuration["Jwt:AppId"],    //Issuer
               audience: _configuration["Jwt:AppKey"],  //Audience
               claims: claims,                          //Claims,
               notBefore: DateTime.Now,                    //notBefore
               expires: DateTime.Now.AddHours(1),     //expires
               signingCredentials: signingCredentials               //Credentials
            );

            // 6. 将token变为string
            var token = new JwtSecurityTokenHandler().WriteToken(jwtSecurityToken);

            return token;
        }

        /// <summary>
        /// 根据token反向解析
        /// </summary>
        /// <param name="token"></param>
        /// <returns></returns>
        public string GetInfoFromToken(string token = null)
        {
            if (token is null || token == "")
                return null;

            string tokenStr = token.Replace("Bearer ", "");

            var handler = new JwtSecurityTokenHandler();
            // string tokenStr = token;
            var payload = handler.ReadJwtToken(tokenStr).Payload;

            var claims = payload.Claims;

            var info = new
            {
                UserId = claims.First(claim => claim.Type == "user_id")?.Value,
                AppId = _configuration["Jwt:AppId"],
                AppKey = _configuration["Jwt:AppKey"]
            };
            return JsonConvert.SerializeObject(info);
        }

        /// <summary>
        /// 从Token中获取用户身份
        /// </summary>
        /// <param name="token"></param>
        /// <param name="securityKey">securityKey明文,Java加密使用的是Base64</param>
        /// <returns></returns>
        public ClaimsPrincipal GetPrincipal(string token)
        {
            try
            {
                string securityKey = _configuration["Jwt:SecretKey"];
                token = token.Replace("Bearer ", "");
                var handler = new JwtSecurityTokenHandler();
                TokenValidationParameters tokenValidationParameters = new TokenValidationParameters
                {
                    ValidateAudience = false,
                    ValidateIssuer = false,
                    ValidateIssuerSigningKey = true,
                    IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(securityKey)),
                    ValidateLifetime = false
                };
                return handler.ValidateToken(token, tokenValidationParameters, out SecurityToken validatedToken);
            }
            catch (Exception ex)
            {

                return null;
            }
        }


        /// <summary>
        /// 校验Token
        /// </summary>
        /// <param name="token">token</param>
        /// <returns></returns>
        public bool CheckToken(string token)
        {
            var principal = GetPrincipal(token);
            if (principal is null)
            {
                return false;
            }
            return true;
        }
    }

在控制器中添加对应校验

    [Route("api/[controller]/[action]")]
    [ApiController]
    public class UserInfoController : ControllerBase
    {
        private readonly JwtHelper _jwt;

        /// <summary>
        /// 初始化
        /// </summary>
        /// <param name="jwtHelper"></param>
        public UserInfoController(JwtHelper jwtHelper)
        {
            _jwt = jwtHelper;
        }
        /// <summary>
        /// 获取Token
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public IActionResult GetToken(string userid)
        {
            //参数验证等等....
            if (string.IsNullOrEmpty(userid))
            {
                return Ok("参数异常！");
            }
            //这里可以连接mysql数据库做账号密码验证

            //这里可以做Redis缓存验证等等
            //这里获取Token，当然，这里也可以选择传结构体过去
            var token = _jwt.CreateToken(userid);
            return Ok(token);
        }

        /// <summary>
        /// 获取自己的详细信息，其中 [Authorize] 就表示要带Token才行
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        [Authorize]
        public IActionResult GetSelfInfo()
        {
            //执行到这里，就表示已经验证授权通过了
            /*
             * 这里返回个人信息有两种方式
             * 第一种：从Header中的Token信息反向解析出用户账号，再从数据库中查找返回
             * 第二种：从Header中的Token信息反向解析出用户账号信息直接返回，当然，在前面创建        Token时，要保存进使用到的Claims中。
            */
            var token = Request.Headers.Authorization.ToString();
            bool isOK = _jwt.CheckToken(token);

            var data = _jwt.GetInfoFromToken(token);
            return Ok("授权通过了！");

        }
    }

 Program.cs中进行配置

    public class Program
    {
        public static void Main(string[] args)
        {
            var builder = WebApplication.CreateBuilder(args);

            // Add services to the container.

            builder.Services.AddControllers();
            // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
            builder.Services.AddEndpointsApiExplorer();
            builder.Services.AddSwaggerGen();
            #region JWT服务
            // 注册JWT服务
            builder.Services.AddSingleton(new JwtHelper(builder.Configuration));

            builder.Services.AddAuthentication(options =>
            {
                options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
            }
            ).AddJwtBearer(options =>
            {
                options.TokenValidationParameters = new TokenValidationParameters()
                {
                    ValidateIssuer = true, //是否验证Issuer
                    ValidIssuer = builder.Configuration["Jwt:AppId"], //发行人Issuer
                    ValidateAudience = true, //是否验证Audience
                    ValidAudience = builder.Configuration["Jwt:AppKey"], //订阅人Audience
                    ValidateIssuerSigningKey = true, //是否验证SecurityKey
                    IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(builder.Configuration["Jwt:SecretKey"])), //SecurityKey
                    ValidateLifetime = true, //是否验证失效时间
                    ClockSkew = TimeSpan.FromSeconds(30), //过期时间容错值，解决服务器端时间不同步问题（秒）
                    RequireExpirationTime = true,
                };
            }
            );
            #endregion
            var app = builder.Build();

            // Configure the HTTP request pipeline.
            if (app.Environment.IsDevelopment())
            {
                app.UseSwagger();
                app.UseSwaggerUI();
            }

            app.UseHttpsRedirection();

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


            app.MapControllers();

            app.Run();
        }
    }

appsettings.json中配置

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "Jwt": {
    "SecretKey": "u6u^Bdob@OJ&KF2RcAB%ybsoy&2S7jhP^SW!q!Z^FK7eB7F8CcxIHsIh4Ll3pL^#",
    "AppId": "WebAppAppId",
    "AppKey": "WebAppAudience"
  }
}