From 267c472e4c1f91f1a8b9d298521283c29b55c6ce Mon Sep 17 00:00:00 2001 From: Muhammad Askri Date: Mon, 16 Nov 2026 19:52:58 -0800 Subject: [PATCH] Add `//extensions:network_ext_decls` providing the compile-time declarations and AST literal validator for the CEL network extension library (`cel.lib.ext.network`). Exposes `kNetworkExtensionLatestVersion`, `NetIpType()`, `NetCidrType()`, `NetworkCheckerLibrary()`, `NetworkCompilerLibrary()`, and `NetworkValidator()` (`cel.validator.network`) with parity against `cel-go`'s `ext.Network()` and `cel-spec`. PiperOrigin-RevId: 1023333097 --- extensions/BUILD | 48 +++ extensions/network_ext_decls.cc | 197 +++++++++++ extensions/network_ext_decls.h | 89 +++++ extensions/network_ext_decls_test.cc | 188 +++++++++++ internal/BUILD | 29 ++ internal/network_addr.cc | 467 +++++++++++++++++++++++++++ internal/network_addr.h | 102 ++++++ internal/network_addr_test.cc | 285 ++++++++++++++++ 8 files changed, 1405 insertions(+) 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 internal/network_addr.cc create mode 100644 internal/network_addr.h create mode 100644 internal/network_addr_test.cc diff --git a/extensions/BUILD b/extensions/BUILD index d9f8d7684..e75819d5e 100644 --- a/extensions/BUILD +++ b/extensions/BUILD @@ -961,3 +961,51 @@ 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", + ], +) 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/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