From e1c63fa0b7a57b9becc1b172eb5f143d8706f931 Mon Sep 17 00:00:00 2001 From: Muhammad Askri Date: Mon, 16 Nov 2026 17:06:47 -0800 Subject: [PATCH] Declarative CEL C++ environments configured via `cel::Env` and `cel::EnvRuntime` could not load the `network` extension by name (`cel.lib.ext.network` / `network`). Register `NetworkCompilerLibrary(version)` and `RegisterNetworkFunctions(builder, version)` across `0..kNetworkExtensionLatestVersion` in `RegisterStandardExtensions` for both `cel::Env` and `cel::EnvRuntime`, and enable `enable_qualified_type_identifiers` when `network` is configured in `EnvRuntime`. PiperOrigin-RevId: 1023242061 --- env/BUILD | 4 + env/env_runtime.cc | 4 +- env/env_runtime_test.cc | 16 + env/env_std_extensions.cc | 7 + env/env_std_extensions_test.cc | 9 + env/runtime_std_extensions.cc | 13 + env/runtime_std_extensions_test.cc | 17 + extensions/BUILD | 125 ++++++ extensions/network_ext.cc | 375 ++++++++++++++++ extensions/network_ext.h | 51 +++ extensions/network_ext_decls.cc | 197 +++++++++ extensions/network_ext_decls.h | 89 ++++ extensions/network_ext_decls_test.cc | 188 ++++++++ extensions/network_ext_test.cc | 623 +++++++++++++++++++++++++++ internal/BUILD | 29 ++ internal/network_addr.cc | 467 ++++++++++++++++++++ internal/network_addr.h | 102 +++++ internal/network_addr_test.cc | 285 ++++++++++++ 18 files changed, 2600 insertions(+), 1 deletion(-) create mode 100644 extensions/network_ext.cc create mode 100644 extensions/network_ext.h create mode 100644 extensions/network_ext_decls.cc create mode 100644 extensions/network_ext_decls.h create mode 100644 extensions/network_ext_decls_test.cc create mode 100644 extensions/network_ext_test.cc create mode 100644 internal/network_addr.cc create mode 100644 internal/network_addr.h create mode 100644 internal/network_addr_test.cc diff --git a/env/BUILD b/env/BUILD index fd39f9997..c866101b6 100644 --- a/env/BUILD +++ b/env/BUILD @@ -105,6 +105,7 @@ cc_library( "//extensions:encoders", "//extensions:lists_functions", "//extensions:math_ext_decls", + "//extensions:network_ext_decls", "//extensions:proto_ext", "//extensions:regex_ext", "//extensions:sets_functions", @@ -154,6 +155,8 @@ cc_library( "//extensions:lists_functions", "//extensions:math_ext", "//extensions:math_ext_decls", + "//extensions:network_ext", + "//extensions:network_ext_decls", "//extensions:regex_ext", "//extensions:sets_functions", "//extensions:strings", @@ -308,6 +311,7 @@ cc_test( "//compiler", "//extensions:lists_functions", "//extensions:math_ext_decls", + "//extensions:network_ext_decls", "//extensions:strings", "//internal:testing", "//internal:testing_descriptor_pool", diff --git a/env/env_runtime.cc b/env/env_runtime.cc index 0f58d80b9..de96620b6 100644 --- a/env/env_runtime.cc +++ b/env/env_runtime.cc @@ -55,7 +55,9 @@ absl::StatusOr EnvRuntime::CreateRuntimeBuilder( if (extension_config.name == "optional") { optional_extension_config = &extension_config; runtime_options.enable_qualified_type_identifiers = true; - break; + } else if (extension_config.name == "network" || + extension_config.name == "cel.lib.ext.network") { + runtime_options.enable_qualified_type_identifiers = true; } } diff --git a/env/env_runtime_test.cc b/env/env_runtime_test.cc index 47892772c..fc0d6275c 100644 --- a/env/env_runtime_test.cc +++ b/env/env_runtime_test.cc @@ -153,6 +153,22 @@ std::vector GetEnvRuntimeTestCases() { "1 + 2 == 3", .expected_to_fail = true, }, + TestCase{ + .config_yaml = R"yaml( + extensions: + - name: "network" + )yaml", + .expr = "type(ip('192.168.0.1')) == net.IP && " + "cidr('10.0.0.0/8').containsIP('10.0.0.1')", + }, + TestCase{ + .config_yaml = R"yaml( + extensions: + - name: "cel.lib.ext.network" + version: 1 + )yaml", + .expr = "cidr('192.168.0.1/24').masked() == cidr('192.168.0.0/24')", + }, }; } diff --git a/env/env_std_extensions.cc b/env/env_std_extensions.cc index f2041b979..c5b793133 100644 --- a/env/env_std_extensions.cc +++ b/env/env_std_extensions.cc @@ -22,6 +22,7 @@ #include "extensions/encoders.h" #include "extensions/lists_functions.h" #include "extensions/math_ext_decls.h" +#include "extensions/network_ext_decls.h" #include "extensions/proto_ext.h" #include "extensions/regex_ext.h" #include "extensions/sets_functions.h" @@ -71,6 +72,12 @@ void RegisterStandardExtensions(Env& env) { env.RegisterCompilerLibrary("cel.lib.ext.regex", "regex", 0, []() { return extensions::RegexExtCompilerLibrary(); }); + for (int version = 0; version <= extensions::kNetworkExtensionLatestVersion; + ++version) { + env.RegisterCompilerLibrary( + "cel.lib.ext.network", "network", version, + [version]() { return extensions::NetworkCompilerLibrary(version); }); + } } } // namespace cel diff --git a/env/env_std_extensions_test.cc b/env/env_std_extensions_test.cc index 6edd9b21d..9860f4a2f 100644 --- a/env/env_std_extensions_test.cc +++ b/env/env_std_extensions_test.cc @@ -114,6 +114,15 @@ INSTANTIATE_TEST_SUITE_P( TestCase{ .extension = "regex", .expr = "regex.replace('abc', '$', '_end')", + }, + TestCase{ + .extension = "cel.lib.ext.network", + .expr = "type(ip('192.168.0.1')) == net.IP && " + "cidr('10.0.0.0/8').containsIP('10.0.0.1')", + }, + TestCase{ + .extension = "network", + .expr = "cidr('192.168.0.1/24').masked() == cidr('192.168.0.0/24')", })); } // namespace diff --git a/env/runtime_std_extensions.cc b/env/runtime_std_extensions.cc index b866a5965..24505a089 100644 --- a/env/runtime_std_extensions.cc +++ b/env/runtime_std_extensions.cc @@ -23,6 +23,8 @@ #include "extensions/lists_functions.h" #include "extensions/math_ext.h" #include "extensions/math_ext_decls.h" +#include "extensions/network_ext.h" +#include "extensions/network_ext_decls.h" #include "extensions/regex_ext.h" #include "extensions/sets_functions.h" #include "extensions/strings.h" @@ -128,6 +130,17 @@ void RegisterStandardExtensions(EnvRuntime& env_runtime) { return cel::extensions::RegisterRegexExtensionFunctions( runtime_builder); }); + + for (int version = 0; version <= extensions::kNetworkExtensionLatestVersion; + ++version) { + registry.AddFunctionRegistration( + "cel.lib.ext.network", "network", version, + [version](RuntimeBuilder& runtime_builder, + const RuntimeOptions& runtime_options) -> absl::Status { + return cel::extensions::RegisterNetworkFunctions(runtime_builder, + version); + }); + } } } // namespace cel diff --git a/env/runtime_std_extensions_test.cc b/env/runtime_std_extensions_test.cc index 4c7cb9829..49d6f586b 100644 --- a/env/runtime_std_extensions_test.cc +++ b/env/runtime_std_extensions_test.cc @@ -33,6 +33,7 @@ #include "env/env_std_extensions.h" #include "extensions/lists_functions.h" #include "extensions/math_ext_decls.h" +#include "extensions/network_ext_decls.h" #include "extensions/strings.h" #include "internal/testing.h" #include "internal/testing_descriptor_pool.h" @@ -219,6 +220,22 @@ std::vector GetRuntimeStdExtensionTestCases() { .expr = "regex.replace('abc', '$', '_end') == 'abc_end'", .requires_optional_extension = true, }, + TestCase{ + .extension_name = "cel.lib.ext.network", + .extension_versions = {0, 1}, + .latest_extension_version = + extensions::kNetworkExtensionLatestVersion, + .expr = "type(ip('192.168.0.1')) == net.IP && " + "ip.isCanonical('192.168.0.1') && " + "cidr('10.0.0.0/8').containsIP('10.0.0.1')", + }, + TestCase{ + .extension_name = "network", + .extension_versions = {0, 1}, + .latest_extension_version = + extensions::kNetworkExtensionLatestVersion, + .expr = "cidr('192.168.0.1/24').masked() == cidr('192.168.0.0/24')", + }, }; } diff --git a/extensions/BUILD b/extensions/BUILD index d9f8d7684..15c38c7e0 100644 --- a/extensions/BUILD +++ b/extensions/BUILD @@ -961,3 +961,128 @@ cc_test( "@com_google_protobuf//:protobuf", ], ) + +cc_library( + name = "network_ext_decls", + srcs = ["network_ext_decls.cc"], + hdrs = ["network_ext_decls.h"], + deps = [ + "//checker:type_checker_builder", + "//checker/internal:builtins_arena", + "//common:constant", + "//common:decl", + "//common:expr", + "//common:navigable_ast", + "//common:standard_definitions", + "//common:type", + "//compiler", + "//internal:network_addr", + "//internal:status_macros", + "//validator", + "@com_google_absl//absl/base:no_destructor", + "@com_google_absl//absl/status", + "@com_google_absl//absl/strings", + "@com_google_absl//absl/strings:string_view", + "@com_google_absl//absl/types:span", + ], +) + +cc_test( + name = "network_ext_decls_test", + srcs = ["network_ext_decls_test.cc"], + deps = [ + ":network_ext_decls", + "//checker:standard_library", + "//checker:validation_result", + "//common:ast", + "//common:decl", + "//common:source", + "//common:type", + "//compiler", + "//compiler:compiler_factory", + "//internal:status_macros", + "//internal:testing", + "//internal:testing_descriptor_pool", + "//validator", + "@com_google_absl//absl/status:status_matchers", + "@com_google_absl//absl/status:statusor", + "@com_google_absl//absl/strings:string_view", + ], +) + +cc_library( + name = "network_ext", + srcs = ["network_ext.cc"], + hdrs = ["network_ext.h"], + deps = [ + ":network_ext_decls", + "//common:native_type", + "//common:standard_definitions", + "//common:type", + "//common:typeinfo", + "//common:value", + "//eval/public:cel_function_registry", + "//eval/public:cel_options", + "//internal:casts", + "//internal:network_addr", + "//internal:status_macros", + "//runtime", + "//runtime:function", + "//runtime:function_adapter", + "//runtime:function_registry", + "//runtime:runtime_builder", + "//runtime:runtime_options", + "//runtime:type_registry", + "//runtime/internal:errors", + "//runtime/internal:runtime_friend_access", + "//runtime/internal:runtime_impl", + "@com_google_absl//absl/base:nullability", + "@com_google_absl//absl/status", + "@com_google_absl//absl/strings:string_view", + "@com_google_protobuf//:protobuf", + ], +) + +cc_test( + name = "network_ext_test", + srcs = ["network_ext_test.cc"], + deps = [ + ":network_ext", + "//checker:standard_library", + "//checker:validation_result", + "//common:ast", + "//common:decl", + "//common:kind", + "//common:type", + "//common:value", + "//common:value_testing", + "//compiler", + "//compiler:compiler_factory", + "//compiler:optional", + "//eval/public:activation", + "//eval/public:cel_expr_builder_factory", + "//eval/public:cel_expression", + "//eval/public:cel_function_registry", + "//eval/public:cel_options", + "//eval/public:cel_value", + "//extensions/protobuf:runtime_adapter", + "//internal:status_macros", + "//internal:testing", + "//internal:testing_descriptor_pool", + "//parser", + "//runtime", + "//runtime:activation", + "//runtime:constant_folding", + "//runtime:optional_types", + "//runtime:reference_resolver", + "//runtime:runtime_options", + "//runtime:standard_runtime_builder_factory", + "@com_google_absl//absl/status", + "@com_google_absl//absl/status:status_matchers", + "@com_google_absl//absl/status:statusor", + "@com_google_absl//absl/strings:cord_test_helpers", + "@com_google_absl//absl/strings:string_view", + "@com_google_cel_spec//proto/cel/expr:syntax_cc_proto", + "@com_google_protobuf//:protobuf", + ], +) diff --git a/extensions/network_ext.cc b/extensions/network_ext.cc new file mode 100644 index 000000000..650d08443 --- /dev/null +++ b/extensions/network_ext.cc @@ -0,0 +1,375 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "extensions/network_ext.h" + +#include + +#include "absl/base/nullability.h" +#include "absl/status/status.h" +#include "absl/strings/string_view.h" +#include "common/native_type.h" +#include "common/standard_definitions.h" +#include "common/type.h" +#include "common/typeinfo.h" +#include "common/value.h" +#include "eval/public/cel_function_registry.h" +#include "eval/public/cel_options.h" +#include "extensions/network_ext_decls.h" +#include "internal/casts.h" +#include "internal/network_addr.h" +#include "internal/status_macros.h" +#include "runtime/function.h" +#include "runtime/function_adapter.h" +#include "runtime/function_registry.h" +#include "runtime/internal/errors.h" +#include "runtime/internal/runtime_friend_access.h" +#include "runtime/internal/runtime_impl.h" +#include "runtime/runtime.h" +#include "runtime/runtime_builder.h" +#include "runtime/runtime_options.h" +#include "runtime/type_registry.h" +#include "google/protobuf/arena.h" +#include "google/protobuf/descriptor.h" +#include "google/protobuf/message.h" + +namespace cel::extensions { +namespace { + +struct IpOpaqueTraits { + using Rep = internal::IpAddr; + static absl::string_view TypeName() { return "net.IP"; } + static OpaqueType RuntimeType() { return NetIpType(); } +}; + +struct CidrOpaqueTraits { + using Rep = internal::CidrPrefix; + static absl::string_view TypeName() { return "net.CIDR"; } + static OpaqueType RuntimeType() { return NetCidrType(); } +}; + +template +class NetworkOpaqueValue final : public OpaqueValueInterface { + public: + using Rep = typename Traits::Rep; + + explicit NetworkOpaqueValue(const Rep& rep) : rep_(rep) {} + + static const Rep* absl_nullable Unwrap(const OpaqueValue& val) { + if (val.GetTypeId() != cel::TypeId>() || + val.interface() == nullptr) { + return nullptr; + } + const auto* self = + static_cast*>(val.interface()); + return &self->rep_; + } + + static Value Make(const Rep& rep, google::protobuf::Arena* absl_nonnull arena) { + return OpaqueValue( + google::protobuf::Arena::Create>(arena, rep), arena); + } + + private: + std::string DebugString() const override { return rep_.ToCanonicalString(); } + + absl::string_view GetTypeName() const override { return Traits::TypeName(); } + + OpaqueType GetRuntimeType() const override { return Traits::RuntimeType(); } + + absl::Status Equal(const OpaqueValue& other, + const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool, + google::protobuf::MessageFactory* absl_nonnull message_factory, + google::protobuf::Arena* absl_nonnull arena, + Value* absl_nonnull result) const override { + const Rep* other_rep = Unwrap(other); + *result = BoolValue(other_rep != nullptr && rep_ == *other_rep); + return absl::OkStatus(); + } + + OpaqueValue Clone(google::protobuf::Arena* absl_nonnull arena) const override { + return OpaqueValue( + google::protobuf::Arena::Create>(arena, rep_), arena); + } + + NativeTypeId GetNativeTypeId() const override { + return cel::TypeId>(); + } + + Rep rep_; +}; + +using IpOpaqueValue = NetworkOpaqueValue; +using CidrOpaqueValue = NetworkOpaqueValue; + +Value NoMatchingOverload(absl::string_view fn, + google::protobuf::Arena* absl_nonnull arena) { + return ErrorValue::From(runtime_internal::CreateNoMatchingOverloadError(fn), + arena); +} + +template +absl::Status RegisterOpaqueUnaryMember(FunctionRegistry& registry, + absl::string_view fn_name, Fn fn) { + return UnaryFunctionAdapter:: + RegisterMemberOverload( + fn_name, + [fn_name, fn](const OpaqueValue& val, + const Function::InvokeContext& context) -> Value { + const auto* rep = NetworkOpaqueValue::Unwrap(val); + if (rep == nullptr) { + return NoMatchingOverload(fn_name, context.arena()); + } + return fn(*rep, context.arena()); + }, + registry); +} + +Value IpFromString(const StringValue& raw, + const Function::InvokeContext& context) { + std::string scratch; + absl::string_view raw_view = raw.ToStringView(&scratch); + CEL_ASSIGN_OR_RETURN(internal::IpAddr ip, internal::ParseIp(raw_view), + _.With(ErrorValueReturn(context.arena()))); + return IpOpaqueValue::Make(ip, context.arena()); +} + +Value CidrFromString(const StringValue& raw, + const Function::InvokeContext& context) { + std::string scratch; + absl::string_view raw_view = raw.ToStringView(&scratch); + CEL_ASSIGN_OR_RETURN(internal::CidrPrefix cidr, internal::ParseCidr(raw_view), + _.With(ErrorValueReturn(context.arena()))); + return CidrOpaqueValue::Make(cidr, context.arena()); +} + +Value StringFromOpaque(const OpaqueValue& val, + const Function::InvokeContext& context) { + if (const internal::IpAddr* ip = IpOpaqueValue::Unwrap(val); ip != nullptr) { + return StringValue::From(ip->ToCanonicalString(), context.arena()); + } + if (const internal::CidrPrefix* cidr = CidrOpaqueValue::Unwrap(val); + cidr != nullptr) { + return StringValue::From(cidr->ToCanonicalString(), context.arena()); + } + return NoMatchingOverload(StandardFunctions::kString, context.arena()); +} + +Value CidrContainsIp(const OpaqueValue& cidr_val, const OpaqueValue& ip_val, + const Function::InvokeContext& context) { + const internal::CidrPrefix* cidr = CidrOpaqueValue::Unwrap(cidr_val); + const internal::IpAddr* ip = IpOpaqueValue::Unwrap(ip_val); + if (cidr == nullptr || ip == nullptr) { + return NoMatchingOverload("containsIP", context.arena()); + } + return BoolValue(cidr->ContainsIp(*ip)); +} + +Value CidrContainsIpString(const OpaqueValue& cidr_val, + const StringValue& ip_str, + const Function::InvokeContext& context) { + const internal::CidrPrefix* cidr = CidrOpaqueValue::Unwrap(cidr_val); + if (cidr == nullptr) { + return NoMatchingOverload("containsIP", context.arena()); + } + std::string scratch; + absl::string_view raw_view = ip_str.ToStringView(&scratch); + CEL_ASSIGN_OR_RETURN(internal::IpAddr ip, internal::ParseIp(raw_view), + _.With(ErrorValueReturn(context.arena()))); + return BoolValue(cidr->ContainsIp(ip)); +} + +Value CidrContainsCidr(const OpaqueValue& parent_val, + const OpaqueValue& child_val, + const Function::InvokeContext& context) { + const internal::CidrPrefix* parent = CidrOpaqueValue::Unwrap(parent_val); + const internal::CidrPrefix* child = CidrOpaqueValue::Unwrap(child_val); + if (parent == nullptr || child == nullptr) { + return NoMatchingOverload("containsCIDR", context.arena()); + } + return BoolValue(parent->ContainsCidr(*child)); +} + +Value CidrContainsCidrString(const OpaqueValue& parent_val, + const StringValue& child_str, + const Function::InvokeContext& context) { + const internal::CidrPrefix* parent = CidrOpaqueValue::Unwrap(parent_val); + if (parent == nullptr) { + return NoMatchingOverload("containsCIDR", context.arena()); + } + std::string scratch; + absl::string_view raw_view = child_str.ToStringView(&scratch); + CEL_ASSIGN_OR_RETURN(internal::CidrPrefix child, + internal::ParseCidr(raw_view), + _.With(ErrorValueReturn(context.arena()))); + return BoolValue(parent->ContainsCidr(child)); +} + +bool IsIpString(const StringValue& raw) { + std::string scratch; + return internal::ParseIp(raw.ToStringView(&scratch)).ok(); +} + +bool IsCidrString(const StringValue& raw) { + std::string scratch; + return internal::ParseCidr(raw.ToStringView(&scratch)).ok(); +} + +Value IpIsCanonicalString(const StringValue& raw, + const Function::InvokeContext& context) { + std::string scratch; + absl::string_view raw_view = raw.ToStringView(&scratch); + CEL_ASSIGN_OR_RETURN(internal::IpAddr ip, internal::ParseIp(raw_view), + _.With(ErrorValueReturn(context.arena()))); + return BoolValue(ip.ToCanonicalString() == raw_view); +} + +absl::Status RegisterStringNetworkFunctions(FunctionRegistry& registry) { + CEL_RETURN_IF_ERROR( + (UnaryFunctionAdapter::RegisterGlobalOverload( + "isIP", &IsIpString, registry))); + CEL_RETURN_IF_ERROR( + (UnaryFunctionAdapter::RegisterGlobalOverload( + "isCIDR", &IsCidrString, registry))); + CEL_RETURN_IF_ERROR( + (UnaryFunctionAdapter::RegisterGlobalOverload( + "ip.isCanonical", &IpIsCanonicalString, registry))); + return absl::OkStatus(); +} + +} // namespace + +absl::Status RegisterNetworkFunctions(RuntimeBuilder& builder, int version) { + (void)version; + Runtime& base_runtime = + runtime_internal::RuntimeFriendAccess::GetMutableRuntime(builder); + if (runtime_internal::RuntimeFriendAccess::RuntimeTypeId(base_runtime) != + cel::TypeId()) { + return absl::UnimplementedError( + "network_ext is only supported on the default cel::Runtime " + "implementation"); + } + auto& runtime = + cel::internal::down_cast(base_runtime); + const RuntimeOptions& options = runtime.expr_builder().options(); + if (!options.enable_qualified_type_identifiers) { + return absl::FailedPreconditionError( + "network_ext requires " + "RuntimeOptions.enable_qualified_type_identifiers"); + } + // NOLINTNEXTLINE(clang-diagnostic-deprecated-declarations) + if (!options.enable_heterogeneous_equality) { + return absl::FailedPreconditionError( + "network_ext requires RuntimeOptions.enable_heterogeneous_equality"); + } + + CEL_RETURN_IF_ERROR(builder.type_registry().RegisterType(NetIpType())); + CEL_RETURN_IF_ERROR(builder.type_registry().RegisterType(NetCidrType())); + + FunctionRegistry& registry = builder.function_registry(); + CEL_RETURN_IF_ERROR(RegisterStringNetworkFunctions(registry)); + + CEL_RETURN_IF_ERROR( + (UnaryFunctionAdapter::RegisterGlobalOverload( + "ip", &IpFromString, registry))); + CEL_RETURN_IF_ERROR( + (UnaryFunctionAdapter::RegisterGlobalOverload( + "cidr", &CidrFromString, registry))); + if (options.enable_string_conversion) { + CEL_RETURN_IF_ERROR(( + UnaryFunctionAdapter::RegisterGlobalOverload( + StandardFunctions::kString, &StringFromOpaque, registry))); + } + + CEL_RETURN_IF_ERROR(RegisterOpaqueUnaryMember( + registry, "ip", + [](const internal::CidrPrefix& cidr, google::protobuf::Arena* absl_nonnull arena) { + return IpOpaqueValue::Make(cidr.ip, arena); + })); + CEL_RETURN_IF_ERROR(RegisterOpaqueUnaryMember( + registry, "masked", + [](const internal::CidrPrefix& cidr, google::protobuf::Arena* absl_nonnull arena) { + return CidrOpaqueValue::Make(cidr.Masked(), arena); + })); + CEL_RETURN_IF_ERROR(RegisterOpaqueUnaryMember( + registry, "isMask", + [](const internal::CidrPrefix& cidr, google::protobuf::Arena* absl_nonnull) { + return BoolValue(cidr.IsMask()); + })); + CEL_RETURN_IF_ERROR(RegisterOpaqueUnaryMember( + registry, "prefixLength", + [](const internal::CidrPrefix& cidr, google::protobuf::Arena* absl_nonnull) { + return IntValue(cidr.prefix_length); + })); + + CEL_RETURN_IF_ERROR( + (BinaryFunctionAdapter:: + RegisterMemberOverload("containsIP", &CidrContainsIp, registry))); + CEL_RETURN_IF_ERROR( + (BinaryFunctionAdapter:: + RegisterMemberOverload("containsIP", &CidrContainsIpString, + registry))); + CEL_RETURN_IF_ERROR(( + BinaryFunctionAdapter:: + RegisterMemberOverload("containsCIDR", &CidrContainsCidr, registry))); + CEL_RETURN_IF_ERROR( + (BinaryFunctionAdapter:: + RegisterMemberOverload("containsCIDR", &CidrContainsCidrString, + registry))); + + CEL_RETURN_IF_ERROR(RegisterOpaqueUnaryMember( + registry, "family", + [](const internal::IpAddr& ip, google::protobuf::Arena* absl_nonnull) { + return IntValue(ip.Family()); + })); + CEL_RETURN_IF_ERROR(RegisterOpaqueUnaryMember( + registry, "isUnspecified", + [](const internal::IpAddr& ip, google::protobuf::Arena* absl_nonnull) { + return BoolValue(ip.IsUnspecified()); + })); + CEL_RETURN_IF_ERROR(RegisterOpaqueUnaryMember( + registry, "isLoopback", + [](const internal::IpAddr& ip, google::protobuf::Arena* absl_nonnull) { + return BoolValue(ip.IsLoopback()); + })); + CEL_RETURN_IF_ERROR(RegisterOpaqueUnaryMember( + registry, "isGlobalUnicast", + [](const internal::IpAddr& ip, google::protobuf::Arena* absl_nonnull) { + return BoolValue(ip.IsGlobalUnicast()); + })); + CEL_RETURN_IF_ERROR(RegisterOpaqueUnaryMember( + registry, "isLinkLocalMulticast", + [](const internal::IpAddr& ip, google::protobuf::Arena* absl_nonnull) { + return BoolValue(ip.IsLinkLocalMulticast()); + })); + CEL_RETURN_IF_ERROR(RegisterOpaqueUnaryMember( + registry, "isLinkLocalUnicast", + [](const internal::IpAddr& ip, google::protobuf::Arena* absl_nonnull) { + return BoolValue(ip.IsLinkLocalUnicast()); + })); + + return absl::OkStatus(); +} + +absl::Status RegisterNetworkFunctions( + google::api::expr::runtime::CelFunctionRegistry* absl_nonnull registry, + const google::api::expr::runtime::InterpreterOptions&, int version) { + (void)version; + if (registry == nullptr) { + return absl::InvalidArgumentError("registry must not be null"); + } + return RegisterStringNetworkFunctions(registry->InternalGetRegistry()); +} + +} // namespace cel::extensions diff --git a/extensions/network_ext.h b/extensions/network_ext.h new file mode 100644 index 000000000..bca247a8b --- /dev/null +++ b/extensions/network_ext.h @@ -0,0 +1,51 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Runtime bindings and opaque value registrations (`net.IP`, `net.CIDR`) for +// the CEL network extension library (`cel.lib.ext.network`). + +#ifndef THIRD_PARTY_CEL_CPP_EXTENSIONS_NETWORK_EXT_H_ +#define THIRD_PARTY_CEL_CPP_EXTENSIONS_NETWORK_EXT_H_ + +#include "absl/base/nullability.h" +#include "absl/status/status.h" +#include "eval/public/cel_function_registry.h" +#include "eval/public/cel_options.h" +#include "extensions/network_ext_decls.h" // IWYU pragma: export +#include "runtime/runtime_builder.h" + +namespace cel::extensions { + +// Registers the network extension functions and types (`net.IP`, `net.CIDR`) +// with `builder`. +// +// Requires `RuntimeOptions.enable_qualified_type_identifiers` and +// `RuntimeOptions.enable_heterogeneous_equality` to be enabled. +absl::Status RegisterNetworkFunctions( + RuntimeBuilder& builder, int version = kNetworkExtensionLatestVersion); + +// Registers the pure-string network extension functions (`isIP`, `isCIDR`, +// `ip.isCanonical`) for the legacy `google::api::expr::runtime::CelValue` +// runtime. +// +// Note: `CelValue` does not support opaque types, so functions producing or +// consuming `net.IP` or `net.CIDR` require `cel::RuntimeBuilder`. +absl::Status RegisterNetworkFunctions( + google::api::expr::runtime::CelFunctionRegistry* absl_nonnull registry, + const google::api::expr::runtime::InterpreterOptions& options, + int version = kNetworkExtensionLatestVersion); + +} // namespace cel::extensions + +#endif // THIRD_PARTY_CEL_CPP_EXTENSIONS_NETWORK_EXT_H_ diff --git a/extensions/network_ext_decls.cc b/extensions/network_ext_decls.cc new file mode 100644 index 000000000..546ff0af3 --- /dev/null +++ b/extensions/network_ext_decls.cc @@ -0,0 +1,197 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "extensions/network_ext_decls.h" + +#include +#include + +#include "absl/base/no_destructor.h" +#include "absl/status/status.h" +#include "absl/strings/str_cat.h" +#include "absl/strings/string_view.h" +#include "absl/types/span.h" +#include "checker/internal/builtins_arena.h" +#include "checker/type_checker_builder.h" +#include "common/constant.h" +#include "common/decl.h" +#include "common/expr.h" +#include "common/navigable_ast.h" +#include "common/standard_definitions.h" +#include "common/type.h" +#include "compiler/compiler.h" +#include "internal/network_addr.h" +#include "internal/status_macros.h" +#include "validator/validator.h" + +namespace cel::extensions { +namespace { + +using ::cel::checker_internal::BuiltinsArena; + +constexpr absl::string_view kNetworkExtensionName = "cel.lib.ext.network"; +constexpr absl::string_view kNetworkValidatorId = "cel.validator.network"; +constexpr absl::string_view kNetIpTypeName = "net.IP"; +constexpr absl::string_view kNetCidrTypeName = "net.CIDR"; + +template +absl::Status AddFunctionDecl(TypeCheckerBuilder& builder, + absl::string_view name, Overloads&&... overloads) { + CEL_ASSIGN_OR_RETURN(FunctionDecl decl, + MakeFunctionDecl(std::string(name), + std::forward(overloads)...)); + return builder.AddFunction(std::move(decl)); +} + +absl::Status RegisterNetworkCheckerDecls(TypeCheckerBuilder& builder) { + CEL_RETURN_IF_ERROR(builder.AddVariable(MakeVariableDecl( + kNetIpTypeName, TypeType(builder.arena(), NetIpType())))); + CEL_RETURN_IF_ERROR(builder.AddVariable(MakeVariableDecl( + kNetCidrTypeName, TypeType(builder.arena(), NetCidrType())))); + + CEL_ASSIGN_OR_RETURN( + FunctionDecl string_decl, + MakeFunctionDecl( + std::string(StandardFunctions::kString), + MakeOverloadDecl("ip_to_string", StringType(), NetIpType()), + MakeOverloadDecl("cidr_to_string", StringType(), NetCidrType()))); + CEL_RETURN_IF_ERROR(builder.MergeFunction(std::move(string_decl))); + + CEL_RETURN_IF_ERROR(AddFunctionDecl( + builder, "cidr", + MakeOverloadDecl("string_to_cidr", NetCidrType(), StringType()))); + CEL_RETURN_IF_ERROR(AddFunctionDecl( + builder, "containsCIDR", + MakeMemberOverloadDecl("cidr_contains_cidr", BoolType(), NetCidrType(), + NetCidrType()), + MakeMemberOverloadDecl("cidr_contains_cidr_string", BoolType(), + NetCidrType(), StringType()))); + CEL_RETURN_IF_ERROR(AddFunctionDecl( + builder, "containsIP", + MakeMemberOverloadDecl("cidr_contains_ip_ip", BoolType(), NetCidrType(), + NetIpType()), + MakeMemberOverloadDecl("cidr_contains_ip_string", BoolType(), + NetCidrType(), StringType()))); + CEL_RETURN_IF_ERROR(AddFunctionDecl( + builder, "family", + MakeMemberOverloadDecl("ip_family", IntType(), NetIpType()))); + CEL_RETURN_IF_ERROR(AddFunctionDecl( + builder, "ip", + MakeOverloadDecl("string_to_ip", NetIpType(), StringType()), + MakeMemberOverloadDecl("cidr_ip", NetIpType(), NetCidrType()))); + CEL_RETURN_IF_ERROR(AddFunctionDecl( + builder, "ip.isCanonical", + MakeOverloadDecl("ip_is_canonical", BoolType(), StringType()))); + CEL_RETURN_IF_ERROR( + AddFunctionDecl(builder, "isCIDR", + MakeOverloadDecl("is_cidr", BoolType(), StringType()))); + CEL_RETURN_IF_ERROR(AddFunctionDecl( + builder, "isGlobalUnicast", + MakeMemberOverloadDecl("ip_is_global_unicast", BoolType(), NetIpType()))); + CEL_RETURN_IF_ERROR(AddFunctionDecl( + builder, "isIP", MakeOverloadDecl("is_ip", BoolType(), StringType()))); + CEL_RETURN_IF_ERROR( + AddFunctionDecl(builder, "isLinkLocalMulticast", + MakeMemberOverloadDecl("ip_is_link_local_multicast", + BoolType(), NetIpType()))); + CEL_RETURN_IF_ERROR( + AddFunctionDecl(builder, "isLinkLocalUnicast", + MakeMemberOverloadDecl("ip_is_link_local_unicast", + BoolType(), NetIpType()))); + CEL_RETURN_IF_ERROR(AddFunctionDecl( + builder, "isLoopback", + MakeMemberOverloadDecl("ip_is_loopback", BoolType(), NetIpType()))); + CEL_RETURN_IF_ERROR(AddFunctionDecl( + builder, "isMask", + MakeMemberOverloadDecl("cidr_is_mask", BoolType(), NetCidrType()))); + CEL_RETURN_IF_ERROR(AddFunctionDecl( + builder, "isUnspecified", + MakeMemberOverloadDecl("ip_is_unspecified", BoolType(), NetIpType()))); + CEL_RETURN_IF_ERROR(AddFunctionDecl( + builder, "masked", + MakeMemberOverloadDecl("cidr_masked", NetCidrType(), NetCidrType()))); + CEL_RETURN_IF_ERROR(AddFunctionDecl( + builder, "prefixLength", + MakeMemberOverloadDecl("cidr_prefix_length", IntType(), NetCidrType()))); + + return absl::OkStatus(); +} + +bool ValidateNetworkLiterals(ValidationContext& context) { + bool valid = true; + for (const NavigableAstNode& node : + context.navigable_ast().Root().DescendantsPostorder()) { + if (node.node_kind() != NodeKind::kCall) { + continue; + } + const CallExpr& call_expr = node.expr()->call_expr(); + if (call_expr.has_target() || call_expr.args().size() != 1) { + continue; + } + const Expr& arg_expr = call_expr.args()[0]; + if (!arg_expr.has_const_expr() || + !arg_expr.const_expr().has_string_value()) { + continue; + } + absl::string_view literal = arg_expr.const_expr().string_value(); + if (call_expr.function() == "ip") { + if (absl::Status status = internal::ParseIp(literal).status(); + !status.ok()) { + context.ReportErrorAt( + arg_expr.id(), + absl::StrCat("invalid ip argument: ", status.message())); + valid = false; + } + } else if (call_expr.function() == "cidr") { + if (absl::Status status = internal::ParseCidr(literal).status(); + !status.ok()) { + context.ReportErrorAt( + arg_expr.id(), + absl::StrCat("invalid cidr argument: ", status.message())); + valid = false; + } + } + } + return valid; +} + +} // namespace + +OpaqueType NetIpType() { + static const absl::NoDestructor kInstance( + BuiltinsArena(), kNetIpTypeName, absl::Span{}); + return *kInstance; +} + +OpaqueType NetCidrType() { + static const absl::NoDestructor kInstance( + BuiltinsArena(), kNetCidrTypeName, absl::Span{}); + return *kInstance; +} + +CheckerLibrary NetworkCheckerLibrary(int version) { + (void)version; + return {.id = std::string(kNetworkExtensionName), + .configure = RegisterNetworkCheckerDecls}; +} + +CompilerLibrary NetworkCompilerLibrary(int version) { + return CompilerLibrary::FromCheckerLibrary(NetworkCheckerLibrary(version)); +} + +Validation NetworkValidator() { + return Validation(&ValidateNetworkLiterals, kNetworkValidatorId); +} + +} // namespace cel::extensions diff --git a/extensions/network_ext_decls.h b/extensions/network_ext_decls.h new file mode 100644 index 000000000..77bbcb7fb --- /dev/null +++ b/extensions/network_ext_decls.h @@ -0,0 +1,89 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Type declarations, opaque types, and compile-time literal validator for the +// CEL network extension library (`cel.lib.ext.network`), matching `cel-go`'s +// `ext.Network()` semantics. +// +// IP addresses and CIDR prefixes are parsed strictly: leading zeros, IPv6 zone +// identifiers, and IPv4-mapped IPv6 addresses (`::ffff:0:0/96`) are rejected. +// +// # Types +// +// net.IP +// net.CIDR +// +// # Global Functions +// +// ip(string) -> net.IP +// isIP(string) -> bool +// ip.isCanonical(string) -> bool +// cidr(string) -> net.CIDR +// isCIDR(string) -> bool +// string(net.IP) -> string +// string(net.CIDR) -> string +// +// # net.IP Member Functions +// +// .family() -> int +// .isUnspecified() -> bool +// .isLoopback() -> bool +// .isGlobalUnicast() -> bool +// .isLinkLocalMulticast() -> bool +// .isLinkLocalUnicast() -> bool +// +// # net.CIDR Member Functions +// +// .ip() -> net.IP +// .masked() -> net.CIDR +// .isMask() -> bool +// .prefixLength() -> int +// .containsIP(net.IP) -> bool +// .containsIP(string) -> bool +// .containsCIDR(net.CIDR) -> bool +// .containsCIDR(string) -> bool + +#ifndef THIRD_PARTY_CEL_CPP_EXTENSIONS_NETWORK_EXT_DECLS_H_ +#define THIRD_PARTY_CEL_CPP_EXTENSIONS_NETWORK_EXT_DECLS_H_ + +#include "checker/type_checker_builder.h" +#include "common/type.h" +#include "compiler/compiler.h" +#include "validator/validator.h" + +namespace cel::extensions { + +constexpr int kNetworkExtensionLatestVersion = 1; + +// Returns the CEL opaque type for `net.IP`. +OpaqueType NetIpType(); + +// Returns the CEL opaque type for `net.CIDR`. +OpaqueType NetCidrType(); + +// Type check declarations for the network extension library. +CheckerLibrary NetworkCheckerLibrary( + int version = kNetworkExtensionLatestVersion); + +// Compiler declarations for the network extension library. +CompilerLibrary NetworkCompilerLibrary( + int version = kNetworkExtensionLatestVersion); + +// Returns a `Validation` (`"cel.validator.network"`) that validates string +// literal arguments passed to global `ip(...)` and `cidr(...)` calls. +Validation NetworkValidator(); + +} // namespace cel::extensions + +#endif // THIRD_PARTY_CEL_CPP_EXTENSIONS_NETWORK_EXT_DECLS_H_ diff --git a/extensions/network_ext_decls_test.cc b/extensions/network_ext_decls_test.cc new file mode 100644 index 000000000..e388beace --- /dev/null +++ b/extensions/network_ext_decls_test.cc @@ -0,0 +1,188 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "extensions/network_ext_decls.h" + +#include +#include +#include +#include + +#include "absl/status/status_matchers.h" +#include "absl/status/statusor.h" +#include "absl/strings/string_view.h" +#include "checker/standard_library.h" +#include "checker/validation_result.h" +#include "common/ast.h" +#include "common/decl.h" +#include "common/source.h" +#include "common/type.h" +#include "compiler/compiler.h" +#include "compiler/compiler_factory.h" +#include "internal/status_macros.h" +#include "internal/testing.h" +#include "internal/testing_descriptor_pool.h" +#include "validator/validator.h" + +namespace cel::extensions { +namespace { + +using ::absl_testing::IsOk; +using ::testing::HasSubstr; +using ::testing::IsEmpty; +using ::testing::TestWithParam; +using ::testing::ValuesIn; + +absl::StatusOr> CreateTestCompiler( + int version = kNetworkExtensionLatestVersion) { + CEL_ASSIGN_OR_RETURN( + auto builder, NewCompilerBuilder(internal::GetTestingDescriptorPool())); + CEL_RETURN_IF_ERROR(builder->AddLibrary(StandardCheckerLibrary())); + CEL_RETURN_IF_ERROR(builder->AddLibrary(NetworkCompilerLibrary(version))); + return std::move(*builder).Build(); +} + +TEST(NetworkExtDeclsTest, TypeNamesAndIds) { + EXPECT_EQ(kNetworkExtensionLatestVersion, 1); + EXPECT_EQ(NetIpType().name(), "net.IP"); + EXPECT_EQ(NetCidrType().name(), "net.CIDR"); + EXPECT_EQ(NetworkCheckerLibrary().id, "cel.lib.ext.network"); + EXPECT_EQ(NetworkCheckerLibrary(0).id, "cel.lib.ext.network"); + EXPECT_EQ(NetworkCompilerLibrary().id, "cel.lib.ext.network"); + EXPECT_EQ(NetworkCompilerLibrary(0).id, "cel.lib.ext.network"); + EXPECT_EQ(NetworkValidator().id(), "cel.validator.network"); +} + +struct NetworkCheckerCase { + std::string expr; + std::string error_substr = ""; +}; + +class NetworkExtDeclsCheckerTest : public TestWithParam {}; + +TEST_P(NetworkExtDeclsCheckerTest, CompileVersionsZeroAndLatest) { + for (int version : {0, kNetworkExtensionLatestVersion}) { + ASSERT_OK_AND_ASSIGN(std::unique_ptr compiler, + CreateTestCompiler(version)); + ASSERT_OK_AND_ASSIGN(ValidationResult result, + compiler->Compile(GetParam().expr)); + absl::string_view error_substr = GetParam().error_substr; + EXPECT_EQ(result.IsValid(), error_substr.empty()) + << "version: " << version << " expr: " << GetParam().expr + << " issues: " << result.FormatError(); + if (!error_substr.empty()) { + EXPECT_THAT(result.FormatError(), HasSubstr(error_substr)); + } + } +} + +INSTANTIATE_TEST_SUITE_P( + NetworkExtDeclsCheckerTest, NetworkExtDeclsCheckerTest, + ValuesIn(std::vector{ + // All 17 functions / 21 overloads + net.IP / net.CIDR type variables. + {"type(ip('192.168.0.1')) == net.IP"}, + {"type(cidr('192.168.0.0/24')) == net.CIDR"}, + {"isIP('192.168.0.1')"}, + {"isCIDR('192.168.0.0/24')"}, + {"ip.isCanonical('2001:db8::1')"}, + {"string(ip('192.168.0.1')) == '192.168.0.1'"}, + {"string(cidr('192.168.0.0/24')) == '192.168.0.0/24'"}, + {"string(42) == '42'"}, + {"ip('192.168.0.1').family() == 4"}, + {"ip('0.0.0.0').isUnspecified()"}, + {"ip('127.0.0.1').isLoopback()"}, + {"ip('8.8.8.8').isGlobalUnicast()"}, + {"ip('224.0.0.1').isLinkLocalMulticast()"}, + {"ip('169.254.1.1').isLinkLocalUnicast()"}, + {"cidr('192.168.0.1/24').ip() == ip('192.168.0.1')"}, + {"cidr('192.168.0.1/24').masked() == cidr('192.168.0.0/24')"}, + {"cidr('192.168.0.0/24').isMask()"}, + {"cidr('192.168.0.0/24').prefixLength() == 24"}, + {"cidr('192.168.0.0/24').containsIP(ip('192.168.0.1'))"}, + {"cidr('192.168.0.0/24').containsIP('192.168.0.1')"}, + {"cidr('192.168.0.0/24').containsCIDR(cidr('192.168.0.0/25'))"}, + {"cidr('192.168.0.0/24').containsCIDR('192.168.0.0/25')"}, + + // Static type-mismatch errors. + {"isIP(cidr('192.168.0.0/24'))", + "found no matching overload for 'isIP' applied to '(net.CIDR)'"}, + {"ip('192.168.0.1') == cidr('192.168.0.1/32')", + "found no matching overload for '_==_' applied to '(net.IP, " + "net.CIDR)'"}, + {"ip('192.168.0.1').prefixLength()", + "found no matching overload for 'prefixLength' applied to '(net.IP)'"}, + {"cidr('192.168.0.0/24').family()", + "found no matching overload for 'family' applied to '(net.CIDR)'"}, + {"string(ip('192.168.0.1')) == 1", + "found no matching overload for '_==_' applied to '(string, int)'"}, + })); + +class NetworkExtDeclsValidatorTest : public TestWithParam { +}; + +TEST_P(NetworkExtDeclsValidatorTest, ValidatesLiterals) { + ASSERT_OK_AND_ASSIGN( + auto builder, NewCompilerBuilder(internal::GetTestingDescriptorPool())); + ASSERT_THAT(builder->AddLibrary(StandardCheckerLibrary()), IsOk()); + ASSERT_THAT(builder->AddLibrary(NetworkCompilerLibrary()), IsOk()); + ASSERT_THAT(builder->GetCheckerBuilder().AddVariable( + MakeVariableDecl("addr", StringType())), + IsOk()); + builder->GetValidator().AddValidation(NetworkValidator()); + ASSERT_OK_AND_ASSIGN(auto compiler, std::move(*builder).Build()); + + ASSERT_OK_AND_ASSIGN(ValidationResult result, + compiler->Compile(GetParam().expr)); + EXPECT_EQ(result.IsValid(), GetParam().error_substr.empty()) + << "Expression: " << GetParam().expr + << " issues: " << result.FormatError(); + if (!GetParam().error_substr.empty()) { + EXPECT_THAT(result.FormatError(), HasSubstr(GetParam().error_substr)); + } +} + +INSTANTIATE_TEST_SUITE_P( + NetworkExtDeclsValidatorTest, NetworkExtDeclsValidatorTest, + ValuesIn(std::vector{ + {"ip('192.168.0.1')"}, + {"ip(addr)"}, + {"cidr('192.168.0.1/24').ip()"}, + {"cidr('2001:db8::/32')"}, + {"ip('192.168.0.1.0')", "invalid ip argument"}, + {"ip('fe80::1%en0')", "invalid ip argument"}, + {"ip('::ffff:192.168.0.1')", "invalid ip argument"}, + {"cidr('192.168.0.0/')", "invalid cidr argument"}, + {"cidr('10.0.0.0/08')", "invalid cidr argument"}, + {"cidr('::ffff:192.168.0.1/24')", "invalid cidr argument"}, + })); + +TEST(NetworkExtDeclsValidatorRawAstTest, IgnoresNonStringAndMemberCalls) { + ASSERT_OK_AND_ASSIGN( + auto builder, NewCompilerBuilder(internal::GetTestingDescriptorPool())); + ASSERT_OK_AND_ASSIGN(auto compiler, std::move(*builder).Build()); + ASSERT_OK_AND_ASSIGN( + std::unique_ptr source, + NewSource("ip(123) == x.ip('invalid') && cidr('a', 'b')")); + ASSERT_OK_AND_ASSIGN(std::unique_ptr ast, + compiler->GetParser().Parse(*source)); + + Validator validator; + validator.AddValidation(NetworkValidator()); + Validator::ValidationOutput output = validator.Validate(*ast); + EXPECT_TRUE(output.valid); + EXPECT_THAT(output.issues, IsEmpty()); +} + +} // namespace +} // namespace cel::extensions diff --git a/extensions/network_ext_test.cc b/extensions/network_ext_test.cc new file mode 100644 index 000000000..f228c5a3c --- /dev/null +++ b/extensions/network_ext_test.cc @@ -0,0 +1,623 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "extensions/network_ext.h" + +#include +#include +#include +#include +#include + +#include "cel/expr/syntax.pb.h" +#include "absl/status/status.h" +#include "absl/status/status_matchers.h" +#include "absl/status/statusor.h" +#include "absl/strings/cord_test_helpers.h" +#include "absl/strings/string_view.h" +#include "checker/standard_library.h" +#include "checker/validation_result.h" +#include "common/ast.h" +#include "common/decl.h" +#include "common/kind.h" +#include "common/type.h" +#include "common/value.h" +#include "common/value_testing.h" +#include "compiler/compiler.h" +#include "compiler/compiler_factory.h" +#include "compiler/optional.h" +#include "eval/public/activation.h" +#include "eval/public/cel_expr_builder_factory.h" +#include "eval/public/cel_expression.h" +#include "eval/public/cel_function_registry.h" +#include "eval/public/cel_options.h" +#include "eval/public/cel_value.h" +#include "extensions/protobuf/runtime_adapter.h" +#include "internal/status_macros.h" +#include "internal/testing.h" +#include "internal/testing_descriptor_pool.h" +#include "parser/parser.h" +#include "runtime/activation.h" +#include "runtime/constant_folding.h" +#include "runtime/optional_types.h" +#include "runtime/reference_resolver.h" +#include "runtime/runtime.h" +#include "runtime/runtime_options.h" +#include "runtime/standard_runtime_builder_factory.h" +#include "google/protobuf/arena.h" +#include "google/protobuf/message.h" + +namespace cel::extensions { +namespace { + +using ::absl_testing::IsOk; +using ::absl_testing::IsOkAndHolds; +using ::absl_testing::StatusIs; +using ::cel::test::BoolValueIs; +using ::cel::test::ErrorValueIs; +using ::cel::test::IntValueIs; +using ::cel::test::StringValueIs; +using ::google::api::expr::parser::Parse; +using ::google::api::expr::runtime::CelExpressionBuilder; +using ::google::api::expr::runtime::CelFunctionRegistry; +using ::google::api::expr::runtime::CelValue; +using ::google::api::expr::runtime::CreateCelExpressionBuilder; +using ::google::api::expr::runtime::InterpreterOptions; +using ::testing::AllOf; +using ::testing::HasSubstr; +using ::testing::IsEmpty; +using ::testing::Not; +using ::testing::SizeIs; +using ::testing::TestWithParam; +using ::testing::ValuesIn; + +using LegacyActivation = google::api::expr::runtime::Activation; + +absl::StatusOr> CreateTestCompiler( + int version = kNetworkExtensionLatestVersion) { + CEL_ASSIGN_OR_RETURN( + auto builder, NewCompilerBuilder(internal::GetTestingDescriptorPool())); + CEL_RETURN_IF_ERROR(builder->AddLibrary(StandardCheckerLibrary())); + CEL_RETURN_IF_ERROR(builder->AddLibrary(OptionalCompilerLibrary())); + CEL_RETURN_IF_ERROR(builder->AddLibrary(NetworkCompilerLibrary(version))); + return std::move(*builder).Build(); +} + +absl::StatusOr> CreateTestRuntime( + int version = kNetworkExtensionLatestVersion, + bool enable_constant_folding = false) { + RuntimeOptions options; + options.enable_qualified_type_identifiers = true; + CEL_ASSIGN_OR_RETURN(auto builder, + CreateStandardRuntimeBuilder( + internal::GetTestingDescriptorPool(), options)); + if (enable_constant_folding) { + CEL_RETURN_IF_ERROR(EnableConstantFolding(builder)); + } + CEL_RETURN_IF_ERROR( + EnableReferenceResolver(builder, ReferenceResolverEnabled::kAlways)); + CEL_RETURN_IF_ERROR(EnableOptionalTypes(builder)); + CEL_RETURN_IF_ERROR(RegisterNetworkFunctions(builder, version)); + return std::move(builder).Build(); +} + +TEST(NetworkExtTest, VersionedRegistration) { + for (int version : {0, kNetworkExtensionLatestVersion}) { + ASSERT_OK_AND_ASSIGN(auto compiler, CreateTestCompiler(version)); + ASSERT_OK_AND_ASSIGN(auto runtime, CreateTestRuntime(version)); + ASSERT_OK_AND_ASSIGN( + ValidationResult validation_result, + compiler->Compile("cidr('10.0.0.0/8').containsIP(ip('10.1.2.3'))")); + ASSERT_TRUE(validation_result.IsValid()) << validation_result.FormatError(); + ASSERT_OK_AND_ASSIGN(std::unique_ptr ast, + validation_result.ReleaseAst()); + ASSERT_OK_AND_ASSIGN(std::unique_ptr program, + runtime->CreateProgram(std::move(ast))); + google::protobuf::Arena arena; + Activation activation; + EXPECT_THAT(program->Evaluate(&arena, activation), + IsOkAndHolds(BoolValueIs(true))); + } +} + +TEST(NetworkExtTest, BuildFailsWithoutQualifiedTypeIdentifiers) { + RuntimeOptions options; + options.enable_qualified_type_identifiers = false; + + ASSERT_OK_AND_ASSIGN(auto builder, + CreateStandardRuntimeBuilder( + internal::GetTestingDescriptorPool(), options)); + EXPECT_THAT(RegisterNetworkFunctions(builder), + StatusIs(absl::StatusCode::kFailedPrecondition, + HasSubstr("enable_qualified_type_identifiers"))); +} + +TEST(NetworkExtTest, BuildFailsWithoutHeterogeneousEquality) { + RuntimeOptions options; + options.enable_qualified_type_identifiers = true; + // NOLINTNEXTLINE(clang-diagnostic-deprecated-declarations) + options.enable_heterogeneous_equality = false; + + ASSERT_OK_AND_ASSIGN(auto builder, + CreateStandardRuntimeBuilder( + internal::GetTestingDescriptorPool(), options)); + EXPECT_THAT(RegisterNetworkFunctions(builder), + StatusIs(absl::StatusCode::kFailedPrecondition, + HasSubstr("enable_heterogeneous_equality"))); +} + +TEST(NetworkExtTest, StringConversionDisabled) { + RuntimeOptions options; + options.enable_qualified_type_identifiers = true; + options.enable_string_conversion = false; + + ASSERT_OK_AND_ASSIGN(auto builder, + CreateStandardRuntimeBuilder( + internal::GetTestingDescriptorPool(), options)); + ASSERT_THAT(RegisterNetworkFunctions(builder), IsOk()); + ASSERT_OK_AND_ASSIGN(auto runtime, std::move(builder).Build()); + + ASSERT_OK_AND_ASSIGN(cel::expr::ParsedExpr parsed, + Parse("string(ip('192.168.0.1'))")); + EXPECT_THAT(ProtobufRuntimeAdapter::CreateProgram(*runtime, parsed), + StatusIs(absl::StatusCode::kInvalidArgument)); +} + +TEST(NetworkExtTest, LegacyRuntimeRegistryOverloads) { + InterpreterOptions options; + CelFunctionRegistry* null_registry = nullptr; + EXPECT_THAT(RegisterNetworkFunctions(null_registry, options), + StatusIs(absl::StatusCode::kInvalidArgument)); + + CelFunctionRegistry registry; + ASSERT_THAT(RegisterNetworkFunctions(®istry, options, /*version=*/0), + IsOk()); + EXPECT_THAT(registry.FindStaticOverloads("isIP", false, {cel::Kind::kString}), + SizeIs(1)); + EXPECT_THAT( + registry.FindStaticOverloads("isCIDR", false, {cel::Kind::kString}), + SizeIs(1)); + EXPECT_THAT(registry.FindStaticOverloads("ip.isCanonical", false, + {cel::Kind::kString}), + SizeIs(1)); + EXPECT_THAT(registry.FindStaticOverloads("ip", false, {cel::Kind::kString}), + IsEmpty()); + EXPECT_THAT(registry.FindStaticOverloads("cidr", false, {cel::Kind::kString}), + IsEmpty()); +} + +TEST(NetworkExtTest, LegacyRuntimeStringFunctions) { + InterpreterOptions options; + options.enable_qualified_type_identifiers = true; + options.enable_qualified_identifier_rewrites = true; + + std::unique_ptr builder = CreateCelExpressionBuilder( + internal::GetTestingDescriptorPool(), nullptr, options); + ASSERT_THAT(RegisterNetworkFunctions(builder->GetRegistry(), options), + IsOk()); + + auto eval = [&](absl::string_view expr_str, + google::protobuf::Arena* arena) -> absl::StatusOr { + CEL_ASSIGN_OR_RETURN(cel::expr::ParsedExpr parsed, Parse(expr_str)); + CEL_ASSIGN_OR_RETURN( + auto program, + builder->CreateExpression(&parsed.expr(), &parsed.source_info())); + LegacyActivation activation; + return program->Evaluate(activation, arena); + }; + + google::protobuf::Arena arena; + ASSERT_OK_AND_ASSIGN(CelValue r1, eval("isIP('192.168.0.1')", &arena)); + ASSERT_TRUE(r1.IsBool()); + EXPECT_TRUE(r1.BoolOrDie()); + + ASSERT_OK_AND_ASSIGN(CelValue r2, eval("isIP('01.2.3.4')", &arena)); + ASSERT_TRUE(r2.IsBool()); + EXPECT_FALSE(r2.BoolOrDie()); + + ASSERT_OK_AND_ASSIGN(CelValue r3, eval("isCIDR('2001:db8::/32')", &arena)); + ASSERT_TRUE(r3.IsBool()); + EXPECT_TRUE(r3.BoolOrDie()); + + ASSERT_OK_AND_ASSIGN(CelValue r4, eval("isCIDR('192.168.0.0/08')", &arena)); + ASSERT_TRUE(r4.IsBool()); + EXPECT_FALSE(r4.BoolOrDie()); + + ASSERT_OK_AND_ASSIGN(CelValue r5, + eval("ip.isCanonical('2001:db8::1')", &arena)); + ASSERT_TRUE(r5.IsBool()); + EXPECT_TRUE(r5.BoolOrDie()); + + ASSERT_OK_AND_ASSIGN(CelValue r6, + eval("ip.isCanonical('2001:DB8::1')", &arena)); + ASSERT_TRUE(r6.IsBool()); + EXPECT_FALSE(r6.BoolOrDie()); + + ASSERT_OK_AND_ASSIGN(CelValue r7, eval("ip.isCanonical('invalid')", &arena)); + EXPECT_TRUE(r7.IsError()); +} + +TEST(NetworkExtTest, OpaqueValueInterfaceCloningAndConstantFolding) { + ASSERT_OK_AND_ASSIGN(auto compiler, CreateTestCompiler()); + ASSERT_OK_AND_ASSIGN(auto runtime, + CreateTestRuntime(kNetworkExtensionLatestVersion, + /*enable_constant_folding=*/true)); + + auto compile_program = [&](absl::string_view expr_str) + -> absl::StatusOr> { + CEL_ASSIGN_OR_RETURN(ValidationResult validation_result, + compiler->Compile(expr_str)); + if (!validation_result.IsValid()) { + return absl::InvalidArgumentError(validation_result.FormatError()); + } + CEL_ASSIGN_OR_RETURN(std::unique_ptr ast, + validation_result.ReleaseAst()); + return runtime->CreateProgram(std::move(ast)); + }; + + google::protobuf::Arena arena1; + google::protobuf::Arena arena2; + Activation activation; + + ASSERT_OK_AND_ASSIGN(std::unique_ptr ip_program, + compile_program("ip('2001:0DB8::1')")); + ASSERT_OK_AND_ASSIGN(Value ip_val, ip_program->Evaluate(&arena1, activation)); + ASSERT_TRUE(ip_val.IsOpaque()); + EXPECT_EQ(ip_val.DebugString(), "2001:db8::1"); + EXPECT_EQ(ip_val.GetTypeName(), "net.IP"); + EXPECT_EQ(ip_val.GetOpaque().GetRuntimeType(), NetIpType()); + + OpaqueValue cloned_ip = ip_val.GetOpaque().Clone(&arena2); + EXPECT_EQ(cloned_ip.DebugString(), "2001:db8::1"); + EXPECT_EQ(cloned_ip.GetTypeName(), "net.IP"); + EXPECT_EQ(cloned_ip.GetRuntimeType(), NetIpType()); + + Value eq_result; + ASSERT_THAT(ip_val.Equal(cloned_ip, internal::GetTestingDescriptorPool(), + google::protobuf::MessageFactory::generated_factory(), &arena2, + &eq_result), + IsOk()); + EXPECT_THAT(eq_result, BoolValueIs(true)); + + ASSERT_OK_AND_ASSIGN(std::unique_ptr cidr_program, + compile_program("cidr('192.168.1.5/24')")); + ASSERT_OK_AND_ASSIGN(Value cidr_val, + cidr_program->Evaluate(&arena1, activation)); + ASSERT_TRUE(cidr_val.IsOpaque()); + EXPECT_EQ(cidr_val.DebugString(), "192.168.1.5/24"); + EXPECT_EQ(cidr_val.GetTypeName(), "net.CIDR"); + EXPECT_EQ(cidr_val.GetOpaque().GetRuntimeType(), NetCidrType()); + + OpaqueValue cloned_cidr = cidr_val.GetOpaque().Clone(&arena2); + EXPECT_EQ(cloned_cidr.DebugString(), "192.168.1.5/24"); + EXPECT_EQ(cloned_cidr.GetTypeName(), "net.CIDR"); + EXPECT_EQ(cloned_cidr.GetRuntimeType(), NetCidrType()); + + ASSERT_THAT(cidr_val.Equal(cloned_cidr, internal::GetTestingDescriptorPool(), + google::protobuf::MessageFactory::generated_factory(), + &arena2, &eq_result), + IsOk()); + EXPECT_THAT(eq_result, BoolValueIs(true)); + + ASSERT_THAT(ip_val.Equal(cloned_cidr, internal::GetTestingDescriptorPool(), + google::protobuf::MessageFactory::generated_factory(), &arena2, + &eq_result), + IsOk()); + EXPECT_THAT(eq_result, BoolValueIs(false)); +} + +TEST(NetworkExtTest, FragmentedCordStringValues) { + ASSERT_OK_AND_ASSIGN( + auto builder, NewCompilerBuilder(internal::GetTestingDescriptorPool())); + ASSERT_THAT(builder->AddLibrary(StandardCheckerLibrary()), IsOk()); + ASSERT_THAT(builder->AddLibrary(NetworkCompilerLibrary()), IsOk()); + ASSERT_THAT(builder->GetCheckerBuilder().AddVariable( + MakeVariableDecl("ip_var", StringType())), + IsOk()); + ASSERT_THAT(builder->GetCheckerBuilder().AddVariable( + MakeVariableDecl("cidr_var", StringType())), + IsOk()); + ASSERT_THAT(builder->GetCheckerBuilder().AddVariable( + MakeVariableDecl("sub_cidr_var", StringType())), + IsOk()); + ASSERT_OK_AND_ASSIGN(auto compiler, std::move(*builder).Build()); + ASSERT_OK_AND_ASSIGN(auto runtime, CreateTestRuntime()); + + const std::string expr = + "isIP(ip_var) && isCIDR(cidr_var) && ip.isCanonical(ip_var) && " + "cidr(cidr_var).containsIP(ip(ip_var)) && " + "cidr(cidr_var).containsIP(ip_var) && " + "cidr(cidr_var).containsCIDR(sub_cidr_var)"; + + ASSERT_OK_AND_ASSIGN(ValidationResult validation_result, + compiler->Compile(expr)); + ASSERT_TRUE(validation_result.IsValid()) << validation_result.FormatError(); + ASSERT_OK_AND_ASSIGN(std::unique_ptr ast, + validation_result.ReleaseAst()); + ASSERT_OK_AND_ASSIGN(std::unique_ptr program, + runtime->CreateProgram(std::move(ast))); + + google::protobuf::Arena arena; + Activation activation; + activation.InsertOrAssignValue( + "ip_var", + StringValue::From(absl::MakeFragmentedCord({"2001:", "db8", "::", "1"}), + &arena)); + activation.InsertOrAssignValue( + "cidr_var", + StringValue::From(absl::MakeFragmentedCord({"2001:db", "8::/", "32"}), + &arena)); + activation.InsertOrAssignValue( + "sub_cidr_var", + StringValue::From(absl::MakeFragmentedCord({"2001:", "db8::", "/64"}), + &arena)); + + EXPECT_THAT(program->Evaluate(&arena, activation), + IsOkAndHolds(BoolValueIs(true))); +} + +TEST(NetworkExtTest, CidrInvalidIpErrorIsNotDoubleWrapped) { + ASSERT_OK_AND_ASSIGN(auto runtime, CreateTestRuntime()); + ASSERT_OK_AND_ASSIGN(cel::expr::ParsedExpr parsed, + Parse("cidr('invalid/24')")); + ASSERT_OK_AND_ASSIGN(std::unique_ptr program, + ProtobufRuntimeAdapter::CreateProgram(*runtime, parsed)); + google::protobuf::Arena arena; + Activation activation; + ASSERT_OK_AND_ASSIGN(Value result, program->Evaluate(&arena, activation)); + ASSERT_TRUE(result.IsError()); + EXPECT_THAT( + result.GetError().NativeValue(), + StatusIs( + absl::StatusCode::kInvalidArgument, + AllOf(HasSubstr("CIDR 'invalid/24' parse error during conversion " + "from string: unable to parse IP"), + Not(HasSubstr("CIDR 'invalid' parse error"))))); +} + +enum class ExpectedKind { + kBoolTrue, + kBoolFalse, + kInt, + kString, + kInvalidArgError, + kNoMatchingOverloadError, +}; + +struct NetworkEvalCase { + std::string expr; + ExpectedKind expected_kind; + std::string expected_str = ""; + int64_t expected_int = 0; + bool test_checked = true; + bool test_parse_only = true; +}; + +class NetworkExtEvalTest : public TestWithParam { + public: + void SetUp() override { + ASSERT_OK_AND_ASSIGN(compiler_, CreateTestCompiler()); + ASSERT_OK_AND_ASSIGN(runtime_, CreateTestRuntime()); + } + + absl::StatusOr EvalChecked(absl::string_view expr_str) { + CEL_ASSIGN_OR_RETURN(ValidationResult validation_result, + compiler_->Compile(expr_str)); + if (!validation_result.IsValid()) { + return absl::InvalidArgumentError(validation_result.FormatError()); + } + CEL_ASSIGN_OR_RETURN(std::unique_ptr ast, + validation_result.ReleaseAst()); + CEL_ASSIGN_OR_RETURN(std::unique_ptr program, + runtime_->CreateProgram(std::move(ast))); + Activation activation; + return program->Evaluate(&arena_, activation); + } + + absl::StatusOr EvalParseOnly(absl::string_view expr_str) { + CEL_ASSIGN_OR_RETURN(cel::expr::ParsedExpr parsed_expr, + Parse(expr_str)); + CEL_ASSIGN_OR_RETURN( + std::unique_ptr program, + ProtobufRuntimeAdapter::CreateProgram(*runtime_, parsed_expr)); + Activation activation; + return program->Evaluate(&arena_, activation); + } + + void VerifyResult(const absl::StatusOr& result, + const NetworkEvalCase& test_case) { + switch (test_case.expected_kind) { + case ExpectedKind::kBoolTrue: + EXPECT_THAT(result, IsOkAndHolds(BoolValueIs(true))) + << "Expression: " << test_case.expr; + break; + case ExpectedKind::kBoolFalse: + EXPECT_THAT(result, IsOkAndHolds(BoolValueIs(false))) + << "Expression: " << test_case.expr; + break; + case ExpectedKind::kInt: + EXPECT_THAT(result, IsOkAndHolds(IntValueIs(test_case.expected_int))) + << "Expression: " << test_case.expr; + break; + case ExpectedKind::kString: + EXPECT_THAT(result, IsOkAndHolds(StringValueIs(test_case.expected_str))) + << "Expression: " << test_case.expr; + break; + case ExpectedKind::kInvalidArgError: + EXPECT_THAT(result, IsOkAndHolds(ErrorValueIs( + StatusIs(absl::StatusCode::kInvalidArgument, + HasSubstr(test_case.expected_str))))) + << "Expression: " << test_case.expr; + break; + case ExpectedKind::kNoMatchingOverloadError: + EXPECT_THAT(result, IsOkAndHolds(ErrorValueIs( + StatusIs(absl::StatusCode::kUnknown, + HasSubstr("No matching overloads"))))) + << "Expression: " << test_case.expr; + break; + } + } + + google::protobuf::Arena arena_; + std::unique_ptr compiler_; + std::unique_ptr runtime_; +}; + +TEST_P(NetworkExtEvalTest, CheckedAndParseOnly) { + const NetworkEvalCase& test_case = GetParam(); + if (test_case.test_checked) { + VerifyResult(EvalChecked(test_case.expr), test_case); + } + if (test_case.test_parse_only) { + VerifyResult(EvalParseOnly(test_case.expr), test_case); + } +} + +std::vector NetworkEvalCases() { + return { + // IPv4 parsing, string formatting, type, and predicates. + {"string(ip('192.168.0.1'))", ExpectedKind::kString, "192.168.0.1"}, + {"string(ip('0.0.0.0'))", ExpectedKind::kString, "0.0.0.0"}, + {"type(ip('192.168.0.1')) == net.IP", ExpectedKind::kBoolTrue}, + {"ip('192.168.0.1').family()", ExpectedKind::kInt, "", 4}, + {"ip('0.0.0.0').isUnspecified()", ExpectedKind::kBoolTrue}, + {"ip('127.0.0.1').isUnspecified()", ExpectedKind::kBoolFalse}, + {"ip('127.0.0.1').isLoopback()", ExpectedKind::kBoolTrue}, + {"ip('1.2.3.4').isLoopback()", ExpectedKind::kBoolFalse}, + {"ip('169.254.169.254').isLinkLocalUnicast()", ExpectedKind::kBoolTrue}, + {"ip('192.168.0.1').isLinkLocalUnicast()", ExpectedKind::kBoolFalse}, + {"ip('224.0.0.1').isLinkLocalMulticast()", ExpectedKind::kBoolTrue}, + {"ip('224.0.1.1').isLinkLocalMulticast()", ExpectedKind::kBoolFalse}, + {"ip('8.8.8.8').isGlobalUnicast()", ExpectedKind::kBoolTrue}, + {"ip('255.255.255.255').isGlobalUnicast()", ExpectedKind::kBoolFalse}, + + // IPv6 parsing, RFC 5952 formatting, and predicates. + {"string(ip('2001:0DB8:0000:0000:0008:0800:200C:417A'))", + ExpectedKind::kString, "2001:db8::8:800:200c:417a"}, + {"ip('2001:db8::68').family()", ExpectedKind::kInt, "", 6}, + {"ip('::').isUnspecified()", ExpectedKind::kBoolTrue}, + {"ip('::1').isLoopback()", ExpectedKind::kBoolTrue}, + {"ip('fe80::1').isLinkLocalUnicast()", ExpectedKind::kBoolTrue}, + {"ip('ff02::1').isLinkLocalMulticast()", ExpectedKind::kBoolTrue}, + {"ip('2001:db8::abcd').isGlobalUnicast()", ExpectedKind::kBoolTrue}, + + // isIP / isCIDR / ip.isCanonical. + {"isIP('192.168.0.1')", ExpectedKind::kBoolTrue}, + {"isIP('01.2.3.4')", ExpectedKind::kBoolFalse}, + {"isIP('::ffff:192.168.0.1')", ExpectedKind::kBoolFalse}, + {"isCIDR('2001:db8::/32')", ExpectedKind::kBoolTrue}, + {"isCIDR('192.168.0.0/08')", ExpectedKind::kBoolFalse}, + {"ip.isCanonical('2001:db8::68')", ExpectedKind::kBoolTrue}, + {"ip.isCanonical('2001:DB8::68')", ExpectedKind::kBoolFalse}, + + // CIDR operations. + {"type(cidr('192.168.0.0/24')) == net.CIDR", ExpectedKind::kBoolTrue}, + {"string(cidr('192.168.0.1/24'))", ExpectedKind::kString, + "192.168.0.1/24"}, + {"cidr('192.168.0.1/24').ip() == ip('192.168.0.1')", + ExpectedKind::kBoolTrue}, + {"cidr('192.168.0.1/24').masked() == cidr('192.168.0.0/24')", + ExpectedKind::kBoolTrue}, + {"cidr('192.168.0.1/24').isMask()", ExpectedKind::kBoolFalse}, + {"cidr('192.168.0.0/24').isMask()", ExpectedKind::kBoolTrue}, + {"cidr('2001:db8::1:2/112').masked() == cidr('2001:db8::1:0/112')", + ExpectedKind::kBoolTrue}, + {"cidr('192.168.0.0/24').prefixLength()", ExpectedKind::kInt, "", 24}, + {"cidr('192.168.0.1/24').containsIP(ip('192.168.0.0'))", + ExpectedKind::kBoolTrue}, + {"cidr('192.168.0.0/24').containsIP('192.168.1.0')", + ExpectedKind::kBoolFalse}, + {"cidr('192.168.1.5/24').containsCIDR(cidr('192.168.1.130/25'))", + ExpectedKind::kBoolTrue}, + {"cidr('192.168.0.0/24').containsCIDR('192.168.0.0/23')", + ExpectedKind::kBoolFalse}, + + // Equality, inequality, & heterogeneous equality. + {"ip('2001:db8::1') == ip('2001:DB8::1')", ExpectedKind::kBoolTrue}, + {"ip('2001:db8::1') != ip('2001:db8::2')", ExpectedKind::kBoolTrue}, + {"cidr('192.168.0.1/24') == cidr('192.168.0.0/24')", + ExpectedKind::kBoolFalse}, + {"dyn(ip('192.168.0.1')) == cidr('192.168.0.1/32')", + ExpectedKind::kBoolFalse}, + {"dyn(ip('192.168.0.1')) == optional.of(1)", ExpectedKind::kBoolFalse}, + {"ip('192.168.0.1') == cidr('192.168.0.1/32')", ExpectedKind::kBoolFalse, + "", 0, /*test_checked=*/false, /*test_parse_only=*/true}, + {"cidr('192.168.0.0/24') == optional.none()", ExpectedKind::kBoolFalse, + "", 0, /*test_checked=*/false, /*test_parse_only=*/true}, + + // Runtime parse error propagation across all string-parsing functions. + {"ip('invalid')", ExpectedKind::kInvalidArgError, "parse error"}, + {"cidr('invalid/24')", ExpectedKind::kInvalidArgError, "parse error"}, + {"ip.isCanonical('127.0.0.1.0')", ExpectedKind::kInvalidArgError, + "parse error"}, + {"cidr('192.168.0.0/24').containsIP('not-an-ip')", + ExpectedKind::kInvalidArgError, "parse error"}, + {"cidr('192.168.0.0/24').containsCIDR('not-a-cidr')", + ExpectedKind::kInvalidArgError, "parse error"}, + + // Parse-only runtime overload safety for wrong opaque types. + {"ip('192.168.0.1').prefixLength()", + ExpectedKind::kNoMatchingOverloadError, "", 0, /*test_checked=*/false, + /*test_parse_only=*/true}, + {"ip('192.168.0.1').masked()", ExpectedKind::kNoMatchingOverloadError, "", + 0, /*test_checked=*/false, /*test_parse_only=*/true}, + {"ip('192.168.0.1').isMask()", ExpectedKind::kNoMatchingOverloadError, "", + 0, /*test_checked=*/false, /*test_parse_only=*/true}, + {"ip('192.168.0.1').ip()", ExpectedKind::kNoMatchingOverloadError, "", 0, + /*test_checked=*/false, /*test_parse_only=*/true}, + {"cidr('192.168.0.0/24').family()", + ExpectedKind::kNoMatchingOverloadError, "", 0, /*test_checked=*/false, + /*test_parse_only=*/true}, + {"cidr('0.0.0.0/0').isUnspecified()", + ExpectedKind::kNoMatchingOverloadError, "", 0, /*test_checked=*/false, + /*test_parse_only=*/true}, + {"cidr('192.168.0.0/24').isLoopback()", + ExpectedKind::kNoMatchingOverloadError, "", 0, /*test_checked=*/false, + /*test_parse_only=*/true}, + {"cidr('192.168.0.0/24').isGlobalUnicast()", + ExpectedKind::kNoMatchingOverloadError, "", 0, /*test_checked=*/false, + /*test_parse_only=*/true}, + {"cidr('224.0.0.0/24').isLinkLocalMulticast()", + ExpectedKind::kNoMatchingOverloadError, "", 0, /*test_checked=*/false, + /*test_parse_only=*/true}, + {"cidr('169.254.0.0/16').isLinkLocalUnicast()", + ExpectedKind::kNoMatchingOverloadError, "", 0, /*test_checked=*/false, + /*test_parse_only=*/true}, + {"cidr('192.168.0.0/24').containsIP(cidr('192.168.0.1/32'))", + ExpectedKind::kNoMatchingOverloadError, "", 0, /*test_checked=*/false, + /*test_parse_only=*/true}, + {"ip('192.168.0.1').containsIP('192.168.0.1')", + ExpectedKind::kNoMatchingOverloadError, "", 0, /*test_checked=*/false, + /*test_parse_only=*/true}, + {"cidr('192.168.0.0/24').containsCIDR(ip('192.168.0.1'))", + ExpectedKind::kNoMatchingOverloadError, "", 0, /*test_checked=*/false, + /*test_parse_only=*/true}, + {"ip('192.168.0.1').containsCIDR('192.168.0.0/24')", + ExpectedKind::kNoMatchingOverloadError, "", 0, /*test_checked=*/false, + /*test_parse_only=*/true}, + {"string(optional.none())", ExpectedKind::kNoMatchingOverloadError, "", 0, + /*test_checked=*/false, /*test_parse_only=*/true}, + {"optional.none().family()", ExpectedKind::kNoMatchingOverloadError, "", + 0, /*test_checked=*/false, /*test_parse_only=*/true}, + {"optional.none().containsIP('192.168.0.1')", + ExpectedKind::kNoMatchingOverloadError, "", 0, /*test_checked=*/false, + /*test_parse_only=*/true}, + }; +} + +INSTANTIATE_TEST_SUITE_P(NetworkExtEvalTest, NetworkExtEvalTest, + ValuesIn(NetworkEvalCases())); + +} // namespace +} // namespace cel::extensions diff --git a/internal/BUILD b/internal/BUILD index ce0d49594..ab47fad5f 100644 --- a/internal/BUILD +++ b/internal/BUILD @@ -893,3 +893,32 @@ cc_library( "@com_google_protobuf//:protobuf", ], ) + +cc_library( + name = "network_addr", + srcs = ["network_addr.cc"], + hdrs = ["network_addr.h"], + deps = [ + ":status_macros", + "@com_google_absl//absl/log:absl_check", + "@com_google_absl//absl/status", + "@com_google_absl//absl/status:statusor", + "@com_google_absl//absl/strings", + "@com_google_absl//absl/strings:str_format", + "@com_google_absl//absl/strings:string_view", + ], +) + +cc_test( + name = "network_addr_test", + srcs = ["network_addr_test.cc"], + deps = [ + ":network_addr", + ":testing", + "@com_google_absl//absl/log:absl_check", + "@com_google_absl//absl/status", + "@com_google_absl//absl/status:status_matchers", + "@com_google_absl//absl/status:statusor", + "@com_google_absl//absl/strings:string_view", + ], +) diff --git a/internal/network_addr.cc b/internal/network_addr.cc new file mode 100644 index 000000000..384b1d54f --- /dev/null +++ b/internal/network_addr.cc @@ -0,0 +1,467 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "internal/network_addr.h" + +#include +#include +#include +#include + +#include "absl/log/absl_check.h" +#include "absl/status/status.h" +#include "absl/status/statusor.h" +#include "absl/strings/ascii.h" +#include "absl/strings/match.h" +#include "absl/strings/numbers.h" +#include "absl/strings/str_cat.h" +#include "absl/strings/str_format.h" +#include "absl/strings/string_view.h" +#include "internal/status_macros.h" + +namespace cel::internal { +namespace { + +absl::Status MakeParseError(absl::string_view prefix, absl::string_view raw, + absl::string_view detail) { + return absl::InvalidArgumentError( + absl::StrCat(prefix, " '", raw, + "' parse error during conversion from string: ", detail)); +} + +constexpr uint64_t Ipv4Mask(int prefix_length) { + if (prefix_length <= 0) { + return 0; + } + if (prefix_length < 32) { + return (uint64_t{0xFFFFFFFFU} << (32 - prefix_length)) & + uint64_t{0xFFFFFFFFU}; + } + return uint64_t{0xFFFFFFFFU}; +} + +constexpr uint64_t Ipv6HiMask(int prefix_length) { + if (prefix_length <= 0) { + return 0; + } + if (prefix_length < 64) { + return ~uint64_t{0} << (64 - prefix_length); + } + return ~uint64_t{0}; +} + +constexpr uint64_t Ipv6LoMask(int prefix_length) { + if (prefix_length <= 64) { + return 0; + } + if (prefix_length < 128) { + return ~uint64_t{0} << (128 - prefix_length); + } + return ~uint64_t{0}; +} + +struct ParsedIpWithZone { + IpAddr ip; + bool has_zone = false; +}; + +absl::StatusOr ParseIpv4(absl::string_view s, + absl::string_view error_prefix, + absl::string_view raw_for_error) { + uint32_t octet = 0; + int digits = 0; + int dot_count = 0; + uint32_t addr = 0; + for (size_t i = 0; i < s.size(); ++i) { + char c = s[i]; + if (absl::ascii_isdigit(static_cast(c))) { + if (digits == 1 && octet == 0) { + return MakeParseError(error_prefix, raw_for_error, + "IPv4 field has octet with leading zero"); + } + octet = octet * 10 + static_cast(c - '0'); + ++digits; + if (octet > 255) { + return MakeParseError(error_prefix, raw_for_error, + "IPv4 field has value >255"); + } + } else if (c == '.') { + if (digits == 0) { + return MakeParseError(error_prefix, raw_for_error, + "IPv4 field must have at least one digit"); + } + if (dot_count == 3) { + return MakeParseError(error_prefix, raw_for_error, + "IPv4 address too long"); + } + addr = (addr << 8) | octet; + octet = 0; + digits = 0; + ++dot_count; + } else { + return MakeParseError(error_prefix, raw_for_error, + "unexpected character"); + } + } + if (dot_count != 3 || digits == 0) { + return MakeParseError(error_prefix, raw_for_error, + "IPv4 address too short"); + } + return (addr << 8) | octet; +} + +absl::StatusOr ParseIpv6Body(absl::string_view s, + absl::string_view error_prefix, + absl::string_view raw_for_error) { + if (s.size() < 2) { + return MakeParseError(error_prefix, raw_for_error, "address too short"); + } + + std::array hextets{}; + int count = 0; + int ellipsis = -1; + size_t i = 0; + + if (s[0] == ':') { + if (s[1] != ':') { + return MakeParseError(error_prefix, raw_for_error, + "each colon-separated field must have a digit"); + } + ellipsis = 0; + i = 2; + } + + while (i < s.size()) { + size_t seg_start = i; + int hex_digits = 0; + bool hit_dot = false; + + while (i < s.size()) { + char c = s[i]; + if (absl::ascii_isxdigit(static_cast(c))) { + if (hex_digits == 4) { + return MakeParseError(error_prefix, raw_for_error, + "IPv6 field has too many digits"); + } + ++hex_digits; + ++i; + } else if (c == ':') { + break; + } else if (c == '.') { + hit_dot = true; + break; + } else { + return MakeParseError(error_prefix, raw_for_error, + "unexpected character"); + } + } + + if (hit_dot) { + if (seg_start == 0) { + return MakeParseError(error_prefix, raw_for_error, + "unexpected IPv4 prefix in IPv6 address"); + } + if (count > 6 || (ellipsis >= 0 && count >= 6)) { + return MakeParseError(error_prefix, raw_for_error, "address too long"); + } + CEL_ASSIGN_OR_RETURN(uint32_t v4, ParseIpv4(s.substr(seg_start), + error_prefix, raw_for_error)); + hextets[count++] = static_cast((v4 >> 16) & 0xFFFF); + hextets[count++] = static_cast(v4 & 0xFFFF); + break; + } + + if (hex_digits == 0) { + // Encountered ':' immediately after consuming the previous ':' -> "::". + if (ellipsis >= 0) { + return MakeParseError(error_prefix, raw_for_error, + "multiple :: in IPv6 address"); + } + ellipsis = count; + ++i; + continue; + } + + if (count >= 8) { + return MakeParseError(error_prefix, raw_for_error, "address too long"); + } + uint16_t val = 0; + const bool ok = absl::SimpleHexAtoi(s.substr(seg_start, hex_digits), &val); + ABSL_DCHECK(ok); + hextets[count++] = val; + + if (i == s.size()) { + break; + } + ++i; + if (i == s.size()) { + return MakeParseError(error_prefix, raw_for_error, "trailing colon"); + } + } + + std::array full{}; + if (ellipsis < 0) { + if (count != 8) { + return MakeParseError(error_prefix, raw_for_error, "address too short"); + } + full = hextets; + } else { + if (count >= 8) { + return MakeParseError(error_prefix, raw_for_error, + "address too long for :: compression"); + } + int zeros = 8 - count; + for (int idx = 0; idx < ellipsis; ++idx) { + full[idx] = hextets[idx]; + } + for (int idx = ellipsis; idx < count; ++idx) { + full[idx + zeros] = hextets[idx]; + } + } + + uint64_t hi_val = (static_cast(full[0]) << 48) | + (static_cast(full[1]) << 32) | + (static_cast(full[2]) << 16) | + static_cast(full[3]); + uint64_t lo_val = (static_cast(full[4]) << 48) | + (static_cast(full[5]) << 32) | + (static_cast(full[6]) << 16) | + static_cast(full[7]); + return IpAddr{6, hi_val, lo_val}; +} + +absl::StatusOr ParseIpWithOptionalZone( + absl::string_view raw, absl::string_view error_prefix, + absl::string_view raw_for_error) { + if (raw.empty()) { + return MakeParseError(error_prefix, raw_for_error, "unable to parse IP"); + } + if (absl::StrContains(raw, ':')) { + absl::string_view ip_part = raw; + bool has_zone = false; + size_t pct_idx = raw.find('%'); + if (pct_idx != absl::string_view::npos) { + ip_part = raw.substr(0, pct_idx); + absl::string_view zone = raw.substr(pct_idx + 1); + if (zone.empty()) { + return MakeParseError(error_prefix, raw_for_error, + "zone must be non-empty"); + } + has_zone = true; + } + CEL_ASSIGN_OR_RETURN(IpAddr ip, + ParseIpv6Body(ip_part, error_prefix, raw_for_error)); + return ParsedIpWithZone{ip, has_zone}; + } + if (absl::StrContains(raw, '.')) { + CEL_ASSIGN_OR_RETURN(uint32_t v4, + ParseIpv4(raw, error_prefix, raw_for_error)); + return ParsedIpWithZone{IpAddr{4, 0, static_cast(v4)}, false}; + } + return MakeParseError(error_prefix, raw_for_error, "unable to parse IP"); +} + +absl::StatusOr ParsePrefixLength(absl::string_view prefix_part, + int max_bits, + absl::string_view raw_for_error) { + if (prefix_part.empty()) { + return MakeParseError("CIDR", raw_for_error, "empty prefix"); + } + for (char c : prefix_part) { + if (!absl::ascii_isdigit(static_cast(c))) { + return MakeParseError("CIDR", raw_for_error, "invalid prefix length"); + } + } + if (prefix_part.size() > 1 && prefix_part[0] == '0') { + return MakeParseError("CIDR", raw_for_error, + "prefix length has leading zero"); + } + if (prefix_part.size() > 3) { + return MakeParseError("CIDR", raw_for_error, "prefix length out of range"); + } + int value = 0; + if (!absl::SimpleAtoi(prefix_part, &value) || value < 0 || value > max_bits) { + return MakeParseError("CIDR", raw_for_error, "prefix length out of range"); + } + return value; +} + +} // namespace + +bool IpAddr::IsUnspecified() const { + if (family == 4) { + return lo == 0; + } + return hi == 0 && lo == 0; +} + +bool IpAddr::IsLoopback() const { + if (family == 4) { + return ((lo >> 24) & 0xFF) == 127; + } + return hi == 0 && lo == 1; +} + +bool IpAddr::IsLinkLocalUnicast() const { + if (family == 4) { + return ((lo >> 24) & 0xFF) == 169 && ((lo >> 16) & 0xFF) == 254; + } + return ((hi >> 56) & 0xFF) == 0xFE && ((hi >> 48) & 0xC0) == 0x80; +} + +bool IpAddr::IsLinkLocalMulticast() const { + if (family == 4) { + return ((lo >> 24) & 0xFF) == 224 && ((lo >> 16) & 0xFF) == 0 && + ((lo >> 8) & 0xFF) == 0; + } + return ((hi >> 56) & 0xFF) == 0xFF && ((hi >> 48) & 0x0F) == 0x02; +} + +bool IpAddr::IsMulticast() const { + if (family == 4) { + return ((lo >> 24) & 0xF0) == 0xE0; + } + return ((hi >> 56) & 0xFF) == 0xFF; +} + +bool IpAddr::IsGlobalUnicast() const { + if (family == 4 && lo == 0xFFFFFFFFULL) { + return false; + } + return !IsUnspecified() && !IsLoopback() && !IsMulticast() && + !IsLinkLocalUnicast(); +} + +IpAddr IpAddr::Mask(int prefix_length) const { + if (family == 4) { + return IpAddr{4, 0, lo & Ipv4Mask(prefix_length)}; + } + return IpAddr{6, hi & Ipv6HiMask(prefix_length), + lo & Ipv6LoMask(prefix_length)}; +} + +bool IpAddr::MatchesPrefix(const IpAddr& other, int prefix_length) const { + if (family != other.family) { + return false; + } + if (family == 4) { + return ((lo ^ other.lo) & Ipv4Mask(prefix_length)) == 0; + } + return ((hi ^ other.hi) & Ipv6HiMask(prefix_length)) == 0 && + ((lo ^ other.lo) & Ipv6LoMask(prefix_length)) == 0; +} + +std::string IpAddr::ToCanonicalString() const { + if (family == 4) { + return absl::StrFormat("%u.%u.%u.%u", + static_cast((lo >> 24) & 0xFF), + static_cast((lo >> 16) & 0xFF), + static_cast((lo >> 8) & 0xFF), + static_cast(lo & 0xFF)); + } + + std::array h = { + static_cast((hi >> 48) & 0xFFFF), + static_cast((hi >> 32) & 0xFFFF), + static_cast((hi >> 16) & 0xFFFF), + static_cast(hi & 0xFFFF), + static_cast((lo >> 48) & 0xFFFF), + static_cast((lo >> 32) & 0xFFFF), + static_cast((lo >> 16) & 0xFFFF), + static_cast(lo & 0xFFFF), + }; + + int best_start = -1; + int best_len = 0; + int cur_start = -1; + int cur_len = 0; + for (int i = 0; i < 8; ++i) { + if (h[i] == 0) { + if (cur_start < 0) { + cur_start = i; + cur_len = 1; + } else { + ++cur_len; + } + if (cur_len > best_len && cur_len >= 2) { + best_start = cur_start; + best_len = cur_len; + } + } else { + cur_start = -1; + cur_len = 0; + } + } + + std::string out; + out.reserve(39); + for (int i = 0; i < 8; ++i) { + if (i == best_start) { + out.append("::"); + i += best_len - 1; + continue; + } + if (i > 0 && !(best_start >= 0 && i == best_start + best_len)) { + out.push_back(':'); + } + absl::StrAppendFormat(&out, "%x", static_cast(h[i])); + } + return out; +} + +std::string CidrPrefix::ToCanonicalString() const { + return absl::StrCat(ip.ToCanonicalString(), "/", prefix_length); +} + +absl::StatusOr ParseIp(absl::string_view raw) { + CEL_ASSIGN_OR_RETURN(ParsedIpWithZone parsed, + ParseIpWithOptionalZone(raw, "IP Address", raw)); + if (parsed.has_zone) { + return absl::InvalidArgumentError( + absl::StrCat("IP address '", raw, "' with zone value is not allowed")); + } + if (parsed.ip.Is4In6()) { + return absl::InvalidArgumentError( + absl::StrCat("IPv4-mapped IPv6 address '", raw, "' is not allowed")); + } + return parsed.ip; +} + +absl::StatusOr ParseCidr(absl::string_view raw) { + size_t slash = raw.rfind('/'); + if (slash == absl::string_view::npos) { + return MakeParseError("CIDR", raw, "no '/'"); + } + absl::string_view ip_part = raw.substr(0, slash); + absl::string_view prefix_part = raw.substr(slash + 1); + + CEL_ASSIGN_OR_RETURN(ParsedIpWithZone parsed, + ParseIpWithOptionalZone(ip_part, "CIDR", raw)); + + int max_bits = parsed.ip.family == 4 ? 32 : 128; + CEL_ASSIGN_OR_RETURN(int prefix_len, + ParsePrefixLength(prefix_part, max_bits, raw)); + + if (parsed.has_zone) { + return absl::InvalidArgumentError( + absl::StrCat("CIDR '", raw, "' with zone value is not allowed")); + } + if (parsed.ip.Is4In6()) { + return absl::InvalidArgumentError( + absl::StrCat("IPv4-mapped IPv6 address '", raw, "' is not allowed")); + } + return CidrPrefix{parsed.ip, prefix_len}; +} + +} // namespace cel::internal diff --git a/internal/network_addr.h b/internal/network_addr.h new file mode 100644 index 000000000..47df92591 --- /dev/null +++ b/internal/network_addr.h @@ -0,0 +1,102 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Portable IPv4/IPv6 address and CIDR prefix representation, strict parsing, +// and RFC 5952 canonical formatting matching Go's `net/netip` and CEL's +// `cel.lib.ext.network` extension semantics. + +#ifndef THIRD_PARTY_CEL_CPP_INTERNAL_NETWORK_ADDR_H_ +#define THIRD_PARTY_CEL_CPP_INTERNAL_NETWORK_ADDR_H_ + +#include +#include + +#include "absl/status/statusor.h" +#include "absl/strings/string_view.h" + +namespace cel::internal { + +// Value representation of an IPv4 or IPv6 address in network byte order +// (`family == 4` stores the 32-bit address in the low 32 bits of `lo`; +// `family == 6` stores the 128-bit address across `hi` and `lo`). +struct IpAddr { + uint8_t family = 4; // 4 or 6 + uint64_t hi = 0; + uint64_t lo = 0; + + bool Is4In6() const { return family == 6 && hi == 0 && (lo >> 32) == 0xFFFF; } + + int64_t Family() const { return static_cast(family); } + + bool IsUnspecified() const; + bool IsLoopback() const; + bool IsLinkLocalUnicast() const; + bool IsLinkLocalMulticast() const; + bool IsMulticast() const; + bool IsGlobalUnicast() const; + + IpAddr Mask(int prefix_length) const; + bool MatchesPrefix(const IpAddr& other, int prefix_length) const; + + // Formats IPv4 dotted-decimal or RFC 5952 canonical IPv6 text. + std::string ToCanonicalString() const; + + bool operator==(const IpAddr& other) const { + return family == other.family && hi == other.hi && lo == other.lo; + } + + bool operator!=(const IpAddr& other) const { return !(*this == other); } +}; + +// Value representation of a CIDR prefix (`ip/prefix_length`), preserving any +// unmasked host bits in `ip` to match Go `netip.Prefix`. +struct CidrPrefix { + IpAddr ip; + int prefix_length = 0; + + CidrPrefix Masked() const { + return CidrPrefix{ip.Mask(prefix_length), prefix_length}; + } + + bool IsMask() const { return ip == ip.Mask(prefix_length); } + + bool ContainsIp(const IpAddr& other) const { + return ip.MatchesPrefix(other, prefix_length); + } + + bool ContainsCidr(const CidrPrefix& child) const { + return ip.family == child.ip.family && + prefix_length <= child.prefix_length && ContainsIp(child.ip); + } + + std::string ToCanonicalString() const; + + bool operator==(const CidrPrefix& other) const { + return prefix_length == other.prefix_length && ip == other.ip; + } + + bool operator!=(const CidrPrefix& other) const { return !(*this == other); } +}; + +// Strictly parses an IPv4 or IPv6 address, rejecting leading zeros, zone +// identifiers, and IPv4-mapped IPv6 addresses (`::ffff:0:0/96`). +absl::StatusOr ParseIp(absl::string_view raw); + +// Strictly parses a CIDR prefix (`addr/prefix_length`), rejecting leading +// zeros, zone identifiers, and IPv4-mapped IPv6 addresses (`::ffff:0:0/96`). +absl::StatusOr ParseCidr(absl::string_view raw); + +} // namespace cel::internal + +#endif // THIRD_PARTY_CEL_CPP_INTERNAL_NETWORK_ADDR_H_ diff --git a/internal/network_addr_test.cc b/internal/network_addr_test.cc new file mode 100644 index 000000000..0d563b5e0 --- /dev/null +++ b/internal/network_addr_test.cc @@ -0,0 +1,285 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "internal/network_addr.h" + +#include +#include +#include + +#include "absl/log/absl_check.h" +#include "absl/status/status.h" +#include "absl/status/status_matchers.h" +#include "absl/status/statusor.h" +#include "absl/strings/string_view.h" +#include "internal/testing.h" + +namespace cel::internal { +namespace { + +using ::absl_testing::IsOkAndHolds; +using ::absl_testing::StatusIs; +using ::testing::AllOf; +using ::testing::HasSubstr; +using ::testing::Not; +using ::testing::Property; + +IpAddr MustParseIp(absl::string_view raw) { + absl::StatusOr parsed = ParseIp(raw); + ABSL_CHECK_OK(parsed); + return *parsed; +} + +CidrPrefix MustParseCidr(absl::string_view raw) { + absl::StatusOr parsed = ParseCidr(raw); + ABSL_CHECK_OK(parsed); + return *parsed; +} + +TEST(NetworkAddrTest, ParseIpv4AndCanonicalFormatting) { + ASSERT_OK_AND_ASSIGN(IpAddr addr, ParseIp("192.168.0.1")); + EXPECT_EQ(addr.Family(), 4); + EXPECT_EQ(addr.ToCanonicalString(), "192.168.0.1"); + EXPECT_FALSE(addr.Is4In6()); + + ASSERT_OK_AND_ASSIGN(IpAddr zero, ParseIp("0.0.0.0")); + EXPECT_EQ(zero.ToCanonicalString(), "0.0.0.0"); + EXPECT_NE(addr, zero); + EXPECT_EQ(addr, addr); +} + +TEST(NetworkAddrTest, ParseIpv6AndRfc5952Formatting) { + const std::vector> cases = { + {"2001:0DB8:0000:0000:0008:0800:200C:417A", "2001:db8::8:800:200c:417a"}, + {"2001:db8:0:1:1:1:1:1", "2001:db8:0:1:1:1:1:1"}, + {"2001:0:0:1:0:0:0:1", "2001:0:0:1::1"}, + {"2001:db8:0:0:1:0:0:1", "2001:db8::1:0:0:1"}, + {"2001:0:0:1:0:0:1:1", "2001::1:0:0:1:1"}, + {"0:0:0:0:0:0:0:0", "::"}, + {"0:0:0:0:0:0:0:1", "::1"}, + {"1::", "1::"}, + {"1:2:3:4:5:6:7::", "1:2:3:4:5:6:7:0"}, + {"::2:3:4:5:6:7:8", "0:2:3:4:5:6:7:8"}, + {"64:ff9b::192.0.2.1", "64:ff9b::c000:201"}, + {"::192.168.0.1", "::c0a8:1"}, + {"::0.0.0.0", "::"}, + {"::0.0.0.1", "::1"}, + {"::ffff:0:192.168.0.1", "::ffff:0:c0a8:1"}, + {"1:2:3:4:5:6:1.2.3.4", "1:2:3:4:5:6:102:304"}, + {"1:2:3:4:5::1.2.3.4", "1:2:3:4:5:0:102:304"}, + }; + for (const auto& tc : cases) { + EXPECT_THAT( + ParseIp(tc.first), + IsOkAndHolds(AllOf(Property(&IpAddr::Family, 6), + Property(&IpAddr::ToCanonicalString, tc.second)))) + << "Input: " << tc.first; + } +} + +TEST(NetworkAddrTest, IpPredicates) { + // Unspecified. + EXPECT_TRUE(MustParseIp("0.0.0.0").IsUnspecified()); + EXPECT_FALSE(MustParseIp("127.0.0.1").IsUnspecified()); + EXPECT_TRUE(MustParseIp("::").IsUnspecified()); + EXPECT_FALSE(MustParseIp("::1").IsUnspecified()); + + // Loopback. + EXPECT_TRUE(MustParseIp("127.0.0.0").IsLoopback()); + EXPECT_TRUE(MustParseIp("127.0.0.1").IsLoopback()); + EXPECT_TRUE(MustParseIp("127.255.255.255").IsLoopback()); + EXPECT_FALSE(MustParseIp("128.0.0.1").IsLoopback()); + EXPECT_TRUE(MustParseIp("::1").IsLoopback()); + EXPECT_FALSE(MustParseIp("::2").IsLoopback()); + + // Link-local unicast. + EXPECT_TRUE(MustParseIp("169.254.0.0").IsLinkLocalUnicast()); + EXPECT_TRUE(MustParseIp("169.254.169.254").IsLinkLocalUnicast()); + EXPECT_TRUE(MustParseIp("169.254.255.255").IsLinkLocalUnicast()); + EXPECT_FALSE(MustParseIp("192.168.0.1").IsLinkLocalUnicast()); + EXPECT_TRUE(MustParseIp("fe80::1").IsLinkLocalUnicast()); + EXPECT_TRUE(MustParseIp("febf:ffff::1").IsLinkLocalUnicast()); + EXPECT_FALSE(MustParseIp("fec0::1").IsLinkLocalUnicast()); + EXPECT_FALSE(MustParseIp("fd80::1").IsLinkLocalUnicast()); + + // Link-local multicast & multicast. + EXPECT_TRUE(MustParseIp("224.0.0.0").IsLinkLocalMulticast()); + EXPECT_TRUE(MustParseIp("224.0.0.255").IsLinkLocalMulticast()); + EXPECT_FALSE(MustParseIp("224.0.1.0").IsLinkLocalMulticast()); + EXPECT_TRUE(MustParseIp("224.0.1.0").IsMulticast()); + EXPECT_TRUE(MustParseIp("ff02::1").IsLinkLocalMulticast()); + EXPECT_TRUE(MustParseIp("ff12::1").IsLinkLocalMulticast()); + EXPECT_TRUE(MustParseIp("ff32::1").IsLinkLocalMulticast()); + EXPECT_FALSE(MustParseIp("ff01::1").IsLinkLocalMulticast()); + EXPECT_TRUE(MustParseIp("ff01::1").IsMulticast()); + EXPECT_FALSE(MustParseIp("fd00::1").IsLinkLocalMulticast()); + + // Global unicast. + EXPECT_TRUE(MustParseIp("192.168.0.1").IsGlobalUnicast()); + EXPECT_TRUE(MustParseIp("8.8.8.8").IsGlobalUnicast()); + EXPECT_TRUE(MustParseIp("0.1.2.3").IsGlobalUnicast()); + EXPECT_FALSE(MustParseIp("255.255.255.255").IsGlobalUnicast()); + EXPECT_FALSE(MustParseIp("224.0.0.1").IsGlobalUnicast()); + EXPECT_FALSE(MustParseIp("224.0.1.0").IsGlobalUnicast()); + EXPECT_FALSE(MustParseIp("239.0.0.1").IsGlobalUnicast()); + EXPECT_FALSE(MustParseIp("169.254.1.1").IsGlobalUnicast()); + EXPECT_FALSE(MustParseIp("127.0.0.1").IsGlobalUnicast()); + EXPECT_FALSE(MustParseIp("0.0.0.0").IsGlobalUnicast()); + EXPECT_TRUE(MustParseIp("2001:db8::abcd").IsGlobalUnicast()); + EXPECT_TRUE(MustParseIp("fec0::1").IsGlobalUnicast()); + EXPECT_TRUE(MustParseIp("fc00::1").IsGlobalUnicast()); + EXPECT_FALSE(MustParseIp("ff00::1").IsGlobalUnicast()); + EXPECT_FALSE(MustParseIp("ff01::1").IsGlobalUnicast()); + EXPECT_FALSE(MustParseIp("::1").IsGlobalUnicast()); + EXPECT_FALSE(MustParseIp("::").IsGlobalUnicast()); + EXPECT_FALSE(MustParseIp("fe80::1").IsGlobalUnicast()); +} + +TEST(NetworkAddrTest, CidrMaskAndContainment) { + CidrPrefix unmasked_v4 = MustParseCidr("192.168.0.1/24"); + EXPECT_EQ(unmasked_v4.ToCanonicalString(), "192.168.0.1/24"); + EXPECT_FALSE(unmasked_v4.IsMask()); + EXPECT_EQ(unmasked_v4.Masked(), MustParseCidr("192.168.0.0/24")); + EXPECT_TRUE(unmasked_v4.Masked().IsMask()); + EXPECT_NE(unmasked_v4, unmasked_v4.Masked()); + EXPECT_EQ(MustParseCidr("192.168.0.1/32").Masked(), + MustParseCidr("192.168.0.1/32")); + EXPECT_EQ(MustParseCidr("192.168.0.1/0").Masked(), + MustParseCidr("0.0.0.0/0")); + EXPECT_EQ(MustParseIp("192.168.0.1").Mask(-1), MustParseIp("0.0.0.0")); + + // IPv6 masks across 0, (0,64), 64, (64,128), 128. + EXPECT_EQ(MustParseCidr("2001:db8::1/0").Masked(), MustParseCidr("::/0")); + EXPECT_EQ(MustParseIp("2001:db8::1").Mask(-1), MustParseIp("::")); + EXPECT_EQ(MustParseCidr("2001:db8::1/32").Masked(), + MustParseCidr("2001:db8::/32")); + EXPECT_EQ(MustParseCidr("2001:db8:0:1::1/64").Masked(), + MustParseCidr("2001:db8:0:1::/64")); + EXPECT_EQ(MustParseCidr("2001:db8::1:2/96").Masked(), + MustParseCidr("2001:db8::/96")); + EXPECT_EQ(MustParseCidr("2001:db8::1:2/112").Masked(), + MustParseCidr("2001:db8::1:0/112")); + EXPECT_FALSE(MustParseCidr("2001:db8::1:2/112").IsMask()); + EXPECT_TRUE(MustParseCidr("2001:db8::1:0/112").IsMask()); + EXPECT_EQ(MustParseCidr("2001:db8::1/128").Masked(), + MustParseCidr("2001:db8::1/128")); + + // IP and CIDR containment (including unmasked host bits and cross-family). + EXPECT_TRUE( + MustParseCidr("192.168.0.1/24").ContainsIp(MustParseIp("192.168.0.0"))); + EXPECT_TRUE( + MustParseCidr("192.168.0.0/24").ContainsIp(MustParseIp("192.168.0.255"))); + EXPECT_FALSE( + MustParseCidr("192.168.0.0/24").ContainsIp(MustParseIp("192.168.1.0"))); + EXPECT_FALSE( + MustParseCidr("192.168.0.0/24").ContainsIp(MustParseIp("2001:db8::1"))); + EXPECT_TRUE(MustParseCidr("2001:db8::1:0/112") + .ContainsIp(MustParseIp("2001:db8::1:ffff"))); + EXPECT_FALSE(MustParseCidr("2001:db8::1:0/112") + .ContainsIp(MustParseIp("2001:db8::2:0"))); + EXPECT_TRUE(MustParseCidr("192.168.1.5/24") + .ContainsCidr(MustParseCidr("192.168.1.130/25"))); + EXPECT_TRUE(MustParseCidr("192.168.1.5/24") + .ContainsCidr(MustParseCidr("192.168.1.99/24"))); + EXPECT_FALSE(MustParseCidr("192.168.0.0/24") + .ContainsCidr(MustParseCidr("192.168.0.0/23"))); + EXPECT_TRUE(MustParseCidr("2001:db8::/96") + .ContainsCidr(MustParseCidr("2001:db8::/112"))); + EXPECT_FALSE(MustParseCidr("2001:db8::/32") + .ContainsCidr(MustParseCidr("192.168.0.0/24"))); +} + +TEST(NetworkAddrTest, ParseIpErrors) { + const std::vector> bad_ips = { + {"", "unable to parse IP"}, + {"1", "unable to parse IP"}, + {"1..2.3", "must have at least one digit"}, + {".1.2.3", "must have at least one digit"}, + {"1.2.3.", "IPv4 address too short"}, + {"1.2.3", "IPv4 address too short"}, + {"192.168.0.a", "unexpected character"}, + {"192.168.0.1%eth0", "unexpected character"}, + {"192.168.0.1.0", "IPv4 address too long"}, + {"01.2.3.4", "leading zero"}, + {"256.0.0.1", "value >255"}, + {":%eth0", "address too short"}, + {"2001:0db80::1", "too many digits"}, + {"2001:db8::g", "unexpected character"}, + {"2001:db8:::68", "multiple ::"}, + {":::", "multiple ::"}, + {":1::", "colon-separated"}, + {"::1:", "trailing colon"}, + {":1", "colon-separated"}, + {"1:", "trailing colon"}, + {"192.168.0.1:80", "unexpected IPv4 prefix"}, + {"1.2.3.4::", "unexpected IPv4 prefix"}, + {"::1.2.3.4:5", "unexpected character"}, + {"1:2:3:4:5:6:7:1.2.3.4", "address too long"}, + {"1:2:3:4:5:6::1.2.3.4", "address too long"}, + {"1:2:3:4:5:1.2.3.4", "address too short"}, + {"2001:db8::192.168.0.01", "leading zero"}, + {"fe80::192.168.0.1%eth0", "zone value is not allowed"}, + {"1:2:3:4:5:6:7:8:9", "address too long"}, + {"1:2:3:4:5:6:7", "address too short"}, + {"2001:db8:1", "address too short"}, + {"1:2:3:4:5:6:7:8::", "address too long for :: compression"}, + {"::1:2:3:4:5:6:7:8", "address too long for :: compression"}, + {"fe80::1%en0", "zone value is not allowed"}, + {"fe80::1%", "zone must be non-empty"}, + {"::ffff:192.168.0.1", "IPv4-mapped IPv6 address"}, + {"::ffff:c0a8:1", "IPv4-mapped IPv6 address"}, + }; + for (const auto& tc : bad_ips) { + EXPECT_THAT(ParseIp(tc.first), StatusIs(absl::StatusCode::kInvalidArgument, + HasSubstr(tc.second))) + << "Input: " << tc.first; + } +} + +TEST(NetworkAddrTest, ParseCidrErrorsAndNoDoubleWrapping) { + EXPECT_THAT( + ParseCidr("invalid/24"), + StatusIs(absl::StatusCode::kInvalidArgument, + AllOf(HasSubstr("CIDR 'invalid/24' parse error during " + "conversion from string: unable to parse IP"), + Not(HasSubstr("CIDR 'invalid' parse error"))))); + + const std::vector> bad_cidrs = { + {"192.168.0.0", "no '/'"}, + {":/64", "address too short"}, + {"999.0.0.1/24", "value >255"}, + {"192.168.0.0/", "empty prefix"}, + {"10.0.0.0/00", "leading zero"}, + {"192.168.0.0/08", "leading zero"}, + {"2001:db8::/1000", "out of range"}, + {"10.0.0.0/-1", "invalid prefix length"}, + {"10.0.0.0/+24", "invalid prefix length"}, + {"10.0.0.0/abcd", "invalid prefix length"}, + {"fe80::1/64%en0", "invalid prefix length"}, + {"192.168.0.1%eth0/24", "unexpected character"}, + {"192.168.0.0/33", "out of range"}, + {"2001:db8::/129", "out of range"}, + {"fe80::1%en0/64", "zone value is not allowed"}, + {"::ffff:192.168.0.1/24", "IPv4-mapped IPv6 address"}, + }; + for (const auto& tc : bad_cidrs) { + EXPECT_THAT( + ParseCidr(tc.first), + StatusIs(absl::StatusCode::kInvalidArgument, HasSubstr(tc.second))) + << "Input: " << tc.first; + } +} + +} // namespace +} // namespace cel::internal