MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

JWT在隐私保护中的作用与挑战

2024-01-035.9k 阅读

JWT 基础概念

JSON Web Token（JWT）是一种开放标准（RFC 7519），它定义了一种紧凑且自包含的方式，用于在各方之间作为 JSON 对象安全地传输信息。这些信息可以被验证和信任，因为它是数字签名的。JWT 通常由三部分组成：头部（Header）、载荷（Payload）和签名（Signature）。

头部（Header）

头部通常由两部分组成：令牌的类型，即 JWT，以及所使用的签名算法，如 HMAC SHA256 或 RSA。以下是一个头部的示例：

{
  "alg": "HS256",
  "typ": "JWT"
}

然后，这个 JSON 对象会使用 Base64Url 编码组成 JWT 的第一部分。

载荷（Payload）

载荷是 JWT 的第二部分，其中包含声明（claims）。声明是关于实体（通常是用户）和其他数据的陈述。有三种类型的声明：注册声明（registered claims）、公共声明（public claims）和私有声明（private claims）。

  • 注册声明：这些是一组预定义的声明，它们不是强制性的，但推荐使用。例如：iss（issuer，发行者）、exp（expiration time，过期时间）、sub（subject，主题）等。
  • 公共声明：可以由使用 JWT 的各方随意定义。但为了避免冲突，应在 IANA JSON Web Token 注册表中定义，或者定义为包含命名空间的 URI。
  • 私有声明：是为了在同意使用它们的各方之间共享信息而创建的自定义声明。

以下是一个载荷的示例：

{
  "sub": "1234567890",
  "name": "John Doe",
  "iat": 1516239022
}

同样，这个 JSON 对象会使用 Base64Url 编码组成 JWT 的第二部分。

签名（Signature）

要创建签名部分，需要使用编码后的头部、编码后的载荷、一个密钥（secret）、头部中指定的签名算法。例如，如果使用 HMAC SHA256 算法，签名将按如下方式创建：

HMACSHA256(
  base64UrlEncode(header) + "." +
  base64UrlEncode(payload),
  secret)

签名用于验证消息在传输过程中没有被更改，并且，当使用私钥签名时，它还可以验证 JWT 的发送者的身份。

JWT 在隐私保护中的作用

减少服务器端状态存储

传统的身份验证机制，如基于会话（session - based）的认证，服务器需要在内存或数据库中存储用户的会话信息。这不仅增加了服务器的存储负担，还带来了隐私风险。如果服务器的会话存储被攻击，攻击者就可以获取到用户的敏感信息。

而 JWT 是无状态的。服务器不需要存储关于用户会话的任何信息，因为所有必要的信息都包含在 JWT 本身中。当客户端发送带有 JWT 的请求时，服务器只需要验证 JWT 的签名，而不需要查询数据库或内存中的会话信息。这样，即使服务器的数据库被泄露，攻击者也无法从会话存储中获取用户的敏感信息，从而保护了用户的隐私。

例如，在一个简单的 Node.js 应用中，使用 Express 框架和 jsonwebtoken 库实现无状态认证：

const express = require('express');
const jwt = require('jsonwebtoken');
const app = express();
const secret = 'your - secret - key';

// 模拟用户登录
app.post('/login', (req, res) => {
  const user = { id: 1, username: 'testuser' };
  const token = jwt.sign(user, secret, { expiresIn: '1h' });
  res.json({ token });
});

// 受保护的路由
app.get('/protected', authenticateToken, (req, res) => {
  res.json(req.user);
});

function authenticateToken(req, res, next) {
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1];
  if (token == null) return res.sendStatus(401);
  jwt.verify(token, secret, (err, user) => {
    if (err) return res.sendStatus(403);
    req.user = user;
    next();
  });
}

const port = 3000;
app.listen(port, () => {
  console.log(`Server running on port ${port}`);
});

在这个例子中，服务器在用户登录时生成 JWT，之后对受保护路由的请求只需要验证 JWT 而无需额外的会话存储。

数据封装与传输安全

JWT 将用户相关的信息封装在一个 JSON 对象中，并进行 Base64Url 编码和签名。这种封装方式使得在网络传输过程中，数据具有一定的完整性和安全性。

编码后的 JWT 数据在网络上传输时，虽然 Base64Url 编码并非加密，但它使得数据在外观上不直观可读，增加了攻击者获取敏感信息的难度。而且，JWT 的签名机制保证了数据在传输过程中没有被篡改。如果攻击者尝试修改 JWT 的载荷部分，签名验证将失败，服务器可以拒绝该请求。

例如，在一个 Python Flask 应用中，使用 PyJWT 库来展示 JWT 的数据封装与验证：

from flask import Flask, request, jsonify
import jwt
from datetime import datetime, timedelta

app = Flask(__name__)
app.config['SECRET_KEY'] = 'your - secret - key'

@app.route('/login', methods=['POST'])
def login():
    data = request.get_json()
    user = {
        'id': 1,
        'username': data.get('username')
    }
    expiration = datetime.utcnow() + timedelta(minutes = 30)
    token = jwt.encode({
        'user': user,
        'exp': expiration
    }, app.config['SECRET_KEY'], algorithm='HS256')
    return jsonify({'token': token})

@app.route('/protected', methods=['GET'])
def protected():
    token = request.headers.get('Authorization')
    if not token:
        return jsonify({'message': 'Token is missing'}), 401
    try:
        token = token.split(' ')[1]
        data = jwt.decode(token, app.config['SECRET_KEY'], algorithms=['HS256'])
        return jsonify(data.get('user'))
    except jwt.ExpiredSignatureError:
        return jsonify({'message': 'Token has expired'}), 401
    except jwt.InvalidTokenError:
        return jsonify({'message': 'Invalid token'}), 401

if __name__ == '__main__':
    app.run(debug = True)

在这个 Flask 应用中，JWT 封装了用户信息，并在传输和验证过程中保证了数据的安全性和完整性。

跨域与分布式系统中的隐私保护

在跨域（Cross - Origin）和分布式系统中，JWT 可以作为一种安全的身份验证和授权机制，保护用户隐私。

在跨域场景下，传统的基于 Cookie 的认证机制会受到同源策略的限制，而 JWT 可以轻松地在不同域之间传递。客户端可以将 JWT 存储在本地（如 localStorage 或 sessionStorage），并在每次跨域请求时将其包含在请求头中。服务器在接收到请求后，验证 JWT 的有效性，从而决定是否允许访问。这样可以避免在跨域过程中暴露用户的敏感信息。

在分布式系统中，不同的微服务可能需要相互验证身份和权限。JWT 可以在微服务之间传递，每个微服务都可以独立地验证 JWT 的签名和载荷信息。由于 JWT 包含了用户的身份和权限信息，微服务不需要再向其他服务或中心认证服务器查询用户信息，减少了信息泄露的风险。

例如，在一个使用 Spring Cloud 构建的分布式系统中，假设一个用户服务（User Service）和一个订单服务（Order Service）。用户服务在用户登录后生成 JWT，订单服务通过验证 JWT 来处理订单相关请求：

// 用户服务生成 JWT
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.stereotype.Service;

import java.util.Date;

@Service
public class JwtService {
    private static final String SECRET_KEY = "your - secret - key";

    public String generateToken(String username) {
        Date now = new Date();
        Date expiration = new Date(now.getTime() + 10 * 60 * 1000);

        Claims claims = Jwts.claims().setSubject(username);
        claims.put("created", now);

        return Jwts.builder()
               .setClaims(claims)
               .setIssuedAt(now)
               .setExpiration(expiration)
               .signWith(SignatureAlgorithm.HS256, SECRET_KEY)
               .compact();
    }
}

// 订单服务验证 JWT
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureException;
import org.springframework.stereotype.Service;

import java.util.Date;

@Service
public class OrderService {
    private static final String SECRET_KEY = "your - secret - key";

    public boolean validateToken(String token) {
        try {
            Claims claims = Jwts.parser()
                   .setSigningKey(SECRET_KEY)
                   .parseClaimsJws(token)
                   .getBody();

            Date expiration = claims.getExpiration();
            Date now = new Date();

            return expiration.after(now);
        } catch (SignatureException | IllegalArgumentException e) {
            return false;
        }
    }
}

在这个示例中，用户服务生成的 JWT 在订单服务中被验证，确保了分布式系统中服务间通信的隐私和安全。

JWT 在隐私保护中的挑战

密钥管理

JWT 的安全性在很大程度上依赖于密钥（secret）的保密性。如果密钥泄露，攻击者就可以伪造 JWT，从而绕过认证和授权机制，获取用户的敏感信息。

在大规模的应用中，密钥的生成、存储和更新是一个复杂的任务。例如，在一个云原生应用中，多个微服务可能都需要使用相同的密钥来验证 JWT。如何安全地在各个微服务之间共享密钥，同时防止密钥泄露是一个挑战。

一种解决方案是使用密钥管理服务（KMS，Key Management Service）。KMS 可以提供安全的密钥生成、存储和访问控制。例如，AWS Key Management Service（AWS KMS）允许用户创建、管理和控制加密密钥。应用程序可以通过 API 调用 KMS 来获取密钥，而无需在本地存储密钥。以下是使用 AWS KMS 和 Java 进行 JWT 签名的示例：

import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.kms.AWSKMS;
import com.amazonaws.services.kms.AWSKMSClientBuilder;
import com.amazonaws.services.kms.model.DecryptRequest;
import com.amazonaws.services.kms.model.DecryptResult;
import com.amazonaws.services.kms.model.EncryptRequest;
import com.amazonaws.services.kms.model.EncryptResult;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

import java.nio.ByteBuffer;
import java.security.SecureRandom;
import java.util.Date;

public class JwtWithKMS {
    private static final String KEY_ID = "your - kms - key - id";
    private static final AWSKMS kms = AWSKMSClientBuilder.standard()
           .withRegion(Regions.US_EAST_1)
           .withCredentials(new DefaultAWSCredentialsProviderChain())
           .build();

    public static String generateToken(String username) {
        Date now = new Date();
        Date expiration = new Date(now.getTime() + 10 * 60 * 1000);

        Claims claims = Jwts.claims().setSubject(username);
        claims.put("created", now);

        byte[] secretBytes = new byte[32];
        SecureRandom random = new SecureRandom();
        random.nextBytes(secretBytes);

        EncryptRequest encryptRequest = new EncryptRequest()
               .withKeyId(KEY_ID)
               .withPlaintext(ByteBuffer.wrap(secretBytes));
        EncryptResult encryptResult = kms.encrypt(encryptRequest);

        byte[] encryptedSecret = encryptResult.getCiphertextBlob().array();

        return Jwts.builder()
               .setClaims(claims)
               .setIssuedAt(now)
               .setExpiration(expiration)
               .signWith(SignatureAlgorithm.HS256, encryptedSecret)
               .compact();
    }

    public static boolean validateToken(String token) {
        try {
            EncryptRequest encryptRequest = new EncryptRequest()
                   .withKeyId(KEY_ID)
                   .withPlaintext(ByteBuffer.wrap(new byte[32]));
            EncryptResult encryptResult = kms.encrypt(encryptRequest);
            byte[] encryptedSecret = encryptResult.getCiphertextBlob().array();

            DecryptRequest decryptRequest = new DecryptRequest()
                   .withCiphertextBlob(ByteBuffer.wrap(encryptedSecret));
            DecryptResult decryptResult = kms.decrypt(decryptRequest);
            byte[] secretBytes = decryptResult.getPlaintext().array();

            Claims claims = Jwts.parser()
                   .setSigningKey(secretBytes)
                   .parseClaimsJws(token)
                   .getBody();

            Date expiration = claims.getExpiration();
            Date now = new Date();

            return expiration.after(now);
        } catch (SignatureException | IllegalArgumentException e) {
            return false;
        }
    }
}

通过使用 KMS，应用程序可以更安全地管理 JWT 的密钥，降低密钥泄露的风险。

JWT 载荷大小与隐私暴露

JWT 的载荷部分可以包含用户的各种信息，如身份、权限等。然而，如果载荷中包含过多敏感信息，就可能增加隐私暴露的风险。

一方面，由于 JWT 通常会在客户端存储（如 localStorage 或 sessionStorage），如果客户端的存储被攻击，攻击者可以获取到 JWT 的全部载荷信息。另一方面，JWT 在网络传输过程中，虽然经过编码，但并非加密，如果网络被监听，攻击者也有可能获取到载荷中的敏感信息。

为了减少这种风险，应尽量避免在 JWT 载荷中包含高度敏感的信息，如用户的密码、信用卡号等。对于必要的用户信息，可以进行适当的加密处理后再放入载荷中。

例如，在一个 Ruby on Rails 应用中，使用 bcrypt 库对敏感信息进行加密后放入 JWT 载荷：

require 'jwt'
require 'bcrypt'

secret_key = 'your - secret - key'

user = { id: 1, username: 'testuser', email: 'test@example.com' }
# 假设 password 是敏感信息，进行加密
user[:encrypted_password] = BCrypt::Password.create('user - password')

payload = { user: user }
token = JWT.encode(payload, secret_key, 'HS256')

# 验证时
begin
  decoded = JWT.decode(token, secret_key, true, { algorithm: 'HS256' })
  user_info = decoded[0]['user']
  puts user_info
rescue JWT::DecodeError => e
  puts "Invalid token: #{e.message}"
end

在这个例子中，敏感的用户密码信息经过加密后放入 JWT 载荷，降低了隐私暴露的风险。

过期与撤销机制

JWT 有一个过期时间（exp）的声明，可以设置 JWT 的有效期限。然而，在某些情况下，需要提前撤销 JWT，例如用户注销、密码修改或者检测到异常登录等情况。

由于 JWT 是无状态的，服务器没有存储关于 JWT 的任何信息，实现撤销机制比较困难。一种常见的解决方案是使用黑名单（blacklist）或白名单（whitelist）。服务器可以维护一个已撤销的 JWT 列表（黑名单），每次接收到请求时，检查 JWT 是否在黑名单中。

例如，在一个 Node.js 应用中，使用 Redis 作为黑名单存储：

const express = require('express');
const jwt = require('jsonwebtoken');
const redis = require('redis');
const app = express();
const secret = 'your - secret - key';
const redisClient = redis.createClient();

// 模拟用户登录
app.post('/login', (req, res) => {
  const user = { id: 1, username: 'testuser' };
  const token = jwt.sign(user, secret, { expiresIn: '1h' });
  res.json({ token });
});

// 撤销 JWT
app.post('/logout', (req, res) => {
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1];
  if (token == null) return res.sendStatus(401);
  redisClient.setex(token, 3600, 'revoked');
  res.sendStatus(200);
});

// 受保护的路由
app.get('/protected', authenticateToken, (req, res) => {
  res.json(req.user);
});

function authenticateToken(req, res, next) {
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1];
  if (token == null) return res.sendStatus(401);
  redisClient.get(token, (err, reply) => {
    if (reply ==='revoked') {
      return res.sendStatus(401);
    }
    jwt.verify(token, secret, (err, user) => {
      if (err) return res.sendStatus(403);
      req.user = user;
      next();
    });
  });
}

const port = 3000;
app.listen(port, () => {
  console.log(`Server running on port ${port}`);
});

在这个示例中，通过 Redis 实现了 JWT 的撤销机制，当用户注销时，将 JWT 加入黑名单，后续请求时验证 JWT 是否在黑名单中，以决定是否允许访问。然而，这种方法增加了服务器的状态管理，与 JWT 的无状态特性有一定冲突，并且在分布式系统中实现黑名单同步也存在挑战。

安全漏洞风险

JWT 存在一些已知的安全漏洞风险，如签名算法漏洞、注入攻击等。

如果使用的签名算法存在漏洞，攻击者可能利用这些漏洞伪造签名，从而伪造 JWT。例如，曾经有一些针对某些早期版本的 HMAC 算法实现的攻击，攻击者可以通过精心构造的输入绕过签名验证。因此，应始终使用经过安全审计的、最新版本的 JWT 库，并及时更新以修复可能存在的签名算法漏洞。

另外，JWT 也可能受到注入攻击。例如，在构建 JWT 载荷时，如果没有对用户输入进行适当的验证和过滤，攻击者可能注入恶意数据，从而影响 JWT 的验证逻辑或获取敏感信息。

为了防止注入攻击，在处理用户输入时，应使用严格的验证和过滤机制。例如，在一个 PHP 应用中，使用 filter_var 函数对用户输入进行验证：

<?php
use Firebase\JWT\JWT;

$secret_key = "your - secret - key";
$user_input = $_POST['username'];
// 验证用户名输入
if (!filter_var($user_input, FILTER_VALIDATE_REGEXP, array("options" => array("regexp" => "/^[a-zA - Z0 - 9_]{3,20}$/")))) {
    die('Invalid username');
}

$user = array('id' => 1, 'username' => $user_input);
$issued_at = time();
$expiration = $issued_at + 3600;

$payload = array(
    'user' => $user,
    'iat' => $issued_at,
    'exp' => $expiration
);

$jwt = JWT::encode($payload, $secret_key, 'HS256');
echo $jwt;
?>

在这个 PHP 示例中，通过对用户输入的用户名进行正则表达式验证，防止了可能的注入攻击，提高了 JWT 的安全性。同时，开发人员需要关注安全社区的动态，及时了解和防范 JWT 相关的安全漏洞。

通过以上对 JWT 在隐私保护中的作用与挑战的深入分析，我们可以看到 JWT 为后端开发中的隐私保护提供了有力的工具，但同时也需要开发人员谨慎处理相关的挑战，以确保系统的安全性和用户隐私的保护。