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