现在开发前后端分离的系统或者开发 APP 的项目时，在验证用户是否登录时都会使用 Token 的方式，使用 Token 也是为系统后续可以进行拆分的第一步。
 
 
       Token 的生成规则可以任意，只要最终可以通过 Token 去匹配到合适的用户即可。不过我们可以使用 JWT 类库来帮助我们生成 Token。JWT 是 Json Web Token 的意思，是一种通过 Json 格式在 Web 中进行传递的 Token。
 
 
JWT 的使用
 
       先来看看关于 JWT 的使用，它的使用是比较简单的。
 
        创建一个 Spring Boot 的项目，然后引入 JWT 的依赖，依赖如下：
 
<dependency>  <groupId>io.jsonwebtoken</groupId>  <artifactId>jjwt</artifactId>  <version>0.7.0</version></dependency>
 
       然后创建一个 Util，用来生成 Token，代码如下：
 
public static String createToken(String subject){    return Jwts.builder()            .setSubject(subject)            .signWith(SignatureAlgorithm.HS256, secret)            .compact();}
 
       方法中，subject 就是要生成 token 的值，比如这里可以是用户名、用户 ID 等。signWith 是设置一个签名的算法，其中 HS256 是 HMAC-SHA256，HMAC 是基于哈希的消息验证码，SHA256 是一种哈希算法。secret 是我们自己定义的一个密钥，这个密钥很重要。
 
        调用 createToken 就可以生成 Token 了，写一个单元测试，代码如下：
 
String name = "木瓜";String token = TokenUtil.createToken(name);System.out.println("木瓜的token:" + token);​name = "西瓜";token = TokenUtil.createToken(name);System.out.println("西瓜的token:" + token);
 
        运行它，输出如下：
 
木瓜的token:eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiLmnKjnk5wifQ.PmD4oa5OeA9p0TKr076UgO95WoNhyr2Yk1pAdgfqG3s西瓜的token:eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiLopb_nk5wifQ.HcPdzxH0IFcyr_m0QZMPiX18dToPh07fQn4pDMWxdi0
 
       可以看出，两个不同的 name 生成了不同的 Token。
 
 
        我们同样可以使用 JWT 类库来对 Token 进行验证，代码如下：
 
public static String parseToken(String token){    Claims body = null;​    try {        body = Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();    } catch (io.jsonwebtoken.ExpiredJwtException e) {        return e.getMessage();    }​    return body.getSubject();}
 
        修改单元测试的代码，代码如下：
 
String name = "木瓜";String token = TokenUtil.createToken(name);System.out.println("木瓜的token:" + token);System.out.println("parseToken:" + TokenUtil.parseToken(token));​name = "西瓜";token = TokenUtil.createToken(name);System.out.println("西瓜的token:" + token);System.out.println("parseToken:" + TokenUtil.parseToken(token));
 
        运行结果如下：
 
木瓜的token:eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiLmnKjnk5wifQ.PmD4oa5OeA9p0TKr076UgO95WoNhyr2Yk1pAdgfqG3sparseToken:木瓜西瓜的token:eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiLopb_nk5wifQ.HcPdzxH0IFcyr_m0QZMPiX18dToPh07fQn4pDMWxdi0parseToken:西瓜
 
       可以看到，我们的 name 被还原回来了，这样就可以进行验证匹配了。
 
 
        JWT 还可以设置 Token 的过期时间等，那些就不再描述了。
 
 
JWT 的原理
 
       JWT 的原理其实并不复杂，简单的看一眼代码，并给出它的原理。
 
 
        在介绍其原理之前，先使用一个在线工具来对 JWT 生成的 Token 进行一下解密，如下图。
 
 
        可以看出，我们的 Token 被还原了。我们的签名算法和名字都被解析了出来。慌吗？这是什么情况呢！
 
 
        上面 JWT 生成的 Token 包含三部分，并使用“点”号分隔。使用前面的 Token 来进行说明，Token 如下：
 
eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiLmnKjnk5wifQ.PmD4oa5OeA9p0TKr076UgO95WoNhyr2Yk1pAdgfqG3s
 
        上面的 Token 实际分为三部分，分别如下：
 
eyJhbGciOiJIUzI1NiJ9eyJzdWIiOiLmnKjnk5wifQPmD4oa5OeA9p0TKr076UgO95WoNhyr2Yk1pAdgfqG3s
 
        上面每行代表一部分，第一行表示签名算法，第二行是我们的用户名或用户ID，第三行是签名。
 
        第一部分和第二部分是用 base64 算法进行编码的，只要通过 base64 的解码算法进行解码就可以得到相关的内容，解码如下。
 
 
 
        从图中可以看出，对第一部分和第二部分进行解码后，都是一个 Json 串。
 
 
        第三部分是对第一部分加第二部分内容的一个签名。
 
 
        大体流程如下图。
 
 
 
        大致来看一下源码。回顾 JWT 生成 Token 的方法，代码如下：
 
return Jwts.builder()        .setSubject(subject)        .signWith(SignatureAlgorithm.HS256, secret)        .compact();
 
        我们关键来看 signWith 和 compact 两个方法。
 
        先来看一下 signWith 方法，代码如下：
 
public JwtBuilder signWith(SignatureAlgorithm alg, byte[] secretKey) {    Assert.notNull(alg, "SignatureAlgorithm cannot be null.");    Assert.notEmpty(secretKey, "secret key byte array cannot be null or empty.");    Assert.isTrue(alg.isHmac(), "Key bytes may only be specified for HMAC signatures.  If using RSA or Elliptic Curve, use the signWith(SignatureAlgorithm, Key) method instead.");    this.algorithm = alg;    this.keyBytes = secretKey;    return this;}​public JwtBuilder signWith(SignatureAlgorithm alg, String base64EncodedSecretKey) {    Assert.hasText(base64EncodedSecretKey, "base64-encoded secret key cannot be null or empty.");    Assert.isTrue(alg.isHmac(), "Base64-encoded key bytes may only be specified for HMAC signatures.  If using RSA or Elliptic Curve, use the signWith(SignatureAlgorithm, Key) method instead.");    byte[] bytes = TextCodec.BASE64.decode(base64EncodedSecretKey);    return this.signWith(alg, bytes);}
 
        上面的代码主要就是设置了 签名算法 和 secretKey，secretKey 使用 base64 解码算法，除此并没有太多的处理。
 
 
        再来看一下 compact 方法，代码如下：
 
public String compact() {    if (this.payload == null && Collections.isEmpty(this.claims)) {        throw new IllegalStateException("Either 'payload' or 'claims' must be specified.");    } else if (this.payload != null && !Collections.isEmpty(this.claims)) {        throw new IllegalStateException("Both 'payload' and 'claims' cannot both be specified. Choose either one.");    } else if (this.key != null && this.keyBytes != null) {        throw new IllegalStateException("A key object and key bytes cannot both be specified. Choose either one.");    } else {        Header header = this.ensureHeader();        Key key = this.key;        if (key == null && !Objects.isEmpty(this.keyBytes)) {            // 生成了key            key = new SecretKeySpec(this.keyBytes, this.algorithm.getJcaName());        }​        Object jwsHeader;        if (header instanceof JwsHeader) {            jwsHeader = (JwsHeader)header;        } else {            jwsHeader = new DefaultJwsHeader(header);        }​        if (key != null) {            ((JwsHeader)jwsHeader).setAlgorithm(this.algorithm.getValue());        } else {            ((JwsHeader)jwsHeader).setAlgorithm(SignatureAlgorithm.NONE.getValue());        }​        if (this.compressionCodec != null) {            ((JwsHeader)jwsHeader).setCompressionAlgorithm(this.compressionCodec.getAlgorithmName());        }​        // 对{"alg": "HS256"}进行base64编码        String base64UrlEncodedHeader = this.base64UrlEncode(jwsHeader, "Unable to serialize header to json.");        String base64UrlEncodedBody;        if (this.compressionCodec != null) {            byte[] bytes;            try {                bytes = this.payload != null ? this.payload.getBytes(Strings.UTF_8) : this.toJson(this.claims);            } catch (JsonProcessingException var9) {                throw new IllegalArgumentException("Unable to serialize claims object to json.");            }            base64UrlEncodedBody = TextCodec.BASE64URL.encode(this.compressionCodec.compress(bytes));        } else {            // 对{"sub": "木瓜"}进行base64编码            base64UrlEncodedBody = this.payload != null ? TextCodec.BASE64URL.encode(this.payload) : this.base64UrlEncode(this.claims, "Unable to serialize claims object to json.");        }        // 两个base64字符串拼接
        String jwt = base64UrlEncodedHeader + '.' + base64UrlEncodedBody;        if (key != null) {            // 生成签名            JwtSigner signer = this.createSigner(this.algorithm, (Key)key);            String base64UrlSignature = signer.sign(jwt);            // 拼接字符串            jwt = jwt + '.' + base64UrlSignature;        } else {            jwt = jwt + '.';        }​        return jwt;    }}
 
       以上就是 JWT 生成 Token 的流程了。整个代码流程并不复杂。
 
 
 
总结
 
       JWT 生成 Token 的流程比较简单的，通过 base64 解码算法也可以轻松的拿到原始数据和签名算法。对于 JWT 库，不但可以对原始数据和签名算法进行还原，也会根据提前预定的 secret 来验证签名，确保数据没有被篡改。看了 JWT 后可能觉得，这个东西没有加密，的确是这样的。JWT 中的签名也是通常意义上的签名，只用来保证数据的完整性、抗抵赖性的，并不是起加密作用的。而对于签名算法中最为重要的 secret 可以使用暴力破解的方式来进行猜测，一旦猜测成功，JWT 就不安全了。
 

 
本文实例讲述了PHP token验证生成原理。分享给大家供大家参考，具体如下：
 
/**
 
* @Author: Ding Jianlong
 
* @Date: 2019-03-20 00:38:01
 
* @Last Modified by: Ding Jianlong
 
* @Last Modified time: 2019-03-22 17:50:59
 
*/
 
//生成发送请求的验证 token
 
//这里的key可以是包含用户信息的内容，不用用户+不同的权限
 
function makeToken($key){
 
//100秒内有效，不变，时间根据实际需要调整。第三方登录授权15天。
 
return $token = md5($key.sha1(substr(time(),3,7)));
 
}
 
//后台同理验证，
 
function checkToken($key,$token){
 
$true = md5($key.sha1(substr(time(),3,7)));
 
if($token == $true){
 
return true; //token正确
 
}else{
 
return false;
 
}
 
}
 
$key = 'https://github.com/idjl/';
 
echo $t = makeToken($key);
 
var_dump(checkToken($key,'259521122'));
 
var_dump(checkToken($key,$t));
 
var_dump(checkToken($key,'259521122'));
 
运行结果：
 
e4ce1a6c66246eee048f11a540bf197ebool(false)
 
bool(true)
 
bool(false)
 
希望本文所述对大家PHP程序设计有所帮助。

 
什么是token?
 
Token是服务端生成的一串字符串，以作客户端进行请求的一个令牌，当第一次登录后，服务器生成一个Token便将此Token返回给客户端，以后客户端只需带上这个Token前来请求数据即可，无需再次带上用户名和密码。
 
基于 Token 的身份验证
 
使用基于 Token 的身份验证方法，在服务端不需要存储用户的登录记录。流程是这样的：
 
1.客户端使用用户名跟密码请求登录
 
2.服务端收到请求，去验证用户名与密码
 
3.验证成功后，服务端会签发一个 Token，再把这个 Token 发送给客户端
 
客户端收到 Token 以后可以把它存储起来，比如放在 Cookie 里或者 Local Storage 里
 
4.客户端每次向服务端请求资源的时候需要带着服务端签发的 Token
 
服务端收到请求，然后去验证客户端请求里面带着的 Token，如果验证成功，就向客户端返回请求的数据
 
5.APP登录的时候发送加密的用户名和密码到服务器，服务器验证用户名和密码，如果成功，以某种方式比如随机生成32位的字符串作为token，存储到服务器中，并返回token到APP，以后APP请求时，
 
凡是需要验证的地方都要带上该token，然后服务器端验证token，成功返回所需要的结果，失败返回错误信息，让他重新登录。其中服务器上token设置一个有效期，每次APP请求的时候都验证token和有效期。
 
token的优势
 
1.无状态、可扩展
 
在客户端存储的Tokens是无状态的，并且能够被扩展。基于这种无状态和不存储Session信息，负载负载均衡器能够将用户信息从一个服务传到其他服务器上。如果我们将已验证的用户的信息保存在Session中，则每次请求都需要用户向已验证的服务器发送验证信息(称为Session亲和性)。用户量大时，可能会造成 一些拥堵。但是不要着急。使用tokens之后这些问题都迎刃而解，因为tokens自己hold住了用户的验证信息。
 
2.安全性
 
请求中发送token而不再是发送cookie能够防止CSRF(跨站请求伪造)。即使在客户端使用cookie存储token，cookie也仅仅是一个存储机制而不是用于认证。不将信息存储在Session中，让我们少了对session操作。token是有时效的，一段时间之后用户需要重新验证。我们也不一定需要等到token自动失效，token有撤回的操作，通过token revocataion可以使一个特定的token或是一组有相同认证的token无效。
 
3.可扩展性
 
Tokens能够创建与其它程序共享权限的程序。例如，能将一个随便的社交帐号和自己的大号(Fackbook或是Twitter)联系起来。当通过服务登录Twitter(我们将这个过程Buffer)时，我们可以将这些Buffer附到Twitter的数据流上(we are allowing Buffer to post to our Twitter stream)。使用tokens时，可以提供可选的权限给第三方应用程序。当用户想让另一个应用程序访问它们的数据，我们可以通过建立自己的API，得出特殊权限的tokens。
 
4.多平台跨域
 
我们提前先来谈论一下CORS(跨域资源共享)，对应用程序和服务进行扩展的时候，需要介入各种各种的设备和应用程序。Having our API just serve data, we can also make the design choice to serve assets from a CDN. This eliminates the issues that CORS brings up after we set a quick header configuration for our application.只要用户有一个通过了验证的token，数据和资源就能够在任何域上被请求到。Access-Control-Allow-Origin: *
 
5.基于标准
 
创建token的时候，你可以设定一些选项。我们在后续的文章中会进行更加详尽的描述，但是标准的用法会在JSON Web Tokens体现。最近的程序和文档是供给JSON Web Tokens的。它支持众多的语言。这意味在未来的使用中你可以真正的转换你的认证机制。
 
token原理
 
1.将荷载payload，以及Header信息进行Base64加密，形成密文payload密文，header密文。
 
2.将形成的密文用句号链接起来，用服务端秘钥进行HS256加密，生成签名.
 
3.将前面的两个密文后面用句号链接签名形成最终的token返回给服务端
 
注：
 
(1)用户请求时携带此token(分为三部分，header密文，payload密文，签名)到服务端，服务端解析第一部分(header密文)，用Base64解密，可以知道用了什么算法进行签名，此处解析发现是HS256。
 
(2)服务端使用原来的秘钥与密文(header密文+"."+payload密文)同样进行HS256运算，然后用生成的签名与token携带的签名进行对比，若一致说明token合法，不一致说明原文被修改。
 
(3)判断是否过期，客户端通过用Base64解密第二部分(payload密文)，可以知道荷载中授权时间，以及有效期。通过这个与当前时间对比发现token是否过期。
 
token实现思路
 
1.用户登录校验，校验成功后就返回Token给客户端。
 
2.客户端收到数据后保存在客户端
 
3.客户端每次访问API是携带Token到服务器端。
 
4.服务器端采用filter过滤器校验。校验成功则返回请求数据，校验失败则返回错误码
 
token代码生成工具类demo
 
package com.frank.common.utils;
 
import com.alibaba.fastjson.JSON;
 
import com.frank.common.entity.TokenHeader;
 
import com.frank.common.entity.TokenPlayload;
 
import com.frank.common.entity.User;
 
import java.rmi.server.UID;
 
import java.util.UUID;
 
/**
 
Description:Token生成工具
 
第一部分我们称它为头部(header),第二部分我们称其为载荷(payload, 类似于飞机上承载的物品)，第三部分是签证(signature).
 
Auth: Frank
 
Date: 2020-11-05
 
Time: 下午 5:05
 
*/
 
public class TokenUtil {
 
public static final String TOKEN_AES_KEY = "xiangli8Token";
 
public static final String REFREH_TOKEN_AES_KEY = "xiangli8RefreshToken";
 
public static final String JWT_TYP = "JWT";
 
public static final String JWT_ALG = "AES";
 
public static final String JWT_EXP = "30";
 
public static final String JWT_ISS = "xiangli8";
 
/**
 
* 获得token
 
* @param data 自定义数据
 
* @param 自定义数据
 
* @return
 
* @throws Exception
 
*/
 
public static String getToken(T data) throws Exception {
 
TokenPlayload userTokenPlayload = new TokenPlayload<>();
 
userTokenPlayload.setExpData(data);
 
String jwt = createJWT(userTokenPlayload);
 
return jwt;
 
}
 
/**
 
* 生成jwt的header部分内容
 
* @return
 
* @throws Exception
 
*/
 
private static String tokenHeaderBase64() throws Exception {
 
TokenHeader tokenHeader = new TokenHeader();
 
tokenHeader.setTyp(JWT_TYP);
 
tokenHeader.setAlg(JWT_ALG);
 
String headerJson = JSON.toJSONString(tokenHeader);
 
String headerBase64 = Base64Util.encryptBASE64(headerJson.getBytes());
 
return headerBase64;
 
}
 
/**
 
* 生成jwt的payload部分内容
 
* @param tokenPlayload
 
* @param 自定义的数据块
 
* @return
 
* @throws Exception
 
*/
 
private static String tokenPayloadBase64(TokenPlayload tokenPlayload) throws Exception {
 
tokenPlayload.setIss(JWT_ISS);
 
tokenPlayload.setExp(JWT_EXP);
 
tokenPlayload.setIat(String.valueOf(System.currentTimeMillis()));
 
String headerJson =JSON.toJSONString(tokenPlayload);
 
String headerBase64 = Base64Util.encryptBASE64(headerJson.getBytes());
 
return headerBase64;
 
}
 
/**
 
生成JWT
 
@return
 
*/
 
public static String createJWT(TokenPlayload tokenPlayload) throws Exception {
 
StringBuilder jwtSb = new StringBuilder();
 
StringBuilder headerPlayloadSb = new StringBuilder();
 
String tokenHeaderBase64 = tokenHeaderBase64();
 
String tokenPayloadBase64 = tokenPayloadBase64(tokenPlayload);
 
jwtSb.append(tokenHeaderBase64);
 
jwtSb.append(".");
 
jwtSb.append(tokenPayloadBase64);
 
jwtSb.append(".");
 
headerPlayloadSb.append(tokenHeaderBase64);
 
headerPlayloadSb.append(tokenPayloadBase64);
 
String headerPlayloadSalt = SaltUtil.addSalt(headerPlayloadSb.toString());
 
String key = AesUtil.initKey(TOKEN_AES_KEY+tokenPlayload.getIat());
 
String signature = Base64Util.encryptBASE64(AesUtil.encrypt(headerPlayloadSalt.getBytes(),key));
 
jwtSb.append(signature);
 
return Base64Util.encryptBASE64(jwtSb.toString().getBytes());
 
}
 
/**
 
* 校验token是否是服务器生成的，以防token被修改
 
* @param jwtBase64
 
* @return
 
* @throws Exception
 
*/
 
public static boolean verifyJWT(String jwtBase64) throws Exception {
 
String jwt = new String (Base64Util.decryptBASE64(jwtBase64));
 
if(!jwt.contains(".")){
 
return false;
 
}
 
String[] jwts = jwt.split("\\.");
 
if(jwts.length<3){
 
return false;
 
}
 
TokenPlayload tTokenPlayload = JSON.parseObject(new String(Base64Util.decryptBASE64(jwts[1])),TokenPlayload.class);
 
String key = AesUtil.initKey(TOKEN_AES_KEY+tTokenPlayload.getIat());
 
//解析出header跟playload
 
StringBuilder headerPlayloadSb = new StringBuilder();
 
headerPlayloadSb.append(jwts[0]);
 
headerPlayloadSb.append(jwts[1]);
 
//解析signature
 
String headerPlayloadSalt = new String (AesUtil.decrypt(Base64Util.decryptBASE64(jwts[2]),key));
 
return SaltUtil.verifyPwd(headerPlayloadSb.toString(),headerPlayloadSalt);
 
}
 
public static void main(String[] args) throws Exception {
 
String jwt = getToken(new User(1L,"你是逗逼"));
 
System.out.println("jwt:"+jwt);
 
System.out.println("verifyJWT:"+verifyJWT(jwt));
 
}
 
}
 
使用说明
 
1，根据上面生成一个由base64编码的token，该token由Header，Payload，Signature组成。
 
2，token作为用户请求的标识，客户端保存这token的全部信息。服务端只需要保存token的Signature部分。
 
3，服务端把token的Signature存于redis和服务器的数据库中。
 
4，客户端请求的数据附带token，服务端拿到token，首先校验token，以防token伪造。校验规则如下：
 
4.1，拆分出token的Header，Payload，Signature。
 
4.2，校验Signature，通过token的header和payload生成Signature，看看生成的Signature是否和客户端附带上来的Signature一致。如果一致继续请求操作，不一致则打回操作
 
4.3，查看Signature是否存在服务器的redis和数据库中。如果不存在则打回请求操作
 
差不多也是这些东西

背景
 
公司处在前后端分离的转折阶段，作为后端人员，要找到一个适用于接口验证的方式，公司仍保持后端使用Laravel框架，而laravel框架默认的是【web】方式，web 方式是使用 session 来进行用户认证，当然也是可以使用，但是有一定的不安全，经过调研，主流使用的Token验证方式。
 
介绍JWT
 
JWT资料
 
项目Wiki
官方指导文档
 
JWT：全称Json Web Token，是一种规范化的token。可以理解为对token这一技术提出的一套规范，是在RFC 7519中提出的。介绍JWT之前，先了解token的基本原理
 Token认证原理概述
 
客户端发送认证信息（一般是指用户名/密码，clientid/secret），向服务器发送请求
服务器验证客户端请求来的认证信息，然后服务端向客户端返回一个加密的token（字符串）
客户端接收并将token存储（采用cookie、session都可），然后在每次请求服务器的时候都要携带这个token
服务器端验证token的合法性，验证通过，服务器就认为这是一个合法请求，允许进行接下来的沟通
 
上述的token只是一种思路，一种解决用户授权问题的思考方式，基于这个思路，针对不同场景也就衍生出很多种的实现。而JWT就是最为流行的一种。
 
JWT概述
 
在传统的实现中，服务器会保存生成的token，当客户端发送请求的时候，服务器进行对比来实现验证，但是jwt不需要在服务器存储任何token，而是使用一套加/解密算法和一个密钥来对客户端发送的token进行验证。
 这样的作法同时增加了多服务器的扩展性，在传统的token验证中，客户端请求来的token，必选先找到存贮这个token的服务器是那台，然后由那一台服务器进行用户身份验证。而JWT的存在，只需要每一台服务器都知道解密密钥，那么每一台服务器都有验证用户身份的能力。
 
写在最后
 
用过laravel的都清楚laravel推出了自己的用户认证模块“Passport”，要使用吗
 我个人觉着这个层次太高，是一个很大的抽象层，被设计成一个完全成熟的OAuth2服务来用，目标专一。而jwt设计更倾向于，是一个简单的用户认证方式。当然功能也是十分强大的。假如真有OAuth相关的需求，需要一台支持OAuth的服务器，那么可以使用passport。
 
jwt-auth介绍二：Token组成方式
 
【前程栽树，后人乘凉】
 JWT超详细分析
 JWT-Auth了解