深度优先

这个家伙好懒,除了文章什么都没留下

0%

一、概述

首先说一下认证(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”的权限(实际权限来源此处不做展示)。

1
2
3
4
5
6
7
8
9
10
11
12
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如下

1
2
3
4
5
6
7
8
9
10
/// <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中添加授权代码:

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

在BookController中添加一个Action如下

1
2
3
4
5
6
[HttpDelete]
[Authorize(Policy = "TestPolicy")]
public JsonResult Delete()
{
return new JsonResult("Delete Book ...");
}

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

四、基于策略自定义授权

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

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

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

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

1.样例数据

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/// <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));
}
}

涉及到的两个类如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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接口。

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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修改一下:

1
2
3
4
5
6
7
[HttpDelete]
//[Authorize(Policy = "TestPolicy")]
[Authorize(Policy = "Permission")]
public JsonResult Delete()
{
return new JsonResult("Delete Book ...");
}
1
测试一下只有李四可以访问这个Action。

一、什么是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:

1
2
3
4
5
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的真实性。

三、认证流程

大概的流程是这样的:

  1. 认证服务器:用于用户的登录验证和Token的发放。

  2. 应用服务器:业务数据接口。被保护的API。

  3. 客户端:一般为APP、小程序等。 认证流程:

  4. 用户首先通过登录,到认证服务器获取一个Token。

  5. 在访问应用服务器的API的时候,将获取到的Token放置在请求的Header中。

  6. 应用服务器验证该Token,通过后返回对应的结果。 说明:这只是示例方案,实际项目中可能有所不同。

  7. 对于小型项目,可能认证服务和应用服务在一起。本例通过分开的方式来实现,使我们能更好的了解二者之间的认证流程。

  8. 对于复杂一些的项目,可能存在多个应用服务,用户获取到的Token可以在多个分布式服务中被认证,这也是JWT的优势之一。

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

四、应用实例

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

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

    认证服务

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

将其命名为FlyLolo.JWT.Server。

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
[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相关:

1
2
3
4
5
6
public class User
{
public string Code { get; set; }
public string Name { get; set; }
public string Password { get; set; }
}

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

1
2
3
4
5
6
7
8
9
10
11
12
/// <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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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,这里有几个关键参数:

  1. issuer Token发布者
  2. Audience Token接受者
  3. expires 过期时间
  4. IssuerSigningKey 签名秘钥 对应的Token代码如下:
1
2
3
4
5
6
public class Token
{
public string TokenContent { get; set; }

public DateTime Expires { get; set; }
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
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中对认证信息做配置如下:

1
2
3
4
5
6
"JWT": {
"Issuer": "FlyLolo",
"Audience": "TestAudience",
"IssuerSigningKey": "FlyLolo1234567890",
"AccessTokenExpiresMinutes": "30"
}

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

1
2
3
4
5
{"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。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
[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文件中配置认证:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
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();
}
}

这里同样用到了配置:

1
2
3
4
5
6
7
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:

1
2
3
4
5
6
"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还有一些其他参数,在它的构造方法中已经做了默认设置,代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
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小时)。

  1. Token到期了如何处理?

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

五、Token的刷新

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

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

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

1
2
3
4
5
public class ComplexToken
{
public Token AccessToken { get; set; }
public Token RefreshToken { get; set; }
}

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

修改 appsettings.json,添加两个配置项:

1
2
"RefreshTokenAudience": "RefreshTokenAudience", 
"RefreshTokenExpiresMinutes": "10080" //60*24*7

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

修改TokenHelper:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
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

1
2
3
4
5
6
[HttpPost]
[Authorize]
public IActionResult Post()
{
return Ok(tokenHelper.RefreshToken(Request.HttpContext.User));
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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:

1
2
3
4
5
6
7
8
9
10
11
12
13
{"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较多,对应的服务(器)也可能较多,所以泄露的概率更大一些。

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
[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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
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前端调用接口:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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();
}