#include "openai/admin/webhooks.h" #include #include #include #include "llm/error.h" #include "openai/admin/caps.h" #include "openai/admin/validate.h" #include "security/crypto/Base64.h" #include "security/crypto/Hmac.h" #include "security/crypto/SecureRandom.h" namespace molo::openai::admin { namespace crypto = security::crypto; namespace { constexpr std::size_t kFailureCount = 11; std::array, kFailureCount> g_failures{}; std::atomic g_accepted{0}; std::string lower(std::string s) { std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) { return std::tolower(c); }); return s; } [[noreturn]] void bad_secret(const std::string& why) { Validate::fail("webhook secret unusable: " + why); } std::string decode_secret(const std::string& secret) { if (secret.empty() || secret.size() > AdminCaps::kMaxSecretChars) bad_secret("empty or too long"); static const std::string kPrefix = "whsec_"; if (secret.rfind(kPrefix, 0) != 0) return secret; // raw key bytes, as the SDKs allow const std::string encoded = secret.substr(kPrefix.size()); std::string decoded; if (!crypto::Base64::decode(encoded, decoded)) bad_secret("not valid base64"); if (crypto::Base64::encode(decoded) != encoded) bad_secret("base64 is not canonical"); if (decoded.size() < AdminCaps::kMinSecretBytes) bad_secret("decoded key is under 24 bytes"); return decoded; } } // namespace const char* webhook_failure_name(WebhookFailure f) { switch (f) { case WebhookFailure::kNone: return "none"; case WebhookFailure::kBadSecret: return "bad_secret"; case WebhookFailure::kBodyTooLarge: return "body_too_large"; case WebhookFailure::kMissingId: return "missing_webhook_id"; case WebhookFailure::kMissingTimestamp: return "missing_webhook_timestamp"; case WebhookFailure::kMissingSignature: return "missing_webhook_signature"; case WebhookFailure::kBadTimestamp: return "bad_timestamp"; case WebhookFailure::kTooOld: return "timestamp_too_old"; case WebhookFailure::kTooNew: return "timestamp_too_new"; case WebhookFailure::kBadSignatureHeader: return "bad_signature_header"; case WebhookFailure::kMismatch: return "signature_mismatch"; } return "unknown"; } WebhookHeaders WebhookHeaders::from(const std::map& headers) { WebhookHeaders out; for (const auto& [name, value] : headers) { const std::string n = lower(name); if (n == "webhook-id") out.id = value; else if (n == "webhook-timestamp") out.timestamp = value; else if (n == "webhook-signature") out.signature = value; } return out; } void WebhookCounters::count(WebhookFailure failure) { g_failures[static_cast(failure)].fetch_add(1, std::memory_order_relaxed); } std::uint64_t WebhookCounters::value(WebhookFailure failure) { return g_failures[static_cast(failure)].load(std::memory_order_relaxed); } std::uint64_t WebhookCounters::accepted() { return g_accepted.load(std::memory_order_relaxed); } void WebhookCounters::count_accepted() { g_accepted.fetch_add(1, std::memory_order_relaxed); } std::map WebhookCounters::snapshot() { std::map out; out["accepted"] = accepted(); for (std::size_t i = 1; i < kFailureCount; ++i) out[webhook_failure_name(static_cast(i))] = value(static_cast(i)); return out; } WebhookVerifier::WebhookVerifier(const std::string& secret, std::int64_t tolerance_seconds) : key_(decode_secret(secret)), tolerance_(tolerance_seconds) { Validate::range("tolerance_seconds", tolerance_seconds, 0, AdminCaps::kMaxToleranceSeconds); } WebhookVerifier::~WebhookVerifier() { crypto::SecureRandom::zeroize(key_); } std::int64_t WebhookVerifier::system_now() { return std::chrono::duration_cast( std::chrono::system_clock::now().time_since_epoch()) .count(); } std::string WebhookVerifier::sign(const std::string& webhook_id, const std::string& timestamp, const std::string& body) const { const std::string signed_payload = webhook_id + "." + timestamp + "." + body; const auto mac = crypto::Hmac::sha256(key_, signed_payload); return "v1," + crypto::Base64::encode(mac.data(), mac.size()); } VerifyResult WebhookVerifier::verify(const std::string& body, const WebhookHeaders& h) const { return verify(body, h, system_now()); } VerifyResult WebhookVerifier::verify(const std::string& body, const WebhookHeaders& h, std::int64_t now) const { auto reject = [](WebhookFailure f, const std::string& why) { WebhookCounters::count(f); VerifyResult r; r.failure = f; r.reason = why; return r; }; if (body.size() > AdminCaps::kMaxWebhookBodyBytes) return reject(WebhookFailure::kBodyTooLarge, "body is over the byte cap"); if (h.id.empty() || h.id.size() > 256) return reject(WebhookFailure::kMissingId, "missing webhook-id header"); if (h.timestamp.empty()) return reject(WebhookFailure::kMissingTimestamp, "missing webhook-timestamp header"); if (h.signature.empty()) return reject(WebhookFailure::kMissingSignature, "missing webhook-signature header"); if (h.signature.size() > AdminCaps::kMaxWebhookHeaderChars) return reject(WebhookFailure::kBadSignatureHeader, "webhook-signature header is too long"); if (h.timestamp.size() > 12 || !std::all_of(h.timestamp.begin(), h.timestamp.end(), [](unsigned char c) { return std::isdigit(c) != 0; })) return reject(WebhookFailure::kBadTimestamp, "webhook-timestamp is not unix seconds"); const std::int64_t ts = std::stoll(h.timestamp); if (now - ts > tolerance_) return reject(WebhookFailure::kTooOld, "timestamp is outside the tolerance (old)"); if (ts - now > tolerance_) return reject(WebhookFailure::kTooNew, "timestamp is outside the tolerance (future)"); // Candidate signatures: space separated "v1," entries. std::vector candidates; std::size_t pos = 0; while (pos < h.signature.size()) { while (pos < h.signature.size() && std::isspace(static_cast(h.signature[pos]))) ++pos; std::size_t end = pos; while (end < h.signature.size() && !std::isspace(static_cast(h.signature[end]))) ++end; if (end > pos) { const std::string part = h.signature.substr(pos, end - pos); if (part.rfind("v1,", 0) == 0) candidates.push_back(part.substr(3)); } pos = end; } if (candidates.empty()) return reject(WebhookFailure::kBadSignatureHeader, "no v1 signature in webhook-signature"); if (candidates.size() > AdminCaps::kMaxWebhookSignatures) return reject(WebhookFailure::kBadSignatureHeader, "too many signatures in webhook-signature"); const std::string signed_payload = h.id + "." + h.timestamp + "." + body; const auto expected = crypto::Hmac::sha256(key_, signed_payload); bool match = false; for (const std::string& c : candidates) { std::string raw; if (!crypto::Base64::decode(c, raw) || raw.size() != expected.size()) continue; match |= crypto::SecureRandom::constant_time_equal( reinterpret_cast(raw.data()), expected.data(), expected.size()); } if (!match) return reject(WebhookFailure::kMismatch, "signature does not match"); WebhookCounters::count_accepted(); VerifyResult ok; ok.ok = true; return ok; } void WebhookVerifier::require(const std::string& body, const WebhookHeaders& h, std::int64_t now) const { const VerifyResult r = verify(body, h, now); if (!r.ok) throw llm::ApiError("openai", 401, "INVALID_SIGNATURE", r.reason); } WebhookEvent WebhookVerifier::unwrap(const std::string& body, const WebhookHeaders& h, std::int64_t now) const { require(body, h, now); return WebhookEnvelope::parse(body); } // ---- endpoint management ---- AdminService::Json WebhookEndpoints::list(std::optional limit, const std::string& after) { Query q; if (limit) { Validate::range("limit", *limit, 1, AdminCaps::kMaxPageLimit); q.set_int("limit", *limit); } if (!after.empty()) q.set("after", after); return execute(Call::kWebhookEndpointsList, {}, q); } AdminService::Json WebhookEndpoints::get(const std::string& endpoint_id) { return execute(Call::kWebhookEndpointsGet, {endpoint_id}); } AdminService::Json WebhookEndpoints::create(const WebhookEndpointSpec& spec) { Json body = spec.to_json(true); return execute(Call::kWebhookEndpointsCreate, {}, {}, &body); } AdminService::Json WebhookEndpoints::update(const std::string& endpoint_id, const WebhookEndpointSpec& spec) { Json body = spec.to_json(false); return execute(Call::kWebhookEndpointsUpdate, {endpoint_id}, {}, &body); } AdminService::Json WebhookEndpoints::destroy(const std::string& endpoint_id, bool confirm) { return execute(Call::kWebhookEndpointsDelete, {endpoint_id}, {}, nullptr, confirm); } AdminService::Json WebhookEndpoints::rotate_secret(const std::string& endpoint_id, bool keep_old_secret_for_24_hours, bool confirm) { Json body = Json::object(); body.set("keep_old_secret_active_for_24_hours", Json(keep_old_secret_for_24_hours)); return execute(Call::kWebhookEndpointsRotateSecret, {endpoint_id}, {}, &body, confirm); } AdminService::Json WebhookEndpoints::test(const std::string& endpoint_id, const std::string& event_type) { if (!WebhookEvents::is_subscribable(event_type)) Validate::fail("event type " + event_type + " cannot be tested"); Json body = Json::object(); body.set("event_type", Json(event_type)); return execute(Call::kWebhookEndpointsTest, {endpoint_id}, {}, &body); } AdminService::Json WebhookEndpoints::event_types() { return execute(Call::kWebhookEventTypesList); } } // namespace molo::openai::admin