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:
@@ -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());
|
||||
}
|
||||
Reference in New Issue
Block a user