ASP.NET Core 6.0 添加 JWT 认证和授权功能

更新时间：2022年04月16日 10:24:17 作者：芦荟柚子茶

这篇文章主要介绍了ASP.NET Core 6.0 添加 JWT 认证和授权,本文将分别介绍 Authentication（认证）和 Authorization（授权），通过实例代码分别介绍了这两个功能，需要的朋友可以参考下

序言

本文将分别介绍 Authentication（认证）和 Authorization（授权）。

并以简单的例子在 ASP.NET Core 6.0 的 WebAPI 中分别实现这两个功能。

认证（Authentication）

基本步骤

安装相关 Nuget 包：Microsoft.AspNetCore.Authentication.JwtBearer
准备配置信息（密钥等）
添加服务
调用中间件
实现一个 JwtHelper，用于生成 Token
控制器限制访问（添加 Authorize 标签）

1 安装 Nuget 包

安装 Microsoft.AspNetCore.Authentication.JwtBearer

在程序包管理器控制台中：

Install-Package Microsoft.AspNetCore.Authentication.JwtBearer -Version 6.0.1

2 准备配置信息

在 appsetting.json 中，添加一个 Jwt 节点

"Jwt": {
    "SecretKey": "lisheng741@qq.com",
    "Issuer": "WebAppIssuer",
    "Audience": "WebAppAudience"
}

3 添加服务

在 Program.cs 文件中注册服务。

// 引入所需的命名空间
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.IdentityModel.Tokens;
using System.Text;

// ……
var configuration = builder.Configuration;

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

4 调用中间件

调用 UseAuthentication（认证），必须在所有需要身份认证的中间件前调用，比如 UseAuthorization（授权）。

// ……
app.UseAuthentication();
app.UseAuthorization();
// ……

5 JwtHelper 类实现

主要是用于生成 JWT 的 Token。

using Microsoft.IdentityModel.Tokens;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;
namespace TestWebApi;
public class JwtHelper
{
    private readonly IConfiguration _configuration;
    public JwtHelper(IConfiguration configuration)
    {
        _configuration = configuration;
    }
    public string CreateToken()
        // 1. 定义需要使用到的Claims
        var claims = new[]
        {
            new Claim(ClaimTypes.Name, "u_admin"), //HttpContext.User.Identity.Name
            new Claim(ClaimTypes.Role, "r_admin"), //HttpContext.User.IsInRole("r_admin")
            new Claim(JwtRegisteredClaimNames.Jti, "admin"),
            new Claim("Username", "Admin"),
            new Claim("Name", "超级管理员")
        };
        // 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(
            _configuration["Jwt:Issuer"],     //Issuer
            _configuration["Jwt:Audience"],   //Audience
            claims,                          //Claims,
            DateTime.Now,                    //notBefore
            DateTime.Now.AddSeconds(30),    //expires
            signingCredentials               //Credentials
        );
        // 6. 将token变为string
        var token = new JwtSecurityTokenHandler().WriteToken(jwtSecurityToken);
        return token;
}

该 JwtHelper 依赖于 IConfiguration（为了读取配置文件），将 JwtHelper 的创建交由 DI 容器，在 Program.cs 中添加服务：

var configuration = builder.Configuration;
builder.Services.AddSingleton(new JwtHelper(configuration));

将 JwtHelper 注册为单例模式。

6 控制器配置

新建一个 AccountController，以构造函数方式注入 JwtHelper，添加两个 Action：GetToken 用于获取 Token，GetTest 打上 [Authorize] 标签用于验证认证。

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
namespace TestWebApi.Controllers;
[Route("api/[controller]/[action]")]
[ApiController]
public class AccountController : ControllerBase
{
    private readonly JwtHelper _jwtHelper;
    public AccountController(JwtHelper jwtHelper)
    {
        _jwtHelper = jwtHelper;
    }
    [HttpGet]
    public ActionResult<string> GetToken()
    {
        return _jwtHelper.CreateToken();
    }
    [Authorize]
    [HttpGet]
    public ActionResult<string> GetTest()
    {
        return "Test Authorize";
    }
}

7 测试调用

方式一：通过 Postman、Apifox 等接口调试软件调试

使用 Postman 调用 /api/Account/GetToken 生成 Token

在调用 /api/Account/GetTest 时传入 Token，得到返回结果

方式二：在浏览器控制台调试

调试 /api/Account/GetToken

var xhr = new XMLHttpRequest();
xhr.addEventListener("readystatechange", function() {
   if(this.readyState === 4) {
      console.log(token = this.responseText); //这里用了一个全局变量 token，为下一个接口服务
   }
});
xhr.open("GET", "/api/Account/GetToken");
xhr.send();

调试 /api/Account/GetTest

var xhr = new XMLHttpRequest();
xhr.addEventListener("readystatechange", function() {
   if(this.readyState === 4) {
      console.log(this.status, this.responseText); //this.status为响应状态码，401为无认证状态
   }
});
xhr.open("GET", "/api/Account/GetTest");
xhr.setRequestHeader("Authorization",`Bearer ${token}`); //附带上 token
xhr.send();

授权（Authorization）

注意：授权必须基于认证，即：若没有完成上文关于认证的配置，则下面的授权是不会成功的。

授权部分，将先介绍相关标签、授权方式，再介绍基于策略的授权。这三部分大致的内容如下描述：

相关标签：Authorize 和 AllowAnonymous

授权方式：介绍 Policy、Role、Scheme 的基本内容

基于策略（Policy）的授权：深入 Policy 授权方式

授权方式

基本上授权只有：Policy、Role、Scheme 这3种方式，对应 Authorize 标签的3个属性。

1 Policy（策略）

推荐的授权方式，在 ASP.NET Core 的官方文档提及最多的。一个 Policy 可以包含多个要求（要求可能是 Role 匹配，也可能是 Claims 匹配，也可能是其他方式。）

下面举个基础例子（说是基础例子，主要是基于 Policy 的授权方式可以不断深入追加一些配置）：

在 Program.cs 中，添加两条 Policy：

policy1 要求用户拥有一个 Claim，其 ClaimType 值为 EmployeeNumber。

policy2 要求用户拥有一个 Claim，其 ClaimType 值为 EmployeeNumber，且其 ClaimValue 值为1、2、3、4 或 5。

builder.Services.AddAuthorization(options => {
    options.AddPolicy("policy1", policy => policy.RequireClaim("EmployeeNumber"));
    options.AddPolicy("policy2", policy => policy.RequireClaim("EmployeeNumber", "1", "2", "3", "4", "5"));
})

在控制器中添加 [Authorize] 标签即可生效：

[Authorize(Policy = "policy1")]
public class TestController : ControllerBase

或在控制器的 Action 上：

public class TestController : ControllerBase
{
    [Authorize(Policy = "policy1")]
    public ActionResult<string> GetTest => "GetTest";
}

2 Role（角色）

基于角色授权，只要用户拥有角色，即可通过授权验证。

在认证时，给用户添加角色相关的 Claim ，即可标识用户拥有的角色（注：一个用户可以拥有多个角色的 Claim），如：

new Claim(ClaimTypes.Role, "admin"),
new Claim(ClaimTypes.Role, "user")

在 Controller 或 Action 中：

[Authorize(Roles = "user")]
public class TestController : ControllerBase
{
    public ActionResult<string> GetUser => "GetUser";
    
    [Authorize(Roles = "admin")] //与控制器的Authorize叠加作用，除了拥有user，还需拥有admin
    public ActionResult<string> GetAdmin => "GetAdmin";
    
    [Authorize(Roles = "user,admin")] //user 或 admin 其一满足即可
    public ActionResult<string> GetUserOrAdmin => "GetUserOrAdmin";
}

3 Scheme（方案）

方案如：Cookies 和 Bearer，当然也可以是自定义的方案。

由于这种方式不常用，这里不做展开，请参考官方文档按方案限制标识。

基于策略（Policy）的授权

上面已经提及了一个基于策略授权的基础例子，下面将继续深入这种授权方式。

1 授权过程

在不断深入 Policy 这种方式的授权之前，有必要将授权的过程描述一下。授权过程描述建议结合源码查看，这样能更清楚其中的作用。当然，这一部分是比较难懂，笔者表述可能也不够清晰，而这一部分对于完成授权的配置也不会有影响，故而如果读者看不明白或无法理解，可以暂且跳过，不必纠结。

建议看一下ASP.NET Core使用JWT认证授权的方法这篇文章，文章将授权相关的源码整理出来了，并说明了其中的关系。

这里简单梳理一下：

与授权相关的 interface 和 class 如下：

IAuthorizationService #验证授权的服务，主要方法AuthorizeAsync
DefaultAuthorizationService #IAuthorizationService的默认实现
IAuthorizationHandler #负责检查是否满足要求，主要方法HandleAsync
IAuthorizationRequirement #只有属性，没有方法；用于标记服务，以及用于追踪授权是否成功的机制。
AuthorizationHandler<TRequirement> #主要方法HandleRequirementAsync

这些 interface 和 class 的关系以及授权过程是这样的：

DefaultAuthorizationService 实现 IAuthorizationService 的 AuthorizeAsync 方法。

AuthorizeAsync 方法会获取到所有实现了 IAuthorizationHandler 的实例，并循环调用所有实例的 HandleAsync 方法检查是否满足授权要求，如果有任一一个 HandleAsync 返回了 Fail 则将结束循环（细节请参考官方文档处理程序返回结果），并禁止用户访问。

IAuthorizationHandler 的作用如上一点所述，提供了一个 HandleAsync 方法，用于检查授权。

IAuthorizationRequirement 是一个要求，主要是配合 AuthorizationHandler<TRequirement> 使用。

AuthorizationHandler<TRequirement> 实现了 IAuthorizationHandler 的 HandleAsync 方法，并提供了一个 HandleRequirementAsync 的方法。HandleRequirementAsync 用于检查 Requirement（要求）是否满足。HandleAsync 的默认实现为获取所有实现 TRequirement 的请求（且该请求由 Policy 添加进列表里），循环调用 HandleRequirementAsync，检查哪个要求（Requirement）能满足授权。

简述一下：

[Authorize] 标签生效时，调用的是 IAuthorizationService 的 AuthorizeAsync（由 DefaultAuthorizationService 实现）。

AuthorizeAsync 会去调用所有 IAuthorizationHandler 的 HandleAsync （由 AuthorizationHandler<TRequirement> 实现）。

HandleAsync 会去调用 AuthorizationHandler<TRequirement> 的HandleRequirementAsync 的方法。

注意：这里只是列出了主要的接口和类，部分没有列出，如：IAuthorizationHandlerProvider（这个接口的默认实现 DefaultAuthorizationHandlerProvider，主要是用于收集 IAuthorizationHandler 并返回 IEnumerable<IAuthorizationHandler>）

2 实现说明

IAuthorizationService 已默认实现，不需要我们做额外工作。

IAuthorizationHandler 由 AuthorizationHandler<TRequirement> 实现。

所以我们要做的，是：

第一步，准备 Requirement 实现 IAuthorizationRequirement

第二步，添加一个 Handler 程序继承 AuthorizationHandler<TRequirement> 并重写 HandleRequirementAsync 方法

关于具体实现，可以参考asp.net core 授权详解基于权限的授权部分，该文章思路已十分清晰，这里将其主要步骤列出来。

3 定义权限项

在实现 Requirement 之前，我们需要先定义一些权限项，主要用于后续作为 Policy 的名称，并传入我们实现的 Requirement 之中。

public static class UserPermission
{
    public const string User = "User";
    public const string UserCreate = User + ".Create";
    public const string UserDelete = User + ".Delete";
    public const string UserUpdate = User + ".Update";
}

如上，定义了“增”、“删”、“改”等权限，其中 User 将拥有完整权限。

4 实现 Requirement

public class PermissionAuthorizationRequirement : IAuthorizationRequirement
{
    public PermissionAuthorizationRequirement(string name)
    {
        Name = name;
    }
    public string Name { get; set; }
}

使用 Name 属性表示权限的名称，与 UserPermission 中的常量对应。

5 实现授权处理程序 Handler

这里假定用户的 Claim 中 ClaimType 为 Permission 的项，如：

new Claim("Permission", UserPermission.UserCreate),
new Claim("Permission", UserPermission.UserUpdate)

如上，标识该用户用户 UserCreate 和 UserUpdate 的权限。

注意：当然，实际程序我们肯定不是这样实现的，这里只是简易示例。

接着，实现一个授权 Handler：

public class PermissionAuthorizationHandler : AuthorizationHandler<PermissionAuthorizationRequirement>
{
    protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, PermissionAuthorizationRequirement requirement)
    {
        var permissions = context.User.Claims.Where(_ => _.Type == "Permission").Select(_ => _.Value).ToList();
        if (permissions.Any(_ => _.StartsWith(requirement.Name)))
        {
            context.Succeed(requirement);
        }
        return Task.CompletedTask;
    }
}

运行 HandleRequirementAsync 时，会将用户的 Claim 中 ClaimType 为 Permission 的项取出，并获取其 Value 组成一个 List<string>。

接着验证 Requirement 是否满足授权，满足则运行 context.Succeed 。

6 添加授权处理程序

在 Program.cs 中，将 PermissionAuthorizationHandler 添加到 DI 中：

builder.Services.AddSingleton<IAuthorizationHandler, PermissionAuthorizationHandler>();

7 添加授权策略

builder.Services.AddAuthorization(options =>
{
    options.AddPolicy(UserPermission.UserCreate, policy => policy.AddRequirements(new PermissionAuthorizationRequirement(UserPermission.UserCreate)));
    options.AddPolicy(UserPermission.UserUpdate, policy => policy.AddRequirements(new PermissionAuthorizationRequirement(UserPermission.UserUpdate)));
    options.AddPolicy(UserPermission.UserDelete, policy => policy.AddRequirements(new PermissionAuthorizationRequirement(UserPermission.UserDelete)));
});

8 控制器配置

控制器如下：

[Route("api/[controller]/[action]")]
[ApiController]
public class UserController : ControllerBase
{
    [HttpGet]
    [Authorize(UserPermission.UserCreate)]
    public ActionResult<string> UserCreate() => "UserCreate";

    [HttpGet]
    [Authorize(UserPermission.UserUpdate)]
    public ActionResult<string> UserUpdate() => "UserUpdate";

    [HttpGet]
    [Authorize(UserPermission.UserDelete)]
    public ActionResult<string> UserDelete() => "UserDelete";
}

基于上面的假定，用户访问接口的情况如下：

/api/User/UserCreate #成功
/api/User/UserUpdate #成功
/api/User/UserDelete #403无权限

至此，基于策略（Policy）的授权其实已经基本完成。

接下去的内容，将是对上面一些内容的完善或补充。

完善：实现策略提供程序 PolicyProvider

一般添加授权策略如下是在 Program.cs 中，方式如下：

builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("policy", policy => policy.RequireClaim("EmployeeNumber"));
});

通过 AuthorizationOptions.AddPolicy 添加授权策略这种方式不灵活，无法动态添加。

通过实现 IAuthorizationPolicyProvider 并添加到 DI 中，可以实现动态添加 Policy。

IAuthorizationPolicyProvider 的默认实现为 DefaultAuthorizationPolicyProvider 。

实现一个 PolicyProvider 如下：

public class TestAuthorizationPolicyProvider : DefaultAuthorizationPolicyProvider, IAuthorizationPolicyProvider
{
    public Test2AuthorizationPolicyProvider(IOptions<AuthorizationOptions> options) : base(options) {}

    public new Task<AuthorizationPolicy> GetDefaultPolicyAsync()
        => return base.GetDefaultPolicyAsync();

    public new Task<AuthorizationPolicy?> GetFallbackPolicyAsync()
        return base.GetFallbackPolicyAsync();

    public new Task<AuthorizationPolicy?> GetPolicyAsync(string policyName)
    {
        if (policyName.StartsWith(UserPermission.User))
        {
            var policy = new AuthorizationPolicyBuilder("Bearer");
            policy.AddRequirements(new PermissionAuthorizationRequirement(policyName));
            return Task.FromResult<AuthorizationPolicy?>(policy.Build());
        }
        return base.GetPolicyAsync(policyName);
    }
}

注意：自定义的 TestAuthorizationPolicyProvider 必须实现 IAuthorizationPolicyProvider，否则添加到 DI 时会不生效。

在 Program.cs 中，将自定义的 PolicyProvider 添加到 DI 中：

builder.Services.AddSingleton<IAuthorizationPolicyProvider, TestAuthorizationPolicyProvider>();

注意：只会生效最后一个添加的 PolicyProvider。

补充：自定义 AuthorizationMiddleware

自定义 AuthorizationMiddleware 可以：

返回自定义的响应
增强（或者说改变）默认的 challenge 或 forbid 响应

具体请查看官方文档自定义 AuthorizationMiddleware 的行为

补充：MiniApi 的授权

在 MiniApi 中几乎都是形如 MapGet() 的分支节点，这类终结点无法使用 [Authorize] 标签，可以用使用 RequireAuthorization("Something") 进行授权，如：

app.MapGet("/helloworld", () => "Hello World!")
    .RequireAuthorization("AtLeast21");

参考来源

ASP.NET Core 6.0 官方文档：授权策略提供程序

.NET 6 使用JWT Bearer认证和授权的步骤

ASP.NET Core 认证与授权6:授权策略是怎么执行的？（mark：这篇很强！）

ASP.NET Core 认证与授权7:动态授权

到此这篇关于ASP.NET Core 6.0 添加 JWT 认证和授权的文章就介绍到这了,更多相关ASP.NET Core 添加 JWT 认证和授权内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

asp.Net JS取母板页控件值的简单方法
这篇文章介绍了asp.Net JS取母板页控件值的简单方法，有需要的朋友可以参考一下
2013-07-07
微信公众平台开发之发送文本消息.Net代码解析
这篇文章主要为大家详细解析了微信公众平台开发之发送文本消息.Net代码，感兴趣的小伙伴们可以参考一下
2016-06-06
asp.net直接Response输出WML页面示例代码
本例实现直接Response输出WML页面，具体代码如下，有需要的朋友可以和参考下
2013-08-08
Visual Studio 2017 针对移动开发的新特性汇总
Visual Studio是世界上最好的IDE之一，下面就让我们一起来看看Visual Studio 2017中有哪些功能使得移动开发变得更加容易，感兴趣的朋友通过本文学习下吧
2017-05-05
ASP.NET MVC5网站开发概述(一)
这篇文章主要内容是ASP.NET MVC5网站开发实践的整体概述，分析了开发环境、使用的技术以及项目的整体结构，感兴趣的小伙伴们可以参考一下
2015-09-09
Asp.net(C#)读取数据库并生成JS文件制作首页图片切换效果(附demo源码下载)
这篇文章主要介绍了Asp.net(C#)读取数据库并生成JS文件制作首页图片切换效果的方法,涉及asp.net数据库操作及JavaScript幻灯片生成的相关技巧,并附带demo源码供读者下载参考,需要的朋友可以参考下
2016-04-04
.net平台的rabbitmq使用封装demo详解
这篇文章主要针对rabbitmq学习后封装RabbitMQ.Client的一个分享，文章最后，我会把封装组件和demo奉上，对.net平台的rabbitmq使用封装相关知识感兴趣的朋友一起看看吧
2021-09-09
C# 添加图片水印类实现代码
图片水印类实现代码，需要的朋友可以参考下。
2009-05-05
asp.net DropDownList自定义控件，让你的分类更清晰
记得上次做论坛，一个功能就是合并2个子板块的主题，用级联的2个DropDownList也是可以完成，那样我们要合并的时候总共就有4个DropDownList控件，觉得界面友好
2011-10-10
ASP.NET Core扩展库之日志功能的使用详解
这篇文章主要介绍了ASP.NET Core扩展库之日志功能的使用详解，帮助大家更好的理解和学习使用.NET技术，感兴趣的朋友可以了解下
2021-03-03