Question

我想要做的基本任务：在gRPC服务器中提供Authenticate服务，所有客户端最初调用（并提供用户名和密码）以获取授权令牌（比如JWT）。接下来，当客户端进行其他服务调用时，应验证令牌。

这可以使用ServerInterceptor和ClientInterceptor接口轻松地在Java API中完成。在ServerInterceptor中，我可以检查调用哪个服务，并决定是允许还是拒绝该呼叫。在ClientInterceptor方面，我可以将授权令牌作为元数据添加到每个服务调用中。

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

Answer 1

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

Process的实现必须决定截获方法是否需要身份验证（即，Authenticate方法不需要身份验证，但后续调用的方法将需要身份验证）。这可以通过检查:path元数据密钥来完成，如问题#9211中所述，这是一个指定截获方法的可信值。

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

不幸的是，无法在不安全的凭据之上注册AuthMetadataProcessor，这意味着您必须使用SSL，否则会尝试以不同方式拦截方法。

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

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());
};

拦截服务器和客户端中的gRPC C ++调用

1 个答案: