【.Net Core】JWT与用户授权（细化到Action）

发表于 2019-09-04 分类于编程路上
本文字数： 6k 阅读时长 ≈ 5 分钟

一、概述

首先说一下认证(authentication)与授权(authorization)，它们经常在一起工作，所以有时候会分不清楚。并且这两个英文单词长得也像兄弟。举例来说，我刷门禁卡进入公司，门禁【认证】了我是这里的员工，可以进入；但进入公司以后，我并不是所有房间都可以进，比如“机房重地，闲人免进”，我能进入哪些房间，需要公司的【授权】。这就是认证和授权的区别。

ASP.NET Core提倡的是基于声明（Claim）的授权，关于这个Claim，上一章用到过，有如下这样的代码，但没有介绍：

1	Claim[] claims = new Claim[] { new Claim(ClaimTypes.NameIdentifier, user.Code), new Claim(ClaimTypes.Name, user.Name) };

这是一个声明的集合，它包含了两个声明，用于保存了用户的唯一ID和用户名。当然我们还可以添加更多的Claim。对应Claim，还有ClaimsIdentity 和ClaimsPrincipal 两个类型。

ClaimsIdentity相当于是一个证件，例如上例的门禁卡；ClaimsPrincipal 则是证件的持有者，也就是我本人；那么对应的Claim就是门禁卡内存储的一些信息，例如证件号、持有人姓名等。

我除了门禁卡还有身份证、银行卡等，也就是说一个ClaimsPrincipal中可以有多个ClaimsIdentity，而一个ClaimsIdentity中可以有多个Claim。ASP.NET Core的授权模型大概就是这样的一个体系。

ASP.NET Core支持多种授权方式，包括兼容之前的角色授权。下面通过几个例子说明一下（例子依然以上一章的代码为基础）。

二、基于角色授权

ASP.NET Core兼容之前的角色授权模式，如何使用呢？由于不是本文的重点，这里只是简要说一下。修改FlyLolo.JWT.Server的TokenHelper临时为张三添加了一个名为“TestPutBookRole”的权限（实际权限来源此处不做展示）。

public ComplexToken CreateToken(User user)
{
    Claim[] claims = new Claim[] { new Claim(ClaimTypes.NameIdentifier, user.Code), new Claim(ClaimTypes.Name, user.Name) };

    //下面对code为001的张三添加了一个Claim，用于测试在Token中存储用户的角色信息，对应测试在FlyLolo.JWT.API的BookController的Put方法，若用不到可删除
    if (user.Code.Equals("001"))
    {
        claims = claims.Append(new Claim(ClaimTypes.Role, "TestPutBookRole")).ToArray();
    }
    
    return CreateToken(claims);
}

修改FlyLolo.JWT.API的BookController，添加了一个Action如下

/// <summary>
/// 测试在JWT的token中添加角色，在此验证  见TokenHelper
/// </summary>
/// <returns></returns>
[HttpPut]
[Authorize(Roles = "TestPutBookRole")]
public JsonResult Put()
{
    return new JsonResult("Put  Book ...");
}

访问这个Action，只有用张三登录后获取的Token能正常访问。

三、基于声明授权

对于上例来说，本质上也是基于声明（Claim）的授权，因为张三的”TestPutBookRole”角色也是作为一个Claim添加到证书中的。只不过采用了特定的ClaimTypes.Role。那么是否可以将其他的普通Claim作为授权的依据呢？当然是可以的。

这里涉及到了另一个单词“Policy”，翻译为策略？也就是说，可以把一系列的规则（例如要求姓名为李四，账号为002，国籍为中国等等）组合在一起，形成一个Policy，只有满足这个Policy的才可以被授权访问。

下面我们就新建一个Policy，在Startup的ConfigureServices中添加授权代码：

services.AddAuthorization(options=>options.AddPolicy("Name",policy=> {
    policy.RequireClaim(ClaimTypes.Name, "张三");
    policy.RequireClaim(ClaimTypes.NameIdentifier,"001");
}));

在BookController中添加一个Action如下

[HttpDelete]
[Authorize(Policy = "TestPolicy")]
public JsonResult Delete()
{
    return new JsonResult("Delete Book ...");
}

可以通过张三和李四的账号测试一下，只有使用张三的账号获取的Token能访问成功。

四、基于策略自定义授权

上面介绍了两种授权方式，现在有个疑问，通过角色授权，只适合一些小型项目，将几个功能通过角色区分开就可以了。

通过声明的方式，目测实际项目中需要在Startup中先声明一系列的Policy，然后在Controller或Action中使用。

这两种方式都感觉不好。例如经常存在这样的需求：一个用户可以有多个角色，每个角色对应多个可访问的API地址（将授权细化到具体的Action）。用户还可以被特殊的授予某个API地址的权限。

这样的需求采用上面的两种方式实现起来都很麻烦，好在ASP.NET Core提供了方便的扩展方式。

1.样例数据

将上面的需求汇总一下，最终可以形成如下形式的数据：

/// <summary>
/// 虚拟数据，模拟从数据库或缓存中读取用户相关的权限
/// </summary>
public static class TemporaryData
{
    public readonly static List<UserPermissions> UserPermissions = new List<UserPermissions> {
        new UserPermissions {
            Code = "001",
            Permissions = new List<Permission> {
                new Permission { Code = "A1", Name = "student.create", Url = "/api/student",Method="post" },
                new Permission { Code = "A2", Name = "student.delete", Url = "/api/student",Method="delete"}
            }
        },
        new UserPermissions {
            Code = "002",
            Permissions = new List<Permission> {
                new Permission { Code = "B1", Name = "book.create", Url = "/api/book" ,Method="post"},
                new Permission { Code = "B2", Name = "book.delete", Url = "/api/book" ,Method="delete"}
            }
        },
    };

    public static UserPermissions GetUserPermission(string code)
    {
        return UserPermissions.FirstOrDefault(m => m.Code.Equals(code));
    }
}

涉及到的两个类如下：

public class Permission
{
    public string Code { get; set; }
    public string Name { get; set; }
    public string Url { get; set; }

    public string Method { get; set; }
}

public class UserPermissions
{
    public string Code { get; set; }
    public List<Permission> Permissions { get; set; }
}

2.自定义处理程序

下面就是根据样例数据来制定相应的处理程序了。这涉及到IAuthorizationRequirement和AuthorizationHandler两个内容。

IAuthorizationRequirement是一个空的接口，主要用于提供授权所需要满足的“要求”，或者说是“规则”。AuthorizationHandler则是对请求和“要求”的联合处理。

新建一个PermissionRequirement实现IAuthorizationRequirement接口。

public class PermissionRequirement: IAuthorizationRequirement
{
    public List<UserPermissions> UsePermissionList { get { return TemporaryData.UserPermissions; } }
}

很简单的内容。它的“要求”也就是用户的权限列表了，用户的权限列表中包含当前访问的API，则授权通过，否则不通过。

判断逻辑放在新建的PermissionHandler中：

public class PermissionHandler : AuthorizationHandler<PermissionRequirement>
{
    protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, PermissionRequirement requirement)
    {
        var code = context.User.Claims.FirstOrDefault(m => m.Type.Equals(ClaimTypes.NameIdentifier));
        if (null != code)
        {
            UserPermissions userPermissions = requirement.UsePermissionList.FirstOrDefault(m => m.Code.Equals(code.Value.ToString()));

            var Request = (context.Resource as AuthorizationFilterContext).HttpContext.Request;

            if (null != userPermissions && userPermissions.Permissions.Any(m => m.Url.ToLower().Equals(Request.Path.Value.ToLower()) && m.Method.ToLower().Equals(Request.Method.ToLower()) ))
            {
                context.Succeed(requirement);
            }
            else
            {
                context.Fail();
            }
        }
        else
        {
            context.Fail();
        }

        return Task.CompletedTask;
    }
}

逻辑很简单不再描述。

3.使用自定义的处理程序

在Startup的ConfigureServices中添加授权代码

1
2

services.AddAuthorization(options => options.AddPolicy("Permission", policy => policy.Requirements.Add(new PermissionRequirement())));
services.AddSingleton<IAuthorizationHandler, PermissionHandler>();

将BookController的Delete Action修改一下：

[HttpDelete]
//[Authorize(Policy = "TestPolicy")]
[Authorize(Policy = "Permission")]
public JsonResult Delete()
{
    return new JsonResult("Delete Book ...");
}

1	测试一下只有李四可以访问这个Action。

【.Net Core】应用JWT进行用户认证及Token的刷新

发表于 2019-09-04 分类于编程路上
本文字数： 16k 阅读时长 ≈ 15 分钟

一、什么是JWT？

JWT(json web token)基于开放标准（RFC 7519)，是一种无状态的分布式的身份验证方式，主要用于在网络应用环境间安全地传递声明。它是基于JSON的，所以它也像json一样可以在.Net、JAVA、JavaScript,、PHP等多种语言使用。
为什么要使用JWT？
传统的Web应用一般采用Cookies+Session来进行认证。但对于目前越来越多的App、小程序等应用来说，它们对应的服务端一般都是RestFul 类型的无状态的API，再采用这样的的认证方式就不是很方便了。而JWT这种无状态的分布式的身份验证方式恰好符合这样的需求。

二、JWT的组成：

JWT是什么样子的呢？它就是下面这样的一段字符串：

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJodHRwOi8vc2NoZW1hcy54bWxzb2FwLm9yZy93cy8yMDA1LzA1L2lkZW50aXR5L2NsYWltcy9uYW1laWRlbnRpZmllciI6IjAwMiIsImh0dHA6Ly9zY2hlbWFzLnhtbHNvYXAub3JnL3dzLzIwMDUvMDUvaWRlbnRpdHkvY2xhaW1zL25hbWUiOiLmnY7lm5siLCJuYmYiOjE1NjU5MjMxMjIsImV4cCI6MTU2NTkyMzI0MiwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo1NDIxNCIsImF1ZCI6Imh0dHA6Ly9sb2NhbGhvc3Q6NTQyMTUifQ.Mrta7nftmfXeo_igBVd4rl2keMmm0rg0WkqRXoVAeik

它是由三段“乱码”字符串通过两个“.”连接在一起组成。官网https://jwt.io/提供了它的验证方式

它的三个字符串分别对应了上图右侧的Header、Payload和Signature三部分。

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

标识加密方式为HS256，Token类型为JWT, 这段JSON通过Base64Url编码形成上例的第一个字符串

Payload

Payload是JWT用于信息存储部分，其中包含了许多种的声明（claims）。
可以自定义多个声明添加到Payload中，系统也提供了一些默认的类型
iss (issuer)：签发人
exp (expiration time)：过期时间
sub (subject)：主题
aud (audience)：受众
nbf (Not Before)：生效时间
iat (Issued At)：签发时间
jti (JWT ID)：编号

这部分通过Base64Url编码生成第二个字符串。

Signature

Signature是用于Token的验证。它的值类似这样的表达式：Signature = HMACSHA256( base64UrlEncode(header) + “.” + base64UrlEncode(payload), secret)，也就是说，它是通过将前两个字符串加密后生成的一个新字符串。

所以只有拥有同样加密密钥的人，才能通过前两个字符串获得同样的字符串，通过这种方式保证了Token的真实性。

三、认证流程

大概的流程是这样的：

认证服务器：用于用户的登录验证和Token的发放。
应用服务器：业务数据接口。被保护的API。
客户端：一般为APP、小程序等。认证流程：
用户首先通过登录，到认证服务器获取一个Token。
在访问应用服务器的API的时候，将获取到的Token放置在请求的Header中。
应用服务器验证该Token，通过后返回对应的结果。说明：这只是示例方案，实际项目中可能有所不同。
对于小型项目，可能认证服务和应用服务在一起。本例通过分开的方式来实现，使我们能更好的了解二者之间的认证流程。
对于复杂一些的项目，可能存在多个应用服务，用户获取到的Token可以在多个分布式服务中被认证，这也是JWT的优势之一。

关于JWT的文章很多，这里就不做过多介绍了。下面通过实际的例子来看一下它是如何在ASP.NET Core 中应用的。

四、应用实例

上一节的图：“JWT的认证流程”中涉及到客户端、认证服务器、应用服务器三部分，下面通过示例来对这三部分进行模拟：

认证服务器：新建一个WebApi的解决方案，名为FlyLolo.JWT.Server。
应用服务器：新建一个WebApi的解决方案，名为FlyLolo.JWT.API。
客户端：这里用Fiddler发送请求做测试。
认证服务

首先新建一个ASP.NET Core 的解决方案WebApi的解决方案

将其命名为FlyLolo.JWT.Server。

首先新建一个TokenController用于登录和Token的发放：

[Route("api/[controller]")]
public class TokenController : Controller
{
    private ITokenHelper tokenHelper = null;
    public TokenController(ITokenHelper _tokenHelper)
    {
        tokenHelper = _tokenHelper;
    }
    [HttpGet]
    public IActionResult Get(string code, string pwd)
    {
        User user = TemporaryData.GetUser(code);
        if (null != user && user.Password.Equals(pwd))
        {
            return Ok(tokenHelper.CreateToken(user));
        }
        return BadRequest();
    }
}

它有个名为Get的Action用于接收提交的用户名和密码，并进行验证，验证通过后，调用TokenHelper的CreateToken方法生成Token返回。

这里涉及到了User和TokenHelper两个类。

User相关：

public class User
{
    public string Code { get; set; }
    public string Name { get; set; }
    public string Password { get; set; }
}

由于只是Demo，User类只含有以上三个字段。在TemporaryData类中做了User的模拟数据

/// <summary>
/// 虚拟数据，模拟从数据库或缓存中读取用户
/// </summary>
public static class TemporaryData
{
    private static List<User> Users = new List<User>() { new User { Code = "001", Name = "张三", Password = "111111" }, new User { Code = "002", Name = "李四", Password = "222222" } };

    public static User GetUser(string code)
    {
        return Users.FirstOrDefault(m => m.Code.Equals(code));
    }
}

这只是模拟数据，实际项目中应该从数据库或者缓存等读取。

TokenHelper：

public class TokenHelper : ITokenHelper
{
    private IOptions<JWTConfig> _options;
    public TokenHelper(IOptions<JWTConfig> options)
    {
        _options = options;
    }

    public Token CreateToken(User user)
    {
        Claim[] claims = { new Claim(ClaimTypes.NameIdentifier,user.Code),new Claim(ClaimTypes.Name,user.Name) };

        return CreateToken(claims);
    }
    private Token CreateToken(Claim[] claims)
    {
        var now = DateTime.Now;var expires = now.Add(TimeSpan.FromMinutes(_options.Value.AccessTokenExpiresMinutes));
        var token = new JwtSecurityToken(
            issuer: _options.Value.Issuer,
            audience: _options.Value.Audience,
            claims: claims,
            notBefore: now,
            expires: expires,
            signingCredentials: new SigningCredentials(new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_options.Value.IssuerSigningKey)), SecurityAlgorithms.HmacSha256));
        return new Token { TokenContent = new JwtSecurityTokenHandler().WriteToken(token), Expires = expires };
    }
}

通过CreateToken方法创建Token，这里有几个关键参数：

issuer Token发布者
Audience Token接受者
expires 过期时间
IssuerSigningKey 签名秘钥对应的Token代码如下：

public class Token
{
    public string TokenContent { get; set; }

    public DateTime Expires { get; set; }
}

这样通过TokenHelper的CreateToken方法生成了一个Token返回给了客户端。到现在来看，貌似所有的工作已经完成了。并非如此，我们还需要在Startup文件中做一些设置。

public class Startup
{
    // 。。。。。。此处省略部分代码

    public void ConfigureServices(IServiceCollection services)
    {
        //读取配置信息
        services.AddSingleton<ITokenHelper, TokenHelper>();
        services.Configure<JWTConfig>(Configuration.GetSection("JWT"));
        //启用JWT
        services.AddAuthentication(Options =>
        {
            Options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
            Options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
        }).
        AddJwtBearer();
        services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        //启用认证中间件
        app.UseAuthentication();
        app.UseMvc();
    }
}

这里用到了配置信息，在appsettings.json中对认证信息做配置如下：

"JWT": {
    "Issuer": "FlyLolo",
    "Audience": "TestAudience",
    "IssuerSigningKey": "FlyLolo1234567890",
    "AccessTokenExpiresMinutes": "30"
}

运行这个项目，并通过Fidder以Get方式访问api/token?code=002&pwd=222222，返回结果如下：

{"tokenContent":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJodHRwOi8vc2NoZW1hcy54bWxzb2FwLm9yZy93cy8
yMDA1LzA1L2lkZW50aXR5L2NsYWltcy9uYW1laWRlbnRpZmllciI6IjAwMiIsImh0dHA6Ly9zY2hlbWFzLnhtbHNvYXAub3JnL
3dzLzIwMDUvMDUvaWRlbnRpdHkvY2xhaW1zL25hbWUiOiLmnY7lm5siLCJuYmYiOjE1NjY3OTg0NzUsImV4cCI6MTU2NjgwMDI
3NSwiaXNzIjoiRmx5TG9sbyIsImF1ZCI6IlRlc3RBdWRpZW5jZSJ9.BVf3gOuW1E9RToqKy8XXp8uIvZKL-lBA-q9fB9QTEZ4",
"expires":"2019-08-26T21:17:55.1183172+08:00"}

客户端登录成功并成功返回了一个Token，认证服务创建完成

应用服务

新建一个WebApi的解决方案，名为FlyLolo.JWT.API。

添加BookController用作业务API。

[Route("api/[controller]")]
[Authorize]
public class BookController : Controller
{
    // GET: api/<controller>
    [HttpGet]
    [AllowAnonymous]
    public IEnumerable<string> Get()
    {
        return new string[] { "ASP", "C#" };
    }

    // POST api/<controller>
    [HttpPost]
    public JsonResult Post()
    {
        return new JsonResult("Create  Book ...");
    }
}

对此Controller添加了[Authorize]标识，表示此Controller的Action被访问时需要进行认证，而它的名为Get的Action被标识了[AllowAnonymous]，表示此Action的访问可以跳过认证。

在Startup文件中配置认证：

public class Startup
{
// 省略部分代码
    public void ConfigureServices(IServiceCollection services)
    {
        #region 读取配置
        JWTConfig config = new JWTConfig();
        Configuration.GetSection("JWT").Bind(config);
        #endregion

        #region 启用JWT认证
        services.AddAuthentication(options =>
        {
            options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
            options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
        }).
        AddJwtBearer(options =>
        {
            options.TokenValidationParameters = new TokenValidationParameters
            {
                ValidIssuer = config.Issuer,
                ValidAudience = config.Audience,
                IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(config.IssuerSigningKey)),
                ClockSkew = TimeSpan.FromMinutes(1)
            };
        });
        #endregion

        services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
    }

    // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        app.UseAuthentication();
        app.UseMvc();
    }
}

这里同样用到了配置：

public class JWTConfig
{
    public string Issuer { get; set; }
    public string Audience { get; set; }
    public string IssuerSigningKey { get; set; }
    public int AccessTokenExpiresMinutes { get; set; }
}

appsettings.json：

"JWT": {
    "Issuer": "FlyLolo",
    "Audience": "TestAudience",
    "IssuerSigningKey": "FlyLolo1234567890",
    "AccessTokenExpiresMinutes": "30"
}

关于JWT认证，这里通过options.TokenValidationParameters对认证信息做了设置，ValidIssuer、ValidAudience、IssuerSigningKey这三个参数用于验证Token生成的时候填写的Issuer、Audience、IssuerSigningKey，所以值要和生成Token时的设置一致。

ClockSkew默认值为5分钟，它是一个缓冲期，例如Token设置有效期为30分钟，到了30分钟的时候是不会过期的，会有这么个缓冲时间，也就是35分钟才会过期。为了方便测试（不想等太长时间），这里我设置了1分钟。

TokenValidationParameters还有一些其他参数，在它的构造方法中已经做了默认设置，代码如下：

public TokenValidationParameters()
{
    RequireExpirationTime = true;  
    RequireSignedTokens = true;    
    SaveSigninToken = false;
    ValidateActor = false;
    ValidateAudience = true;  //是否验证接受者
    ValidateIssuer = true;   //是否验证发布者
    ValidateIssuerSigningKey = false;  //是否验证秘钥
    ValidateLifetime = true; //是否验证过期时间
    ValidateTokenReplay = false;
 }

访问api/book，正常返回了结果

1	["ASP","C#"]

通过POST方式访问，返回401错误。

这就需要使用获取到的Toke了，如下图方式再次访问

添加了“Authorization: bearer Token内容”这样的Header，可以正常访问了。

至此，简单的JWT认证示例就完成了，代码地址https://github.com/FlyLolo/JWT.Demo/releases/tag/1.0。

这里可能会有个疑问，例如：

1.Token被盗了怎么办？

答: 在启用Https的情况下，Token被放在Header中还是比较安全的。另外Token的有效期不要设置过长。例如可以设置为1小时（微信公众号的网页开发的Token有效期为2小时）。

Token到期了如何处理？

答：理论上Token过期应该是跳到登录界面，但这样太不友好了。可以在后台根据Token的过期时间定期去请求新的Token。下一节来演示一下Token的刷新方案。

五、Token的刷新

为了使客户端能够获取到新的Token，对上文的例子进行改造，大概思路如下：

用户登录成功的时候，一次性给他两个Token，分别为AccessToken和RefreshToken，AccessToken用于正常请求，也就是上例中原有的Token，RefreshToken作为刷新AccessToken的凭证。
AccessToken的有效期较短，例如一小时，短一点安全一些。RefreshToken有效期可以设置长一些，例如一天、一周等。
当AccessToken即将过期的时候，例如提前5分钟，客户端利用RefreshToken请求指定的API获取新的AccessToken并更新本地存储中的AccessToken。所以只需要修改FlyLolo.JWT.Server即可。

首先修改Token的返回方案，新增一个Model

public class ComplexToken
{
    public Token AccessToken { get; set; }
    public Token RefreshToken { get; set; }
}

包含AccessToken和RefreshToken，用于用户登录成功后的Token结果返回。

修改 appsettings.json，添加两个配置项：

1 2	"RefreshTokenAudience": "RefreshTokenAudience", "RefreshTokenExpiresMinutes": "10080" //60247

RefreshTokenExpiresMinutes用于设置RefreshToken的过期时间，这里设置了7天。RefreshTokenAudience用于设置RefreshToken的接受者，与原Audience值不一致，作用是使RefreshToken不能用于访问应用服务的业务API，而AccessToken不能用于刷新Token。

修改TokenHelper：

public enum TokenType
{
    AccessToken = 1,
    RefreshToken = 2
}
public class TokenHelper : ITokenHelper
{
    private IOptions<JWTConfig> _options;
    public TokenHelper(IOptions<JWTConfig> options)
    {
        _options = options;
    }

    public Token CreateAccessToken(User user)
    {
        Claim[] claims = new Claim[] { new Claim(ClaimTypes.NameIdentifier, user.Code), new Claim(ClaimTypes.Name, user.Name) };

        return CreateToken(claims, TokenType.AccessToken);
    }

    public ComplexToken CreateToken(User user)
    {
        Claim[] claims = new Claim[] { new Claim(ClaimTypes.NameIdentifier, user.Code), new Claim(ClaimTypes.Name, user.Name)
            //下面两个Claim用于测试在Token中存储用户的角色信息，对应测试在FlyLolo.JWT.API的两个测试Controller的Put方法，若用不到可删除
            , new Claim(ClaimTypes.Role, "TestPutBookRole"), new Claim(ClaimTypes.Role, "TestPutStudentRole")
        };

        return CreateToken(claims);
    }

    public ComplexToken CreateToken(Claim[] claims)
    {
        return new ComplexToken { AccessToken = CreateToken(claims, TokenType.AccessToken), RefreshToken = CreateToken(claims, TokenType.RefreshToken) };
    }

    /// <summary>
    /// 用于创建AccessToken和RefreshToken。
    /// 这里AccessToken和RefreshToken只是过期时间不同，【实际项目】中二者的claims内容可能会不同。
    /// 因为RefreshToken只是用于刷新AccessToken，其内容可以简单一些。
    /// 而AccessToken可能会附加一些其他的Claim。
    /// </summary>
    /// <param name="claims"></param>
    /// <param name="tokenType"></param>
    /// <returns></returns>
    private Token CreateToken(Claim[] claims, TokenType tokenType)
    {
        var now = DateTime.Now;
        var expires = now.Add(TimeSpan.FromMinutes(tokenType.Equals(TokenType.AccessToken) ? _options.Value.AccessTokenExpiresMinutes : _options.Value.RefreshTokenExpiresMinutes));//设置不同的过期时间
        var token = new JwtSecurityToken(
            issuer: _options.Value.Issuer,
            audience: tokenType.Equals(TokenType.AccessToken) ? _options.Value.Audience : _options.Value.RefreshTokenAudience,//设置不同的接受者
            claims: claims,
            notBefore: now,
            expires: expires,
            signingCredentials: new SigningCredentials(new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_options.Value.IssuerSigningKey)), SecurityAlgorithms.HmacSha256));
        return new Token { TokenContent = new JwtSecurityTokenHandler().WriteToken(token), Expires = expires };
    }

    public Token RefreshToken(ClaimsPrincipal claimsPrincipal)
    {
        var code = claimsPrincipal.Claims.FirstOrDefault(m => m.Type.Equals(ClaimTypes.NameIdentifier));
        if (null != code )
        {
            return CreateAccessToken(TemporaryData.GetUser(code.Value.ToString()));
        }
        else
        {
            return null;
        }
    }
}

在登录后，生成两个Token返回给客户端。在TokenHelper添加了一个RefreshToken方法，用于生成新的AccessToken。对应在TokenController中添加一个名为Post的Action，用于调用这个RefreshToken方法刷新Token

[HttpPost]
[Authorize]
public IActionResult Post()
{
    return Ok(tokenHelper.RefreshToken(Request.HttpContext.User));
}

这个方法添加了[Authorize]标识，说明调用它需要RefreshToken认证通过。既然启用了认证，那么在Startup文件中需要像上例的业务API一样做JWT的认证配置。

public void ConfigureServices(IServiceCollection services)
{
        #region 读取配置信息
        services.AddSingleton<ITokenHelper, TokenHelper>();
        services.Configure<JWTConfig>(Configuration.GetSection("JWT"));
        JWTConfig config = new JWTConfig();
        Configuration.GetSection("JWT").Bind(config);
        #endregion

        #region 启用JWT
        services.AddAuthentication(Options =>
        {
            Options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
            Options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
        }).
            AddJwtBearer(options =>
            {
                options.TokenValidationParameters = new TokenValidationParameters
                {
                    ValidIssuer = config.Issuer,
                    ValidAudience = config.RefreshTokenAudience,
                    IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(config.IssuerSigningKey))
                };
            });
        #endregion

        services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
    }

注意这里的ValidAudience被赋值为config.RefreshTokenAudience，和FlyLolo.JWT.API中的不一致，用于防止AccessToken和RefreshToken的混用。

再次访问/api/token?code=002&pwd=222222，会返回两个Token：

{"accessToken":{"tokenContent":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJodHRwOi8vc2NoZW1hcy54bWxzb2FwLm9yZy93cy8y
MDA1LzA1L2lkZW50aXR5L2NsYWltcy9uYW1laWRlbnRpZmllciI6IjAwMiIsImh0dHA6Ly9zY2hlbWFzLnhtbHNvYXAub3JnL3dzLzIwMDUvMDUva
WRlbnRpdHkvY2xhaW1zL25hbWUiOiLmnY7lm5siLCJodHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL3dzLzIwMDgvMDYvaWRlbnRpdHkvY2xhaW
1zL3JvbGUiOlsiVGVzdFB1dEJvb2tSb2xlIiwiVGVzdFB1dFN0dWRlbnRSb2xlIl0sIm5iZiI6MTU2NjgwNjQ3OSwiZXhwIjoxNTY2ODA4Mjc5LCJ
pc3MiOiJGbHlMb2xvIiwiYXVkIjoiVGVzdEF1ZGllbmNlIn0.wlMorS1V0xP0Fb2MDX7jI7zsgZbb2Do3u78BAkIIwGg",
"expires":"2019-08-26T22:31:19.5312172+08:00"},

"refreshToken":{"tokenContent":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJodHRwOi8vc2NoZW1hcy54bWxzb2FwLm9yZy93cy8y
MDA1LzA1L2lkZW50aXR5L2NsYWltcy9uYW1laWRlbnRpZmllciI6IjAwMiIsImh0dHA6Ly9zY2hlbWFzLnhtbHNvYXAub3JnL3dzLzIwMDUvMDUva
WRlbnRpdHkvY2xhaW1zL25hbWUiOiLmnY7lm5siLCJodHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL3dzLzIwMDgvMDYvaWRlbnRpdHkvY2xhaW
1zL3JvbGUiOlsiVGVzdFB1dEJvb2tSb2xlIiwiVGVzdFB1dFN0dWRlbnRSb2xlIl0sIm5iZiI6MTU2NjgwNjQ3OSwiZXhwIjoxNTY3NDExMjc5LCJ
pc3MiOiJGbHlMb2xvIiwiYXVkIjoiUmVmcmVzaFRva2VuQXVkaWVuY2UifQ.3EDi6cQBqa39-ywq2EjFGiM8W2KY5l9QAOWaIDi8FnI",
"expires":"2019-09-02T22:01:19.6143038+08:00"}}

可以使用RefreshToken去请求新的AccessToken

测试用AccessToken可以正常访问FlyLolo.JWT.API，用RefreshToken则不可以。

至此，Token的刷新功能改造完成。代码地址：https://github.com/FlyLolo/JWT.Demo/releases/tag/1.1

疑问：RefreshToken有效期那么长，被盗了怎么办，和直接将AccessToken的有效期延长有什么区别？

个人认为：1. RefreshToken不像AccessToken那样在大多数请求中都被使用。2. 应用类的API较多，对应的服务（器）也可能较多，所以泄露的概率更大一些。

【Angular】.NetCore导出Excel和文件下载

发表于 2019-09-03 分类于前端知识
本文字数： 8.4k 阅读时长 ≈ 8 分钟

相比之前用windows.open(url);向服务器下载文件做了些改进

之前的方式不能携带上token，还需要在服务器上存一份下载的文件；

.NetCore导出Excel中的NPOI组件，写了一个基于配置导出Excel的方法，美化了导出文件的格式：

[Authorize]
[HttpGet("download")]
public IActionResult Download()
{
    DataTable dataTable = new DataTable();

    List<ExportDataColumn> columnList = new List<ExportDataColumn>();
    columnList.Add(new ExportDataColumn() { Prop = "id", Label = "序号", ColumnWidth = 256 * 10 });
    dataTable.Columns.Add(new DataColumn("id", Type.GetType("System.String")));

    columnList.Add(new ExportDataColumn() { Prop = "name", Label = "姓名", ColumnWidth = 256 * 10 });
    dataTable.Columns.Add(new DataColumn("name", Type.GetType("System.String")));

    columnList.Add(new ExportDataColumn() { Prop = "phone", Label = "手机号", ColumnWidth = 256 * 10 });
    dataTable.Columns.Add(new DataColumn("phone", Type.GetType("System.String")));

    columnList.Add(new ExportDataColumn() { Prop = "email", Label = "邮箱", ColumnWidth = 256 * 10 });
    dataTable.Columns.Add(new DataColumn("email", Type.GetType("System.String")));

    columnList.Add(new ExportDataColumn() { Prop = "recordTime", Label = "记录时间", ColumnWidth = 256 * 20 });
    dataTable.Columns.Add(new DataColumn("recordTime", Type.GetType("System.String")));

    for (int i = 0; i < 1000; i++)
    {
        DataRow dr = dataTable.NewRow();
        dr["id"] = i + 1;
        dr["name"] = $"管星-{i}";
        dr["phone"] = $"15377011087-{i}";
        dr["email"] = $"xguan2014@gmail.com-{i}";
        dr["recordTime"] = DateTime.Now;

        dataTable.Rows.Add(dr);
    }

    string path = $"{_hosting.WebRootPath}//{_config["ExportPath"]}";
    string fileName = NPOIHelper.Export(dataTable, columnList, "Export_", path);

    FileStream fs = new FileStream($"{path}//{fileName}", FileMode.Open);
    return File(fs, "application/vnd.ms-excel", fileName);
}

using Core.Correlation;
using NPOI.HSSF.UserModel;
using NPOI.HSSF.Util;
using NPOI.SS.UserModel;
using NPOI.SS.Util;
using NPOI.XSSF.UserModel;
using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Reflection;
using static NPOI.HSSF.Util.HSSFColor;

namespace XXXX.Helpers
{
    public class NPOIHelper
    {
        /// <summary>
        /// 导出Excel
        /// </summary>
        /// <param name="dt"></param>
        /// <param name="columnTitle"></param>
        /// <param name="title"></param>
        /// <param name="path"></param>
        /// <returns></returns>
        public static string Export(DataTable dt, List<ExportDataColumn> columnTitle, string title, string path)
        {
            XSSFWorkbook book = new XSSFWorkbook();
            XSSFSheet sheet = book.CreateSheet("Export") as XSSFSheet;

            CellRangeAddress region = new CellRangeAddress(0, 0, 0, columnTitle.Count - 1);
            sheet.AddMergedRegion(region);

            IFont font12 = book.CreateFont();
            font12.FontHeightInPoints = 12;
            font12.FontName = "微软雅黑";
            font12.Boldweight = short.MaxValue;
            font12.Color = Black.Index;

            ICellStyle cellStyle = book.CreateCellStyle();
            cellStyle.Alignment = HorizontalAlignment.Center;
            cellStyle.BorderBottom = BorderStyle.Thin;
            cellStyle.BorderLeft = BorderStyle.Thin;
            cellStyle.BorderRight = BorderStyle.Thin;
            cellStyle.BorderTop = BorderStyle.Thin;
            cellStyle.SetFont(font12);
            cellStyle.FillBackgroundColor = BlueGrey.Index;

            for (int i = region.FirstRow; i <= region.LastRow; i++)
            {
                IRow row = sheet.CreateRow(i);
                for (int j = region.FirstColumn; j <= region.LastColumn; j++)
                {
                    ICell singleCell = row.CreateCell((short)j);
                    singleCell.CellStyle = cellStyle;
                }
            }

            IRow hrow = sheet.GetRow(0);
            hrow.Height = 20 * 20;
            ICell icellltop0 = hrow.GetCell(0);
            icellltop0.CellStyle = cellStyle;
            icellltop0.SetCellValue(title + "_" + DateTime.Now.ToString("yyyy-MM-dd"));

            ICellStyle TitleStyle = book.CreateCellStyle();
            TitleStyle.FillForegroundColor = PaleBlue.Index;
            TitleStyle.FillPattern = FillPattern.SolidForeground;
            TitleStyle.Alignment = HorizontalAlignment.Center;
            TitleStyle.BorderBottom = BorderStyle.Thin;
            TitleStyle.BorderLeft = BorderStyle.Thin;
            TitleStyle.BorderRight = BorderStyle.Thin;
            TitleStyle.BorderTop = BorderStyle.Thin;

            IRow TitleRow = sheet.CreateRow(1);
            TitleRow.Height = 20 * 15;
            for (int i = 0; i < columnTitle.Count; i++)
            {
                ICell cell = TitleRow.CreateCell(i);
                cell.CellStyle = TitleStyle;
                cell.SetCellValue(columnTitle[i].Label);
                sheet.SetColumnWidth(i, columnTitle[i].ColumnWidth);
            }

            for (int i = 0; i < dt.Rows.Count; i++)
            {
                IRow row = sheet.CreateRow(i + 2);
                for (int j = 0; j < columnTitle.Count; j++)
                {
                    row.CreateCell(j).SetCellValue(dt.Rows[i][columnTitle[j].Prop].ToString());
                }
            }

            ICellStyle borStyle = book.CreateCellStyle();
            borStyle.Alignment = HorizontalAlignment.Center;
            borStyle.BorderBottom = BorderStyle.Thin;
            borStyle.BorderLeft = BorderStyle.Thin;
            borStyle.BorderRight = BorderStyle.Thin;
            borStyle.BorderTop = BorderStyle.Thin;

            for (int i = 1; i <= dt.Rows.Count + 1; i++)
            {
                IRow row = sheet.GetRow(i);
                row.Height = 20 * 16;
                for (int j = 0; j < columnTitle.Count; j++)
                {
                    ICell singleCell = row.GetCell((short)j);
                    singleCell.CellStyle = borStyle;
                }
            }
            if (!Directory.Exists(path))
            {
                Directory.CreateDirectory(path);
            }
            string fileName = title + DateTime.Now.ToString("yyyyMMddHHmmssff") + ".xlsx";
            using (FileStream fsWrite = File.OpenWrite($"{path}//{fileName}"))
            {
                book.Write(fsWrite);
            }
            return fileName;
        }

        /// <summary>
        /// 导入 用户数据 
        /// </summary>
        /// <param name="stream"></param>
        /// <returns></returns>
        public static void Import(string filePath)
        {
            FileStream fs = null;
            IWorkbook workbook = null;
            using (fs = new FileStream(filePath, FileMode.Open))
            {
                if (filePath.EndsWith(".xlsx"))
                {
                    workbook = new XSSFWorkbook(fs);
                }
                else if (filePath.EndsWith(".xls"))
                {
                    workbook = new HSSFWorkbook(fs);
                }
                if (workbook != null)
                {
                    // 添加系统用户
                    ISheet userSheet = workbook.GetSheetAt(0);
                    if (userSheet != null)
                    {
                        int rowCount = userSheet.LastRowNum;
                        for (int i = 1; i <= rowCount; i++)
                        {
                            IRow row = userSheet.GetRow(i);
                            string account = row.GetCell(0).ToString();
                            string name = row.GetCell(1).ToString();
                            string email = row.GetCell(2).ToString();
                            Console.WriteLine($"{account}--{name}--{email}");
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 实体列表转换成DataTable
        /// </summary>
        /// <typeparam name="T">实体</typeparam>
        /// <param name="list"> 实体列表</param>
        /// <returns></returns>
        public DataTable ListToDataTable<T>(IList<T> list)
            where T : class
        {
            if (list == null || list.Count <= 0)
            {
                return null;
            }
            DataTable dt = new DataTable(typeof(T).Name);
            DataColumn column;
            DataRow row;

            PropertyInfo[] myPropertyInfo = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance);

            int length = myPropertyInfo.Length;
            bool createColumn = true;

            foreach (T t in list)
            {
                if (t == null)
                {
                    continue;
                }
                row = dt.NewRow();
                for (int i = 0; i < length; i++)
                {
                    PropertyInfo pi = myPropertyInfo[i];
                    string name = pi.Name;
                    if (createColumn)
                    {
                        column = new DataColumn(name, typeof(string));
                        dt.Columns.Add(column);
                    }
                    row[name] = pi.GetValue(t, null) is null ? "" : pi.GetValue(t, null).ToString();
                }
                if (createColumn)
                {
                    createColumn = false;
                }
                dt.Rows.Add(row);
            }
            return dt;
        }
    }
}

Angualr前端调用接口：

Download() {
    const url = appConfig.apiUrl + '/api/export/download';
    return this.http.get(url, { responseType: 'blob' }).subscribe((results) => {
        SaveExcel(results, '导出数据');
    });
}
  
SaveExcel(data: Blob, name: string) {
    const a = document.createElement('a');
    // tslint:disable-next-line: quotemark
    // tslint:disable-next-line: object-literal-key-quotes
    const blob = new Blob([data], { 'type': 'application/vnd.ms-excel' });
    a.href = URL.createObjectURL(blob);
    a.download = name + '.xlsx';
    a.click();
}