#include "google/armor/template.h" #include "google/armor/caps.h" #include "google/errors.h" namespace molo::google::armor { using clients::body::Json; namespace { const Json* member(const Json& doc, const char* key) { return doc.is_object() ? doc.find(key) : nullptr; } std::string text_of(const Json& doc, const char* key) { const Json* v = member(doc, key); return v && v->is_string() ? v->as_string() : std::string(); } bool flag_of(const Json& doc, const char* key) { const Json* v = member(doc, key); return v && v->is_bool() && v->as_bool(); } int int_of(const Json& doc, const char* key) { const Json* v = member(doc, key); return v && v->is_number() ? static_cast(v->as_int()) : 0; } bool valid_rai_type(const std::string& t) { return t == "SEXUALLY_EXPLICIT" || t == "HATE_SPEECH" || t == "HARASSMENT" || t == "DANGEROUS"; } bool upper_name(const std::string& v) { if (v.empty() || v.size() > 64) return false; for (char c : v) if (!((c >= 'A' && c <= 'Z') || c == '_')) return false; return true; } Json enabled_json(bool on) { Json o = Json::object(); o.set("filterEnforcement", on ? "ENABLED" : "DISABLED"); return o; } bool enabled(const Json* settings) { return settings && text_of(*settings, "filterEnforcement") == "ENABLED"; } Json enforcement_json(const FloorEnforcement& e) { Json p = Json::object(); p.set("enableCloudLogging", e.cloud_logging); p.set(e.inspect_only ? "inspectOnly" : "inspectAndBlock", true); return p; } FloorEnforcement enforcement_from(const Json& p) { FloorEnforcement e; e.present = true; e.cloud_logging = flag_of(p, "enableCloudLogging"); e.inspect_only = flag_of(p, "inspectOnly"); return e; } Json rule_sets_json(const std::vector& sets) { Json arr = Json::array(); for (const auto& rs : sets) { Json set = Json::object(); Json types = Json::array(); for (const auto& t : rs.filter_types) types.push(t); set.set("filterTypes", types); Json rules = Json::array(); for (const auto& r : rs.rules) { Json ex = Json::object(); if (!r.matching_scope.empty()) ex.set("matchingScope", r.matching_scope); if (!r.regex.empty()) { Json re = Json::object(); re.set("pattern", r.regex); ex.set("regex", re); } else { Json words = Json::array(); for (const auto& w : r.words) words.push(w); Json list = Json::object(); list.set("words", words); Json dict = Json::object(); dict.set("wordList", list); ex.set("dictionary", dict); } Json rule = Json::object(); rule.set("exclusionRule", ex); rules.push(rule); } set.set("rules", rules); arr.push(set); } Json settings = Json::object(); settings.set("ruleSets", arr); return settings; } std::vector rule_sets_from(const Json& settings) { std::vector out; const Json* sets = member(settings, "ruleSets"); if (!sets || !sets->is_array()) return out; for (const Json& set : sets->as_array()) { if (out.size() >= ArmorCaps::kMaxRuleSets) break; FilterRuleSet rs; if (const Json* t = member(set, "filterTypes"); t && t->is_array()) for (const Json& x : t->as_array()) if (x.is_string()) rs.filter_types.push_back(x.as_string()); if (const Json* rules = member(set, "rules"); rules && rules->is_array()) for (const Json& rule : rules->as_array()) { const Json* ex = member(rule, "exclusionRule"); if (!ex || rs.rules.size() >= ArmorCaps::kMaxRulesPerSet) continue; ExclusionRule er; er.matching_scope = text_of(*ex, "matchingScope"); if (const Json* re = member(*ex, "regex")) er.regex = text_of(*re, "pattern"); if (const Json* dict = member(*ex, "dictionary")) if (const Json* wl = member(*dict, "wordList")) if (const Json* w = member(*wl, "words"); w && w->is_array()) for (const Json& x : w->as_array()) if (x.is_string() && er.words.size() < ArmorCaps::kMaxRuleWords) er.words.push_back(x.as_string()); rs.rules.push_back(std::move(er)); } out.push_back(std::move(rs)); } return out; } } // namespace void FilterConfig::validate() const { if (rai.size() > ArmorCaps::kMaxRaiFilters) throw GoogleError::invalid("too many rai filters"); for (const auto& f : rai) if (!valid_rai_type(f.type)) throw GoogleError::invalid("rai filter type must be SEXUALLY_EXPLICIT, " "HATE_SPEECH, HARASSMENT or DANGEROUS"); if (rule_sets.size() > ArmorCaps::kMaxRuleSets) throw GoogleError::invalid("too many rule sets"); for (const auto& rs : rule_sets) { if (rs.rules.size() > ArmorCaps::kMaxRulesPerSet) throw GoogleError::invalid("too many rules in a rule set"); for (const auto& t : rs.filter_types) if (!upper_name(t)) throw GoogleError::invalid("bad rule set filter type"); for (const auto& r : rs.rules) { if (r.words.size() > ArmorCaps::kMaxRuleWords || r.regex.size() > ArmorCaps::kMaxRegexChars) throw GoogleError::invalid("exclusion rule too large"); if (!r.matching_scope.empty() && !upper_name(r.matching_scope)) throw GoogleError::invalid("bad matching scope"); if (r.regex.empty() && r.words.empty()) throw GoogleError::invalid("exclusion rule needs words or a regex"); } } if (sdp == SdpMode::kAdvanced && sdp_inspect_template.empty()) throw GoogleError::invalid("advanced sdp needs an inspect template"); if (sdp_inspect_template.size() > 512 || sdp_deidentify_template.size() > 512) throw GoogleError::invalid("sdp template name too long"); } Json FilterConfig::to_json() const { Json o = Json::object(); if (!rai.empty()) { Json filters = Json::array(); for (const auto& f : rai) { Json item = Json::object(); item.set("filterType", f.type); if (f.confidence != Confidence::kUnspecified) item.set("confidenceLevel", confidence_name(f.confidence)); filters.push(item); } Json settings = Json::object(); settings.set("raiFilters", filters); o.set("raiSettings", settings); } if (!rule_sets.empty()) o.set("filterRuleSettings", rule_sets_json(rule_sets)); if (sdp == SdpMode::kBasic) { Json settings = Json::object(); settings.set("basicConfig", enabled_json(true)); o.set("sdpSettings", settings); } else if (sdp == SdpMode::kAdvanced) { Json adv = Json::object(); adv.set("inspectTemplate", sdp_inspect_template); if (!sdp_deidentify_template.empty()) adv.set("deidentifyTemplate", sdp_deidentify_template); Json settings = Json::object(); settings.set("advancedConfig", adv); o.set("sdpSettings", settings); } if (prompt_injection) { Json pi = enabled_json(true); if (prompt_injection_confidence != Confidence::kUnspecified) pi.set("confidenceLevel", confidence_name(prompt_injection_confidence)); o.set("piAndJailbreakFilterSettings", pi); } if (malicious_uri) o.set("maliciousUriFilterSettings", enabled_json(true)); return o; } FilterConfig FilterConfig::from_json(const Json& doc) { FilterConfig c; if (const Json* r = member(doc, "raiSettings")) if (const Json* list = member(*r, "raiFilters"); list && list->is_array()) for (const Json& f : list->as_array()) { if (c.rai.size() >= ArmorCaps::kMaxRaiFilters) break; c.rai.push_back({text_of(f, "filterType"), confidence_from(text_of(f, "confidenceLevel"))}); } if (const Json* r = member(doc, "filterRuleSettings")) c.rule_sets = rule_sets_from(*r); if (const Json* s = member(doc, "sdpSettings")) { if (const Json* adv = member(*s, "advancedConfig")) { c.sdp = SdpMode::kAdvanced; c.sdp_inspect_template = text_of(*adv, "inspectTemplate"); c.sdp_deidentify_template = text_of(*adv, "deidentifyTemplate"); } else if (const Json* basic = member(*s, "basicConfig")) { if (enabled(basic)) c.sdp = SdpMode::kBasic; } } if (const Json* pi = member(doc, "piAndJailbreakFilterSettings")) { c.prompt_injection = enabled(pi); c.prompt_injection_confidence = confidence_from(text_of(*pi, "confidenceLevel")); } c.malicious_uri = enabled(member(doc, "maliciousUriFilterSettings")); return c; } void TemplateMetadata::validate() const { if (!enforcement.empty() && enforcement != "INSPECT_ONLY" && enforcement != "INSPECT_AND_BLOCK") throw GoogleError::invalid("enforcement must be INSPECT_ONLY or INSPECT_AND_BLOCK"); if (custom_prompt_error_message.size() > 1024 || custom_response_error_message.size() > 1024) throw GoogleError::invalid("custom error message too long"); if (custom_prompt_error_code < 0 || custom_response_error_code < 0) throw GoogleError::invalid("custom error code must not be negative"); if (!filter_version_alias.empty() && !upper_name(filter_version_alias)) throw GoogleError::invalid("bad filter version alias"); if (!filter_version.empty() && !filter_version_alias.empty()) throw GoogleError::invalid("filter version and alias are mutually exclusive"); if (filter_version.size() > 32) throw GoogleError::invalid("filter version too long"); if (modalities.size() > 2) throw GoogleError::invalid("too many modalities"); for (const auto& m : modalities) if (m != "MODALITY_TEXT" && m != "MODALITY_IMAGE") throw GoogleError::invalid("modality must be MODALITY_TEXT or MODALITY_IMAGE"); } Json TemplateMetadata::to_json() const { Json o = Json::object(); if (!enforcement.empty()) o.set("enforcementType", enforcement); if (ignore_partial_failures) o.set("ignorePartialInvocationFailures", true); if (log_template_operations) o.set("logTemplateOperations", true); if (log_sanitize_operations) o.set("logSanitizeOperations", true); if (multi_language_detection) { Json m = Json::object(); m.set("enableMultiLanguageDetection", true); o.set("multiLanguageDetection", m); } if (custom_prompt_error_code) o.set("customPromptSafetyErrorCode", custom_prompt_error_code); if (!custom_prompt_error_message.empty()) o.set("customPromptSafetyErrorMessage", custom_prompt_error_message); if (custom_response_error_code) o.set("customLlmResponseSafetyErrorCode", custom_response_error_code); if (!custom_response_error_message.empty()) o.set("customLlmResponseSafetyErrorMessage", custom_response_error_message); if (!filter_version.empty() || !filter_version_alias.empty()) { Json sel = Json::object(); if (!filter_version.empty()) sel.set("version", filter_version); if (!filter_version_alias.empty()) sel.set("alias", filter_version_alias); o.set("filterVersionSelector", sel); } if (!modalities.empty()) { Json m = Json::array(); for (const auto& x : modalities) m.push(x); o.set("modalities", m); } if (data_residency_set) o.set("dataResidencyCompliant", data_residency_compliant); return o; } TemplateMetadata TemplateMetadata::from_json(const Json& doc) { TemplateMetadata m; m.enforcement = text_of(doc, "enforcementType"); if (m.enforcement == "ENFORCEMENT_TYPE_UNSPECIFIED") m.enforcement.clear(); m.ignore_partial_failures = flag_of(doc, "ignorePartialInvocationFailures"); m.log_template_operations = flag_of(doc, "logTemplateOperations"); m.log_sanitize_operations = flag_of(doc, "logSanitizeOperations"); if (const Json* ml = member(doc, "multiLanguageDetection")) m.multi_language_detection = flag_of(*ml, "enableMultiLanguageDetection"); m.custom_prompt_error_code = int_of(doc, "customPromptSafetyErrorCode"); m.custom_prompt_error_message = text_of(doc, "customPromptSafetyErrorMessage"); m.custom_response_error_code = int_of(doc, "customLlmResponseSafetyErrorCode"); m.custom_response_error_message = text_of(doc, "customLlmResponseSafetyErrorMessage"); if (const Json* sel = member(doc, "filterVersionSelector")) { m.filter_version = text_of(*sel, "version"); m.filter_version_alias = text_of(*sel, "alias"); } if (const Json* mods = member(doc, "modalities"); mods && mods->is_array()) for (const Json& x : mods->as_array()) if (x.is_string() && m.modalities.size() < 2) m.modalities.push_back(x.as_string()); if (const Json* r = member(doc, "dataResidencyCompliant"); r && r->is_bool()) { m.data_residency_set = true; m.data_residency_compliant = r->as_bool(); } return m; } void Template::validate() const { filter.validate(); metadata.validate(); if (labels.size() > ArmorCaps::kMaxLabels) throw GoogleError::invalid("too many labels"); for (const auto& [k, v] : labels) if (k.empty() || k.size() > ArmorCaps::kMaxLabelChars || v.size() > ArmorCaps::kMaxLabelChars) throw GoogleError::invalid("label key or value too long"); } Json Template::to_json() const { Json o = Json::object(); o.set("filterConfig", filter.to_json()); Json meta = metadata.to_json(); if (!meta.as_object().empty()) o.set("templateMetadata", meta); if (!labels.empty()) { Json l = Json::object(); for (const auto& [k, v] : labels) l.set(k, v); o.set("labels", l); } return o; } Template Template::from_json(const Json& doc) { Template t; t.name = text_of(doc, "name"); t.create_time = text_of(doc, "createTime"); t.update_time = text_of(doc, "updateTime"); if (const Json* f = member(doc, "filterConfig")) t.filter = FilterConfig::from_json(*f); if (const Json* m = member(doc, "templateMetadata")) t.metadata = TemplateMetadata::from_json(*m); if (const Json* l = member(doc, "labels"); l && l->is_object()) for (const auto& [k, v] : l->as_object()) if (v.is_string() && t.labels.size() < ArmorCaps::kMaxLabels) t.labels[k] = v.as_string(); return t; } void FloorSetting::validate() const { filter.validate(); for (const auto& s : integrated_services) if (s != "AI_PLATFORM" && s != "GOOGLE_MCP_SERVER") throw GoogleError::invalid( "integrated service must be AI_PLATFORM or GOOGLE_MCP_SERVER"); if (integrated_services.size() > 2) throw GoogleError::invalid("too many integrated services"); } Json FloorSetting::to_json() const { Json o = Json::object(); o.set("filterConfig", filter.to_json()); o.set("enableFloorSettingEnforcement", enforcement_enabled); if (!integrated_services.empty()) { Json s = Json::array(); for (const auto& x : integrated_services) s.push(x); o.set("integratedServices", s); } if (ai_platform.present) o.set("aiPlatformFloorSetting", enforcement_json(ai_platform)); if (mcp_server.present) o.set("googleMcpServerFloorSetting", enforcement_json(mcp_server)); if (multi_language_detection) { Json ml = Json::object(); ml.set("enableMultiLanguageDetection", true); Json meta = Json::object(); meta.set("multiLanguageDetection", ml); o.set("floorSettingMetadata", meta); } return o; } FloorSetting FloorSetting::from_json(const Json& doc) { FloorSetting f; f.name = text_of(doc, "name"); f.update_time = text_of(doc, "updateTime"); f.ai_platform = FloorEnforcement{}; if (const Json* c = member(doc, "filterConfig")) f.filter = FilterConfig::from_json(*c); f.enforcement_enabled = flag_of(doc, "enableFloorSettingEnforcement"); if (const Json* s = member(doc, "integratedServices"); s && s->is_array()) for (const Json& x : s->as_array()) if (x.is_string() && f.integrated_services.size() < 2) f.integrated_services.push_back(x.as_string()); if (const Json* p = member(doc, "aiPlatformFloorSetting")) f.ai_platform = enforcement_from(*p); if (const Json* p = member(doc, "googleMcpServerFloorSetting")) f.mcp_server = enforcement_from(*p); if (const Json* m = member(doc, "floorSettingMetadata")) if (const Json* ml = member(*m, "multiLanguageDetection")) f.multi_language_detection = flag_of(*ml, "enableMultiLanguageDetection"); return f; } } // namespace molo::google::armor