欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

【从零开始搭建自己的.NET Core Api框架】(四)实战!带你半个小时实现接口的JWT授权验证

程序员文章站 2022-07-27 23:44:25
系列目录 一. 创建项目并集成swagger 1.1 创建 1.2 完善 二. 搭建项目整体架构 三. 集成轻量级ORM框架——SqlSugar 3.1 搭建环境 3.2 实战篇:利用SqlSugar快速实现CRUD 3.3 生成实体类 四. 集成JWT授权验证 源码已上传Github:https: ......

系列目录

.  创建项目并集成swagger

  

  

三. 集成轻量级ORM框架——SqlSugar

  

  

  

 


 

源码已上传Github:

 

  1. 根

根据*定义,JWT(读作 [/dʒɒt/]),即JSON Web Tokens,是一种基于JSON的、用于在网络上声明某种主张的令牌(token)。

JWT通常由三部分组成: 头信息(header), 消息体(payload)和签名(signature)。它是一种用于双方之间传递安全信息的表述性声明规范。

JWT作为一个开放的标准(RFC 7519),定义了一种简洁的、自包含的方法,从而使通信双方实现以JSON对象的形式安全的传递信息。

 

以上是JWT的官方解释,可以看出JWT并不是一种只能权限验证的工具,而是一种标准化的数据传输规范。所以,只要是在系统之间需要传输简短但却需要一定安全等级的数据时,都可以使用JWT规范来传输。规范是不因平台而受限制的,这也是JWT做为授权验证可以跨平台的原因。

如果理解还是有困难的话,我们可以拿JWT和JSON类比:

JSON是一种轻量级的数据交换格式,是一种数据层次结构规范。它并不是只用来给接口传递数据的工具,只要有层级结构的数据都可以使用JSON来存储和表示。当然,JSON也是跨平台的,不管是Win还是Linux,.NET还是Java,都可以使用它作为数据传输形式。

 

该篇的主要目的是实战,所以关于JWT本身的优点,以及使用JWT作为系统授权验证的优缺点,这里就不细说了,感兴趣的可以自己去查阅相关资料。

 

 1.1 在授权验证系统中,JWT是怎么工作的呢?

如果将JWT运用到Web Api的授权验证中,那么它的工作原理是这样的:

【从零开始搭建自己的.NET Core Api框架】(四)实战!带你半个小时实现接口的JWT授权验证

 

1)客户端向授权服务系统发起请求,申请获取“令牌”。

2)授权服务根据用户身份,生成一张专属“令牌”,并将该“令牌”以JWT规范返回给客户端

3)客户端将获取到的“令牌”放到http请求的headers中后,向主服务系统发起请求。主服务系统收到请求后会从headers中获取“令牌”,并从“令牌”中解析出该用户的身份权限,然后做出相应的处理(同意或拒绝返回资源)

 

可以看出,JWT授权服务是可以脱离我们的主服务系统而作为一个独立系统存在的。

 

 1.2 令牌是什么?JWT就是令牌吗?

前面说了其实把JWT理解为一种规范更为贴切,但是往往大家把根据JWT规则生成的加密字符串也叫作JWT,还有人直接称呼JWT为令牌。本文为了阐述方便,特此做了一些区分:

 1.2.1 JWT:

本文所说的JWT皆指的是JWT规范

 1.2.2 JWT字符串:

本文所说的“JWT字符串”是指通过JWT规则加密后生成的字符串,它由三本分组成:Header(头部)、Payload(数据)、Signature(签名),将这三部分由‘.’连接而组成的一长串加密字符串就成为JWT字符串。

1)Header

由且只由两个数据组成,一个是“alg”(加密规范)指定了该JWT字符串的加密规则,另一个是“typ”(JWT字符串类型)。例如:

{
  "alg": "HS256",
  "typ": "JWT"
}

将这组JSON格式的数据通过Base64Url格式编码后,生成的字符串就是我们JWT字符串的第一个部分。

2)Payload

由一组数据组成,它负责传递数据,我们可以添加一些已注册声明,比如“iss”(JWT字符串的颁发人名称)、“exp”(该JWT字符串的过期时间)、“sub”(身份)、“aud”(受众),除了这些,我们还可根据需要添加自定义的需要传输的数据,一般是发起请求的用户的信息。例如:

{
  “iss”:"RayPI",
  "sub": "Client",
  "name": "张三",
  "uid": 1
}

将该JSON格式的数据通过Base64Url格式编码后,生成的字符串就是我们JWT字符串的第二部分。

3)Signature

数字签名,由4个因素所同时决定:编码后的header字符串,编码后的payload字符串,之前在头部声明的加密算法,我们自定义的一个秘钥字符串(secret)。例如:

HMACSHA256(
  base64UrlEncode(header) + "." +
  base64UrlEncode(payload),
  secret)

所以签名可以安全地验证一个JWT的合法性(有没有被篡改过)。

最后,给一个实际生成后的JWT字符串的完整样例:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJDbGllbnQiLCJqdGkiOiIwZTRjYzVkNC0yMmIzLTQwYzUtOTBjMy0wOTk0MjFjNWRjMjkiLCJpYXQiOiIyMDE4LzcvMyAyOjE3OjQ5IiwiZXhwIjoxNTMwNjI3NDY5LCJpc3MiOiJSYXlQSSJ9.98pAaDVhNwVfiSHQVeXKhYE2ML6WK_f9rYC-iwyQEpU

我们可以拿着这个JWT字符串到试着解析出前两部分的内容。

 1.2.3 令牌:

本文的“令牌”指的是用于http传输headers中用于验证授权的JSON数据,它是key和value两部分组成,在本文中,key为“Authorization”,value为“Bearer {JWT字符串}”,其中value除了JWT字符串外,还在前面添加了“Bearer ”字符串,这里可以把它理解为大家约约定俗成的规定即可,没有实际的作用。例如:

{ "Authorization": "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJDbGllbnQiLCJqdGkiOiIwZTRjYzVkNC0yMmIzLTQwYzUtOTBjMy0wOTk0MjFjNWRjMjkiLCJpYXQiOiIyMDE4LzcvMyAyOjE3OjQ5IiwiZXhwIjoxNTMwNjI3NDY5LCJpc3MiOiJSYXlQSSJ9.98pAaDVhNwVfiSHQVeXKhYE2ML6WK_f9rYC-iwyQEpU" }

 

整体的思路明白了,下面实战起来就不会乱了。

 

  2. 道

 搭建完的项目架构应该是这样的:

 【从零开始搭建自己的.NET Core Api框架】(四)实战!带你半个小时实现接口的JWT授权验证

这里有三块工作区域:

一个是RayPI.Token层,该层主要负责“令牌”的生成和存储。

还有一个是在主项目下面的AuthHelper的TokenAuth,该类为一个中间件,它被注册到客服端和接口之间,在客户端发起http请求时,这个http请求会先被传输到TokenAuth类中,然后该类经过一系列验证和操作(包括了JWT验证),决定是否对给http请求进行授权,然后将请求传递给下一个中间件。

最后一个是系统的系统类Startup.cs,我们将在这里面注册中间件,添加Authorization服务等操作。

 

2.1 搭建RayPI.Token 层

2.1.1 Model

在RayPI.Token层中新建一个Model文件夹,在该文件夹下新建一个TokenModel类,类的定义如下:

namespace RayPI.Token.Model
{
    /// <summary>
    /// 令牌类
    /// </summary>
    public class TokenModel
    {
        public TokenModel()
        {
            this.Uid = 0;
        }
        /// <summary>
        /// 用户Id
        /// </summary>
        public long Uid { get; set; }
        /// <summary>
        /// 用户名
        /// </summary>
        public string Uname { get; set; }
        /// <summary>
        /// 手机
        /// </summary>
        public string Phone { get; set; }
        /// <summary>
        /// 头像
        /// </summary>
        public string Icon { get; set; }
        /// <summary>
        /// 昵称
        /// </summary>
        public string UNickname { get; set; }
        /// <summary>
        /// 身份
        /// </summary>
        public string Sub { get; set; }
    }
}

该类用于存储客户端的一些基本信息,后面我们需要将它存入到系统缓存中。

2.1.2 缓存类

新建一个RayPIMemoryCache类,该类是一个系统扩展类,用于集成我们常用的对MemoryCache的操作,代码如下:

using System;
using Microsoft.Extensions.Caching.Memory;

namespace RayPI.Token
{
    public class RayPIMemoryCache
    {
        public static MemoryCache _cache = new MemoryCache(new MemoryCacheOptions());

        /// <summary>
        /// 验证缓存项是否存在
        /// </summary>
        /// <param name="key">缓存Key</param>
        /// <returns></returns>
        public static bool Exists(string key)
        {
            if (key == null)
            {
                throw new ArgumentNullException(nameof(key));
            }
            object cached;
            return _cache.TryGetValue(key, out cached);
        }

        /// <summary>
        /// 获取缓存
        /// </summary>
        /// <param name="key">缓存Key</param>
        /// <returns></returns>
        public static object Get(string key)
        {
            if (key == null)
            {
                throw new ArgumentNullException(nameof(key));
            }
            return _cache.Get(key);
        }

        /// <summary>
        /// 添加缓存
        /// </summary>
        /// <param name="key">缓存Key</param>
        /// <param name="value">缓存Value</param>
        /// <param name="expiresSliding">滑动过期时长(如果在过期时间内有操作,则以当前时间点延长过期时间)</param>
        /// <param name="expiressAbsoulte">绝对过期时长</param>
        /// <returns></returns>
        public static bool AddMemoryCache(string key, object value, TimeSpan expiresSliding, TimeSpan expiressAbsoulte)
        {
            if (key == null)
            {
                throw new ArgumentNullException(nameof(key));
            }
            if (value == null)
            {
                throw new ArgumentNullException(nameof(value));
            }
            _cache.Set(key, value,
                    new MemoryCacheEntryOptions()
                    .SetSlidingExpiration(expiresSliding)
                    .SetAbsoluteExpiration(expiressAbsoulte)
                    );

            return Exists(key);
        }
    }
}

2.1.3 RayPIToken类

该类只有一个方法叫IssueJWT,我们将tokenModel传递给这个函数,它会根据tokenModel生成JWT字符串,然后将JWT字符串作为key、tokenModel作为value存入系统缓存中中。

using Microsoft.IdentityModel.Tokens;
using RayPI.Token.Model;
using System;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;

namespace RayPI.Token
{
    /// <summary>
    /// 令牌类
    /// </summary>
    public class RayPIToken
    {

        public RayPIToken()
        {
        }

        /// <summary>
        /// 获取JWT字符串并存入缓存
        /// </summary>
        /// <param name="tm"></param>
        /// <param name="expireSliding"></param>
        /// <param name="expireAbsoulte"></param>
        /// <returns></returns>
        public static string IssueJWT(TokenModel tokenModel, TimeSpan expiresSliding, TimeSpan expiresAbsoulte)
        {
            DateTime UTC = DateTime.UtcNow;
            Claim[] claims = new Claim[]
            {
                new Claim(JwtRegisteredClaimNames.Sub,tokenModel.Sub),//Subject,
                new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),//JWT ID,JWT的唯一标识
                new Claim(JwtRegisteredClaimNames.Iat, UTC.ToString(), ClaimValueTypes.Integer64),//Issued At,JWT颁发的时间,采用标准unix时间,用于验证过期
            };

            JwtSecurityToken jwt = new JwtSecurityToken(
            issuer: "RayPI",//jwt签发者,非必须
            audience: tokenModel.Uname,//jwt的接收该方,非必须
            claims: claims,//声明集合
            expires: UTC.AddHours(12),//指定token的生命周期,unix时间戳格式,非必须
            signingCredentials: new Microsoft.IdentityModel.Tokens
                .SigningCredentials(new SymmetricSecurityKey(Encoding.ASCII.GetBytes("RayPI's Secret Key")), SecurityAlgorithms.HmacSha256));//使用私钥进行签名加密

            var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);//生成最后的JWT字符串

            RayPIMemoryCache.AddMemoryCache(encodedJwt, tokenModel, expiresSliding, expiresAbsoulte);//将JWT字符串和tokenModel作为key和value存入缓存
            return encodedJwt;
        }
    }
}

 

2.2. 搭建AuthHelp中间件

在主项目中添加文件夹AuthHelp,在文件夹下添加TokenAuth类。

该类后面我们会把它注册为中间件,用于验证并授权客户端发来的http请求。代码如下:

using Microsoft.AspNetCore.Http;
using RayPI.Token;
using RayPI.Token.Model;
using System;
using System.Collections.Generic;
using System.Security.Claims;
using System.Threading.Tasks;

namespace RayPI.AuthHelper
{
    /// <summary>
    /// Token验证授权中间件
    /// </summary>
    public class TokenAuth
    {
        /// <summary>
        /// http委托
        /// </summary>
        private readonly RequestDelegate _next;
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="next"></param>
        public TokenAuth(RequestDelegate next)
        {
            _next = next;
        }
        /// <summary>
        /// 验证授权
        /// </summary>
        /// <param name="httpContext"></param>
        /// <returns></returns>
        public Task Invoke(HttpContext httpContext)
        {
            var headers = httpContext.Request.Headers;
            //检测是否包含'Authorization'请求头,如果不包含返回context进行下一个中间件,用于访问不需要认证的API
            if (!headers.ContainsKey("Authorization"))
            {
                return _next(httpContext);
            }
            var tokenStr = headers["Authorization"];
            try
            {
                string jwtStr = tokenStr.ToString().Substring("Bearer ".Length).Trim();
                //验证缓存中是否存在该jwt字符串
                if (!RayPIMemoryCache.Exists(jwtStr))
                {
                    return httpContext.Response.WriteAsync("非法请求");
                }
                TokenModel tm = ((TokenModel)RayPIMemoryCache.Get(jwtStr));
                //提取tokenModel中的Sub属性进行authorize认证
                List<Claim> lc = new List<Claim>();
                Claim c = new Claim(tm.Sub+"Type", tm.Sub);
                lc.Add(c);
                ClaimsIdentity identity = new ClaimsIdentity(lc);
                ClaimsPrincipal principal = new ClaimsPrincipal(identity);
                httpContext.User = principal;
                return _next(httpContext);
            }
            catch (Exception)
            {
                return httpContext.Response.WriteAsync("token验证异常");
            }
        }
    }
}

 

2.3 设置Startup.cs类

在ConfigureServices,我们需要注册两个服务项

1)缓存

services.AddSingleton<IMemoryCache>(factory =>
            {
                var cache = new MemoryCache(new MemoryCacheOptions());
                return cache;
            });

2)认证

services.AddAuthorization(options =>
            {
                options.AddPolicy("System", policy => policy.RequireClaim("SystemType").Build());
                options.AddPolicy("Client", policy => policy.RequireClaim("ClientType").Build());
                options.AddPolicy("Admin", policy => policy.RequireClaim("AdminType").Build());
            });

这里放了三个身份,System、Client和Admin,后面如果需要可以再添加。

 

在Configure中,需要将之前的TokenAuth类注册为中间件

app.UseMiddleware<TokenAuth>();

 

完整的Startup.cs代码是这样的:

【从零开始搭建自己的.NET Core Api框架】(四)实战!带你半个小时实现接口的JWT授权验证
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using RayPI.SwaggerHelp;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Microsoft.Extensions.PlatformAbstractions;
using RayPI.AuthHelper;
using RayPI.Token;
using Swashbuckle.AspNetCore.Swagger;
using Microsoft.AspNetCore.StaticFiles;

namespace RayPI
{
    /// <summary>
    /// 
    /// </summary>
    public class Startup
    {
        /// <summary>
        /// 
        /// </summary>
        /// <param name="configuration"></param>
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }
        /// <summary>
        /// 
        /// </summary>
        public IConfiguration Configuration { get; }

        /// <summary>
        /// This method gets called by the runtime. Use this method to add services to the container.
        /// </summary>
        /// <param name="services"></param>
        public void ConfigureServices(IServiceCollection services)
        {
            services.Configure<Dictionary<string, string>>(Configuration.GetSection("Mime"));
            services.AddMvc().AddJsonOptions(options =>
            {
                options.SerializerSettings.DateFormatString = "yyyy-MM-dd HH:mm:ss";//设置时间格式
            });

            #region Swagger
            services.AddSwaggerGen(c =>
            {
                c.SwaggerDoc("v1", new Info
                {
                    Version = "v1.1.0",
                    Title = "Ray WebAPI",
                    Description = "框架集合",
                    TermsOfService = "None",
                    Contact = new Swashbuckle.AspNetCore.Swagger.Contact { Name = "RayWang", Email = "2271272653@qq.com", Url = "http://www.cnblogs.com/RayWang" }
                });
                //添加注释服务
                var basePath = PlatformServices.Default.Application.ApplicationBasePath;
                var xmlPath = Path.Combine(basePath, "APIHelp.xml");
                c.IncludeXmlComments(xmlPath);
                //添加对控制器的标签(描述)
                c.DocumentFilter<SwaggerDocTag>();

                //添加header验证信息
                //c.OperationFilter<SwaggerHeader>();
                var security = new Dictionary<string, IEnumerable<string>> { { "Bearer", new string[] { } }, };
                c.AddSecurityRequirement(security);//添加一个必须的全局安全信息,和AddSecurityDefinition方法指定的方案名称要一致,这里是Bearer。
                c.AddSecurityDefinition("Bearer", new ApiKeyScheme
                {
                    Description = "JWT授权(数据将在请求头中进行传输) 参数结构: \"Authorization: Bearer {token}\"",
                    Name = "Authorization",//jwt默认的参数名称
                    In = "header",//jwt默认存放Authorization信息的位置(请求头中)
                    Type = "apiKey"
                });
            });
            #endregion

            #region Token
            services.AddSingleton<IMemoryCache>(factory =>
            {
                var cache = new MemoryCache(new MemoryCacheOptions());
                return cache;
            });
            services.AddAuthorization(options =>
            {
                options.AddPolicy("System", policy => policy.RequireClaim("SystemType").Build());
                options.AddPolicy("Client", policy => policy.RequireClaim("ClientType").Build());
                options.AddPolicy("Admin", policy => policy.RequireClaim("AdminType").Build());
            });
            #endregion
        }

        /// <summary>
        /// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        /// </summary>
        /// <param name="app"></param>
        /// <param name="env"></param>
        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            #region Swagger
            app.UseSwagger();
            app.UseSwaggerUI(c =>
            {
                c.SwaggerEndpoint("/swagger/v1/swagger.json", "ApiHelp V1");
            });
            #endregion

            #region TokenAuth
            app.UseMiddleware<TokenAuth>();
            #endregion

            app.UseMvc();
            
            app.UseStaticFiles();//用于访问wwwroot下的文件 
        }
    }
}
Startup.cs

 

Tips:

这里有一个坑,不太了解依赖注入和中间件的人很容易踩到(其实就是我自己了)

在Startup.cs的Configure函数中,里面每个app.UseXXXXX();是有一定顺序。可以理解为,这里添加中间件的顺序就是客户端发起http请求时所经过的顺序。

之前我因为把“app.UseMvc();”写到了“app.UseMiddleware<TokenAuth>();”上面去了,结果导致怎么Debug都找不到问题。。。

 

  3.果

 搭建完成之后,下面就是测试了。

选择一个测试控制器,在其头上标注[Authorize]属性

【从零开始搭建自己的.NET Core Api框架】(四)实战!带你半个小时实现接口的JWT授权验证

 

然后在TokenAuth的Invoke函数下添加一个断点,在我们调用接口发起http请求后,应该会先命中这个断点,在处理了授权验证之后才会进入我们的接口中。

【从零开始搭建自己的.NET Core Api框架】(四)实战!带你半个小时实现接口的JWT授权验证

 

 F5运行,在swagger ui中调用一个需要授权验证的接口(根据Id获取学生信息)

【从零开始搭建自己的.NET Core Api框架】(四)实战!带你半个小时实现接口的JWT授权验证

 

输入1,先不进行任何授权认证的操作,直接点击Excute尝试调用,系统命中Invoke函数下的断点,放行,返回结果如下:

【从零开始搭建自己的.NET Core Api框架】(四)实战!带你半个小时实现接口的JWT授权验证

 

状态码500,还返回了一大段html代码,我们可以将接口的完整地址输入到浏览器地址栏进行访问,就可以看到这段html代码的页面了:

【从零开始搭建自己的.NET Core Api框架】(四)实战!带你半个小时实现接口的JWT授权验证

 

可以看到接口返回了一个错误页,原因就是因为该接口加了授权验证之后,中间件TokenAuth会在http请求的头部(headers)中寻找“Authorization"字段里的”令牌“,因为我们没有向接口递送”令牌“,所以系统就会拒绝我们访问该接口。

 

现在,我们先调用获取JWT接口(实际项目中不应该有该接口,分发令牌的功能应该集成到登陆功能中,但是这里为了简单直观,我将分发令牌的功能直接写成了接口,以供测试),输入相应的客户端信息,Excute:

【从零开始搭建自己的.NET Core Api框架】(四)实战!带你半个小时实现接口的JWT授权验证

 

接口会生成”令牌“,并将令牌存入系统缓存的同时,返回JWT字符串:

【从零开始搭建自己的.NET Core Api框架】(四)实战!带你半个小时实现接口的JWT授权验证

 

我们要复制这串JWT字符串,然后将其添加到http请求的Headers中去。测试方法有两个:

 

1)可以新建一个html页面,模拟前端写个ajax调用接口,在ajax添加headers字段,如下:

$.ajax({
                url: "http://localhost:3608/api/Admin/Student/1",
                type: ”get“,
                dataType: "json",
                //data: {},
                async: false,
          //手动高亮 headers: { "Authorization": "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJBZG1pbiIsImp0aSI6IjhjMDEwMzI2LTE4M2MtNGQ5ZC1iMDFjLWFjM2EzNTIzODYxOCIsImlhdCI6IjIwMTgvNy8yIDE1OjAzOjQ4IiwiZXhwIjoxNTMwNTg3MDI4LCJpc3MiOiJSYXlQSSJ9.1Bb7hwoDD12n8ymcQsu79Xm-GDq14GERhS9b-1l1kmg" }, success: function (d) { alert(JSON.stringify(d)); }, error: function (d) { alert(JSON.stringify(d)) } });

 

2)如果你的swagger像我一样,集成了添加Authrize头部功能,那么可以点击这个按钮进行添加(如果你的swagger看不到这个按钮,可以参考我之前的章节,对swagger进行相关的设置)

【从零开始搭建自己的.NET Core Api框架】(四)实战!带你半个小时实现接口的JWT授权验证

【从零开始搭建自己的.NET Core Api框架】(四)实战!带你半个小时实现接口的JWT授权验证

 

这里除了JWT字符串外,前面还需要手动写入“Bearer ”(有一个空格)字符串。点击Authorize保存"令牌"。

 

再次调用刚才的”根据id获取学生信息“接口,发现获取成功:

【从零开始搭建自己的.NET Core Api框架】(四)实战!带你半个小时实现接口的JWT授权验证

可以看到swagger向http请求的headers中添加了我们刚才保存的”令牌“。

 

参考内容:

https://jwt.io/

https://www.cnblogs.com/webenh/p/9039322.html