Revision control

// Copyright (C) 2024 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
#include "clientguide.grpc.pb.h"
#include <grpcpp/security/server_credentials.h>
#include <grpcpp/server.h>
#include <grpcpp/server_builder.h>
+ #include <charconv>
#include <chrono>
#include <iostream>
+ #include <mutex>
+ #include <sstream>
#include <string_view>
using client::guide::Request;
using client::guide::Response;
static constexpr std::string_view ServerUri = "localhost:50056";
namespace {
int64_t now()
{
return std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now()
.time_since_epoch())
.count();
}
std::ostream &operator<<(std::ostream &stream, const Request &request)
{
return stream << "Request( time: " << request.time() << ", num: " << request.num() << " )";
}
+ // Validate Bearer token format and freshness
+ grpc::Status validateAuth(grpc::ServerContext *context)
+ {
+ const auto fail = [&](grpc::StatusCode code, const std::string &msg) {
+ context->AddTrailingMetadata("www-authenticate",
+ R"(Bearer realm="clientguide", error="invalid_token")");
+ return grpc::Status{ code, msg };
+ };
+
+ const auto &md = context->client_metadata();
+ const auto it = md.find("authorization");
+ if (it == md.end())
+ return grpc::Status::OK; // no auth required in this demo
+
+ std::string_view auth{ it->second.data(), it->second.size() };
+ if (auth.size() < 7 || auth.substr(0, 7) != "Bearer ")
+ return { grpc::StatusCode::UNAUTHENTICATED, "Invalid authorization format" };
+
+ auto token = auth.substr(7);
+
+ // Expected: header.payload.signature
+ const auto dot1 = token.find('.');
+ const auto dot2 = token.find('.', dot1 == token.npos ? dot1 : dot1 + 1);
+ if (dot1 == token.npos || dot2 == token.npos)
+ return fail(grpc::StatusCode::UNAUTHENTICATED, "Invalid token structure");
+
+ // payload = timestamp
+ std::string_view payload = token.substr(dot1 + 1, dot2 - dot1 - 1);
+
+ int64_t ts{ };
+ const auto [_, ec] = std::from_chars(payload.data(), payload.data() + payload.size(), ts);
+ if (ec != std::errc{ })
+ return fail(grpc::StatusCode::UNAUTHENTICATED, "Invalid token payload");
+
+ const auto age = now() - ts;
+ if (age > 500) {
+ return fail(grpc::StatusCode::UNAUTHENTICATED,
+ "Token expired with age: " + std::to_string(age) + " ms");
+ }
+
+ return grpc::Status::OK;
}
+ std::string getPrintableTraceId(const std::multimap<grpc::string_ref, grpc::string_ref> &md)
+ {
+ const auto traceIt = md.find("x-trace-id");
+ if (traceIt == md.cend())
+ return { };
+ return std::string(", Metadata: { ")
+ .append(traceIt->first.data(), traceIt->first.size())
+ .append(": ")
+ .append(traceIt->second.data(), traceIt->second.size())
+ .append(" }");
+ }
+
+ class LogLine
+ {
+ public:
+ ~LogLine()
+ {
+ std::lock_guard lock(mutex());
+ std::cout << m_buf.str() << std::endl;
+ }
+
+ template <typename T>
+ LogLine &operator<<(T &&value)
+ {
+ m_buf << std::forward<T>(value);
+ return *this;
+ }
+
+ private:
+ static std::mutex &mutex()
+ {
+ static std::mutex m;
+ return m;
+ }
+ std::ostringstream m_buf;
+ };
+
+ LogLine log() { return { }; }
+
+ } // namespace
+
class ClientGuideService : public client::guide::ClientGuideService::Service
{
- grpc::Status UnaryCall(grpc::ServerContext * /* context */, const Request *request,
+ grpc::Status UnaryCall(grpc::ServerContext *context, const Request *request,
Response *response) override
{
- std::cout << "Server (UnaryCall): " << *request << std::endl;
+ //! [auth]
+ if (auto authStatus = validateAuth(context); !authStatus.ok())
+ return authStatus;
+ //! [auth]
+
+ log() << "Server (UnaryCall): " << *request
+ << getPrintableTraceId(context->client_metadata());
+
//! [time]
const auto time = now();
if (request->time() > time)
return { grpc::StatusCode::INVALID_ARGUMENT, "Request time is in the future!" };
//! [time]
//! [response]
response->set_num(request->num());
response->set_time(time);
return grpc::Status::OK;
//! [response]
}
- grpc::Status ServerStreaming(grpc::ServerContext * /* context */, const Request *request,
+ grpc::Status ServerStreaming(grpc::ServerContext *context, const Request *request,
grpc::ServerWriter<Response> *writer) override
{
- std::cout << "Server (ServerStreaming): " << *request << std::endl;
+ if (auto authStatus = validateAuth(context); !authStatus.ok())
+ return authStatus;
+
+ log() << "Server (ServerStreaming): " << *request
+ << getPrintableTraceId(context->client_metadata());
+
if (request->time() > now())
return { grpc::StatusCode::INVALID_ARGUMENT, "Request time is in the future!" };
Response response;
for (int32_t i = 0; i < request->num(); ++i) {
response.set_num(i);
response.set_time(now());
writer->Write(response);
}
return grpc::Status::OK;
}
- grpc::Status ClientStreaming(grpc::ServerContext * /* context */,
- grpc::ServerReader<Request> *reader, Response *response) override
+ grpc::Status ClientStreaming(grpc::ServerContext *context, grpc::ServerReader<Request> *reader,
+ Response *response) override
{
+ if (auto authStatus = validateAuth(context); !authStatus.ok())
+ return authStatus;
+
+ log() << "Server (ClientStreaming) accepted call"
+ << getPrintableTraceId(context->client_metadata());
+
Request request;
int32_t count = 0;
while (reader->Read(&request)) {
- std::cout << "Server (ClientStreaming): " << request << std::endl;
+ log() << "Server (ClientStreaming): " << request;
if (request.time() > now())
return { grpc::StatusCode::INVALID_ARGUMENT, "Request time is in the future!" };
++count;
}
response->set_num(count);
response->set_time(now());
return grpc::Status::OK;
}
grpc::Status
- BidirectionalStreaming(grpc::ServerContext * /* context */,
+ BidirectionalStreaming(grpc::ServerContext *context,
grpc::ServerReaderWriter<Response, Request> *stream) override
{
+ if (auto authStatus = validateAuth(context); !authStatus.ok())
+ return authStatus;
+
+ log() << "Server (BidirectionalStreaming) accepted call"
+ << getPrintableTraceId(context->client_metadata());
+
Request request;
Response response;
while (stream->Read(&request)) {
- std::cout << "Server (BidirectionalStreaming): " << request << std::endl;
+ log() << "Server (BidirectionalStreaming): " << request;
const auto time = now();
if (request.time() > time)
return { grpc::StatusCode::INVALID_ARGUMENT, "Request time is in the future!" };
response.set_num(request.num());
response.set_time(time);
if (!stream->Write(response))
return grpc::Status::CANCELLED;
}
return grpc::Status::OK;
}
};
int main(int /* argc */, char * /* argv */[])
{
std::unique_ptr<grpc::Server> server;
ClientGuideService service;
{
grpc::ServerBuilder builder;
builder.AddListeningPort(ServerUri.data(), grpc::InsecureServerCredentials());
builder.RegisterService(&service);
server = builder.BuildAndStart();
}
std::cout << "Server listening on: " << ServerUri.data() << std::endl;
server->Wait();
}