C++ JWT库jwt-cpp实现身份认证与令牌验证实践

auto token = jwt::create()
    .set_issuer("auth.myapp.com")
    .set_type("jwt")
    .set_payload_claim("username", jwt::claim(std::string("john_doe"))) // 自定义声明
    .set_expires_at(std::chrono::system_clock::now() + std::chrono::hours{24}) // 自动处理时间戳
    .sign(jwt::algorithm::hs256{"my_super_secret_key"});

# 安装vcpkg（如果尚未安装）
git clone https://github.com/microsoft/vcpkg.git
./vcpkg/bootstrap-vcpkg.sh

# 安装jwt-cpp
./vcpkg install jwt-cpp

find_package(jwt-cpp config required)
target_link_libraries(your_target private jwt-cpp::jwt-cpp)

git submodule add https://github.com/thalhammer/jwt-cpp.git externals/jwt-cpp

add_subdirectory(externals/jwt-cpp)
target_link_libraries(your_target private jwt-cpp)

#include <jwt-cpp/jwt.h>
#include <iostream>

int main() {
    // 1. 定义密钥（在实际应用中，应从安全配置中读取，切勿硬编码！）
    std::string secret = "my_at_least_32_bytes_long_super_secret_key";

    // 2. 创建token builder，设置声明并签名
    auto token = jwt::create()
        .set_issuer("myapp-server")
        .set_subject("user12345")
        .set_issued_at(std::chrono::system_clock::now())
        .set_expires_at(std::chrono::system_clock::now() + std::chrono::hours{1})
        .set_payload_claim("role", jwt::claim(std::string("admin")))
        .sign(jwt::algorithm::hs256{secret});

    // 3. 输出令牌
    std::cout << "generated token: " << token << std::endl;
    return 0;
}

#include <jwt-cpp/jwt.h>
#include <iostream>

bool validate_token(const std::string& token, const std::string& secret) {
    try {
        // 1. 创建验证器，指定验证规则
        auto verifier = jwt::verify()
            .allow_algorithm(jwt::algorithm::hs256{secret}) // 允许的算法
            .with_issuer("myapp-server") // 签发者必须匹配
            .with_subject("user12345"); // 主题必须匹配（根据业务需要可选）

        // 2. 解码并验证令牌
        auto decoded_token = jwt::decode(token);
        verifier.verify(decoded_token);

        // 3. 验证通过，可以安全地使用声明了
        std::cout << "token is valid." << std::endl;
        std::cout << "user role: " << decoded_token.get_payload_claim("role").as_string() << std::endl;
        return true;
    } catch (const jwt::token_verification_exception& e) {
        // 捕获验证失败异常（签名无效、过期、issuer不匹配等）
        std::cerr << "token verification failed: " << e.what() << std::endl;
        return false;
    } catch (const std::exception& e) {
        // 捕获其他异常（如解码错误）
        std::cerr << "error: " << e.what() << std::endl;
        return false;
    }
}

// 假设你已经从pem文件或硬件安全模块（hsm）加载了私钥
// 私钥字符串（示例，实际应从文件读取）
std::string private_key_pem = r"(-----begin private key-----
...
-----end private key-----)";

auto token = jwt::create()
    .set_issuer("https://auth.mycompany.com")
    .set_audience("api.myapp.com")
    .sign(jwt::algorithm::rs256("， private_key_pem， "")); // 使用私钥签名

// 公钥字符串（可以从auth server的jwks端点获取）
std::string public_key_pem = r"(-----begin public key-----
...
-----end public key-----)";

auto verifier = jwt::verify()
    .allow_algorithm(jwt::algorithm::rs256(public_key_pem， ""))
    .with_issuer("https://auth.mycompany.com");

auto decoded = jwt::decode(incoming_token);
verifier.verify(decoded); // 使用公钥验证签名

auto verifier = jwt::verify()
    .allow_algorithm(jwt::algorithm::hs256{secret})
    .with_issuer("myapp")
    .leeway(30); // 设置30秒的宽容期

// 或者，为特定声明单独设置
auto verifier2 = jwt::verify()
    .allow_algorithm(jwt::algorithm::hs256{secret})
    .with_issuer("myapp")
    .leeway_for_exp(60) // 过期时间宽容60秒
    .leeway_for_nbf(10); // 生效时间宽容10秒

auto verifier = jwt::verify()
    .allow_algorithm(jwt::algorithm::hs256{secret})
    .with_custom_claim_validation("department"， [](const jwt::claim& c) {
        // 自定义验证逻辑
        if (!c.has_value() || c.get_type() != jwt::json::type::string) {
            throw jwt::token_verification_exception("claim 'department' is missing or not a string");
        }
        std::string dept = c.as_string();
        if (dept != "engineering" && dept != "sales" && dept != "hr") {
            throw jwt::token_verification_exception("invalid department");
        }
    });

// 错误：没有指定算法，或允许了不安全的算法
// auto verifier = jwt::verify(); // 这将接受任何算法，包括“none”！

// 正确：显式指定允许的算法
auto verifier = jwt::verify().allow_algorithm(jwt::algorithm::rs256(public_key));

auto verifier = jwt::verify()
    .allow_algorithm(...)
    .with_issuer("https://trusted-issuer.com") // 验证签发者
    .with_audience("my-resource-server") // 验证受众
    .with_claim("version"， jwt::claim(std::string("2.0"))) // 验证自定义声明
    // .leeway(...) // 根据需要设置宽容期

// 伪代码，展示核心逻辑
#include <jwt-cpp/jwt.h>
#include <string>
#include <unordered_map>

class tokenvalidator {
public:
    tokenvalidator(const std::string& public_key_pem， const std::string& expected_issuer)
        : verifier_(jwt::verify()
            .allow_algorithm(jwt::algorithm::rs256(public_key_pem， ""))
            .with_issuer(expected_issuer)
            .leeway(5)) // 5秒时钟偏移容忍
    {}

    struct validationresult {
        bool isvalid;
        std::string userid;
        std::string error;
    };

    validationresult validate(const std::string& auth_header) {
        validationresult result;
        // 1. 从 "bearer <token>" 格式中提取令牌
        const std::string bearer_prefix = "bearer ";
        if (auth_header.find(bearer_prefix) != 0) {
            result.isvalid = false;
            result.error = "invalid authorization header format";
            return result;
        }
        std::string token = auth_header.substr(bearer_prefix.length());

        try {
            // 2. 解码并验证
            auto decoded = jwt::decode(token);
            verifier_.verify(decoded);

            // 3. 提取业务信息
            result.isvalid = true;
            // 假设用户id存储在 `sub` (subject) 声明中
            result.userid = decoded.get_subject();

            // 4. 可选：检查自定义声明，如权限
            if (decoded.has_payload_claim("scopes")) {
                auto scopes_claim = decoded.get_payload_claim("scopes");
                // ... 解析scope，进行权限判断 ...
            }

        } catch (const jwt::token_verification_exception& e) {
            result.isvalid = false;
            result.error = std::string("token verification failed: ") + e.what();
        } catch (const std::exception& e) {
            result.isvalid = false;
            result.error = std::string("unexpected error: ") + e.what();
        }
        return result;
    }

private:
    jwt::verifier<jwt::default_clock> verifier_;
};

// 使用示例
int handle_http_request(const std::string& auth_header) {
    static tokenvalidator validator(get_public_key_from_config()， "https://auth.mycompany.com");

    auto result = validator.validate(auth_header);
    if (!result.isvalid) {
        // 返回 401 unauthorized， 并在响应头中携带 www-authenticate
        return 401;
    }

    // 令牌有效，将 result.userid 传递给下游处理
    process_user_request(result.userid);
    return 200;
}