p PatchFirst

PatchFirst · Latest vulnerabilities

rack vulnerabilities

Vulnerabilities published for rack in the last 30 days: 4. Listed in the KEV catalogue: 0.

Filter vulnerabilities
Clear filters

Vulnerabilities: 54

  1. CVE-2026-125111

    High · CVSS 7.5EPSS 0.5%Fix available

    Rack: Multipart parsing allows DoS via unbounded scan buffer growth

    Rack is a modular Ruby web server interface. Prior to 2.2.25, 3.1.23, and 3.2.8, Rack::Multipart::Parser can retain parsed data in its internal StringScanner buffer when reads end inside or immediately after multipart headers. An unauthenticated attacker can align many small parts with rack.multipart.buffer_size boundaries so the buffer grows with the request despite per-field, header, and preamble limits, causing a worker to exhaust memory. The attack requires only a well-formed multipart body and affects applications that parse multipart requests. This issue is fixed in versions 2.2.25, 3.1.23, and 3.2.8.

    • Update to 2.2.25
    • Update to 3.1.23
    • Update to 3.2.8
    Published Updated
  2. CVE-2026-125110

    Medium · CVSS 5.3EPSS 0.25%Fix available

    Rack: Rack::Static header_rules bypass via dot-segment normalization mismatch

    Rack is a modular Ruby web server interface. Prior to 2.2.25, 3.1.23, and 3.2.8, Rack::Static serves a path after Utils.clean_path_info normalization but evaluates header_rules against a path that is only URL-decoded. An unauthenticated attacker can request a known file through raw or percent-encoded dot segments and receive it without path-specific security headers such as Content-Disposition or Content-Security-Policy. Applications that do not use path-specific header_rules are not affected. This issue is fixed in versions 2.2.25, 3.1.23, and 3.2.8.

    • Update to 2.2.25
    • Update to 3.1.23
    • Update to 3.2.8
    Published Updated
  3. CVE-2026-125109

    Medium · CVSS 4.8EPSS 0.29%Fix available

    Rack: Rack::Request#host_with_port (and #base_url / #url) return the raw invalid Host header — incomplete fix of CVE-2026-34835

    Rack is a modular Ruby web server interface. From 3.0 until 3.1.23 and 3.2.8, Rack::Request#host_with_port, #base_url, and #url can return an attacker-controlled invalid authority from Host, X-Forwarded-Host, or Forwarded: host= verbatim. Applications without an independent host allowlist that use these methods for absolute URLs, redirects, or origin-dependent checks can emit attacker-chosen delimiters, enabling redirect manipulation, string-based allowlist bypass, or unescaped markup reflection. Rails overrides these methods and is not expected to be affected. This issue is fixed in versions 3.1.23 and 3.2.8.

    • Update to 3.1.23
    • Update to 3.2.8
    Published Updated
  4. CVE-2026-125108

    Low · CVSS 3.7EPSS 0.32%Fix available

    Rack: Multipart boundary ambiguity guard in Rack::Multipart::Parser can be bypassed with a quoted boundary value, allowing WAF bypass

    Rack is a modular Ruby web server interface. Prior to 2.2.25, 3.1.23, and 3.2.8, Rack::Multipart::Parser.parse_boundary can skip a leading empty or quoted boundary parameter in a multipart Content-Type header and accept a later parameter. Rack can therefore parse a request body with a boundary that a conforming intermediary would not derive, allowing form fields or file uploads to reach an application without the intended proxy or web application firewall inspection. This issue is fixed in versions 2.2.25, 3.1.23, and 3.2.8.

    • Update to 2.2.25
    • Update to 3.1.23
    • Update to 3.2.8
    Published Updated
  5. CVE-2026-26962

    Medium · CVSS 4.8EPSS 0.24%Fix available

    Rack: Header injection in multipart requests

    Rack is a modular Ruby web server interface. From version 3.2.0 to before version 3.2.6, Rack::Multipart::Parser unfolds folded multipart part headers incorrectly. When a multipart header contains an obs-fold sequence, Rack preserves the embedded CRLF in parsed parameter values such as filename or name instead of removing the folded line break during unfolding. As a result, applications that later reuse those parsed values in HTTP response headers may be vulnerable to downstream header injection or response splitting. This issue has been patched in version 3.2.6.

    • Update to 3.2.6
    Published Updated
  6. CVE-2026-34835

    Medium · CVSS 4.8EPSS 0.21%Fix available

    Rack: `Rack::Request` accepts invalid Host characters, enabling host allowlist bypass.

    Rack is a modular Ruby web server interface. From versions 3.0.0.beta1 to before 3.1.21, and 3.2.0 to before 3.2.6, Rack::Request parses the Host header using an AUTHORITY regular expression that accepts characters not permitted in RFC-compliant hostnames, including /, ?, #, and @. Because req.host returns the full parsed value, applications that validate hosts using naive prefix or suffix checks can be bypassed. This can lead to host header poisoning in applications that use req.host, req.url, or req.base_url for link generation, redirects, or origin validation. This issue has been patched in versions 3.1.21 and 3.2.6.

    • Update to 3.1.21
    • Update to 3.2.6
    Published Updated
  7. CVE-2026-34827

    High · CVSS 7.5EPSS 0.51%Fix available

    Rack: Algorithmic-Complexity DoS in Rack::Multipart::Parser

    Rack is a modular Ruby web server interface. From versions 3.0.0.beta1 to before 3.1.21, and 3.2.0 to before 3.2.6, Rack::Multipart::Parser#handle_mime_head parses quoted multipart parameters such as Content-Disposition: form-data; name="..." using repeated String#index searches combined with String#slice! prefix deletion. For escape-heavy quoted values, this causes super-linear processing. An unauthenticated attacker can send a crafted multipart/form-data request containing many parts with long backslash-escaped parameter values to trigger excessive CPU usage during multipart parsing. This results in a denial of service condition in Rack app

    • Update to 3.1.21
    • Update to 3.2.6
    Published Updated
  8. CVE-2026-32762

    Medium · CVSS 4.8EPSS 0.19%Fix available

    Rack: Forwarded Header semicolon injection enables Host and Scheme spoofing

    Rack is a modular Ruby web server interface. From versions 3.0.0.beta1 to before 3.1.21 and 3.2.0 to before 3.2.6, Rack::Utils.forwarded_values parses the RFC 7239 Forwarded header by splitting on semicolons before handling quoted-string values. Because quoted values may legally contain semicolons, a header can be interpreted by Rack as multiple Forwarded directives rather than as a single quoted for value. In deployments where an upstream proxy, WAF, or intermediary validates or preserves quoted Forwarded values differently, this discrepancy can allow an attacker to smuggle host, proto, for, or by parameters through a single header value. Th

    • Update to 3.1.21
    • Update to 3.2.6
    Published Updated
  9. CVE-2026-34830

    Medium · CVSS 5.9EPSS 0.25%Fix available

    Rack: Rack::Sendfile regex injection via HTTP_X_ACCEL_MAPPING header allows arbitrary file reads through nginx

    Rack is a modular Ruby web server interface. Prior to versions 2.2.23, 3.1.21, and 3.2.6, Rack::Sendfile#map_accel_path interpolates the value of the X-Accel-Mapping request header directly into a regular expression when rewriting file paths for X-Accel-Redirect. Because the header value is not escaped, an attacker who can supply X-Accel-Mapping to the backend can inject regex metacharacters and control the generated X-Accel-Redirect response header. In deployments using Rack::Sendfile with x-accel-redirect, this can allow an attacker to cause nginx to serve unintended files from configured internal locations. This issue has been patched in v

    • Update to 2.2.23
    • Update to 3.1.21
    • Update to 3.2.6
    Published Updated
  10. CVE-2026-34829

    High · CVSS 7.5EPSS 0.38%Fix available

    Rack: Denial of Service via Unbounded Multipart File Upload Without Content-Length

    Rack is a modular Ruby web server interface. Prior to versions 2.2.23, 3.1.21, and 3.2.6, Rack::Multipart::Parser only wraps the request body in a BoundedIO when CONTENT_LENGTH is present. When a multipart/form-data request is sent without a Content-Length header, such as with HTTP chunked transfer encoding, multipart parsing continues until end-of-stream with no total size limit. For file parts, the uploaded body is written directly to a temporary file on disk rather than being constrained by the buffered in-memory upload limit. An unauthenticated attacker can therefore stream an arbitrarily large multipart file upload and consume unbounded

    • Update to 2.2.23
    • Update to 3.1.21
    • Update to 3.2.6
    Published Updated
  11. CVE-2026-34826

    Medium · CVSS 5.3EPSS 0.4%Fix available

    Rack: Unbounded Range Count in get_byte_ranges Enables DoS

    Rack is a modular Ruby web server interface. Prior to versions 2.2.23, 3.1.21, and 3.2.6, Rack::Utils.get_byte_ranges parses the HTTP Range header without limiting the number of individual byte ranges. Although the existing fix for CVE-2024-26141 rejects ranges whose total byte coverage exceeds the file size, it does not restrict the count of ranges. An attacker can supply many small overlapping ranges such as 0-0,0-0,0-0,... to trigger disproportionate CPU, memory, I/O, and bandwidth consumption per request. This results in a denial of service condition in Rack file-serving paths that process multipart byte range responses. This issue has be

    • Update to 2.2.23
    • Update to 3.1.21
    • Update to 3.2.6
    Published Updated
  12. CVE-2026-34786

    Medium · CVSS 5.3EPSS 0.21%Fix available

    Rack: Rack::Static header_rules bypass via URL-encoded paths

    Rack is a modular Ruby web server interface. Prior to versions 2.2.23, 3.1.21, and 3.2.6, Rack::Static#applicable_rules evaluates several header_rules types against the raw URL-encoded PATH_INFO, while the underlying file-serving path is decoded before the file is served. As a result, a request for a URL-encoded variant of a static path can serve the same file without the headers that header_rules were intended to apply. In deployments that rely on Rack::Static to attach security-relevant response headers to static content, this can allow an attacker to bypass those headers by requesting an encoded form of the path. This issue has been patche

    • Update to 2.2.23
    • Update to 3.1.21
    • Update to 3.2.6
    Published Updated
  13. CVE-2026-34785

    High · CVSS 7.5EPSS 0.4%Fix available

    Rack: Local file inclusion in `Rack::Static` via URL Prefix Matching

    Rack is a modular Ruby web server interface. Prior to versions 2.2.23, 3.1.21, and 3.2.6, Rack::Static determines whether a request should be served as a static file using a simple string prefix check. When configured with URL prefixes such as "/css", it matches any request path that begins with that string, including unrelated paths such as "/css-config.env" or "/css-backup.sql". As a result, files under the static root whose names merely share the configured prefix may be served unintentionally, leading to information disclosure. This issue has been patched in versions 2.2.23, 3.1.21, and 3.2.6.

    • Update to 2.2.23
    • Update to 3.1.21
    • Update to 3.2.6
    Published Updated
  14. CVE-2026-34763

    Medium · CVSS 5.3EPSS 0.26%Fix available

    Rack: Rack::Directory info disclosure and DoS via unescaped regex interpolation

    Rack is a modular Ruby web server interface. Prior to versions 2.2.23, 3.1.21, and 3.2.6, Rack::Directory interpolates the configured root path directly into a regular expression when deriving the displayed directory path. If root contains regex metacharacters such as +, *, or ., the prefix stripping can fail and the generated directory listing may expose the full filesystem path in the HTML output. This issue has been patched in versions 2.2.23, 3.1.21, and 3.2.6.

    • Update to 2.2.23
    • Update to 3.1.21
    • Update to 3.2.6
    Published Updated
  15. CVE-2026-34831

    Medium · CVSS 4.8EPSS 0.16%Fix available

    Rack: Content-Length mismatch in Rack::Files error responses

    Rack is a modular Ruby web server interface. Prior to versions 2.2.23, 3.1.21, and 3.2.6, Rack::Files#fail sets the Content-Length response header using String#size instead of String#bytesize. When the response body contains multibyte UTF-8 characters, the declared Content-Length is smaller than the number of bytes actually sent on the wire. Because Rack::Files reflects the requested path in 404 responses, an attacker can trigger this mismatch by requesting a non-existent path containing percent-encoded UTF-8 characters. This results in incorrect HTTP response framing and may cause response desynchronization in deployments that rely on the in

    • Update to 2.2.23
    • Update to 3.1.21
    • Update to 3.2.6
    Published Updated
  16. CVE-2026-26961

    Low · CVSS 3.7EPSS 0.27%Fix available

    Rack: Multipart Boundary Parsing Ambiguity allowing WAF Bypass

    Rack is a modular Ruby web server interface. Prior to versions 2.2.23, 3.1.21, and 3.2.6, Rack::Multipart::Parser extracts the boundary parameter from multipart/form-data using a greedy regular expression. When a Content-Type header contains multiple boundary parameters, Rack selects the last one rather than the first. In deployments where an upstream proxy, WAF, or intermediary interprets the first boundary parameter, this mismatch can allow an attacker to smuggle multipart content past upstream inspection and have Rack parse a different body structure than the intermediary validated. This issue has been patched in versions 2.2.23, 3.1.21, a

    • Update to 2.2.23
    • Update to 3.1.21
    • Update to 3.2.6
    Published Updated
  17. CVE-2026-34230

    Medium · CVSS 5.3EPSS 0.46%Fix available

    Rack: Quadratic complexity in Rack::Utils.select_best_encoding via wildcard Accept-Encoding header

    Rack is a modular Ruby web server interface. Prior to versions 2.2.23, 3.1.21, and 3.2.6, Rack::Utils.select_best_encoding processes Accept-Encoding values with quadratic time complexity when the header contains many wildcard (*) entries. Because this method is used by Rack::Deflater to choose a response encoding, an unauthenticated attacker can send a single request with a crafted Accept-Encoding header and cause disproportionate CPU consumption on the compression middleware path. This results in a denial of service condition for applications using Rack::Deflater. This issue has been patched in versions 2.2.23, 3.1.21, and 3.2.6.

    • Update to 2.2.23
    • Update to 3.1.21
    • Update to 3.2.6
    Published Updated
  18. CVE-2026-25500

    Medium · CVSS 5.4EPSS 0.27%Fix available

    Rack's Stored XSS in Rack::Directory via javascript: filenames rendered into anchor href

    Rack is a modular Ruby web server interface. Prior to versions 2.2.22, 3.1.20, and 3.2.5, `Rack::Directory` generates an HTML directory index where each file entry is rendered as a clickable link. If a file exists on disk whose basename starts with the `javascript:` scheme (e.g. `javascript:alert(1)`), the generated index contains an anchor whose `href` is exactly `javascript:alert(1)`. Clicking the entry executes JavaScript in the browser (demonstrated with `alert(1)`). Versions 2.2.22, 3.1.20, and 3.2.5 fix the issue.

    • Update to 2.2.22
    • Update to 3.1.20
    • Update to 3.2.5
    Published Updated
  19. CVE-2026-22860

    High · CVSS 7.5EPSS 0.78%Fix available

    Rack has a Directory Traversal via Rack:Directory

    Rack is a modular Ruby web server interface. Prior to versions 2.2.22, 3.1.20, and 3.2.5, `Rack::Directory`’s path check used a string prefix match on the expanded path. A request like `/../root_example/` can escape the configured root if the target path starts with the root string, allowing directory listing outside the intended root. Versions 2.2.22, 3.1.20, and 3.2.5 fix the issue.

    • Update to 2.2.22
    • Update to 3.1.20
    • Update to 3.2.5
    Published Updated
  20. CVE-2025-61919

    High · CVSS 7.5EPSS 0.65%Fix available

    Rack is vulnerable to a memory-exhaustion DoS through unbounded URL-encoded body parsing

    Rack is a modular Ruby web server interface. Prior to versions 2.2.20, 3.1.18, and 3.2.3, `Rack::Request#POST` reads the entire request body into memory for `Content-Type: application/x-www-form-urlencoded`, calling `rack.input.read(nil)` without enforcing a length or cap. Large request bodies can therefore be buffered completely into process memory before parsing, leading to denial of service (DoS) through memory exhaustion. Users should upgrade to Rack version 2.2.20, 3.1.18, or 3.2.3, anu of which enforces form parameter limits using `query_parser.bytesize_limit`, preventing unbounded reads of `application/x-www-form-urlencoded` bodies. Ad

    • Update to 2.2.20
    • Update to 3.1.18
    • Update to 3.2.3
    Published Updated

Check your server

Check your installed stack and versions against the current vulnerability feeds.

Check your server →