npm package report

Is @adonisjs/http-server safe?

3 known vulnerabilities, worst severity MODERATE.

// reach

12 direct dependencies

2 carry known advisories, worst CRITICAL

0 packages depend on it

an advisory here reaches each of them

    Create a free accountfor every dependency path, dependent and what to upgrade
    // ai model usage

    Tracked for PyPI packages. HuggingFace models declare Python dependencies, so npm packages are not covered.


    cvss
    8.7
    high

    CVSS v4.0 base score out of 10; GitHub rates it MODERATE

    epss
    0.37%
    low

    chance of exploitation in 30 days, 31st percentile of all CVEs

    xyz score
    not scored

    CyberXYZ composite out of 10

    fig. 01 — GHSA-524c-h47v-m3h8, the advisory selected below

    // 3 advisories

    GHSA-524c-h47v-m3h8

    MODERATEGitHub ratingCVE-2026-104150
    // description

    A Regular Expression Denial of Service vulnerability in the built-in AdonisJS slug route matcher may allow a remote attacker to block the Node.js event loop using a specially crafted URL.

    This affects applications using router.matchers.slug() on a route parameter reachable by an attacker.

    // details

    The regular expression used by router.matchers.slug() contains adjacent greedy quantifiers with overlapping character classes:

    /^[^\s-_](?!.*?[-_]{2,})([a-z0-9-\\]{1,})[^\s]*[^-_\s]$/

    When the matcher receives a long string ending with a character rejected by the final assertion, the regular expression engine must evaluate many possible ways of dividing the input between the overlapping quantifiers before determining that it does not match.

    This results in quadratic execution time. Testing measured an approximate complexity of O(n^1.98).

    Route matchers are evaluated against attacker-controlled URL segments during routing. Therefore, an unauthenticated attacker can trigger the vulnerable expression by sending a request to a route configured as follows:

    router
      .get('/posts/:slug', handler)
      .where('slug', router.matchers.slug())

    Routing occurs before route and group middleware. As a result, authentication or rate-limiting middleware attached to the affected route may not prevent exploitation.

    The vulnerability is limited to routes that explicitly use the built-in slug matcher.

    // impact

    Exploitation requires an application to expose a route using router.matchers.slug() with an attacker-controlled parameter.

    A specially crafted request can cause excessive CPU consumption and block the Node.js event loop. While the expression is being evaluated, the process cannot serve other requests, including requests to unrelated routes or health-check endpoints.

    Only a small number of requests may be required to consume the capacity of a worker. Reverse-proxy request-line limits reduce the maximum processing time of an individual request but do not fully mitigate the vulnerability.

    // patches

    Fixes targeting v6 and v7 have been published below.

    Users should upgrade to a version that includes the following fix:

    // cvss v4.0 vector

    CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N

    Attack vector
    Network
    Attack complexity
    Low
    Attack requirements
    None
    Privileges required
    None
    User interaction
    None
    Confidentiality (vulnerable system)
    None
    Integrity (vulnerable system)
    None
    Availability (vulnerable system)
    High
    Confidentiality (subsequent systems)
    None
    Integrity (subsequent systems)
    None
    Availability (subsequent systems)
    None

    Checked 2026-11-06 at 21:41 UTC. The most recent advisory here was published 2026-10-15. Updated continuously from NVD, GHSA, OSV and CNA feeds.

    Think a verdict here is wrong? Tell us — we respond within 2 business days.