jq is a command-line JSON processor. Prior to 1.8.2, comparing two sufficiently deeply nested arrays with the == operator exhausts the C stack on jq's ordinary command-line surface, resulting in denial of service via stack exhaustion (uncontrolled recursion). The crash occurs in jq's recursive structural comparison code, with the recursion repeating through jvp_array_equal() and jv_equal() in src/jv.c when comparing deeply nested arrays; a nearby sort comparator path through jv_cmp() in src/jv_aux.c overflows the stack at a larger nesting depth from the same missing recursion guard. Anyone running jq comparisons on attacker-controlled deeply nested JSON values, or embedding jq in a context where untrusted data can reach the == comparison path, is affected. This vulnerability is fixed in 1.8.2.

The remote Debian 13 host has packages installed that are affected by multiple vulnerabilities as referenced in the dsa-6416 advisory.

    - -------------------------------------------------------------------------     Debian Security Advisory DSA-6416-1                   security@debian.org     https://www.debian.org/security/                                  Aron Xu     August 07, 2026                       https://www.debian.org/security/faq
    - -------------------------------------------------------------------------

    Package        : jq     CVE ID         : CVE-2024-53427 CVE-2026-32316 CVE-2026-40612 CVE-2026-41256                      CVE-2026-41257 CVE-2026-43894 CVE-2026-43895 CVE-2026-43896                      CVE-2026-44777 CVE-2026-47770 CVE-2026-49839 CVE-2026-54679     Debian Bug     :

    Multiple security issues were discovered in jq, a command-line JSON     processor, which could result in denial of service or potentially the     execution of arbitrary code when processing untrusted input.

    This update additionally addresses three issues for which no CVE has been     assigned: GHSA-ggc9-rpv2-xgpm, GHSA-gvwx-xj9r-3frq and GHSA-gf4g-95wj-4q4r.

    Two changes in behaviour follow from the fixes above. An operation whose     result would exceed the internal string length limit, such as repeating     or escaping a very large string, now terminates with the error String     too long instead of returning a truncated result. A comparison or     containment check on a deeply nested value now reports an error rather     than recursing until the stack is exhausted. Filters relying on the     previous behaviour will report an error where they previously appeared     to succeed.

    For the stable distribution (trixie), these problems have been fixed in     version 1.7.1-6+deb13u3.

    We recommend that you upgrade your jq packages.

    For the detailed security status of jq please refer to     its security tracker page at:
    https://security-tracker.debian.org/tracker/jq

    Further information about Debian Security Advisories, how to apply     these updates to your system and frequently asked questions can be     found at: https://www.debian.org/security/

    Mailing list: debian-security-announce@lists.debian.org

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

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

The version of jq installed on the remote host is prior to 1.6-17. It is, therefore, affected by multiple vulnerabilities as referenced in the ALAS2-2026-3496 advisory.

    jq is a command-line JSON processor. An integer overflow vulnerability exists through version 1.8.1 within     the jvp_string_append() and jvp_string_copy_replace_bad functions, where concatenating strings with a     combined length exceeding 2^31 bytes causes a 32-bit unsigned integer overflow in the buffer allocation     size calculation, resulting in a drastically undersized heap buffer. Subsequent memory copy operations     then write the full string data into this undersized buffer, causing a heap buffer overflow classified as     CWE-190 (Integer Overflow) leading to CWE-122 (Heap-based Buffer Overflow). Any system evaluating     untrusted jq queries is affected, as an attacker can crash the process or potentially achieve further     exploitation through heap corruption by crafting queries that produce extremely large strings. The root     cause is the absence of string size bounds checking, unlike arrays and objects which already have size     limits. The issue has been addressed in commit e47e56d226519635768e6aab2f38f0ab037c09e5. (CVE-2026-32316)

    jq is a command-line JSON processor. In versions 1.8.1 and below, functions jv_setpath(), jv_getpath(),     and delpaths_sorted() in jq's src/jv_aux.c use unbounded recursion whose depth is controlled by the length     of a caller-supplied path array, with no depth limit enforced. An attacker can supply a JSON document     containing a flat array of ~65,000 integers (~200 KB) that, when used as a path argument by a trusted jq     filter, exhausts the C call stack and crashes the process with a segmentation fault (SIGSEGV). This bypass     works because the existing MAX_PARSING_DEPTH (10,000) limit only protects the JSON parser, not runtime     path operations where arrays can be programmatically constructed to arbitrary lengths. The impact is     denial of service (unrecoverable crash) affecting any application or service that processes untrusted JSON     input through jq's setpath, getpath, or delpaths builtins. This issue has been addressed in commit     fb59f1491058d58bdc3e8dd28f1773d1ac690a1f. (CVE-2026-33947)

    jq is a command-line JSON processor. Commits before 6374ae0bcdfe33a18eb0ae6db28493b1f34a0a5b contain a     vulnerability where CLI input parsing allows validation bypass via embedded NUL bytes. When reading JSON     from files or stdin, jq uses strlen() to determine buffer length instead of the actual byte count from     fgets(), causing it to truncate input at the first NUL byte and parse only the preceding prefix. This     enables an attacker to craft input with a benign JSON prefix before a NUL byte followed by malicious     trailing data, where jq validates only the prefix as valid JSON while silently discarding the suffix.
    Workflows relying on jq to validate untrusted JSON before forwarding it to downstream consumers are     susceptible to parser differential attacks, as those consumers may process the full input including the     malicious trailing bytes. This issue has been patched by commit 6374ae0bcdfe33a18eb0ae6db28493b1f34a0a5b.
    (CVE-2026-33948)

    jq is a command-line JSON processor. In commits after 69785bf77f86e2ea1b4a20ca86775916889e91c9, the
    _strindices builtin in jq's src/builtin.c passes its arguments directly to jv_string_indexes() without     verifying they are strings, and jv_string_indexes() in src/jv.c relies solely on assert() checks that are     stripped in release builds compiled with -DNDEBUG. This allows an attacker to crash jq trivially with     input like _strindices(0), and by crafting a numeric value whose IEEE-754 bit pattern maps to a chosen     pointer, achieve a controlled pointer dereference and limited memory read/probe primitive. Any deployment     that evaluates untrusted jq filters against a release build is vulnerable. This issue has been patched in     commit fdf8ef0f0810e3d365cdd5160de43db46f57ed03. (CVE-2026-39956)

    jq is a command-line JSON processor. In commits before 2f09060afab23fe9390cce7cb860b10416e1bf5f, the     jv_parse_sized() API in libjq accepts a counted buffer with an explicit length parameter, but its error-     handling path formats the input buffer using %s in jv_string_fmt(), which reads until a NUL terminator is     found rather than respecting the caller-supplied length. This means that when malformed JSON is passed in     a non-NUL-terminated buffer, the error construction logic performs an out-of-bounds read past the end of     the buffer. The vulnerability is reachable by any libjq consumer calling jv_parse_sized() with untrusted     input, and depending on memory layout, can result in memory disclosure or process termination. The issue     has been patched in commit 2f09060afab23fe9390cce7cb860b10416e1bf5f. (CVE-2026-39979)

    jq is a command-line JSON processor. Before commit 0c7d133c3c7e37c00b6d46b658a02244fdd3c784, jq used     MurmurHash3 with a hardcoded, publicly visible seed (0x432A9843) for all JSON object hash table     operations, which allowed an attacker to precompute key collisions offline. By supplying a crafted JSON     object (~100 KB) where all keys hashed to the same bucket, hash table lookups degraded from O(1) to O(n),     turning any jq expression into an O(n2) operation and causing significant CPU exhaustion. This affected     common jq use cases such as CI/CD pipelines, web services, and data processing scripts, and was far more     practical to exploit than existing heap overflow issues since it required only a small payload. This issue     has been patched in commit 0c7d133c3c7e37c00b6d46b658a02244fdd3c784. (CVE-2026-40164)

    jq is a command-line JSON processor. In 1.8.1 and earlier, unbounded recursion in     jv_object_merge_recursive() allows a crafted jq program to crash the process with a segfault. The function     is reachable through the * operator when both operands are objects. (CVE-2026-43896)

    The vulnerability is an unbounded recursion in jv_equal() and jv_cmp() that causes a stack overflow when     processing deeply nested JSON structures during equality checks (==, !=) or comparisons (sort, unique,     bsearch, min_by, max_by). (CVE-2026-47770)

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

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

The remote Debian 12 host has packages installed that are affected by multiple vulnerabilities as referenced in the dla-4662 advisory.

    -------------------------------------------------------------------------     Debian LTS Advisory DLA-4662-1                debian-lts@lists.debian.org     https://www.debian.org/lts/security/                   Andreas Henriksson     July 01, 2026                                 https://wiki.debian.org/LTS
    -------------------------------------------------------------------------

    Package        : jq     Version        : 1.6-2.1+deb12u2     CVE ID         : CVE-2026-32316 CVE-2026-33947 CVE-2026-33948 CVE-2026-39956                      CVE-2026-39979 CVE-2026-40164 CVE-2026-41256 CVE-2026-41257                      CVE-2026-43894 CVE-2026-43895 CVE-2026-43896 CVE-2026-44777                      CVE-2026-47770 CVE-2026-49839 CVE-2026-54679     Debian Bug     : 1133921 1136445

    It was found that jq, a lightweight and flexible command-line JSON parser, was     vulnerable to multiple memory corruption attacks, which could lead to     application crashes, denial-of-service conditions, and potentially arbitrary     code execution through heap corruption when parsing untrusted input.

    For Debian 12 bookworm, these problems have been fixed in version     1.6-2.1+deb12u2.

    For Debian 11 bullseye, these issues have been addressed in DLA-4599-1 and     DLA-4661-1.

    We recommend that you upgrade your jq packages.

    For the detailed security status of jq please refer to     its security tracker page at:
    https://security-tracker.debian.org/tracker/jq

    Further information about Debian LTS security advisories, how to apply     these updates to your system and frequently asked questions can be     found at: https://wiki.debian.org/LTS     Attachment:
    signature.asc     Description: PGP signature

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

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

The remote Debian 11 host has packages installed that are affected by multiple vulnerabilities as referenced in the dla-4661 advisory.

    -------------------------------------------------------------------------     Debian LTS Advisory DLA-4661-1                debian-lts@lists.debian.org     https://www.debian.org/lts/security/                   Andreas Henriksson     July 01, 2026                                 https://wiki.debian.org/LTS
    -------------------------------------------------------------------------

    Package        : jq     Version        : 1.6-2.1+deb11u3     CVE ID         : CVE-2026-43894 CVE-2026-47770 CVE-2026-49839 CVE-2026-54679     Debian Bug     : 1136445

    It was found that jq, a lightweight and flexible command-line JSON parser, was     vulnerable to multiple memory corruption attacks, which could lead to     application crashes, denial-of-service conditions, and potentially arbitrary     code execution through heap corruption when parsing untrusted input.

    For Debian 11 bullseye, these problems have been fixed in version     1.6-2.1+deb11u3.

    We recommend that you upgrade your jq packages.

    For the detailed security status of jq please refer to     its security tracker page at:
    https://security-tracker.debian.org/tracker/jq

    Further information about Debian LTS security advisories, how to apply     these updates to your system and frequently asked questions can be     found at: https://wiki.debian.org/LTS     Attachment:
    signature.asc     Description: PGP signature

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

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

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

  - jq is a command-line JSON processor. Prior to 1.8.2, comparing two sufficiently deeply nested arrays with     the == operator exhausts the C stack on jq's ordinary command-line surface, resulting in denial of service     via stack exhaustion (uncontrolled recursion). The crash occurs in jq's recursive structural comparison     code, with the recursion repeating through jvp_array_equal() and jv_equal() in src/jv.c when comparing     deeply nested arrays; a nearby sort comparator path through jv_cmp() in src/jv_aux.c overflows the stack     at a larger nesting depth from the same missing recursion guard. Anyone running jq comparisons on     attacker-controlled deeply nested JSON values, or embedding jq in a context where untrusted data can reach     the == comparison path, is affected. This vulnerability is fixed in 1.8.2. (CVE-2026-47770)

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

ID	Name	Product	Family	Type	Severity
333519	Debian dsa-6416 : jq - security update	Nessus	Debian Local Security Checks	Local	high
325564	Amazon Linux 2 : jq, --advisory ALAS2-2026-3496 (ALAS-2026-3496)	Nessus	Amazon Linux Local Security Checks	Local	medium
324575	Debian dla-4662 : jq - security update	Nessus	Debian Local Security Checks	Local	high
324574	Debian dla-4661 : jq - security update	Nessus	Debian Local Security Checks	Local	medium
317295	Linux Distros Unpatched Vulnerability : CVE-2026-47770	Nessus	Misc.	Local	medium

Detections

Analytics

CVE-2026-47770

medium

Tenable Plugins

high

medium

high

medium

medium