There are packages installed that are affected by a vulnerability referenced in the following CVE:

  - ### Summary The `arrayLimit` option in qs does not enforce limits for comma-separated values when `comma:
    true` is enabled, allowing attackers to cause denial-of-service via memory exhaustion. This is a bypass of
    the array limit enforcement, similar to the bracket notation bypass addressed in GHSA-6rw7-vpxm-498p
    (CVE-2025-15284). ### Details When the `comma` option is set to `true` (not the default, but configurable
    in applications), qs allows parsing comma-separated strings as arrays (e.g., `?param=a,b,c` becomes `['a',
    'b', 'c']`). However, the limit check for `arrayLimit` (default: 20) and the optional throwOnLimitExceeded
    occur after the comma-handling logic in `parseArrayValue`, enabling a bypass. This permits creation of
    arbitrarily large arrays from a single parameter, leading to excessive memory allocation. **Vulnerable
    code** (lib/parse.js: lines ~40-50): ```js if (val && typeof val === 'string' && options.comma &&
    val.indexOf(',') > -1) { return val.split(','); } if (options.throwOnLimitExceeded && currentArrayLength
    >= options.arrayLimit) { throw new RangeError('Array limit exceeded. Only ' + options.arrayLimit + '
    element' + (options.arrayLimit === 1 ? '' : 's') + ' allowed in an array.'); } return val; ``` The
    `split(',')` returns the array immediately, skipping the subsequent limit check. Downstream merging via
    `utils.combine` does not prevent allocation, even if it marks overflows for sparse arrays.This discrepancy
    allows attackers to send a single parameter with millions of commas (e.g., `?param=,,,,,,,,...`),
    allocating massive arrays in memory without triggering limits. It bypasses the intent of `arrayLimit`,
    which is enforced correctly for indexed (`a[0]=`) and bracket (`a[]=`) notations (the latter fixed in
    v6.14.1 per GHSA-6rw7-vpxm-498p). ### PoC **Test 1 - Basic bypass:** ``` npm install qs ``` ```js const qs
    = require('qs'); const payload = 'a=' + ','.repeat(25); // 26 elements after split (bypasses arrayLimit:
    5) const options = { comma: true, arrayLimit: 5, throwOnLimitExceeded: true }; try { const result =
    qs.parse(payload, options); console.log(result.a.length); // Outputs: 26 (bypass successful) } catch (e) {
    console.log('Limit enforced:', e.message); // Not thrown } ``` **Configuration:** - `comma: true` -
    `arrayLimit: 5` - `throwOnLimitExceeded: true` Expected: Throws "Array limit exceeded" error. Actual:
    Parses successfully, creating an array of length 26. ### Impact Denial of Service (DoS) via memory
    exhaustion. (CVE-2026-2391)

Linux/Unix 主機上安裝了一個或多個受到弱點影響的套件，且供應商未提供可用的修補程式。

  - ### 摘要 qs 中的「arrayLimit」選項不會強制限制逗號分隔值，當「逗號：
    啟用了 true'，使攻擊者能透過記憶體耗盡來造成阻斷服務（denial-ofservice）。這是繞過陣列限制強制的方法，類似於 GHSA-6rw7-vpxm-498p （CVE-2025-15284）中處理的括號符號繞過。### 細節 當「逗號」選項設為「true」（非預設，但在應用程式中可設定）時，qs 允許將逗號分隔字串解析為陣列（例如，'？param=a，b，c' 變成 '['a'， 'b'， 'c']''）。然而，'arrayLimit'（預設值：20）的限制檢查和可選的throwOnLimitExceeded會在「parseArrayValue」逗號處理邏輯之後進行，從而實現繞過。這使得從單一參數建立任意大的陣列，導致記憶體分配過多。**易受攻擊的程式碼**（lib/parse.js：行數 ~40-50）： '''js if （val && typeof val === 'string' && options.coma && val.indexOf（'，'） > -1） { return val.split（'，'）; } if （options.throwOnLimitExceeded && currentArrayLength >= options.arrayLimit） { throw new RangeError（'Array limit exteeded. 只有 ' + options.arrayLimit + ' element' + （options.arrayLimit === 1 ？'' ： 's'） + ' 允許在陣列中。'）;} 返回 val;''' 'split（'，'）' 立即回傳陣列，跳過後續的極限檢查。透過 'utils.combine' 進行下游合併並不會阻止配置，即使它標記了稀疏陣列的溢位。這種差異讓攻擊者能夠傳送一個帶有數百萬逗號的單一參數（例如「？param=,,,,,,,,...」），在記憶體中分配龐大陣列且不觸發限制。它繞過了「arrayLimit」的意圖，該意圖在索引（'a[0]='）及括號（'a[]='）符號下正確執行（後者於 v6.14.1 依 GHSA-6rw7-vpxm-498p 修正）。### PoC **Test 1 - Basic bypass：** ''' npm install qs '''' ''js const qs = require（'qs'）;const 有效載荷 = 'a=' + '，'。重複（25）;拆分後 26 個元素（繞過 arrayLimit：
    5） const options = { 逗號： true， arrayLimit： 5， throwOnLimitExceeded： true };try { const result = qs.parse（payload， options）; console.log（result.a.length）; // 輸出：26 （bypass successful） } catch （e） {console.log（'Limit enforced：'， e.message）; // 未拋出 } '''' **Configuration：** - '逗號： true' - 'arrayLimit： 5' - 'throwOnLimitExceeded： true' 預期：擲出 陣列限制超過錯誤。實際情況：
    成功解析，建立了長度為 26 的陣列。### 因記憶體耗盡而產生的阻斷服務（DoS）影響。（CVE-2026-2391）

請注意，Nessus 的判定取決於廠商所報告的套件是否存在。

Linux/Unix 主机中安装的一个或多个程序包受到一个漏洞影响，而供应商没有提供补丁程序。

  - ### 摘要 qs 中的“arrayLimit”选项在“逗号：
    启用了 true'，允许攻击者通过内存耗尽实现拒绝服务。这是绕过数组限制强制的一种方法，类似于 GHSA-6rw7-vpxm-498p （CVE-2025-15284）中处理的括号符号绕过。### 详情 当“逗号”选项设置为“true”（非默认，但在应用程序中可配置）时，qs 允许将逗号分隔字符串解析为数组（例如，'？param=a，b，c' 变为 '['a'， 'b'， 'c']'）。然而，'arrayLimit'（默认：20）的极限检查和可选的throwOnLimitExceeded发生在'parseArrayValue'中的逗号处理逻辑之后，从而实现了绕过。这使得从单个参数创建任意大的数组成为可能，导致内存分配过高。**易受攻击的代码**（lib/parse.js：行数~40-50）： '''js 如果（val && typeof val === 'string' && options.coma && val.indexOf（'，'） > -1） { return val.split（'，'）; } if （options.throwOnLimitExceeded && currentArrayLength >= options.arrayLimit） { throw new RangeError（'Array limit exteeded. 只有 ' + options.arrayLimit + ' element' + （options.arrayLimit === 1 ？“' ： 's'） + ' 允许在数组中。'）;} 返回Val;''' 'split（'，'）' 立即返回数组，跳过后续的极限检查。通过“utils.combine”进行下游合并并不会阻止分配，即使它标记了稀疏数组的溢出。这种差异使攻击者能够发送带有数百万个逗号的单一参数（例如，'？param=,,,,,,,,...'），在内存中分配大量数组而不触发限制。它绕过了“arrayLimit”的意图，该意图在索引（'a[0]='）和括号（'a[]='）符号中正确执行（后者在v6.14.1中根据GHSA-6rw7-vpxm-498p修正）。### PoC **Test 1 - Basic bypass：** ''' npm install qs ''''js const qs = require（'qs'）;const有效载荷 = 'a=' + '，'。重复（25）;拆分后26个元素（绕过arrayLimit：
    5） const options = { 逗号： true， arrayLimit： 5， throwOnLimitExceeded： true };try { const result = qs.parse（payload， options）; console.log（result.a.length）; // 输出： 26 （bypass 成功） } catch （e） {console.log（'Limit enforced：'， e.message）; // 未被抛出 } '''' **Configuration：** - '逗号： true' - 'arrayLimit： 5' - 'throwOnLimitExceeded： true' Expected： Throws 数组限制超出错误。实际情况：
    成功解析，生成长度为26的数组。### 通过内存耗尽导致的阻断服务（DoS）影响。（CVE-2026-2391）

请注意，Nessus 依赖供应商报告的程序包是否存在进行判断。

Linux/Unix ホストには、ベンダーが提供するパッチが利用できない脆弱性の影響を受ける複数のパッケージがインストールされています。

  - ### 要約 qsの「arrayLimit」オプションは、カンマ区切られた値に対して「コンマ:
    true'が有効であるため、攻撃者はメモリ枯渇によってサービス拒否(DoS)を起こすことができます。これは配列制限の強制を回避するもので、GHSA-6rw7-vpxm-498p(CVE-2025-15284)で扱われている括弧表記の回避に似ています。### 詳細 「コンマ」オプションが「true」に設定されている場合(デフォルトではありませんがアプリケーション内で設定可能)、qsはカンマ区切りの文字列を配列として解析できます(例:'?param=a,b,c'は'['a', 'b', 'c']'になります)。しかし、「arrayLimit」(デフォルト:20)のリミットチェックとオプションのthrowOnLimitExceededは、parseArrayValueのカンマ処理ロジックの後に行われ、バイパスを可能にします。これにより、単一のパラメータから任意の大きな配列を作成できるため、過剰なメモリ割り当てが発生します。**脆弱なコード**(lib/parse.js: 行数~40-50): '''js if (val && typeof val === 'string' && options.coma && val.indexOf(',') > -1) { val.split(','); } if (options.throwOnLimitExceeded && currentArrayLength >= options.arrayLimit) { throw new RangeError('Array limit exteeded. ただ ' + options.arrayLimit + ' element' + (options.arrayLimit === 1 ?「」 : 's') + ' 配列内で許可されています。');} 戻るval;''' 'split(',')' は配列を即座に返し、その後のリミットチェックをスキップします。'utils.combine'による下流マージは、スパース配列のオーバーフローをマークしても割り当てを妨げません。この不一致により、攻撃者は数百万カンマの単一のパラメータ(例:'?param=,,,,,,,,...')を送信し、メモリに大量配列を割り当て、制限をトリガーしません。これは「arrayLimit」の意図を回避し、インデックス付き('a[0]=')および括弧('a[]=')表記法で正しく強制されます(後者はGHSA-6rw7-vpxm-498pによりv6.14.1で修正済み)。### PoC **Test 1 - Basic bypass:** ''' npm install qs ''''js const qs = require('qs');const ペイロード = 'a=' + ','。繰り返し(25);分割後26要素(arrayLimitをバイパス:
    5) const options = { コンマ: true, arrayLimit: 5, throwOnLimitExceeded: true };try { const result = qs.parse(payload, options); console.log(result.a.length); // 出力: 26 (バイパス成功) } catch (e) {console.log('Limit enforced:', e.message); // thrownではありません } '''' **Configuration:** - 'comma: true' - 'arrayLimit: 5' - 'throwOnLimitExceeded: true' Expected: Throws array limit limit beyond error. 実際の:
    解析に成功し、長さ26の配列を作成しました。### メモリ枯渇によるサービス拒否(DoS)の影響。(CVE-2026-2391)

Nessus は、ベンダーによって報告されたパッケージの存在に依存していることに注意してください。

リモートの Fedora 42 ホストには、FEDORA-2026-ca43aa006f のアドバイザリに記載された複数の脆弱性の影響を受けるパッケージがインストールされています。

    33.0.1 リリース

Tenable は、前述の記述ブロックを Fedora セキュリティアドバイザリから直接抽出しています。

Nessus はこれらの問題をテストしておらず、代わりにアプリケーションが自己報告するバージョン番号にのみ依存していることに注意してください。

The Linux/Unix host has one or more packages installed that are impacted by a vulnerability without a vendor supplied patch available.

  - ### Summary The `arrayLimit` option in qs does not enforce limits for comma-separated values when `comma:
    true` is enabled, allowing attackers to cause denial-of-service via memory exhaustion. This is a bypass of     the array limit enforcement, similar to the bracket notation bypass addressed in GHSA-6rw7-vpxm-498p     (CVE-2025-15284). ### Details When the `comma` option is set to `true` (not the default, but configurable     in applications), qs allows parsing comma-separated strings as arrays (e.g., `?param=a,b,c` becomes `['a',     'b', 'c']`). However, the limit check for `arrayLimit` (default: 20) and the optional throwOnLimitExceeded     occur after the comma-handling logic in `parseArrayValue`, enabling a bypass. This permits creation of     arbitrarily large arrays from a single parameter, leading to excessive memory allocation. **Vulnerable     code** (lib/parse.js: lines ~40-50): ```js if (val && typeof val === 'string' && options.comma &&     val.indexOf(',') > -1) { return val.split(','); } if (options.throwOnLimitExceeded && currentArrayLength     >= options.arrayLimit) { throw new RangeError('Array limit exceeded. Only ' + options.arrayLimit + '     element' + (options.arrayLimit === 1 ? '' : 's') + ' allowed in an array.'); } return val; ``` The     `split(',')` returns the array immediately, skipping the subsequent limit check. Downstream merging via     `utils.combine` does not prevent allocation, even if it marks overflows for sparse arrays.This discrepancy     allows attackers to send a single parameter with millions of commas (e.g., `?param=,,,,,,,,...`),     allocating massive arrays in memory without triggering limits. It bypasses the intent of `arrayLimit`,     which is enforced correctly for indexed (`a[0]=`) and bracket (`a[]=`) notations (the latter fixed in     v6.14.1 per GHSA-6rw7-vpxm-498p). ### PoC **Test 1 - Basic bypass:** ``` npm install qs ``` ```js const qs     = require('qs'); const payload = 'a=' + ','.repeat(25); // 26 elements after split (bypasses arrayLimit:
    5) const options = { comma: true, arrayLimit: 5, throwOnLimitExceeded: true }; try { const result =     qs.parse(payload, options); console.log(result.a.length); // Outputs: 26 (bypass successful) } catch (e) {     console.log('Limit enforced:', e.message); // Not thrown } ``` **Configuration:** - `comma: true` -     `arrayLimit: 5` - `throwOnLimitExceeded: true` Expected: Throws Array limit exceeded error. Actual:
    Parses successfully, creating an array of length 26. ### Impact Denial of Service (DoS) via memory     exhaustion. (CVE-2026-2391)

Note that Nessus relies on the presence of the package as reported by the vendor.

The remote Fedora 42 host has a package installed that is affected by multiple vulnerabilities as referenced in the FEDORA-2026-ca43aa006f advisory.

    33.0.1 release

Tenable has extracted the preceding description block directly from the Fedora security advisory.

Note that Nessus has not tested for these issues but has instead relied only on the application's self-reported version number.

ID	名稱	產品	系列	已發布	已更新	嚴重性
437712	SCA: security update for qs (GHSA-w7fw-mjwx-w883)	Tenable Cloud Security	SCA Checks	2026/2/12	2026/7/2	medium
437712	SCA: security update for qs (GHSA-w7fw-mjwx-w883)	Tenable Self-Hosted Container Security	SCA Checks	2026/2/12	2026/7/2	medium
298899	Linux Distros 未修補的弱點：CVE-2026-2391	Nessus	Misc.	2026/2/13	2026/7/6	medium
298899	Linux Distros 未修补的漏洞：CVE-2026-2391	Nessus	Misc.	2026/2/13	2026/7/6	medium
298899	Linux Distros のパッチ未適用の脆弱性: CVE-2026-2391	Nessus	Misc.	2026/2/13	2026/7/6	medium
305115	Fedora 42nextcloud2026-ca43aa006f	Nessus	Fedora Local Security Checks	2026/4/7	2026/4/7	high
298899	Linux Distros Unpatched Vulnerability : CVE-2026-2391	Nessus	Misc.	2026/2/13	2026/7/6	medium
305115	Fedora 42 : nextcloud (2026-ca43aa006f)	Nessus	Fedora Local Security Checks	2026/4/7	2026/4/7	high

偵測

搜尋 Plugin

medium

medium

medium

medium

medium

high

medium

high