我想做的基本任务:在 gRPC 服务器中提供一个 Authenticate 服务，所有客户端最初调用(并提供用户名和密码)以获得授权 token (比如 JWT)。接下来，当客户端进行其他服务调用时，应对 token 进行验证。

这可以在 Java API 中使用 ServerInterceptor 和 ClientInterceptor 接口(interface)轻松实现。在 ServerInterceptor 中，我可以检查调用了哪个服务并决定是允许还是拒绝调用。在 ClientInterceptor 端，我可以将授权 token 作为元数据添加到每个服务调用中。

C++中有这个AuthMetadataProcessor抽象类。但不确定如何完成类似于 Java API 的任务。有没有办法在 C++ API 中做类似的事情？

最佳答案

是的。您需要子类化 AuthMetadataProcessor，覆盖其 Process 方法并向您的服务注册派生类型的实例。完成后，所有方法调用都将被 Process 拦截，并且会获得与请求一起发送的客户端元数据。

Process 的实现必须决定被拦截的方法是否需要身份验证(即，您的 Authenticate 方法不需要身份验证，但随后调用的各种方法都需要身份验证方法)。这可以通过检查 :path 元数据键来完成，如问题 #9211 中所述。 , 这是指定拦截方法的可信值。

Process 的实现必须决定 token 是否在请求中提供并且是否有效。这是一个实现细节，但通常 Process 是指由 Authenticate 生成的有效 token 的存储。这可能是您已经在 J​​ava 中设置它的方式。

不幸的是，不能在不安全的凭据之上注册 AuthMetadataProcessor，这意味着您将不得不使用 SSL，或者尝试以不同的方式拦截方法。

该框架还提供了方便的功能，允许您使用对等身份属性。 Process 可以在身份验证上下文中调用 AddProperty，提供 token 隐含的身份，然后是 SetPeerIdentityPropertyName。然后，调用的方法可以使用 GetPeerIdentity 访问信息，并避免将 token 重新映射到身份。

AuthMetadataProcessor 实现示例

struct Const
{
    static const std::string& TokenKeyName() { static std::string _("token"); return _; }
    static const std::string& PeerIdentityPropertyName() { static std::string _("username"); return _; }    
};

class MyServiceAuthProcessor : public grpc::AuthMetadataProcessor
{

public:

    grpc::Status Process(const InputMetadata& auth_metadata, grpc::AuthContext* context, OutputMetadata* consumed_auth_metadata, OutputMetadata* response_metadata) override
    {
        // determine intercepted method
        std::string dispatch_keyname = ":path";
        auto dispatch_kv = auth_metadata.find(dispatch_keyname);
        if (dispatch_kv == auth_metadata.end())
            return grpc::Status(grpc::StatusCode::INTERNAL, "Internal Error");

        // if token metadata not necessary, return early, avoid token checking
        auto dispatch_value = std::string(dispatch_kv->second.data());
        if (dispatch_value == "/MyPackage.MyService/Authenticate")
            return grpc::Status::OK;

        // determine availability of token metadata
        auto token_kv = auth_metadata.find(Const::TokenKeyName());
        if (token_kv == auth_metadata.end())
            return grpc::Status(grpc::StatusCode::UNAUTHENTICATED, "Missing Token");

        // determine validity of token metadata
        auto token_value = std::string(token_kv->second.data());
        if (tokens.count(token_value) == 0)
            return grpc::Status(grpc::StatusCode::UNAUTHENTICATED, "Invalid Token");

        // once verified, mark as consumed and store user for later retrieval
        consumed_auth_metadata->insert(std::make_pair(Const::TokenKeyName(), token_value));     // required
        context->AddProperty(Const::PeerIdentityPropertyName(), tokens[token_value]);           // optional
        context->SetPeerIdentityPropertyName(Const::PeerIdentityPropertyName());                // optional

        return grpc::Status::OK;
    }

    std::map<std::string, std::string> tokens;
};

安全服务中的 AuthMetadataProcessor 设置

class MyServiceImplSecure : public MyPackage::MyService::Service
{

public:

    MyServiceImplSecure(std::string _server_priv, std::string _server_cert, std::string _ca_cert) :
        server_priv(_server_priv), server_cert(_server_cert), ca_cert(_ca_cert) {}

    std::shared_ptr<grpc::ServerCredentials> GetServerCredentials()
    {
        grpc::SslServerCredentialsOptions::PemKeyCertPair pkcp;
        pkcp.private_key = server_priv;
        pkcp.cert_chain = server_cert;

        grpc::SslServerCredentialsOptions ssl_opts;
        ssl_opts.pem_key_cert_pairs.push_back(pkcp);
        ssl_opts.pem_root_certs = ca_cert;

        std::shared_ptr<grpc::ServerCredentials> creds = grpc::SslServerCredentials(ssl_opts);
        creds->SetAuthMetadataProcessor(auth_processor);
        return creds;
    }

    void GetContextUserMapping(::grpc::ServerContext* context, std::string& username)
    {
        username = context->auth_context()->GetPeerIdentity()[0].data();
    }

private:

    std::string server_priv;
    std::string server_cert;
    std::string ca_cert;

    std::shared_ptr<MyServiceAuthProcessor> auth_processor =
        std::shared_ptr<MyServiceAuthProcessor>(new MyServiceAuthProcessor());
};

关于c++ - 拦截服务器和客户端中的 gRPC C++ 调用，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/41051041/