From 8b40614e45c5dd7a5da5060df7bd31f82a0aa67e Mon Sep 17 00:00:00 2001 From: Sean Huh Date: Fri, 13 Nov 2026 14:52:29 -0800 Subject: [PATCH] Scope policy variables globally and trust checked element types in the verifier PiperOrigin-RevId: 1021348550 --- .../cel/verifier/CelAstToZ3Translator.java | 2 +- .../CelZ3ComprehensionTranslator.java | 42 ++++--- .../cel/verifier/CelZ3OperatorTranslator.java | 113 ++++++++++-------- .../cel/verifier/CelZ3TranslationContext.java | 14 ++- .../cel/verifier/axioms/OptionalAxioms.java | 38 ++---- .../verifier/CelPolicyVerifierImplTest.java | 73 +++++++---- .../cel/verifier/CelVerifierZ3ImplTest.java | 78 ++++++++++-- 7 files changed, 228 insertions(+), 132 deletions(-) diff --git a/verifier/src/main/java/dev/cel/verifier/CelAstToZ3Translator.java b/verifier/src/main/java/dev/cel/verifier/CelAstToZ3Translator.java index 25496cc8c..d150ec1c5 100644 --- a/verifier/src/main/java/dev/cel/verifier/CelAstToZ3Translator.java +++ b/verifier/src/main/java/dev/cel/verifier/CelAstToZ3Translator.java @@ -243,7 +243,7 @@ private TranslatedValue translateIdent(CelExpr celExpr, CelAbstractSyntaxTree as } String name = ident.name(); CelType type = ast.getTypeOrThrow(exprId); - if (type instanceof TypeType) { + if (type instanceof TypeType && !context.lookupSymbol(name).isPresent()) { TypeType typeType = (TypeType) type; if (typeType.type().kind() != CelKind.DYN) { return TranslatedValue.create( diff --git a/verifier/src/main/java/dev/cel/verifier/CelZ3ComprehensionTranslator.java b/verifier/src/main/java/dev/cel/verifier/CelZ3ComprehensionTranslator.java index 379fba20a..f4b4e1904 100644 --- a/verifier/src/main/java/dev/cel/verifier/CelZ3ComprehensionTranslator.java +++ b/verifier/src/main/java/dev/cel/verifier/CelZ3ComprehensionTranslator.java @@ -51,13 +51,6 @@ final class CelZ3ComprehensionTranslator { TranslatedValue translateComprehension(CelExpr celExpr, CelAbstractSyntaxTree ast) { CelComprehension comp = celExpr.comprehension(); CelExpr iterRangeExpr = comp.iterRange(); - if (iterRangeExpr.exprKind().getKind() == ExprKind.Kind.IDENT) { - iterRangeExpr = - context - .lookupSymbol(iterRangeExpr.ident().name()) - .flatMap(TranslatedValue::celExpr) - .orElse(iterRangeExpr); - } List iterationElements = new ArrayList<>(); List taints = new ArrayList<>(); List> allRangeElems = new ArrayList<>(); @@ -86,6 +79,7 @@ TranslatedValue translateComprehension(CelExpr celExpr, CelAbstractSyntaxTree as allRangeElems.add(key); allRangeElems.add(value); } + allRangeElems.add(translateExpr(iterRangeExpr, ast).z3Expr()); } else { return translateDynamicComprehension(celExpr, ast); } @@ -182,18 +176,36 @@ private TranslatedValue translateDynamicComprehension( isMap ? (ArrayExpr) typeSystem.getMapPresence(typeSystem.getMapRef(iterRange)) : null; BoolExpr isValidRange = isMap ? typeSystem.isMap(iterRange) : typeSystem.isList(iterRange); + int unrollLimit = unrollLimit(comp.iterRange()); BoolExpr isTruncated = context.recordUnrollLimitApproximation( - ctx.mkAnd(isValidRange, ctx.mkGt(lengthExpr, ctx.mkInt(comprehensionUnrollLimit)))); + ctx.mkAnd(isValidRange, ctx.mkGt(lengthExpr, ctx.mkInt(unrollLimit)))); context.addUnmodeledResult(isTruncated); if (isAllMacro(comp) || isExistsMacro(comp)) { return unrollAllAndExists( - celExpr, ast, seq, lengthExpr, mapPresence, isTruncated, iterRangeTv); + celExpr, ast, seq, lengthExpr, mapPresence, isTruncated, iterRangeTv, unrollLimit); } else { return unrollMapAndFilter( - celExpr, ast, seq, lengthExpr, mapPresence, isTruncated, iterRangeTv); + celExpr, ast, seq, lengthExpr, mapPresence, isTruncated, iterRangeTv, unrollLimit); + } + } + + /** The size of the literal bound to {@code iterRange}, else the unroll limit. */ + private int unrollLimit(CelExpr iterRange) { + if (iterRange.exprKind().getKind() != ExprKind.Kind.IDENT) { + return comprehensionUnrollLimit; } + return context + .lookupSymbol(iterRange.ident().name()) + .flatMap(TranslatedValue::celExpr) + .map(e -> + e.exprKind().getKind() == ExprKind.Kind.LIST + ? e.list().elements().size() + : e.exprKind().getKind() == ExprKind.Kind.MAP + ? e.map().entries().size() + : comprehensionUnrollLimit) + .orElse(comprehensionUnrollLimit); } private T withIterationScope( @@ -260,7 +272,8 @@ private TranslatedValue unrollAllAndExists( ArithExpr lengthExpr, ArrayExpr mapPresence, BoolExpr isTruncated, - TranslatedValue iterRangeTv) { + TranslatedValue iterRangeTv, + int unrollLimit) { CelComprehension comp = celExpr.comprehension(); List iterations = new ArrayList<>(); TranslatedValue accuInitTv = translateExpr(comp.accuInit(), ast); @@ -269,7 +282,7 @@ private TranslatedValue unrollAllAndExists( boolean isMap = mapPresence != null; boolean isTwoVar = !comp.iterVar2().isEmpty(); - for (int i = 0; i < comprehensionUnrollLimit; i++) { + for (int i = 0; i < unrollLimit; i++) { IntExpr idx = ctx.mkInt(i); BoolExpr inBounds = ctx.mkLt(idx, lengthExpr); Expr xVal = ctx.mkNth(seq, idx); @@ -301,7 +314,8 @@ private TranslatedValue unrollMapAndFilter( ArithExpr lengthExpr, ArrayExpr mapPresence, BoolExpr isTruncated, - TranslatedValue iterRangeTv) { + TranslatedValue iterRangeTv, + int unrollLimit) { CelComprehension comp = celExpr.comprehension(); // For macros like map and filter, we must sequentially thread the accumulator through the loop TranslatedValue chainedAccuTv = translateExpr(comp.accuInit(), ast); @@ -314,7 +328,7 @@ private TranslatedValue unrollMapAndFilter( taints.add(chainedAccuTv.isApproximate()); taints.add(iterRangeTv.isApproximate()); - for (int i = 0; i < comprehensionUnrollLimit; i++) { + for (int i = 0; i < unrollLimit; i++) { IntExpr idx = ctx.mkInt(i); BoolExpr inBounds = ctx.mkLt(idx, lengthExpr); Expr xVal = ctx.mkNth(seq, idx); diff --git a/verifier/src/main/java/dev/cel/verifier/CelZ3OperatorTranslator.java b/verifier/src/main/java/dev/cel/verifier/CelZ3OperatorTranslator.java index c223dbd9b..6f1e17e43 100644 --- a/verifier/src/main/java/dev/cel/verifier/CelZ3OperatorTranslator.java +++ b/verifier/src/main/java/dev/cel/verifier/CelZ3OperatorTranslator.java @@ -65,6 +65,14 @@ final class CelZ3OperatorTranslator { Optional translateFunctionCall( String functionName, List args, long exprId, CelAbstractSyntaxTree ast) { + ImmutableList overloadIds = + ast.getReference(exprId).map(CelReference::overloadIds).orElse(ImmutableList.of()); + if (overloadIds.equals(ImmutableList.of("optional_or_optional"))) { + return Optional.of(translateOptionalOr(functionName, args, ast, /* unwrap= */ false)); + } + if (overloadIds.equals(ImmutableList.of("optional_orValue_value"))) { + return Optional.of(translateOptionalOr(functionName, args, ast, /* unwrap= */ true)); + } Optional opOpt = Operator.findReverse(functionName); ImmutableList> z3Args = args.stream().map(TranslatedValue::z3Expr).collect(toImmutableList()); @@ -238,6 +246,43 @@ private BoolExpr constrainInWitnessTypes( mayObserveTruncatedTypeConstraint(ast, lhsTv, rhsTv))); } + /** + * Translates {@code receiver.or(alternative)}, or {@code orValue} if {@code unwrap}, which only + * evaluates the alternative if the receiver is empty. + */ + private TranslatedValue translateOptionalOr( + String functionName, List args, CelAbstractSyntaxTree ast, boolean unwrap) { + TranslatedValue receiver = args.get(0); + TranslatedValue alternative = args.get(1); + Expr optRef = typeSystem.getOptionalRef(receiver.z3Expr()); + TranslatedValue hasValue = + TranslatedValue.propagateStrict( + ctx, + typeSystem, + functionName, + typeSystem.withRuntimeError( + typeSystem.wrapBool(typeSystem.optHasValue(optRef)), + ctx.mkNot(typeSystem.isOptional(receiver.z3Expr()))), + receiver); + TranslatedValue present = + unwrap + ? TranslatedValue.create(typeSystem.getOptionalValue(optRef), typeSystem, ctx.mkFalse()) + : receiver; + Expr alt = alternative.z3Expr(); + // `isUnknown` is untested: a model can't be forced to make an unknown input unknown. + TranslatedValue absent = + unwrap + ? alternative + : TranslatedValue.create( + ctx.mkITE( + ctx.mkOr(typeSystem.isOptional(alt), typeSystem.isUnknown(alt)), + alt, + typeSystem.mkError()), + typeSystem, + alternative.isApproximate()); + return translateConditional(ImmutableList.of(hasValue, present, absent), ast); + } + private BoolExpr mkTypeGuard(Expr arg, CelType expectedType) { switch (expectedType.kind()) { case LIST: @@ -864,9 +909,6 @@ private BoolExpr listMembership( // Whether lhs may equal an element of elemType: a number only across numeric types, and a list // only another list (anything else conservatively). private BoolExpr mayEqualElement(Expr lhs, CelType elemType) { - if (elemType instanceof NullableType) { - return ctx.mkTrue(); - } if (isNumericType(elemType)) { return isNumeric(lhs); } @@ -989,8 +1031,6 @@ private TranslatedValue translateEquality( structuralEq = (BoolExpr) ctx.mkITE(bothMaps, mapEquality, structuralEq); } else if (!isStaticallyKnown(type0) && !isStaticallyKnown(type1)) { // Performance only: a side with a known type isn't a list or map here. - // TODO: Unless the type checker narrowed it, e.g. `(int_list + - // dyn_var)[0]`. structuralEq = approximateEqualityWhere( context.recordApproximation( @@ -1027,13 +1067,11 @@ private static final class IndexAccess { private final BoolExpr valid; private final BoolExpr found; private final Expr value; - private final BoolExpr isApproximate; - private IndexAccess(BoolExpr valid, BoolExpr found, Expr value, BoolExpr isApproximate) { + private IndexAccess(BoolExpr valid, BoolExpr found, Expr value) { this.valid = valid; this.found = found; this.value = value; - this.isApproximate = isApproximate; } } @@ -1043,8 +1081,7 @@ private IndexAccess listAccess(Expr lhsTrans, Expr rhsTrans) { return new IndexAccess( ctx.mkAnd(typeSystem.isList(lhsTrans), typeSystem.isInt(rhsTrans)), ctx.mkAnd(ctx.mkGe(index, ctx.mkInt(0)), ctx.mkLt(index, ctx.mkLength(seq))), - ctx.mkNth(seq, index), - /* isApproximate= */ ctx.mkFalse()); + ctx.mkNth(seq, index)); } private IndexAccess mapAccess(Expr lhsTrans, Expr rhsTrans) { @@ -1052,45 +1089,32 @@ private IndexAccess mapAccess(Expr lhsTrans, Expr rhsTrans) { return new IndexAccess( typeSystem.isMap(lhsTrans), typeSystem.hasEqualKey(lhsTrans, equalKeys), - typeSystem.valueAtEqualKey(lhsTrans, equalKeys), - /* isApproximate= */ ctx.mkFalse()); + typeSystem.valueAtEqualKey(lhsTrans, equalKeys)); } /** - * Looks up {@code rhsTrans} in the list or map {@code lhsTrans}. The value is approximate if the - * static element type isn't guaranteed and it may not conform. + * Looks up {@code rhsTrans} in the list or map {@code lhsTrans} of type {@code containerType}. */ - private IndexAccess indexAccess( - Expr lhsTrans, Expr rhsTrans, CelType containerType, boolean isLhsTypeGuaranteed) { + private IndexAccess indexAccess(Expr lhsTrans, Expr rhsTrans, CelType containerType) { IndexAccess list = listAccess(lhsTrans, rhsTrans); IndexAccess map = mapAccess(lhsTrans, rhsTrans); IndexAccess access = new IndexAccess( ctx.mkOr(list.valid, map.valid), (BoolExpr) ctx.mkITE(list.valid, list.found, map.found), - ctx.mkITE(list.valid, list.value, map.value), - /* isApproximate= */ ctx.mkFalse()); + ctx.mkITE(list.valid, list.value, map.value)); BoolExpr isRead = ctx.mkAnd(access.valid, access.found); context.constrainValidValue(isRead, access.value); - if (containerType.kind() != CelKind.MAP && containerType.kind() != CelKind.LIST) { - return access; - } - CelType elemType = - containerType.kind() == CelKind.MAP - ? ((MapType) containerType).valueType() - : ((ListType) containerType).elemType(); - BoolExpr conforms = typeConstraintGenerator.createTypeConstraintForType(access.value, elemType); - if (isLhsTypeGuaranteed) { - context.addConstraint(ctx.mkImplies(isRead, conforms)); - return access; + if (containerType instanceof MapType || containerType instanceof ListType) { + CelType elemType = + containerType instanceof MapType + ? ((MapType) containerType).valueType() + : ((ListType) containerType).elemType(); + context.addConstraint( + ctx.mkImplies( + isRead, typeConstraintGenerator.createTypeConstraintForType(access.value, elemType))); } - // The type checker may narrow other static types (e.g. `(['a'] + dyn_var)[1]` is typed - // string), so the element may not conform. - return new IndexAccess( - access.valid, - access.found, - access.value, - CelZ3Exprs.mkAndFlattened(ctx, isRead, CelZ3Exprs.mkNotFlattened(ctx, conforms))); + return access; } /** @@ -1102,7 +1126,6 @@ private TranslatedValue translateIndex( TranslatedValue lhs = args.get(0); TranslatedValue rhs = args.get(1); CelType lhsType = extractAstTypeOrDefault(lhs, ast); - boolean isLhsTypeGuaranteed = lhsType.equals(guaranteedType(lhs, ast)); CelType containerType = lhsType instanceof OptionalType ? lhsType.parameters().get(0) : lhsType; Expr lhsTrans = lhs.z3Expr(); @@ -1112,7 +1135,7 @@ private TranslatedValue translateIndex( BoolExpr lhsHasValue = typeSystem.optHasValue(optRef); lhsTrans = ctx.mkITE(isOptionalLhs, typeSystem.getOptionalValue(optRef), lhsTrans); // An empty optional's value can't be read, so constraining it is harmless. - IndexAccess access = indexAccess(lhsTrans, rhsTrans, containerType, isLhsTypeGuaranteed); + IndexAccess access = indexAccess(lhsTrans, rhsTrans, containerType); Expr element = ctx.mkITE(ctx.mkAnd(access.valid, access.found), access.value, typeSystem.mkError()); Expr optionalElement = @@ -1139,8 +1162,7 @@ private TranslatedValue translateIndex( BoolExpr isMapIndexTruncated = context.isTruncatedMap(lhsTrans); return TranslatedValue.propagateStrict(ctx, typeSystem, op.getFunction(), actualValue, args) .withApproximation( - CelZ3Exprs.mkOrFlattened( - ctx, isListIndexTruncated, isMapIndexTruncated, access.isApproximate)); + CelZ3Exprs.mkOrFlattened(ctx, isListIndexTruncated, isMapIndexTruncated)); } private TranslatedValue translateConditional( @@ -1197,12 +1219,7 @@ private static CelType extractAstTypeOrDefault(TranslatedValue val, CelAbstractS return val.celExpr().map(node -> ast.getTypeOrThrow(node.id())).orElse(SimpleType.DYN); } - /** - * Returns the type that {@code val} is guaranteed to conform to at runtime: a constant's, the - * declared type of an input variable, or else dyn. Global constraints may only be derived from - * guaranteed types: the type checker may narrow static types (e.g. {@code ['a'] + dyn_var} is - * typed list(string)), so constraints derived from those could exclude valid inputs. - */ + /** Returns a constant's type, or an input variable's declared type, or else dyn. */ private CelType guaranteedType(TranslatedValue val, CelAbstractSyntaxTree ast) { return val.isLiteral(ExprKind.Kind.CONSTANT) ? extractAstTypeOrDefault(val, ast) @@ -1254,9 +1271,11 @@ private static boolean hasStructuralEquality(CelType type) { } } + /** Excludes wrappers, whose kind is their value's but which may also be null. */ private static boolean isNumericType(CelType type) { CelKind kind = type.kind(); - return kind == CelKind.INT || kind == CelKind.UINT || kind == CelKind.DOUBLE; + return !(type instanceof NullableType) + && (kind == CelKind.INT || kind == CelKind.UINT || kind == CelKind.DOUBLE); } /** diff --git a/verifier/src/main/java/dev/cel/verifier/CelZ3TranslationContext.java b/verifier/src/main/java/dev/cel/verifier/CelZ3TranslationContext.java index 05e6e307a..ff5d80ab1 100644 --- a/verifier/src/main/java/dev/cel/verifier/CelZ3TranslationContext.java +++ b/verifier/src/main/java/dev/cel/verifier/CelZ3TranslationContext.java @@ -178,20 +178,24 @@ BoolExpr hasUnmodeledResult() { } void bindSymbol(String name, TranslatedValue value) { - localScope.put(name, value); + symbolTable.put(name, value); } Optional lookupSymbol(String name) { - return Optional.ofNullable(localScope.get(name)); + TranslatedValue local = localScope.get(name); + return Optional.ofNullable(local != null ? local : symbolTable.get(globalName(name))); } TranslatedValue computeSymbolIfAbsent( String rawName, Function mappingFunction) { - if (!rawName.startsWith(".") && localScope.containsKey(rawName)) { + if (localScope.containsKey(rawName)) { return localScope.get(rawName); } - return symbolTable.computeIfAbsent( - rawName.startsWith(".") ? rawName.substring(1) : rawName, mappingFunction); + return symbolTable.computeIfAbsent(globalName(rawName), mappingFunction); + } + + private static String globalName(String name) { + return name.startsWith(".") ? name.substring(1) : name; } /** Binds {@code varName} to {@code value} while running {@code action}, then restores it. */ diff --git a/verifier/src/main/java/dev/cel/verifier/axioms/OptionalAxioms.java b/verifier/src/main/java/dev/cel/verifier/axioms/OptionalAxioms.java index 748b6f6ca..956bb8a84 100644 --- a/verifier/src/main/java/dev/cel/verifier/axioms/OptionalAxioms.java +++ b/verifier/src/main/java/dev/cel/verifier/axioms/OptionalAxioms.java @@ -18,8 +18,6 @@ import static dev.cel.extensions.CelOptionalLibrary.OptionalDeclaration.OPTIONAL_NONE; import static dev.cel.extensions.CelOptionalLibrary.OptionalDeclaration.OPTIONAL_OF; import static dev.cel.extensions.CelOptionalLibrary.OptionalDeclaration.OPTIONAL_OF_NON_ZERO_VALUE; -import static dev.cel.extensions.CelOptionalLibrary.OptionalDeclaration.OPTIONAL_OR; -import static dev.cel.extensions.CelOptionalLibrary.OptionalDeclaration.OPTIONAL_OR_VALUE; import static dev.cel.extensions.CelOptionalLibrary.OptionalDeclaration.OPTIONAL_VALUE; import com.google.common.base.Preconditions; @@ -27,7 +25,6 @@ import com.microsoft.z3.BoolExpr; import com.microsoft.z3.Context; import com.microsoft.z3.Expr; -import com.microsoft.z3.FPExpr; import com.microsoft.z3.SeqExpr; import dev.cel.common.CelFunctionDecl; import dev.cel.common.CelOverloadDecl; @@ -72,19 +69,6 @@ final class OptionalAxioms { Expr optRef = ts.getOptionalRef(val); return Optional.of( ctx.mkITE(ts.optHasValue(optRef), ts.getOptionalValue(optRef), ts.mkError())); - }), - createBinaryAxiom( - OPTIONAL_OR_VALUE, - (ctx, ts, sink, val, other) -> { - Expr optRef = ts.getOptionalRef(val); - return Optional.of( - ctx.mkITE(ts.optHasValue(optRef), ts.getOptionalValue(optRef), other)); - }), - createBinaryAxiom( - OPTIONAL_OR, - (ctx, ts, sink, val, other) -> { - Expr optRef = ts.getOptionalRef(val); - return Optional.of(ctx.mkITE(ts.optHasValue(optRef), val, other)); })); private static BoolExpr isZeroValue(Context ctx, CelZ3TypeSystem ts, Expr val) { @@ -93,7 +77,7 @@ private static BoolExpr isZeroValue(Context ctx, CelZ3TypeSystem ts, Expr val ctx.mkAnd(ts.isBool(val), ctx.mkEq(ts.unwrapBool(val), ctx.mkFalse())), ctx.mkAnd(ts.isInt(val), ctx.mkEq(ts.getInt(val), ctx.mkInt(0))), ctx.mkAnd(ts.isUint(val), ctx.mkEq(ts.getUint(val), ctx.mkInt(0))), - ctx.mkAnd(ts.isDouble(val), ctx.mkFPIsZero((FPExpr) ts.getDouble(val))), + ctx.mkAnd(ts.isDouble(val), ctx.mkFPIsZero(ts.getDouble(val))), ctx.mkAnd(ts.isTimestamp(val), ctx.mkEq(ts.getTimestamp(val), ctx.mkInt(0))), ctx.mkAnd(ts.isDuration(val), ctx.mkEq(ts.getDuration(val), ctx.mkInt(0))), ctx.mkAnd(ts.isString(val), ctx.mkEq(ts.getString(val), ctx.mkString(""))), @@ -113,25 +97,17 @@ private static BoolExpr isZeroValue(Context ctx, CelZ3TypeSystem ts, Expr val private static CelZ3FunctionAxiom createAxiom( CelFunctionDecl.Declarer declarer, CelZ3OverloadTranslator translator) { CelFunctionDecl functionDecl = declarer.functionDecl(); - CelZ3FunctionAxiom.Builder builder = CelZ3FunctionAxiom.newBuilder(functionDecl); - builder.addOverloadTranslator(getSingleOverloadOrThrow(functionDecl), translator); - return builder.build(); + return CelZ3FunctionAxiom.newBuilder(functionDecl) + .addOverloadTranslator(getSingleOverloadOrThrow(functionDecl), translator) + .build(); } private static CelZ3FunctionAxiom createUnaryAxiom( CelFunctionDecl.Declarer declarer, CelZ3FunctionAxiom.UnaryTranslator translator) { CelFunctionDecl functionDecl = declarer.functionDecl(); - CelZ3FunctionAxiom.Builder builder = CelZ3FunctionAxiom.newBuilder(functionDecl); - builder.addUnaryOverloadTranslator(getSingleOverloadOrThrow(functionDecl), translator); - return builder.build(); - } - - private static CelZ3FunctionAxiom createBinaryAxiom( - CelFunctionDecl.Declarer declarer, CelZ3FunctionAxiom.BinaryTranslator translator) { - CelFunctionDecl functionDecl = declarer.functionDecl(); - CelZ3FunctionAxiom.Builder builder = CelZ3FunctionAxiom.newBuilder(functionDecl); - builder.addBinaryOverloadTranslator(getSingleOverloadOrThrow(functionDecl), translator); - return builder.build(); + return CelZ3FunctionAxiom.newBuilder(functionDecl) + .addUnaryOverloadTranslator(getSingleOverloadOrThrow(functionDecl), translator) + .build(); } private static CelOverloadDecl getSingleOverloadOrThrow(CelFunctionDecl functionDecl) { diff --git a/verifier/src/test/java/dev/cel/verifier/CelPolicyVerifierImplTest.java b/verifier/src/test/java/dev/cel/verifier/CelPolicyVerifierImplTest.java index 8c18f4da9..cd16e7d50 100644 --- a/verifier/src/test/java/dev/cel/verifier/CelPolicyVerifierImplTest.java +++ b/verifier/src/test/java/dev/cel/verifier/CelPolicyVerifierImplTest.java @@ -450,6 +450,54 @@ public void verifyInvariants_restrictedDestinationsPolicy_verified() throws Exce "unrestricted_destination_allowed", CelVerificationResult.verified()); } + private enum VariableReadTestCase { + INSIDE_SHADOWING_COMPREHENSION( + "[x]", "[999].all(x, variables.v.all(e, e == 999))", VerificationStatus.VIOLATED), + PAST_SHADOWING_ITERATION_VARIABLE( + "x", "[2].all(variables, .variables.v == 1)", VerificationStatus.VERIFIED), + TYPE("[int][x]", "variables.v == int", VerificationStatus.VIOLATED), + TYPE_ELEMENT("[int]", "variables.v.all(e, e == int)", VerificationStatus.VERIFIED), + LITERAL_PAST_UNROLL_LIMIT( + "[1, 2, 3, 4, 5, 6]", "variables.v.all(e, e > 0)", VerificationStatus.VERIFIED), + REPEATED_KEY("{x: 1, 1u: 2}", "variables.v.all(k, true)", VerificationStatus.VIOLATED); + + private final String variable; + private final String assertion; + private final VerificationStatus expectedStatus; + + VariableReadTestCase(String variable, String assertion, VerificationStatus expectedStatus) { + this.variable = variable; + this.assertion = assertion; + this.expectedStatus = expectedStatus; + } + } + + @Test + public void verifyInvariants_variableRead(@TestParameter VariableReadTestCase testCase) + throws Exception { + CelPolicy policy = + PARSER.parse( + "name: variable_read_policy\n" // + + "rule:\n" // + + " match:\n" // + + " - output: 'true'\n" // + + "verification:\n" // + + " variables:\n" // + + " - v: '" + + testCase.variable + + "'\n" // + + " invariants:\n" // + + " - id: reads_variable\n" // + + " assume: x == 1\n" // + + " assert: '" + + testCase.assertion + + "'"); + + ImmutableMap results = VERIFIER.verifyInvariants(policy); + + assertThat(results.get("reads_variable").status()).isEqualTo(testCase.expectedStatus); + } + @Test public void verifyInvariants_invariantReferencesPolicyVariable_verified() throws Exception { String policySource = @@ -504,31 +552,6 @@ public void verifyInvariants_verificationVariablesAndMultiClauseLists_verified() assertThat(results).containsExactly("ergonomic_inv", CelVerificationResult.verified()); } - @Test - public void verifyInvariants_literalListVariableBeyondUnrollLimit_verified() throws Exception { - String policySource = - "name: literal_list_policy\n" // - + "rule:\n" // - + " variables:\n" // - + " - xs: '[1, 2, 3, 4, 5, 6]'\n" // - + " match:\n" // - + " - output: 'true'\n" // - + "verification:\n" // - + " invariants:\n" // - + " - id: all_positive\n" // - + " assert: variables.xs.all(x, x > 0)"; - CelPolicy policy = PARSER.parse(policySource); - CelPolicyVerifier verifier = - CelPolicyVerifierFactory.newVerifier( - POLICY_COMPILER, - CelVerifierFactory.newVerifier(CEL).setComprehensionUnrollLimit(5).build()) - .build(); - - ImmutableMap results = verifier.verifyInvariants(policy); - - assertThat(results).containsExactly("all_positive", CelVerificationResult.verified()); - } - @Test public void verifyInvariants_workloadAdmissionFlawed_violationsDetected() throws Exception { Cel extendedCel = diff --git a/verifier/src/test/java/dev/cel/verifier/CelVerifierZ3ImplTest.java b/verifier/src/test/java/dev/cel/verifier/CelVerifierZ3ImplTest.java index 0fd3ba2cb..bf6dc048f 100644 --- a/verifier/src/test/java/dev/cel/verifier/CelVerifierZ3ImplTest.java +++ b/verifier/src/test/java/dev/cel/verifier/CelVerifierZ3ImplTest.java @@ -58,6 +58,7 @@ import dev.cel.optimizer.CelOptimizer; import dev.cel.optimizer.CelOptimizerFactory; import dev.cel.optimizer.optimizers.ConstantFoldingOptimizer; +import dev.cel.optimizer.optimizers.SubexpressionOptimizer; import dev.cel.parser.CelMacro; import dev.cel.parser.CelStandardMacro; import dev.cel.verifier.CelVerificationResult.VerificationStatus; @@ -159,6 +160,8 @@ public void setUp() { private enum IsSatisfiableTestCase { SATISFIABLE("x > 5", "x = (?:[6-9]|[1-9]\\d+)"), + OPTIONAL_OR_VALUE_SKIPS_APPROXIMATE_ALTERNATIVE( + "optional.of(x).orValue(int('123')) == 7", "x = 7"), DYNAMIC_ARITHMETIC("request == 1 && request + 2 == 3", "request = 1"), DYNAMIC_ARITHMETIC_UNARY("request == 1 && -request == -1", "request = 1"), GREATER_DOUBLE("d > 1.5", "d = "), @@ -212,8 +215,13 @@ private enum IsSatisfiableTestCase { INT_MAX_DOUBLE_EQUALITY( "dyn(request) == 9223372036854775808.0", "request = 9223372036854775[2-8]\\d+"), UINT_MAX_DOUBLE_EQUALITY("dyn(u) == 18446744073709551616.0", "u = 1844674407370955\\d+u"), - // The type checker narrows `int_list + dyn_var` to list(int), which must not constrain dyn_var. IN_NARROWED_LIST_CONCATENATION("dyn('a') in (int_list + dyn_var)", "dyn_var = "), + DYN_TYPE_PARAMETER_JOIN( + "!b && (b ? dyn_int_map : string_dyn_map)['a'] != (b ? dyn_int_map : string_dyn_map)['a']", + "string_dyn_map = "), + OR_VALUE_OF_DYN_NAN( + "dyn_var.orValue(1) != dyn_var.orValue(1)", + "dyn_var = optional\\.of\\(double\\(\"NaN\"\\)\\)"), // Indexing and conditionals return existing values, so they do not inherit truncated type // constraints from their operands. DYN_ELEMENT_OF_LONG_NESTED_LIST_EQUALITY( @@ -689,6 +697,11 @@ public void isSatisfiable_approximate_returnsPotentialSatisfyingInput() throws E } private enum IsSatisfiableInconclusiveTestCase { + OPTIONAL_OR_VALUE_EMPTY_RECEIVER_APPROXIMATE_ALTERNATIVE( + "optional.none().orValue(int('123')) == 7"), + OPTIONAL_OR_VALUE_APPROXIMATE_RECEIVER("optional.of(int('123')).orValue(1) == 7"), + OPTIONAL_OR_EMPTY_RECEIVER_APPROXIMATE_ALTERNATIVE( + "optional.none().or(optional.of(int('123'))) == optional.of(7)"), // A list of nullable ints may hold null past the unroll limit. NULL_IN_NULLABLE_LIST_PAST_UNROLL_LIMIT( "size(nullable_int_list) == 6 && nullable_int_list[0] != null && nullable_int_list[1] !=" @@ -834,7 +847,9 @@ public void isSatisfiable_comprehensionZeroUnrollLimit_inconclusive() throws Exc } private enum IsUnsatisfiableTestCase { + OPTIONAL_OR_NON_OPTIONAL_ALTERNATIVE("optional.none().or(dyn(x)) == dyn(x)"), DYN_MESSAGE_PRESENT_UNDECLARED_FIELD("dyn(test_all_types).unknown_field == 42"), + NULLABLE_NULL_AND_ONE("nullable_int == null && nullable_int == 1"), REPEATED_FIELD_FROM_NON_LIST( "dyn_var == 42 && TestAllTypes{repeated_int64: dyn_var} == TestAllTypes{}"), UNSATISFIABLE("x > 5 && x < 3"), @@ -1225,7 +1240,9 @@ private enum IsAlwaysTrueTestCase { OPTIONAL_OF_EQ_OF_VAR("optional.of(x) == optional.of(x)"), OPTIONAL_OF_NEQ_OF_VAR("x != y ? optional.of(x) != optional.of(y) : true"), OPTIONAL_OR_VALUE_VAR("optional.of(x).orValue(y) == x"), - // Indexing follows the value, whatever type the checker narrowed it to. + OPTIONAL_OR_VALUE_SKIPS_FAILING_ALTERNATIVE("optional.of(x).orValue(1 / 0) == x"), + OPTIONAL_OR_SKIPS_FAILING_ALTERNATIVE( + "optional.of(x).or(optional.of(1 / 0)) == optional.of(x)"), NARROWED_MAP_INDEXED_AS_LIST( "dyn_var == optional.of([2]) ? dyn_var.orValue({0: 1})[0] == 2 : true"), NARROWED_LIST_INDEXED_AS_MAP( @@ -1249,8 +1266,6 @@ private enum IsAlwaysTrueTestCase { OPTIONAL_LIST_INDEXED_BY_STRING("TestAllTypes{}.?repeated_int64[dyn('a')] == optional.none()"), OPTIONAL_LIST_OPTIONALLY_INDEXED_BY_STRING( "TestAllTypes{}.?repeated_int64[?dyn('a')] == optional.none()"), - // The checker finds several overloads for an optional(dyn) lhs, so the runtime indexes a value - // typed optional that isn't one by what it is. NARROWED_OPTIONAL_DYN_INDEX( "dyn_var == optional.of([2]) ? dyn_var.orValue(optional.of(dyn([1])))[0] == 2 : true"), NARROWED_OPTIONAL_DYN_OPTIONAL_INDEX( @@ -1778,6 +1793,19 @@ public void verifyEquivalence_withUnknownIdentifiers_inconclusive( assertThat(result.status()).isEqualTo(VerificationStatus.INCONCLUSIVE); } + @Test + public void verifyEquivalence_orValueOfNonOptionalWithUnknownAlternative_verified() + throws Exception { + CelVerifier verifier = + CelVerifierFactory.newVerifier(CEL).addUnknownIdentifier("unknown_var").build(); + CelAbstractSyntaxTree astA = CEL.compile("dyn(1).orValue(unknown_var)").getAst(); + CelAbstractSyntaxTree astB = CEL.compile("1 / 0").getAst(); + + CelVerificationResult result = verifier.verifyEquivalence(astA, astB); + + assertThat(result.status()).isEqualTo(VerificationStatus.VERIFIED); + } + @Test public void verifyEquivalence_freeVariableIndicesDeduplicated() throws Exception { CelAbstractSyntaxTree astA = @@ -1988,23 +2016,31 @@ private enum IsAlwaysTrueViolationTestCase { "string_dyn_map == string_dyn_map", "Condition is not always true\\."), // `[NaN]` is found nowhere, not even by its term. IN_LIST_NAN_LIST("[d] in [[d]]", "d = double\\(\"NaN\"\\)"), - // The checker types the value string, but at runtime it's the int 1, which equals 1.0. + NULLABLE_CONDITIONAL( + "b || nullable_int != null || dyn({'a': b ? 1 : nullable_int}.a) != null", + "nullable_int = null"), + OR_VALUE_OF_DYN_MAP_LITERAL_EQUALITY( + "dyn_var == optional.of({'a': 1.0}) ? dyn_var.orValue(string_int_map) != {'a': 1} : true", + "Condition is not always true\\."), + FIELD_OF_MESSAGE_OR_NULL( + "b || has((b ? test_all_types : null).single_int64)" + + " || !has((b ? test_all_types : null).single_int64)", + "Condition is not always true\\."), NARROWED_TYPE_NUMERIC_EQUALITY( "dyn_var == optional.of(1) ? optional.ofNonZeroValue('').or(dyn_var).value() != dyn(1.0)" + " : true", "dyn_var = optional\\.of\\(1\\)"), - // Indexing 42 errors whether or not the overload is picked by its narrowed type. NARROWED_OPTIONAL_INDEX_NOT_CONTAINER( "dyn_var == optional.of(42) ? dyn_var.orValue(optional.of([1]))[0] in [42, optional.of(42)]" + " : true", "dyn_var = optional\\.of\\(42\\)"), - // Selecting from an optional follows its value, here 42 rather than the map its type says. NARROWED_OPTIONAL_MAP_SELECTED( "dyn_var == optional.of(optional.of(42))" + " ? (dyn_var.orValue(optional.of({'a': 1})).a.hasValue()" + " || !dyn_var.orValue(optional.of({'a': 1})).a.hasValue()) : true", "dyn_var = optional\\.of\\(optional\\.of\\(42\\)\\)"), // Map literal keys must be strings, ints, uints or bools, and can't repeat. + MAP_LITERAL_RANGE_REPEATED_KEY("x == 1 ? {x: 'a', 1u: 'b'}.all(k, true) : true", "x = 1"), MAP_LITERAL_DOUBLE_KEY("{1.0: 'a'}[dyn(1)] == 'a'", "Condition is not always true\\."), MAP_LITERAL_BYTES_KEY("size({b'a': 1}) == 1", "Condition is not always true\\."), MAP_LITERAL_REPEATED_KEY("size({1: 'a', 1: 'b'}) == 1", "Condition is not always true\\."), @@ -2293,8 +2329,6 @@ private enum IsAlwaysTrueViolationTestCase { "size(int_list) == 5 ? int_list[5] == 1 : true", "Condition is not always true\\.", "Counterexample input:"), - // The type checker narrows static types (e.g. `['guest'] + dyn_var` is typed list(string)), so - // those must not constrain inputs, even in subexpressions that are never evaluated. NARROWED_LIST_IN_DOES_NOT_CONSTRAIN_INPUTS( "dyn_var != [0] || (false && 'x' in (['guest'] + dyn_var))", "Condition is not always true\\.", @@ -2514,6 +2548,9 @@ public void isAlwaysTrue_inconclusive_containsPotentialCounterexample() throws E } private enum EquivalenceInconclusiveTestCase { + OPTIONAL_OR_VALUE_OF_TRUNCATED_RECEIVER( + "size(int_list) > 5 ? int_list.map(n, optional.none())[0].orValue(1) : 0", + "size(int_list) > 5 ? int_list.map(n, optional.none())[0].orValue(2) : 0"), // A list or map typed dyn holding NaN (e.g. `[NaN]`) differs from itself, so these do diverge, // but lists and maps typed dyn on both sides compare approximately. DYN_NAN_INPUT_AND_LITERAL("dyn_var != dyn_var ? 0.0 / 0.0 : dyn_var", "dyn_var"), @@ -2641,6 +2678,7 @@ public void verifyEquivalence_inconclusive( } private enum EquivalenceTestCase { + OPTIONAL_OR_VALUE_OF_NON_OPTIONAL("dyn(1).orValue(int('123'))", "1 / 0"), STRUCT_UNSET_TIMESTAMP_DEFAULT("TestAllTypes{}.single_timestamp", "timestamp(0)"), // Both are errors. STRUCT_UNSET_ANY_DEFAULT("TestAllTypes{}.single_any == null", "1 / 0 == 1"), @@ -3188,6 +3226,8 @@ private enum EquivalenceViolationTestCase { CROSS_TYPE_SYMBOLIC_INEQUALITY_INT_UINT("dyn(x) == dyn(u)", "false"), CROSS_TYPE_SYMBOLIC_INEQUALITY_UINT_INT("dyn(u) == dyn(x)", "false"), OPTIONAL_OR_VALUE_VIOLATION("optional.of(x).orValue(y)", "y"), + OPTIONAL_OR_VALUE_FAILING_ALTERNATIVE( + "optional.of(x).orValue(1 / 0)", "optional.of(y).orValue(1 / 0)"), OPTIONAL_VALUE_VIOLATION("optional.of(x).value()", "y"), LIST_OPTIONAL_ELEMENTS_COLLISION("[1, ?opt_var]", "[1, opt_var]"), CROSS_NUMERIC_EQUALITY_INT_DYN_VIOLATION("1 == request", "false"), @@ -4024,6 +4064,26 @@ public void isAlwaysTrue_nanAndInfinityConstants_tautology( assertThat(VERIFIER.isAlwaysTrue(optimizedAst).status()).isEqualTo(VerificationStatus.VERIFIED); } + @Test + public void isAlwaysTrue_blockIndexLiteralPastUnrollLimit_verified( + @TestParameter({ + "[1, 2, 3, 4, 5, 6].all(x, x > 0) && [1, 2, 3, 4, 5, 6].exists(x, x == 6)", + "{1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0}.all(k, k > 0)" + + " && {1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0}.exists(k, k == 6)" + }) + String expr) + throws Exception { + CelOptimizer optimizer = + CelOptimizerFactory.standardCelOptimizerBuilder(CEL) + .addAstOptimizers(SubexpressionOptimizer.getInstance()) + .build(); + CelAbstractSyntaxTree ast = optimizer.optimize(CEL.compile(expr).getAst()); + + CelVerificationResult result = VERIFIER_WITHOUT_ORACLE.isAlwaysTrue(ast); + + assertThat(result.status()).isEqualTo(VerificationStatus.VERIFIED); + } + @Test public void translateFunctionCall_staticallyResolved_skipsDeadOverloads() throws Exception { CelFunctionDecl spyFuncDecl =