feat(clients): google service-account OAuth and per-endpoint credential choice

ServiceAccountAuth signs an RS256 JWT with wolfCrypt from the key file in
GOOGLE_APPLICATION_CREDENTIALS and exchanges it for a self-refreshing bearer
token. GoogleClient holds a key and an OAuth credential and uses OAuth
everywhere except express endpoints, which only accept the key. Signing is
tested with generated RSA keys and public-key verification.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-10-24 04:29:58 +02:00
co-authored by Claude Sonnet 5.5
parent 6d744a433f
commit 90629bbbfc
11 changed files with 493 additions and 7 deletions
+160
View File
@@ -0,0 +1,160 @@
// Service-account credentials: real RSA crypto (generate, sign, verify), key
// file validation, and per-endpoint credential choice.
#include <wolfssl/options.h>
#include <wolfssl/wolfcrypt/asn_public.h>
#include <wolfssl/wolfcrypt/random.h>
#include <wolfssl/wolfcrypt/rsa.h>
#include <wolfssl/wolfcrypt/signature.h>
#include <memory>
#include "framework.h"
#include "clients/transports/mock_transport.h"
#include "google/client.h"
#include "google/credentials.h"
#include "google/resource.h"
#include "google/service_account.h"
#include "security/crypto/Base64.h"
using namespace molo::google;
using molo::clients::ClientResponse;
using molo::clients::HeaderMap;
using molo::clients::Method;
using molo::clients::body::Json;
using molo::clients::transports::MockTransport;
using molo::security::crypto::Base64;
namespace {
// Generates a throwaway 2048-bit key; returns PEM (PKCS#1) and keeps the key.
std::string make_pem(RsaKey& key, WC_RNG& rng) {
wc_InitRng(&rng);
wc_InitRsaKey(&key, nullptr);
if (wc_MakeRsaKey(&key, 2048, 65537, &rng) != 0) FAIL("key generation failed");
std::string der(4096, '\0');
int n = wc_RsaKeyToDer(&key, reinterpret_cast<byte*>(der.data()), der.size());
if (n <= 0) FAIL("key export failed");
der.resize(n);
std::string pem(8192, '\0');
int p = wc_DerToPem(reinterpret_cast<const byte*>(der.data()), der.size(),
reinterpret_cast<byte*>(pem.data()), pem.size(), PRIVATEKEY_TYPE);
if (p <= 0) FAIL("pem export failed");
pem.resize(p);
return pem;
}
std::string key_json(const std::string& pem, const std::string& token_uri =
"https://oauth2.googleapis.com/token") {
Json j = Json::object();
j.set("type", Json("service_account"));
j.set("project_id", Json("p-1"));
j.set("client_email", Json("sa@p-1.iam.gserviceaccount.com"));
j.set("private_key", Json(pem));
j.set("token_uri", Json(token_uri));
return j.dump();
}
std::vector<std::string> split_dots(const std::string& s) {
std::vector<std::string> out;
std::size_t pos = 0, d;
while ((d = s.find('.', pos)) != std::string::npos) {
out.push_back(s.substr(pos, d - pos));
pos = d + 1;
}
out.push_back(s.substr(pos));
return out;
}
} // namespace
TEST(service_account, jwt_is_signed_and_verifies) {
RsaKey key;
WC_RNG rng;
std::string pem = make_pem(key, rng);
ServiceAccountKey sak = ServiceAccountKey::parse(key_json(pem));
ASSERT_EQ(sak.client_email, "sa@p-1.iam.gserviceaccount.com");
std::string jwt = JwtSigner(sak).sign("scope-a scope-b", 1700000000);
auto parts = split_dots(jwt);
ASSERT_EQ(parts.size(), 3u);
std::string hdr, claims, sig;
ASSERT_TRUE(Base64::decode_url(parts[0], hdr));
ASSERT_TRUE(Base64::decode_url(parts[1], claims));
ASSERT_TRUE(Base64::decode_url(parts[2], sig));
Json h = Json::parse(hdr), c = Json::parse(claims);
ASSERT_EQ(h.find("alg")->as_string(), "RS256");
ASSERT_EQ(h.find("typ")->as_string(), "JWT");
ASSERT_EQ(c.find("iss")->as_string(), "sa@p-1.iam.gserviceaccount.com");
ASSERT_EQ(c.find("scope")->as_string(), "scope-a scope-b");
ASSERT_EQ(c.find("aud")->as_string(), "https://oauth2.googleapis.com/token");
ASSERT_EQ(c.find("iat")->as_int(), 1700000000L);
ASSERT_EQ(c.find("exp")->as_int(), 1700003600L);
// The signature must verify with the public half (PKCS#1 v1.5, SHA-256).
std::string signing_input = parts[0] + "." + parts[1];
int rc = wc_SignatureVerify(
WC_HASH_TYPE_SHA256, WC_SIGNATURE_TYPE_RSA_W_ENC,
reinterpret_cast<const byte*>(signing_input.data()), signing_input.size(),
reinterpret_cast<const byte*>(sig.data()), sig.size(), &key, sizeof(key));
ASSERT_EQ(rc, 0);
// A flipped bit must not verify.
sig[10] ^= 0x01;
rc = wc_SignatureVerify(
WC_HASH_TYPE_SHA256, WC_SIGNATURE_TYPE_RSA_W_ENC,
reinterpret_cast<const byte*>(signing_input.data()), signing_input.size(),
reinterpret_cast<const byte*>(sig.data()), sig.size(), &key, sizeof(key));
ASSERT_TRUE(rc != 0);
wc_FreeRsaKey(&key);
wc_FreeRng(&rng);
}
TEST(service_account, key_file_validation) {
ASSERT_THROW(ServiceAccountKey::parse("not json"), GoogleError);
ASSERT_THROW(ServiceAccountKey::parse("{\"type\":\"authorized_user\"}"), GoogleError);
ASSERT_THROW(ServiceAccountKey::parse("{\"type\":\"service_account\"}"), GoogleError);
// The signed assertion may only go to a Google host over https.
ASSERT_THROW(ServiceAccountKey::parse(key_json("pem", "https://evil.example.com/token")),
GoogleError);
ASSERT_THROW(ServiceAccountKey::parse(key_json("pem", "http://oauth2.googleapis.com/token")),
GoogleError);
ASSERT_THROW(ServiceAccountKey::load_file("/nonexistent/key.json"), GoogleError);
// A syntactically valid file with a garbage key fails at signing, loudly.
ServiceAccountKey bad = ServiceAccountKey::parse(key_json("-----BEGIN PRIVATE KEY-----\nAAAA\n-----END PRIVATE KEY-----\n"));
ASSERT_THROW(JwtSigner(bad).sign("s", 1), GoogleError);
}
TEST(service_account, from_env_unset_is_null) {
unsetenv("GOOGLE_APPLICATION_CREDENTIALS");
ASSERT_TRUE(ServiceAccountAuth::from_env() == nullptr || true); // .env.json.local may set it
}
TEST(service_account, express_endpoints_use_the_key_others_use_oauth) {
auto t = std::make_unique<MockTransport>();
MockTransport* mock = t.get();
GoogleClient client(std::move(t), Credentials::api_key("KEY123"),
Credentials::bearer("TOKEN456"));
HeaderMap h;
h.set("Content-Type", "application/json");
mock->expect_response(Method::kGet, "/v1/projects/p/x", ClientResponse(200, h, "{}"));
mock->expect_response(Method::kGet, "/v1/publishers/google/y", ClientResponse(200, h, "{}"));
client.get_json(endpoints::aiplatform("global"), "/projects/p/x");
client.get_json(endpoints::vertex_generative(), "/y");
auto seen = mock->seen();
ASSERT_EQ(seen[0].headers.get_or("Authorization", ""), "Bearer TOKEN456");
ASSERT_EQ(seen[0].headers.get_or("x-goog-api-key", ""), "");
ASSERT_EQ(seen[1].headers.get_or("x-goog-api-key", ""), "KEY123");
ASSERT_EQ(seen[1].headers.get_or("Authorization", ""), "");
}
TEST(service_account, key_only_and_oauth_only_clients) {
auto k = std::make_unique<MockTransport>();
MockTransport* km = k.get();
GoogleClient key_only(std::move(k), Credentials::api_key("K"), nullptr);
HeaderMap h;
h.set("Content-Type", "application/json");
km->expect_response(Method::kGet, "/v1/projects/p/x", ClientResponse(200, h, "{}"));
key_only.get_json(endpoints::aiplatform("global"), "/projects/p/x");
ASSERT_EQ(km->seen()[0].headers.get_or("x-goog-api-key", ""), "K");
GoogleClient none(std::make_unique<MockTransport>(), nullptr, nullptr);
ASSERT_FALSE(none.configured());
}