【從零開始搭建本身的.NET Core Api框架】（七）受權認證進階篇

根據維基百科定義，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的受權驗證中，那麼它的工做原理是這樣的：

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字符串到https://jwt.io/#debugger試着解析出前兩部分的內容。

1.2.3 令牌：

本文的「令牌」指的是用於http傳輸headers中用於驗證受權的JSON數據，它是key和value兩部分組成，在本文中，key爲「Authorization」，value爲「Bearer {JWT字符串}」，其中value除了JWT字符串外，還在前面添加了「Bearer 」字符串，這裏能夠把它理解爲你們約約定俗成的規定便可，沒有實際的做用。例如：

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

1.3 受權？認證？傻傻分不清楚

先問一個問題：認證和受權是一回事嗎？

答案顯然是否認的。由於你們都喜歡把這兩個詞放在一塊兒說，因此很容易就混淆了他們含義。在.NET Core中，認證的單詞是「Authentication」，而受權的單詞是「Authorization」。

認證，驗證身份的意思。即驗證當前請求的用戶是否爲合法用戶（放在當前場景下，就是驗證用戶攜帶的令牌是否爲一個合法令牌）；

受權，給用戶頒發權限的意思。即給驗證經過的用戶授予相應的權限（放在當前場景下，就是根據令牌中解析出的用戶身份，賦予該http請求，該http請求使用該身份就能夠訪問對應的接口）

因此，咱們下面要實現的整體思路是：

在每一個接口上都標明該接口容許什麼樣的身份訪問（好比「Client」表明客戶端，「Admin」表明後臺管理員）。

在用戶登陸成功後，咱們將該用戶的身份（是Client仍是Admin）等信息生成JWT規範的令牌返回。客戶端將返回的令牌存儲好（通常是存在Cookie中），之後每次調用接口都要將該令牌攜帶上。

服務端收到請求後，提取令牌，先進行認證，若是不合法（好比被篡改），將駁回請求。若是認證經過，則從令牌中提取身份，進行受權操做，將該身份賦予http請求，放行請求。

請求進到接口後會和接口標明的容許訪問身份進行匹配，若是該接口容許該身份訪問，則返回相應請求資源，若是不容許，則駁回請求。

思路明白了，下面實戰起來就不會亂了。

2. 道

搭建完的項目架構應該是這樣的：

這裏有三塊工做區域：

1）JwtHelper是一個Jwt幫助類，裏面有兩個函數，一個函數幫助生成Jwt字符串並返回，一個幫助從Jwt字符串逆向解析出數據。

2）JwtAuthorizationFilter.cs是一個受權中間件

3）Startup中添加了認證服務和受權服務

2.1 JwtHelper

using Microsoft.IdentityModel.Tokens;
using System;
using System.Collections.Generic;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;
//
using RayPI.Model.ConfigModel;

namespace RayPI.Helper
{
    public class JwtHelper
    {
        /// <summary>
        /// 頒發JWT字符串
        /// </summary>
        /// <param name="tokenModel"></param>
        /// <returns></returns>
        public static string IssueJWT(TokenModel tokenModel)
        {
            var dateTime = DateTime.UtcNow;
            var claims = new Claim[]
            {
                new Claim(JwtRegisteredClaimNames.Jti,tokenModel.Uid.ToString()),//用戶Id
                new Claim("Role", tokenModel.Role),//身份
                new Claim("Project", tokenModel.Project),//身份
                new Claim(JwtRegisteredClaimNames.Iat,dateTime.ToString(),ClaimValueTypes.Integer64)
            };
            //祕鑰
            var jwtConfig = new JwtAuthConfigModel();
            var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(jwtConfig.JWTSecretKey));
            var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
            //過時時間
            double exp = 0;
            switch (tokenModel.TokenType)
            {
                case "Web":
                    exp = jwtConfig.WebExp;
                    break;
                case "App":
                    exp = jwtConfig.AppExp;
                    break;
                case "MiniProgram":
                    exp = jwtConfig.MiniProgramExp;
                    break;
                case "Other":
                    exp = jwtConfig.OtherExp;
                    break;
            }
            var jwt = new JwtSecurityToken(
                issuer: "RayPI",
                claims: claims, //聲明集合
                expires: dateTime.AddHours(exp),
                signingCredentials: creds);

            var jwtHandler = new JwtSecurityTokenHandler();
            var encodedJwt = jwtHandler.WriteToken(jwt);

            return encodedJwt;
        }

        /// <summary>
        /// 解析
        /// </summary>
        /// <param name="jwtStr"></param>
        /// <returns></returns>
        public static TokenModel SerializeJWT(string jwtStr)
        {
            var jwtHandler = new JwtSecurityTokenHandler();
            JwtSecurityToken jwtToken = jwtHandler.ReadJwtToken(jwtStr);
            object role = new object(); ;
            object project = new object();
            try
            {
                jwtToken.Payload.TryGetValue("Role", out role);
                jwtToken.Payload.TryGetValue("Project", out project);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
            var tm = new TokenModel
            {
                Uid = long.Parse(jwtToken.Id),
                Role = role.ToString(),
                Project = project.ToString()
            };
            return tm;
        }
    }

    /// <summary>
    /// 令牌
    /// </summary>
    public class TokenModel
    {
        /// <summary>
        /// 用戶Id
        /// </summary>
        public long Uid { get; set; }
        /// <summary>
        /// 身份
        /// </summary>
        public string Role { get; set; }
        /// <summary>
        /// 項目名稱
        /// </summary>
        public string Project { get; set; }
        /// <summary>
        /// 令牌類型
        /// </summary>
        public string TokenType { get; set; }
    }
}

JwtHelper

其中JwtAuthConfigModel是一個存儲配置文件的類，裏面讀取了配置文件中的jwt祕鑰和幾個過時時間。這裏就不放了，能夠在代碼裏直接寫死。

2.2. JwtAuthorizationFilter

using Microsoft.AspNetCore.Http;
using RayPI.Bussiness;
using RayPI.Helper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using System.Threading.Tasks;

namespace RayPI.AuthHelp
{
    /// <summary>
    /// 受權中間件
    /// </summary>
    public class JwtAuthorizationFilter
    {
        private readonly RequestDelegate _next;

        /// <summary>
        /// 
        /// </summary>
        /// <param name="next"></param>
        public JwtAuthorizationFilter(RequestDelegate next)
        {
            _next = next;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="httpContext"></param>
        /// <returns></returns>
        public Task Invoke(HttpContext httpContext)
        {
            //檢測是否包含'Authorization'請求頭，若是不包含則直接放行
            if (!httpContext.Request.Headers.ContainsKey("Authorization"))
            {
                return _next(httpContext);
            }
            var tokenHeader = httpContext.Request.Headers["Authorization"];
            tokenHeader = tokenHeader.ToString().Substring("Bearer ".Length).Trim();

            TokenModel tm = JwtHelper.SerializeJWT(tokenHeader);

            //BaseBLL.TokenModel = tm;//將tokenModel存入baseBll

            //受權
            var claimList = new List<Claim>();
            var claim = new Claim(ClaimTypes.Role, tm.Role);
            claimList.Add(claim);
            var identity = new ClaimsIdentity(claimList);
            var principal = new ClaimsPrincipal(identity);
            httpContext.User = principal;

            return _next(httpContext);
        }
    }
}

JwtAuthorizationFilter

2.3 Startup

完整代碼：

using System.Collections.Generic;
using System.IO;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.PlatformAbstractions;
using Swashbuckle.AspNetCore.Swagger;
using RayPI.Model.ConfigModel;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.IdentityModel.Tokens;
using System.Text;
using RayPI.AuthHelp;

namespace RayPI
{
    /// <summary>
    /// 
    /// </summary>
    public class Startup
    {
        /// <summary>
        /// 
        /// </summary>
        /// <param name="env"></param>
        public Startup(IHostingEnvironment env)
        {
            var builder = new ConfigurationBuilder()
                .SetBasePath(env.ContentRootPath)
                .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);

            this.Configuration = builder.Build();

            BaseConfigModel.SetBaseConfig(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.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 apiXmlPath = Path.Combine(basePath, "APIHelp.xml");
                var entityXmlPath = Path.Combine(basePath, "EntityHelp.xml"); 
                c.IncludeXmlComments(apiXmlPath, true);//控制器層註釋（true表示顯示控制器註釋）
                c.IncludeXmlComments(entityXmlPath);

                //添加控制器註釋
                //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 認證
            services.AddAuthentication(x =>
                {
                    x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
                    x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
                })
                .AddJwtBearer(o =>
                {
                    JwtAuthConfigModel jwtConfig=new JwtAuthConfigModel();
                    o.TokenValidationParameters = new TokenValidationParameters
                    {
                        ValidIssuer = "RayPI",
                        ValidAudience = "wr",
                        IssuerSigningKey = new SymmetricSecurityKey(Encoding.ASCII.GetBytes(jwtConfig.JWTSecretKey)),

                        /***********************************TokenValidationParameters的參數默認值***********************************/
                        RequireSignedTokens = true,
                        // SaveSigninToken = false,
                        // ValidateActor = false,
                        // 將下面兩個參數設置爲false，能夠不驗證Issuer和Audience，可是不建議這樣作。
                        ValidateAudience = false,
                        ValidateIssuer = true,
                        ValidateIssuerSigningKey = true,
                        // 是否要求Token的Claims中必須包含 Expires
                        RequireExpirationTime = true,
                        // 容許的服務器時間偏移量
                        // ClockSkew = TimeSpan.FromSeconds(300),
                        // 是否驗證Token有效期，使用當前時間與Token的Claims中的NotBefore和Expires對比
                        ValidateLifetime = true
                    };
                });
            #endregion

            #region 受權
            services.AddAuthorization(options =>
            {
                options.AddPolicy("RequireClient", policy => policy.RequireRole("Client").Build());
                options.AddPolicy("RequireAdmin", policy => policy.RequireRole("Admin").Build());
                options.AddPolicy("RequireAdminOrClient", policy => policy.RequireRole("Admin,Client").Build());
            });
            #endregion

            #region CORS
            services.AddCors(c =>
            {
                c.AddPolicy("Any", policy =>
                 {
                     policy.AllowAnyOrigin()
                     .AllowAnyMethod()
                     .AllowAnyHeader()
                     .AllowCredentials();
                 });

                c.AddPolicy("Limit", policy =>
                 {
                     policy
                     .WithOrigins("localhost:8083")
                     .WithMethods("get", "post", "put", "delete")
                     //.WithHeaders("Authorization");
                     .AllowAnyHeader();
                 });
            });
            #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

            //認證
            app.UseAuthentication();

            //受權
            app.UseMiddleware<JwtAuthorizationFilter>();

            app.UseMvc();

            app.UseStaticFiles();//用於訪問wwwroot下的文件 
        }
    }
}

Startup

Tips：

這裏有一個坑，不太瞭解依賴注入和中間件的人很容易踩到（其實就是我本身了）

在Startup.cs的Configure函數中，裏面每一個app.UseXXXXX();是有必定順序。能夠理解爲，這裏添加中間件的順序就是客戶端發起http請求時所通過的順序。

以前我由於把「app.UseMvc();」寫到了認證受權上面去了，結果致使怎麼Debug都找不到問題。。。

因此必定要先app.UseAuthentication()認證，而後app.UseMiddleware<JwtAuthorizationFilter>()受權，最後再app.UseMvc()

3.果

搭建完成以後，下面就是測試了。

選擇一個測試控制器，在其頭上標註[Authorize]屬性

（Policy和Roles兩種寫法是一個意思，可是必需要是Startup中已經申明的，不然Swagger會直接報錯）

F5運行，在swagger ui中調用一個須要受權驗證的接口（根據Id獲取學生信息）

輸入1，先不進行任何受權認證的操做，直接點擊Excute嘗試調用，返回結果以下：

狀態碼500，還返回了一大段html代碼，咱們能夠將接口的完整地址輸入到瀏覽器地址欄進行訪問，就能夠看到這段html代碼的頁面了：

能夠看到接口返回了一個錯誤頁，緣由就是中間件在http請求的頭部（headers）中沒有找到「Authorization"字段裏的」令牌「。

如今，咱們先調用獲取JWT接口（實際項目中不該該有該接口，分發令牌的功能應該集成到登錄功能中，可是這裏爲了簡單直觀，我將分發令牌的功能直接寫成了接口，以供測試），輸入相應的客戶端信息，Excute:

接口會生成」令牌「，返回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)) } });