Quarkus OpenAPI Generator contains an AI-written security flaw in the affected release range that exposes users to the advisory-described vulnerability.

+import jakarta.ws.rs.HeaderParam;+import jakarta.ws.rs.Path;+import jakarta.ws.rs.PathParam;+import jakarta.ws.rs.Produces;+import jakarta.ws.rs.core.MediaType;

+        // Return mock response+        String response = String.format(+                "{\"ref\":\"refs/%s\",\"url\":\"https://api.github.com/repos/%s/git/refs/%s\",\"object\":{\"type\":\"commit\",\"sha\":\"abc123\",\"url\":\"https://api.github.com/repos/%s/git/commits/abc123\"}}",+                ref, owner, ref, owner);++        return Response.ok(response).build();+    }

+        // Return mock response+        String response = String.format(+                "{\"login\":\"%s\",\"id\":12345,\"url\":\"https://api.github.com/users/%s\"}",+                username, username);++        return Response.ok(response).build();+    }+}

 public class UrlPatternMatcher { -    // For each pattern {keyName} replaces it with (.*)+    // For each pattern {keyName} replaces it with ([^/]*) or (.*)     private static final Pattern LEVEL_ONE_PATTERN = Pattern.compile("\\{([^/]+?)\\}");-    // Replaces each {keyName} with (.*)-    private static final String REPLACES_WITH = "(.*)";     private static final String URL_QUERY_STRING_REGEX = "(?:\\?.*?)?$";      private final Pattern pattern; -    public UrlPatternMatcher(String uriTemplate) {+    /**+     * Creates a URL pattern matcher with per-parameter segment control.+     *+     * @param uriTemplate The URI template with {param} placeholders+     * @param multiSegmentParams Set of parameter names that can match across slashes.+     *        Parameters in this set use (.*) regex.+     *        All other parameters use ([^/]*) for security.+     */+    public UrlPatternMatcher(String uriTemplate, Set<String> multiSegmentParams) {+        Set<String> multiSegParams = multiSegmentParams != null ? multiSegmentParams : Set.of();+         StringBuilder patternBuilder = new StringBuilder();         Matcher m = LEVEL_ONE_PATTERN.matcher(uriTemplate);         int end = 0;+         while (m.find()) {-            // In each loop, find next pattern in URI that is "{keyName}"-            // If found,append the substring to patternBuilder.-            patternBuilder.append(Pattern.quote(uriTemplate.substring(end, m.start()))).append(REPLACES_WITH);+            // Extract parameter name from {paramName}+            String paramName = m.group(1);++            // Choose regex based on whether this param is multi-segment+            String replacement;+            if (multiSegParams.contains(paramName)) {+                replacement = "(.*)"; // Multi-segment: matches across slashes (greedy)+            } else {+                replacement = "([^/]*)"; // Single-segment: secure default+            }++            patternBuilder.append(Pattern.quote(uriTemplate.substring(end, m.start())))+                    .append(replacement);             end = m.end();         }-        patternBuilder.append(Pattern.quote(uriTemplate.substring(end, uriTemplate.length())));++        patternBuilder.append(Pattern.quote(uriTemplate.substring(end)));         this.pattern = Pattern.compile(patternBuilder + URL_QUERY_STRING_REGEX);     } +    /**+     * Backwards compatibility: existing callers get secure single-segment behavior.+     */+    public UrlPatternMatcher(String uriTemplate) {+        this(uriTemplate, Set.of());+    }+     /**      * Test the given URL against the underlying pattern to determine if it matches, returning a boolean      * to reflect the outcome.

     private String operationId = "";     private String path;     private String httpMethod;     private UrlPatternMatcher pathMatcher;+    private Set<String> multiSegmentParams = Set.of();      public OperationAuthInfo() {     }@@ -17,10 +19,22 @@ public void setOperationId(final String operationId) {     }      public void setPath(final String path) {-        this.pathMatcher = new UrlPatternMatcher(path);+        this.pathMatcher = new UrlPatternMatcher(path, multiSegmentParams);         this.path = path;     } +    public void setMultiSegmentParams(final Set<String> params) {+        this.multiSegmentParams = params != null ? params : Set.of();+        // Recreate matcher if path was already set+        if (this.path != null) {+            this.pathMatcher = new UrlPatternMatcher(this.path, this.multiSegmentParams);+        }+    }++    public Set<String> getMultiSegmentParams() {+        return multiSegmentParams;+    }+     public void setHttpMethod(final String method) {         this.httpMethod = method;     }@@ -58,12 +72,13 @@ public boolean equals(Object o) {             return false;         }         OperationAuthInfo that = (OperationAuthInfo) o;-        return operationId.equals(that.operationId) && path.equals(that.path) && httpMethod.equals(that.httpMethod);+        return operationId.equals(that.operationId) && path.equals(that.path) && httpMethod.equals(that.httpMethod)+                && multiSegmentParams.equals(that.multiSegmentParams);     }      @Override     public int hashCode() {-        return Objects.hash(operationId, path, httpMethod);+        return Objects.hash(operationId, path, httpMethod, multiSegmentParams);     }      public static final class Builder {@@ -76,17 +91,26 @@ public Builder withId(final String operationId) {         }          public Builder withPath(final String path) {-            this.operationAuthInfo.pathMatcher = new UrlPatternMatcher(path);             this.operationAuthInfo.path = path;             return this;         } +        public Builder withMultiSegmentParams(final Set<String> params) {+            this.operationAuthInfo.multiSegmentParams = params != null ? params : Set.of();+            return this;+        }+         public Builder withMethod(final String method) {             this.operationAuthInfo.httpMethod = method;             return this;         }          public OperationAuthInfo build() {+            if (this.operationAuthInfo.path != null) {+                this.operationAuthInfo.pathMatcher = new UrlPatternMatcher(+                        this.operationAuthInfo.path,+                        this.operationAuthInfo.multiSegmentParams);+            }             return this.operationAuthInfo;         }     }

      /**      * Creates a URL pattern matcher with per-parameter segment control.@@ -50,20 +51,28 @@ public class UrlPatternMatcher {     public UrlPatternMatcher(String uriTemplate, Set<String> multiSegmentParams) {         Set<String> multiSegParams = multiSegmentParams != null ? multiSegmentParams : Set.of(); +        this.pattern = compilePattern(uriTemplate, multiSegParams);++        String trailingSlashTemplate = uriTemplate.endsWith("/") && uriTemplate.length() > 1+                ? uriTemplate.substring(0, uriTemplate.length() - 1)+                : uriTemplate + "/";+        Pattern compiled = compilePattern(trailingSlashTemplate, multiSegParams);+        this.patternWithTrailingSlash = compiled.equals(this.pattern) ? null : compiled;+    }++    private static Pattern compilePattern(String uriTemplate, Set<String> multiSegParams) {         StringBuilder patternBuilder = new StringBuilder();         Matcher m = LEVEL_ONE_PATTERN.matcher(uriTemplate);         int end = 0;          while (m.find()) {-            // Extract parameter name from {paramName}             String paramName = m.group(1); -            // Choose regex based on whether this param is multi-segment             String replacement;             if (multiSegParams.contains(paramName)) {-                replacement = "(.*)"; // Multi-segment: matches across slashes (greedy)+                replacement = "(.*)";             } else {-                replacement = "([^/]*)"; // Single-segment: secure default+                replacement = "([^/]*)";             }              patternBuilder.append(Pattern.quote(uriTemplate.substring(end, m.start())))@@ -72,7 +81,7 @@ public UrlPatternMatcher(String uriTemplate, Set<String> multiSegmentParams) {

@@ -86,11 +95,22 @@ public UrlPatternMatcher(String uriTemplate) {      * Test the given URL against the underlying pattern to determine if it matches, returning a boolean      * to reflect the outcome.      *+     * Trailing slashes are normalized so that a pattern with or without a trailing slash+     * will match a request URL regardless of its trailing slash presence.+     * This is important because OpenAPI spec paths may define trailing slashes (e.g., /request/issues/)+     * but the actual runtime request URI may or may not include the trailing slash.+     *      * @param url an URL string with or without query string.      * @return true if the given URL matches the underlying pattern. Otherwise false.      */     public boolean matches(String url) {-        return pattern.matcher(url).matches();+        if (pattern.matcher(url).matches()) {+            return true;+        }+        if (patternWithTrailingSlash != null) {+            return patternWithTrailingSlash.matcher(url).matches();+        }+        return false;     }      public String toString() {

-@Dependent-@Alternative-@Priority(100)

 import org.slf4j.Logger; import org.slf4j.LoggerFactory;@@ -13,8 +11,6 @@ import io.quarkiverse.openapi.generator.providers.CredentialsContext;  @Dependent-@Alternative-@Priority(200) public class CustomCredentialsProvider extends ConfigCredentialsProvider {     private static final Logger LOGGER = LoggerFactory.getLogger(CustomCredentialsProvider.class);