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+"'";

Reply via email to