理解JWT
1. JSON Web Token是什么
JSON Web Token (JWT)是一个开放标准(RFC 7519)，它定义了一种紧凑的、自包含的方式，用于做为JSON对象在各方之间安全地传输信息。该信息能够被验证和信任，由于它是数字签名的。html
2. 何时你应该用JSON Web Tokens
下列场景中使用JSON Web Token是颇有用的：java
- Authorization (受权) : 这是使用JWT的最多见场景。一旦用户登陆，后续每一个请求都将包含JWT，容许用户访问该令牌容许的路由、服务和资源。单点登陆是如今普遍使用的JWT的一个特性，由于它的开销很小，而且能够轻松地跨域使用。
- Information Exchange (信息交换) : 对于安全的在各方之间传输信息而言，JSON Web Tokens无疑是一种很好的方式。由于JWTs能够被签名，例如，用公钥/私钥对，你能够肯定发送人就是它们所说的那我的。另外，因为签名是使用头和有效负载计算的，您还能够验证内容没有被篡改。
3. JSON Web Token的结构是什么样的
JSON Web Token由三部分组成，它们之间用圆点(.)链接。这三部分分别是：web
- Header
- Payload
- Signature
所以，一个典型的JWT看起来是这个样子的：算法
xxxxx.yyyyy.zzzzzspring
接下来，具体看一下每一部分：数据库
Header
header典型的由两部分组成：token的类型（“JWT”）和算法名称（好比：HMAC SHA256或者RSA等等）。json
例如：api
而后，用Base64对这个JSON编码就获得JWT的第一部分跨域
Payload
JWT的第二部分是payload，它包含声明（要求）。声明是关于实体(一般是用户)和其余数据的声明。声明有三种类型: registered, public 和 private。浏览器
- Registered claims : 这里有一组预约义的声明，它们不是强制的，可是推荐。好比：iss (issuer), exp (expiration time), sub (subject), aud (audience)等。
- Public claims : 能够随意定义。
- Private claims : 用于在赞成使用它们的各方之间共享信息，而且不是注册的或公开的声明。
下面是一个例子：
对payload进行Base64编码就获得JWT的第二部分
注意，不要在JWT的payload或header中放置敏感信息，除非它们是加密的。
Signature
为了获得签名部分，你必须有编码过的header、编码过的payload、一个秘钥，签名算法是header中指定的那个，然对它们签名便可。
例如：
HMACSHA256(base64UrlEncode(header) + "." + base64UrlEncode(payload), secret)
签名是用于验证消息在传递过程当中有没有被更改，而且，对于使用私钥签名的token，它还能够验证JWT的发送方是否为它所称的发送方。
看一张官网的图就明白了：
4. JSON Web Tokens是如何工做的
在认证的时候，当用户用他们的凭证成功登陆之后，一个JSON Web Token将会被返回。此后，token就是用户凭证了，你必须很是当心以防止出现安全问题。通常而言，你保存令牌的时候不该该超过你所须要它的时间。
不管什么时候用户想要访问受保护的路由或者资源的时候，用户代理（一般是浏览器）都应该带上JWT，典型的，一般放在Authorization header中，用Bearer schema。
header应该看起来是这样的：
Authorization: Bearer <token>
服务器上的受保护的路由将会检查Authorization header中的JWT是否有效，若是有效，则用户能够访问受保护的资源。若是JWT包含足够多的必需的数据，那么就能够减小对某些操做的数据库查询的须要，尽管可能并不老是如此。
若是token是在受权头（Authorization header）中发送的，那么跨源资源共享(CORS)将不会成为问题，由于它不使用cookie。
下面这张图显示了如何获取JWT以及使用它来访问APIs或者资源：
- 应用（或者客户端）想受权服务器请求受权。例如，若是用受权码流程的话，就是/oauth/authorize
- 当受权被许能够后，受权服务器返回一个access token给应用
- 应用使用access token访问受保护的资源（好比：API）
5. 基于Token的身份认证 与 基于服务器的身份认证
5.1. 基于服务器的身份认证
在讨论基于Token的身份认证是如何工做的以及它的好处以前，咱们先来看一下之前咱们是怎么作的：
HTTP协议是无状态的，也就是说，若是咱们已经认证了一个用户，那么他下一次请求的时候，服务器不知道我是谁，咱们必须再次认证
传统的作法是将已经认证过的用户信息存储在服务器上，好比Session。用户下次请求的时候带着Session ID，而后服务器以此检查用户是否定证过。
这种基于服务器的身份认证方式存在一些问题：
- Sessions : 每次用户认证经过之后，服务器须要建立一条记录保存用户信息，一般是在内存中，随着认证经过的用户愈来愈多，服务器的在这里的开销就会愈来愈大。
- Scalability : 因为Session是在内存中的，这就带来一些扩展性的问题。
- CORS : 当咱们想要扩展咱们的应用，让咱们的数据被多个移动设备使用时，咱们必须考虑跨资源共享问题。当使用AJAX调用从另外一个域名下获取资源时，咱们可能会遇到禁止请求的问题。
- CSRF : 用户很容易受到CSRF攻击。
5.2. JWT与Session的差别
相同点是，它们都是存储用户信息；然而，Session是在服务器端的，而JWT是在客户端的。
Session方式存储用户信息的最大问题在于要占用大量服务器内存，增长服务器的开销。
而JWT方式将用户状态分散到了客户端中，能够明显减轻服务端的内存压力。
Session的状态是存储在服务器端，客户端只有session id；而Token的状态是存储在客户端。
5.3. 基于Token的身份认证是如何工做的
基于Token的身份认证是无状态的，服务器或者Session中不会存储任何用户信息。
没有会话信息意味着应用程序能够根据须要扩展和添加更多的机器，而没必要担忧用户登陆的位置。
虽然这一实现可能会有所不一样，但其主要流程以下：
- 用户携带用户名和密码请求访问
- 服务器校验用户凭据
- 应用提供一个token给客户端
- 客户端存储token，而且在随后的每一次请求中都带着它
- 服务器校验token并返回数据
注意：
- 每一次请求都须要token
- Token应该放在请求header中
- 咱们还须要将服务器设置为接受来自全部域的请求，用Access-Control-Allow-Origin: *
5.4. 用Token的好处
- 无状态和可扩展性：Tokens存储在客户端。彻底无状态，可扩展。咱们的负载均衡器能够将用户传递到任意服务器，由于在任何地方都没有状态或会话信息。
- 安全：Token不是Cookie。（The token, not a cookie.）每次请求的时候Token都会被发送。并且，因为没有Cookie被发送，还有助于防止CSRF攻击。即便在你的实现中将token存储到客户端的Cookie中，这个Cookie也只是一种存储机制，而非身份认证机制。没有基于会话的信息能够操做，由于咱们没有会话
6.什么是jwt
双方之间传递安全信息的简洁的、URL安全的表述性声明规范。JWT做为一个开放的标准（
RFC 7519），定义了一种简洁的，自包含的方法用于通讯双方之间以Json对象的形式安全的传递信息。
简洁(Compact): 能够经过URL，POST参数或者在HTTP header发送，由于数据量小，传输速度也很快
自包含(Self-contained)：负载中包含了全部用户所须要的信息，避免了屡次查询数据库。
6.1.Jwt在javaweb项目中的简单使用
第一步：引入maven依赖
<!--引入JWT依赖,因为是基于Java，因此须要的是java-jwt-->
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>0.9.1</version>
</dependency>
<dependency>
<groupId>com.auth0</groupId>
<artifactId>java-jwt</artifactId>
<version>3.4.0</version>
</dependency>
第二步：建立两个注解，拦截器经过注释区分是否进行权限拦截（详情参考上一篇文章JWT在JAVAWEB项目中的应用核心步骤解读 http://www.javashuo.com/article/p-wbdpbnxu-dk.html)
package com.pjb.springbootjjwt.jimisun;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface LoginToken {
boolean required() default true;
}
package com.pjb.springbootjjwt.jimisun;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface CheckToken {
boolean required() default true;
}
第三步：编写JwtUtil工具类（生成token,解析token,校验token）
package com.pjb.springbootjjwt.jimisun;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
/**
* @Author:jimisun
* @Description:
* @Date:Created in 14:08 2018/8/15
* @Modified By:
*/
public class JwtUtil {
/**
* 用户登陆成功后生成Jwt
* 使用Hs256算法 私匙使用用户密码
*
* @param ttlMillis jwt过时时间
* @param user 登陆成功的user对象
* @return
*/
public static String createJWT(long ttlMillis, User user) {
//指定签名的时候使用的签名算法，也就是header那部分，jjwt已经将这部份内容封装好了。
SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
//生成JWT的时间
long nowMillis = System.currentTimeMillis();
Date now = new Date(nowMillis);
//建立payload的私有声明（根据特定的业务须要添加，若是要拿这个作验证，通常是须要和jwt的接收方提早沟通好验证方式的）
Map<String, Object> claims = new HashMap<String, Object>();
claims.put("id", user.getId());
claims.put("username", user.getUsername());
claims.put("password", user.getPassword());
//生成签名的时候使用的秘钥secret,这个方法本地封装了的，通常能够从本地配置文件中读取，切记这个秘钥不能外露哦。它就是你服务端的私钥，在任何场景都不该该流露出去。一旦客户端得知这个secret, 那就意味着客户端是能够自我签发jwt了。
String key = user.getPassword();
//生成签发人
String subject = user.getUsername();
//下面就是在为payload添加各类标准声明和私有声明了
//这里其实就是new一个JwtBuilder，设置jwt的body
JwtBuilder builder = Jwts.builder()
//若是有私有声明，必定要先设置这个本身建立的私有的声明，这个是给builder的claim赋值，一旦写在标准的声明赋值以后，就是覆盖了那些标准的声明的
.setClaims(claims)
//设置jti(JWT ID)：是JWT的惟一标识，根据业务须要，这个能够设置为一个不重复的值，主要用来做为一次性token,从而回避重放攻击。
.setId(UUID.randomUUID().toString())
//iat: jwt的签发时间
.setIssuedAt(now)
//表明这个JWT的主体，即它的全部人，这个是一个json格式的字符串，能够存放什么userid，roldid之类的，做为何用户的惟一标志。
.setSubject(subject)
//设置签名使用的签名算法和签名使用的秘钥
.signWith(signatureAlgorithm, key);
if (ttlMillis >= 0) {
long expMillis = nowMillis + ttlMillis;
Date exp = new Date(expMillis);
//设置过时时间
builder.setExpiration(exp);
}
return builder.compact();
}
/**
* Token的解密
* @param token 加密后的token
* @param user 用户的对象
* @return
*/
public static Claims parseJWT(String token, User user) {
//签名秘钥，和生成的签名的秘钥如出一辙
String key = user.getPassword();
//获得DefaultJwtParser
Claims claims = Jwts.parser()
//设置签名的秘钥
.setSigningKey(key)
//设置须要解析的jwt
.parseClaimsJws(token).getBody();
return claims;
}
/**
* 校验token
* 在这里可使用官方的校验，我这里校验的是token中携带的密码于数据库一致的话就校验经过
* @param token
* @param user
* @return
*/
public static Boolean isVerify(String token, User user) {
//签名秘钥，和生成的签名的秘钥如出一辙
String key = user.getPassword();
//获得DefaultJwtParser
Claims claims = Jwts.parser()
//设置签名的秘钥
.setSigningKey(key)
//设置须要解析的jwt
.parseClaimsJws(token).getBody();
if (claims.get("password").equals(user.getPassword())) {
return true;
}
return false;
}
}
第四步：编写拦截器拦截请求进行权限验证
package com.pjb.springbootjjwt.interceptor;
import com.auth0.jwt.JWT;
import com.auth0.jwt.exceptions.JWTDecodeException;
import com.pjb.springbootjjwt.jimisun.CheckToken;
import com.pjb.springbootjjwt.jimisun.JwtUtil;
import com.pjb.springbootjjwt.jimisun.LoginToken;
import com.pjb.springbootjjwt.jimisun.User;
import com.pjb.springbootjjwt.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.Method;
/**
* jimisun
*/
public class AuthenticationInterceptor implements HandlerInterceptor {
@Autowired
UserService userService;
@Override
public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object object) throws Exception {
// 从 http 请求头中取出 token
String token = httpServletRequest.getHeader("token");
// 若是不是映射到方法直接经过
if (!(object instanceof HandlerMethod)) {
return true;
}
HandlerMethod handlerMethod = (HandlerMethod) object;
Method method = handlerMethod.getMethod();
//检查是否有LoginToken注释，有则跳过认证
if (method.isAnnotationPresent(LoginToken.class)) {
LoginToken loginToken = method.getAnnotation(LoginToken.class);
if (loginToken.required()) {
return true;
}
}
//检查有没有须要用户权限的注解
if (method.isAnnotationPresent(CheckToken.class)) {
CheckToken checkToken = method.getAnnotation(CheckToken.class);
if (checkToken.required()) {
// 执行认证
if (token == null) {
throw new RuntimeException("无token，请从新登陆");
}
// 获取 token 中的 user id
String userId;
try {
userId = JWT.decode(token).getClaim("id").asString();
} catch (JWTDecodeException j) {
throw new RuntimeException("访问异常！");
}
User user = userService.findUserById(userId);
if (user == null) {
throw new RuntimeException("用户不存在，请从新登陆");
}
Boolean verify = JwtUtil.isVerify(token, user);
if (!verify) {
throw new RuntimeException("非法访问！");
}
return true;
}
}
return true;
}
@Override
public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
}
@Override
public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
}
}
配置拦截器（ps:我使用的是springboot，你们使用ssm配置拦截器的方式不同）
package com.pjb.springbootjjwt.interceptorconfig;
import com.pjb.springbootjjwt.interceptor.AuthenticationInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(authenticationInterceptor())
.addPathPatterns("/**"); // 拦截全部请求，经过判断是否有 @LoginRequired 注解 决定是否须要登陆
}
@Bean
public AuthenticationInterceptor authenticationInterceptor() {
return new AuthenticationInterceptor();
}
}
第五步:在示例Controller中的实际应用
package com.pjb.springbootjjwt.jimisun;
import com.alibaba.fastjson.JSONObject;
import com.pjb.springbootjjwt.annotation.PassToken;
import com.pjb.springbootjjwt.annotation.UserLoginToken;
import com.pjb.springbootjjwt.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import java.util.UUID;
/**
* @Author:jimisun
* @Description:
* @Date:Created in 15:04 2018/8/15
* @Modified By:
*/
@RestController
@RequestMapping("/api")
public class UserController {
@Autowired
private UserService userService;
//登陆
@PostMapping("/login")
@LoginToken
public Object login(@RequestBody @Valid com.pjb.springbootjjwt.jimisun.User user) {
JSONObject jsonObject = new JSONObject();
com.pjb.springbootjjwt.jimisun.User userForBase = userService.findByUsername(user);
if (userForBase == null) {
jsonObject.put("message", "登陆失败,用户不存在");
return jsonObject;
} else {
if (!userForBase.getPassword().equals(user.getPassword())) {
jsonObject.put("message", "登陆失败,密码错误");
return jsonObject;
} else {
String token = JwtUtil.createJWT(6000000, userForBase);
jsonObject.put("token", token);
jsonObject.put("user", userForBase);
return jsonObject;
}
}
}
//查看我的信息
@CheckToken
@GetMapping("/getMessage")
public String getMessage() {
return "你已经过验证";
}
}
最后一步，咱们如今来访问一下啊
先进行登陆
登陆后携带token进行业务操做
相关文章
- 1. 理解JWT，使用JWT
- 2. JWT理论理解
- 3. JWT原理解析
- 4. jwt的我的理解
- 5. JWT的简单理解
- 6. 你真的了解JWT？JWT详解
- 7. 了解 JWT
- 8. JWT详解
- 9. jwt 0.9.0（一）推荐jwt理由
- 10. 理解JWT（JSON Web Token）认证
- 更多相关文章...
- • SQLite Explain（解释） - SQLite教程
- • 错误处理 - RUST 教程
- • Docker 清理命令
- • ☆技术问答集锦（13）Java Instrument原理
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章
- 1. 理解JWT，使用JWT
- 2. JWT理论理解
- 3. JWT原理解析
- 4. jwt的我的理解
- 5. JWT的简单理解
- 6. 你真的了解JWT？JWT详解
- 7. 了解 JWT
- 8. JWT详解
- 9. jwt 0.9.0（一）推荐jwt理由
- 10. 理解JWT（JSON Web Token）认证