grpc 1.46.3 → 1.53.1

data/src/core/ext/xds/xds_http_rbac_filter.cc

@@ -18,7 +18,18 @@
 
 #include "src/core/ext/xds/xds_http_rbac_filter.h"
 
-#include "absl/strings/str_format.h"
+#include <stddef.h>
+
+#include <algorithm>
+#include <cstdint>
+#include <map>
+#include <string>
+#include <utility>
+
+#include "absl/strings/match.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/variant.h"
 #include "envoy/config/core/v3/address.upb.h"
 #include "envoy/config/rbac/v3/rbac.upb.h"
 #include "envoy/config/route/v3/route_components.upb.h"
@@ -30,20 +41,16 @@
 #include "envoy/type/matcher/v3/string.upb.h"
 #include "envoy/type/v3/range.upb.h"
 #include "google/protobuf/wrappers.upb.h"
+#include "upb/upb.h"
 
 #include "src/core/ext/filters/rbac/rbac_filter.h"
 #include "src/core/ext/filters/rbac/rbac_service_config_parser.h"
 #include "src/core/ext/xds/upb_utils.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/json/json.h"
 
 namespace grpc_core {
 
-const char* kXdsHttpRbacFilterConfigName =
-    "envoy.extensions.filters.http.rbac.v3.RBAC";
-
-const char* kXdsHttpRbacFilterConfigOverrideName =
-    "envoy.extensions.filters.http.rbac.v3.RBACPerRoute";
-
 namespace {
 
 Json ParseRegexMatcherToJson(
@@ -58,20 +65,20 @@ Json ParseInt64RangeToJson(const envoy_type_v3_Int64Range* range) {
                       {"end", envoy_type_v3_Int64Range_end(range)}};
 }
 
-absl::StatusOr<Json> ParseHeaderMatcherToJson(
-    const envoy_config_route_v3_HeaderMatcher* header) {
+Json ParseHeaderMatcherToJson(const envoy_config_route_v3_HeaderMatcher* header,
+                              ValidationErrors* errors) {
   Json::Object header_json;
-  std::vector<absl::Status> error_list;
-  std::string name =
-      UpbStringToStdString(envoy_config_route_v3_HeaderMatcher_name(header));
-  if (name == ":scheme") {
-    error_list.push_back(
-        absl::InvalidArgumentError("':scheme' not allowed in header"));
-  } else if (absl::StartsWith(name, "grpc-")) {
-    error_list.push_back(
-        absl::InvalidArgumentError("'grpc-' prefixes not allowed in header"));
+  {
+    ValidationErrors::ScopedField field(errors, ".name");
+    std::string name =
+        UpbStringToStdString(envoy_config_route_v3_HeaderMatcher_name(header));
+    if (name == ":scheme") {
+      errors->AddError("':scheme' not allowed in header");
+    } else if (absl::StartsWith(name, "grpc-")) {
+      errors->AddError("'grpc-' prefixes not allowed in header");
+    }
+    header_json.emplace("name", std::move(name));
   }
-  header_json.emplace("name", std::move(name));
   if (envoy_config_route_v3_HeaderMatcher_has_exact_match(header)) {
     header_json.emplace(
         "exactMatch",
@@ -107,21 +114,16 @@ absl::StatusOr<Json> ParseHeaderMatcherToJson(
         UpbStringToStdString(
             envoy_config_route_v3_HeaderMatcher_contains_match(header)));
   } else {
-    error_list.push_back(
-        absl::InvalidArgumentError("Invalid route header matcher specified."));
-  }
-  if (!error_list.empty()) {
-    return StatusCreate(absl::StatusCode::kInvalidArgument,
-                        "Error parsing HeaderMatcher", DEBUG_LOCATION,
-                        std::move(error_list));
+    errors->AddError("invalid route header matcher specified");
   }
   header_json.emplace("invertMatch",
                       envoy_config_route_v3_HeaderMatcher_invert_match(header));
   return header_json;
 }
 
-absl::StatusOr<Json> ParseStringMatcherToJson(
-    const envoy_type_matcher_v3_StringMatcher* matcher) {
+Json ParseStringMatcherToJson(
+    const envoy_type_matcher_v3_StringMatcher* matcher,
+    ValidationErrors* errors) {
   Json::Object json;
   if (envoy_type_matcher_v3_StringMatcher_has_exact(matcher)) {
     json.emplace("exact",
@@ -144,30 +146,23 @@ absl::StatusOr<Json> ParseStringMatcherToJson(
                  UpbStringToStdString(
                      envoy_type_matcher_v3_StringMatcher_contains(matcher)));
   } else {
-    return absl::InvalidArgumentError("StringMatcher: Invalid match pattern");
+    errors->AddError("invalid match pattern");
   }
   json.emplace("ignoreCase",
                envoy_type_matcher_v3_StringMatcher_ignore_case(matcher));
   return json;
 }
 
-absl::StatusOr<Json> ParsePathMatcherToJson(
-    const envoy_type_matcher_v3_PathMatcher* matcher) {
+Json ParsePathMatcherToJson(const envoy_type_matcher_v3_PathMatcher* matcher,
+                            ValidationErrors* errors) {
+  ValidationErrors::ScopedField field(errors, ".path");
   const auto* path = envoy_type_matcher_v3_PathMatcher_path(matcher);
   if (path == nullptr) {
-    return absl::InvalidArgumentError("PathMatcher has empty path");
-  }
-  Json::Object json;
-  auto path_json = ParseStringMatcherToJson(path);
-  if (!path_json.ok()) {
-    return path_json;
+    errors->AddError("field not present");
+    return Json();
   }
-  json.emplace("path", std::move(*path_json));
-  return json;
-}
-
-Json ParseUInt32ValueToJson(const google_protobuf_UInt32Value* value) {
-  return Json::Object{{"value", google_protobuf_UInt32Value_value(value)}};
+  Json path_json = ParseStringMatcherToJson(path, errors);
+  return Json::Object{{"path", std::move(path_json)}};
 }
 
 Json ParseCidrRangeToJson(const envoy_config_core_v3_CidrRange* range) {
@@ -177,7 +172,7 @@ Json ParseCidrRangeToJson(const envoy_config_core_v3_CidrRange* range) {
                    envoy_config_core_v3_CidrRange_address_prefix(range)));
   const auto* prefix_len = envoy_config_core_v3_CidrRange_prefix_len(range);
   if (prefix_len != nullptr) {
-    json.emplace("prefixLen", ParseUInt32ValueToJson(prefix_len));
+    json.emplace("prefixLen", google_protobuf_UInt32Value_value(prefix_len));
   }
   return json;
 }
@@ -193,66 +188,49 @@ Json ParseMetadataMatcherToJson(
   return json;
 }
 
-absl::StatusOr<Json> ParsePermissionToJson(
-    const envoy_config_rbac_v3_Permission* permission) {
+Json ParsePermissionToJson(const envoy_config_rbac_v3_Permission* permission,
+                           ValidationErrors* errors) {
   Json::Object permission_json;
   // Helper function to parse Permission::Set to JSON. Used by `and_rules` and
   // `or_rules`.
   auto parse_permission_set_to_json =
-      [](const envoy_config_rbac_v3_Permission_Set* set)
-      -> absl::StatusOr<Json> {
-    std::vector<absl::Status> error_list;
+      [errors](const envoy_config_rbac_v3_Permission_Set* set) -> Json {
     Json::Array rules_json;
     size_t size;
     const envoy_config_rbac_v3_Permission* const* rules =
         envoy_config_rbac_v3_Permission_Set_rules(set, &size);
     for (size_t i = 0; i < size; ++i) {
-      auto permission_json = ParsePermissionToJson(rules[i]);
-      if (!permission_json.ok()) {
-        error_list.push_back(permission_json.status());
-      } else {
-        rules_json.emplace_back(std::move(*permission_json));
-      }
-    }
-    if (!error_list.empty()) {
-      return StatusCreate(absl::StatusCode::kInvalidArgument,
-                          "Error parsing Set", DEBUG_LOCATION,
-                          std::move(error_list));
+      ValidationErrors::ScopedField field(errors,
+                                          absl::StrCat(".rules[", i, "]"));
+      Json permission_json = ParsePermissionToJson(rules[i], errors);
+      rules_json.emplace_back(std::move(permission_json));
     }
     return Json::Object({{"rules", std::move(rules_json)}});
   };
   if (envoy_config_rbac_v3_Permission_has_and_rules(permission)) {
+    ValidationErrors::ScopedField field(errors, ".and_permission");
     const auto* and_rules =
         envoy_config_rbac_v3_Permission_and_rules(permission);
-    auto permission_set_json = parse_permission_set_to_json(and_rules);
-    if (!permission_set_json.ok()) {
-      return permission_set_json;
-    }
-    permission_json.emplace("andRules", std::move(*permission_set_json));
+    Json permission_set_json = parse_permission_set_to_json(and_rules);
+    permission_json.emplace("andRules", std::move(permission_set_json));
   } else if (envoy_config_rbac_v3_Permission_has_or_rules(permission)) {
+    ValidationErrors::ScopedField field(errors, ".or_permission");
     const auto* or_rules = envoy_config_rbac_v3_Permission_or_rules(permission);
-    auto permission_set_json = parse_permission_set_to_json(or_rules);
-    if (!permission_set_json.ok()) {
-      return permission_set_json;
-    }
-    permission_json.emplace("orRules", std::move(*permission_set_json));
+    Json permission_set_json = parse_permission_set_to_json(or_rules);
+    permission_json.emplace("orRules", std::move(permission_set_json));
   } else if (envoy_config_rbac_v3_Permission_has_any(permission)) {
     permission_json.emplace("any",
                             envoy_config_rbac_v3_Permission_any(permission));
   } else if (envoy_config_rbac_v3_Permission_has_header(permission)) {
-    auto header_json = ParseHeaderMatcherToJson(
-        envoy_config_rbac_v3_Permission_header(permission));
-    if (!header_json.ok()) {
-      return header_json;
-    }
-    permission_json.emplace("header", std::move(*header_json));
+    ValidationErrors::ScopedField field(errors, ".header");
+    Json header_json = ParseHeaderMatcherToJson(
+        envoy_config_rbac_v3_Permission_header(permission), errors);
+    permission_json.emplace("header", std::move(header_json));
   } else if (envoy_config_rbac_v3_Permission_has_url_path(permission)) {
-    auto url_path_json = ParsePathMatcherToJson(
-        envoy_config_rbac_v3_Permission_url_path(permission));
-    if (!url_path_json.ok()) {
-      return url_path_json;
-    }
-    permission_json.emplace("urlPath", std::move(*url_path_json));
+    ValidationErrors::ScopedField field(errors, ".url_path");
+    Json url_path_json = ParsePathMatcherToJson(
+        envoy_config_rbac_v3_Permission_url_path(permission), errors);
+    permission_json.emplace("urlPath", std::move(url_path_json));
   } else if (envoy_config_rbac_v3_Permission_has_destination_ip(permission)) {
     permission_json.emplace(
         "destinationIp",
@@ -267,70 +245,53 @@ absl::StatusOr<Json> ParsePermissionToJson(
         "metadata", ParseMetadataMatcherToJson(
                         envoy_config_rbac_v3_Permission_metadata(permission)));
   } else if (envoy_config_rbac_v3_Permission_has_not_rule(permission)) {
-    auto not_rule_json = ParsePermissionToJson(
-        envoy_config_rbac_v3_Permission_not_rule(permission));
-    if (!not_rule_json.ok()) {
-      return not_rule_json;
-    }
-    permission_json.emplace("notRule", std::move(*not_rule_json));
+    ValidationErrors::ScopedField field(errors, ".not_rule");
+    Json not_rule_json = ParsePermissionToJson(
+        envoy_config_rbac_v3_Permission_not_rule(permission), errors);
+    permission_json.emplace("notRule", std::move(not_rule_json));
   } else if (envoy_config_rbac_v3_Permission_has_requested_server_name(
                  permission)) {
-    auto requested_server_name_json = ParseStringMatcherToJson(
-        envoy_config_rbac_v3_Permission_requested_server_name(permission));
-    if (!requested_server_name_json.ok()) {
-      return requested_server_name_json;
-    }
+    ValidationErrors::ScopedField field(errors, ".requested_server_name");
+    Json requested_server_name_json = ParseStringMatcherToJson(
+        envoy_config_rbac_v3_Permission_requested_server_name(permission),
+        errors);
     permission_json.emplace("requestedServerName",
-                            std::move(*requested_server_name_json));
+                            std::move(requested_server_name_json));
   } else {
-    return absl::InvalidArgumentError("Permission: Invalid rule");
+    errors->AddError("invalid rule");
   }
   return permission_json;
 }
 
-absl::StatusOr<Json> ParsePrincipalToJson(
-    const envoy_config_rbac_v3_Principal* principal) {
+Json ParsePrincipalToJson(const envoy_config_rbac_v3_Principal* principal,
+                          ValidationErrors* errors) {
   Json::Object principal_json;
   // Helper function to parse Principal::Set to JSON. Used by `and_ids` and
   // `or_ids`.
   auto parse_principal_set_to_json =
-      [](const envoy_config_rbac_v3_Principal_Set* set)
-      -> absl::StatusOr<Json> {
-    Json::Object json;
-    std::vector<absl::Status> error_list;
+      [errors](const envoy_config_rbac_v3_Principal_Set* set) -> Json {
     Json::Array ids_json;
     size_t size;
     const envoy_config_rbac_v3_Principal* const* ids =
         envoy_config_rbac_v3_Principal_Set_ids(set, &size);
     for (size_t i = 0; i < size; ++i) {
-      auto principal_json = ParsePrincipalToJson(ids[i]);
-      if (!principal_json.ok()) {
-        error_list.push_back(principal_json.status());
-      } else {
-        ids_json.emplace_back(std::move(*principal_json));
-      }
-    }
-    if (!error_list.empty()) {
-      return StatusCreate(absl::StatusCode::kInvalidArgument,
-                          "Error parsing Set", DEBUG_LOCATION,
-                          std::move(error_list));
+      ValidationErrors::ScopedField field(errors,
+                                          absl::StrCat(".ids[", i, "]"));
+      Json principal_json = ParsePrincipalToJson(ids[i], errors);
+      ids_json.emplace_back(std::move(principal_json));
     }
     return Json::Object({{"ids", std::move(ids_json)}});
   };
   if (envoy_config_rbac_v3_Principal_has_and_ids(principal)) {
+    ValidationErrors::ScopedField field(errors, ".and_ids");
     const auto* and_rules = envoy_config_rbac_v3_Principal_and_ids(principal);
-    auto principal_set_json = parse_principal_set_to_json(and_rules);
-    if (!principal_set_json.ok()) {
-      return principal_set_json;
-    }
-    principal_json.emplace("andIds", std::move(*principal_set_json));
+    Json principal_set_json = parse_principal_set_to_json(and_rules);
+    principal_json.emplace("andIds", std::move(principal_set_json));
   } else if (envoy_config_rbac_v3_Principal_has_or_ids(principal)) {
+    ValidationErrors::ScopedField field(errors, ".or_ids");
     const auto* or_rules = envoy_config_rbac_v3_Principal_or_ids(principal);
-    auto principal_set_json = parse_principal_set_to_json(or_rules);
-    if (!principal_set_json.ok()) {
-      return principal_set_json;
-    }
-    principal_json.emplace("orIds", std::move(*principal_set_json));
+    Json principal_set_json = parse_principal_set_to_json(or_rules);
+    principal_json.emplace("orIds", std::move(principal_set_json));
   } else if (envoy_config_rbac_v3_Principal_has_any(principal)) {
     principal_json.emplace("any",
                            envoy_config_rbac_v3_Principal_any(principal));
@@ -342,12 +303,12 @@ absl::StatusOr<Json> ParsePrincipalToJson(
         envoy_config_rbac_v3_Principal_Authenticated_principal_name(
             envoy_config_rbac_v3_Principal_authenticated(principal));
     if (principal_name != nullptr) {
-      auto principal_name_json = ParseStringMatcherToJson(principal_name);
-      if (!principal_name_json.ok()) {
-        return principal_name_json;
-      }
+      ValidationErrors::ScopedField field(errors,
+                                          ".authenticated.principal_name");
+      Json principal_name_json =
+          ParseStringMatcherToJson(principal_name, errors);
       authenticated_json->emplace("principalName",
-                                  std::move(*principal_name_json));
+                                  std::move(principal_name_json));
     }
   } else if (envoy_config_rbac_v3_Principal_has_source_ip(principal)) {
     principal_json.emplace(
@@ -363,87 +324,71 @@ absl::StatusOr<Json> ParsePrincipalToJson(
         "remoteIp", ParseCidrRangeToJson(
                         envoy_config_rbac_v3_Principal_remote_ip(principal)));
   } else if (envoy_config_rbac_v3_Principal_has_header(principal)) {
-    auto header_json = ParseHeaderMatcherToJson(
-        envoy_config_rbac_v3_Principal_header(principal));
-    if (!header_json.ok()) {
-      return header_json;
-    }
-    principal_json.emplace("header", std::move(*header_json));
+    ValidationErrors::ScopedField field(errors, ".header");
+    Json header_json = ParseHeaderMatcherToJson(
+        envoy_config_rbac_v3_Principal_header(principal), errors);
+    principal_json.emplace("header", std::move(header_json));
   } else if (envoy_config_rbac_v3_Principal_has_url_path(principal)) {
-    auto url_path_json = ParsePathMatcherToJson(
-        envoy_config_rbac_v3_Principal_url_path(principal));
-    if (!url_path_json.ok()) {
-      return url_path_json;
-    }
-    principal_json.emplace("urlPath", std::move(*url_path_json));
+    ValidationErrors::ScopedField field(errors, ".url_path");
+    Json url_path_json = ParsePathMatcherToJson(
+        envoy_config_rbac_v3_Principal_url_path(principal), errors);
+    principal_json.emplace("urlPath", std::move(url_path_json));
   } else if (envoy_config_rbac_v3_Principal_has_metadata(principal)) {
     principal_json.emplace(
         "metadata", ParseMetadataMatcherToJson(
                         envoy_config_rbac_v3_Principal_metadata(principal)));
   } else if (envoy_config_rbac_v3_Principal_has_not_id(principal)) {
-    auto not_id_json =
-        ParsePrincipalToJson(envoy_config_rbac_v3_Principal_not_id(principal));
-    if (!not_id_json.ok()) {
-      return not_id_json;
-    }
-    principal_json.emplace("notId", std::move(*not_id_json));
+    ValidationErrors::ScopedField field(errors, ".not_id");
+    Json not_id_json = ParsePrincipalToJson(
+        envoy_config_rbac_v3_Principal_not_id(principal), errors);
+    principal_json.emplace("notId", std::move(not_id_json));
   } else {
-    return absl::InvalidArgumentError("Principal: Invalid rule");
+    errors->AddError("invalid rule");
   }
   return principal_json;
 }
 
-absl::StatusOr<Json> ParsePolicyToJson(
-    const envoy_config_rbac_v3_Policy* policy) {
+Json ParsePolicyToJson(const envoy_config_rbac_v3_Policy* policy,
+                       ValidationErrors* errors) {
   Json::Object policy_json;
-  std::vector<absl::Status> error_list;
   size_t size;
   Json::Array permissions_json;
   const envoy_config_rbac_v3_Permission* const* permissions =
       envoy_config_rbac_v3_Policy_permissions(policy, &size);
   for (size_t i = 0; i < size; ++i) {
-    auto permission_json = ParsePermissionToJson(permissions[i]);
-    if (!permission_json.ok()) {
-      error_list.push_back(permission_json.status());
-    } else {
-      permissions_json.emplace_back(std::move(*permission_json));
-    }
+    ValidationErrors::ScopedField field(errors,
+                                        absl::StrCat(".permissions[", i, "]"));
+    Json permission_json = ParsePermissionToJson(permissions[i], errors);
+    permissions_json.emplace_back(std::move(permission_json));
   }
   policy_json.emplace("permissions", std::move(permissions_json));
   Json::Array principals_json;
   const envoy_config_rbac_v3_Principal* const* principals =
       envoy_config_rbac_v3_Policy_principals(policy, &size);
   for (size_t i = 0; i < size; ++i) {
-    auto principal_json = ParsePrincipalToJson(principals[i]);
-    if (!principal_json.ok()) {
-      error_list.push_back(principal_json.status());
-    } else {
-      principals_json.emplace_back(std::move(*principal_json));
-    }
+    ValidationErrors::ScopedField field(errors,
+                                        absl::StrCat(".principals[", i, "]"));
+    Json principal_json = ParsePrincipalToJson(principals[i], errors);
+    principals_json.emplace_back(std::move(principal_json));
   }
   policy_json.emplace("principals", std::move(principals_json));
   if (envoy_config_rbac_v3_Policy_has_condition(policy)) {
-    error_list.push_back(
-        absl::InvalidArgumentError("Policy: condition not supported"));
+    ValidationErrors::ScopedField field(errors, ".condition");
+    errors->AddError("condition not supported");
   }
   if (envoy_config_rbac_v3_Policy_has_checked_condition(policy)) {
-    error_list.push_back(
-        absl::InvalidArgumentError("Policy: checked condition not supported"));
-  }
-  if (!error_list.empty()) {
-    return StatusCreate(absl::StatusCode::kInvalidArgument,
-                        "Error parsing Policy", DEBUG_LOCATION,
-                        std::move(error_list));
+    ValidationErrors::ScopedField field(errors, ".checked_condition");
+    errors->AddError("checked condition not supported");
   }
   return policy_json;
 }
 
-absl::StatusOr<Json> ParseHttpRbacToJson(
-    const envoy_extensions_filters_http_rbac_v3_RBAC* rbac) {
+Json ParseHttpRbacToJson(const envoy_extensions_filters_http_rbac_v3_RBAC* rbac,
+                         ValidationErrors* errors) {
   Json::Object rbac_json;
-  std::vector<absl::Status> error_list;
   const auto* rules = envoy_extensions_filters_http_rbac_v3_RBAC_rules(rbac);
   if (rules != nullptr) {
+    ValidationErrors::ScopedField field(errors, ".rules");
     int action = envoy_config_rbac_v3_RBAC_action(rules);
     // Treat Log action as RBAC being absent
     if (action == envoy_config_rbac_v3_RBAC_LOG) {
@@ -459,94 +404,92 @@ absl::StatusOr<Json> ParseHttpRbacToJson(
         if (entry == nullptr) {
           break;
         }
-        auto policy = ParsePolicyToJson(
-            envoy_config_rbac_v3_RBAC_PoliciesEntry_value(entry));
-        if (!policy.ok()) {
-          error_list.push_back(StatusCreate(
-              absl::StatusCode::kInvalidArgument,
-              absl::StrFormat(
-                  "RBAC PoliciesEntry key:%s",
-                  UpbStringToStdString(
-                      envoy_config_rbac_v3_RBAC_PoliciesEntry_key(entry))),
-              DEBUG_LOCATION, {policy.status()}));
-        } else {
-          policies_object.emplace(
-              UpbStringToStdString(
-                  envoy_config_rbac_v3_RBAC_PoliciesEntry_key(entry)),
-              std::move(*policy));
-        }
+        absl::string_view key =
+            UpbStringToAbsl(envoy_config_rbac_v3_RBAC_PoliciesEntry_key(entry));
+        ValidationErrors::ScopedField field(
+            errors, absl::StrCat(".policies[", key, "]"));
+        Json policy = ParsePolicyToJson(
+            envoy_config_rbac_v3_RBAC_PoliciesEntry_value(entry), errors);
+        policies_object.emplace(std::string(key), std::move(policy));
       }
       inner_rbac_json.emplace("policies", std::move(policies_object));
     }
     rbac_json.emplace("rules", std::move(inner_rbac_json));
   }
-  if (!error_list.empty()) {
-    return StatusCreate(absl::StatusCode::kInvalidArgument,
-                        "Error parsing RBAC", DEBUG_LOCATION,
-                        std::move(error_list));
-  }
   return rbac_json;
 }
 
 }  // namespace
 
+absl::string_view XdsHttpRbacFilter::ConfigProtoName() const {
+  return "envoy.extensions.filters.http.rbac.v3.RBAC";
+}
+
+absl::string_view XdsHttpRbacFilter::OverrideConfigProtoName() const {
+  return "envoy.extensions.filters.http.rbac.v3.RBACPerRoute";
+}
+
 void XdsHttpRbacFilter::PopulateSymtab(upb_DefPool* symtab) const {
   envoy_extensions_filters_http_rbac_v3_RBAC_getmsgdef(symtab);
 }
 
-absl::StatusOr<XdsHttpFilterImpl::FilterConfig>
-XdsHttpRbacFilter::GenerateFilterConfig(upb_StringView serialized_filter_config,
-                                        upb_Arena* arena) const {
-  absl::StatusOr<Json> rbac_json;
+absl::optional<XdsHttpFilterImpl::FilterConfig>
+XdsHttpRbacFilter::GenerateFilterConfig(
+    const XdsResourceType::DecodeContext& context, XdsExtension extension,
+    ValidationErrors* errors) const {
+  absl::string_view* serialized_filter_config =
+      absl::get_if<absl::string_view>(&extension.value);
+  if (serialized_filter_config == nullptr) {
+    errors->AddError("could not parse HTTP RBAC filter config");
+    return absl::nullopt;
+  }
   auto* rbac = envoy_extensions_filters_http_rbac_v3_RBAC_parse(
-      serialized_filter_config.data, serialized_filter_config.size, arena);
+      serialized_filter_config->data(), serialized_filter_config->size(),
+      context.arena);
   if (rbac == nullptr) {
-    return absl::InvalidArgumentError(
-        "could not parse HTTP RBAC filter config");
-  }
-  rbac_json = ParseHttpRbacToJson(rbac);
-  if (!rbac_json.ok()) {
-    return rbac_json.status();
+    errors->AddError("could not parse HTTP RBAC filter config");
+    return absl::nullopt;
   }
-  return FilterConfig{kXdsHttpRbacFilterConfigName, std::move(*rbac_json)};
+  return FilterConfig{ConfigProtoName(), ParseHttpRbacToJson(rbac, errors)};
 }
 
-absl::StatusOr<XdsHttpFilterImpl::FilterConfig>
+absl::optional<XdsHttpFilterImpl::FilterConfig>
 XdsHttpRbacFilter::GenerateFilterConfigOverride(
-    upb_StringView serialized_filter_config, upb_Arena* arena) const {
+    const XdsResourceType::DecodeContext& context, XdsExtension extension,
+    ValidationErrors* errors) const {
+  absl::string_view* serialized_filter_config =
+      absl::get_if<absl::string_view>(&extension.value);
+  if (serialized_filter_config == nullptr) {
+    errors->AddError("could not parse RBACPerRoute");
+    return absl::nullopt;
+  }
   auto* rbac_per_route =
       envoy_extensions_filters_http_rbac_v3_RBACPerRoute_parse(
-          serialized_filter_config.data, serialized_filter_config.size, arena);
+          serialized_filter_config->data(), serialized_filter_config->size(),
+          context.arena);
   if (rbac_per_route == nullptr) {
-    return absl::InvalidArgumentError("could not parse RBACPerRoute");
+    errors->AddError("could not parse RBACPerRoute");
+    return absl::nullopt;
   }
-  absl::StatusOr<Json> rbac_json;
+  Json rbac_json;
   const auto* rbac =
       envoy_extensions_filters_http_rbac_v3_RBACPerRoute_rbac(rbac_per_route);
   if (rbac == nullptr) {
     rbac_json = Json::Object();
   } else {
-    rbac_json = ParseHttpRbacToJson(rbac);
-    if (!rbac_json.ok()) {
-      return rbac_json.status();
-    }
+    ValidationErrors::ScopedField field(errors, ".rbac");
+    rbac_json = ParseHttpRbacToJson(rbac, errors);
   }
-  return FilterConfig{kXdsHttpRbacFilterConfigOverrideName,
-                      std::move(*rbac_json)};
+  return FilterConfig{OverrideConfigProtoName(), std::move(rbac_json)};
 }
 
 const grpc_channel_filter* XdsHttpRbacFilter::channel_filter() const {
   return &RbacFilter::kFilterVtable;
 }
 
-grpc_channel_args* XdsHttpRbacFilter::ModifyChannelArgs(
-    grpc_channel_args* args) const {
-  grpc_arg arg_to_add = grpc_channel_arg_integer_create(
-      const_cast<char*>(GRPC_ARG_PARSE_RBAC_METHOD_CONFIG), 1);
-  grpc_channel_args* new_args =
-      grpc_channel_args_copy_and_add(args, &arg_to_add, 1);
-  grpc_channel_args_destroy(args);
-  return new_args;
+ChannelArgs XdsHttpRbacFilter::ModifyChannelArgs(
+    const ChannelArgs& args) const {
+  return args.Set(GRPC_ARG_PARSE_RBAC_METHOD_CONFIG, 1);
 }
 
 absl::StatusOr<XdsHttpFilterImpl::ServiceConfigJsonEntry>