The remote host is affected by the vulnerability described in GLSA-202209-17 (Redis: Multiple Vulnerabilities)

  - Redis is an open source, in-memory database that persists on disk. In affected versions specially crafted     Lua scripts executing in Redis can cause the heap-based Lua stack to be overflowed, due to incomplete     checks for this condition. This can result with heap corruption and potentially remote code execution.
    This problem exists in all versions of Redis with Lua scripting support, starting from 2.6. The problem is     fixed in versions 6.2.6, 6.0.16 and 5.0.14. For users unable to update an additional workaround to     mitigate the problem without patching the redis-server executable is to prevent users from executing Lua     scripts. This can be done using ACL to restrict EVAL and EVALSHA commands. (CVE-2021-32626)

  - Redis is an open source, in-memory database that persists on disk. In affected versions an integer     overflow bug in Redis can be exploited to corrupt the heap and potentially result with remote code     execution. The vulnerability involves changing the default proto-max-bulk-len and client-query-buffer-     limit configuration parameters to very large values and constructing specially crafted very large stream     elements. The problem is fixed in Redis 6.2.6, 6.0.16 and 5.0.14. For users unable to upgrade an     additional workaround to mitigate the problem without patching the redis-server executable is to prevent     users from modifying the proto-max-bulk-len configuration parameter. This can be done using ACL to     restrict unprivileged users from using the CONFIG SET command. (CVE-2021-32627)

  - Redis is an open source, in-memory database that persists on disk. An integer overflow bug in the ziplist     data structure used by all versions of Redis can be exploited to corrupt the heap and potentially result     with remote code execution. The vulnerability involves modifying the default ziplist configuration     parameters (hash-max-ziplist-entries, hash-max-ziplist-value, zset-max-ziplist-entries or zset-max-     ziplist-value) to a very large value, and then constructing specially crafted commands to create very     large ziplists. The problem is fixed in Redis versions 6.2.6, 6.0.16, 5.0.14. An additional workaround to     mitigate the problem without patching the redis-server executable is to prevent users from modifying the     above configuration parameters. This can be done using ACL to restrict unprivileged users from using the     CONFIG SET command. (CVE-2021-32628)

  - Redis is an open source, in-memory database that persists on disk. When using the Redis Lua Debugger,     users can send malformed requests that cause the debugger's protocol parser to read data beyond the actual     buffer. This issue affects all versions of Redis with Lua debugging support (3.2 or newer). The problem is     fixed in versions 6.2.6, 6.0.16 and 5.0.14. (CVE-2021-32672)

  - Redis is an open source, in-memory database that persists on disk. When parsing an incoming Redis Standard     Protocol (RESP) request, Redis allocates memory according to user-specified values which determine the     number of elements (in the multi-bulk header) and size of each element (in the bulk header). An attacker     delivering specially crafted requests over multiple connections can cause the server to allocate     significant amount of memory. Because the same parsing mechanism is used to handle authentication     requests, this vulnerability can also be exploited by unauthenticated users. The problem is fixed in Redis     versions 6.2.6, 6.0.16 and 5.0.14. An additional workaround to mitigate this problem without patching the     redis-server executable is to block access to prevent unauthenticated users from connecting to Redis. This     can be done in different ways: Using network access control tools like firewalls, iptables, security     groups, etc. or Enabling TLS and requiring users to authenticate using client side certificates.
    (CVE-2021-32675)

  - Redis is an open source, in-memory database that persists on disk. An integer overflow bug affecting all     versions of Redis can be exploited to corrupt the heap and potentially be used to leak arbitrary contents     of the heap or trigger remote code execution. The vulnerability involves changing the default set-max-     intset-entries configuration parameter to a very large value and constructing specially crafted commands     to manipulate sets. The problem is fixed in Redis versions 6.2.6, 6.0.16 and 5.0.14. An additional     workaround to mitigate the problem without patching the redis-server executable is to prevent users from     modifying the set-max-intset-entries configuration parameter. This can be done using ACL to restrict     unprivileged users from using the CONFIG SET command. (CVE-2021-32687)

  - Redis is an in-memory database that persists on disk. A vulnerability involving out-of-bounds read and     integer overflow to buffer overflow exists starting with version 2.2 and prior to versions 5.0.13, 6.0.15,     and 6.2.5. On 32-bit systems, Redis `*BIT*` command are vulnerable to integer overflow that can     potentially be exploited to corrupt the heap, leak arbitrary heap contents or trigger remote code     execution. The vulnerability involves changing the default `proto-max-bulk-len` configuration parameter to     a very large value and constructing specially crafted commands bit commands. This problem only affects     Redis on 32-bit platforms, or compiled as a 32-bit binary. Redis versions 5.0.`3m 6.0.15, and 6.2.5     contain patches for this issue. An additional workaround to mitigate the problem without patching the     `redis-server` executable is to prevent users from modifying the `proto-max-bulk-len` configuration     parameter. This can be done using ACL to restrict unprivileged users from using the CONFIG SET command.
    (CVE-2021-32761)

  - Redis is an open source, in-memory database that persists on disk. The redis-cli command line tool and     redis-sentinel service may be vulnerable to integer overflow when parsing specially crafted large multi-     bulk network replies. This is a result of a vulnerability in the underlying hiredis library which does not     perform an overflow check before calling the calloc() heap allocation function. This issue only impacts     systems with heap allocators that do not perform their own overflow checks. Most modern systems do and are     therefore not likely to be affected. Furthermore, by default redis-sentinel uses the jemalloc allocator     which is also not vulnerable. The problem is fixed in Redis versions 6.2.6, 6.0.16 and 5.0.14.
    (CVE-2021-32762)

  - Redis is an open source, in-memory database that persists on disk. An integer overflow bug in the     underlying string library can be used to corrupt the heap and potentially result with denial of service or     remote code execution. The vulnerability involves changing the default proto-max-bulk-len configuration     parameter to a very large value and constructing specially crafted network payloads or commands. The     problem is fixed in Redis versions 6.2.6, 6.0.16 and 5.0.14. An additional workaround to mitigate the     problem without patching the redis-server executable is to prevent users from modifying the proto-max-     bulk-len configuration parameter. This can be done using ACL to restrict unprivileged users from using the     CONFIG SET command. (CVE-2021-41099)

  - Redis is an in-memory database that persists on disk. By exploiting weaknesses in the Lua script execution     environment, an attacker with access to Redis prior to version 7.0.0 or 6.2.7 can inject Lua code that     will execute with the (potentially higher) privileges of another Redis user. The Lua script execution     environment in Redis provides some measures that prevent a script from creating side effects that persist     and can affect the execution of the same, or different script, at a later time. Several weaknesses of     these measures have been publicly known for a long time, but they had no security impact as the Redis     security model did not endorse the concept of users or privileges. With the introduction of ACLs in Redis     6.0, these weaknesses can be exploited by a less privileged users to inject Lua code that will execute at     a later time, when a privileged user executes a Lua script. The problem is fixed in Redis versions 7.0.0     and 6.2.7. An additional workaround to mitigate this problem without patching the redis-server executable,     if Lua scripting is not being used, is to block access to `SCRIPT LOAD` and `EVAL` commands using ACL     rules. (CVE-2022-24735)

  - Redis is an in-memory database that persists on disk. Prior to versions 6.2.7 and 7.0.0, an attacker     attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result     with a crash of the redis-server process. The problem is fixed in Redis versions 7.0.0 and 6.2.7. An     additional workaround to mitigate this problem without patching the redis-server executable, if Lua     scripting is not being used, is to block access to `SCRIPT LOAD` and `EVAL` commands using ACL rules.
    (CVE-2022-24736)

  - Redis is an in-memory database that persists on disk. A specially crafted `XAUTOCLAIM` command on a stream     key in a specific state may result with heap overflow, and potentially remote code execution. This problem     affects versions on the 7.x branch prior to 7.0.4. The patch is released in version 7.0.4.
    (CVE-2022-31144)

  - Redis v7.0 was discovered to contain a memory leak via the component streamGetEdgeID. (CVE-2022-33105)

  - Redis is an in-memory database that persists on disk. Versions 7.0.0 and above, prior to 7.0.5 are     vulnerable to an Integer Overflow. Executing an `XAUTOCLAIM` command on a stream key in a specific state,     with a specially crafted `COUNT` argument may cause an integer overflow, a subsequent heap overflow, and     potentially lead to remote code execution. This has been patched in Redis version 7.0.5. No known     workarounds exist. (CVE-2022-35951)

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

An update of the redis package has been released.

远程主机受到 GLSA-202209-17 中所述漏洞的影响（Redis：多个漏洞）

  - Redis 是一个持续存在于磁盘上的开源内存中数据库。在受影响的版本中，在 Redis 中执行特别构建的 Lua 脚本会导致基于堆的 Lua 堆栈溢出，原因是对此情况的检查不完整。这会导致堆损坏，并可能导致远程代码执行。
    此问题存在于具有 Lua 脚本支持的所有 Redis 版本（从 2.6 开始）中。此问题已在版本 6.2.6、6.0.16 和 5.0.14 中修复。对于无法更新的用户，在不修补 redis-server 可执行文件的情况下缓解该问题的其他变通方案是阻止用户执行 Lua 脚本。这可通过使用 ACL 限制 EVAL 和 EVALSHA 命令来实现。(CVE-2021-32626)

  - Redis 是一个持续存在于磁盘上的开源内存中数据库。在受影响的版本中，可以利用 Redis 中的整数溢出缺陷来损坏堆，并可能导致远程代码执行。该漏洞涉及将默认的 proto-max-bulk-len 和 client-query-buffer-limit 配置参数更改为非常大的值，然后构造特别构建的非常大的流元素。此问题已在 Redis 6.2.6、6.0.16 和 5.0.14 中修复。对于无法升级的用户，在不修补 redis-server 可执行文件的情况下缓解该问题的其他变通方案是阻止用户修改 proto-max-bulk-len 配置参数。这可通过使用 ACL 限制非特权用户使用 CONFIG SET 命令来实现。(CVE-2021-32627)

  - Redis 是一个持续存在于磁盘上的开源内存中数据库。可以利用所有 Redis 版本使用的 ziplist 数据结构中的整数溢出缺陷来损坏堆，并可能导致远程代码执行。该漏洞涉及将默认的 ziplist 配置参数（hash-max-ziplist-entries、hash-max-ziplist-value、zset-max-ziplist-entries 或 zset-max-ziplist-value）修改为非常大的值，然后构造特别构建的命令以创建非常大的 ziplist。此问题已在 Redis 版本 6.2.6、6.0.16 和 5.0.14 中修复。在不修补 redis-server 可执行文件的情况下缓解该问题的其他变通方案是阻止用户修改上述配置参数。这可通过使用 ACL 限制非特权用户使用 CONFIG SET 命令来实现。(CVE-2021-32628)

  - Redis 是一个持续存在于磁盘上的开源内存中数据库。使用 Redis Lua Debugger 时，用户可以发送畸形请求，造成调试器的协议解析器读取实际缓冲区之外的数据。此问题会影响具有 Lua 调试支持的所有 Redis 版本（3.2 或更高版本）。已在版本 6.2.6、6.0.16 和 5.0.14 中修复此问题。(CVE-2021-32672)

  - Redis 是一个持续存在于磁盘上的开源内存中数据库。解析传入的 Redis 标准协议 (RESP) 请求时，Redis 根据用户指定的值分配内存，这些值决定元素的数量（在多批量标头中）和每个元素的大小（在批量标头中）。通过多个连接传递特别构建的请求的攻击者可导致服务器分配大量内存。由于使用相同的解析机制来处理身份验证请求，因此未经身份验证的用户也可利用此漏洞。此问题已在 Redis 版本 6.2.6、6.0.16 和 5.0.14 中修复。在不修补 redis-server 可执行文件的情况下缓解该问题的其他变通方案是阻止访问，以阻止未经身份验证的用户连接到 Redis。这可以通过几种不同的方法实现：使用防火墙、iptables 和安全组等网络访问控制工具，或启用 TLS 并要求用户使用客户端证书进行身份验证。
    (CVE-2021-32675)

  - Redis 是一个持续存在于磁盘上的开源内存中数据库。可以利用影响所有 Redis 版本的整数溢出缺陷来损坏堆，并可能用于泄漏堆的任意内容或触发远程代码执行。该漏洞涉及将默认的 set-max-intset-entries 配置参数更改为非常大的值，然后构造特别构建的命令以操纵集。此问题已在 Redis 版本 6.2.6、6.0.16 和 5.0.14 中修复。在不修补 redis-server 可执行文件的情况下缓解该问题的其他变通方案是阻止用户修改 set-max-intset-entries 配置参数。这可通过使用 ACL 限制非特权用户使用 CONFIG SET 命令来实现。(CVE-2021-32687)

  - Redis 是一个持续存在于磁盘上的内存中数据库。自版本 2.2 开始，以及在 5.0.13、6.0.15 和 6.2.5 之前的版本中，存在一个涉及越界读取和整数溢出的漏洞。在 32 位系统上，Redis“*BIT*”命令容易受到整数溢出漏洞的影响，此漏洞可能会被用来损坏堆、泄漏任意堆内容或触发远程代码执行。该漏洞涉及将默认的“proto-max-bulk-len”配置参数更改为极大值，然后构造特别构建的命令位命令。此问题仅影响 32 位平台上或编译为 32 位二进制的 Redis。Redis 版本 5.0.`3m 6.0.15 和 6.2.5 包含针对此问题的修补程序。在不修补“redis-server”可执行文件的情况下缓解该问题的其他变通方案是阻止用户修改“proto-max-bulk-len”配置参数。这可通过使用 ACL 限制非特权用户使用 CONFIG SET 命令来实现。
    (CVE-2021-32761)

  - Redis 是一个持续存在于磁盘上的开源内存中数据库。解析特别构建的大量多批次网络回复时，redis-cli 命令行工具和 redis-sentinel 服务可能容易受到整数溢出漏洞的影响。这是由底层 hiredis 库中的漏洞所致，此库在调用 calloc() 堆分配函数之前未执行溢出检查。此问题仅影响具有不执行自有溢出检查的堆分配器的系统。大多数现代系统都会进行检查，因此不太可能受到影响。此外，默认情况下，redis-sentinel 使用也不易受到影响的 jemalloc 分配器。此问题已在 Redis 版本 6.2.6、6.0.16 和 5.0.14 中修复。
    (CVE-2021-32762)

  - Redis 是一个持续存在于磁盘上的开源内存中数据库。可以利用基础字符串库中的整数溢出缺陷来损坏堆，并可能导致拒绝服务或远程代码执行。该漏洞涉及将默认的 proto-max-bulk-len 配置参数更改为非常大的值，然后构造特别构建的网络有效负载或命令。此问题已在 Redis 版本 6.2.6、6.0.16 和 5.0.14 中修复。在不修补 redis-server 可执行文件的情况下缓解该问题的其他变通方案是阻止用户修改 proto-max-bulk-len 配置参数。这可通过使用 ACL 限制非特权用户使用 CONFIG SET 命令来实现。(CVE-2021-41099)

  - Redis 是一个持续存在于磁盘上的内存中数据库。通过利用 Lua 脚本执行环境中的漏洞，有权访问版本低于 7.0.0 或 6.2.7 的 Redis 的攻击者可以注入 Lua 代码，该代码将以另一个 Redis 用户（可能更高的）权限执行。Redis 中的 Lua 脚本执行环境提供了一些措施，可防止脚本产生持续存在的副作用，这些副作用可在以后影响相同或不同脚本的执行。这些措施的多个漏洞早已为人所知，但它们不会造成安全影响，因为 Redis 安全模型未认可用户或权限的概念。在 Redis 6.0 版中引入 ACL 后，较低权限的用户可利用这些弱点，注入稍后会在特权用户执行 Lua 脚本时执行的 Lua 代码。已在 Redis 版本 7.0.0 和 6.2.7 中修复此问题。如果不使用 Lua 脚本，还有一种变通方案可在不修补 redis-server 可执行文件的情况下缓解此问题，即使用 ACL 规则阻止访问 `SCRIPT LOAD` 和 `EVAL` 命令。(CVE-2022-24735)

  - Redis 是一个持续存在于磁盘上的内存中数据库。在低于 6.2.7 和 7.0.0 的版本中，尝试加载特别构建的 Lua 脚本的攻击者可造成空指针取消引用，进而导致 redis-server 进程崩溃。已在 Redis 版本 7.0.0 和 6.2.7 中修复此问题。如果不使用 Lua 脚本，还有一种变通方案可在不修补 redis-server 可执行文件的情况下缓解此问题，即使用 ACL 规则阻止访问 `SCRIPT LOAD` 和 `EVAL` 命令。
    (CVE-2022-24736)

  - Redis 是一个持续存在于磁盘上的内存中数据库。在特定状态下对串流密钥执行特别构建的“XAUTOCLAIM”命令可能会造成堆溢出，并且可能导致远程代码执行。此问题会影响 7.x 分支的 7.0.4 之前版本。该修补程序在 7.0.4 版中发布。
    (CVE-2022-31144)

  - 在 Redis v7.0 中发现可通过 streamGetEdgeID 组件造成内存泄漏。(CVE-2022-33105)

  - Redis 是一个持续存在于磁盘上的内存中数据库。7.0.0 至 7.0.5 版容易受到整数溢出漏洞影响。在特定状态下使用特别构建的“COUNT”参数对串流密钥执行“XAUTOCLAIM”命令可能会造成整数溢出以及后续的堆溢出，并且可能导致远程代码执行。Redis 7.0.5 版已修复此问题。尚无已知的变通方案。(CVE-2022-35951)

请注意，Nessus 尚未测试这些问题，而是只依据应用程序自我报告的版本号进行判断。

遠端主機受到 GLSA-202209-17 中所述的弱點影響 (Redis：多個弱點)

  - Redis 是一種保留在磁碟上的開放原始碼記憶體資料庫。在受影響的版本中，於 Redis 中執行的特製 Lua 指令碼可造成堆積型 Lua 堆疊溢位，這是因為對此情形的檢查不完整所導致。這會導致堆積損毀，並可能造成遠端程式碼執行。
    從 2.6 開始，此問題存在於受 Lua 指令碼支援的所有 Redis 版本中。此問題已在  6.2.6、6.0.16 與 5.0.14 版中修正。對於無法升級的使用者，採取在不修補 redis-server 可執行檔的情況下減輕問題的因應措施，是為了防止使用者執行 Lua 指令碼。此動作可以透過使用 ACL 限制 EVAL 和 EVALSHA 命令完成。(CVE-2021-32626)

  - Redis 是一種保留在磁碟上的開放原始碼記憶體資料庫。在受影響的版本中，攻擊者可利用 Redis 中出現的整數溢位錯誤損毀堆積，並且此錯誤可能導致遠端程式碼執行。此弱點涉及將預設的「proto-max-bulk-len」和「client-query-buffer-limit」組態參數變更為非常大的值，以及建構特製的非常大的資料流元素。此問題已在 Redis 6.2.6、6.0.16 與 5.0.14 版中修正。對於無法升級的使用者，採取在不修補 redis-server 可執行檔的情況下減輕問題的其他因應措施，是為了防止使用者修改「proto-max-bulk-len」組態參數。此動作可以使用 ACL 來完成，以限制無權限的使用者使用 CONFIG SET 命令。 (CVE-2021-32627)

  - Redis 是一種保留在磁碟上的開放原始碼記憶體資料庫。攻擊者可利用 Redis 所有版本都在使用的 ziplist 資料結構中的整數溢位錯誤損毀堆積，並且此錯誤可能導致遠端程式碼執行。此弱點涉及將預設的 ziplist 組態參數 (「hash-max-ziplist-entries」、「hash-max-ziplist-value」、「zset-max-ziplist-entries」 或 「zset-max-ziplist-value」) 修改為非常大的值，然後建構特製的命令以建立非常大的 ziplist。此問題已在 Redis 版本 6.2.6、6.0.16 與 5.0.14 中修正。採取在不修補 redis-server 可執行檔的情況下減輕問題的其他因應措施，是為了防止使用者修改上述組態參數。此動作可以使用 ACL 來完成，以限制無權限的使用者使用 CONFIG SET 命令。 (CVE-2021-32628)

  - Redis 是一種保留在磁碟上的開放原始碼記憶體資料庫。使用 Redis Lua 偵錯程式時，使用者可傳送格式錯誤的要求，造成偵錯程式的通訊協定剖析器讀取實際緩衝區之外的資料。此問題會影響支援 Lua 偵錯的所有 Redis 版本 (3.2 或更新版本)。此問題已在 6.2.6 、6.0.16 與 5.0.14 版中修正。(CVE-2021-32672)

  - Redis 是一種保留在磁碟上的開放原始碼記憶體資料庫。剖析傳入的 Redis 標准通訊協定 (RESP) 要求時，Redis 會根據決定元素數量 (位於多個批量標頭中) 和每個元素大小 (位於批量標頭中) 的使用者指定值配置記憶體。透過多個連線傳送特製要求的攻擊者可造成伺服器配置大量記憶體。由於我們會使用相同的剖析機制處理驗證要求，因此未經驗證的使用者也可利用此弱點。此問題已在 Redis 版本 6.2.6、6.0.16 與 5.0.14 中修正。採取在不修補 redis-server 可執行檔的情況下減輕問題的其他因應措施，是為了封鎖存取，以防止未經授權的使用者修改連線至 Redis。可以透過不同的方式完成此動作：使用防火牆、iptables、安全性群組等網路存取控制工具，或啟用 TLS 並要求使用者使用用戶端憑證完成驗證。
    (CVE-2021-32675)

  - Redis 是一種保留在磁碟上的開放原始碼記憶體資料庫。攻擊者可利用影響所有 Redis 版本的整數溢位錯誤損毀堆積，並且可能會使用此錯誤洩漏堆積的任意內容或觸發遠端程式碼執行。此弱點涉及將預設的「set-max-intset-entries」組態參數變更為非常大的值，以及建構特製的命令以操控設定。此問題已在 Redis 版本 6.2.6、6.0.16 與 5.0.14 中修正。採取在不修補 redis-server 可執行檔的情況下減輕問題的其他因應措施，是為了防止使用者修改「set-max-intset-entries」組態參數。此動作可以使用 ACL 來完成，以限制無權限的使用者使用 CONFIG SET 命令。 (CVE-2021-32687)

  - Redis 是一種保留在磁碟上的記憶體內資料庫。從 2.2 版開始，以及低於 5.0.13、6.0.15 和 6.2.5 的版本中，存在與超出邊界讀取、整數溢位和緩衝區溢位有關的弱點。在 32 位元系統上，Redis *BIT* 命令容易受到整數溢位弱點影響，攻擊者可利用此弱點來損毀堆積、洩漏任意堆積內容或觸發遠端程式碼執行攻擊。此弱點涉及將預設的「proto-max-bulk-len」組態參數變更為非常大的值，以及建構特製的命令位元命令。此問題只會影響 32 位元平台上的 Redis，或編譯為 32 位元二進位制的 Redis。Redis 5.0 版、3m 6.0.15 和 6.2.5 版包含此問題的修補程式。在不修補「redis-server」可執行檔的情況下減輕此問題的另一個因應措施是，防止使用者修改「proto-max-bulk-len」組態參數。爲此，可以使用 ACL 來限制無權限的使用者使用 CONFIG SET 命令。
    (CVE-2021-32761)

  - Redis 是一種保留在磁碟上的開放原始碼記憶體資料庫。剖析特別建構的大型多批次網路回覆時，redis-cli 命令行工具和 redis-sentinel 服務可能容易受到整數溢位攻擊。這是因為基礎 hiredis 程式庫中存在弱點，即它在呼叫 calloc() 堆積配置函式之前未執行溢位檢查。此問題只會影響堆積配置器未自行執行溢位檢查的系統。大多數現代系統都會執行檢查，因此不太可能受到影響。此外，redis-sentinel 預設情況下使用 jemalloc 配置器，也不受此弱點影響。此問題已在 Redis 版本 6.2.6、6.0.16 與 5.0.14 中修正。
    (CVE-2021-32762)

  - Redis 是一種保留在磁碟上的開放原始碼記憶體資料庫。攻擊者可利用基礎字串程式庫中的整數溢位錯誤損毀堆積，並且此錯誤可能導致拒絕服務或遠端程式碼執行。此弱點涉及將預設的「proto-max-bulk-len」組態參數變更為非常大的值，以及建構特製的網路承載或命令。此問題已在 Redis 版本 6.2.6、6.0.16 與 5.0.14 中修正。採取在不修補 redis-server 可執行檔的情況下減輕問題的其他因應措施，是為了防止使用者修改「proto-max-bulk-len」組態參數。此動作可以使用 ACL 來完成，以限制無權限的使用者使用 CONFIG SET 命令。 (CVE-2021-41099)

  - Redis 是一種保留在磁碟上的記憶體內資料庫。能夠存取 Redis 7.0.0 之前版本或 6.2.7 版的攻擊者可以利用 Lua 指令碼執行環境中的弱點插入 Lua 程式碼，以其他 Redis 使用者的權限 (可能更高) 執行此程式碼。Redis 中的 Lua 指令碼執行環境提供了一些措施，用於防止指令碼產生持續的副作用，並在之後影響相同或不同指令碼的執行。這些措施的數個弱點早已為人所知，但因為 Redis 安全性模型不認可使用者或權限的概念，所以它們沒有安全性影響。在 Redis 6.0 中引入 ACL 後，具有較低權限的使用者可惡意利用這些弱點插入 Lua 程式碼，插入的程式碼會於稍後在有權限的使用者執行 Lua 指令碼時執行。此問題已在 Redis 7.0.0 和 6.2.7 版中修正。若未使用 Lua 指令碼，在不修補 redis-server 可執行檔的情況下減輕此問題的另一個因應措施是使用 ACL 規則封鎖對 SCRIPT LOAD 和 EVAL 命令的存取。(CVE-2022-24735)

  - Redis 是一種保留在磁碟上的記憶體內資料庫。在 6.2.7 和 7.0.0 之前版本中，攻擊者可透過嘗試載入特製的 Lua 指令碼造成 NULL 指標解除參照，進而導致 redis-server 處理程序損毀。此問題已在 Redis 7.0.0 和 6.2.7 版中修正。若未使用 Lua 指令碼，在不修補 redis-server 可執行檔的情況下減輕此問題的另一個因應措施是使用 ACL 規則封鎖對 SCRIPT LOAD 和 EVAL 命令的存取。
    (CVE-2022-24736)

  - Redis 是一種保留在磁碟上的記憶體內資料庫。針對特定狀態下的串流金鑰執行「XAUTOCLAIM」命令可能會導致堆積溢位，並可能導致遠端程式碼執行。此問題會影響 7.x 分支的 7.0.4 之前版本。修補程式已在 7.0.4 版中發佈。
    (CVE-2022-31144)

  - 據發現，Redis v7.0 的 streamGetEdgeID 元件存在記憶體洩漏弱點。(CVE-2022-33105)

  - Redis 是一種保留在磁碟上的記憶體內資料庫。7.0.0 至 7.0.5 版本容易受到整數溢位弱點影響。使用特製的「COUNT」參數針對串流金鑰執行「XAUTOCLAIM」命令可能會造成整數溢位，進而後續引致堆積溢位，並且可能導致遠端程式碼執行。現已在 Redis 7.0.5 版本中修補此問題。目前尚無已知的因應措施。(CVE-2022-35951)

請注意，Nessus 並未測試這些問題，而是僅依據應用程式自我報告的版本號碼作出判斷。

ID	名称	产品	系列	发布时间	最近更新时间	严重程度
165541	GLSA-202209-17 : Redis: Multiple Vulnerabilities	Nessus	Gentoo Local Security Checks	2022/9/29	2023/10/10	critical
203299	Photon OS 4.0: Redis PHSA-2022-4.0-0207	Nessus	PhotonOS Local Security Checks	2024/7/23	2024/7/23	high
165541	GLSA-202209-17：Redis：多个漏洞	Nessus	Gentoo Local Security Checks	2022/9/29	2023/10/10	critical
165541	GLSA-202209-17：Redis：多個弱點	Nessus	Gentoo Local Security Checks	2022/9/29	2023/10/10	critical

检测

插件搜索

critical

high

critical

critical