Latest data: Mon Jan 6 08:09:05 UTC 2025

Homebrew · Jan 6, 2025 · bc6d6c7 · bc6d6c7
1 parent 5bc7899
commit bc6d6c7
Show file tree

Hide file tree

Showing 21 changed files with 112 additions and 42 deletions.
diff --git a/audits/aider-requirements.audit.json b/audits/aider-requirements.audit.json
@@ -19,6 +19,7 @@
         ],
         "related": [
           "CGA-2589-9xpr-fmp7",
+          "CGA-9x7g-9rfp-4xhm",
           "CGA-gvvw-7w3r-7m54",
           "CGA-mvqg-6j62-4pjm",
           "CGA-whf8-42p9-686q"
@@ -161,7 +162,8 @@
           "CGA-79fr-pvjg-j9xm",
           "CGA-crfr-r549-cvmg",
           "CGA-gm37-p355-3fq6",
-          "CGA-h3v9-xgx5-mrgr"
+          "CGA-h3v9-xgx5-mrgr",
+          "CGA-p9v5-jpj2-q3ww"
         ],
         "summary": "Jinja has a sandbox breakout through indirect reference to format method",
         "details": "An oversight in how the Jinja sandboxed environment detects calls to `str.format` allows an attacker that controls the content of a template to execute arbitrary Python code.\n\nTo exploit the vulnerability, an attacker needs to control the content of a template. Whether that is the case depends on the type of application using Jinja. This vulnerability impacts users of applications which execute untrusted templates.\n\nJinja's sandbox does catch calls to `str.format` and ensures they don't escape the sandbox. However, it's possible to store a reference to a malicious string's `format` method, then pass that to a filter that calls it. No such filters are built-in to Jinja, but could be present through custom filters in an application. After the fix, such indirect calls are also handled by the sandbox.",

diff --git a/audits/ansible-lint-requirements.audit.json b/audits/ansible-lint-requirements.audit.json
@@ -19,6 +19,7 @@
         ],
         "related": [
           "CGA-2589-9xpr-fmp7",
+          "CGA-9x7g-9rfp-4xhm",
           "CGA-gvvw-7w3r-7m54",
           "CGA-mvqg-6j62-4pjm",
           "CGA-whf8-42p9-686q"
@@ -161,7 +162,8 @@
           "CGA-79fr-pvjg-j9xm",
           "CGA-crfr-r549-cvmg",
           "CGA-gm37-p355-3fq6",
-          "CGA-h3v9-xgx5-mrgr"
+          "CGA-h3v9-xgx5-mrgr",
+          "CGA-p9v5-jpj2-q3ww"
         ],
         "summary": "Jinja has a sandbox breakout through indirect reference to format method",
         "details": "An oversight in how the Jinja sandboxed environment detects calls to `str.format` allows an attacker that controls the content of a template to execute arbitrary Python code.\n\nTo exploit the vulnerability, an attacker needs to control the content of a template. Whether that is the case depends on the type of application using Jinja. This vulnerability impacts users of applications which execute untrusted templates.\n\nJinja's sandbox does catch calls to `str.format` and ensures they don't escape the sandbox. However, it's possible to store a reference to a malicious string's `format` method, then pass that to a filter that calls it. No such filters are built-in to Jinja, but could be present through custom filters in an application. After the fix, such indirect calls are also handled by the sandbox.",

diff --git a/audits/certsync-requirements.audit.json b/audits/certsync-requirements.audit.json
@@ -19,6 +19,7 @@
         ],
         "related": [
           "CGA-2589-9xpr-fmp7",
+          "CGA-9x7g-9rfp-4xhm",
           "CGA-gvvw-7w3r-7m54",
           "CGA-mvqg-6j62-4pjm",
           "CGA-whf8-42p9-686q"
@@ -161,7 +162,8 @@
           "CGA-79fr-pvjg-j9xm",
           "CGA-crfr-r549-cvmg",
           "CGA-gm37-p355-3fq6",
-          "CGA-h3v9-xgx5-mrgr"
+          "CGA-h3v9-xgx5-mrgr",
+          "CGA-p9v5-jpj2-q3ww"
         ],
         "summary": "Jinja has a sandbox breakout through indirect reference to format method",
         "details": "An oversight in how the Jinja sandboxed environment detects calls to `str.format` allows an attacker that controls the content of a template to execute arbitrary Python code.\n\nTo exploit the vulnerability, an attacker needs to control the content of a template. Whether that is the case depends on the type of application using Jinja. This vulnerability impacts users of applications which execute untrusted templates.\n\nJinja's sandbox does catch calls to `str.format` and ensures they don't escape the sandbox. However, it's possible to store a reference to a malicious string's `format` method, then pass that to a filter that calls it. No such filters are built-in to Jinja, but could be present through custom filters in an application. After the fix, such indirect calls are also handled by the sandbox.",

diff --git a/audits/charmcraft-requirements.audit.json b/audits/charmcraft-requirements.audit.json
@@ -19,6 +19,7 @@
         ],
         "related": [
           "CGA-2589-9xpr-fmp7",
+          "CGA-9x7g-9rfp-4xhm",
           "CGA-gvvw-7w3r-7m54",
           "CGA-mvqg-6j62-4pjm",
           "CGA-whf8-42p9-686q"
@@ -161,7 +162,8 @@
           "CGA-79fr-pvjg-j9xm",
           "CGA-crfr-r549-cvmg",
           "CGA-gm37-p355-3fq6",
-          "CGA-h3v9-xgx5-mrgr"
+          "CGA-h3v9-xgx5-mrgr",
+          "CGA-p9v5-jpj2-q3ww"
         ],
         "summary": "Jinja has a sandbox breakout through indirect reference to format method",
         "details": "An oversight in how the Jinja sandboxed environment detects calls to `str.format` allows an attacker that controls the content of a template to execute arbitrary Python code.\n\nTo exploit the vulnerability, an attacker needs to control the content of a template. Whether that is the case depends on the type of application using Jinja. This vulnerability impacts users of applications which execute untrusted templates.\n\nJinja's sandbox does catch calls to `str.format` and ensures they don't escape the sandbox. However, it's possible to store a reference to a malicious string's `format` method, then pass that to a filter that calls it. No such filters are built-in to Jinja, but could be present through custom filters in an application. After the fix, such indirect calls are also handled by the sandbox.",

diff --git a/audits/gdbgui-requirements.audit.json b/audits/gdbgui-requirements.audit.json
@@ -281,6 +281,7 @@
         ],
         "related": [
           "CGA-2589-9xpr-fmp7",
+          "CGA-9x7g-9rfp-4xhm",
           "CGA-gvvw-7w3r-7m54",
           "CGA-mvqg-6j62-4pjm",
           "CGA-whf8-42p9-686q"
@@ -714,7 +715,8 @@
           "CGA-79fr-pvjg-j9xm",
           "CGA-crfr-r549-cvmg",
           "CGA-gm37-p355-3fq6",
-          "CGA-h3v9-xgx5-mrgr"
+          "CGA-h3v9-xgx5-mrgr",
+          "CGA-p9v5-jpj2-q3ww"
         ],
         "summary": "Jinja has a sandbox breakout through indirect reference to format method",
         "details": "An oversight in how the Jinja sandboxed environment detects calls to `str.format` allows an attacker that controls the content of a template to execute arbitrary Python code.\n\nTo exploit the vulnerability, an attacker needs to control the content of a template. Whether that is the case depends on the type of application using Jinja. This vulnerability impacts users of applications which execute untrusted templates.\n\nJinja's sandbox does catch calls to `str.format` and ensures they don't escape the sandbox. However, it's possible to store a reference to a malicious string's `format` method, then pass that to a filter that calls it. No such filters are built-in to Jinja, but could be present through custom filters in an application. After the fix, such indirect calls are also handled by the sandbox.",

diff --git a/audits/gi-docgen-requirements.audit.json b/audits/gi-docgen-requirements.audit.json
@@ -19,6 +19,7 @@
         ],
         "related": [
           "CGA-2589-9xpr-fmp7",
+          "CGA-9x7g-9rfp-4xhm",
           "CGA-gvvw-7w3r-7m54",
           "CGA-mvqg-6j62-4pjm",
           "CGA-whf8-42p9-686q"
@@ -161,7 +162,8 @@
           "CGA-79fr-pvjg-j9xm",
           "CGA-crfr-r549-cvmg",
           "CGA-gm37-p355-3fq6",
-          "CGA-h3v9-xgx5-mrgr"
+          "CGA-h3v9-xgx5-mrgr",
+          "CGA-p9v5-jpj2-q3ww"
         ],
         "summary": "Jinja has a sandbox breakout through indirect reference to format method",
         "details": "An oversight in how the Jinja sandboxed environment detects calls to `str.format` allows an attacker that controls the content of a template to execute arbitrary Python code.\n\nTo exploit the vulnerability, an attacker needs to control the content of a template. Whether that is the case depends on the type of application using Jinja. This vulnerability impacts users of applications which execute untrusted templates.\n\nJinja's sandbox does catch calls to `str.format` and ensures they don't escape the sandbox. However, it's possible to store a reference to a malicious string's `format` method, then pass that to a filter that calls it. No such filters are built-in to Jinja, but could be present through custom filters in an application. After the fix, such indirect calls are also handled by the sandbox.",

diff --git a/audits/harlequin-requirements.audit.json b/audits/harlequin-requirements.audit.json
@@ -19,6 +19,7 @@
         ],
         "related": [
           "CGA-2589-9xpr-fmp7",
+          "CGA-9x7g-9rfp-4xhm",
           "CGA-gvvw-7w3r-7m54",
           "CGA-mvqg-6j62-4pjm",
           "CGA-whf8-42p9-686q"
@@ -161,7 +162,8 @@
           "CGA-79fr-pvjg-j9xm",
           "CGA-crfr-r549-cvmg",
           "CGA-gm37-p355-3fq6",
-          "CGA-h3v9-xgx5-mrgr"
+          "CGA-h3v9-xgx5-mrgr",
+          "CGA-p9v5-jpj2-q3ww"
         ],
         "summary": "Jinja has a sandbox breakout through indirect reference to format method",
         "details": "An oversight in how the Jinja sandboxed environment detects calls to `str.format` allows an attacker that controls the content of a template to execute arbitrary Python code.\n\nTo exploit the vulnerability, an attacker needs to control the content of a template. Whether that is the case depends on the type of application using Jinja. This vulnerability impacts users of applications which execute untrusted templates.\n\nJinja's sandbox does catch calls to `str.format` and ensures they don't escape the sandbox. However, it's possible to store a reference to a malicious string's `format` method, then pass that to a filter that calls it. No such filters are built-in to Jinja, but could be present through custom filters in an application. After the fix, such indirect calls are also handled by the sandbox.",

diff --git a/audits/libplacebo-requirements.audit.json b/audits/libplacebo-requirements.audit.json
@@ -19,6 +19,7 @@
         ],
         "related": [
           "CGA-2589-9xpr-fmp7",
+          "CGA-9x7g-9rfp-4xhm",
           "CGA-gvvw-7w3r-7m54",
           "CGA-mvqg-6j62-4pjm",
           "CGA-whf8-42p9-686q"
@@ -161,7 +162,8 @@
           "CGA-79fr-pvjg-j9xm",
           "CGA-crfr-r549-cvmg",
           "CGA-gm37-p355-3fq6",
-          "CGA-h3v9-xgx5-mrgr"
+          "CGA-h3v9-xgx5-mrgr",
+          "CGA-p9v5-jpj2-q3ww"
         ],
         "summary": "Jinja has a sandbox breakout through indirect reference to format method",
         "details": "An oversight in how the Jinja sandboxed environment detects calls to `str.format` allows an attacker that controls the content of a template to execute arbitrary Python code.\n\nTo exploit the vulnerability, an attacker needs to control the content of a template. Whether that is the case depends on the type of application using Jinja. This vulnerability impacts users of applications which execute untrusted templates.\n\nJinja's sandbox does catch calls to `str.format` and ensures they don't escape the sandbox. However, it's possible to store a reference to a malicious string's `format` method, then pass that to a filter that calls it. No such filters are built-in to Jinja, but could be present through custom filters in an application. After the fix, such indirect calls are also handled by the sandbox.",

diff --git a/audits/litani-requirements.audit.json b/audits/litani-requirements.audit.json
@@ -19,6 +19,7 @@
         ],
         "related": [
           "CGA-2589-9xpr-fmp7",
+          "CGA-9x7g-9rfp-4xhm",
           "CGA-gvvw-7w3r-7m54",
           "CGA-mvqg-6j62-4pjm",
           "CGA-whf8-42p9-686q"
@@ -161,7 +162,8 @@
           "CGA-79fr-pvjg-j9xm",
           "CGA-crfr-r549-cvmg",
           "CGA-gm37-p355-3fq6",
-          "CGA-h3v9-xgx5-mrgr"
+          "CGA-h3v9-xgx5-mrgr",
+          "CGA-p9v5-jpj2-q3ww"
         ],
         "summary": "Jinja has a sandbox breakout through indirect reference to format method",
         "details": "An oversight in how the Jinja sandboxed environment detects calls to `str.format` allows an attacker that controls the content of a template to execute arbitrary Python code.\n\nTo exploit the vulnerability, an attacker needs to control the content of a template. Whether that is the case depends on the type of application using Jinja. This vulnerability impacts users of applications which execute untrusted templates.\n\nJinja's sandbox does catch calls to `str.format` and ensures they don't escape the sandbox. However, it's possible to store a reference to a malicious string's `format` method, then pass that to a filter that calls it. No such filters are built-in to Jinja, but could be present through custom filters in an application. After the fix, such indirect calls are also handled by the sandbox.",

diff --git a/audits/mentat-requirements.audit.json b/audits/mentat-requirements.audit.json
@@ -385,6 +385,7 @@
         ],
         "related": [
           "CGA-2589-9xpr-fmp7",
+          "CGA-9x7g-9rfp-4xhm",
           "CGA-gvvw-7w3r-7m54",
           "CGA-mvqg-6j62-4pjm",
           "CGA-whf8-42p9-686q"
@@ -818,7 +819,8 @@
           "CGA-79fr-pvjg-j9xm",
           "CGA-crfr-r549-cvmg",
           "CGA-gm37-p355-3fq6",
-          "CGA-h3v9-xgx5-mrgr"
+          "CGA-h3v9-xgx5-mrgr",
+          "CGA-p9v5-jpj2-q3ww"
         ],
         "summary": "Jinja has a sandbox breakout through indirect reference to format method",
         "details": "An oversight in how the Jinja sandboxed environment detects calls to `str.format` allows an attacker that controls the content of a template to execute arbitrary Python code.\n\nTo exploit the vulnerability, an attacker needs to control the content of a template. Whether that is the case depends on the type of application using Jinja. This vulnerability impacts users of applications which execute untrusted templates.\n\nJinja's sandbox does catch calls to `str.format` and ensures they don't escape the sandbox. However, it's possible to store a reference to a malicious string's `format` method, then pass that to a filter that calls it. No such filters are built-in to Jinja, but could be present through custom filters in an application. After the fix, such indirect calls are also handled by the sandbox.",

diff --git a/audits/organize-tool-requirements.audit.json b/audits/organize-tool-requirements.audit.json
@@ -19,6 +19,7 @@
         ],
         "related": [
           "CGA-2589-9xpr-fmp7",
+          "CGA-9x7g-9rfp-4xhm",
           "CGA-gvvw-7w3r-7m54",
           "CGA-mvqg-6j62-4pjm",
           "CGA-whf8-42p9-686q"
@@ -161,7 +162,8 @@
           "CGA-79fr-pvjg-j9xm",
           "CGA-crfr-r549-cvmg",
           "CGA-gm37-p355-3fq6",
-          "CGA-h3v9-xgx5-mrgr"
+          "CGA-h3v9-xgx5-mrgr",
+          "CGA-p9v5-jpj2-q3ww"
         ],
         "summary": "Jinja has a sandbox breakout through indirect reference to format method",
         "details": "An oversight in how the Jinja sandboxed environment detects calls to `str.format` allows an attacker that controls the content of a template to execute arbitrary Python code.\n\nTo exploit the vulnerability, an attacker needs to control the content of a template. Whether that is the case depends on the type of application using Jinja. This vulnerability impacts users of applications which execute untrusted templates.\n\nJinja's sandbox does catch calls to `str.format` and ensures they don't escape the sandbox. However, it's possible to store a reference to a malicious string's `format` method, then pass that to a filter that calls it. No such filters are built-in to Jinja, but could be present through custom filters in an application. After the fix, such indirect calls are also handled by the sandbox.",

diff --git a/audits/pytorch-requirements.audit.json b/audits/pytorch-requirements.audit.json
@@ -19,6 +19,7 @@
         ],
         "related": [
           "CGA-2589-9xpr-fmp7",
+          "CGA-9x7g-9rfp-4xhm",
           "CGA-gvvw-7w3r-7m54",
           "CGA-mvqg-6j62-4pjm",
           "CGA-whf8-42p9-686q"
@@ -161,7 +162,8 @@
           "CGA-79fr-pvjg-j9xm",
           "CGA-crfr-r549-cvmg",
           "CGA-gm37-p355-3fq6",
-          "CGA-h3v9-xgx5-mrgr"
+          "CGA-h3v9-xgx5-mrgr",
+          "CGA-p9v5-jpj2-q3ww"
         ],
         "summary": "Jinja has a sandbox breakout through indirect reference to format method",
         "details": "An oversight in how the Jinja sandboxed environment detects calls to `str.format` allows an attacker that controls the content of a template to execute arbitrary Python code.\n\nTo exploit the vulnerability, an attacker needs to control the content of a template. Whether that is the case depends on the type of application using Jinja. This vulnerability impacts users of applications which execute untrusted templates.\n\nJinja's sandbox does catch calls to `str.format` and ensures they don't escape the sandbox. However, it's possible to store a reference to a malicious string's `format` method, then pass that to a filter that calls it. No such filters are built-in to Jinja, but could be present through custom filters in an application. After the fix, such indirect calls are also handled by the sandbox.",

diff --git a/audits/recon-ng-requirements.audit.json b/audits/recon-ng-requirements.audit.json
@@ -19,6 +19,7 @@
         ],
         "related": [
           "CGA-2589-9xpr-fmp7",
+          "CGA-9x7g-9rfp-4xhm",
           "CGA-gvvw-7w3r-7m54",
           "CGA-mvqg-6j62-4pjm",
           "CGA-whf8-42p9-686q"
@@ -161,7 +162,8 @@
           "CGA-79fr-pvjg-j9xm",
           "CGA-crfr-r549-cvmg",
           "CGA-gm37-p355-3fq6",
-          "CGA-h3v9-xgx5-mrgr"
+          "CGA-h3v9-xgx5-mrgr",
+          "CGA-p9v5-jpj2-q3ww"
         ],
         "summary": "Jinja has a sandbox breakout through indirect reference to format method",
         "details": "An oversight in how the Jinja sandboxed environment detects calls to `str.format` allows an attacker that controls the content of a template to execute arbitrary Python code.\n\nTo exploit the vulnerability, an attacker needs to control the content of a template. Whether that is the case depends on the type of application using Jinja. This vulnerability impacts users of applications which execute untrusted templates.\n\nJinja's sandbox does catch calls to `str.format` and ensures they don't escape the sandbox. However, it's possible to store a reference to a malicious string's `format` method, then pass that to a filter that calls it. No such filters are built-in to Jinja, but could be present through custom filters in an application. After the fix, such indirect calls are also handled by the sandbox.",

diff --git a/audits/sail-requirements.audit.json b/audits/sail-requirements.audit.json
@@ -19,6 +19,7 @@
         ],
         "related": [
           "CGA-2589-9xpr-fmp7",
+          "CGA-9x7g-9rfp-4xhm",
           "CGA-gvvw-7w3r-7m54",
           "CGA-mvqg-6j62-4pjm",
           "CGA-whf8-42p9-686q"
@@ -161,7 +162,8 @@
           "CGA-79fr-pvjg-j9xm",
           "CGA-crfr-r549-cvmg",
           "CGA-gm37-p355-3fq6",
-          "CGA-h3v9-xgx5-mrgr"
+          "CGA-h3v9-xgx5-mrgr",
+          "CGA-p9v5-jpj2-q3ww"
         ],
         "summary": "Jinja has a sandbox breakout through indirect reference to format method",
         "details": "An oversight in how the Jinja sandboxed environment detects calls to `str.format` allows an attacker that controls the content of a template to execute arbitrary Python code.\n\nTo exploit the vulnerability, an attacker needs to control the content of a template. Whether that is the case depends on the type of application using Jinja. This vulnerability impacts users of applications which execute untrusted templates.\n\nJinja's sandbox does catch calls to `str.format` and ensures they don't escape the sandbox. However, it's possible to store a reference to a malicious string's `format` method, then pass that to a filter that calls it. No such filters are built-in to Jinja, but could be present through custom filters in an application. After the fix, such indirect calls are also handled by the sandbox.",