This is an automated email from the ASF dual-hosted git repository. afs pushed a commit to branch main in repository https://gitbox.apache.org/repos/asf/jena.git
commit 53e3d05fa4ed42356a939ea075d1f827cd84edaf Author: Rob Vesse <[email protected]> AuthorDate: Thu Oct 8 11:36:19 2026 +0100 Limit Shex regex constraint evaluation Shex regular expression constraints could run too long depending on the regular expression and data combinations. This commit uses the shared RegexEngine.timeBounded() mechanism to limit evaluation time. Also disables a test scenario where optimisation effects means that the test does not reliably fail so is not a useful stable test. --- .../org/apache/jena/sparql/expr/RegexEngine.java | 27 +++++++++++++++++++--- .../jena/sparql/expr/nodevalue/XSDFuncOp.java | 4 +--- .../jena/sparql/pfunction/library/strSplit.java | 3 +-- .../org/apache/jena/sparql/expr/TestRegex.java | 6 ++++- .../jena/shex/expressions/StrRegexConstraint.java | 2 +- 5 files changed, 32 insertions(+), 10 deletions(-) diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/RegexEngine.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/RegexEngine.java index e9abbd51b1..96812f5eae 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/RegexEngine.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/RegexEngine.java @@ -156,7 +156,7 @@ public abstract class RegexEngine { @Override public boolean match(String s) { - Matcher m = MAX_REGEX_EVALUATION_TIME >= 0 ? regexPattern.matcher(new TimeBoundedCharSequence(s, MAX_REGEX_EVALUATION_TIME)) : regexPattern.matcher(s); + Matcher m = regexPattern.matcher(RegexEngine.timeBounded(s)); return m.find(); } } @@ -203,18 +203,39 @@ public abstract class RegexEngine { }; } + /** + * Returns a potentially time-bounded character sequence + * <p> + * If {@link #MAX_REGEX_EVALUATION_TIME} is set to a positive non-zero value then a time-bounded + * {@link CharSequence} is returned to prevent regular expression evaluation taking too long. If it's set to + * anything else then the original character sequence is returned. + * </p> + * @param charSequence Original character sequence to time bound + * @return Possible time-bounded Character Sequence, or {@code null} if the input was {@code null} + */ + public static CharSequence timeBounded(CharSequence charSequence) { + if (charSequence == null) { + return null; + } + if (RegexEngine.MAX_REGEX_EVALUATION_TIME > 0) { + return new TimeBoundedCharSequence(charSequence, RegexEngine.MAX_REGEX_EVALUATION_TIME); + } else { + return charSequence; + } + } + /** * A {@link CharSequence} and {@link CharacterIterator} that time bounds operations so that if too much time is * spent accessing it {@link ExprEvalException}'s will be thrown. This is used to protect the regular expression * evaluation against catastrophic backtracking. */ - public static final class TimeBoundedCharSequence implements CharSequence, CharacterIterator { + static final class TimeBoundedCharSequence implements CharSequence, CharacterIterator { private final CharSequence data; private final long timeLimit; private int iterIndex = 0; - public TimeBoundedCharSequence(CharSequence characters, long timeLimitMillis) { + TimeBoundedCharSequence(CharSequence characters, long timeLimitMillis) { this.data = characters; this.timeLimit = timeLimitMillis < System.currentTimeMillis() ? System.currentTimeMillis() + timeLimitMillis : timeLimitMillis; // Note always make an immediate time limit check as if we've been constructed as a sub-sequence then diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/expr/nodevalue/XSDFuncOp.java b/jena-arq/src/main/java/org/apache/jena/sparql/expr/nodevalue/XSDFuncOp.java index 5d08d03248..25319698a0 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/expr/nodevalue/XSDFuncOp.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/expr/nodevalue/XSDFuncOp.java @@ -647,9 +647,7 @@ public class XSDFuncOp public static NodeValue strReplace(NodeValue nvStr, Pattern pattern, NodeValue nvReplacement) { String n = NodeValueOps.checkAndGetStringLiteral("replace", nvStr).getLiteralLexicalForm(); String rep = NodeValueOps.checkAndGetStringLiteral("replace", nvReplacement).getLiteralLexicalForm(); - CharSequence matchSource = RegexEngine.MAX_REGEX_EVALUATION_TIME > 0 ? - new RegexEngine.TimeBoundedCharSequence(n, RegexEngine.MAX_REGEX_EVALUATION_TIME) : n; - String x = replaceAll(pattern.matcher(matchSource), rep); + String x = replaceAll(pattern.matcher(RegexEngine.timeBounded(n)), rep); if ( x == null ) // No replacement. return nvStr; diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/pfunction/library/strSplit.java b/jena-arq/src/main/java/org/apache/jena/sparql/pfunction/library/strSplit.java index 96554f36d8..d123dbb6c1 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/pfunction/library/strSplit.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/pfunction/library/strSplit.java @@ -79,8 +79,7 @@ public class strSplit extends PFuncSimpleAndList List<String> tokens; if (RegexEngine.MAX_REGEX_EVALUATION_TIME > 0) { Pattern pattern = Pattern.compile(regex); - tokens = Arrays.stream( - pattern.split(new RegexEngine.TimeBoundedCharSequence(s, RegexEngine.MAX_REGEX_EVALUATION_TIME), 0)) + tokens = Arrays.stream(pattern.split(RegexEngine.timeBounded(s), 0)) .map(String::trim) .toList(); } else { diff --git a/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestRegex.java b/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestRegex.java index 3dfc4ca08f..2412d1b1bf 100644 --- a/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestRegex.java +++ b/jena-arq/src/test/java/org/apache/jena/sparql/expr/TestRegex.java @@ -44,6 +44,8 @@ import org.apache.jena.sparql.engine.binding.BindingFactory; public class TestRegex { + protected static final String ALPHABET_CSV = "a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,z,"; + private static Stream<Arguments> provideArgs() { List<Arguments> x = List.of( Arguments.of( "Java Regex", RegexEngine.RegexImpl.Java), @@ -122,7 +124,9 @@ public class TestRegex public static Stream<Arguments> backtrackingRegex() { return Stream.of( - Arguments.of("a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,z,y,z", "^(.*?,){11}P", "m", false), + // While this is a nice example it behaves very different using Java vs Xerces regex so isn't + // a stable test + /*Arguments.of(ALPHABET_CSV, "^(.*?,){11}P", "m", false),*/ Arguments.of(Strings.repeat("a", 4096) + "!", "(a+)+$", "m", false), Arguments.of(Strings.repeat("a", 32 * 1024) + "!", "(a+)+$", "m", false) ); diff --git a/jena-shex/src/main/java/org/apache/jena/shex/expressions/StrRegexConstraint.java b/jena-shex/src/main/java/org/apache/jena/shex/expressions/StrRegexConstraint.java index 50e439f581..3de403530f 100644 --- a/jena-shex/src/main/java/org/apache/jena/shex/expressions/StrRegexConstraint.java +++ b/jena-shex/src/main/java/org/apache/jena/shex/expressions/StrRegexConstraint.java @@ -70,7 +70,7 @@ public class StrRegexConstraint extends NodeConstraintComponent { return new ReportItem(msg, n); } String str = NodeFunctions.str(n); - boolean b = pattern.matcher(str).find(); + boolean b = pattern.matcher(RegexEngine.timeBounded(str)).find(); if ( b ) return null; String msg = toString()+": Does not match: '"+str+"'";
