基于token的登陆验证机制

Cookie认证

在互联网服务起步之初，业务系统一般都是单系统的，登录只要登录这一个系统就好。在此阶段，主要通过cookie进行登录验证。

Cookie实际上是存储在浏览器上的数据，格式为key-value形式。比如chrome浏览器，可以在设置页面查看到存储了网站的cookie：

在同一域名下，不同页面之间可以共享Cookie；而在不同域名下，默认情况下是不能共享Cookie的，这是为了安全考虑的。当然可以通过一些设置允许Cookie跨域。Cookie有时间限制和长度限制，一般不超过4KB。

客户端第一次请求服务端的时候，服务器通过相应头的形式，向客户端发送一个身份认证的Cookie，客户端会自动将其保存在浏览器中。随后，当客户端浏览器每次请求服务器的时候，浏览器会自动将身份认证相关的Cookie通过请求头的形式发送到服务器，以供服务器鉴别其身份。

Cookie存在如下一些问题：

• 数量和长度限制。不同浏览器每个domain保存的cookie的key-value是有数量限制的，且基本都有4KB的长度限制，超过此长度的会被截掉。
• 安全性问题。如果cookie被人截取了，那别人就可以利用这些cookie了，即使加密也没用，因为拦截者并不需要知道cookie的意义，只要原样转发就可以冒充被拦截者的身份。
• 占用网络带宽。每次请求服务器资源时，都携带cookie信息向服务器传递。

Session认证

由于cookie认证存在上文所述的诸多问题，后来session认证出现了。Session是一块保存在服务器端的内存空间，一般用于保存用户的会话信息。

用户通过用户名和密码登陆成功之后，服务器端程序会在服务器端开辟一块session内存空间并将用户的信息存入这块空间，同时服务器会在cookie中写入一个session_id的值，这个值用于标识这个内存空间。

下次用户再来访问的话会带着这个cookie中的session_id，服务器拿着这个id去寻找对应的session，如果session中已经有了这个用户的登陆信息，则说明用户已经登陆过了。

使用Session保持会话信息使用起来非常简单，技术也非常成熟。但是也存在下面的几个问题：

• 服务器压力大：与cookie存储在客户端不同，session是存储在服务器的，当用户量增大时，服务器的压力增大。
• 扩展性：在分布式集群中，用户的每次请求可能会落到不同的服务器上，因此就会存在session共享的问题。当然，使用redis等分布式中心作为分布式session方案已经是比较成熟的应用了，问题不大。
• CSRF跨站伪造请求攻击：Session机制是基于浏览器端的cookie的，cookie如果被截获，用户就会很容易受到跨站请求伪造的攻击。

基于Token的认证

通过上文我们知道，cookie是存储在浏览器上的，具有安全性上的问题。而session是基于cookie的，需要在cookie中存储sessionId，同样存在安全性问题。
而且在移动互联网时代，出于安全、隐私或性能上的考虑，很多移动设备对cookie有不同的限制或禁用。

基于token的认证机制将认证信息（也就是token）返回给客户端并存储，客户端下次访问时只需要带上认证信息即可。

简单的流程如下：

• 客户端使用用户名跟密码请求登录；
• 服务端收到请求，去验证用户名与密码；
• 验证成功后，服务端会签发一个Token，再把这个Token发送给客户端；
• 客户端收到 Token 以后可以把它存储起来，比如放在 Cookie 里或者 Local Storage 里；
• 客户端每次向服务端请求资源的时候需要带着服务端签发的Token；
• 服务端收到请求，然后去验证客户端请求里面带着的Token，如果验证成功，就向客户端返回请求的数据；

基于token的验证机制，有以下的优点：

• 支持跨域访问，默认情况下cookie是不支持跨域访问的。而使用token则可以将其置于请求头中，进行跨域访问；
• 无状态化，服务端无需存储token，只需要验证token信息是否正确即可，而session需要在服务端存储，一般是通过 cookie中的sessionID在服务端查找对应的session；
• 无需绑定到一个特殊的身份验证方案（传统的用户名密码登陆），只需要生成的token是符合我们预期设定的即可；
• 更适用于移动端（Android，iOS，小程序等等），像这种原生平台不支持cookie，比如说微信小程序，每一次请求都是一次会话，当然也可以每次去手动为他添加cookie；
• 避免CSRF跨站伪造攻击，还是因为不依赖cookie；
• 性能更高，token无需在服务端存储，不用查询，只需校验其合法性(包括加解密)，消耗cpu资源。性能更高。

缺点的话一个就是相比较于传统的session登陆机制实现起来略微复杂一点，另外一个比较大的缺点是由于服务器不保存token，因此无法在使用过程中废止某个token，或者更改token的权限。也就是说，一旦 token 签发了，在到期之前就会始终有效，除非服务器部署额外的逻辑。

退出登陆的话，只要前端清除token信息即可。

JWT

Json Web Token是一个标准Token。

JWT标准的token有三个部分：

header.payload.signature

三个部分用.隔开，并且都使用base64编码，生成的token类似这样的：

ewofasfasfsagvfmairjqwtiu.fmaslkgjighodapskafbnsdg.gfmkgnlkorwuahgjbasgjbamncAkjkjLKjbr

header

header部分包括token类型和使用的签名算法，例如：

{
    “type”：“JWT”,
    "alg": "HS256"
}

用base64加密后得到：ewogICd0eXBlJzogJ0pXVCcsCiAgJ2FsZyc6ICdIUzI1NicKfQ==

playload

存放有效信息的地方。主要包括：jwt标准声明，公共声明和私有声明。

标准声明包括：iss(jwt签发者)，sub(面向的用户)，aud(接收jwt的一方)，exp(jwt的过期时间)，nbf(jwt生效时间)，iat(jwt签发时间)，jti(jwt的唯一身份标识)，标准声明不强制使用。

公共声明可以添加任何信息，一般是用户和业务相关信息，但不能放敏感信息如密码等，因为base64编码可以认为是明文的。

私有声明是提供者和消费者共同定义的声明，同样不建议存放敏感信息。

下面是一个payload的示例：

{
  "sub": "1234567890",
  "name": "John",
  "admin": true
}

经过base64编码后得到：ewogICJzdWIiOiAiMTIzNDU2Nzg5MCIsCiAgIm5hbWUiOiAiSm9obiIsCiAgImFkbWluIjogdHJ1ZQp9CiA=

signature

jwt的第三部分是一个签名信息，将base64编码的header和payload用.连接起来，然后通过header中声明的签名方式进行签名，就得到了jwt的第三部分。过程如下：

originStr = base64(header) + "." + base64(payload)
signature = HS256(originStr , secret)

将这三部分用.连接起来就得到了最终的jwt。

jwt应用

客户端发请求时将jwt放到请求头中（需要加上Bearer标注）：

headers: {
    'Authorization': 'Bearer ' + token
  }

服务器对客户端请求头中的jwt进行验签，验签通过说明是合法的，通过解码获取到用户信息，并返回数据。

如果token在传输的过程中被攻击者截取了的话，那么对方就可以利用窃取到的token模拟正常请求，实现用户的正常操作，而服务器端完全不知道。因为JWT在服务器端是无状态的，且服务器端不存储jwt的。

事实上jwt解决的问题是认证和授权的问题，对于安全性的话，还是建议使用https来保证。

一种实际应用方案

在上文介绍的认证方案中，相较于session，token认证方式对服务端来讲更简单，因为只需要验证token的合法性，而无需存储token，另外token还是无状态的，不需要考虑状态一致性问题。但问题是token可能会被截取。

因此，可以将session和token的思想结合起来使用。具体来说，生成token的时候不用公共协议，而是用自定义方式。比如用uid和deviceId加上签发时间一起组成字符串进行加密。客户端发起请求时，带上token和deviceId，服务端收到请求后对token进行解密，对比deviceId是否相同，并验证token是否过期。如此一来，就可以过滤伪造的非法token了。假设你的加密协议和密钥都泄漏出去了，服务端收到的token是伪造的格式正确的token，还可以进一步查询数据库，判断该token对应的用户是否存在且与token解析出来的一致，以确保该token对应的用户是合法登录用户。

在这种方式中，token相当于一个有意义的sessionId。在不查询数据库的基础上，可以直接校验token的合法性，避免非法sessionId每次都要查询数据库，带来巨大压力。如果不考虑token的加密协议和密钥存在泄漏的可能性，甚至不需要后续查询数据库的部分，直接校验token就行。事实上，这就是一种不使用jwt的token认证方案。

如果合法用户的token和deviceId都被截取，那么不管如何做，都会导致身份冒用。

下面是将Token和Session思想结合起来使用的流程：

下面是token生成与解析：

class TokenFactory(object):
    key_bytes = [0x40, 0x64, 0x13, 0x38, 0x43, 0x25, 0x47,
                 0x67, 0x16, 0x64, 0x15, 0x79, 0x36, 0x23,
                 0x24, 0x37]
    key = ''.join(map(lambda x: chr(x % 256), key_bytes))
    iv_bytes = [0x24, 0x11, 0x34, 0x71, 0x41, 0x03, 0x13,
                0x17, 0x49, 0x64, 0x21, 0x34, 0x54, 0x66,
                0x12, 0x24]
    iv = ''.join(map(lambda x: chr(x % 256), iv_bytes))

    PADDING = '}'
    BS = 16
    MAGIC = 'TESTMOD'
    EXTEND = 1

    @classmethod
    def pad(cls, s):
        return '%s%s' % (s, (cls.BS - len(s) % cls.BS) * cls.PADDING)

    @classmethod
    def generate(cls, user_id, device_id, current_time=None):
        current_time = current_time is not None and current_time or int(time.time() * 1000)

        data = '%s%s%s%s%s' % (cls.MAGIC,
                               struct.pack('>d', current_time),
                               struct.pack('>Q', user_id),
                               struct.pack('B', cls.EXTEND),
                               str(device_id))

        cipher = AES.new(cls.key, AES.MODE_CBC, cls.iv)
        t = string.maketrans('+/=', '-_.')
        return base64.b64encode(cipher.encrypt(cls.pad(data))).translate(t)

    @classmethod
    def load(cls, token):
        cipher = AES.new(cls.key, AES.MODE_CBC, cls.iv)
        t = string.maketrans('-_.', '+/=')

        try:
            data = cipher.decrypt(base64.b64decode(token.translate(t))).rstrip(cls.PADDING)
            if data[:7] == cls.MAGIC:
                create_time = int(struct.unpack('>d', data[7:15])[0])
                user_id = int(struct.unpack('>Q', data[15:23])[0])
                extend = int(struct.unpack('B', data[23])[0])
                device_id = data[24:]
            else:
                logging.info('LOAD TOKEN FAILED %s' % token)
                return None
        except Exception, e:
            logging.exception(e)
            logging.error(e)
            return None

        return int(user_id), device_id, int(create_time), extend

Java实现

public class TokenFactory {

    private static final int[] keyBytes = new int[] {
            0x40, 0x64, 0x13, 0x38, 0x43, 0x25, 0x47,
            0x67, 0x16, 0x64, 0x15, 0x79, 0x36, 0x23,
            0x24, 0x37};
    private static final int[] ivBytes = new int[] {
            0x24, 0x11, 0x34, 0x71, 0x41, 0x03, 0x13,
            0x17, 0x49, 0x64, 0x21, 0x34, 0x54, 0x66,
            0x12, 0x24};

    private static final String MAGIC = "TESTMOD";
    private static final byte PADDING = '}';
    private static final byte EXTEND = 1;
    private static final int BS = 16;
    private static final SecretKeySpec SECRET_KEY;
    private static final IvParameterSpec IvParam;

    static {
        StringBuffer buffer = new StringBuffer();
        for (int i = 0; i < keyBytes.length; i++) {
            buffer.append((char) (keyBytes[i] % 256));
        }
        String aesKey = buffer.toString();

        byte[] iv = new byte[ivBytes.length];
        for (int i = 0; i < ivBytes.length; i++) {
            iv[i] = (byte) (ivBytes[i] % 256);
        }

        SECRET_KEY = new SecretKeySpec(aesKey.getBytes(), "AES");
        IvParam = new IvParameterSpec(iv);
    }

    public static String generate(long userId, String deviceId, long time) {
        if (time < 1) {
            time = System.currentTimeMillis();
        }

        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            DataOutputStream os = new DataOutputStream(bos);
            os.writeDouble(time);
            os.writeLong(userId);
            os.writeByte(EXTEND);
            byte[] data = BasicUtil.combineBytes(MAGIC.getBytes(), bos.toByteArray(), deviceId.getBytes());

            Cipher aesEncrypt = Cipher.getInstance("AES/CBC/NOPADDING");
            aesEncrypt.init(Cipher.ENCRYPT_MODE, SECRET_KEY, IvParam);

            return new String(Base64.encode(aesEncrypt.doFinal(pad(data)))).replace('+', '-').replace('/', '_').replace('=', '.');
        } catch (Exception e) {
            e.printStackTrace();
        }

        return "";
    }

    public static String generate(long userId, String deviceId) {
        return generate(userId, deviceId, System.currentTimeMillis());
    }

    public static String[] load(String token) {
        long createTime;
        long userId;
        int extend;
        String device;
        try {
            token = token.replace('-', '+').replace('_', '/').replace('.', '=');
            byte[] decodedToken = Base64.decode(token);

            Cipher aesDecrypt = Cipher.getInstance("AES/CBC/NOPADDING");
            aesDecrypt.init(Cipher.DECRYPT_MODE, SECRET_KEY, IvParam);

            byte[] aesDecrypted = aesDecrypt.doFinal(decodedToken);
            byte[] rstriped = BasicUtil.rstrip(aesDecrypted, PADDING);
            if (BasicUtil.startsWith(rstriped, MAGIC.getBytes())) {
                byte[] lstriped = Arrays.copyOfRange(rstriped, MAGIC.length(), aesDecrypted.length);
                DataInputStream is = new DataInputStream(new ByteArrayInputStream(lstriped));
                createTime = (long)is.readDouble();   // 8 byte
                userId = is.readLong();          // 8 byte
                extend = is.readUnsignedByte();   // 1 byte
                device = new String(Arrays.copyOfRange(lstriped, 17, lstriped.length));
            } else {
                Logger.info("LOAD TOKEN FAILED", "%s", token);
                return new String[0];
            }
        } catch (Exception e) {
            e.printStackTrace();
            return new String[0];
        }

        return new String[] {String.valueOf(userId), device, String.valueOf(createTime), String.valueOf(extend)};
    }

    private static final byte[] pad(byte[] data) {
        byte[] padding = new byte[(BS - data.length % BS)];
        Arrays.fill(padding, PADDING);
        return BasicUtil.combineBytes(data, padding);
    }
}

public class BasicUtil {
    public static byte[] combineBytes(byte[]... args) {
        int length = 0;
        for (byte[] b : args) {
            length += b.length;
        }

        final byte[] result = new byte[length];
        length = 0;
        for (final byte[] b : args) {
            for (int i = 0; i < b.length; i ++) {
                result[length++] = b[i];
            }
        }

        return result;
    }

    public static byte[] rstrip(byte[] src, byte target) {
        if (isEmpty(src)) {
            return src;
        }

        int end = src.length - 1;
        while (end >= 0) {
            if (src[end] == target) {
                end--;
            } else {
                break;
            }
        }

        if (end < 0) {
            return new byte[0];
        } else {
            return Arrays.copyOf(src, end + 1);
        }
    }

    public static boolean startsWith(byte[] src, byte[] tag) {
        for (int i = 0; i < tag.length; i++) {
            if (src[i] != tag[i]) {
                return false;
            }
        }

        return true;
    }
}

参考资料

[1]. https://www.cnblogs.com/54chensongxia/p/13491214.html
[2]. https://www.jianshu.com/p/576dbf44b2ae