This is an automated email from the ASF dual-hosted git repository.

gnodet pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/maven.git


The following commit(s) were added to refs/heads/master by this push:
     new bd1d610413 fix: protect cached VersionRange restriction lists from 
mutation (#13999)
bd1d610413 is described below

commit bd1d61041394fe485bb2902a6dc063290bb6ad8a
Author: Amar Ghugare <[email protected]>
AuthorDate: Mon Nov 16 20:45:27 2026 +0530

    fix: protect cached VersionRange restriction lists from mutation (#13999)
    
    - `VersionRange` caches and returns shared instances from 
`createFromVersionSpec()` and `createFromVersion()`, but `getRestrictions()` 
exposed the mutable backing list; callers that cleared or mutated it corrupted 
subsequent range checks for every other caller using the same cached 
specification
    - Move the `Collections.unmodifiableList()` wrap into the private 
constructor so every code path (direct construction, `cloneOf()`, `restrict()`) 
produces an immutable restriction list from the start; remove the now-redundant 
wrapping in `restrict()`
    - Document `getRestrictions()` to state that the returned list is 
unmodifiable and non-null
    - Add parameterized tests verifying that cached, cloned, intersected, and 
version-only ranges all throw `UnsupportedOperationException` on mutation 
attempts and that the cache remains consistent after attempted mutation
    - Backported to `maven-3.10.x` (#13997) and `maven-3.9.x` (#13998)
---
 .../maven/artifact/versioning/VersionRange.java    | 12 ++++-
 .../artifact/versioning/VersionRangeTest.java      | 61 ++++++++++++++++++++++
 2 files changed, 71 insertions(+), 2 deletions(-)

diff --git 
a/compat/maven-artifact/src/main/java/org/apache/maven/artifact/versioning/VersionRange.java
 
b/compat/maven-artifact/src/main/java/org/apache/maven/artifact/versioning/VersionRange.java
index 152e8365c6..2602cbe2a9 100644
--- 
a/compat/maven-artifact/src/main/java/org/apache/maven/artifact/versioning/VersionRange.java
+++ 
b/compat/maven-artifact/src/main/java/org/apache/maven/artifact/versioning/VersionRange.java
@@ -44,13 +44,21 @@ public class VersionRange {
 
     private VersionRange(ArtifactVersion recommendedVersion, List<Restriction> 
restrictions) {
         this.recommendedVersion = recommendedVersion;
-        this.restrictions = restrictions;
+        this.restrictions = Collections.unmodifiableList(restrictions);
     }
 
     public ArtifactVersion getRecommendedVersion() {
         return recommendedVersion;
     }
 
+    /**
+     * Returns the intervals used to match versions against this range.
+     *
+     * <p>If this list is empty, {@link #containsVersion(ArtifactVersion)} 
returns {@code false}.
+     * A recommended version may still be available from {@link 
#getRecommendedVersion()}.</p>
+     *
+     * @return an unmodifiable, non-null list of version restrictions
+     */
     public List<Restriction> getRestrictions() {
         return restrictions;
     }
@@ -251,7 +259,7 @@ public VersionRange restrict(VersionRange restriction) {
         if (r1.isEmpty() || r2.isEmpty()) {
             restrictions = Collections.emptyList();
         } else {
-            restrictions = Collections.unmodifiableList(intersection(r1, r2));
+            restrictions = intersection(r1, r2);
         }
 
         ArtifactVersion version = null;
diff --git 
a/compat/maven-artifact/src/test/java/org/apache/maven/artifact/versioning/VersionRangeTest.java
 
b/compat/maven-artifact/src/test/java/org/apache/maven/artifact/versioning/VersionRangeTest.java
index 7685a899b1..7122799170 100644
--- 
a/compat/maven-artifact/src/test/java/org/apache/maven/artifact/versioning/VersionRangeTest.java
+++ 
b/compat/maven-artifact/src/test/java/org/apache/maven/artifact/versioning/VersionRangeTest.java
@@ -22,6 +22,8 @@
 
 import org.apache.maven.artifact.Artifact;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
@@ -793,4 +795,63 @@ void testCache() throws 
InvalidVersionSpecificationException {
                 spec.equals(version),
                 "check 
!VersionRange.createFromVersionSpec(x).equals(VersionRange.createFromVersion(x))");
     }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"[1.1234,2.5678]", "[1.1234]", 
"(,1.1234],[2.5678,)", "1.1234"})
+    void testCachedRestrictionsAreUnmodifiable(String spec) throws 
InvalidVersionSpecificationException {
+        VersionRange range = VersionRange.createFromVersionSpec(spec);
+        List<Restriction> restrictions = List.copyOf(range.getRestrictions());
+        ArtifactVersion version = new DefaultArtifactVersion("1.1234");
+        assertTrue(range.containsVersion(version));
+
+        assertThrows(
+                UnsupportedOperationException.class,
+                () -> range.getRestrictions().clear());
+        assertThrows(
+                UnsupportedOperationException.class,
+                () -> range.getRestrictions().set(0, Restriction.EVERYTHING));
+
+        VersionRange cached = VersionRange.createFromVersionSpec(spec);
+        assertSame(range, cached);
+        assertEquals(restrictions, cached.getRestrictions());
+        assertTrue(cached.containsVersion(version));
+    }
+
+    @Test
+    @SuppressWarnings("deprecation")
+    void testClonedRestrictionsAreUnmodifiable() throws 
InvalidVersionSpecificationException {
+        VersionRange range = 
VersionRange.createFromVersionSpec("[3.1234,4.5678]");
+        VersionRange clone = range.cloneOf();
+
+        assertThrows(
+                UnsupportedOperationException.class,
+                () -> clone.getRestrictions().clear());
+        assertEquals(range, clone);
+        assertTrue(clone.containsVersion(new 
DefaultArtifactVersion("3.5000")));
+        assertFalse(clone.containsVersion(new DefaultArtifactVersion("5.0")));
+    }
+
+    @Test
+    void testIntersectedRestrictionsAreUnmodifiable() throws 
InvalidVersionSpecificationException {
+        VersionRange range = 
VersionRange.createFromVersionSpec("[3.1234,4.5678]")
+                .restrict(VersionRange.createFromVersionSpec("[3.5000,5.0]"));
+
+        assertThrows(
+                UnsupportedOperationException.class,
+                () -> range.getRestrictions().clear());
+        assertTrue(range.containsVersion(new DefaultArtifactVersion("4.0")));
+        assertFalse(range.containsVersion(new 
DefaultArtifactVersion("3.2500")));
+    }
+
+    @Test
+    void testVersionRestrictionsAreUnmodifiable() {
+        VersionRange range = VersionRange.createFromVersion("3.1234");
+
+        assertThrows(
+                UnsupportedOperationException.class,
+                () -> range.getRestrictions().add(Restriction.EVERYTHING));
+        assertSame(range, VersionRange.createFromVersion("3.1234"));
+        assertTrue(range.getRestrictions().isEmpty());
+        assertEquals(new DefaultArtifactVersion("3.1234"), 
range.getRecommendedVersion());
+    }
 }

Reply via email to