From d361e003486f174deb9c3d8c26ffa7a91b5cb56d Mon Sep 17 00:00:00 2001 From: Muhammad Askri Date: Wed, 18 Nov 2026 14:40:41 -0800 Subject: [PATCH] Expose the public `CelNetworkExtensions` bundle and `CelExtensions.network()` factory methods across CEL Java, register `"network"` in `CelEnvironment` for YAML and policy environments, document the `network` extension and supported versions (`0` and `1`), and add precompiled Android lite runtime evaluation coverage. PiperOrigin-RevId: 1024996983 --- .../java/dev/cel/bundle/CelEnvironment.java | 55 +- .../dev/cel/bundle/CelEnvironmentTest.java | 5 +- .../cel/common/types/DefaultTypeProvider.java | 8 + extensions/BUILD.bazel | 32 ++ .../main/java/dev/cel/extensions/BUILD.bazel | 104 ++++ .../main/java/dev/cel/extensions/CelCidr.java | 174 +++++++ .../dev/cel/extensions/CelExtensions.java | 43 ++ .../main/java/dev/cel/extensions/CelIp.java | 462 +++++++++++++++++ .../extensions/CelNetworkCompilerLibrary.java | 300 +++++++++++ .../cel/extensions/CelNetworkExtensions.java | 159 ++++++ .../extensions/CelNetworkRuntimeLibrary.java | 212 ++++++++ .../main/java/dev/cel/extensions/README.md | 69 +++ .../test/java/dev/cel/extensions/BUILD.bazel | 8 + .../dev/cel/extensions/CelExtensionsTest.java | 17 + .../extensions/CelNetworkExtensionsTest.java | 489 ++++++++++++++++++ .../cel/extensions/CelNetworkTypesTest.java | 289 +++++++++++ .../src/test/java/dev/cel/runtime/BUILD.bazel | 1 + .../runtime/CelLiteRuntimeAndroidTest.java | 15 + .../java/dev/cel/testing/compiled/BUILD.bazel | 7 + .../resources/environment/all_extensions.yaml | 1 + 20 files changed, 2420 insertions(+), 30 deletions(-) create mode 100644 extensions/src/main/java/dev/cel/extensions/CelCidr.java create mode 100644 extensions/src/main/java/dev/cel/extensions/CelIp.java create mode 100644 extensions/src/main/java/dev/cel/extensions/CelNetworkCompilerLibrary.java create mode 100644 extensions/src/main/java/dev/cel/extensions/CelNetworkExtensions.java create mode 100644 extensions/src/main/java/dev/cel/extensions/CelNetworkRuntimeLibrary.java create mode 100644 extensions/src/test/java/dev/cel/extensions/CelNetworkExtensionsTest.java create mode 100644 extensions/src/test/java/dev/cel/extensions/CelNetworkTypesTest.java diff --git a/bundle/src/main/java/dev/cel/bundle/CelEnvironment.java b/bundle/src/main/java/dev/cel/bundle/CelEnvironment.java index 7ef2edad4..931d831eb 100644 --- a/bundle/src/main/java/dev/cel/bundle/CelEnvironment.java +++ b/bundle/src/main/java/dev/cel/bundle/CelEnvironment.java @@ -73,17 +73,19 @@ public abstract class CelEnvironment { @VisibleForTesting static final ImmutableMap CEL_EXTENSION_CONFIG_MAP = - ImmutableMap.of( - "bindings", CanonicalCelExtension.BINDINGS, - "encoders", CanonicalCelExtension.ENCODERS, - "lists", CanonicalCelExtension.LISTS, - "math", CanonicalCelExtension.MATH, - "optional", CanonicalCelExtension.OPTIONAL, - "protos", CanonicalCelExtension.PROTOS, - "regex", CanonicalCelExtension.REGEX, - "sets", CanonicalCelExtension.SETS, - "strings", CanonicalCelExtension.STRINGS, - "two-var-comprehensions", CanonicalCelExtension.COMPREHENSIONS); + ImmutableMap.builder() + .put("bindings", CanonicalCelExtension.BINDINGS) + .put("encoders", CanonicalCelExtension.ENCODERS) + .put("lists", CanonicalCelExtension.LISTS) + .put("math", CanonicalCelExtension.MATH) + .put("network", CanonicalCelExtension.NETWORK) + .put("optional", CanonicalCelExtension.OPTIONAL) + .put("protos", CanonicalCelExtension.PROTOS) + .put("regex", CanonicalCelExtension.REGEX) + .put("sets", CanonicalCelExtension.SETS) + .put("strings", CanonicalCelExtension.STRINGS) + .put("two-var-comprehensions", CanonicalCelExtension.COMPREHENSIONS) + .buildOrThrow(); private static final ImmutableMap> LIMIT_HANDLERS = ImmutableMap.of( @@ -279,10 +281,9 @@ public CelCompiler extend(CelCompiler celCompiler, CelOptions celOptions) applyStandardLibrarySubset(compilerBuilder); contextVariable() - .ifPresent( - cv -> - compilerBuilder.addProtoTypeMasks( - ProtoTypeMask.ofAllFields(cv.typeName()).withFieldsAsVariableDeclarations())); + .ifPresent(cv -> + compilerBuilder.addProtoTypeMasks( + ProtoTypeMask.ofAllFields(cv.typeName()).withFieldsAsVariableDeclarations())); return compilerBuilder.build(); } catch (RuntimeException e) { @@ -392,9 +393,8 @@ private void applyStandardLibrarySubset(CelCompilerBuilder compilerBuilder) { .setStandardEnvironmentEnabled(false) .setStandardDeclarations( CelStandardDeclarations.newBuilder() - .filterFunctions( - (function, overload) -> - FunctionSelector.matchesAny(function, overload, includedFunctions)) + .filterFunctions((function, overload) -> + FunctionSelector.matchesAny(function, overload, includedFunctions)) .build()); } else if (!librarySubset.excludedFunctions().isEmpty()) { ImmutableSet excludedFunctions = librarySubset.excludedFunctions(); @@ -402,9 +402,8 @@ private void applyStandardLibrarySubset(CelCompilerBuilder compilerBuilder) { .setStandardEnvironmentEnabled(false) .setStandardDeclarations( CelStandardDeclarations.newBuilder() - .filterFunctions( - (function, overload) -> - !FunctionSelector.matchesAny(function, overload, excludedFunctions)) + .filterFunctions((function, overload) -> + !FunctionSelector.matchesAny(function, overload, excludedFunctions)) .build()); } } @@ -655,10 +654,7 @@ private CelOverloadDecl toCelOverloadDecl(Function> ty target() .ifPresent( - t -> - builder - .setIsInstanceFunction(true) - .addParameterTypes(t.toCelType(typeFinder))); + t -> builder.setIsInstanceFunction(true).addParameterTypes(t.toCelType(typeFinder))); for (TypeDecl type : arguments()) { builder.addParameterTypes(type.toCelType(typeFinder)); @@ -823,16 +819,14 @@ private CelType toCelType(Function> typeFinder) { Optional builtinType = findCelTypeByName(name()); if (builtinType.isPresent()) { - checkArgument( - params().isEmpty(), "Type %s cannot have type parameters", name()); + checkArgument(params().isEmpty(), "Type %s cannot have type parameters", name()); return builtinType.get(); } CelType resolvedType = typeFinder .apply(name()) - .orElseThrow( - () -> new IllegalArgumentException("Undefined type name: " + name())); + .orElseThrow(() -> new IllegalArgumentException("Undefined type name: " + name())); if (!params().isEmpty()) { return resolvedType.withParameters( params().stream().map(p -> p.toCelType(typeFinder)).collect(toImmutableList())); @@ -1007,6 +1001,9 @@ enum CanonicalCelExtension { MATH( (options, version) -> CelExtensions.math(options, version), (options, version) -> CelExtensions.math(options, version)), + NETWORK( + (options, version) -> CelExtensions.network(version), + (options, version) -> CelExtensions.network(version)), OPTIONAL( (options, version) -> CelExtensions.optional(version), (options, version) -> CelExtensions.optional(version)), diff --git a/bundle/src/test/java/dev/cel/bundle/CelEnvironmentTest.java b/bundle/src/test/java/dev/cel/bundle/CelEnvironmentTest.java index 337fbbabb..e02fc4a03 100644 --- a/bundle/src/test/java/dev/cel/bundle/CelEnvironmentTest.java +++ b/bundle/src/test/java/dev/cel/bundle/CelEnvironmentTest.java @@ -91,6 +91,7 @@ public void extend_allExtensions() throws Exception { ExtensionConfig.latest("encoders"), ExtensionConfig.latest("lists"), ExtensionConfig.latest("math"), + ExtensionConfig.latest("network"), ExtensionConfig.latest("optional"), ExtensionConfig.latest("protos"), ExtensionConfig.latest("regex"), @@ -104,7 +105,9 @@ public void extend_allExtensions() throws Exception { CelAbstractSyntaxTree ast = cel.compile( "cel.bind(x, 10, math.greatest([1,x])) < int(' 11 '.trim()) &&" - + " optional.none().orValue(true) && [].flatten() == []") + + " optional.none().orValue(true) && [].flatten() == [] &&" + + " cidr('10.0.0.0/8').containsIP(ip('10.0.0.1')) &&" + + " type(ip('10.0.0.1')) == net.IP") .getAst(); boolean result = (boolean) cel.createProgram(ast).eval(); diff --git a/common/src/main/java/dev/cel/common/types/DefaultTypeProvider.java b/common/src/main/java/dev/cel/common/types/DefaultTypeProvider.java index 372a50e73..16bcd31df 100644 --- a/common/src/main/java/dev/cel/common/types/DefaultTypeProvider.java +++ b/common/src/main/java/dev/cel/common/types/DefaultTypeProvider.java @@ -50,6 +50,14 @@ private DefaultTypeProvider() { "optional_type", // TODO: Move to CelOptionalLibrary and register it on demand OptionalType.create(SimpleType.DYN)); + typeMapBuilder.put( + "net.IP", + // TODO: Move to CelNetworkExtensions and register it on demand + OpaqueType.create("net.IP")); + typeMapBuilder.put( + "net.CIDR", + // TODO: Move to CelNetworkExtensions and register it on demand + OpaqueType.create("net.CIDR")); this.commonTypes = typeMapBuilder.buildOrThrow(); } } diff --git a/extensions/BUILD.bazel b/extensions/BUILD.bazel index 1f9f792f0..1b019dcb4 100644 --- a/extensions/BUILD.bazel +++ b/extensions/BUILD.bazel @@ -197,3 +197,35 @@ cel_android_library( name = "regex_runtime_library_android", exports = ["//extensions/src/main/java/dev/cel/extensions:regex_runtime_library_android"], ) + +java_library( + name = "network", + exports = ["//extensions/src/main/java/dev/cel/extensions:network"], +) + +java_library( + name = "network_types", + exports = ["//extensions/src/main/java/dev/cel/extensions:network_types"], +) + +cel_android_library( + name = "network_types_android", + exports = ["//extensions/src/main/java/dev/cel/extensions:network_types_android"], +) + +java_library( + name = "network_compiler_library", + visibility = ["//:internal"], + exports = ["//extensions/src/main/java/dev/cel/extensions:network_compiler_library"], +) + +java_library( + name = "network_runtime_library", + visibility = ["//:internal"], + exports = ["//extensions/src/main/java/dev/cel/extensions:network_runtime_library"], +) + +cel_android_library( + name = "network_runtime_library_android", + exports = ["//extensions/src/main/java/dev/cel/extensions:network_runtime_library_android"], +) diff --git a/extensions/src/main/java/dev/cel/extensions/BUILD.bazel b/extensions/src/main/java/dev/cel/extensions/BUILD.bazel index 3cded5e17..1bdcb71a3 100644 --- a/extensions/src/main/java/dev/cel/extensions/BUILD.bazel +++ b/extensions/src/main/java/dev/cel/extensions/BUILD.bazel @@ -37,6 +37,7 @@ java_library( ":lists", ":math", ":native", + ":network", ":optional_library", ":protos", ":regex", @@ -599,6 +600,109 @@ cel_android_library( ], ) +java_library( + name = "network_types", + srcs = [ + "CelCidr.java", + "CelIp.java", + ], + tags = [ + ], + deps = [ + "//common/types", + "//common/values", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:org_jspecify_jspecify", + ], +) + +cel_android_library( + name = "network_types_android", + srcs = [ + "CelCidr.java", + "CelIp.java", + ], + tags = [ + ], + deps = [ + "//common/types:types_android", + "//common/values:values_android", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:org_jspecify_jspecify", + ], +) + +java_library( + name = "network", + srcs = ["CelNetworkExtensions.java"], + tags = [ + ], + exports = [":network_types"], + deps = [ + ":extension_library", + ":network_compiler_library", + ":network_runtime_library", + "//checker:checker_builder", + "//common:cel_function_decl", + "//common:cel_var_decl", + "//compiler:compiler_builder", + "//runtime", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "network_compiler_library", + srcs = ["CelNetworkCompilerLibrary.java"], + tags = [ + ], + deps = [ + ":extension_library", + ":network_types", + "//checker:checker_builder", + "//common:cel_function_decl", + "//common:cel_overload_decl", + "//common:cel_var_decl", + "//common/types", + "//compiler:compiler_builder", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +java_library( + name = "network_runtime_library", + srcs = ["CelNetworkRuntimeLibrary.java"], + tags = [ + ], + exports = [":network_types"], + deps = [ + ":network_types", + "//common/exceptions:bad_format", + "//runtime:function_binding", + "//runtime:lite_runtime", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven//:com_google_guava_guava", + ], +) + +cel_android_library( + name = "network_runtime_library_android", + srcs = ["CelNetworkRuntimeLibrary.java"], + tags = [ + ], + exports = [":network_types_android"], + deps = [ + ":network_types_android", + "//common/exceptions:bad_format", + "//runtime:function_binding_android", + "//runtime:lite_runtime_android", + "@maven//:com_google_errorprone_error_prone_annotations", + "@maven_android//:com_google_guava_guava", + ], +) + java_library( name = "comprehensions", srcs = ["CelComprehensionsExtensions.java"], diff --git a/extensions/src/main/java/dev/cel/extensions/CelCidr.java b/extensions/src/main/java/dev/cel/extensions/CelCidr.java new file mode 100644 index 000000000..1d7d3eb7d --- /dev/null +++ b/extensions/src/main/java/dev/cel/extensions/CelCidr.java @@ -0,0 +1,174 @@ +// 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. + +package dev.cel.extensions; + +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.types.OpaqueType; +import dev.cel.common.values.OpaqueValue; +import java.util.Objects; +import org.jspecify.annotations.Nullable; + +/** Immutable CEL opaque value representing an IPv4 or IPv6 CIDR prefix ({@code net.CIDR}). */ +@Immutable +@CheckReturnValue +public final class CelCidr extends OpaqueValue { + + /** CEL opaque type for {@code net.CIDR}. */ + public static final OpaqueType CIDR_TYPE = OpaqueType.create("net.CIDR"); + + private final CelIp ip; + private final int prefixLength; + + private CelCidr(CelIp ip, int prefixLength) { + this.ip = ip; + this.prefixLength = prefixLength; + } + + /** + * Parses a CIDR string strictly according to Go {@code netip.ParsePrefix} semantics, preserving + * host bits and disallowing zone identifiers and IPv4-mapped IPv6 addresses. + */ + public static CelCidr parse(String raw) { + Objects.requireNonNull(raw, "raw"); + int slash = raw.lastIndexOf('/'); + if (slash < 0) { + throw new IllegalArgumentException( + "CIDR '" + raw + "' parse error during conversion from string: no '/'"); + } + String ipPart = raw.substring(0, slash); + String prefixPart = raw.substring(slash + 1); + + CelIp.ParsedIp parsed = CelIp.parseWithOptionalZone(ipPart, "CIDR", raw); + if (parsed.zone != null) { + throw new IllegalArgumentException("CIDR '" + raw + "' with zone value is not allowed"); + } + if (parsed.ip.is4In6()) { + throw new IllegalArgumentException("IPv4-mapped IPv6 address '" + raw + "' is not allowed"); + } + + int maxBits = parsed.ip.family() == 4L ? 32 : 128; + int prefixLen = parsePrefixLength(prefixPart, maxBits, raw); + return new CelCidr(parsed.ip, prefixLen); + } + + private static int parsePrefixLength(String prefixPart, int maxBits, String rawForError) { + if (prefixPart.isEmpty()) { + throw new IllegalArgumentException( + "CIDR '" + rawForError + "' parse error during conversion from string: empty prefix"); + } + if (prefixPart.length() > 1 && prefixPart.charAt(0) == '0') { + throw new IllegalArgumentException( + "CIDR '" + + rawForError + + "' parse error during conversion from string: prefix length has leading zero"); + } + if (prefixPart.length() > 3) { + throw new IllegalArgumentException( + "CIDR '" + + rawForError + + "' parse error during conversion from string: prefix length out of range"); + } + int value = 0; + for (int i = 0; i < prefixPart.length(); i++) { + char c = prefixPart.charAt(i); + if (c < '0' || c > '9') { + throw new IllegalArgumentException( + "CIDR '" + + rawForError + + "' parse error during conversion from string: invalid prefix length"); + } + value = value * 10 + (c - '0'); + } + if (value > maxBits) { + throw new IllegalArgumentException( + "CIDR '" + + rawForError + + "' parse error during conversion from string: prefix length out of range"); + } + return value; + } + + @Override + public CelCidr value() { + return this; + } + + @Override + public OpaqueType celType() { + return CIDR_TYPE; + } + + /** Returns the underlying {@link CelIp} address, preserving any unmasked host bits. */ + public CelIp ip() { + return ip; + } + + /** Returns the CIDR prefix length in bits. */ + public long prefixLength() { + return prefixLength; + } + + /** Returns a new {@link CelCidr} with host bits beyond {@link #prefixLength()} zeroed out. */ + public CelCidr masked() { + return new CelCidr(ip.mask(prefixLength), prefixLength); + } + + /** Returns true iff all host bits beyond {@link #prefixLength()} are zero. */ + public boolean isMask() { + return ip.equals(ip.mask(prefixLength)); + } + + /** Returns true iff {@code other} belongs to the network masked by this CIDR. */ + public boolean containsIp(CelIp other) { + Objects.requireNonNull(other, "other"); + return ip.matchesPrefix(other, prefixLength); + } + + /** Returns true iff this CIDR contains all addresses in {@code child}. */ + public boolean containsCidr(CelCidr child) { + Objects.requireNonNull(child, "child"); + return this.ip.family() == child.ip.family() + && this.prefixLength <= child.prefixLength + && this.containsIp(child.ip); + } + + /** Returns the canonical string form {@code "/"}. */ + public String toCanonicalString() { + return ip.toCanonicalString() + "/" + prefixLength; + } + + @Override + public String toString() { + return toCanonicalString(); + } + + @Override + public boolean equals(@Nullable Object obj) { + if (this == obj) { + return true; + } + if (!(obj instanceof CelCidr)) { + return false; + } + CelCidr other = (CelCidr) obj; + return this.prefixLength == other.prefixLength && this.ip.equals(other.ip); + } + + @Override + public int hashCode() { + return Objects.hash(ip, prefixLength); + } +} diff --git a/extensions/src/main/java/dev/cel/extensions/CelExtensions.java b/extensions/src/main/java/dev/cel/extensions/CelExtensions.java index e86531171..800da182d 100644 --- a/extensions/src/main/java/dev/cel/extensions/CelExtensions.java +++ b/extensions/src/main/java/dev/cel/extensions/CelExtensions.java @@ -37,6 +37,7 @@ public final class CelExtensions { private static final CelProtoExtensions PROTO_EXTENSIONS = new CelProtoExtensions(); private static final CelBindingsExtensions BINDINGS_EXTENSIONS = new CelBindingsExtensions(); private static final CelRegexExtensions REGEX_EXTENSIONS = new CelRegexExtensions(); + private static final CelNetworkExtensions NETWORK_EXTENSIONS = new CelNetworkExtensions(); private static final CelComprehensionsExtensions COMPREHENSIONS_EXTENSIONS = new CelComprehensionsExtensions(); @@ -447,6 +448,44 @@ public static CelRegexExtensions regex(Set function return new CelRegexExtensions(functions); } + /** + * Extended functions for IP addresses and CIDR blocks ({@code net.IP}, {@code net.CIDR}). + * + *

Refer to README.md for available functions. + */ + public static CelNetworkExtensions network() { + return NETWORK_EXTENSIONS; + } + + /** + * Extended functions for IP addresses and CIDR blocks ({@code net.IP}, {@code net.CIDR}). + * + *

Refer to README.md for functions available in each version. + */ + public static CelNetworkExtensions network(int version) { + return CelNetworkExtensions.library().version(version); + } + + /** + * Extended functions for IP addresses and CIDR blocks ({@code net.IP}, {@code net.CIDR}). + * + *

This will include only the specific functions denoted by {@link + * CelNetworkExtensions.Function}. + */ + public static CelNetworkExtensions network(CelNetworkExtensions.Function... functions) { + return network(ImmutableSet.copyOf(functions)); + } + + /** + * Extended functions for IP addresses and CIDR blocks ({@code net.IP}, {@code net.CIDR}). + * + *

This will include only the specific functions denoted by {@link + * CelNetworkExtensions.Function}. + */ + public static CelNetworkExtensions network(Set functions) { + return new CelNetworkExtensions(functions); + } + /** * Extended functions for Two Variable Comprehensions Expressions. * @@ -526,6 +565,8 @@ public static ImmutableSet getAllFunctionNames() { .map(CelListsExtensions.Function::getFunction), EnumSet.allOf(CelRegexExtensions.Function.class).stream() .map(CelRegexExtensions.Function::getFunction), + EnumSet.allOf(CelNetworkExtensions.Function.class).stream() + .map(CelNetworkExtensions.Function::getFunction), Stream.of( CelOptionalLibrary.Function.VALUE, CelOptionalLibrary.Function.HAS_VALUE, @@ -550,6 +591,8 @@ public static CelExtensionLibrary getE return CelListsExtensions.library(); case "math": return CelMathExtensions.library(); + case "network": + return CelNetworkExtensions.library(); case "optional": return CelOptionalLibrary.library(); case "protos": diff --git a/extensions/src/main/java/dev/cel/extensions/CelIp.java b/extensions/src/main/java/dev/cel/extensions/CelIp.java new file mode 100644 index 000000000..2d5c7ab03 --- /dev/null +++ b/extensions/src/main/java/dev/cel/extensions/CelIp.java @@ -0,0 +1,462 @@ +// 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. + +package dev.cel.extensions; + +import com.google.errorprone.annotations.CheckReturnValue; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.types.OpaqueType; +import dev.cel.common.values.OpaqueValue; +import java.util.Objects; +import org.jspecify.annotations.Nullable; + +/** Immutable CEL opaque value representing an IPv4 or IPv6 address ({@code net.IP}). */ +@Immutable +@CheckReturnValue +public final class CelIp extends OpaqueValue { + + /** CEL opaque type for {@code net.IP}. */ + public static final OpaqueType IP_TYPE = OpaqueType.create("net.IP"); + + private final byte family; + private final long hi; + private final long lo; + + private CelIp(byte family, long hi, long lo) { + this.family = family; + this.hi = hi; + this.lo = lo; + } + + /** + * Parses an IPv4 or IPv6 address string strictly according to Go {@code netip.ParseAddr} / RFC + * 4291 semantics, disallowing zone identifiers and IPv4-mapped IPv6 addresses. + */ + public static CelIp parse(String raw) { + Objects.requireNonNull(raw, "raw"); + ParsedIp parsed = parseWithOptionalZone(raw, "IP Address", raw); + if (parsed.zone != null) { + throw new IllegalArgumentException("IP address '" + raw + "' with zone value is not allowed"); + } + if (parsed.ip.is4In6()) { + throw new IllegalArgumentException("IPv4-mapped IPv6 address '" + raw + "' is not allowed"); + } + return parsed.ip; + } + + static ParsedIp parseWithOptionalZone(String raw, String errorPrefix, String rawForError) { + if (raw.isEmpty()) { + throw parseError(errorPrefix, rawForError, "unable to parse IP"); + } + if (raw.indexOf(':') >= 0) { + return parseIpv6WithOptionalZone(raw, errorPrefix, rawForError); + } + if (raw.indexOf('.') >= 0) { + int ipv4 = parseIpv4(raw, errorPrefix, rawForError); + return new ParsedIp(new CelIp((byte) 4, 0L, ipv4 & 0xFFFFFFFFL), null); + } + throw parseError(errorPrefix, rawForError, "unable to parse IP"); + } + + private static ParsedIp parseIpv6WithOptionalZone( + String raw, String errorPrefix, String rawForError) { + String ipPart = raw; + String zone = null; + int pctIdx = raw.indexOf('%'); + if (pctIdx >= 0) { + ipPart = raw.substring(0, pctIdx); + zone = raw.substring(pctIdx + 1); + if (zone.isEmpty()) { + throw parseError(errorPrefix, rawForError, "zone must be non-empty"); + } + } + CelIp ip = parseIpv6Body(ipPart, errorPrefix, rawForError); + return new ParsedIp(ip, zone); + } + + private static int parseIpv4(String s, String errorPrefix, String rawForError) { + int octet = 0; + int digits = 0; + int dotCount = 0; + int addr = 0; + int len = s.length(); + for (int i = 0; i < len; i++) { + char c = s.charAt(i); + if (c >= '0' && c <= '9') { + if (digits == 1 && octet == 0) { + throw parseError(errorPrefix, rawForError, "IPv4 field has octet with leading zero"); + } + octet = octet * 10 + (c - '0'); + digits++; + if (octet > 255) { + throw parseError(errorPrefix, rawForError, "IPv4 field has value >255"); + } + } else if (c == '.') { + if (digits == 0) { + throw parseError(errorPrefix, rawForError, "IPv4 field must have at least one digit"); + } + if (dotCount == 3) { + throw parseError(errorPrefix, rawForError, "IPv4 address too long"); + } + addr = (addr << 8) | octet; + octet = 0; + digits = 0; + dotCount++; + } else { + throw parseError(errorPrefix, rawForError, "unexpected character"); + } + } + if (dotCount != 3 || digits == 0) { + throw parseError(errorPrefix, rawForError, "IPv4 address too short"); + } + return (addr << 8) | octet; + } + + private static CelIp parseIpv6Body(String s, String errorPrefix, String rawForError) { + int len = s.length(); + if (len < 2) { + throw parseError(errorPrefix, rawForError, "address too short"); + } + + int[] hextets = new int[8]; + int count = 0; + int ellipsis = -1; + int i = 0; + + if (s.charAt(0) == ':') { + if (s.charAt(1) != ':') { + throw parseError(errorPrefix, rawForError, "each colon-separated field must have a digit"); + } + ellipsis = 0; + i = 2; + } + + while (i < len) { + int segStart = i; + int val = 0; + int hexDigits = 0; + boolean hitDot = false; + + while (i < len) { + char c = s.charAt(i); + int digit = hexValue(c); + if (digit >= 0) { + if (hexDigits == 4) { + throw parseError(errorPrefix, rawForError, "IPv6 field has too many digits"); + } + val = (val << 4) | digit; + hexDigits++; + i++; + } else if (c == ':') { + break; + } else if (c == '.') { + hitDot = true; + break; + } else { + throw parseError(errorPrefix, rawForError, "unexpected character"); + } + } + + if (hitDot) { + if (segStart == 0) { + throw parseError(errorPrefix, rawForError, "unexpected IPv4 prefix in IPv6 address"); + } + if (count > 6 || (ellipsis >= 0 && count >= 6)) { + throw parseError(errorPrefix, rawForError, "address too long"); + } + int v4 = parseIpv4(s.substring(segStart), errorPrefix, rawForError); + hextets[count++] = (v4 >>> 16) & 0xFFFF; + hextets[count++] = v4 & 0xFFFF; + i = len; + break; + } + + if (hexDigits == 0) { + // Encountered ':' immediately after consuming the previous ':' -> "::". + if (ellipsis >= 0) { + throw parseError(errorPrefix, rawForError, "multiple :: in IPv6 address"); + } + ellipsis = count; + i++; + continue; + } + + if (count >= 8) { + throw parseError(errorPrefix, rawForError, "address too long"); + } + hextets[count++] = val; + + if (i == len) { + break; + } + // Must be ':' because '.', invalid chars, and hex digits were handled above. + i++; + if (i == len) { + throw parseError(errorPrefix, rawForError, "trailing colon"); + } + } + + int[] full; + if (ellipsis < 0) { + if (count != 8) { + throw parseError(errorPrefix, rawForError, "address too short"); + } + full = hextets; + } else { + if (count >= 8) { + throw parseError(errorPrefix, rawForError, "address too long for :: compression"); + } + int zeros = 8 - count; + full = new int[8]; + for (int idx = 0; idx < ellipsis; idx++) { + full[idx] = hextets[idx]; + } + for (int idx = ellipsis; idx < count; idx++) { + full[idx + zeros] = hextets[idx]; + } + } + + long hiVal = + ((long) full[0] << 48) + | ((long) full[1] << 32) + | ((long) full[2] << 16) + | (full[3] & 0xFFFFL); + long loVal = + ((long) full[4] << 48) + | ((long) full[5] << 32) + | ((long) full[6] << 16) + | (full[7] & 0xFFFFL); + return new CelIp((byte) 6, hiVal, loVal); + } + + private static int hexValue(char c) { + if (c >= '0' && c <= '9') { + return c - '0'; + } + if (c >= 'a' && c <= 'f') { + return 10 + (c - 'a'); + } + if (c >= 'A' && c <= 'F') { + return 10 + (c - 'A'); + } + return -1; + } + + private static IllegalArgumentException parseError( + String errorPrefix, String raw, String detail) { + return new IllegalArgumentException( + errorPrefix + " '" + raw + "' parse error during conversion from string: " + detail); + } + + boolean is4In6() { + return family == 6 && hi == 0L && (lo >>> 32) == 0xFFFFL; + } + + @Override + public CelIp value() { + return this; + } + + @Override + public OpaqueType celType() { + return IP_TYPE; + } + + /** Returns the IP address family: {@code 4} for IPv4 or {@code 6} for IPv6. */ + public long family() { + return family; + } + + /** Returns true if the IP address is unspecified ({@code 0.0.0.0} or {@code ::}). */ + public boolean isUnspecified() { + if (family == 4) { + return lo == 0L; + } + return hi == 0L && lo == 0L; + } + + /** Returns true if the IP address is a loopback address ({@code 127.0.0.0/8} or {@code ::1}). */ + public boolean isLoopback() { + if (family == 4) { + return ((lo >>> 24) & 0xFFL) == 127L; + } + return hi == 0L && lo == 1L; + } + + /** Returns true if the IP address is a link-local unicast address. */ + public boolean isLinkLocalUnicast() { + if (family == 4) { + return ((lo >>> 24) & 0xFFL) == 169L && ((lo >>> 16) & 0xFFL) == 254L; + } + return ((hi >>> 56) & 0xFFL) == 0xFEL && ((hi >>> 48) & 0xC0L) == 0x80L; + } + + /** Returns true if the IP address is a link-local multicast address. */ + public boolean isLinkLocalMulticast() { + if (family == 4) { + return ((lo >>> 24) & 0xFFL) == 224L + && ((lo >>> 16) & 0xFFL) == 0L + && ((lo >>> 8) & 0xFFL) == 0L; + } + return ((hi >>> 56) & 0xFFL) == 0xFFL && ((hi >>> 48) & 0x0FL) == 0x02L; + } + + private boolean isMulticast() { + if (family == 4) { + return ((lo >>> 24) & 0xF0L) == 0xE0L; + } + return ((hi >>> 56) & 0xFFL) == 0xFFL; + } + + /** Returns true if the IP address is a global unicast address per Go {@code netip} semantics. */ + public boolean isGlobalUnicast() { + if (family == 4 && lo == 0xFFFFFFFFL) { + return false; + } + return !isUnspecified() && !isLoopback() && !isMulticast() && !isLinkLocalUnicast(); + } + + CelIp mask(int prefixLength) { + if (family == 4) { + long v4Mask = prefixLength == 0 ? 0L : (0xFFFFFFFFL << (32 - prefixLength)) & 0xFFFFFFFFL; + return new CelIp((byte) 4, 0L, lo & v4Mask); + } + long hiMask = ipv6HiMask(prefixLength); + long loMask = ipv6LoMask(prefixLength); + return new CelIp((byte) 6, hi & hiMask, lo & loMask); + } + + boolean matchesPrefix(CelIp other, int prefixLength) { + if (this.family != other.family) { + return false; + } + if (family == 4) { + long v4Mask = prefixLength == 0 ? 0L : (0xFFFFFFFFL << (32 - prefixLength)) & 0xFFFFFFFFL; + return ((this.lo ^ other.lo) & v4Mask) == 0L; + } + long hiMask = ipv6HiMask(prefixLength); + long loMask = ipv6LoMask(prefixLength); + return ((this.hi ^ other.hi) & hiMask) == 0L && ((this.lo ^ other.lo) & loMask) == 0L; + } + + private static long ipv6HiMask(int prefixLength) { + if (prefixLength == 0) { + return 0L; + } + if (prefixLength < 64) { + return -1L << (64 - prefixLength); + } + return -1L; + } + + private static long ipv6LoMask(int prefixLength) { + if (prefixLength <= 64) { + return 0L; + } + if (prefixLength < 128) { + return -1L << (128 - prefixLength); + } + return -1L; + } + + /** Returns the canonical string form of this IP address (RFC 5952 for IPv6). */ + public String toCanonicalString() { + if (family == 4) { + return ((lo >>> 24) & 0xFFL) + + "." + + ((lo >>> 16) & 0xFFL) + + "." + + ((lo >>> 8) & 0xFFL) + + "." + + (lo & 0xFFL); + } + int[] h = { + (int) ((hi >>> 48) & 0xFFFFL), + (int) ((hi >>> 32) & 0xFFFFL), + (int) ((hi >>> 16) & 0xFFFFL), + (int) (hi & 0xFFFFL), + (int) ((lo >>> 48) & 0xFFFFL), + (int) ((lo >>> 32) & 0xFFFFL), + (int) ((lo >>> 16) & 0xFFFFL), + (int) (lo & 0xFFFFL), + }; + int bestStart = -1; + int bestLen = 0; + int curStart = -1; + int curLen = 0; + for (int i = 0; i < 8; i++) { + if (h[i] == 0) { + if (curStart < 0) { + curStart = i; + curLen = 1; + } else { + curLen++; + } + if (curLen > bestLen && curLen >= 2) { + bestStart = curStart; + bestLen = curLen; + } + } else { + curStart = -1; + curLen = 0; + } + } + + StringBuilder sb = new StringBuilder(39); + for (int i = 0; i < 8; i++) { + if (i == bestStart) { + sb.append("::"); + i += bestLen - 1; + continue; + } + if (i > 0 && !(bestStart >= 0 && i == bestStart + bestLen)) { + sb.append(':'); + } + sb.append(Integer.toHexString(h[i])); + } + return sb.toString(); + } + + @Override + public String toString() { + return toCanonicalString(); + } + + @Override + public boolean equals(@Nullable Object obj) { + if (this == obj) { + return true; + } + if (!(obj instanceof CelIp)) { + return false; + } + CelIp other = (CelIp) obj; + return this.family == other.family && this.hi == other.hi && this.lo == other.lo; + } + + @Override + public int hashCode() { + return Objects.hash(family, hi, lo); + } + + static final class ParsedIp { + final CelIp ip; + final @Nullable String zone; + + ParsedIp(CelIp ip, @Nullable String zone) { + this.ip = ip; + this.zone = zone; + } + } +} diff --git a/extensions/src/main/java/dev/cel/extensions/CelNetworkCompilerLibrary.java b/extensions/src/main/java/dev/cel/extensions/CelNetworkCompilerLibrary.java new file mode 100644 index 000000000..a4cf88082 --- /dev/null +++ b/extensions/src/main/java/dev/cel/extensions/CelNetworkCompilerLibrary.java @@ -0,0 +1,300 @@ +// 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. + +package dev.cel.extensions; + +import static com.google.common.collect.ImmutableSet.toImmutableSet; + +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.Immutable; +import dev.cel.checker.CelCheckerBuilder; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOverloadDecl; +import dev.cel.common.CelVarDecl; +import dev.cel.common.types.SimpleType; +import dev.cel.common.types.TypeType; +import dev.cel.compiler.CelCompilerLibrary; +import java.util.Set; + +/** Internal implementation of CEL Network compile-time extensions. */ +@Immutable +public final class CelNetworkCompilerLibrary + implements CelCompilerLibrary, CelExtensionLibrary.FeatureSet { + + /** Supported functions for the Network compiler extension. */ + public enum Function { + CIDR( + CelFunctionDecl.newFunctionDeclaration( + "cidr", + CelOverloadDecl.newGlobalOverload( + "string_to_cidr", + "Parses a string into a CIDR block.", + CelCidr.CIDR_TYPE, + SimpleType.STRING))), + STRING( + CelFunctionDecl.newFunctionDeclaration( + "string", + CelOverloadDecl.newGlobalOverload( + "ip_to_string", + "Converts an IP address to its canonical string representation.", + SimpleType.STRING, + CelIp.IP_TYPE), + CelOverloadDecl.newGlobalOverload( + "cidr_to_string", + "Converts a CIDR block to its string representation.", + SimpleType.STRING, + CelCidr.CIDR_TYPE))), + CONTAINS_CIDR( + CelFunctionDecl.newFunctionDeclaration( + "containsCIDR", + CelOverloadDecl.newMemberOverload( + "cidr_contains_cidr", + "Checks if a CIDR block contains another CIDR block.", + SimpleType.BOOL, + CelCidr.CIDR_TYPE, + CelCidr.CIDR_TYPE), + CelOverloadDecl.newMemberOverload( + "cidr_contains_cidr_string", + "Checks if a CIDR block contains a CIDR block parsed from string.", + SimpleType.BOOL, + CelCidr.CIDR_TYPE, + SimpleType.STRING))), + CONTAINS_IP( + CelFunctionDecl.newFunctionDeclaration( + "containsIP", + CelOverloadDecl.newMemberOverload( + "cidr_contains_ip_ip", + "Checks if a CIDR block contains an IP address.", + SimpleType.BOOL, + CelCidr.CIDR_TYPE, + CelIp.IP_TYPE), + CelOverloadDecl.newMemberOverload( + "cidr_contains_ip_string", + "Checks if a CIDR block contains an IP address parsed from string.", + SimpleType.BOOL, + CelCidr.CIDR_TYPE, + SimpleType.STRING))), + FAMILY( + CelFunctionDecl.newFunctionDeclaration( + "family", + CelOverloadDecl.newMemberOverload( + "ip_family", + "Returns the IP address family (4 or 6).", + SimpleType.INT, + CelIp.IP_TYPE))), + IP( + CelFunctionDecl.newFunctionDeclaration( + "ip", + CelOverloadDecl.newGlobalOverload( + "string_to_ip", + "Parses a string into an IP address.", + CelIp.IP_TYPE, + SimpleType.STRING), + CelOverloadDecl.newMemberOverload( + "cidr_ip", + "Returns the IP address of the CIDR block, preserving host bits.", + CelIp.IP_TYPE, + CelCidr.CIDR_TYPE))), + IP_IS_CANONICAL( + CelFunctionDecl.newFunctionDeclaration( + "ip.isCanonical", + CelOverloadDecl.newGlobalOverload( + "ip_is_canonical", + "Checks whether an IP address string is in canonical RFC 5952 format.", + SimpleType.BOOL, + SimpleType.STRING))), + IS_CIDR( + CelFunctionDecl.newFunctionDeclaration( + "isCIDR", + CelOverloadDecl.newGlobalOverload( + "is_cidr", + "Checks if a string is a valid CIDR block.", + SimpleType.BOOL, + SimpleType.STRING))), + IS_GLOBAL_UNICAST( + CelFunctionDecl.newFunctionDeclaration( + "isGlobalUnicast", + CelOverloadDecl.newMemberOverload( + "ip_is_global_unicast", + "Checks if the IP address is a global unicast address.", + SimpleType.BOOL, + CelIp.IP_TYPE))), + IS_IP( + CelFunctionDecl.newFunctionDeclaration( + "isIP", + CelOverloadDecl.newGlobalOverload( + "is_ip", + "Checks if a string is a valid IP address.", + SimpleType.BOOL, + SimpleType.STRING))), + IS_LINK_LOCAL_MULTICAST( + CelFunctionDecl.newFunctionDeclaration( + "isLinkLocalMulticast", + CelOverloadDecl.newMemberOverload( + "ip_is_link_local_multicast", + "Checks if the IP address is a link-local multicast address.", + SimpleType.BOOL, + CelIp.IP_TYPE))), + IS_LINK_LOCAL_UNICAST( + CelFunctionDecl.newFunctionDeclaration( + "isLinkLocalUnicast", + CelOverloadDecl.newMemberOverload( + "ip_is_link_local_unicast", + "Checks if the IP address is a link-local unicast address.", + SimpleType.BOOL, + CelIp.IP_TYPE))), + IS_LOOPBACK( + CelFunctionDecl.newFunctionDeclaration( + "isLoopback", + CelOverloadDecl.newMemberOverload( + "ip_is_loopback", + "Checks if the IP address is a loopback address.", + SimpleType.BOOL, + CelIp.IP_TYPE))), + IS_MASK( + CelFunctionDecl.newFunctionDeclaration( + "isMask", + CelOverloadDecl.newMemberOverload( + "cidr_is_mask", + "Checks if the CIDR block has all host bits set to zero.", + SimpleType.BOOL, + CelCidr.CIDR_TYPE))), + IS_UNSPECIFIED( + CelFunctionDecl.newFunctionDeclaration( + "isUnspecified", + CelOverloadDecl.newMemberOverload( + "ip_is_unspecified", + "Checks if the IP address is unspecified (0.0.0.0 or ::).", + SimpleType.BOOL, + CelIp.IP_TYPE))), + MASKED( + CelFunctionDecl.newFunctionDeclaration( + "masked", + CelOverloadDecl.newMemberOverload( + "cidr_masked", + "Returns the CIDR block with host bits zeroed out.", + CelCidr.CIDR_TYPE, + CelCidr.CIDR_TYPE))), + PREFIX_LENGTH( + CelFunctionDecl.newFunctionDeclaration( + "prefixLength", + CelOverloadDecl.newMemberOverload( + "cidr_prefix_length", + "Returns the prefix length of the CIDR block.", + SimpleType.INT, + CelCidr.CIDR_TYPE))); + + private final CelFunctionDecl functionDecl; + + String getFunction() { + return functionDecl.name(); + } + + public CelFunctionDecl getFunctionDecl() { + return functionDecl; + } + + Function(CelFunctionDecl functionDecl) { + this.functionDecl = functionDecl; + } + } + + private static final ImmutableSet NETWORK_TYPE_VARIABLES = + ImmutableSet.of( + CelVarDecl.newVarDeclaration(CelIp.IP_TYPE.name(), TypeType.create(CelIp.IP_TYPE)), + CelVarDecl.newVarDeclaration( + CelCidr.CIDR_TYPE.name(), TypeType.create(CelCidr.CIDR_TYPE))); + + private static final class Library implements CelExtensionLibrary { + private final CelNetworkCompilerLibrary version0 = + new CelNetworkCompilerLibrary( + 0, ImmutableSet.copyOf(Function.values()), NETWORK_TYPE_VARIABLES); + private final CelNetworkCompilerLibrary version1 = + new CelNetworkCompilerLibrary( + 1, ImmutableSet.copyOf(Function.values()), NETWORK_TYPE_VARIABLES); + + @Override + public String name() { + return "network"; + } + + @Override + public ImmutableSet versions() { + return ImmutableSet.of(version0, version1); + } + } + + private static final Library LIBRARY = new Library(); + + /** Returns the {@link CelExtensionLibrary} descriptor for the 'network' compiler extension. */ + public static CelExtensionLibrary library() { + return LIBRARY; + } + + /** Returns the latest version of the 'network' compiler extension. */ + public static CelNetworkCompilerLibrary network() { + return LIBRARY.version1; + } + + /** Returns the specified version of the 'network' compiler extension. */ + public static CelNetworkCompilerLibrary network(int version) { + return library().version(version); + } + + /** Returns the 'network' compiler extension with only the specified functions. */ + public static CelNetworkCompilerLibrary network(Function... functions) { + return network(ImmutableSet.copyOf(functions)); + } + + /** Returns the 'network' compiler extension with only the specified functions. */ + public static CelNetworkCompilerLibrary network(Set functions) { + return new CelNetworkCompilerLibrary(functions); + } + + private final ImmutableSet functions; + private final ImmutableSet variables; + private final int version; + + CelNetworkCompilerLibrary(Set functions) { + this(-1, functions, NETWORK_TYPE_VARIABLES); + } + + private CelNetworkCompilerLibrary( + int version, Set functions, Set variables) { + this.version = version; + this.functions = ImmutableSet.copyOf(functions); + this.variables = ImmutableSet.copyOf(variables); + } + + @Override + public int version() { + return version; + } + + @Override + public ImmutableSet functions() { + return functions.stream().map(Function::getFunctionDecl).collect(toImmutableSet()); + } + + @Override + public ImmutableSet variables() { + return variables; + } + + @Override + public void setCheckerOptions(CelCheckerBuilder checkerBuilder) { + checkerBuilder.addVarDeclarations(variables()); + functions.forEach(function -> checkerBuilder.addFunctionDeclarations(function.functionDecl)); + } +} diff --git a/extensions/src/main/java/dev/cel/extensions/CelNetworkExtensions.java b/extensions/src/main/java/dev/cel/extensions/CelNetworkExtensions.java new file mode 100644 index 000000000..f82b80cb9 --- /dev/null +++ b/extensions/src/main/java/dev/cel/extensions/CelNetworkExtensions.java @@ -0,0 +1,159 @@ +// 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. + +package dev.cel.extensions; + +import static com.google.common.collect.ImmutableSet.toImmutableSet; + +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.Immutable; +import dev.cel.checker.CelCheckerBuilder; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelVarDecl; +import dev.cel.compiler.CelCompilerLibrary; +import dev.cel.runtime.CelRuntimeBuilder; +import dev.cel.runtime.CelRuntimeLibrary; +import java.util.Set; + +/** Internal implementation of CEL Network extensions. */ +@Immutable +public final class CelNetworkExtensions + implements CelCompilerLibrary, CelRuntimeLibrary, CelExtensionLibrary.FeatureSet { + + /** Denotes the network extension function. */ + public enum Function { + CIDR(CelNetworkCompilerLibrary.Function.CIDR, CelNetworkRuntimeLibrary.Function.CIDR), + STRING(CelNetworkCompilerLibrary.Function.STRING, CelNetworkRuntimeLibrary.Function.STRING), + CONTAINS_CIDR( + CelNetworkCompilerLibrary.Function.CONTAINS_CIDR, + CelNetworkRuntimeLibrary.Function.CONTAINS_CIDR), + CONTAINS_IP( + CelNetworkCompilerLibrary.Function.CONTAINS_IP, + CelNetworkRuntimeLibrary.Function.CONTAINS_IP), + FAMILY(CelNetworkCompilerLibrary.Function.FAMILY, CelNetworkRuntimeLibrary.Function.FAMILY), + IP(CelNetworkCompilerLibrary.Function.IP, CelNetworkRuntimeLibrary.Function.IP), + IP_IS_CANONICAL( + CelNetworkCompilerLibrary.Function.IP_IS_CANONICAL, + CelNetworkRuntimeLibrary.Function.IP_IS_CANONICAL), + IS_CIDR(CelNetworkCompilerLibrary.Function.IS_CIDR, CelNetworkRuntimeLibrary.Function.IS_CIDR), + IS_GLOBAL_UNICAST( + CelNetworkCompilerLibrary.Function.IS_GLOBAL_UNICAST, + CelNetworkRuntimeLibrary.Function.IS_GLOBAL_UNICAST), + IS_IP(CelNetworkCompilerLibrary.Function.IS_IP, CelNetworkRuntimeLibrary.Function.IS_IP), + IS_LINK_LOCAL_MULTICAST( + CelNetworkCompilerLibrary.Function.IS_LINK_LOCAL_MULTICAST, + CelNetworkRuntimeLibrary.Function.IS_LINK_LOCAL_MULTICAST), + IS_LINK_LOCAL_UNICAST( + CelNetworkCompilerLibrary.Function.IS_LINK_LOCAL_UNICAST, + CelNetworkRuntimeLibrary.Function.IS_LINK_LOCAL_UNICAST), + IS_LOOPBACK( + CelNetworkCompilerLibrary.Function.IS_LOOPBACK, + CelNetworkRuntimeLibrary.Function.IS_LOOPBACK), + IS_MASK(CelNetworkCompilerLibrary.Function.IS_MASK, CelNetworkRuntimeLibrary.Function.IS_MASK), + IS_UNSPECIFIED( + CelNetworkCompilerLibrary.Function.IS_UNSPECIFIED, + CelNetworkRuntimeLibrary.Function.IS_UNSPECIFIED), + MASKED(CelNetworkCompilerLibrary.Function.MASKED, CelNetworkRuntimeLibrary.Function.MASKED), + PREFIX_LENGTH( + CelNetworkCompilerLibrary.Function.PREFIX_LENGTH, + CelNetworkRuntimeLibrary.Function.PREFIX_LENGTH); + + private final CelNetworkCompilerLibrary.Function compilerFunction; + private final CelNetworkRuntimeLibrary.Function runtimeFunction; + + String getFunction() { + return compilerFunction.getFunction(); + } + + Function( + CelNetworkCompilerLibrary.Function compilerFunction, + CelNetworkRuntimeLibrary.Function runtimeFunction) { + this.compilerFunction = compilerFunction; + this.runtimeFunction = runtimeFunction; + } + } + + private static final class Library implements CelExtensionLibrary { + private final ImmutableSet versions; + + Library() { + versions = + CelNetworkCompilerLibrary.library().versions().stream() + .map(CelNetworkExtensions::new) + .collect(toImmutableSet()); + } + + @Override + public String name() { + return CelNetworkCompilerLibrary.library().name(); + } + + @Override + public ImmutableSet versions() { + return versions; + } + } + + private static final Library LIBRARY = new Library(); + + static CelExtensionLibrary library() { + return LIBRARY; + } + + private final CelNetworkCompilerLibrary compilerLibrary; + private final CelNetworkRuntimeLibrary runtimeLibrary; + + CelNetworkExtensions() { + this(CelNetworkCompilerLibrary.network()); + } + + CelNetworkExtensions(Set functions) { + this.compilerLibrary = + new CelNetworkCompilerLibrary( + functions.stream().map(f -> f.compilerFunction).collect(toImmutableSet())); + this.runtimeLibrary = + new CelNetworkRuntimeLibrary( + functions.stream().map(f -> f.runtimeFunction).collect(toImmutableSet())); + } + + private CelNetworkExtensions(CelNetworkCompilerLibrary compilerLibrary) { + this.compilerLibrary = compilerLibrary; + this.runtimeLibrary = CelNetworkRuntimeLibrary.network(compilerLibrary.version()); + } + + @Override + public int version() { + return compilerLibrary.version(); + } + + @Override + public ImmutableSet functions() { + return compilerLibrary.functions(); + } + + @Override + public ImmutableSet variables() { + return compilerLibrary.variables(); + } + + @Override + public void setCheckerOptions(CelCheckerBuilder checkerBuilder) { + compilerLibrary.setCheckerOptions(checkerBuilder); + } + + @Override + public void setRuntimeOptions(CelRuntimeBuilder runtimeBuilder) { + runtimeBuilder.addFunctionBindings(runtimeLibrary.newFunctionBindings()); + } +} diff --git a/extensions/src/main/java/dev/cel/extensions/CelNetworkRuntimeLibrary.java b/extensions/src/main/java/dev/cel/extensions/CelNetworkRuntimeLibrary.java new file mode 100644 index 000000000..e7ca90303 --- /dev/null +++ b/extensions/src/main/java/dev/cel/extensions/CelNetworkRuntimeLibrary.java @@ -0,0 +1,212 @@ +// 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. + +package dev.cel.extensions; + +import com.google.common.collect.ImmutableSet; +import com.google.errorprone.annotations.Immutable; +import dev.cel.common.exceptions.CelBadFormatException; +import dev.cel.runtime.CelFunctionBinding; +import dev.cel.runtime.CelLiteRuntimeBuilder; +import dev.cel.runtime.CelLiteRuntimeLibrary; +import java.util.Set; + +/** Runtime implementation of CEL Network extension functions. */ +@Immutable +public final class CelNetworkRuntimeLibrary implements CelLiteRuntimeLibrary { + + /** Enumeration of runtime function bindings for the Network extension. */ + public enum Function { + CIDR( + "cidr", + ImmutableSet.of( + CelFunctionBinding.from( + "string_to_cidr", String.class, CelNetworkRuntimeLibrary::parseCidr))), + STRING( + "string", + ImmutableSet.of( + CelFunctionBinding.from("ip_to_string", CelIp.class, CelIp::toCanonicalString), + CelFunctionBinding.from("cidr_to_string", CelCidr.class, CelCidr::toCanonicalString))), + CONTAINS_CIDR( + "containsCIDR", + ImmutableSet.of( + CelFunctionBinding.from( + "cidr_contains_cidr", CelCidr.class, CelCidr.class, CelCidr::containsCidr), + CelFunctionBinding.from( + "cidr_contains_cidr_string", + CelCidr.class, + String.class, + (parent, childStr) -> parent.containsCidr(parseCidr(childStr))))), + CONTAINS_IP( + "containsIP", + ImmutableSet.of( + CelFunctionBinding.from( + "cidr_contains_ip_ip", CelCidr.class, CelIp.class, CelCidr::containsIp), + CelFunctionBinding.from( + "cidr_contains_ip_string", + CelCidr.class, + String.class, + (cidr, ipStr) -> cidr.containsIp(parseIp(ipStr))))), + FAMILY( + "family", + ImmutableSet.of(CelFunctionBinding.from("ip_family", CelIp.class, CelIp::family))), + IP( + "ip", + ImmutableSet.of( + CelFunctionBinding.from( + "string_to_ip", String.class, CelNetworkRuntimeLibrary::parseIp), + CelFunctionBinding.from("cidr_ip", CelCidr.class, CelCidr::ip))), + IP_IS_CANONICAL( + "ip.isCanonical", + ImmutableSet.of( + CelFunctionBinding.from( + "ip_is_canonical", String.class, CelNetworkRuntimeLibrary::isCanonical))), + IS_CIDR( + "isCIDR", + ImmutableSet.of( + CelFunctionBinding.from("is_cidr", String.class, CelNetworkRuntimeLibrary::isCidr))), + IS_GLOBAL_UNICAST( + "isGlobalUnicast", + ImmutableSet.of( + CelFunctionBinding.from("ip_is_global_unicast", CelIp.class, CelIp::isGlobalUnicast))), + IS_IP( + "isIP", + ImmutableSet.of( + CelFunctionBinding.from("is_ip", String.class, CelNetworkRuntimeLibrary::isIp))), + IS_LINK_LOCAL_MULTICAST( + "isLinkLocalMulticast", + ImmutableSet.of( + CelFunctionBinding.from( + "ip_is_link_local_multicast", CelIp.class, CelIp::isLinkLocalMulticast))), + IS_LINK_LOCAL_UNICAST( + "isLinkLocalUnicast", + ImmutableSet.of( + CelFunctionBinding.from( + "ip_is_link_local_unicast", CelIp.class, CelIp::isLinkLocalUnicast))), + IS_LOOPBACK( + "isLoopback", + ImmutableSet.of(CelFunctionBinding.from("ip_is_loopback", CelIp.class, CelIp::isLoopback))), + IS_MASK( + "isMask", + ImmutableSet.of(CelFunctionBinding.from("cidr_is_mask", CelCidr.class, CelCidr::isMask))), + IS_UNSPECIFIED( + "isUnspecified", + ImmutableSet.of( + CelFunctionBinding.from("ip_is_unspecified", CelIp.class, CelIp::isUnspecified))), + MASKED( + "masked", + ImmutableSet.of(CelFunctionBinding.from("cidr_masked", CelCidr.class, CelCidr::masked))), + PREFIX_LENGTH( + "prefixLength", + ImmutableSet.of( + CelFunctionBinding.from("cidr_prefix_length", CelCidr.class, CelCidr::prefixLength))); + + private final String functionName; + private final ImmutableSet functionBindings; + + Function(String functionName, ImmutableSet functionBindings) { + this.functionName = functionName; + this.functionBindings = functionBindings; + } + } + + private static final CelNetworkRuntimeLibrary VERSION_1 = + new CelNetworkRuntimeLibrary(ImmutableSet.copyOf(Function.values())); + + /** Returns the latest version of the 'network' runtime functions. */ + public static CelNetworkRuntimeLibrary network() { + return VERSION_1; + } + + /** Returns the specified version of the 'network' runtime functions. */ + public static CelNetworkRuntimeLibrary network(int version) { + switch (version) { + case 0: + case 1: + case Integer.MAX_VALUE: + return VERSION_1; + default: + throw new IllegalArgumentException("Unsupported 'network' extension version " + version); + } + } + + /** Returns the 'network' runtime functions with only the specified functions. */ + public static CelNetworkRuntimeLibrary network(Function... functions) { + return network(ImmutableSet.copyOf(functions)); + } + + /** Returns the 'network' runtime functions with only the specified functions. */ + public static CelNetworkRuntimeLibrary network(Set functions) { + return new CelNetworkRuntimeLibrary(functions); + } + + private final ImmutableSet functions; + + CelNetworkRuntimeLibrary(Set functions) { + this.functions = ImmutableSet.copyOf(functions); + } + + @Override + public void setRuntimeOptions(CelLiteRuntimeBuilder runtimeBuilder) { + runtimeBuilder.addFunctionBindings(newFunctionBindings()); + } + + /** Creates the {@link CelFunctionBinding}s for the configured network functions. */ + public ImmutableSet newFunctionBindings() { + ImmutableSet.Builder builder = ImmutableSet.builder(); + for (Function function : functions) { + builder.addAll( + CelFunctionBinding.fromOverloads(function.functionName, function.functionBindings)); + } + return builder.build(); + } + + private static CelIp parseIp(String raw) { + try { + return CelIp.parse(raw); + } catch (IllegalArgumentException e) { + throw new CelBadFormatException(e); + } + } + + private static CelCidr parseCidr(String raw) { + try { + return CelCidr.parse(raw); + } catch (IllegalArgumentException e) { + throw new CelBadFormatException(e); + } + } + + private static boolean isCanonical(String raw) { + return parseIp(raw).toCanonicalString().equals(raw); + } + + private static boolean isIp(String raw) { + try { + CelIp unused = CelIp.parse(raw); + return true; + } catch (IllegalArgumentException e) { + return false; + } + } + + private static boolean isCidr(String raw) { + try { + CelCidr unused = CelCidr.parse(raw); + return true; + } catch (IllegalArgumentException e) { + return false; + } + } +} diff --git a/extensions/src/main/java/dev/cel/extensions/README.md b/extensions/src/main/java/dev/cel/extensions/README.md index 403566f56..899686b18 100644 --- a/extensions/src/main/java/dev/cel/extensions/README.md +++ b/extensions/src/main/java/dev/cel/extensions/README.md @@ -1176,3 +1176,72 @@ The type-mapping between Java and CEL is as follows: * If there is a name collision with a Protobuf type, the protobuf type will take precedence. * Instantiating new struct values (e.g., `Account{id: 1234}`) requires the class to have a no-argument constructor (public, protected, package-private, or private). * Final fields are supported only in a **read-only** capacity; they cannot be populated when instantiating new struct values. + +## Network + +The `network` extension (`CelExtensions.network()`) provides functions and +opaque types (`net.IP` and `net.CIDR`) for parsing, inspecting, and validating +IPv4/IPv6 addresses and CIDR blocks. IPv4-mapped IPv6 addresses and zone +identifiers are disallowed. + +Supported versions: `0` and `1` (both expose the full set of `net.IP` and +`net.CIDR` types and functions). + +### IP Addresses + +``` +ip(string) -> net.IP +isIP(string) -> bool +ip.isCanonical(string) -> bool +string(net.IP) -> string +.family() -> int +.isUnspecified() -> bool +.isLoopback() -> bool +.isGlobalUnicast() -> bool +.isLinkLocalMulticast() -> bool +.isLinkLocalUnicast() -> bool +``` + +Examples: + +``` +ip('192.168.0.1').family() == 4 +ip('2001:db8::1').family() == 6 +isIP('127.0.0.1') // true +isIP('invalid') // false +ip.isCanonical('2001:db8::1') // true +ip.isCanonical('2001:DB8::1') // false +ip('127.0.0.1').isLoopback() // true +string(ip('2001:0db8::1')) // '2001:db8::1' +type(ip('192.168.0.1')) == net.IP +``` + +### CIDR Blocks + +``` +cidr(string) -> net.CIDR +isCIDR(string) -> bool +string(net.CIDR) -> string +.ip() -> net.IP +.masked() -> net.CIDR +.isMask() -> bool +.prefixLength() -> int +.containsIP(net.IP) -> bool +.containsIP(string) -> bool +.containsCIDR(net.CIDR) -> bool +.containsCIDR(string) -> bool +``` + +Examples: + +``` +cidr('10.0.0.0/8').containsIP(ip('10.0.0.1')) // true +cidr('10.0.0.0/8').containsIP('10.0.0.1') // true +cidr('10.0.0.0/8').containsCIDR('10.1.0.0/16') // true +cidr('192.168.1.5/24').ip() == ip('192.168.1.5') // true +cidr('192.168.1.5/24').isMask() // false +cidr('192.168.1.5/24').masked() == cidr('192.168.1.0/24') // true +cidr('192.168.1.0/24').prefixLength() == 24 +type(cidr('192.168.0.0/24')) == net.CIDR +``` + diff --git a/extensions/src/test/java/dev/cel/extensions/BUILD.bazel b/extensions/src/test/java/dev/cel/extensions/BUILD.bazel index 99d40146c..11fbac965 100644 --- a/extensions/src/test/java/dev/cel/extensions/BUILD.bazel +++ b/extensions/src/test/java/dev/cel/extensions/BUILD.bazel @@ -20,13 +20,16 @@ java_library( "//common:cel_validation_result", "//common:cel_var_decl", "//common:container", + "//common:error_codes", "//common:options", "//common/ast", "//common/exceptions:attribute_not_found", + "//common/exceptions:bad_format", "//common/exceptions:divide_by_zero", "//common/exceptions:index_out_of_bounds", "//common/exceptions:invalid_argument", "//common/types", + "//common/types:default_type_provider", "//common/types:message_type_provider", "//common/types:type_providers", "//common/values", @@ -49,6 +52,10 @@ java_library( "//extensions:math_compiler_library", "//extensions:math_runtime_library", "//extensions:native", + "//extensions:network", + "//extensions:network_compiler_library", + "//extensions:network_runtime_library", + "//extensions:network_types", "//extensions:optional_compiler_library", "//extensions:optional_library", "//extensions:optional_runtime_library", @@ -85,6 +92,7 @@ java_library( "@cel_conformance//proto/cel/expr/conformance/test:simple_java_proto", "@maven//:com_google_errorprone_error_prone_annotations", "@maven//:com_google_guava_guava", + "@maven//:com_google_guava_guava_testlib", "@maven//:com_google_protobuf_protobuf_java", # unuseddeps: keep "@maven//:com_google_testparameterinjector_test_parameter_injector", "@maven//:junit_junit", diff --git a/extensions/src/test/java/dev/cel/extensions/CelExtensionsTest.java b/extensions/src/test/java/dev/cel/extensions/CelExtensionsTest.java index 06a6ba142..3fe52ce75 100644 --- a/extensions/src/test/java/dev/cel/extensions/CelExtensionsTest.java +++ b/extensions/src/test/java/dev/cel/extensions/CelExtensionsTest.java @@ -189,6 +189,23 @@ public void getAllFunctionNames() { "regex.replace", "regex.extract", "regex.extractAll", + "cidr", + "string", + "containsCIDR", + "containsIP", + "family", + "ip", + "ip.isCanonical", + "isCIDR", + "isGlobalUnicast", + "isIP", + "isLinkLocalMulticast", + "isLinkLocalUnicast", + "isLoopback", + "isMask", + "isUnspecified", + "masked", + "prefixLength", "value", "hasValue", "optional.none", diff --git a/extensions/src/test/java/dev/cel/extensions/CelNetworkExtensionsTest.java b/extensions/src/test/java/dev/cel/extensions/CelNetworkExtensionsTest.java new file mode 100644 index 000000000..4888b1661 --- /dev/null +++ b/extensions/src/test/java/dev/cel/extensions/CelNetworkExtensionsTest.java @@ -0,0 +1,489 @@ +// 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. + +package dev.cel.extensions; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.bundle.Cel; +import dev.cel.bundle.CelFactory; +import dev.cel.common.CelAbstractSyntaxTree; +import dev.cel.common.CelErrorCode; +import dev.cel.common.CelFunctionDecl; +import dev.cel.common.CelOptions; +import dev.cel.common.CelValidationException; +import dev.cel.common.CelVarDecl; +import dev.cel.common.exceptions.CelBadFormatException; +import dev.cel.common.types.TypeType; +import dev.cel.compiler.CelCompiler; +import dev.cel.compiler.CelCompilerFactory; +import dev.cel.runtime.CelEvaluationException; +import dev.cel.runtime.CelLiteRuntime; +import dev.cel.runtime.CelLiteRuntimeFactory; +import dev.cel.runtime.CelRuntime; +import dev.cel.runtime.CelRuntimeFactory; +import dev.cel.runtime.CelStandardFunctions; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class CelNetworkExtensionsTest extends CelExtensionTestBase { + + @Override + protected Cel newCelEnv() { + return runtimeFlavor + .builder() + .addCompilerLibraries(CelExtensions.network()) + .addRuntimeLibraries(CelExtensions.network()) + .build(); + } + + @Test + public void library() { + CelExtensionLibrary library = + CelExtensions.getExtensionLibrary("network", CelOptions.DEFAULT); + assertThat(library.name()).isEqualTo("network"); + assertThat(library.latest().version()).isEqualTo(1); + assertThat(library.version(0).functions().stream().map(CelFunctionDecl::name)) + .containsExactly( + "cidr", + "string", + "containsCIDR", + "containsIP", + "family", + "ip", + "ip.isCanonical", + "isCIDR", + "isGlobalUnicast", + "isIP", + "isLinkLocalMulticast", + "isLinkLocalUnicast", + "isLoopback", + "isMask", + "isUnspecified", + "masked", + "prefixLength"); + assertThat(library.version(1).variables().stream().map(CelVarDecl::name)) + .containsExactly("net.IP", "net.CIDR"); + assertThat(library.version(1).macros()).isEmpty(); + } + + @Test + @TestParameters("{expr: \"cidr('192.168.0.0/24').ip() == ip('192.168.0.0')\"}") + @TestParameters("{expr: \"cidr('192.168.1.5/24').ip() == ip('192.168.1.5')\"}") + @TestParameters("{expr: \"cidr('192.168.1.5/24').masked() == cidr('192.168.1.0/24')\"}") + @TestParameters("{expr: \"cidr('192.168.1.0/24').masked() == cidr('192.168.1.0/24')\"}") + @TestParameters("{expr: \"cidr('192.168.1.5/24') != cidr('192.168.1.0/24')\"}") + @TestParameters("{expr: \"cidr('0.0.0.0/0').masked() == cidr('0.0.0.0/0')\"}") + @TestParameters("{expr: \"cidr('255.255.255.255/0').masked() == cidr('0.0.0.0/0')\"}") + @TestParameters("{expr: \"cidr('192.168.1.5/32').masked() == cidr('192.168.1.5/32')\"}") + @TestParameters("{expr: \"cidr('10.0.0.0/8').containsCIDR(cidr('10.0.0.0/8'))\"}") + @TestParameters("{expr: \"cidr('10.0.0.0/8').containsCIDR(cidr('10.1.0.0/16'))\"}") + @TestParameters("{expr: \"cidr('10.0.0.0/8').containsCIDR('10.1.0.0/16')\"}") + @TestParameters("{expr: \"cidr('192.168.0.0/24').containsCIDR('192.168.0.5/24')\"}") + @TestParameters("{expr: \"!cidr('10.0.0.0/8').containsCIDR(cidr('::1/128'))\"}") + @TestParameters("{expr: \"!cidr('10.0.0.0/8').containsCIDR(cidr('11.0.0.0/8'))\"}") + @TestParameters("{expr: \"!cidr('10.0.0.0/8').containsCIDR(cidr('0.0.0.0/4'))\"}") + @TestParameters("{expr: \"cidr('10.0.0.0/8').containsIP(ip('10.255.255.255'))\"}") + @TestParameters("{expr: \"cidr('10.0.0.0/8').containsIP(ip('10.0.0.0'))\"}") + @TestParameters("{expr: \"cidr('10.0.0.0/8').containsIP(ip('10.1.2.3'))\"}") + @TestParameters("{expr: \"cidr('10.0.0.0/8').containsIP('10.1.2.3')\"}") + @TestParameters("{expr: \"cidr('192.168.1.5/24').containsIP('192.168.1.200')\"}") + @TestParameters("{expr: \"!cidr('10.0.0.0/8').containsIP(ip('11.0.0.0'))\"}") + @TestParameters("{expr: \"!cidr('2001:db8::/32').containsIP(ip('192.168.1.1'))\"}") + @TestParameters("{expr: \"!cidr('192.168.1.1/32').containsIP(ip('2001:db8::1'))\"}") + @TestParameters("{expr: \"ip('127.0.0.1') == ip('127.0.0.1')\"}") + @TestParameters("{expr: \"ip('2001:db8::1') == ip('2001:DB8::1')\"}") + @TestParameters("{expr: \"ip('127.0.0.1') != ip('1.2.3.4')\"}") + @TestParameters("{expr: \"ip('192.168.0.1') != ip('2001:db8::1')\"}") + @TestParameters("{expr: \"ip('0.0.0.0') != ip('::')\"}") + @TestParameters("{expr: \"ip('0.0.0.1') != ip('::1')\"}") + @TestParameters("{expr: \"cidr('0.0.0.0/0') != cidr('::/0')\"}") + @TestParameters("{expr: \"ip('::') != ip('::ffff')\"}") + @TestParameters("{expr: \"dyn(ip('10.0.0.1')) != dyn(cidr('10.0.0.1/32'))\"}") + @TestParameters("{expr: \"dyn(ip('0.0.0.0')) != dyn(ip('::'))\"}") + @TestParameters("{expr: \"dyn(cidr('0.0.0.0/0')) != dyn(cidr('::/0'))\"}") + @TestParameters("{expr: \"dyn(ip('10.0.0.1')) != '10.0.0.1'\"}") + @TestParameters("{expr: \"type(dyn(ip('10.0.0.1'))) == net.IP\"}") + @TestParameters("{expr: \"type(dyn(cidr('10.0.0.0/8'))) == net.CIDR\"}") + @TestParameters("{expr: \"ip.isCanonical('127.0.0.1')\"}") + @TestParameters("{expr: \"!ip.isCanonical('2001:db8:0:0:0:0:0:1')\"}") + @TestParameters("{expr: \"ip.isCanonical('2001:db8::1')\"}") + @TestParameters("{expr: \"!ip.isCanonical('2001:DB8::1')\"}") + @TestParameters("{expr: \"ip.isCanonical('2001:db8:0:1::1')\"}") + @TestParameters("{expr: \"!ip.isCanonical('2001:db8::1:1:1:1:1')\"}") + @TestParameters("{expr: \"ip.isCanonical('2001:db8:0:1:1:1:1:1')\"}") + @TestParameters("{expr: \"ip.isCanonical('::')\"}") + @TestParameters("{expr: \"ip('8.8.8.8').isGlobalUnicast()\"}") + @TestParameters("{expr: \"ip('192.168.0.1').isGlobalUnicast()\"}") + @TestParameters("{expr: \"!ip('255.255.255.255').isGlobalUnicast()\"}") + @TestParameters("{expr: \"!ip('0.0.0.0').isGlobalUnicast()\"}") + @TestParameters("{expr: \"!ip('127.0.0.1').isGlobalUnicast()\"}") + @TestParameters("{expr: \"!ip('224.0.0.1').isGlobalUnicast()\"}") + @TestParameters("{expr: \"!ip('169.254.0.1').isGlobalUnicast()\"}") + @TestParameters("{expr: \"ip('2001:db8::abcd').isGlobalUnicast()\"}") + @TestParameters("{expr: \"!ip('ff00::1').isGlobalUnicast()\"}") + @TestParameters("{expr: \"!ip('::').isGlobalUnicast()\"}") + @TestParameters("{expr: \"!ip('::1').isGlobalUnicast()\"}") + @TestParameters("{expr: \"!ip('fe80::1').isGlobalUnicast()\"}") + @TestParameters("{expr: \"ip('ff02::1').isLinkLocalMulticast()\"}") + @TestParameters("{expr: \"ip('ff12::1').isLinkLocalMulticast()\"}") + @TestParameters("{expr: \"!ip('ff05::1').isLinkLocalMulticast()\"}") + @TestParameters("{expr: \"!ip('fd00::1').isLinkLocalMulticast()\"}") + @TestParameters("{expr: \"ip('224.0.0.1').isLinkLocalMulticast()\"}") + @TestParameters("{expr: \"!ip('224.0.1.1').isLinkLocalMulticast()\"}") + @TestParameters("{expr: \"ip('169.254.169.254').isLinkLocalUnicast()\"}") + @TestParameters("{expr: \"!ip('192.168.0.1').isLinkLocalUnicast()\"}") + @TestParameters("{expr: \"ip('fe80::1').isLinkLocalUnicast()\"}") + @TestParameters("{expr: \"!ip('fd80::1').isLinkLocalUnicast()\"}") + @TestParameters("{expr: \"ip('127.0.0.1').isLoopback()\"}") + @TestParameters("{expr: \"!ip('1.2.3.4').isLoopback()\"}") + @TestParameters("{expr: \"ip('::1').isLoopback()\"}") + @TestParameters("{expr: \"!ip('2001:db8::abcd').isLoopback()\"}") + @TestParameters("{expr: \"ip('0.0.0.0').isUnspecified()\"}") + @TestParameters("{expr: \"!ip('127.0.0.1').isUnspecified()\"}") + @TestParameters("{expr: \"ip('::').isUnspecified()\"}") + @TestParameters("{expr: \"!ip('::1').isUnspecified()\"}") + @TestParameters("{expr: \"isCIDR('10.0.0.0/8')\"}") + @TestParameters("{expr: \"isCIDR('10.0.0.1/8')\"}") + @TestParameters("{expr: \"isCIDR('2001:db8::/32')\"}") + @TestParameters("{expr: \"isCIDR('::/0')\"}") + @TestParameters("{expr: \"!isCIDR('10.0.0.0/999')\"}") + @TestParameters("{expr: \"!isCIDR('10.0.0.0/08')\"}") + @TestParameters("{expr: \"!isCIDR('10.0.0.0/00')\"}") + @TestParameters("{expr: \"!isCIDR('10.0.0.0/-1')\"}") + @TestParameters("{expr: \"!isCIDR('10.0.0.0/')\"}") + @TestParameters("{expr: \"!isCIDR('10.0.0.0')\"}") + @TestParameters("{expr: \"!isCIDR('10.0.0.0/33')\"}") + @TestParameters("{expr: \"!isCIDR('::/129')\"}") + @TestParameters("{expr: \"!isCIDR('fe80::1%en0/24')\"}") + @TestParameters("{expr: \"!isCIDR('::ffff:192.168.0.1/24')\"}") + @TestParameters("{expr: \"isIP('1.2.3.4')\"}") + @TestParameters("{expr: \"isIP('2001:db8::1')\"}") + @TestParameters("{expr: \"isIP('64:ff9b::192.0.2.1')\"}") + @TestParameters("{expr: \"!isIP('')\"}") + @TestParameters("{expr: \"!isIP('not.an.ip')\"}") + @TestParameters("{expr: \"!isIP('127.0.0.1:80')\"}") + @TestParameters("{expr: \"!isIP('01.2.3.4')\"}") + @TestParameters("{expr: \"!isIP('192.168.001.1')\"}") + @TestParameters("{expr: \"!isIP('192.168.0.1.0')\"}") + @TestParameters("{expr: \"!isIP('192.168.0.')\"}") + @TestParameters("{expr: \"!isIP('.192.168.0.1')\"}") + @TestParameters("{expr: \"!isIP('2001:db8:::68')\"}") + @TestParameters("{expr: \"!isIP('1::2::3')\"}") + @TestParameters("{expr: \"!isIP('1:2:3:4:5:6:7::8')\"}") + @TestParameters("{expr: \"!isIP('fe80::1%en0')\"}") + @TestParameters("{expr: \"!isIP('::ffff:192.168.0.1')\"}") + @TestParameters("{expr: \"!isIP('::ffff:c0a8:1')\"}") + @TestParameters("{expr: \"cidr('10.0.0.0/8').isMask()\"}") + @TestParameters("{expr: \"!cidr('10.0.0.1/8').isMask()\"}") + @TestParameters("{expr: \"cidr('2001:db8::/32').isMask()\"}") + @TestParameters("{expr: \"!cidr('2001:db8::1/32').isMask()\"}") + @TestParameters("{expr: \"cidr('2001:db8::/32').containsIP(ip('2001:db8::1'))\"}") + @TestParameters("{expr: \"!cidr('2001:db8::/32').containsIP(ip('2001:dc8::1'))\"}") + @TestParameters("{expr: \"cidr('2001:db8::/32').containsIP('2001:db8::1')\"}") + @TestParameters("{expr: \"!cidr('2001:db8::/32').containsIP('2001:dc8::1')\"}") + @TestParameters("{expr: \"cidr('2001:db8::/32').containsCIDR(cidr('2001:db8::/33'))\"}") + @TestParameters("{expr: \"!cidr('2001:db8::/32').containsCIDR(cidr('2001:db8::/31'))\"}") + @TestParameters("{expr: \"cidr('2001:db8::/32').containsCIDR('2001:db8::/33')\"}") + @TestParameters("{expr: \"!cidr('2001:db8::/32').containsCIDR('2001:db8::/31')\"}") + @TestParameters("{expr: \"cidr('2001:db8::/32').ip() == ip('2001:db8::')\"}") + @TestParameters("{expr: \"cidr('2001:db8::/32').masked() == cidr('2001:db8::/32')\"}") + @TestParameters("{expr: \"cidr('2001:db8:1::/32').masked() == cidr('2001:db8::/32')\"}") + @TestParameters( + "{expr: \"cidr('ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/64').masked() ==" + + " cidr('ffff:ffff:ffff:ffff::/64')\"}") + @TestParameters("{expr: \"cidr('ffff:ffff::/0').masked() == cidr('::/0')\"}") + @TestParameters("{expr: \"cidr('2001:db8::1/128').masked() == cidr('2001:db8::1/128')\"}") + @TestParameters( + "{expr: \"cidr('2001:db8::dead:beef/112').masked() == cidr('2001:db8::dead:0/112')\"}") + @TestParameters("{expr: \"cidr('2001:db8::/96').containsIP('2001:db8::1')\"}") + @TestParameters("{expr: \"cidr('0.0.0.0/0').containsIP('192.168.1.1')\"}") + @TestParameters("{expr: \"!cidr('0.0.0.0/0').containsIP('::1')\"}") + @TestParameters("{expr: \"!ip('169.255.0.1').isLinkLocalUnicast()\"}") + @TestParameters("{expr: \"!ip('fec0::1').isLinkLocalUnicast()\"}") + @TestParameters("{expr: \"!ip('224.1.0.1').isLinkLocalMulticast()\"}") + @TestParameters("{expr: \"ip('::ffff:ffff').isGlobalUnicast()\"}") + @TestParameters("{expr: \"isIP('::192.168.0.1')\"}") + @TestParameters("{expr: \"!isIP('192.168.300.1')\"}") + @TestParameters("{expr: \"!isIP('fe80::1%')\"}") + @TestParameters("{expr: \"!isIP('gggg::1%en0')\"}") + @TestParameters("{expr: \"!isIP('1.2.3')\"}") + @TestParameters("{expr: \"!isIP('1..2.3.4')\"}") + @TestParameters("{expr: \"!isIP(':')\"}") + @TestParameters("{expr: \"!isIP('fe801::1')\"}") + @TestParameters("{expr: \"!isIP('gggg::1')\"}") + @TestParameters("{expr: \"!isIP('1:2:3:4:5:6:7:1.2.3.4')\"}") + @TestParameters("{expr: \"!isIP('1:2:3:4:5:6::1.2.3.4')\"}") + @TestParameters("{expr: \"!isIP('1:2:3:4:5:6:7:8:9')\"}") + @TestParameters("{expr: \"!isIP('1:2:3:4:5:6:7')\"}") + @TestParameters("{expr: \"!isIP('1:2:3:4:5:192.168.0.1')\"}") + @TestParameters("{expr: \"!isCIDR('999.0.0.1/24')\"}") + @TestParameters("{expr: \"!isCIDR('10.0.0.0/8/16')\"}") + @TestParameters("{expr: \"!isCIDR('10.0.0.0/1000')\"}") + @TestParameters("{expr: \"!isCIDR('fe80::1/64%en0')\"}") + @TestParameters("{expr: \"!isCIDR('10.0.0.0/ab')\"}") + @TestParameters("{expr: \"type(ip('192.168.0.1')) == net.IP\"}") + @TestParameters("{expr: \"type(cidr('192.168.0.0/24')) == net.CIDR\"}") + @TestParameters("{expr: \"type(ip('::1')) != net.CIDR\"}") + @TestParameters("{expr: \"net.IP != net.CIDR\"}") + @TestParameters("{expr: \"string(42) + ' ' + string(ip('1.2.3.4')) == '42 1.2.3.4'\"}") + public void networkExpressions_true(String expr) throws Exception { + assertThat(eval(expr)).isEqualTo(true); + } + + @Test + @TestParameters("{expr: \"string(cidr('10.0.0.0/8'))\", expected: '10.0.0.0/8'}") + @TestParameters("{expr: \"string(cidr('192.168.1.5/24'))\", expected: '192.168.1.5/24'}") + @TestParameters("{expr: \"string(cidr('::1/128'))\", expected: '::1/128'}") + @TestParameters("{expr: \"string(cidr('2001:0DB8:0:0::1/64'))\", expected: '2001:db8::1/64'}") + @TestParameters("{expr: \"string(ip('1.2.3.4'))\", expected: '1.2.3.4'}") + @TestParameters("{expr: \"string(ip('2001:db8::1'))\", expected: '2001:db8::1'}") + @TestParameters("{expr: \"string(ip('2001:0DB8:0:0:0:0:0:1'))\", expected: '2001:db8::1'}") + @TestParameters("{expr: \"string(ip('2001:0:0:1:0:0:0:1'))\", expected: '2001:0:0:1::1'}") + @TestParameters("{expr: \"string(ip('2001:0:0:1:1:0:0:1'))\", expected: '2001::1:1:0:0:1'}") + @TestParameters( + "{expr: \"string(ip('2001:db8:0:1:1:1:1:1'))\", expected: '2001:db8:0:1:1:1:1:1'}") + @TestParameters("{expr: \"string(ip('64:ff9b::192.0.2.1'))\", expected: '64:ff9b::c000:201'}") + @TestParameters("{expr: \"string(ip('0:0:0:0:0:0:0:0'))\", expected: '::'}") + public void stringConversion_success(String expr, String expected) throws Exception { + assertThat(eval(expr)).isEqualTo(expected); + } + + @Test + @TestParameters("{expr: \"ip('127.0.0.1').family()\", expected: 4}") + @TestParameters("{expr: \"ip('::1').family()\", expected: 6}") + @TestParameters("{expr: \"cidr('192.168.0.0/24').prefixLength()\", expected: 24}") + @TestParameters("{expr: \"cidr('2001:db8::/32').prefixLength()\", expected: 32}") + public void intReturnFunctions_success(String expr, long expected) throws Exception { + assertThat(eval(expr)).isEqualTo(expected); + } + + @Test + @TestParameters("{expr: \"ip('192.168.0.1.0')\", errSubstr: 'parse error'}") + @TestParameters("{expr: \"ip('01.2.3.4')\", errSubstr: 'parse error'}") + @TestParameters("{expr: \"ip('2001:db8:::68')\", errSubstr: 'parse error'}") + @TestParameters("{expr: \"ip('2001:db8:')\", errSubstr: 'parse error'}") + @TestParameters("{expr: \"ip(':2001:db8::1')\", errSubstr: 'parse error'}") + @TestParameters("{expr: \"ip('192.168.0.1%eth0')\", errSubstr: 'parse error'}") + @TestParameters("{expr: \"ip('fe80::1%en0')\", errSubstr: 'with zone value is not allowed'}") + @TestParameters("{expr: \"ip('::ffff:192.168.0.1')\", errSubstr: 'IPv4-mapped IPv6 address'}") + @TestParameters("{expr: \"ip('::ffff:c0a8:1')\", errSubstr: 'IPv4-mapped IPv6 address'}") + @TestParameters("{expr: \"ip('::FFFF:192.168.0.1')\", errSubstr: 'IPv4-mapped IPv6 address'}") + @TestParameters("{expr: \"ip.isCanonical('127.0.0.1.0')\", errSubstr: 'parse error'}") + @TestParameters("{expr: \"ip.isCanonical('2001:db8:::68')\", errSubstr: 'parse error'}") + @TestParameters("{expr: \"ip.isCanonical('fe80::1%en0')\", errSubstr: 'with zone value'}") + @TestParameters("{expr: \"cidr('192.168.0.0/')\", errSubstr: 'parse error'}") + @TestParameters("{expr: \"cidr('10.0.0.0/08')\", errSubstr: 'parse error'}") + @TestParameters("{expr: \"cidr('10.0.0.0/999')\", errSubstr: 'parse error'}") + @TestParameters("{expr: \"cidr('fe80::1%en0/24')\", errSubstr: 'with zone value is not allowed'}") + @TestParameters( + "{expr: \"cidr('::ffff:192.168.0.1/24')\", errSubstr: 'IPv4-mapped IPv6 address'}") + @TestParameters( + "{expr: \"cidr('10.0.0.0/8').containsIP('not-an-ip')\", errSubstr: 'parse error'}") + @TestParameters( + "{expr: \"cidr('10.0.0.0/8').containsCIDR('not-a-cidr')\", errSubstr: 'parse error'}") + @TestParameters("{expr: \"ip('999.999.999.999')\", errSubstr: '>255'}") + @TestParameters("{expr: \"ip('fe80::1%')\", errSubstr: 'zone must be non-empty'}") + @TestParameters("{expr: \"cidr('2001:db8::/')\", errSubstr: 'empty prefix'}") + @TestParameters("{expr: \"cidr('1.2.3.4')\", errSubstr: \"no '/'\"}") + @TestParameters("{expr: \"cidr('not-an-ip/24')\", errSubstr: 'unable to parse IP'}") + @TestParameters("{expr: \"cidr('10.0.0.0/1000')\", errSubstr: 'out of range'}") + @TestParameters("{expr: \"cidr('10.0.0.0/2a')\", errSubstr: 'invalid prefix length'}") + @TestParameters("{expr: \"cidr('10.0.0.0/8/16')\", errSubstr: 'unexpected character'}") + @TestParameters("{expr: \"cidr('fe80::1/64%en0')\", errSubstr: 'out of range'}") + public void runtimeErrors_throwsEvaluationException(String expr, String errSubstr) { + CelEvaluationException e = assertThrows(CelEvaluationException.class, () -> eval(expr)); + assertThat(e.getErrorCode()).isEqualTo(CelErrorCode.BAD_FORMAT); + assertThat(e).hasMessageThat().contains(errSubstr); + assertThat(e).hasCauseThat().isInstanceOf(CelBadFormatException.class); + int firstIdx = e.getMessage().indexOf("parse error during conversion from string:"); + if (firstIdx >= 0) { + assertThat(e.getMessage().indexOf("parse error during conversion from string:", firstIdx + 1)) + .isEqualTo(-1); + } + } + + @Test + public void compileErrors_invalidTypes_throwsValidationException() { + CelValidationException e = + assertThrows( + CelValidationException.class, + () -> cel.compile("isIP(cidr('192.168.0.0/24'))").getAst()); + assertThat(e) + .hasMessageThat() + .contains("found no matching overload for 'isIP' applied to '(net.CIDR)'"); + + assertThrows(CelValidationException.class, () -> cel.compile("ip(123)").getAst()); + } + + @Test + public void boundOpaqueVariables_andDirectOpaqueReturn_success() throws Exception { + Cel customCel = + runtimeFlavor + .builder() + .addCompilerLibraries(CelExtensions.network()) + .addRuntimeLibraries(CelExtensions.network()) + .addVar("addr", CelIp.IP_TYPE) + .addVar("subnet", CelCidr.CIDR_TYPE) + .build(); + ImmutableMap vars = + ImmutableMap.of( + "addr", CelIp.parse("10.1.2.3"), + "subnet", CelCidr.parse("10.0.0.0/8")); + + assertThat(eval(customCel, "subnet.containsIP(addr) && type(addr) == net.IP", vars)) + .isEqualTo(true); + assertThat(eval(customCel, "ip('10.1.2.3')", vars)).isEqualTo(CelIp.parse("10.1.2.3")); + assertThat(eval(customCel, "cidr('10.0.0.0/8')", vars)).isEqualTo(CelCidr.parse("10.0.0.0/8")); + assertThat(eval(customCel, "net.IP", vars)).isEqualTo(TypeType.create(CelIp.IP_TYPE)); + assertThat(eval(customCel, "net.CIDR", vars)).isEqualTo(TypeType.create(CelCidr.CIDR_TYPE)); + } + + @Test + public void separateLibraryAndLiteRuntime_checkedAndParseOnly_success() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addLibraries(CelNetworkCompilerLibrary.network()) + .build(); + CelLiteRuntime liteRuntime = + CelLiteRuntimeFactory.newLiteRuntimeBuilder() + .setStandardFunctions(CelStandardFunctions.ALL_STANDARD_FUNCTIONS) + .addLibraries(CelNetworkRuntimeLibrary.network()) + .build(); + + String expr = + "type(ip('192.168.0.1')) == net.IP && type(cidr('192.168.0.0/24')) == net.CIDR &&" + + " string(cidr('10.0.0.1/8').masked()) == '10.0.0.0/8'"; + CelAbstractSyntaxTree ast = + isParseOnly ? compiler.parse(expr).getAst() : compiler.compile(expr).getAst(); + + Object result = liteRuntime.createProgram(ast).eval(); + + assertThat(result).isEqualTo(true); + } + + @Test + public void separateLibraryAndStandardRuntime_versioned_success() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addLibraries(CelNetworkCompilerLibrary.network(0)) + .build(); + CelRuntime runtime = + CelRuntimeFactory.standardCelRuntimeBuilder() + .addFunctionBindings(CelNetworkRuntimeLibrary.network(0).newFunctionBindings()) + .build(); + + CelAbstractSyntaxTree ast = + compiler.compile("cidr('192.168.1.5/24').masked().isMask()").getAst(); + Object result = runtime.createProgram(ast).eval(); + + assertThat(result).isEqualTo(true); + } + + @Test + public void separateLibraryAndRuntime_subsetOfFunctions_success() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addLibraries( + CelNetworkCompilerLibrary.network(CelNetworkCompilerLibrary.Function.IS_IP)) + .build(); + CelRuntime runtime = + CelRuntimeFactory.standardCelRuntimeBuilder() + .addFunctionBindings( + CelNetworkRuntimeLibrary.network(CelNetworkRuntimeLibrary.Function.IS_IP) + .newFunctionBindings()) + .build(); + + CelAbstractSyntaxTree ast = compiler.compile("isIP('127.0.0.1')").getAst(); + assertThat(runtime.createProgram(ast).eval()).isEqualTo(true); + assertThrows( + CelValidationException.class, () -> compiler.compile("isCIDR('10.0.0.0/8')").getAst()); + } + + @Test + public void separateLibraryAndRuntime_setOfFunctions_success() throws Exception { + CelCompiler compiler = + CelCompilerFactory.standardCelCompilerBuilder() + .addLibraries( + CelNetworkCompilerLibrary.network( + ImmutableSet.of(CelNetworkCompilerLibrary.Function.IS_IP))) + .build(); + CelLiteRuntime liteRuntime = + CelLiteRuntimeFactory.newLiteRuntimeBuilder() + .addLibraries( + CelNetworkRuntimeLibrary.network( + ImmutableSet.of(CelNetworkRuntimeLibrary.Function.IS_IP))) + .build(); + + CelAbstractSyntaxTree ast = compiler.compile("isIP('127.0.0.1')").getAst(); + assertThat(liteRuntime.createProgram(ast).eval()).isEqualTo(true); + } + + @Test + public void network_subsetAndSetAndVersioned_success() throws Exception { + Cel subsetCel = + CelFactory.plannerCelBuilder() + .addCompilerLibraries( + CelExtensions.network( + CelNetworkExtensions.Function.IP, CelNetworkExtensions.Function.STRING)) + .addRuntimeLibraries( + CelExtensions.network( + CelNetworkExtensions.Function.IP, CelNetworkExtensions.Function.STRING)) + .build(); + assertThat(eval(subsetCel, "string(ip('127.0.0.1'))")).isEqualTo("127.0.0.1"); + assertThrows( + CelValidationException.class, () -> subsetCel.compile("ip('127.0.0.1').family()").getAst()); + + Cel setCel = + CelFactory.plannerCelBuilder() + .addCompilerLibraries( + CelExtensions.network(ImmutableSet.of(CelNetworkExtensions.Function.IS_CIDR))) + .addRuntimeLibraries( + CelExtensions.network(ImmutableSet.of(CelNetworkExtensions.Function.IS_CIDR))) + .build(); + assertThat(eval(setCel, "isCIDR('10.0.0.0/8')")).isEqualTo(true); + + Cel v1Cel = + CelFactory.plannerCelBuilder() + .addCompilerLibraries(CelExtensions.network(1)) + .addRuntimeLibraries(CelExtensions.network(1)) + .build(); + assertThat(eval(v1Cel, "isIP('::1')")).isEqualTo(true); + } + + @Test + public void unsupportedVersion_throws() { + assertThrows(IllegalArgumentException.class, () -> CelExtensions.network(99)); + assertThrows(IllegalArgumentException.class, () -> CelNetworkCompilerLibrary.network(99)); + assertThrows(IllegalArgumentException.class, () -> CelNetworkRuntimeLibrary.network(99)); + } + + @Test + public void noArgConstructor_andNullParsing_checks() { + CelNetworkExtensions extensions = new CelNetworkExtensions(); + assertThat(extensions.version()).isEqualTo(1); + assertThat(extensions.functions()).hasSize(17); + assertThat(extensions.variables()).hasSize(2); + assertThat(extensions.macros()).isEmpty(); + + assertThrows(NullPointerException.class, () -> CelIp.parse(null)); + assertThrows(NullPointerException.class, () -> CelCidr.parse(null)); + } +} diff --git a/extensions/src/test/java/dev/cel/extensions/CelNetworkTypesTest.java b/extensions/src/test/java/dev/cel/extensions/CelNetworkTypesTest.java new file mode 100644 index 000000000..5fb0d31f6 --- /dev/null +++ b/extensions/src/test/java/dev/cel/extensions/CelNetworkTypesTest.java @@ -0,0 +1,289 @@ +// 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. + +package dev.cel.extensions; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import com.google.common.testing.EqualsTester; +import com.google.testing.junit.testparameterinjector.TestParameterInjector; +import com.google.testing.junit.testparameterinjector.TestParameters; +import dev.cel.common.types.DefaultTypeProvider; +import org.junit.Test; +import org.junit.runner.RunWith; + +@RunWith(TestParameterInjector.class) +public final class CelNetworkTypesTest { + + @Test + public void defaultTypeProvider_registersNetworkOpaqueTypes() { + DefaultTypeProvider provider = DefaultTypeProvider.getInstance(); + assertThat(provider.findType("net.IP")).hasValue(CelIp.IP_TYPE); + assertThat(provider.findType("net.CIDR")).hasValue(CelCidr.CIDR_TYPE); + assertThat(provider.types()).containsAtLeast(CelIp.IP_TYPE, CelCidr.CIDR_TYPE); + assertThat(provider.findType("net.Unknown")).isEmpty(); + } + + @Test + public void nullContracts_throwNullPointerException() { + assertThrows(NullPointerException.class, () -> CelIp.parse(null)); + assertThrows(NullPointerException.class, () -> CelCidr.parse(null)); + + CelCidr cidr = CelCidr.parse("10.0.0.0/8"); + assertThrows(NullPointerException.class, () -> cidr.containsIp(null)); + assertThrows(NullPointerException.class, () -> cidr.containsCidr(null)); + } + + @Test + public void celIp_opaqueValueAndFormatting() { + CelIp ipv4 = CelIp.parse("192.168.1.42"); + assertThat(ipv4.value()).isSameInstanceAs(ipv4); + assertThat(ipv4.celType()).isEqualTo(CelIp.IP_TYPE); + assertThat(ipv4.family()).isEqualTo(4L); + assertThat(ipv4.toCanonicalString()).isEqualTo("192.168.1.42"); + assertThat(ipv4.toString()).isEqualTo("192.168.1.42"); + + CelIp ipv6 = CelIp.parse("2001:0DB8:0:0:1:0:0:1"); + assertThat(ipv6.value()).isSameInstanceAs(ipv6); + assertThat(ipv6.celType()).isEqualTo(CelIp.IP_TYPE); + assertThat(ipv6.family()).isEqualTo(6L); + // RFC 5952: leftmost tie-break for equal-length zero runs, lowercase hex, no leading zeros. + assertThat(ipv6.toCanonicalString()).isEqualTo("2001:db8::1:0:0:1"); + assertThat(ipv6.toString()).isEqualTo("2001:db8::1:0:0:1"); + } + + @Test + @TestParameters("{raw: '0.0.0.0', canonical: '0.0.0.0'}") + @TestParameters("{raw: '255.255.255.255', canonical: '255.255.255.255'}") + @TestParameters("{raw: '::', canonical: '::'}") + @TestParameters("{raw: '::1', canonical: '::1'}") + @TestParameters("{raw: '2001:db8::', canonical: '2001:db8::'}") + @TestParameters("{raw: '1:2:3:4:5:6:7:8', canonical: '1:2:3:4:5:6:7:8'}") + @TestParameters("{raw: '2001:db8:0:1:1:1:1:1', canonical: '2001:db8:0:1:1:1:1:1'}") + @TestParameters("{raw: '2001:0:0:1:0:0:0:1', canonical: '2001:0:0:1::1'}") + @TestParameters("{raw: '2001:db8:abcd:ABCD::09af:AF', canonical: '2001:db8:abcd:abcd::9af:af'}") + @TestParameters("{raw: '::192.168.0.1', canonical: '::c0a8:1'}") + @TestParameters("{raw: '64:ff9b::192.0.2.1', canonical: '64:ff9b::c000:201'}") + @TestParameters("{raw: '1:2:3:4:5:6:192.168.0.1', canonical: '1:2:3:4:5:6:c0a8:1'}") + @TestParameters("{raw: '::fffe:192.168.0.1', canonical: '::fffe:c0a8:1'}") + @TestParameters("{raw: '1::ffff:192.168.0.1', canonical: '1::ffff:c0a8:1'}") + public void celIp_parseValidAndCanonicalize(String raw, String canonical) { + CelIp ip = CelIp.parse(raw); + assertThat(ip.toCanonicalString()).isEqualTo(canonical); + assertThat(ip.toString()).isEqualTo(canonical); + } + + @Test + @TestParameters("{raw: '', errSubstr: 'unable to parse IP'}") + @TestParameters("{raw: 'not-an-ip', errSubstr: 'unable to parse IP'}") + @TestParameters("{raw: '01.2.3.4', errSubstr: 'leading zero'}") + @TestParameters("{raw: '256.0.0.1', errSubstr: '>255'}") + @TestParameters("{raw: '999.999.999.999', errSubstr: '>255'}") + @TestParameters("{raw: '.1.2.3', errSubstr: 'at least one digit'}") + @TestParameters("{raw: '1..2.3.4', errSubstr: 'at least one digit'}") + @TestParameters("{raw: '1.2.3.4.5', errSubstr: 'too long'}") + @TestParameters("{raw: '1.2.3.a', errSubstr: 'unexpected character'}") + @TestParameters("{raw: '1.2.3.-1', errSubstr: 'unexpected character'}") + @TestParameters("{raw: '1.2.3', errSubstr: 'too short'}") + @TestParameters("{raw: '1.2.3.', errSubstr: 'too short'}") + @TestParameters("{raw: '1.2.3.4:80', errSubstr: 'unexpected IPv4 prefix'}") + @TestParameters("{raw: ':', errSubstr: 'address too short'}") + @TestParameters("{raw: ':1:2:3:4:5:6:7', errSubstr: 'must have a digit'}") + @TestParameters("{raw: '20011::1', errSubstr: 'too many digits'}") + @TestParameters("{raw: '0:0:0:0:0:ffff:0:00000', errSubstr: 'too many digits'}") + @TestParameters("{raw: '2001:db8::!', errSubstr: 'unexpected character'}") + @TestParameters("{raw: '2001:db8::@', errSubstr: 'unexpected character'}") + @TestParameters("{raw: '2001:db8::G', errSubstr: 'unexpected character'}") + @TestParameters("{raw: '2001:db8::g', errSubstr: 'unexpected character'}") + @TestParameters("{raw: '2001:db8::/', errSubstr: 'unexpected character'}") + @TestParameters("{raw: 'gggg::1%en0', errSubstr: 'unexpected character'}") + @TestParameters("{raw: 'fe80::1%', errSubstr: 'zone must be non-empty'}") + @TestParameters("{raw: 'fe80::1%en0', errSubstr: 'with zone value is not allowed'}") + @TestParameters("{raw: '::ffff:192.168.0.1', errSubstr: 'IPv4-mapped IPv6 address'}") + @TestParameters("{raw: '::ffff:c0a8:1', errSubstr: 'IPv4-mapped IPv6 address'}") + @TestParameters("{raw: '::ffff:192.168.0.1%en0', errSubstr: 'with zone value is not allowed'}") + @TestParameters("{raw: '1:2:3:4:5:6:7:1.2.3.4', errSubstr: 'address too long'}") + @TestParameters("{raw: '1:2:3:4:5:6::1.2.3.4', errSubstr: 'address too long'}") + @TestParameters("{raw: '1:2:3:4:5:192.168.0.1', errSubstr: 'address too short'}") + @TestParameters("{raw: '2001::db8::1', errSubstr: 'multiple ::'}") + @TestParameters("{raw: ':::', errSubstr: 'multiple ::'}") + @TestParameters("{raw: '1:2:3:4:5:6:7:8:9', errSubstr: 'address too long'}") + @TestParameters("{raw: '2001:db8:1:', errSubstr: 'trailing colon'}") + @TestParameters("{raw: '1:2:3:4:5:6:7', errSubstr: 'address too short'}") + @TestParameters("{raw: '::1:2:3:4:5:6:7:8', errSubstr: 'too long for :: compression'}") + @TestParameters("{raw: '1:2:3:4::5:6:7:8', errSubstr: 'too long for :: compression'}") + public void celIp_parseInvalid_throwsIllegalArgumentException(String raw, String errSubstr) { + IllegalArgumentException e = + assertThrows(IllegalArgumentException.class, () -> CelIp.parse(raw)); + assertThat(e).hasMessageThat().contains(errSubstr); + } + + @Test + public void celIp_predicatesCoverAllBranches() { + assertThat(CelIp.parse("0.0.0.0").isUnspecified()).isTrue(); + assertThat(CelIp.parse("0.0.0.1").isUnspecified()).isFalse(); + assertThat(CelIp.parse("::").isUnspecified()).isTrue(); + assertThat(CelIp.parse("::1").isUnspecified()).isFalse(); + assertThat(CelIp.parse("2001:db8::").isUnspecified()).isFalse(); + + assertThat(CelIp.parse("127.0.0.1").isLoopback()).isTrue(); + assertThat(CelIp.parse("127.255.255.254").isLoopback()).isTrue(); + assertThat(CelIp.parse("128.0.0.1").isLoopback()).isFalse(); + assertThat(CelIp.parse("::1").isLoopback()).isTrue(); + assertThat(CelIp.parse("::2").isLoopback()).isFalse(); + assertThat(CelIp.parse("2001:db8::1").isLoopback()).isFalse(); + + assertThat(CelIp.parse("169.254.1.1").isLinkLocalUnicast()).isTrue(); + assertThat(CelIp.parse("169.255.0.1").isLinkLocalUnicast()).isFalse(); + assertThat(CelIp.parse("192.168.0.1").isLinkLocalUnicast()).isFalse(); + assertThat(CelIp.parse("fe80::1").isLinkLocalUnicast()).isTrue(); + assertThat(CelIp.parse("febf::1").isLinkLocalUnicast()).isTrue(); + assertThat(CelIp.parse("fe00::1").isLinkLocalUnicast()).isFalse(); + assertThat(CelIp.parse("fec0::1").isLinkLocalUnicast()).isFalse(); + assertThat(CelIp.parse("fd00::1").isLinkLocalUnicast()).isFalse(); + + assertThat(CelIp.parse("224.0.0.1").isLinkLocalMulticast()).isTrue(); + assertThat(CelIp.parse("224.0.1.1").isLinkLocalMulticast()).isFalse(); + assertThat(CelIp.parse("224.1.0.1").isLinkLocalMulticast()).isFalse(); + assertThat(CelIp.parse("239.0.0.1").isLinkLocalMulticast()).isFalse(); + assertThat(CelIp.parse("ff02::1").isLinkLocalMulticast()).isTrue(); + assertThat(CelIp.parse("ff12::1").isLinkLocalMulticast()).isTrue(); + assertThat(CelIp.parse("ff05::1").isLinkLocalMulticast()).isFalse(); + assertThat(CelIp.parse("fe80::1").isLinkLocalMulticast()).isFalse(); + + assertThat(CelIp.parse("255.255.255.255").isGlobalUnicast()).isFalse(); + assertThat(CelIp.parse("0.0.0.0").isGlobalUnicast()).isFalse(); + assertThat(CelIp.parse("127.0.0.1").isGlobalUnicast()).isFalse(); + assertThat(CelIp.parse("224.0.0.1").isGlobalUnicast()).isFalse(); + assertThat(CelIp.parse("239.255.255.255").isGlobalUnicast()).isFalse(); + assertThat(CelIp.parse("169.254.0.1").isGlobalUnicast()).isFalse(); + assertThat(CelIp.parse("192.168.1.1").isGlobalUnicast()).isTrue(); + assertThat(CelIp.parse("::").isGlobalUnicast()).isFalse(); + assertThat(CelIp.parse("::1").isGlobalUnicast()).isFalse(); + assertThat(CelIp.parse("ff00::1").isGlobalUnicast()).isFalse(); + assertThat(CelIp.parse("fe80::1").isGlobalUnicast()).isFalse(); + assertThat(CelIp.parse("::ffff:ffff").isGlobalUnicast()).isTrue(); + assertThat(CelIp.parse("2001:db8::1").isGlobalUnicast()).isTrue(); + } + + @Test + public void celCidr_opaqueValueMaskingAndContainment() { + CelCidr v4 = CelCidr.parse("192.168.1.5/24"); + assertThat(v4.value()).isSameInstanceAs(v4); + assertThat(v4.celType()).isEqualTo(CelCidr.CIDR_TYPE); + assertThat(v4.ip()).isEqualTo(CelIp.parse("192.168.1.5")); + assertThat(v4.prefixLength()).isEqualTo(24L); + assertThat(v4.isMask()).isFalse(); + assertThat(v4.toCanonicalString()).isEqualTo("192.168.1.5/24"); + assertThat(v4.toString()).isEqualTo("192.168.1.5/24"); + + CelCidr v4Masked = v4.masked(); + assertThat(v4Masked).isEqualTo(CelCidr.parse("192.168.1.0/24")); + assertThat(v4Masked.isMask()).isTrue(); + assertThat(CelCidr.parse("192.168.1.5/0").masked()).isEqualTo(CelCidr.parse("0.0.0.0/0")); + assertThat(CelCidr.parse("192.168.1.5/32").masked()).isEqualTo(CelCidr.parse("192.168.1.5/32")); + + // IPv4 /0 vs IPv6 containment + CelCidr v4Zero = CelCidr.parse("0.0.0.0/0"); + assertThat(v4Zero.containsIp(CelIp.parse("192.168.1.1"))).isTrue(); + assertThat(v4Zero.containsIp(CelIp.parse("::1"))).isFalse(); + + // IPv6 masking across /0, /32 (<64), /64, /96 and /112 (65..127), and /128 + assertThat(CelCidr.parse("2001:db8::1/0").masked()).isEqualTo(CelCidr.parse("::/0")); + assertThat(CelCidr.parse("2001:db8:abcd::1/32").masked()) + .isEqualTo(CelCidr.parse("2001:db8::/32")); + assertThat(CelCidr.parse("2001:db8:1:2:3:4:5:6/64").masked()) + .isEqualTo(CelCidr.parse("2001:db8:1:2::/64")); + assertThat(CelCidr.parse("2001:db8::1234:dead:beef/96").masked()) + .isEqualTo(CelCidr.parse("2001:db8::1234:0:0/96")); + assertThat(CelCidr.parse("2001:db8::dead:beef/112").masked()) + .isEqualTo(CelCidr.parse("2001:db8::dead:0/112")); + assertThat(CelCidr.parse("2001:db8::dead:beef/128").masked()) + .isEqualTo(CelCidr.parse("2001:db8::dead:beef/128")); + + // IPv6 /112 containment: hi match + lo match vs hi match + lo mismatch vs hi mismatch + CelCidr v6Slash112 = CelCidr.parse("2001:db8::dead:0/112"); + assertThat(v6Slash112.containsIp(CelIp.parse("2001:db8::dead:beef"))).isTrue(); + assertThat(v6Slash112.containsIp(CelIp.parse("2001:db8::beef:0"))).isFalse(); + assertThat(v6Slash112.containsIp(CelIp.parse("2001:db9::dead:0"))).isFalse(); + + // containsCidr branches: cross-family, narrower parent, disjoint, equal, and unmasked parent + assertThat(v4Zero.containsCidr(CelCidr.parse("::/0"))).isFalse(); + assertThat(CelCidr.parse("10.0.0.0/16").containsCidr(CelCidr.parse("10.0.0.0/8"))).isFalse(); + assertThat(CelCidr.parse("10.0.0.0/8").containsCidr(CelCidr.parse("11.0.0.0/16"))).isFalse(); + assertThat(CelCidr.parse("10.0.0.5/8").containsCidr(CelCidr.parse("10.1.2.0/24"))).isTrue(); + } + + @Test + @TestParameters("{raw: '1.2.3.4', errSubstr: \"no '/'\"}") + @TestParameters("{raw: 'invalid/24', errSubstr: 'unable to parse IP'}") + @TestParameters("{raw: '/24', errSubstr: 'unable to parse IP'}") + @TestParameters("{raw: '999.0.0.1/24', errSubstr: '>255'}") + @TestParameters("{raw: '10.0.0.0/8/16', errSubstr: 'unexpected character'}") + @TestParameters("{raw: 'fe80::1%/64', errSubstr: 'zone must be non-empty'}") + @TestParameters("{raw: 'fe80::1%en0/64', errSubstr: 'with zone value is not allowed'}") + @TestParameters("{raw: 'fe80::1%en0/999', errSubstr: 'with zone value is not allowed'}") + @TestParameters("{raw: '::ffff:192.168.0.1/24', errSubstr: 'IPv4-mapped IPv6 address'}") + @TestParameters("{raw: '::ffff:192.168.0.1/999', errSubstr: 'IPv4-mapped IPv6 address'}") + @TestParameters("{raw: '192.168.0.0/', errSubstr: 'empty prefix'}") + @TestParameters("{raw: '2001:db8::/', errSubstr: 'empty prefix'}") + @TestParameters("{raw: '10.0.0.0/08', errSubstr: 'leading zero'}") + @TestParameters("{raw: '10.0.0.0/00', errSubstr: 'leading zero'}") + @TestParameters("{raw: '10.0.0.0/1000', errSubstr: 'out of range'}") + @TestParameters("{raw: 'fe80::1/64%en0', errSubstr: 'out of range'}") + @TestParameters("{raw: '10.0.0.0/-1', errSubstr: 'invalid prefix length'}") + @TestParameters("{raw: '10.0.0.0/2a', errSubstr: 'invalid prefix length'}") + @TestParameters("{raw: '10.0.0.0/33', errSubstr: 'out of range'}") + @TestParameters("{raw: '2001:db8::/129', errSubstr: 'out of range'}") + public void celCidr_parseInvalid_throwsSinglePrefixedIllegalArgumentException( + String raw, String errSubstr) { + IllegalArgumentException e = + assertThrows(IllegalArgumentException.class, () -> CelCidr.parse(raw)); + assertThat(e).hasMessageThat().contains(errSubstr); + // Verify no double "CIDR '...'" error prefix wrapping on invalid IP portions. + String msg = e.getMessage(); + int firstIdx = msg.indexOf("parse error during conversion from string:"); + if (firstIdx >= 0) { + assertThat(msg.indexOf("parse error during conversion from string:", firstIdx + 1)) + .isEqualTo(-1); + assertThat(msg).startsWith("CIDR '" + raw + "' parse error during conversion from string:"); + } + } + + @Test + public void equalsAndHashCode() { + new EqualsTester() + .addEqualityGroup(CelIp.parse("0.0.0.0")) + .addEqualityGroup(CelIp.parse("::"), CelIp.parse("0:0:0:0:0:0:0:0")) + .addEqualityGroup(CelIp.parse("0.0.0.1")) + .addEqualityGroup(CelIp.parse("::1"), CelIp.parse("0:0:0:0:0:0:0:1")) + .addEqualityGroup( + CelIp.parse("2001:db8::1"), + CelIp.parse("2001:DB8::1"), + CelIp.parse("2001:0db8:0:0:0:0:0:1")) + .addEqualityGroup(CelIp.parse("2001:db8::2")) + .addEqualityGroup(CelIp.parse("2001:db9::1")) + .addEqualityGroup(CelCidr.parse("0.0.0.0/0")) + .addEqualityGroup(CelCidr.parse("::/0"), CelCidr.parse("0:0:0:0:0:0:0:0/0")) + .addEqualityGroup(CelCidr.parse("10.0.0.0/8")) + .addEqualityGroup(CelCidr.parse("10.0.0.0/16")) + .addEqualityGroup(CelCidr.parse("10.0.0.1/8")) + .addEqualityGroup( + CelCidr.parse("2001:db8::/32"), + CelCidr.parse("2001:DB8::/32"), + CelCidr.parse("2001:0db8:0:0:0:0:0:0/32")) + .testEquals(); + } +} diff --git a/runtime/src/test/java/dev/cel/runtime/BUILD.bazel b/runtime/src/test/java/dev/cel/runtime/BUILD.bazel index fb2278015..d9d35d887 100644 --- a/runtime/src/test/java/dev/cel/runtime/BUILD.bazel +++ b/runtime/src/test/java/dev/cel/runtime/BUILD.bazel @@ -205,6 +205,7 @@ cel_android_local_test( "//extensions:encoders_runtime_library_android", "//extensions:lists_runtime_library_android", "//extensions:math_runtime_library_android", + "//extensions:network_runtime_library_android", "//extensions:optional_runtime_library_android", "//extensions:regex_runtime_library_android", "//extensions:sets_runtime_library_android", diff --git a/runtime/src/test/java/dev/cel/runtime/CelLiteRuntimeAndroidTest.java b/runtime/src/test/java/dev/cel/runtime/CelLiteRuntimeAndroidTest.java index f1a9f4908..f35a96c34 100644 --- a/runtime/src/test/java/dev/cel/runtime/CelLiteRuntimeAndroidTest.java +++ b/runtime/src/test/java/dev/cel/runtime/CelLiteRuntimeAndroidTest.java @@ -49,6 +49,7 @@ import dev.cel.extensions.CelEncoderRuntimeLibrary; import dev.cel.extensions.CelListsRuntimeLibrary; import dev.cel.extensions.CelMathRuntimeLibrary; +import dev.cel.extensions.CelNetworkRuntimeLibrary; import dev.cel.extensions.CelOptionalRuntimeLibrary; import dev.cel.extensions.CelRegexRuntimeLibrary; import dev.cel.extensions.CelSetsRuntimeLibrary; @@ -875,6 +876,20 @@ public void eval_optionalExtension() throws Exception { assertThat(runtime.createProgram(ast).eval()).isEqualTo(1L); } + @Test + public void eval_networkExtension() throws Exception { + CelLiteRuntime runtime = + CelLiteRuntimeFactory.newLiteRuntimeBuilder() + .setStandardFunctions(CelStandardFunctions.ALL_STANDARD_FUNCTIONS) + .addLibraries(CelNetworkRuntimeLibrary.network()) + .build(); + // Expr: cidr('192.168.1.5/24').masked().containsIP(ip('192.168.1.42')) && + // type(ip('::1')) == net.IP + CelAbstractSyntaxTree ast = readCheckedExpr("compiled_network_cidr_contains_ip"); + + assertThat(runtime.createProgram(ast).eval()).isEqualTo(true); + } + private enum CelOptionsTestCase { UNSIGNED_LONG_DISABLED(newBaseTestOptions().enableUnsignedLongs(false).build()), UNWRAP_WKT_DISABLED(newBaseTestOptions().unwrapWellKnownTypesOnFunctionDispatch(false).build()), diff --git a/testing/src/main/java/dev/cel/testing/compiled/BUILD.bazel b/testing/src/main/java/dev/cel/testing/compiled/BUILD.bazel index 2c5921175..7ecf0a0b3 100644 --- a/testing/src/main/java/dev/cel/testing/compiled/BUILD.bazel +++ b/testing/src/main/java/dev/cel/testing/compiled/BUILD.bazel @@ -53,6 +53,7 @@ java_library( ":compiled_list_literal", ":compiled_lists_slice", ":compiled_math_greatest", + ":compiled_network_cidr_contains_ip", ":compiled_one_plus_two", ":compiled_optional_value", ":compiled_primitive_variables", @@ -130,6 +131,12 @@ compile_cel( expression = "math.greatest(1, 2)", ) +compile_cel( + name = "compiled_network_cidr_contains_ip", + environment = "//testing/environment:all_extensions", + expression = "cidr('192.168.1.5/24').masked().containsIP(ip('192.168.1.42')) && type(ip('::1')) == net.IP", +) + compile_cel( name = "compiled_optional_value", environment = "//testing/environment:all_extensions", diff --git a/testing/src/test/resources/environment/all_extensions.yaml b/testing/src/test/resources/environment/all_extensions.yaml index 80622bacc..984228090 100644 --- a/testing/src/test/resources/environment/all_extensions.yaml +++ b/testing/src/test/resources/environment/all_extensions.yaml @@ -19,6 +19,7 @@ extensions: - name: "encoders" - name: "lists" - name: "math" +- name: "network" - name: "optional" - name: "protos" - name: "regex"