基于token的登陆验证机制

常用的登录验证机制包括session和token。

session简介

做过Web开发的程序员应该对Session都比较熟悉，Session是一块保存在服务器端的内存空间，一般用于保存用户的会话信息。

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

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

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

• 服务器压力大：通常Session是存储在内存中的，每个用户通过认证之后都会将session数据保存在服务器的内存中，而当用户量增大时，服务器的压力增大。
• 扩展性：在分布式集群中，用户的每次请求可能会落到不同的服务器上，因此就会存在session共享的问题。当然，使用redis等分布式中心作为分布式session方案已经是比较成熟的应用了。
• CSRF跨站伪造请求攻击：Session机制是基于浏览器端的cookie的，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信息即可。

JSON Web 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的第三部分是一个签名信息，由三部分组成：

• header (base64后的)
• payload (base64后的)
• secret

将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实际上是一个包含用户信息的sessionId)：

token可以用uid，deviceId或其他标识，加上时间戳等信息生成。客户端将token和deviceId放到cookie中，服务器拿到token之后进行调用check_token进行认证。首先解析token，获取用户信息，验证是否合法(如果解析出来的deviceId与传过来的deviceId不同，说明是不合法的)。接着再到redis中查询，得到用户信息，再次验证是否合法。如果存在且不相同，说明是不合法的，认证失败。如果不存在，则继续到db中查询，如果db中仍然不存在，或者不合法，则认证失败。

下面是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