The remote host is affected by the vulnerability described in GLSA-202210-09 (Rust: Multiple Vulnerabilities)

  - In the standard library in Rust before 1.50.0, read_to_end() does not validate the return value from Read     in an unsafe context. This bug could lead to a buffer overflow. (CVE-2021-28875)

  - In the standard library in Rust before 1.52.0, the Zip implementation has a panic safety issue. It calls
    __iterator_get_unchecked() more than once for the same index when the underlying iterator panics (in     certain conditions). This bug could lead to a memory safety violation due to an unmet safety requirement     for the TrustedRandomAccess trait. (CVE-2021-28876)

  - In the standard library in Rust before 1.51.0, the Zip implementation calls __iterator_get_unchecked() for     the same index more than once when nested. This bug can lead to a memory safety violation due to an unmet     safety requirement for the TrustedRandomAccess trait. (CVE-2021-28877)

  - In the standard library in Rust before 1.52.0, the Zip implementation calls __iterator_get_unchecked()     more than once for the same index (under certain conditions) when next_back() and next() are used     together. This bug could lead to a memory safety violation due to an unmet safety requirement for the     TrustedRandomAccess trait. (CVE-2021-28878)

  - In the standard library in Rust before 1.52.0, the Zip implementation can report an incorrect size due to     an integer overflow. This bug can lead to a buffer overflow when a consumed Zip iterator is used again.
    (CVE-2021-28879)

  - library/std/src/net/parser.rs in Rust before 1.53.0 does not properly consider extraneous zero characters     at the beginning of an IP address string, which (in some situations) allows attackers to bypass access     control that is based on IP addresses, because of unexpected octal interpretation. (CVE-2021-29922)

  - In the standard library in Rust before 1.52.0, a double free can occur in the Vec::from_iter function if     freeing the element panics. (CVE-2021-31162)

  - Dell EMC Avamar Server version 19.4 contains a plain-text password storage vulnerability in AvInstaller. A     local attacker could potentially exploit this vulnerability, leading to the disclosure of certain user     credentials. The attacker may be able to use the exposed credentials to access the vulnerable application     with privileges of the compromised account. (CVE-2021-36317)

  - Dell EMC Avamar versions 18.2,19.1,19.2,19.3,19.4 contain a plain-text password storage vulnerability. A     high privileged user could potentially exploit this vulnerability, leading to a complete outage.
    (CVE-2021-36318)

  - ** DISPUTED ** An issue was discovered in the Bidirectional Algorithm in the Unicode Specification through     14.0. It permits the visual reordering of characters via control sequences, which can be used to craft     source code that renders different logic than the logical ordering of tokens ingested by compilers and     interpreters. Adversaries can leverage this to encode source code for compilers accepting Unicode such     that targeted vulnerabilities are introduced invisibly to human reviewers. NOTE: the Unicode Consortium     offers the following alternative approach to presenting this concern. An issue is noted in the nature of     international text that can affect applications that implement support for The Unicode Standard and the     Unicode Bidirectional Algorithm (all versions). Due to text display behavior when text includes left-to-     right and right-to-left characters, the visual order of tokens may be different from their logical order.
    Additionally, control characters needed to fully support the requirements of bidirectional text can     further obfuscate the logical order of tokens. Unless mitigated, an adversary could craft source code such     that the ordering of tokens perceived by human reviewers does not match what will be processed by a     compiler/interpreter/etc. The Unicode Consortium has documented this class of vulnerability in its     document, Unicode Technical Report #36, Unicode Security Considerations. The Unicode Consortium also     provides guidance on mitigations for this class of issues in Unicode Technical Standard #39, Unicode     Security Mechanisms, and in Unicode Standard Annex #31, Unicode Identifier and Pattern Syntax. Also, the     BIDI specification allows applications to tailor the implementation in ways that can mitigate misleading     visual reordering in program text; see HL4 in Unicode Standard Annex #9, Unicode Bidirectional Algorithm.
    (CVE-2021-42574)

  - ** DISPUTED ** An issue was discovered in the character definitions of the Unicode Specification through     14.0. The specification allows an adversary to produce source code identifiers such as function names     using homoglyphs that render visually identical to a target identifier. Adversaries can leverage this to     inject code via adversarial identifier definitions in upstream software dependencies invoked deceptively     in downstream software. NOTE: the Unicode Consortium offers the following alternative approach to     presenting this concern. An issue is noted in the nature of international text that can affect     applications that implement support for The Unicode Standard (all versions). Unless mitigated, an     adversary could produce source code identifiers using homoglyph characters that render visually identical     to but are distinct from a target identifier. In this way, an adversary could inject adversarial     identifier definitions in upstream software that are not detected by human reviewers and are invoked     deceptively in downstream software. The Unicode Consortium has documented this class of security     vulnerability in its document, Unicode Technical Report #36, Unicode Security Considerations. The Unicode     Consortium also provides guidance on mitigations for this class of issues in Unicode Technical Standard     #39, Unicode Security Mechanisms. (CVE-2021-42694)

  - Rust is a multi-paradigm, general-purpose programming language designed for performance and safety,     especially safe concurrency. The Rust Security Response WG was notified that the `std::fs::remove_dir_all`     standard library function is vulnerable a race condition enabling symlink following (CWE-363). An attacker     could use this security issue to trick a privileged program into deleting files and directories the     attacker couldn't otherwise access or delete. Rust 1.0.0 through Rust 1.58.0 is affected by this     vulnerability with 1.58.1 containing a patch. Note that the following build targets don't have usable APIs     to properly mitigate the attack, and are thus still vulnerable even with a patched toolchain: macOS before     version 10.10 (Yosemite) and REDOX. We recommend everyone to update to Rust 1.58.1 as soon as possible,     especially people developing programs expected to run in privileged contexts (including system daemons and     setuid binaries), as those have the highest risk of being affected by this. Note that adding checks in     your codebase before calling remove_dir_all will not mitigate the vulnerability, as they would also be     vulnerable to race conditions like remove_dir_all itself. The existing mitigation is working as intended     outside of race conditions. (CVE-2022-21658)

  - Cargo is a package manager for the rust programming language. After a package is downloaded, Cargo     extracts its source code in the ~/.cargo folder on disk, making it available to the Rust projects it     builds. To record when an extraction is successful, Cargo writes ok to the .cargo-ok file at the root of     the extracted source code once it extracted all the files. It was discovered that Cargo allowed packages     to contain a .cargo-ok symbolic link, which Cargo would extract. Then, when Cargo attempted to write ok     into .cargo-ok, it would actually replace the first two bytes of the file the symlink pointed to with ok.
    This would allow an attacker to corrupt one file on the machine using Cargo to extract the package. Note     that by design Cargo allows code execution at build time, due to build scripts and procedural macros. The     vulnerabilities in this advisory allow performing a subset of the possible damage in a harder to track     down way. Your dependencies must still be trusted if you want to be protected from attacks, as it's     possible to perform the same attacks with build scripts and procedural macros. The vulnerability is     present in all versions of Cargo. Rust 1.64, to be released on September 22nd, will include a fix for it.
    Since the vulnerability is just a more limited way to accomplish what a malicious build scripts or     procedural macros can do, we decided not to publish Rust point releases backporting the security fix.
    Patch files are available for Rust 1.63.0 are available in the wg-security-response repository for people     building their own toolchain. Mitigations We recommend users of alternate registries to exercise care in     which package they download, by only including trusted dependencies in their projects. Please note that     even with these vulnerabilities fixed, by design Cargo allows arbitrary code execution at build time     thanks to build scripts and procedural macros: a malicious dependency will be able to cause damage     regardless of these vulnerabilities. crates.io implemented server-side checks to reject these kinds of     packages years ago, and there are no packages on crates.io exploiting these vulnerabilities. crates.io     users still need to exercise care in choosing their dependencies though, as remote code execution is     allowed by design there as well. (CVE-2022-36113)

  - Cargo is a package manager for the rust programming language. It was discovered that Cargo did not limit     the amount of data extracted from compressed archives. An attacker could upload to an alternate registry a     specially crafted package that extracts way more data than its size (also known as a zip bomb),     exhausting the disk space on the machine using Cargo to download the package. Note that by design Cargo     allows code execution at build time, due to build scripts and procedural macros. The vulnerabilities in     this advisory allow performing a subset of the possible damage in a harder to track down way. Your     dependencies must still be trusted if you want to be protected from attacks, as it's possible to perform     the same attacks with build scripts and procedural macros. The vulnerability is present in all versions of     Cargo. Rust 1.64, to be released on September 22nd, will include a fix for it. Since the vulnerability is     just a more limited way to accomplish what a malicious build scripts or procedural macros can do, we     decided not to publish Rust point releases backporting the security fix. Patch files are available for     Rust 1.63.0 are available in the wg-security-response repository for people building their own toolchain.
    We recommend users of alternate registries to excercise care in which package they download, by only     including trusted dependencies in their projects. Please note that even with these vulnerabilities fixed,     by design Cargo allows arbitrary code execution at build time thanks to build scripts and procedural     macros: a malicious dependency will be able to cause damage regardless of these vulnerabilities. crates.io     implemented server-side checks to reject these kinds of packages years ago, and there are no packages on     crates.io exploiting these vulnerabilities. crates.io users still need to excercise care in choosing their     dependencies though, as the same concerns about build scripts and procedural macros apply here.
    (CVE-2022-36114)

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

遠端主機受到 GLSA-202210-09 中所述的弱點影響 (Rust：多個弱點)

  - 在 Rust 1.50.0 版之前的標準程式庫中，read_to_end() 不會在不安全的內容中驗證 Read 的傳回值。此錯誤可導致緩衝區溢位。(CVE-2021-28875)

  - 在 Rust 1.52.0 版之前的標準程式庫中，Zip 實作有一個錯誤的安全性問題。當基礎迭代器發生錯誤時 (在某些情況下)，
    程式會針對相同的索引多次呼叫 __iterator_get_unchecked()。由於未滿足 TrustedRandomAccess 特質的安全性需求，此錯誤可導致記憶體安全違規。(CVE-2021-28876)

  - 在 Rust 1.51.0 之前版本的標準程式庫中，Zip 實作會在嵌套時針對相同的索引多次呼叫 __iterator_get_unchecked()。由於未滿足 TrustedRandomAccess 特質的安全性需求，此錯誤可導致記憶體安全違規。(CVE-2021-28877)

  - 在 Rust 1.52.0 之前版本的標準程式庫中，next_back() 和 next() 一起使用時，Zip 實作會針對相同的索引 (在某些情況下) 多次呼叫 __iterator_get_unchecked()。由於未滿足 TrustedRandomAccess 特質的安全性需求，此錯誤可導致記憶體安全違規。(CVE-2021-28878)

  - 在 Rust 1.52.0 之前版本的標準程式庫中，由於存在整數溢位問題，Zip 實作會報告大小不正確。再次使用已消耗的 Zip 迭代器時，此錯誤可導致緩衝區溢位。
    (CVE-2021-28879)

  - 在 1.53.0 之前的 Rust 版本中，library/std/src/net/parser.rs 未正確考量 IP 位址字串開頭的無關零字元，由於非預期的八進位轉譯，(在某些情況下) 允許攻擊者繞過以 IP 位址為基礎的存取控制。(CVE-2021-29922)

  - 在 Rust 1.52.0 之前版本的標準程式庫中，如果釋放元素錯誤，Vec: : from_iter 函式中會發生重複釋放。(CVE-2021-31162)

  - Dell EMC Avamar Server 19.4 版的 AvInstaller 中存在純文字密碼儲存弱點。本機攻擊者可能會利用此弱點，造成特定的使用者憑證遭到洩漏。攻擊者或可利用洩漏的憑證，以遭入侵帳戶的權限存取有弱點的應用程式。(CVE-2021-36317)

  - Dell EMC Avamar 18.2、19.1、19.2、19.3、19.4 版中存在純文字密碼儲存弱點。高權限使用者可能利用此弱點，造成程式完全中斷。
    (CVE-2021-36318)

  - ** 爭議 ** 在 Unicode 規格 14.0 和之前所有版本的雙向演算法中發現一個問題。它允許透過控制序列對字元進行視覺重新排序，這可用於特製原始程式碼，以呈現與編譯器和解譯器提取的 token 邏輯順序不同的邏輯。攻擊者可利用此弱點為接受 Unicode 的編譯器編碼原始程式碼，進而以隱形方式將目標弱點引入人工檢閱者程式。注意：Unicode Consortium 提供以下替代方法來呈現此問題。在國際文字的本質中發現一個問題，其可影響實作 Unicode 標準和 Unicode 雙向演算法 (所有版本) 支援的應用程式。由於文字顯示行為的緣故，當文字包含從左到右和從右到左的字元時，token 的視覺順序可能與其邏輯順序不同。
    此外，爲了完全支援雙向文字的需求而需要的控製字元可能進一步混淆 token 的邏輯順序。除非此問題得到緩解，否則攻擊者可透過特製的原始程式碼，造成人工檢閱者感知到的 token 順序與編譯器/解譯器等要處理的順序不符。Unicode Consortium 已在其「Unicode 技術報告 #36：Unicode 安全性注意事項」文件中記錄此類弱點。Unicode Consortium 也在「Unicode 技術標準 #39」的 「Unicode 安全性機制」和 Unicode 標準附件 #31「Unicode 識別碼和模式語法」中提供此類問題的緩解指南。此外，BIDI 規格允許應用程式以減輕程式文字中具有誤導性的視覺重新排序的方式來自訂實作。請參閱 Unicode 標準附件 #9「Unicode 雙向演算法」中的 HL4。
    (CVE-2021-42574)

  - ** 爭議 ** 在 Unicode 規格 14.0 和之前所有版本的字元定義中發現一個問題。該規格允許攻擊者使用在視覺上與目標識別碼相同的同形文字產生原始程式碼識別碼，例如函式名稱。攻擊者可利用此弱點，透過對抗性識別碼定義在上游軟體中注入程式碼，然後在下游軟體中以誘騙方式叫用。注意：Unicode Consortium 提供以下替代方法來呈現此問題。在國際文字的本質中發現一個問題，其可影響實作 Unicode 標準 (所有版本) 支援的應用程式。除非採取緩解措施，否則攻擊者可使用在視覺上與目標識別碼相同但實際不同的同質字元來產生原始程式碼識別碼。透過這種方式，攻擊者可在上游軟體中注入人類檢閱者無法偵測到的對抗性識別碼定義，並在下游軟體中以誘騙方式叫用。Unicode Consortium 已在其「Unicode 技術報告 #36：Unicode 安全性注意事項」文件中記錄此類安全性弱點。Unicode Consortium 也在「Unicode 技術標準 #39」的 「Unicode 安全性機制」中提供此類問題的緩解指南。(CVE-2021-42694)

  - Rust 是一種多範式、通用的程式設計語言，專為效能和安全性而設計，特別是安全並行性。Rust 安全性回應工作組得知，「std: : fs: : remove_dir_all」標準程式庫函式容易受到啟用符號連結之爭用情形的影響 (CWE-363)。攻擊者可利用此安全性問題，誘騙有權限的程式刪除其無法存取或刪除的檔案和目錄。Rust 1.0.0 版至 Rust 1.58.0 版會受到此弱點影響，其中 1.58.1 版包含一個修補程式。請注意，下列建構目標不提供可用的 API 來適當緩解攻擊造成的影響。因此，即使使用修補過的工具鏈(macOS 10.10 之前版本 (Yosemite) 和 REDOX)，這些目標仍會受到影響。我們建議所有使用者盡快更新至 Rust 1.58.1，尤其是開發預期在有權限的內容中執行程式 (包括系統程序和 setuid 二進位檔) 的人員，因為這些人受此問題影響的風險最高。請注意，於呼叫 remove_dir_all 之前在程式碼庫中新增檢查不會緩解弱點造成的影響，因為這些檢查也容易受到 remove_dir_all 本身之類的爭用情形影響。現有的緩解措施可在爭用情形之外正常運作。(CVE-2022-21658)

  - Cargo 是 rust 程式設計語言的套件管理員。下載套件後，Cargo 會在磁碟上的 ~/.cargo 資料夾中解壓縮其原始程式碼，使其可供其構建的 Rust 專案使用。為了記錄擷取成功的時間，Cargo 會在擷取所有檔案後，在所擷取的原始程式碼根目錄下的 .cargo-ok 檔案中寫入 ok。據發現，Cargo 允許套件包含 Cargo 會擷取的 .cargo-ok 符號連結。然後，當 Cargo 嘗試向 .cargo-ok 寫入 ok 時，它實際上會將符號連結所指向檔案的前兩個位元組替換為 ok。
    攻擊者可藉此損毀使用 Cargo 解壓縮套件的計算機上的一個檔案。請注意，由於建構指令碼和程序巨集，Cargo 允許在建構階段執行程式碼。此公告中的弱點允許攻擊者以更難以追蹤的方式執行部分可能的損害。如果您想避免受到攻擊，您的相依性仍必須受到信任，這是因為攻擊者可以使用版本指令碼和程序巨集執行相同的攻擊。所有 Cargo 版本都存在此弱點。於 9 月 22 日發佈的 Rust 1.64 中包含對此弱點的修正。
    由於該弱點只是實現惡意建置指令碼或程序巨集功能的有限方式，我們決定不發佈反向移植安全性修正的 Rust point 版本。
    現已提供適用於 Rust 1.63.0 的修補程式檔案 使用者可在 wg-security-response 存放庫中取得，以便構建自己的工具鏈。減輕風險 我們建議替代登錄檔的使用者謹慎下載，只在其專案中包含受信任的相依性。請注意，即使已修正這些弱點，由於建置指令碼和程序巨集，Cargo 仍允許在構建時執行任意程式碼：無論這些弱點如何，惡意相依性都能夠造成損害。多年前，crates.io 已實作伺服器端檢查，以拒絕這些類型的套件，並且 crates.io 上沒有套件可利用這些弱點。但是，crates.io 使用者在選擇其相依性時仍需謹慎，因為此處的設計也允許攻擊者觸發遠端程式碼執行攻擊。(CVE-2022-36113)

  - Cargo 是 rust 程式設計語言的套件管理員。據發現，Cargo 並未限制從壓縮封存擷取的資料量。攻擊者可將特製的套件上傳至替代登錄檔，該套件可擷取超過其大小的資料 (也稱為 zip 炸彈)，進而耗盡使用 Cargo 下載套件的計算機上的磁碟空間。請注意，由於建構指令碼和程序巨集，Cargo 允許在建構階段執行程式碼。此公告中的弱點允許攻擊者以更難以追蹤的方式執行部分可能的損害。如果您想避免受到攻擊，您的相依性仍必須受到信任，這是因為攻擊者可以使用版本指令碼和程序巨集執行相同的攻擊。所有 Cargo 版本都存在此弱點。於 9 月 22 日發佈的 Rust 1.64 中包含對此弱點的修正。由於該弱點只是實現惡意建置指令碼或程序巨集功能的有限方式，我們決定不發佈反向移植安全性修正的 Rust point 版本。現已提供適用於 Rust 1.63.0 的修補程式檔案 使用者可在 wg-security-response 存放庫中取得，以便構建自己的工具鏈。
    我們建議替代登錄檔的使用者謹慎下載，只在其專案中包含受信任的相依性。請注意，即使已修正這些弱點，由於建置指令碼和程序巨集，Cargo 仍允許在構建時執行任意程式碼：無論這些弱點如何，惡意相依性都能夠造成損害。多年前，crates.io 已實作伺服器端檢查，以拒絕這些類型的套件，並且 crates.io 上沒有套件可利用這些弱點。但是，crates.io 使用者在選擇其相依性時仍需謹慎，因為此處仍存在與建置指令碼和程序巨集相關的相同問題。
    (CVE-2022-36114)

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

远程主机受到 GLSA-202210-09 中所述漏洞的影响（Rust：多个漏洞）

  - 在 Rust 1.50.0 版之前的标准库中，read_to_end() 不会在不安全的上下文中验证 Read 的返回值。此缺陷可导致缓冲区溢出。(CVE-2021-28875)

  - 在 Rust 1.52.0 版之前的标准库中，Zip 实现存在错误安全问题。当底层迭代器错误时（在某些情况下），
    它会针对相同索引多次调用 __iterator_get_unchecked()。由于未满足 TrustedRandomAccess 特性的安全要求，此缺陷可导致内存安全冲突。(CVE-2021-28876)

  - 在 Rust 1.51.0 之前版本的标准库中，Zip 实现会在嵌套时针对相同索引多次调用 __iterator_get_unchecked()。由于未满足 TrustedRandomAccess 特性的安全要求，此缺陷可导致内存安全冲突。(CVE-2021-28877)

  - 在 Rust 1.52.0 之前版本的标准库中，next_back() 和 next() 一起使用时，Zip 实现会针对相同索引（在某些情况下）多次调用 __iterator_get_unchecked()。由于未满足 TrustedRandomAccess 特性的安全要求，此缺陷可导致内存安全冲突。(CVE-2021-28878)

  - 在 Rust 1.52.0 之前版本的标准库中，Zip 实现可能会因整数溢出问题报告不正确的大小。当再次使用用过的 Zip 迭代器时，此缺陷可导致缓冲区溢出。
    (CVE-2021-28879)

  - 在低于 1.53.0 的 Rust 版本中，library/std/src/net/parser.rs 未正确考虑 IP 地址字符串开头的无关零字符，攻击者可利用此漏洞（在某些情况下），绕过基于 IP 地址的访问控制，这是非预期的八进制解释所致。(CVE-2021-29922)

  - 在 Rust 1.52.0 之前版本的标准库中，如果释放元素错误，Vec: : from_iter 函数中会发生双重释放。(CVE-2021-31162)

  - Dell EMC Avamar Server 版本 19.4 在 AvInstaller 中包含一个纯文本密码存储漏洞。本地攻击者可能会利用此漏洞造成某些用户凭据遭到泄露。攻击者或可使用暴露的凭据，以受损帐户的权限访问易受攻击的应用程序。(CVE-2021-36317)

  - Dell EMC Avamar 版本 18.2、19.1、19.2、19.3 和 19.4 中包含一个纯文本密码存储漏洞。高权限用户可能利用此漏洞导致完全中断。
    (CVE-2021-36318)

  - ** 争议 ** 发现 Unicode 规范 14.0 及之前版本的双向算法中存在问题。它允许通过控制序列对字符进行可视化重新排序，可用于构建呈现与编译器和解释器提取的标记逻辑顺序不同的逻辑的源代码。攻击者可利用此问题为接受 Unicode 的编译器编码源代码，从而以隐蔽方式将目标漏洞引入人工审查者程序。注意：Unicode Consortium 提供了以下替代方法来表示此问题。在国际文本的性质中发现一个问题，其可影响实现 Unicode 标准和 Unicode 双向算法（所有版本）支持的应用程序。由于文本显示行为，当文本包含从左到右和从右到左的字符时，标记的视觉顺序可能与其逻辑顺序不同。
    此外，为完全支持双向文本的要求所需的控制字符可能会进一步混淆标记的逻辑顺序。除非问题得到缓解，否则攻击者可通过特制的源代码，造成人工审查者感知到的标记排序与编译器/解释器等要处理的标记不符。Unicode Consortium 已在其“Unicode 技术报告 #36：Unicode 安全注意事项”文档中记录此类漏洞。Unicode Consortium 还在《Unicode 技术标准 #39》的“Unicode 安全机制”以及《Unicode 标准附件 #31》的“Unicode 标识符和模式语法”中提供此类问题的缓解措施指南。此外，BIDI 规范允许应用程序以可缓解程序文本中具误导性的视觉重新排序的方式来定制实现。请参阅《Unicode 标准附件 #9》“Unicode 双向算法”中的 HL4。
    (CVE-2021-42574)

  - ** 争议 ** 发现 Unicode 规范 14.0 及之前版本的字符定义中存在问题。该规范允许攻击者使用在视觉上与目标标识符相同的同形文字生成函数名称等源代码标识符。攻击者可利用此漏洞，通过在下游软件中欺骗性调用的上游软件依存关系中的对抗性标识符定义注入代码。注意：Unicode Consortium 提供了以下替代方法来表示此问题。在国际文本的性质中发现一个问题，其可影响实现 Unicode 标准（所有版本）支持的应用程序。除非得到缓解，否则攻击者可使用在视觉上与目标标识符相同但不同的同形异义字符生成源代码标识符。通过这种方式，攻击者可在人工审查者未检测到的上游软件中注入对抗性标识符定义，并在下游软件中进行欺骗性调用。Unicode Consortium 已在其“Unicode 技术报告 #36：Unicode 安全注意事项”文档中记录此类安全漏洞。Unicode Consortium 还在《Unicode 技术标准 #39》的“Unicode 安全机制””中提供此类问题的缓解措施指南。(CVE-2021-42694)

  - Rust 是专为性能和安全（尤其是安全并发）而设计的多范式通用编程语言。Rust 安全响应工作组收到通知，其中指出 `std: : fs：: remove_dir_all` 标准库函数容易受到启用符号链接跟随的争用条件的影响 (CWE-363)。攻击者可利用此安全问题诱骗特权程序删除其无法以其他方式访问或删除的文件和目录。Rust 1.0.0 至 Rust 1.58.0 会受到此漏洞影响，其中 1.58.1 版本中包含一个补丁。请注意，以下构建目标没有可用的 API 来正确缓解攻击，因此即使使用修补过的工具链（macOS 10.10 之前版本 (Yosemite) 和 REDOX）也仍易受到攻击。我们建议所有用户尽快更新到 Rust 1.58.1，尤其是开发预计在特权上下文（包括系统后台程序和 setuid 二进制文件）中运行程序的人员，因为他们最容易受此漏洞影响。请注意，在调用 remove_dir_all 之前于代码库中添加检查不会缓解此漏洞，因为这些检查也容易受到 remove_dir_all 本身等争用条件的影响。现有的缓解措施可以在无争用条件的情况下按预期正常工作。(CVE-2022-21658)

  - Cargo 是 rust 编程语言的程序包管理器。下载程序包后，Cargo 会在磁盘上的 ~/.cargo 文件夹中提取其源代码，以供其构建的 Rust 项目使用。为了记录提取成功的时间，Cargo 在提取所有文件后，会向所提取源代码根处的 .cargo-ok 文件写入 ok。据发现，Cargo 允许程序包包含 Cargo 会提取的 .cargo-ok 符号链接。然后，当 Cargo 尝试将 ok 写入 .cargo-ok 时，它实际上会将符号链接指向的文件的前两个字节替换为 ok。
    这将允许攻击者损坏使用 Cargo 的计算机上的一个文件以提取程序包。请注意，由于构建脚本和程序宏，Cargo 按照设计允许在构建时执行代码。此公告中的漏洞允许以更难追踪的方式执行部分潜在破坏。如果您想要免受攻击，则必须仍然信任您的依存关系，因为可以使用构建脚本和程序宏执行相同的攻击。所有 Cargo 版本中均存在此漏洞。9 月 22 日发布的 Rust 1.64 将包含一个补丁。
    由于该漏洞只是实现恶意构建脚本或程序宏功能的更有限方式，因此我们决定不发布向后移植此安全补丁的 Rust 点版本。
    Rust 1.63.0 的修补程序文件现已推出，可在 wg-security-response 存储库中用于构建自己的工具链。缓解措施 我们建议备用注册表用户在下载程序包时谨慎行事，仅在其项目中包含受信任的依存关系。请注意，即使修复了这些漏洞，由于构建脚本和程序宏，Cargo 按照设计允许在构建时执行任意代码：无论这些漏洞如何，恶意依存关系都将造成破坏。 crates.io 多年前实施了服务器端检查以拒绝此类程序包，crates.io 上不存在利用这些漏洞的程序包。不过，crates.io 用户在选择依存关系时仍需谨慎，因为那里的设计也允许远程代码执行。(CVE-2022-36113)

  - Cargo 是 rust 编程语言的程序包管理器。据发现，Cargo 未限制从压缩存档中提取的数据量。攻击者可将提取的数据量超过其大小的特制程序包（也称为 zip 炸弹）上传到备用注册表，从而使用 Cargo 下载程序包以耗尽计算机上的磁盘空间。请注意，由于构建脚本和程序宏，Cargo 按照设计允许在构建时执行代码。此公告中的漏洞允许以更难追踪的方式执行部分潜在破坏。如果您想要免受攻击，则必须仍然信任您的依存关系，因为可以使用构建脚本和程序宏执行相同的攻击。所有 Cargo 版本中均存在此漏洞。9 月 22 日发布的 Rust 1.64 将包含一个补丁。由于该漏洞只是实现恶意构建脚本或程序宏功能的更有限方式，因此我们决定不发布向后移植此安全补丁的 Rust 点版本。Rust 1.63.0 的修补程序文件现已推出，可在 wg-security-response 存储库中用于构建自己的工具链。
    我们建议备用注册表用户在下载程序包时谨慎行事，仅在其项目中包含受信任的依存关系。请注意，即使修复了这些漏洞，由于构建脚本和程序宏，Cargo 按照设计允许在构建时执行任意代码：无论这些漏洞如何，恶意依存关系都将造成破坏。 crates.io 多年前实施了服务器端检查以拒绝此类程序包，crates.io 上不存在利用这些漏洞的程序包。不过，crates.io 用户在选择依存关系时仍需谨慎，因为其所面临的问题与构建脚本和程序宏面临的一样。
    (CVE-2022-36114)

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

ID	名稱	產品	系列	已發布	已更新	嚴重性
166161	GLSA-202210-09 : Rust: Multiple Vulnerabilities	Nessus	Gentoo Local Security Checks	2022/10/16	2023/10/9	critical
166161	GLSA-202210-09：Rust：多個弱點	Nessus	Gentoo Local Security Checks	2022/10/16	2023/10/9	critical
166161	GLSA-202210-09 : Rust：多个漏洞	Nessus	Gentoo Local Security Checks	2022/10/16	2023/10/9	critical

偵測

搜尋 Plugin

critical

critical

critical