#include "Enterprise.hpp" #include #include #include namespace molo::example::fw { namespace { std::uint32_t rotr(std::uint32_t x, int n) { return (x >> n) | (x << (32 - n)); } std::vector split(const std::string& s, char sep) { std::vector out; std::string cur; for (char c : s) { if (c == sep) { out.push_back(cur); cur.clear(); } else { cur += c; } } out.push_back(cur); return out; } std::string trim(const std::string& s) { std::size_t a = s.find_first_not_of(" \t\r\n"); if (a == std::string::npos) return ""; return s.substr(a, s.find_last_not_of(" \t\r\n") - a + 1); } } // namespace std::string sha256_hex(const std::string& data) { static const std::uint32_t k[64] = { 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2}; std::uint32_t h[8] = {0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19}; std::string msg = data; const std::uint64_t bits = static_cast(data.size()) * 8; msg += static_cast(0x80); while (msg.size() % 64 != 56) msg += '\0'; for (int i = 7; i >= 0; --i) msg += static_cast((bits >> (i * 8)) & 0xff); for (std::size_t off = 0; off < msg.size(); off += 64) { std::uint32_t w[64]; for (int i = 0; i < 16; ++i) w[i] = (static_cast(static_cast(msg[off + i * 4])) << 24) | (static_cast(static_cast(msg[off + i * 4 + 1])) << 16) | (static_cast(static_cast(msg[off + i * 4 + 2])) << 8) | static_cast(static_cast(msg[off + i * 4 + 3])); for (int i = 16; i < 64; ++i) { std::uint32_t s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ (w[i - 15] >> 3); std::uint32_t s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ (w[i - 2] >> 10); w[i] = w[i - 16] + s0 + w[i - 7] + s1; } std::uint32_t a = h[0], b = h[1], c = h[2], d = h[3], e = h[4], f = h[5], g = h[6], hh = h[7]; for (int i = 0; i < 64; ++i) { std::uint32_t s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25); std::uint32_t ch = (e & f) ^ (~e & g); std::uint32_t t1 = hh + s1 + ch + k[i] + w[i]; std::uint32_t s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22); std::uint32_t mj = (a & b) ^ (a & c) ^ (b & c); std::uint32_t t2 = s0 + mj; hh = g; g = f; f = e; e = d + t1; d = c; c = b; b = a; a = t1 + t2; } h[0] += a; h[1] += b; h[2] += c; h[3] += d; h[4] += e; h[5] += f; h[6] += g; h[7] += hh; } static const char* hex = "0123456789abcdef"; std::string out; for (std::uint32_t v : h) for (int i = 28; i >= 0; i -= 4) out += hex[(v >> i) & 0xf]; return out; } Response problem_response(int status, const std::string& title, const std::string& detail, const std::string& instance) { std::string body = "{\"type\":\"about:blank\",\"title\":\"" + json_escape(title) + "\",\"status\":" + std::to_string(status) + ",\"detail\":\"" + json_escape(detail) + "\""; if (!instance.empty()) body += ",\"instance\":\"" + json_escape(instance) + "\""; body += "}"; return Response(status, body, "application/problem+json"); } // ---- tenancy --------------------------------------------------------------- bool TenantResolver::valid_id(const std::string& id) { if (id.size() < 2 || id.size() > 32) return false; for (char c : id) if (!((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '-')) return false; return id.front() != '-' && id.back() != '-'; } TenantRef TenantResolver::resolve(const Request& req, const std::string& path_tenant) const { TenantRef ref; std::string host = req.headers.get("Host"); if (req.headers.has("X-Tenant-ID")) { ref.id = req.headers.get("X-Tenant-ID"); ref.source = "header"; } else if (!path_tenant.empty()) { ref.id = path_tenant; ref.source = "path"; } else if (std::count(host.begin(), host.end(), '.') >= 2) { ref.id = host.substr(0, host.find('.')); ref.source = "subdomain"; } else { ref.id = kDefaultTenant; ref.source = "default"; } if (!valid_id(ref.id)) ref.error = "tenant id must be 2-32 chars of a-z, 0-9, '-'"; return ref; } TenantCatalog::TenantCatalog() { tenants_["demo"] = {"demo", "Demo Inc", "free"}; tenants_["acme"] = {"acme", "Acme Corp", "pro"}; tenants_["globex"] = {"globex", "Globex", "free"}; } const Tenant* TenantCatalog::find(const std::string& id) const { auto it = tenants_.find(id); return it == tenants_.end() ? nullptr : &it->second; } std::string TenantCatalog::provision(const std::string& id, const std::string& name, const std::string& plan) { if (!TenantResolver::valid_id(id)) return "bad id"; if (tenants_.count(id)) return "exists"; if (tenants_.size() >= kMaxTenants) return "tenant cap reached"; tenants_[id] = {id, name, plan}; return ""; } std::vector TenantCatalog::list() const { std::vector out; for (const auto& [k, v] : tenants_) out.push_back(v); return out; } bool TenantData::add(const std::string& tenant, const std::string& item) { auto& rows = rows_[tenant]; if (rows.size() >= kMaxPerTenant) return false; rows.push_back(item); return true; } std::vector TenantData::list(const std::string& tenant) const { auto it = rows_.find(tenant); return it == rows_.end() ? std::vector{} : it->second; } std::size_t TenantQuota::limit_for(const std::string& plan) { return plan == "pro" ? 10 : 3; } bool TenantQuota::consume(const std::string& tenant, const std::string& plan) { auto& u = used_[tenant]; if (u >= limit_for(plan)) return false; ++u; return true; } std::size_t TenantQuota::used(const std::string& tenant) const { auto it = used_.find(tenant); return it == used_.end() ? 0 : it->second; } FeatureFlags::FeatureFlags() { defaults_ = {{"beta-ui", false}, {"export", true}, {"audit-log", true}}; } bool FeatureFlags::known(const std::string& flag) const { return defaults_.count(flag) > 0; } bool FeatureFlags::enabled(const std::string& tenant, const std::string& flag) const { auto o = overrides_.find(tenant + "/" + flag); if (o != overrides_.end()) return o->second; auto d = defaults_.find(flag); return d != defaults_.end() && d->second; } bool FeatureFlags::set(const std::string& tenant, const std::string& flag, bool on) { const std::string key = tenant + "/" + flag; if (!overrides_.count(key) && overrides_.size() >= kMaxOverrides) return false; overrides_[key] = on; return true; } std::map FeatureFlags::effective(const std::string& tenant) const { std::map out; for (const auto& [f, v] : defaults_) out[f] = enabled(tenant, f); return out; } ConfigOverlay::ConfigOverlay() { base_ = {{"theme", "light"}, {"page_size", "20"}, {"locale", "en"}}; } bool ConfigOverlay::known(const std::string& key) const { return base_.count(key) > 0; } bool ConfigOverlay::set(const std::string& tenant, const std::string& key, const std::string& value) { std::size_t total = 0; for (const auto& [t, m] : overlay_) total += m.size(); if (total >= kMaxOverrides && !overlay_[tenant].count(key)) return false; overlay_[tenant][key] = value; return true; } std::map ConfigOverlay::effective(const std::string& tenant) const { auto out = base_; auto it = overlay_.find(tenant); if (it != overlay_.end()) for (const auto& [k, v] : it->second) out[k] = v; return out; } void TenantMetrics::inc(const std::string& tenant, const std::string& name) { ++counters_[tenant][name]; } std::map> TenantMetrics::all() const { return counters_; } // ---- audit ----------------------------------------------------------------- std::string AuditChain::hash_of(const AuditRecord& r) { return sha256_hex(std::to_string(r.index) + "|" + r.actor + "|" + r.action + "|" + r.subject + "|" + r.detail + "|" + r.prev); } bool AuditChain::append(const std::string& actor, const std::string& action, const std::string& subject, const std::string& detail) { if (records_.size() >= kMaxRecords) return false; AuditRecord r; r.index = records_.size(); r.actor = actor; r.action = action; r.subject = subject; r.detail = detail; r.prev = records_.empty() ? std::string(64, '0') : records_.back().hash; r.hash = hash_of(r); records_.push_back(r); return true; } std::optional AuditChain::verify() const { std::string prev(64, '0'); for (const auto& r : records_) { if (r.prev != prev || hash_of(r) != r.hash) return r.index; prev = r.hash; } return std::nullopt; } bool AuditChain::tamper(std::size_t index) { if (index >= records_.size()) return false; records_[index].detail += " (edited)"; return true; } std::string PiiMasker::mask_email(const std::string& v) { auto at = v.find('@'); if (at == std::string::npos || at == 0) return std::string(v.size(), '*'); return v.substr(0, 1) + std::string(at - 1, '*') + v.substr(at); } std::string PiiMasker::mask_card(const std::string& v) { std::string digits; for (char c : v) if (c >= '0' && c <= '9') digits += c; if (digits.size() < 4) return std::string(digits.size(), '*'); return std::string(digits.size() - 4, '*') + digits.substr(digits.size() - 4); } std::string PiiMasker::redact(const std::string& text, std::size_t* hits) { static const std::vector> patterns = { {std::regex(R"([A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,})"), "[EMAIL]"}, {std::regex(R"(\b(?:\d[ -]?){13,16}\b)"), "[CARD]"}, {std::regex(R"(\b\d{3}-\d{2}-\d{4}\b)"), "[SSN]"}, {std::regex(R"(\b\d{1,3}(?:\.\d{1,3}){3}\b)"), "[IP]"}}; std::string out = text.substr(0, 2000); std::size_t n = 0; for (const auto& [re, tag] : patterns) { n += static_cast(std::distance( std::sregex_iterator(out.begin(), out.end(), re), std::sregex_iterator())); out = std::regex_replace(out, re, tag); } if (hits) *hits = n; return out; } RetentionStore::RetentionStore() { entries_ = {{"r1", "session", 45, false}, {"r2", "session", 3, false}, {"r3", "invoice", 400, false}, {"r4", "invoice", 3000, false}, {"r5", "log", 120, false}}; } int RetentionStore::max_age(const std::string& klass) { if (klass == "session") return 30; if (klass == "log") return 90; return 2555; // invoice: 7 years } bool RetentionStore::set_hold(const std::string& id, bool hold) { for (auto& e : entries_) if (e.id == id) { e.hold = hold; return true; } return false; } std::vector RetentionStore::expired() const { std::vector out; for (const auto& e : entries_) if (!e.hold && e.age_days > max_age(e.klass)) out.push_back(e.id); return out; } std::size_t RetentionStore::purge() { auto ids = expired(); entries_.erase(std::remove_if(entries_.begin(), entries_.end(), [&](const RetentionEntry& e) { return std::find(ids.begin(), ids.end(), e.id) != ids.end(); }), entries_.end()); return ids.size(); } SubjectStore::SubjectStore() { tables_["profiles"] = {{"ada@example.com", "name=Ada"}, {"bob@example.com", "name=Bob"}}; tables_["orders"] = {{"ada@example.com", "order=1001"}, {"ada@example.com", "order=1002"}, {"bob@example.com", "order=2001"}}; tables_["sessions"] = {{"ada@example.com", "ip=[IP]"}}; } std::map> SubjectStore::export_for( const std::string& subject) const { std::map> out; for (const auto& [t, rows] : tables_) for (const auto& [s, d] : rows) if (s == subject) out[t].push_back(d); return out; } std::size_t SubjectStore::erase(const std::string& subject) { std::size_t n = 0; for (auto& [t, rows] : tables_) { auto before = rows.size(); rows.erase(std::remove_if(rows.begin(), rows.end(), [&](const auto& r) { return r.first == subject; }), rows.end()); n += before - rows.size(); } return n; } // ---- governance ------------------------------------------------------------ std::string ApiKeyStore::issue(const std::string& owner, const std::string& tier, const std::set& scopes, std::string* id_out) { if (keys_.size() >= kMaxKeys) return ""; ++counter_; std::string secret = sha256_hex("molo-key|" + owner + "|" + std::to_string(counter_)); std::string key = "mk_" + secret.substr(0, 32); ApiKeyInfo info; info.id = "key" + std::to_string(counter_); info.owner = owner; info.tier = tier; info.scopes = scopes; info.hash = sha256_hex(key); keys_.push_back(info); if (id_out) *id_out = info.id; return key; } bool ApiKeyStore::revoke(const std::string& id) { for (auto& k : keys_) if (k.id == id) { k.revoked = true; return true; } return false; } KeyResult ApiKeyStore::authenticate(const std::string& key, const std::string& scope, const ApiKeyInfo** info) const { if (key.empty()) return KeyResult::Missing; const std::string h = sha256_hex(key); for (const auto& k : keys_) { if (k.hash != h) continue; if (info) *info = &k; if (k.revoked) return KeyResult::Revoked; if (!scope.empty() && !k.scopes.count(scope)) return KeyResult::Forbidden; return KeyResult::Ok; } return KeyResult::Unknown; } TierPolicy TierTable::find(const std::string& tier) { if (tier == "pro") return {"pro", 10}; return {"free", 3}; } bool QuotaLedger::charge(const std::string& key_id, const TierPolicy& policy) { auto& u = used_[key_id]; if (u < policy.per_min * 100) ++u; // hard cap on the counter itself return u <= policy.per_min; } std::size_t QuotaLedger::used(const std::string& key_id) const { auto it = used_.find(key_id); return it == used_.end() ? 0 : it->second; } void QuotaLedger::headers(const std::string& key_id, const TierPolicy& policy, Headers& out) const { std::size_t u = used(key_id); std::size_t remaining = u >= policy.per_min ? 0 : policy.per_min - u; out.set("X-Tier", policy.name); out.set("X-RateLimit-Limit", std::to_string(policy.per_min)); out.set("X-RateLimit-Remaining", std::to_string(remaining)); out.set("X-RateLimit-Reset", "60"); if (u > policy.per_min) out.set("Retry-After", "60"); } VersionTable::VersionTable() { versions_ = {{"v1", true, "Sat, 31 Dec 2033 23:59:59 GMT", "/v2"}, {"v2", false, "", ""}}; } const ApiVersion* VersionTable::find(const std::string& name) const { for (const auto& v : versions_) if (v.name == name) return &v; return nullptr; } void VersionTable::annotate(const std::string& name, Headers& out) const { const ApiVersion* v = find(name); if (!v) return; out.set("X-API-Version", v->name); if (!v->deprecated) return; out.set("Deprecation", "true"); if (!v->sunset.empty()) out.set("Sunset", v->sunset); if (!v->successor.empty()) out.set("Link", "<" + v->successor + "/items>; rel=\"successor-version\""); } std::vector RouteLinter::lint(const std::vector& paths) { static const std::vector verbs = {"get", "create", "delete", "update", "fetch", "remove"}; std::vector out; std::size_t n = 0; for (const auto& p : paths) { if (++n > kMaxPaths) break; if (p.size() > 1 && p.back() == '/') out.push_back({p, "no-trailing-slash"}); for (char c : p) if (c >= 'A' && c <= 'Z') { out.push_back({p, "lowercase-only"}); break; } if (p.find('_') != std::string::npos) out.push_back({p, "kebab-case"}); for (const auto& seg : split(p, '/')) if (std::find(verbs.begin(), verbs.end(), seg) != verbs.end()) { out.push_back({p, "no-verbs-in-path"}); break; } } return out; } namespace { struct Op { std::set required, optional; }; std::map parse_snapshot(const std::string& s) { std::map ops; std::size_t lines = 0; for (const auto& raw : split(s, '\n')) { std::string line = trim(raw); if (line.empty()) continue; if (++lines > SpecDiffer::kMaxLines) break; std::istringstream in(line); std::string method, path, tok; in >> method >> path; Op op; while (in >> tok) { auto eq = tok.find('='); if (eq == std::string::npos) continue; auto names = split(tok.substr(eq + 1), ','); auto& dst = tok.substr(0, eq) == "required" ? op.required : op.optional; for (auto& n : names) if (!n.empty()) dst.insert(n); } ops[method + " " + path] = op; } return ops; } } // namespace std::vector SpecDiffer::diff(const std::string& before, const std::string& after) { auto a = parse_snapshot(before); auto b = parse_snapshot(after); std::vector out; for (const auto& [name, op] : a) { auto it = b.find(name); if (it == b.end()) { out.push_back({"breaking", name, "operation removed"}); continue; } for (const auto& r : it->second.required) if (!op.required.count(r)) out.push_back({"breaking", name, "new required parameter " + r}); for (const auto& r : op.required) if (!it->second.required.count(r) && !it->second.optional.count(r)) out.push_back({"breaking", name, "parameter removed " + r}); } for (const auto& [name, op] : b) if (!a.count(name)) out.push_back({"compatible", name, "operation added"}); return out; } } // namespace molo::example::fw