From cb6013d2f05e75c57ff2a501b6b7b078a3cb362f Mon Sep 17 00:00:00 2001 From: Sean Huh Date: Tue, 10 Nov 2026 15:12:45 -0800 Subject: [PATCH] Keep values read out of `dyn` containers in their kind's range PiperOrigin-RevId: 1018591163 --- .../cel/verifier/CelAstToZ3Translator.java | 22 ++++-- .../CelZ3ComprehensionTranslator.java | 19 +++++- .../cel/verifier/CelZ3OperatorTranslator.java | 4 ++ .../cel/verifier/CelZ3TranslationContext.java | 4 +- .../dev/cel/verifier/CelZ3TypeSystem.java | 10 +++ .../java/dev/cel/verifier/axioms/InAxiom.java | 10 ++- .../cel/verifier/CelVerifierZ3ImplTest.java | 68 +++++++++---------- 7 files changed, 88 insertions(+), 49 deletions(-) diff --git a/verifier/src/main/java/dev/cel/verifier/CelAstToZ3Translator.java b/verifier/src/main/java/dev/cel/verifier/CelAstToZ3Translator.java index 8a99f6e53..00b04b199 100644 --- a/verifier/src/main/java/dev/cel/verifier/CelAstToZ3Translator.java +++ b/verifier/src/main/java/dev/cel/verifier/CelAstToZ3Translator.java @@ -24,7 +24,6 @@ import com.microsoft.z3.Expr; import com.microsoft.z3.FuncDecl; import com.microsoft.z3.Model; -import com.microsoft.z3.Quantifier; import com.microsoft.z3.SeqExpr; import com.microsoft.z3.Sort; import dev.cel.common.CelAbstractSyntaxTree; @@ -135,14 +134,21 @@ TranslatedValue translate(CelAbstractSyntaxTree ast) { Set> listRefs = new LinkedHashSet<>(); Set> mapRefs = new LinkedHashSet<>(); Set> msgRefs = new LinkedHashSet<>(); + Set> optRefs = new LinkedHashSet<>(); for (Expr constraint : context.constraints()) { - collectReferences(constraint, visited, listRefs, mapRefs, msgRefs); + collectReferences(constraint, visited, listRefs, mapRefs, msgRefs, optRefs); } - collectReferences(result.z3Expr(), visited, listRefs, mapRefs, msgRefs); + collectReferences(result.z3Expr(), visited, listRefs, mapRefs, msgRefs, optRefs); CelZ3ExtensionalityAxioms.generateAxioms(ctx, typeSystem, listRefs, mapRefs, msgRefs) .forEach(context::addConstraint); + // A present optional holds a CEL value, even when the optional is held by a dyn. + for (Expr ref : optRefs) { + context.constrainValidValue( + ctx.mkAnd(typeSystem.isOptional(ref.getArgs()[0]), typeSystem.optHasValue(ref)), + typeSystem.getOptionalValue(ref)); + } return result; } @@ -152,7 +158,8 @@ private void collectReferences( Set> visited, Set> listRefs, Set> mapRefs, - Set> msgRefs) { + Set> msgRefs, + Set> optRefs) { if (!visited.add(expr)) { return; } @@ -164,13 +171,14 @@ private void collectReferences( } else if (sort.equals(typeSystem.messageRefSort())) { msgRefs.add(expr); } + if (expr.isApp() && typeSystem.isOptionalRefAccessor(expr.getFuncDecl())) { + optRefs.add(expr); + } if (expr.isApp()) { for (Expr arg : expr.getArgs()) { - collectReferences(arg, visited, listRefs, mapRefs, msgRefs); + collectReferences(arg, visited, listRefs, mapRefs, msgRefs, optRefs); } - } else if (expr.isQuantifier()) { - collectReferences(((Quantifier) expr).getBody(), visited, listRefs, mapRefs, msgRefs); } } diff --git a/verifier/src/main/java/dev/cel/verifier/CelZ3ComprehensionTranslator.java b/verifier/src/main/java/dev/cel/verifier/CelZ3ComprehensionTranslator.java index c0a2b3ed2..d6a55bbcf 100644 --- a/verifier/src/main/java/dev/cel/verifier/CelZ3ComprehensionTranslator.java +++ b/verifier/src/main/java/dev/cel/verifier/CelZ3ComprehensionTranslator.java @@ -36,6 +36,7 @@ import java.util.List; import java.util.function.BiFunction; import java.util.function.Supplier; +import org.jspecify.annotations.Nullable; /** Translates CEL comprehensions to Z3, unrolling them up to the comprehension unroll limit. */ @SuppressWarnings({"unchecked", "rawtypes"}) // Z3 Java API uses raw types. @@ -273,7 +274,7 @@ private TranslatedValue unrollAllAndExists( BoolExpr inBounds = ctx.mkLt(idx, lengthExpr); Expr xVal = ctx.mkNth(seq, idx); - constrainIterationElement(idx, lengthExpr, xVal, inBounds, mapPresence); + constrainIterationElement(idx, lengthExpr, xVal, inBounds, mapPresence, iterRangeTv.z3Expr()); IterationElement iterElem = getIterationElement(xVal, idx, iterRangeTv.z3Expr(), isMap, isTwoVar); @@ -318,7 +319,7 @@ private TranslatedValue unrollMapAndFilter( BoolExpr inBounds = ctx.mkLt(idx, lengthExpr); Expr xVal = ctx.mkNth(seq, idx); - constrainIterationElement(idx, lengthExpr, xVal, inBounds, mapPresence); + constrainIterationElement(idx, lengthExpr, xVal, inBounds, mapPresence, iterRangeTv.z3Expr()); Expr currentAccu = chainedAccu; IterationElement iterElem = @@ -377,7 +378,12 @@ private TranslatedValue unrollMapAndFilter( } private void constrainIterationElement( - IntExpr idx, ArithExpr lengthExpr, Expr xVal, BoolExpr inBounds, ArrayExpr mapPresence) { + IntExpr idx, + ArithExpr lengthExpr, + Expr xVal, + BoolExpr inBounds, + @Nullable ArrayExpr mapPresence, + Expr iterRange) { // Constrain out-of-bounds elements to prevent MBQI from infinitely instantiating list/map // axioms BoolExpr outOfBounds = ctx.mkGe(idx, lengthExpr); @@ -389,6 +395,13 @@ private void constrainIterationElement( Expr selectExpr = ctx.mkSelect(mapPresence, xVal); context.addConstraint(ctx.mkImplies(inBounds, (BoolExpr) selectExpr)); } + + // Elements of a list, and keys of a map, are CEL values. + context.constrainValidValue( + ctx.mkAnd( + mapPresence == null ? typeSystem.isList(iterRange) : typeSystem.isMap(iterRange), + inBounds), + xVal); } private TranslatedValue reduceAllOrExists( diff --git a/verifier/src/main/java/dev/cel/verifier/CelZ3OperatorTranslator.java b/verifier/src/main/java/dev/cel/verifier/CelZ3OperatorTranslator.java index c7a422eb1..a44f730dd 100644 --- a/verifier/src/main/java/dev/cel/verifier/CelZ3OperatorTranslator.java +++ b/verifier/src/main/java/dev/cel/verifier/CelZ3OperatorTranslator.java @@ -659,6 +659,10 @@ private BoolExpr unrollListEquality( IntExpr idx = ctx.mkInt(i); Expr elem0 = ctx.mkNth(seq0, idx); Expr elem1 = ctx.mkNth(seq1, idx); + context.constrainValidValue( + ctx.mkAnd(typeSystem.isList(listA.z3Expr()), ctx.mkLt(idx, ctx.mkLength(seq0))), elem0); + context.constrainValidValue( + ctx.mkAnd(typeSystem.isList(listB.z3Expr()), ctx.mkLt(idx, ctx.mkLength(seq1))), elem1); if (i >= comprehensionUnrollLimit) { constrainListElement(seq0, idx, elem0, type0); diff --git a/verifier/src/main/java/dev/cel/verifier/CelZ3TranslationContext.java b/verifier/src/main/java/dev/cel/verifier/CelZ3TranslationContext.java index 203cf5b2c..fb6f7270d 100644 --- a/verifier/src/main/java/dev/cel/verifier/CelZ3TranslationContext.java +++ b/verifier/src/main/java/dev/cel/verifier/CelZ3TranslationContext.java @@ -75,9 +75,9 @@ void addConstraint(BoolExpr constraint) { constraints.add(constraint); } - /** Constrains {@code value} to be neither an error nor unknown whenever {@code guard} holds. */ + /** Constrains {@code value} to be a CEL value whenever {@code guard} holds. */ void constrainValidValue(BoolExpr guard, Expr value) { - addConstraint(ctx.mkImplies(guard, ctx.mkNot(typeSystem.isErrorOrUnknown(value)))); + addConstraint(ctx.mkImplies(guard, typeSystem.isValidValue(value))); } void addInputVariable(Expr variable, CelType declaredType) { diff --git a/verifier/src/main/java/dev/cel/verifier/CelZ3TypeSystem.java b/verifier/src/main/java/dev/cel/verifier/CelZ3TypeSystem.java index e8d226c43..b0f05b68f 100644 --- a/verifier/src/main/java/dev/cel/verifier/CelZ3TypeSystem.java +++ b/verifier/src/main/java/dev/cel/verifier/CelZ3TypeSystem.java @@ -573,6 +573,11 @@ public Expr getOptionalRef(Expr val) { return ctx.mkApp(optionalCons.getAccessorDecls()[0], val); } + /** Whether {@code func} is the accessor {@link #getOptionalRef} applies. */ + boolean isOptionalRefAccessor(FuncDecl func) { + return func.equals(optionalCons.getAccessorDecls()[0]); + } + /** Checks if the given optional reference contains a value. */ public BoolExpr optHasValue(Expr optRef) { return ctx.mkNot(ctx.mkEq(optRef, mkNoneOptionalRef())); @@ -819,6 +824,11 @@ BoolExpr isValidScalar(Expr val) { ctx.mkImplies(isDuration(val), ctx.mkNot(checkDurationOverflow(getDuration(val))))); } + /** Returns whether {@code val} is a CEL value: neither an error nor unknown, and in range. */ + public BoolExpr isValidValue(Expr val) { + return ctx.mkAnd(ctx.mkNot(isErrorOrUnknown(val)), isValidScalar(val)); + } + /** Checks if the given arithmetic expression overflows a 64-bit unsigned integer. */ public BoolExpr checkUintOverflow(ArithExpr result) { return ctx.mkOr( diff --git a/verifier/src/main/java/dev/cel/verifier/axioms/InAxiom.java b/verifier/src/main/java/dev/cel/verifier/axioms/InAxiom.java index 809d93725..56b2d366b 100644 --- a/verifier/src/main/java/dev/cel/verifier/axioms/InAxiom.java +++ b/verifier/src/main/java/dev/cel/verifier/axioms/InAxiom.java @@ -76,8 +76,14 @@ public final class InAxiom { BoolExpr containsIntOrUint = ctx.mkOr( - ctx.mkContains((Expr) seq, (Expr) ctx.mkUnit(typeSystem.wrapInt(intVal))), - ctx.mkContains((Expr) seq, (Expr) ctx.mkUnit(typeSystem.wrapUint(intVal)))); + ctx.mkAnd( + ctx.mkNot(typeSystem.checkIntOverflow(intVal)), + ctx.mkContains( + (Expr) seq, (Expr) ctx.mkUnit(typeSystem.wrapInt(intVal)))), + ctx.mkAnd( + ctx.mkNot(typeSystem.checkUintOverflow(intVal)), + ctx.mkContains( + (Expr) seq, (Expr) ctx.mkUnit(typeSystem.wrapUint(intVal))))); BoolExpr intOrUintInList = (BoolExpr) ctx.mkITE(isIntOrUintZero, containsAnyZero, containsIntOrUint); diff --git a/verifier/src/test/java/dev/cel/verifier/CelVerifierZ3ImplTest.java b/verifier/src/test/java/dev/cel/verifier/CelVerifierZ3ImplTest.java index 759923d03..94d10613a 100644 --- a/verifier/src/test/java/dev/cel/verifier/CelVerifierZ3ImplTest.java +++ b/verifier/src/test/java/dev/cel/verifier/CelVerifierZ3ImplTest.java @@ -226,23 +226,6 @@ private enum IsSatisfiableTestCase { // An infinite double has no truncation, and the comparisons never need one. INFINITE_DOUBLE_ABOVE_INT( "x < d && d > 1.7976931348623157e308", "d = double\\(\"Infinity\"\\)"), - // Values reached by indexing into a dyn value aren't range constrained. - TIMESTAMP_ABOVE_RANGE_SATISFIABLE( - "type(dyn_var[0]) == google.protobuf.Timestamp" - + " && dyn_var[0] > google.protobuf.Timestamp{seconds: 253402300799, nanos: 999999999}", - "dyn_var = .*timestamp\\(\\d+\\)"), - TIMESTAMP_BELOW_RANGE_SATISFIABLE( - "type(dyn_var[0]) == google.protobuf.Timestamp" - + " && dyn_var[0] < google.protobuf.Timestamp{seconds: -62135596800}", - "dyn_var = .*timestamp\\(-\\d+\\)"), - DURATION_ABOVE_RANGE_SATISFIABLE( - "type(dyn_var[0]) == google.protobuf.Duration" - + " && dyn_var[0] > google.protobuf.Duration{seconds: 315576000000, nanos: 999999999}", - "dyn_var = .*duration\\(\"\\d+s\"\\)"), - DURATION_BELOW_RANGE_SATISFIABLE( - "type(dyn_var[0]) == google.protobuf.Duration && dyn_var[0] <" - + " google.protobuf.Duration{seconds: -315576000000, nanos: -999999999}", - "dyn_var = .*duration\\(\"-\\d+s\"\\)"), ; private final String expr; @@ -352,21 +335,6 @@ public void isSatisfiable_witnessValueSatisfiesExpressionAndDisplayRoundTrips( } private enum InexactWitnessTestCase { - INT_OUT_OF_RANGE("type(dyn_var[0]) == int && dyn_var[0] > 9223372036854775807", "dyn_var"), - UINT_OUT_OF_RANGE("type(dyn_var[0]) == uint && dyn_var[0] > 18446744073709551615u", "dyn_var"), - NEGATIVE_UINT("type(dyn_var[0]) == uint && dyn_var[0] < 0u", "dyn_var"), - TIMESTAMP_OUT_OF_RANGE( - "type(dyn_var[0]) == google.protobuf.Timestamp" - + " && dyn_var[0] > google.protobuf.Timestamp{seconds: 253402300799, nanos: 999999999}", - "dyn_var"), - DURATION_ABOVE_MAX( - "type(dyn_var[0]) == google.protobuf.Duration" - + " && dyn_var[0] > google.protobuf.Duration{seconds: 315576000000, nanos: 999999999}", - "dyn_var"), - DURATION_BELOW_MIN( - "type(dyn_var[0]) == google.protobuf.Duration && dyn_var[0] <" - + " google.protobuf.Duration{seconds: -315576000000, nanos: -999999999}", - "dyn_var"), SURROGATE_STRING( "size(string_var) == 1 && string_var > '\\ud7ff' && string_var < '\\ue000'", "string_var"), NON_ASCII_BYTES("by == b'\\xc3\\xa9'", "by"), @@ -706,9 +674,6 @@ private enum IsSatisfiableInconclusiveTestCase { APPROXIMATED_INT_TO_STRING("string(123) == '123'"), APPROXIMATED_RANGE("int('123') > 100 && int('123') < 200"), APPROXIMATED_BRANCHING("int('123') == 123 ? x > 5 : false"), - // An element indexed out of a dyn value may be out of range, unlike the literal list holding - // it. - OUT_OF_RANGE_NESTED_DYN_ELEMENT("type([dyn_var[0]][0]) == uint && [dyn_var[0]][0] < 0u"), // The exact pass refines its candidate away; its assertions mustn't leak into the next pass. APPROXIMATED_AFTER_REFINEMENT("(dyn(x) == d && d == 1.5) || int(string_var) == 5"), APPROXIMATED_STRING_TO_INT_CONSTRAINED("string_var == 'abc' && int(string_var) == 5"), @@ -886,6 +851,32 @@ private enum IsUnsatisfiableTestCase { DYN_INT_OUT_OF_RANGE("type(dyn_var) == int && dyn_var > 9223372036854775807"), DYN_UINT_OUT_OF_RANGE("type(dyn_var) == uint && dyn_var > 18446744073709551615u"), DYN_NEGATIVE_UINT("type(dyn_var) == uint && dyn_var < 0u"), + DYN_INDEXED_NEGATIVE_UINT("type(dyn_var[0]) == uint && dyn_var[0] < 0u"), + DYN_INDEXED_INT_OUT_OF_RANGE("type(dyn_var['k']) == int && dyn_var['k'] > 9223372036854775807"), + DYN_OPTIONAL_VALUE_OUT_OF_RANGE("type(dyn_var.value()) == uint && dyn_var.value() < 0u"), + DYN_LIST_COMPREHENSION_ELEMENT_OUT_OF_RANGE( + "size(dyn_list) == 0 && size(dyn_var) == 1" + + " && (dyn_list + dyn_var).exists(x, type(x) == uint && x < 0u)"), + DYN_LIST_FILTER_ELEMENT_OUT_OF_RANGE( + "size(dyn_list) == 0 && size(dyn_var) == 1" + + " && size((dyn_list + dyn_var).filter(x, type(x) == uint && x < 0u)) == 1"), + DYN_OPTIONAL_LIST_COMPREHENSION_ELEMENT_OUT_OF_RANGE( + "[?dyn_var].exists(x, type(x) == uint && x < 0u)"), + DYN_MAP_COMPREHENSION_VALUE_OUT_OF_RANGE( + "{?'a': dyn_var}.exists(k, v, type(v) == uint && v < 0u)"), + DYN_OPTIONAL_LIST_ELEMENT_OUT_OF_INT_RANGE( + "d == -9223372036854777856.0 && [?dyn_var.?f] != [d] && ([?dyn_var.?f] + []) == [d]"), + DYN_LIST_EQUALITY_OUT_OF_RANGE_LEFT_ELEMENT( + "d == -9223372036854777856.0 && dyn_var == [d] && !(d in dyn_var)"), + DYN_LIST_EQUALITY_OUT_OF_RANGE_RIGHT_ELEMENT( + "d == -9223372036854777856.0 && [d] == dyn_var && !(d in dyn_var)"), + DYN_IN_LIST_OUT_OF_RANGE_CROSS_TYPE_CANDIDATE( + "size(dyn_var + []) == 1" + + " && ((-1 in dyn_var && dyn_var != ([-1] + []))" + + " || (18446744073709551615u in dyn_var" + + " && dyn_var != ([18446744073709551615u] + [])))"), + DYN_OPTIONAL_OR_VALUE_OUT_OF_RANGE( + "type(dyn_var.orValue(1u)) == uint && dyn_var.orValue(1u) < 0u"), ANY_NEGATIVE_UINT("type(test_all_types.single_any) == uint && test_all_types.single_any < 0u"), DYN_TIMESTAMP_OUT_OF_RANGE( "type(dyn_var) == google.protobuf.Timestamp" @@ -2657,6 +2648,13 @@ private enum EquivalenceTestCase { DOUBLE_NAN_ARITHMETIC("d != d ? d + 1.0 : 0.0", "d != d ? d : 0.0"), DOUBLE_NAN_INPUT_AND_LITERAL("d != d ? d : 0.0", "d != d ? 0.0 / 0.0 : 0.0"), DYN_NAN_INPUT_AND_LITERAL("dyn_var != dyn_var ? 0.0 / 0.0 : dyn_var", "dyn_var"), + DYN_INDEXED_NAN_AND_LITERAL("dyn_var[0] != dyn_var[0] ? 0.0 / 0.0 : dyn_var[0]", "dyn_var[0]"), + DYN_OPTIONAL_JSON_NAN_AND_LITERAL( + "google.protobuf.Value{?number_value: dyn_var} != google.protobuf.Value{?number_value:" + + " dyn_var} ? 0.0 / 0.0 : google.protobuf.Value{?number_value: dyn_var}", + "google.protobuf.Value{?number_value: dyn_var}"), + DYN_OPTIONAL_NAN_AND_LITERAL( + "dyn_var.value() != dyn_var.value() ? 0.0 / 0.0 : dyn_var.value()", "dyn_var.value()"), ANY_NAN_FIELD_AND_LITERAL( "test_all_types.single_any != test_all_types.single_any" + " ? 0.0 / 0.0 : test_all_types.single_any",