基于 abp vNext 和 .NET Core 开发博客项目 - 接入GitHub，用JWT保护你的API

时间  2020-11-30
标签 html git github web json api 安全 服务器 微信 app 栏目 Git 繁體版
原文   原文链接

上一篇文章(http://www.javashuo.com/article/p-ktmtutos-kr.html)再次把Swagger的使用进行了讲解，完成了对Swagger的分组、描述和开启小绿锁以进行身份的认证受权，那么本篇就来讲说身份认证受权。html

开始以前先搞清楚几个概念，请注意认证与受权是不一样的意思，简单理解：认证，是证实你的身份，你有帐号密码，你能够登陆进咱们的系统，说明你认证成功了；受权，即权限，分配给用户某一权限标识，用户获得什么什么权限，才能使用系统的某一功能，就是受权。git

身份认证能够有不少种方式，能够建立一个用户表，使用帐号密码，也能够接入第三方平台，在这里我接入GitHub进行身份认证。固然你能够选择其余方式(如：QQ、微信、微博等)，能够本身扩展。github

打开GitHub，进入开发者设置界面(https://github.com/settings/developers)，咱们新建一个 oAuth App。web

0

1

如图所示，咱们将要用到敏感数据放在appsettings.json中json

{
  ...
  "Github": {
    "UserId": 13010050,
    "ClientID": "5956811a5d04337ec2ca",
    "ClientSecret": "8fc1062c39728a8c2a47ba445dd45165063edd92",
    "RedirectUri": "https://localhost:44388/account/auth",
    "ApplicationName": "阿星Plus"
  }
}

ClientID和ClientSecret是GitHub为咱们生成的，请注意保管好你的ClientID和ClientSecret。我这里直接给出了明文，我将在本篇结束后删掉此 oAuth App 😝。请本身建立噢！api

RedirectUri是咱们本身添加的回调地址。ApplicationName是咱们应用的名称，所有都要和GitHub对应。安全

相应的在AppSettings.cs中读取服务器

...
        /// <summary>
        /// GitHub
        /// </summary>
        public static class GitHub
        {
            public static int UserId => Convert.ToInt32(_config["Github:UserId"]);

            public static string Client_ID => _config["Github:ClientID"];

            public static string Client_Secret => _config["Github:ClientSecret"];

            public static string Redirect_Uri => _config["Github:RedirectUri"];

            public static string ApplicationName => _config["Github:ApplicationName"];
        }
...

接下来，咱们你们自行去GitHub的OAuth官方文档看看，https://developer.github.com/apps/building-oauth-apps/authorizing-oauth-apps/微信

分析一下，咱们接入GitHub身份认证受权整个流程下来分如下几步app

  1. 根据参数生成GitHub重定向的地址，跳转到GitHub登陆页，进行登陆
  2. 登陆成功以后会跳转到咱们的回调地址，回调地址会携带code参数
  3. 拿到code参数，就能够换取到access_token
  4. 有了access_token，能够调用GitHub获取用户信息的接口，获得当前登陆成功的用户信息

开始以前，先将GitHub的API简单处理一下。

在.Domain层中Configurations文件夹下新建GitHubConfig.cs配置类，将所须要的API以及appsettings.json的内容读取出来。

//GitHubConfig.cs
namespace Meowv.Blog.Domain.Configurations
{
    public class GitHubConfig
    {
        /// <summary>
        /// GET请求，跳转GitHub登陆界面，获取用户受权，获得code
        /// </summary>
        public static string API_Authorize = "https://github.com/login/oauth/authorize";

        /// <summary>
        /// POST请求，根据code获得access_token
        /// </summary>
        public static string API_AccessToken = "https://github.com/login/oauth/access_token";

        /// <summary>
        /// GET请求，根据access_token获得用户信息
        /// </summary>
        public static string API_User = "https://api.github.com/user";

        /// <summary>
        /// Github UserId
        /// </summary>
        public static int UserId = AppSettings.GitHub.UserId;

        /// <summary>
        /// Client ID
        /// </summary>
        public static string Client_ID = AppSettings.GitHub.Client_ID;

        /// <summary>
        /// Client Secret
        /// </summary>
        public static string Client_Secret = AppSettings.GitHub.Client_Secret;

        /// <summary>
        /// Authorization callback URL
        /// </summary>
        public static string Redirect_Uri = AppSettings.GitHub.Redirect_Uri;

        /// <summary>
        /// Application name
        /// </summary>
        public static string ApplicationName = AppSettings.GitHub.ApplicationName;
    }
}

细心的同窗可能以及看到了，咱们在配置的时候多了一个UserId。在这里使用一个策略，由于我是博客系统，管理员用户就只有我一我的，GitHub的用户Id是惟一的，我将本身的UserId配置进去，当咱们经过api获取到UserId和本身配置的UserId一致时，就为其受权，你就是我，我承认你，你能够进入后台随意玩耍了。

在开始写接口以前，还有一些工做要作，就是在 .net core 中开启使用咱们的身份认证和受权，由于.HttpApi.Hosting层引用了项目.Application，.Application层自己也须要添加Microsoft.AspNetCore.Authentication.JwtBearer，因此在.Application添加包：Microsoft.AspNetCore.Authentication.JwtBearer，打开程序包管理器控制台用命令Install-Package Microsoft.AspNetCore.Authentication.JwtBearer安装，这样就不须要重复添加引用了。

在.HttpApi.Hosting模块类MeowvBlogHttpApiHostingModule，ConfigureServices中添加

public override void ConfigureServices(ServiceConfigurationContext context)
{
    // 身份验证
    context.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
           .AddJwtBearer(options =>
           {
               options.TokenValidationParameters = new TokenValidationParameters
               {
                   ValidateIssuer = true,
                   ValidateAudience = true,
                   ValidateLifetime = true,
                   ClockSkew = TimeSpan.FromSeconds(30),
                   ValidateIssuerSigningKey = true,
                   ValidAudience = AppSettings.JWT.Domain,
                   ValidIssuer = AppSettings.JWT.Domain,
                   IssuerSigningKey = new SymmetricSecurityKey(AppSettings.JWT.SecurityKey.GetBytes())
               };
           });

    // 认证受权
    context.Services.AddAuthorization();

    // Http请求
    context.Services.AddHttpClient();
}

由于待会咱们要在代码中调用GitHub的api，因此这里提早将System.Net.Http.IHttpClientFactory和相关服务添加到IServiceCollection中。

解释一下TokenValidationParameters参数的含义：

ValidateIssuer：是否验证颁发者。ValidateAudience：是否验证访问群体。ValidateLifetime：是否验证生存期。ClockSkew：验证Token的时间偏移量。ValidateIssuerSigningKey：是否验证安全密钥。ValidAudience：访问群体。ValidIssuer：颁发者。IssuerSigningKey：安全密钥。
GetBytes()是abp的一个扩展方法，能够直接使用。

设置值所有为true，时间偏移量为30秒，而后将ValidAudience、ValidIssuer、IssuerSigningKey的值配置在appsettings.json中，这些值都是能够自定义的，不必定按照我填的来。

//appsettings.json
{
  ...
  "JWT": {
    "Domain": "https://localhost:44388",
    "SecurityKey": "H4sIAAAAAAAAA3N0cnZxdXP38PTy9vH18w8I9AkOCQ0Lj4iMAgDB4fXPGgAAAA==",
    "Expires": 30
  }
}

//AppSettings.cs
...
        public static class JWT
        {
            public static string Domain => _config["JWT:Domain"];

            public static string SecurityKey => _config["JWT:SecurityKey"];

            public static int Expires => Convert.ToInt32(_config["JWT:Expires"]);
        }
...

Expires是咱们的token过时时间，这里也给个30。至于它是30分钟仍是30秒，由你本身决定。

SecurityKey是我随便用编码工具进行生成的。

同时在OnApplicationInitialization(ApplicationInitializationContext context)中使用它。

...
        public override void OnApplicationInitialization(ApplicationInitializationContext context)
        {
            ...
            // 身份验证
            app.UseAuthentication();

            // 认证受权
            app.UseAuthorization();
            ...
        }
...

此时配置就完成了，接下来去写接口生成Token并在Swagger中运用起来。

在.Application层以前已经添加了包：Microsoft.AspNetCore.Authentication.JwtBearer，直接新建Authorize文件夹，添加接口IAuthorizeService以及实现类AuthorizeService。

//IAuthorizeService.cs
using Meowv.Blog.ToolKits.Base;
using System.Threading.Tasks;

namespace Meowv.Blog.Application.Authorize
{
    public interface IAuthorizeService
    {
        /// <summary>
        /// 获取登陆地址(GitHub)
        /// </summary>
        /// <returns></returns>
        Task<ServiceResult<string>> GetLoginAddressAsync();

        /// <summary>
        /// 获取AccessToken
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        Task<ServiceResult<string>> GetAccessTokenAsync(string code);

        /// <summary>
        /// 登陆成功，生成Token
        /// </summary>
        /// <param name="access_token"></param>
        /// <returns></returns>
        Task<ServiceResult<string>> GenerateTokenAsync(string access_token);
    }
}

添加三个接口成员方法，所有为异步的方式，同时注意咱们是用以前编写的返回模型接收噢，而后一一去实现他们。

先实现GetLoginAddressAsync()，我们构建一个AuthorizeRequest对象，用来填充生成GitHub登陆地址，在.ToolKits层新建GitHub文件夹，引用.Domain项目，添加类：AuthorizeRequest.cs。

//AuthorizeRequest.cs
using Meowv.Blog.Domain.Configurations;
using System;

namespace Meowv.Blog.ToolKits.GitHub
{
    public class AuthorizeRequest
    {
        /// <summary>
        /// Client ID
        /// </summary>
        public string Client_ID = GitHubConfig.Client_ID;

        /// <summary>
        /// Authorization callback URL
        /// </summary>
        public string Redirect_Uri = GitHubConfig.Redirect_Uri;

        /// <summary>
        /// State
        /// </summary>
        public string State { get; set; } = Guid.NewGuid().ToString("N");

        /// <summary>
        /// 该参数可选，须要调用Github哪些信息，能够填写多个，以逗号分割，好比：scope=user,public_repo。
        /// 若是不填写，那么你的应用程序将只能读取Github公开的信息，好比公开的用户信息，公开的库(repository)信息以及gists信息
        /// </summary>
        public string Scope { get; set; } = "user,public_repo";
    }
}

实现方法以下，拼接参数，输出GitHub重定向的地址。

...
        /// <summary>
        /// 获取登陆地址(GitHub)
        /// </summary>
        /// <returns></returns>
        public async Task<ServiceResult<string>> GetLoginAddressAsync()
        {
            var result = new ServiceResult<string>();

            var request = new AuthorizeRequest();
            var address = string.Concat(new string[]
            {
                    GitHubConfig.API_Authorize,
                    "?client_id=", request.Client_ID,
                    "&scope=", request.Scope,
                    "&state=", request.State,
                    "&redirect_uri=", request.Redirect_Uri
            });

            result.IsSuccess(address);
            return await Task.FromResult(result);
        }
...

一样的，实现GetAccessTokenAsync(string code)，构建AccessTokenRequest对象，在.ToolKitsGitHub文件夹添加类：AccessTokenRequest.cs。

//AccessTokenRequest.cs
using Meowv.Blog.Domain.Configurations;

namespace Meowv.Blog.ToolKits.GitHub
{
    public class AccessTokenRequest
    {
        /// <summary>
        /// Client ID
        /// </summary>
        public string Client_ID = GitHubConfig.Client_ID;

        /// <summary>
        /// Client Secret
        /// </summary>
        public string Client_Secret = GitHubConfig.Client_Secret;

        /// <summary>
        /// 调用API_Authorize获取到的Code值
        /// </summary>
        public string Code { get; set; }

        /// <summary>
        /// Authorization callback URL
        /// </summary>
        public string Redirect_Uri = GitHubConfig.Redirect_Uri;

        /// <summary>
        /// State
        /// </summary>
        public string State { get; set; }
    }
}

根据登陆成功获得的code来获取AccessToken，由于涉及到HTTP请求，在这以前咱们须要在构造函数中依赖注入IHttpClientFactory，使用IHttpClientFactory建立HttpClient。

...
private readonly IHttpClientFactory _httpClient;

public AuthorizeService(IHttpClientFactory httpClient)
{
    _httpClient = httpClient;
}
...
...
        /// <summary>
        /// 获取AccessToken
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        public async Task<ServiceResult<string>> GetAccessTokenAsync(string code)
        {
            var result = new ServiceResult<string>();

            if (string.IsNullOrEmpty(code))
            {
                result.IsFailed("code为空");
                return result;
            }

            var request = new AccessTokenRequest();

            var content = new StringContent($"code={code}&client_id={request.Client_ID}&redirect_uri={request.Redirect_Uri}&client_secret={request.Client_Secret}");
            content.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded");

            using var client = _httpClient.CreateClient();
            var httpResponse = await client.PostAsync(GitHubConfig.API_AccessToken, content);

            var response = await httpResponse.Content.ReadAsStringAsync();

            if (response.StartsWith("access_token"))
                result.IsSuccess(response.Split("=")[1].Split("&").First());
            else
                result.IsFailed("code不正确");

            return result;
        }
...

使用IHttpClientFactory建立HttpClient能够自动释放对象，用HttpClient发送一个POST请求，若是GitHub服务器给咱们返回了带access_token的字符串便表示成功了，将其处理一下输出access_token。若是没有，就表明参数code有误。

在.HttpApi层新建一个AuthController控制器，注入咱们的IAuthorizeServiceService，试试咱们的接口。

//AuthController.cs
using Meowv.Blog.Application.Authorize;
using Meowv.Blog.ToolKits.Base;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;
using Volo.Abp.AspNetCore.Mvc;
using static Meowv.Blog.Domain.Shared.MeowvBlogConsts;

namespace Meowv.Blog.HttpApi.Controllers
{
    [ApiController]
    [AllowAnonymous]
    [Route("[controller]")]
    [ApiExplorerSettings(GroupName = Grouping.GroupName_v4)]
    public class AuthController : AbpController
    {
        private readonly IAuthorizeService _authorizeService;

        public AuthController(IAuthorizeService authorizeService)
        {
            _authorizeService = authorizeService;
        }

        /// <summary>
        /// 获取登陆地址(GitHub)
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [Route("url")]
        public async Task<ServiceResult<string>> GetLoginAddressAsync()
        {
            return await _authorizeService.GetLoginAddressAsync();
        }

        /// <summary>
        /// 获取AccessToken
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("access_token")]
        public async Task<ServiceResult<string>> GetAccessTokenAsync(string code)
        {
            return await _authorizeService.GetAccessTokenAsync(code);
        }
    }
}

注意这里咱们添加了两个Attribute：[AllowAnonymous]、[ApiExplorerSettings(GroupName = Grouping.GroupName_v4)]，在.Swagger层中为AuthController添加描述信息

...
new OpenApiTag {
    Name = "Auth",
    Description = "JWT模式认证受权",
    ExternalDocs = new OpenApiExternalDocs { Description = "JSON Web Token" }
}
...

打开Swagger文档，调用一下咱们两个接口看看效果。

3

而后打开咱们生成的重定向地址，会跳转到登陆页面，以下：

4

点击Authorize按钮，登陆成功后会跳转至咱们配置的回调页面，.../account/auth?code=10b7a58c7ba2e4414a14&state=a1ef05212c3b4a2cb2bbd87846dd4a8e

而后拿到code(10b7a58c7ba2e4414a14)，在去调用一下获取AccessToken接口，成功返回咱们的access_token(97eeafd5ca01b3719f74fc928440c89d59f2eeag)。

5

拿到access_token，就能够去调用获取用户信息API了。在这以前咱们先来写几个扩展方法，待会和之后都用得着，在.ToolKits层新建文件夹Extensions，添加几个比较经常使用的扩展类(...)。

扩展类的代码我就不贴出来了。你们能够去GitHub(https://github.com/Meowv/Blog/tree/blog_tutorial/src/Meowv.Blog.ToolKits/Extensions)自行下载，每一个扩展方法都有具体的注释。

接下来实现GenerateTokenAsync(string access_token)，生成Token。

有了access_token，能够直接调用获取用户信息的接口：https://api.github.com/user?access_token=97eeafd5ca01b3719f74fc928440c89d59f2eeag ，会获得一个json，将这个json包装成一个模型类UserResponse.cs。

在这里教你们一个小技巧，若是你须要将json或者xml转换成模型类，可使用Visual Studio的一个快捷功能，点击左上角菜单：编辑 => 选择性粘贴 => 将JSON粘贴为类/将XML粘贴为类，是否是很方便，快去试试吧。

//UserResponse.cs
namespace Meowv.Blog.ToolKits.GitHub
{
    public class UserResponse
    {
        public string Login { get; set; }

        public int Id { get; set; }

        public string Avatar_url { get; set; }

        public string Html_url { get; set; }

        public string Repos_url { get; set; }

        public string Name { get; set; }

        public string Company { get; set; }

        public string Blog { get; set; }

        public string Location { get; set; }

        public string Email { get; set; }

        public string Bio { get; set; }

        public int Public_repos { get; set; }
    }
}

而后看一下具体生成token的方法吧。

...
        /// <summary>
        /// 登陆成功，生成Token
        /// </summary>
        /// <param name="access_token"></param>
        /// <returns></returns>
        public async Task<ServiceResult<string>> GenerateTokenAsync(string access_token)
        {
            var result = new ServiceResult<string>();

            if (string.IsNullOrEmpty(access_token))
            {
                result.IsFailed("access_token为空");
                return result;
            }

            var url = $"{GitHubConfig.API_User}?access_token={access_token}";
            using var client = _httpClient.CreateClient();
            client.DefaultRequestHeaders.Add("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.14 Safari/537.36 Edg/83.0.478.13");
            var httpResponse = await client.GetAsync(url);
            if (httpResponse.StatusCode != HttpStatusCode.OK)
            {
                result.IsFailed("access_token不正确");
                return result;
            }

            var content = await httpResponse.Content.ReadAsStringAsync();

            var user = content.FromJson<UserResponse>();
            if (user.IsNull())
            {
                result.IsFailed("未获取到用户数据");
                return result;
            }

            if (user.Id != GitHubConfig.UserId)
            {
                result.IsFailed("当前帐号未受权");
                return result;
            }

            var claims = new[] {
                    new Claim(ClaimTypes.Name, user.Name),
                    new Claim(ClaimTypes.Email, user.Email),
                    new Claim(JwtRegisteredClaimNames.Exp, $"{new DateTimeOffset(DateTime.Now.AddMinutes(AppSettings.JWT.Expires)).ToUnixTimeSeconds()}"),
                    new Claim(JwtRegisteredClaimNames.Nbf, $"{new DateTimeOffset(DateTime.Now).ToUnixTimeSeconds()}")
                };

            var key = new SymmetricSecurityKey(AppSettings.JWT.SecurityKey.SerializeUtf8());
            var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);

            var securityToken = new JwtSecurityToken(
                issuer: AppSettings.JWT.Domain,
                audience: AppSettings.JWT.Domain,
                claims: claims,
                expires: DateTime.Now.AddMinutes(AppSettings.JWT.Expires),
                signingCredentials: creds);

            var token = new JwtSecurityTokenHandler().WriteToken(securityToken);

            result.IsSuccess(token);
            return await Task.FromResult(result);
        }
...

GitHub的这个API作了相应的安全机制，有一点要注意一下，当咱们用代码去模拟请求的时候，须要给他加上User-Agent，否则是不会成功返回结果的。

FromJson<T>是以前咱们添加的扩展方法，将JSON字符串转为实体对象。

SymmetricSecurityKey(byte[] key)接收一个byte[]参数，这里也用到一个扩展方法SerializeUtf8()字符串序列化成字节序列。

咱们判断返回的Id是否为咱们配置的用户Id，若是是的话，就验证成功，进行受权，生成Token。

生成Token的代码也很简单，指定了 Name，Email，过时时间为30分钟。具体各项含义能够去这里看看：https://tools.ietf.org/html/rfc7519。

最后调用new JwtSecurityTokenHandler().WriteToken(SecurityToken token)即可成功生成Token，在Controller添加好，去试试吧。

...
        /// <summary>
        /// 登陆成功，生成Token
        /// </summary>
        /// <param name="access_token"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("token")]
        public async Task<ServiceResult<string>> GenerateTokenAsync(string access_token)
        {
            return await _authorizeService.GenerateTokenAsync(access_token);
        }
...

6

将以前拿到的access_token传进去，调用接口能够看到已经成功生成了token。

前面为AuthController添加了一个Attribute：[AllowAnonymous]，表明这个Controller下的接口都不须要受权，就能够访问，固然你不添加的话默认也是开放的。能够为整个Controller指定，同时也能够为具体的接口指定。

当想要保护某个接口时，只须要加上Attribute：[Authorize]就能够了。如今来保护咱们的BlogController下非查询接口，给增删改添加上[Authorize]，注意引用命名空间Microsoft.AspNetCore.Authorization。

...
        ...
        /// <summary>
        /// 添加博客
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [Authorize]
        public async Task<ServiceResult<string>> InsertPostAsync([FromBody] PostDto dto)
        ...

        /// <summary>
        /// 删除博客
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpDelete]
        [Authorize]
        public async Task<ServiceResult> DeletePostAsync([Required] int id)
        ...

        /// <summary>
        /// 更新博客
        /// </summary>
        /// <param name="id"></param>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPut]
        [Authorize]
        public async Task<ServiceResult<string>> UpdatePostAsync([Required] int id, [FromBody] PostDto dto)
        ...

        /// <summary>
        /// 查询博客
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet]
        public async Task<ServiceResult<PostDto>> GetPostAsync([Required] int id)
        ...
...

如今编译运行一下，调用上面的增删改看看能不能成功？

7

这时接口就会直接给咱们返回一个状态码为401的错误，为了不这种不友好的错误，咱们能够添加一个中间件来处理咱们的管道请求或者在AddJwtBearer()中处理咱们的身份验证事件机制，当遇到错误的状态码时，咱们仍是返回咱们以前的建立的模型，定义友好的返回错误，将在后面篇章中给出具体方法。

能够看到公开的API和须要受权的API小绿锁是不同的，公开的显示为黑色，须要受权的显示为灰色。

若是须要在Swagger中调用咱们的非公开API，要怎么作呢？点击咱们的小绿锁将生成的token按照Bearer {Token}的方式填进去便可。

8

注意不要点Logout，不然就退出了。

9

能够看到当咱们请求的时候，请求头上多了一个authorization: Bearer {token}，此时便大功告成了。当咱们在web中调用的时候，也遵循这个规则便可。

特别提示

在我作受权的时候，token也生成成功了，也在Swagger中正确填写Bearer {token}了。调用接口的时候始终仍是返回401，最终发现致使这个问题的缘由是在配置Swagger小绿锁时一个错误名称致使的。

10

看他的描述为：A unique name for the scheme, as per the Swagger spec.(根据Swagger规范，该方案的惟一名称)

如图，将其名称改成 "oauth2" ，即可以成功受权。本篇接入了GitHub，实现了认证和受权，用JWT的方式保护咱们写的API，你学会了吗？😁😁😁

开源地址：https://github.com/Meowv/Blog/tree/blog_tutorial

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程