mlflow / mlflow

Large result: showing the top 520 of 33,923 findings (up to 200 per engine, most severe and most likely real first). Totals above include everything.

1. high Semgrep A formatted or concatenated string was detected as input to a ProcessBuilder call. This is dangerous if a variable is controlled by user input and could result in a command injection. Ensure your variables are not controlled by users or sufficiently sanitized. /mlflow/java/client/src/main/java/org/mlflow/artifacts/CliBasedArtifactRepository.java 99%
2. high Semgrep Found 'importlib.resources', which is a module only available on Python 3.7+. This does not work in lower versions, and therefore is not backwards compatible. Use importlib_resources instead for older Python versions. /mlflow/assistant/skill_installer.py 99%
3. high Semgrep Found 'importlib.resources', which is a module only available on Python 3.7+. This does not work in lower versions, and therefore is not backwards compatible. Use importlib_resources instead for older Python versions. /mlflow/pyspark/ml/__init__.py 99%
4. high Semgrep Found 'importlib.resources', which is a module only available on Python 3.7+. This does not work in lower versions, and therefore is not backwards compatible. Use importlib_resources instead for older Python versions. /mlflow/utils/import_hooks/__init__.py 99%
5. high Semgrep Found 'importlib.resources', which is a module only available on Python 3.7+. This does not work in lower versions, and therefore is not backwards compatible. Use importlib_resources instead for older Python versions. /mlflow/utils/providers.py 99%
6. high Dependency checker Typosquatting: 'pymssql' is suspiciously similar to 'pymysql' pyproject.toml 91%
7. high Dependency checker Typosquatting: 'cryptography<51,' is suspiciously similar to 'cryptography' pyproject.toml 90%
8. high Dependency checker Typosquatting: 'sqlalchemy<3,' is suspiciously similar to 'sqlalchemy' pyproject.toml 90%
9. high Semgrep Detected calls to child_process from a function argument `cmd`. This could lead to a command injection if the input is user controllable. Try to avoid calls to child_process, and if it is needed ensure user input is correctly sanitized or sandboxed. /.github/workflows/uv.js 86%
10. high Semgrep Detected calls to child_process from a function argument `cmd`. This could lead to a command injection if the input is user controllable. Try to avoid calls to child_process, and if it is needed ensure user input is correctly sanitized or sandboxed. /.github/workflows/uv.js 86%
11. high Bandit FTP-related functions are being called. FTP is considered insecure. Use SSH/SFTP/SCP or some other encrypted protocol. /mlflow/store/artifact/ftp_artifact_repo.py 84%
12. high Bandit A FTP-related module is being imported. FTP is considered insecure. Use SSH/SFTP/SCP or some other encrypted protocol. /mlflow/store/artifact/ftp_artifact_repo.py 77%
13. high Bandit A FTP-related module is being imported. FTP is considered insecure. Use SSH/SFTP/SCP or some other encrypted protocol. /tests/store/artifact/test_ftp_artifact_repo.py 77%
14. high Bandit A FTP-related module is being imported. FTP is considered insecure. Use SSH/SFTP/SCP or some other encrypted protocol. /mlflow/store/artifact/ftp_artifact_repo.py 77%
15. high Bandit A FTP-related module is being imported. FTP is considered insecure. Use SSH/SFTP/SCP or some other encrypted protocol. /tests/store/artifact/test_ftp_artifact_repo.py 77%
16. high Bandit tarfile.extractall used without any validation. Please check and discard dangerous members. /examples/flower_classifier/train.py 63%
17. high Bandit tarfile.extractall used without any validation. Please check and discard dangerous members. /mlflow/pyfunc/dbconnect_artifact_cache.py 63%
18. high Bandit tarfile.extractall used without any validation. Please check and discard dangerous members. /tests/utils/test_file_utils.py 63%
19. high Bandit tarfile.extractall used without any validation. Please check and discard dangerous members. /tests/utils/test_file_utils.py 63%
20. high Semgrep Using variable interpolation `${{...}}` with `github` context data in a `run:` step could allow an attacker to inject their own code into the runner. This would allow them to steal secrets and code. `github` context data can have arbitrary user input and should be treated as untrusted. Instead, use an intermediate environment variable with `env:` to store the data and use the environment variable in the `run:` script. Be sure to use double-quotes the environment variable, like this: "$ENVVAR". /.github/actions/setup-python/action.yml 55%
21. high Semgrep Using variable interpolation `${{...}}` with `github` context data in a `run:` step could allow an attacker to inject their own code into the runner. This would allow them to steal secrets and code. `github` context data can have arbitrary user input and should be treated as untrusted. Instead, use an intermediate environment variable with `env:` to store the data and use the environment variable in the `run:` script. Be sure to use double-quotes the environment variable, like this: "$ENVVAR". /.github/actions/setup-java/action.yml 55%
22. high Semgrep sqlalchemy.text passes the constructed SQL statement to the database mostly unchanged. This means that the usual SQL injection protections are not applied and this function is vulnerable to SQL injection if user input can reach here. Use normal SQLAlchemy operators (such as `or_()`, `and_()`, etc.) to construct SQL. /mlflow/store/model_registry/dbmodels/models.py 54%
23. high Semgrep sqlalchemy.text passes the constructed SQL statement to the database mostly unchanged. This means that the usual SQL injection protections are not applied and this function is vulnerable to SQL injection if user input can reach here. Use normal SQLAlchemy operators (such as `or_()`, `and_()`, etc.) to construct SQL. /mlflow/store/tracking/dbmodels/models.py 54%
24. high Semgrep sqlalchemy.text passes the constructed SQL statement to the database mostly unchanged. This means that the usual SQL injection protections are not applied and this function is vulnerable to SQL injection if user input can reach here. Use normal SQLAlchemy operators (such as `or_()`, `and_()`, etc.) to construct SQL. /mlflow/store/tracking/dbmodels/models.py 54%
25. high Semgrep sqlalchemy.text passes the constructed SQL statement to the database mostly unchanged. This means that the usual SQL injection protections are not applied and this function is vulnerable to SQL injection if user input can reach here. Use normal SQLAlchemy operators (such as `or_()`, `and_()`, etc.) to construct SQL. /mlflow/store/tracking/dbmodels/models.py 54%
26. high Semgrep sqlalchemy.text passes the constructed SQL statement to the database mostly unchanged. This means that the usual SQL injection protections are not applied and this function is vulnerable to SQL injection if user input can reach here. Use normal SQLAlchemy operators (such as `or_()`, `and_()`, etc.) to construct SQL. /mlflow/store/tracking/dbmodels/models.py 54%
27. high Semgrep sqlalchemy.text passes the constructed SQL statement to the database mostly unchanged. This means that the usual SQL injection protections are not applied and this function is vulnerable to SQL injection if user input can reach here. Use normal SQLAlchemy operators (such as `or_()`, `and_()`, etc.) to construct SQL. /mlflow/store/tracking/dbmodels/models.py 54%
28. high Semgrep sqlalchemy.text passes the constructed SQL statement to the database mostly unchanged. This means that the usual SQL injection protections are not applied and this function is vulnerable to SQL injection if user input can reach here. Use normal SQLAlchemy operators (such as `or_()`, `and_()`, etc.) to construct SQL. /mlflow/store/tracking/dbmodels/models.py 54%
29. high Semgrep sqlalchemy.text passes the constructed SQL statement to the database mostly unchanged. This means that the usual SQL injection protections are not applied and this function is vulnerable to SQL injection if user input can reach here. Use normal SQLAlchemy operators (such as `or_()`, `and_()`, etc.) to construct SQL. /mlflow/store/tracking/dbmodels/models.py 54%
30. high Semgrep sqlalchemy.text passes the constructed SQL statement to the database mostly unchanged. This means that the usual SQL injection protections are not applied and this function is vulnerable to SQL injection if user input can reach here. Use normal SQLAlchemy operators (such as `or_()`, `and_()`, etc.) to construct SQL. /mlflow/store/model_registry/dbmodels/models.py 54%
31. high Semgrep sqlalchemy.text passes the constructed SQL statement to the database mostly unchanged. This means that the usual SQL injection protections are not applied and this function is vulnerable to SQL injection if user input can reach here. Use normal SQLAlchemy operators (such as `or_()`, `and_()`, etc.) to construct SQL. /mlflow/store/model_registry/dbmodels/models.py 54%
32. high Semgrep sqlalchemy.text passes the constructed SQL statement to the database mostly unchanged. This means that the usual SQL injection protections are not applied and this function is vulnerable to SQL injection if user input can reach here. Use normal SQLAlchemy operators (such as `or_()`, `and_()`, etc.) to construct SQL. /mlflow/store/model_registry/dbmodels/models.py 54%
33. high Semgrep sqlalchemy.text passes the constructed SQL statement to the database mostly unchanged. This means that the usual SQL injection protections are not applied and this function is vulnerable to SQL injection if user input can reach here. Use normal SQLAlchemy operators (such as `or_()`, `and_()`, etc.) to construct SQL. /mlflow/store/model_registry/dbmodels/models.py 54%
34. high Semgrep sqlalchemy.text passes the constructed SQL statement to the database mostly unchanged. This means that the usual SQL injection protections are not applied and this function is vulnerable to SQL injection if user input can reach here. Use normal SQLAlchemy operators (such as `or_()`, `and_()`, etc.) to construct SQL. /mlflow/store/model_registry/dbmodels/models.py 54%
35. high Semgrep sqlalchemy.text passes the constructed SQL statement to the database mostly unchanged. This means that the usual SQL injection protections are not applied and this function is vulnerable to SQL injection if user input can reach here. Use normal SQLAlchemy operators (such as `or_()`, `and_()`, etc.) to construct SQL. /mlflow/store/fs2db/__init__.py 54%
36. high Semgrep sqlalchemy.text passes the constructed SQL statement to the database mostly unchanged. This means that the usual SQL injection protections are not applied and this function is vulnerable to SQL injection if user input can reach here. Use normal SQLAlchemy operators (such as `or_()`, `and_()`, etc.) to construct SQL. /mlflow/server/auth/db/models.py 54%
37. high Semgrep sqlalchemy.text passes the constructed SQL statement to the database mostly unchanged. This means that the usual SQL injection protections are not applied and this function is vulnerable to SQL injection if user input can reach here. Use normal SQLAlchemy operators (such as `or_()`, `and_()`, etc.) to construct SQL. /mlflow/server/auth/db/migrations/versions/2ed73881770d_workspace_permissions.py 54%
38. high Semgrep Generic API Key detected /docs/docusaurus.config.ts 50%
39. high Semgrep Functions reliant on pickle can result in arbitrary code execution. Consider loading from `state_dict`, using fickling, or switching to a safer serialization method like ONNX /mlflow/pytorch/_lightning_autolog.py 48%
40. high Semgrep Functions reliant on pickle can result in arbitrary code execution. Consider loading from `state_dict`, using fickling, or switching to a safer serialization method like ONNX /mlflow/pytorch/__init__.py 48%
41. high Semgrep Functions reliant on pickle can result in arbitrary code execution. Consider loading from `state_dict`, using fickling, or switching to a safer serialization method like ONNX /mlflow/pytorch/__init__.py 48%
42. high Semgrep Functions reliant on pickle can result in arbitrary code execution. Consider loading from `state_dict`, using fickling, or switching to a safer serialization method like ONNX /mlflow/pytorch/__init__.py 48%
43. high Semgrep Functions reliant on pickle can result in arbitrary code execution. Consider loading from `state_dict`, using fickling, or switching to a safer serialization method like ONNX /mlflow/pytorch/__init__.py 48%
44. high Semgrep Functions reliant on pickle can result in arbitrary code execution. Consider loading from `state_dict`, using fickling, or switching to a safer serialization method like ONNX /mlflow/pytorch/__init__.py 48%
45. high Semgrep Functions reliant on pickle can result in arbitrary code execution. Consider loading from `state_dict`, using fickling, or switching to a safer serialization method like ONNX /mlflow/pytorch/_lightning_autolog.py 48%
46. high Semgrep Possible path traversal through `tarfile.open($PATH).extractall()` if the source tar is controlled by an attacker /examples/flower_classifier/train.py 47%
47. high YARA YARA rule matched: detect_credential_harvester — References credential/secret material by name AND a deliberate outbound-send API in the same file - narrower than \'reads any env var\', which large legitimate codebases do constantly regardless of intent. Still not proof the two are connected (YARA can\'t trace data flow) - a known limitation, see NOTES.md /dev/check_patch_prs.py 33%
48. high YARA YARA rule matched: detect_credential_harvester — References credential/secret material by name AND a deliberate outbound-send API in the same file - narrower than \'reads any env var\', which large legitimate codebases do constantly regardless of intent. Still not proof the two are connected (YARA can\'t trace data flow) - a known limitation, see NOTES.md /dev/benchmarks/gateway/run.py 33%
49. high YARA YARA rule matched: detect_credential_harvester — References credential/secret material by name AND a deliberate outbound-send API in the same file - narrower than \'reads any env var\', which large legitimate codebases do constantly regardless of intent. Still not proof the two are connected (YARA can\'t trace data flow) - a known limitation, see NOTES.md /dev/update_model_catalog.py 33%
50. high YARA YARA rule matched: detect_credential_harvester — References credential/secret material by name AND a deliberate outbound-send API in the same file - narrower than \'reads any env var\', which large legitimate codebases do constantly regardless of intent. Still not proof the two are connected (YARA can\'t trace data flow) - a known limitation, see NOTES.md /dev/update_changelog.py 33%
51. high YARA YARA rule matched: detect_credential_harvester — References credential/secret material by name AND a deliberate outbound-send API in the same file - narrower than \'reads any env var\', which large legitimate codebases do constantly regardless of intent. Still not proof the two are connected (YARA can\'t trace data flow) - a known limitation, see NOTES.md /mlflow/metrics/genai/model_utils.py 33%
52. high YARA YARA rule matched: detect_credential_harvester — References credential/secret material by name AND a deliberate outbound-send API in the same file - narrower than \'reads any env var\', which large legitimate codebases do constantly regardless of intent. Still not proof the two are connected (YARA can\'t trace data flow) - a known limitation, see NOTES.md /dev/check_whitespace_only.py 33%
53. high YARA YARA rule matched: detect_base64_exec — Encoded payload decoded and then executed /mlflow/utils/search_utils.py 3%
54. high YARA YARA rule matched: detect_base64_exec — Encoded payload decoded and then executed /mlflow/entities/span.py 3%
55. high YARA YARA rule matched: detect_base64_exec — Encoded payload decoded and then executed /mlflow/server/auth/__init__.py 3%
56. high YARA YARA rule matched: detect_base64_exec — Encoded payload decoded and then executed /mlflow/server/js/yarn/releases/yarn-4.12.0.cjs 3%
57. high YARA YARA rule matched: detect_base64_exec — Encoded payload decoded and then executed /libs/typescript/core/src/exporters/wal/daemon.ts 3%
58. high YARA YARA rule matched: detect_base64_exec — Encoded payload decoded and then executed /mlflow/transformers/__init__.py 3%
59. high Semgrep User controlled data in methods like `innerHTML`, `outerHTML` or `document.write` is an anti-pattern that can lead to XSS vulnerabilities /libs/typescript/integrations/openai/docs/assets/main.js 3%
60. high Semgrep User controlled data in methods like `innerHTML`, `outerHTML` or `document.write` is an anti-pattern that can lead to XSS vulnerabilities /libs/typescript/integrations/openai/docs/assets/main.js 3%
61. high Semgrep User controlled data in methods like `innerHTML`, `outerHTML` or `document.write` is an anti-pattern that can lead to XSS vulnerabilities /mlflow/server/js/src/experiment-tracking/components/artifact-view-components/ShowArtifactMapView.tsx 3%
62. high YARA YARA rule matched: detect_download_and_execute — Downloads a remote resource AND executes it - the actually dangerous combination, not just downloading alone /.claude/scripts/install-agent-browser.sh 1%
63. high YARA YARA rule matched: detect_download_and_execute — Downloads a remote resource AND executes it - the actually dangerous combination, not just downloading alone /bin/install.py 1%
64. high YARA YARA rule matched: detect_download_and_execute — Downloads a remote resource AND executes it - the actually dangerous combination, not just downloading alone /mlflow/utils/file_utils.py 1%
65. high YARA YARA rule matched: detect_download_and_execute — Downloads a remote resource AND executes it - the actually dangerous combination, not just downloading alone /mlflow/ml-package-versions.yml 1%
66. high YARA YARA rule matched: detect_download_and_execute — Downloads a remote resource AND executes it - the actually dangerous combination, not just downloading alone /.claude/scripts/install-claude.sh 1%
67. high YARA YARA rule matched: detect_download_and_execute — Downloads a remote resource AND executes it - the actually dangerous combination, not just downloading alone /mlflow/transformers/__init__.py 1%
68. high YARA YARA rule matched: detect_download_and_execute — Downloads a remote resource AND executes it - the actually dangerous combination, not just downloading alone /dev/generate_protos.py 1%
69. high YARA YARA rule matched: detect_download_and_execute — Downloads a remote resource AND executes it - the actually dangerous combination, not just downloading alone /dev/run_dev_server.py 1%
70. high YARA YARA rule matched: detect_download_and_execute — Downloads a remote resource AND executes it - the actually dangerous combination, not just downloading alone /dev/remove_experimental_decorators.py 1%
71. high YARA YARA rule matched: detect_download_and_execute — Downloads a remote resource AND executes it - the actually dangerous combination, not just downloading alone /dev/check_patch_prs.py 1%
72. high YARA YARA rule matched: detect_download_and_execute — Downloads a remote resource AND executes it - the actually dangerous combination, not just downloading alone /dev/install-skinny.sh 1%
73. high YARA YARA rule matched: detect_download_and_execute — Downloads a remote resource AND executes it - the actually dangerous combination, not just downloading alone /.github/workflows/advice.js 1%
74. high YARA YARA rule matched: detect_download_and_execute — Downloads a remote resource AND executes it - the actually dangerous combination, not just downloading alone /dev/benchmarks/gateway/run.py 1%
75. high YARA YARA rule matched: detect_download_and_execute — Downloads a remote resource AND executes it - the actually dangerous combination, not just downloading alone /.github/workflows/ui-preview.yml 1%
76. high YARA YARA rule matched: detect_obfuscated_string_execution — Reconstructs a string character-by-character or from hex escapes, then immediately executes it - fromCharCode/chr() alone are common in ordinary text-processing code, so this requires both the reconstruction and an execution call together /mlflow/server/js/yarn/releases/yarn-4.12.0.cjs 1%
77. high YARA YARA rule matched: detect_obfuscated_string_execution — Reconstructs a string character-by-character or from hex escapes, then immediately executes it - fromCharCode/chr() alone are common in ordinary text-processing code, so this requires both the reconstruction and an execution call together /libs/typescript/core/src/core/utils/json-bigint/parse.js 1%
78. medium Semgrep This GitHub Actions workflow file uses `pull_request_target` and checks out code from the incoming pull request. When using `pull_request_target`, the Action runs in the context of the target repository, which includes access to all repository secrets. Normally, this is safe because the Action only runs code from the target repository, not the incoming PR. However, by checking out the incoming PR code, you're now using the incoming code for the rest of the action. You may be inadvertently executing arbitrary code from the incoming PR with access to repository secrets, which would let an attacker steal repository secrets. This normally happens by running build scripts (e.g., `npm build` and `make`) or dependency installation scripts (e.g., `python setup.py install`). Audit your workflow file to make sure no code from the incoming PR is executed. Please see https://securitylab.github.com/research/github-actions-preventing-pwn-requests/ for additional mitigations. /.github/workflows/ui-preview.yml 99%
79. medium Semgrep RegExp() called with a `searchQuery` function argument, this might allow an attacker to cause a Regular Expression Denial-of-Service (ReDoS) within your application as RegExP blocks the main thread. For this reason, it is recommended to use hardcoded regexes instead. If your regex is run on user-controlled input, consider performing input validation or use a regex checking/sanitization library such as https://www.npmjs.com/package/recheck to verify that the regex does not appear vulnerable to ReDoS. /mlflow/server/js/src/shared/web-shared/genai-traces-table/utils/DisplayUtils.tsx 99%
80. medium Semgrep RegExp() called with a `runId` function argument, this might allow an attacker to cause a Regular Expression Denial-of-Service (ReDoS) within your application as RegExP blocks the main thread. For this reason, it is recommended to use hardcoded regexes instead. If your regex is run on user-controlled input, consider performing input validation or use a regex checking/sanitization library such as https://www.npmjs.com/package/recheck to verify that the regex does not appear vulnerable to ReDoS. /mlflow/server/js/src/model-registry/utils/VersionUtils.ts 99%
81. medium Semgrep RegExp() called with a `variableName` function argument, this might allow an attacker to cause a Regular Expression Denial-of-Service (ReDoS) within your application as RegExP blocks the main thread. For this reason, it is recommended to use hardcoded regexes instead. If your regex is run on user-controlled input, consider performing input validation or use a regex checking/sanitization library such as https://www.npmjs.com/package/recheck to verify that the regex does not appear vulnerable to ReDoS. /mlflow/server/js/src/experiment-tracking/pages/experiment-scorers/utils/templateUtils.ts 99%
82. medium Semgrep RegExp() called with a `routePath` function argument, this might allow an attacker to cause a Regular Expression Denial-of-Service (ReDoS) within your application as RegExP blocks the main thread. For this reason, it is recommended to use hardcoded regexes instead. If your regex is run on user-controlled input, consider performing input validation or use a regex checking/sanitization library such as https://www.npmjs.com/package/recheck to verify that the regex does not appear vulnerable to ReDoS. /mlflow/server/js/src/experiment-tracking/components/experiment-page/hooks/useGetExperimentPageActiveTabByRoute.test.tsx 99%
83. medium Semgrep RegExp() called with a `shouldBeBold` function argument, this might allow an attacker to cause a Regular Expression Denial-of-Service (ReDoS) within your application as RegExP blocks the main thread. For this reason, it is recommended to use hardcoded regexes instead. If your regex is run on user-controlled input, consider performing input validation or use a regex checking/sanitization library such as https://www.npmjs.com/package/recheck to verify that the regex does not appear vulnerable to ReDoS. /mlflow/server/js/src/experiment-tracking/components/EntitySearchAutoComplete.utils.tsx 99%
84. medium Semgrep RegExp() called with a `shouldBeBold` function argument, this might allow an attacker to cause a Regular Expression Denial-of-Service (ReDoS) within your application as RegExP blocks the main thread. For this reason, it is recommended to use hardcoded regexes instead. If your regex is run on user-controlled input, consider performing input validation or use a regex checking/sanitization library such as https://www.npmjs.com/package/recheck to verify that the regex does not appear vulnerable to ReDoS. /mlflow/server/js/src/experiment-tracking/components/EntitySearchAutoComplete.utils.tsx 99%
85. medium Semgrep Insecure HostnameVerifier implementation detected. This will accept any SSL certificate with any hostname, which creates the possibility for man-in-the-middle attacks. /mlflow/java/client/src/main/java/org/mlflow/tracking/MlflowHttpCaller.java 99%
86. medium Semgrep Found a template created with string formatting. This is susceptible to server-side template injection and cross-site scripting attacks. /mlflow/server/auth/__init__.py 99%
87. medium Semgrep Found a template created with string formatting. This is susceptible to server-side template injection and cross-site scripting attacks. /mlflow/server/auth/__init__.py 99%
88. medium Semgrep These permissions `0o750` are widely permissive and grant access to more people than may be necessary. A good default is `0o644` which gives read and write access to yourself and read access to everyone else. /mlflow/utils/file_utils.py 99%
89. medium Semgrep These permissions `0o750` are widely permissive and grant access to more people than may be necessary. A good default is `0o644` which gives read and write access to yourself and read access to everyone else. /mlflow/utils/file_utils.py 99%
90. medium Semgrep These permissions `0o750` are widely permissive and grant access to more people than may be necessary. A good default is `0o644` which gives read and write access to yourself and read access to everyone else. /mlflow/pyfunc/__init__.py 99%
91. medium Semgrep Detects direct creations of SSLConnectionSocketFactories that don't disallow SSL v2, SSL v3, and TLS v1. SSLSocketFactory can be used to validate the identity of the HTTPS server against a list of trusted certificates. These protocols are deprecated due to POODLE, man in the middle attacks, and other vulnerabilities. /mlflow/java/client/src/main/java/org/mlflow/tracking/MlflowHttpCaller.java 99%
92. medium Semgrep If possible, it is better to rely on automatic pinning in PyTorch to avoid undefined behavior and for efficiency /examples/pytorch/HPOExample/hpo_mnist.py 98%
93. medium Semgrep If possible, it is better to rely on automatic pinning in PyTorch to avoid undefined behavior and for efficiency /examples/pytorch/torchscript/MNIST/mnist_torchscript.py 98%
94. medium Semgrep If possible, it is better to rely on automatic pinning in PyTorch to avoid undefined behavior and for efficiency /examples/pytorch/torchscript/MNIST/mnist_torchscript.py 98%
95. medium Semgrep If possible, it is better to rely on automatic pinning in PyTorch to avoid undefined behavior and for efficiency /examples/pytorch/mnist_tensorboard_artifact.py 98%
96. medium Semgrep If possible, it is better to rely on automatic pinning in PyTorch to avoid undefined behavior and for efficiency /examples/pytorch/mnist_tensorboard_artifact.py 98%
97. medium Semgrep If possible, it is better to rely on automatic pinning in PyTorch to avoid undefined behavior and for efficiency /examples/pytorch/HPOExample/hpo_mnist.py 98%
98. medium Semgrep If possible, it is better to rely on automatic pinning in PyTorch to avoid undefined behavior and for efficiency /examples/pytorch/HPOExample/hpo_mnist.py 98%
99. medium Semgrep If possible, it is better to rely on automatic pinning in PyTorch to avoid undefined behavior and for efficiency /examples/pytorch/HPOExample/hpo_mnist.py 98%
100. medium Semgrep If possible, it is better to rely on automatic pinning in PyTorch to avoid undefined behavior and for efficiency /examples/pytorch/MNIST/mnist_autolog_example.py 98%
101. medium Semgrep RegExp() called with a `value` function argument, this might allow an attacker to cause a Regular Expression Denial-of-Service (ReDoS) within your application as RegExP blocks the main thread. For this reason, it is recommended to use hardcoded regexes instead. If your regex is run on user-controlled input, consider performing input validation or use a regex checking/sanitization library such as https://www.npmjs.com/package/recheck to verify that the regex does not appear vulnerable to ReDoS. /mlflow/server/js/src/experiment-tracking/components/evaluation-artifacts-compare/components/EvaluationArtifactCompareTable.test.tsx 98%
102. medium Semgrep RegExp() called with a `value` function argument, this might allow an attacker to cause a Regular Expression Denial-of-Service (ReDoS) within your application as RegExP blocks the main thread. For this reason, it is recommended to use hardcoded regexes instead. If your regex is run on user-controlled input, consider performing input validation or use a regex checking/sanitization library such as https://www.npmjs.com/package/recheck to verify that the regex does not appear vulnerable to ReDoS. /mlflow/server/js/src/experiment-tracking/components/evaluation-artifacts-compare/components/EvaluationArtifactCompareTable.test.tsx 98%
103. medium Semgrep RegExp() called with a `value` function argument, this might allow an attacker to cause a Regular Expression Denial-of-Service (ReDoS) within your application as RegExP blocks the main thread. For this reason, it is recommended to use hardcoded regexes instead. If your regex is run on user-controlled input, consider performing input validation or use a regex checking/sanitization library such as https://www.npmjs.com/package/recheck to verify that the regex does not appear vulnerable to ReDoS. /mlflow/server/js/src/experiment-tracking/components/evaluation-artifacts-compare/components/EvaluationArtifactCompareTable.test.tsx 98%
104. medium Semgrep RegExp() called with a `value` function argument, this might allow an attacker to cause a Regular Expression Denial-of-Service (ReDoS) within your application as RegExP blocks the main thread. For this reason, it is recommended to use hardcoded regexes instead. If your regex is run on user-controlled input, consider performing input validation or use a regex checking/sanitization library such as https://www.npmjs.com/package/recheck to verify that the regex does not appear vulnerable to ReDoS. /mlflow/server/js/src/experiment-tracking/components/evaluation-artifacts-compare/components/EvaluationArtifactCompareTable.test.tsx 98%
105. medium Bandit Use of unsafe yaml load. Allows instantiation of arbitrary objects. Consider yaml.safe_load(). /mlflow/utils/yaml_utils.py 96%
106. medium Bandit Chmod setting a permissive mask 0o750 on file (tmp_nfs_dir). /mlflow/utils/file_utils.py 95%
107. medium Bandit Chmod setting a permissive mask 0o750 on file (tmp_dir). /mlflow/utils/file_utils.py 95%
108. medium Bandit Chmod setting a permissive mask 0o750 on file (tmp_model_dir). /mlflow/pyfunc/__init__.py 95%
109. medium Semgrep Service 'minio-create-bucket' allows for privilege escalation via setuid or setgid binaries. Add 'no-new-privileges:true' in 'security_opt' to prevent this. /examples/mlflow_artifacts/docker-compose.yml 91%
110. medium Semgrep Service 'minio' allows for privilege escalation via setuid or setgid binaries. Add 'no-new-privileges:true' in 'security_opt' to prevent this. /examples/mlflow_artifacts/docker-compose.yml 90%
111. medium Semgrep If an attacker can supply values that the application then uses to determine which class to instantiate or which method to invoke, the potential exists for the attacker to create control flow paths through the application that were not intended by the application developers. This attack vector may allow the attacker to bypass authentication or access control checks or otherwise cause the application to behave in an unexpected manner. /mlflow/java/client/src/main/java/org/mlflow/tracking/utils/DatabricksContext.java 86%
112. medium Semgrep Be careful with `flask.make_response()`. If this response is rendered onto a webpage, this could create a cross-site scripting (XSS) vulnerability. `flask.make_response()` will not autoescape HTML. If you are rendering HTML, write your HTML in a template file and use `flask.render_template()` which will take care of escaping. If you are returning data from an API, consider using `flask.jsonify()`. /mlflow/server/auth/__init__.py 84%
113. medium Semgrep Be careful with `flask.make_response()`. If this response is rendered onto a webpage, this could create a cross-site scripting (XSS) vulnerability. `flask.make_response()` will not autoescape HTML. If you are rendering HTML, write your HTML in a template file and use `flask.render_template()` which will take care of escaping. If you are returning data from an API, consider using `flask.jsonify()`. /mlflow/server/auth/__init__.py 84%
114. medium Semgrep Be careful with `flask.make_response()`. If this response is rendered onto a webpage, this could create a cross-site scripting (XSS) vulnerability. `flask.make_response()` will not autoescape HTML. If you are rendering HTML, write your HTML in a template file and use `flask.render_template()` which will take care of escaping. If you are returning data from an API, consider using `flask.jsonify()`. /mlflow/server/auth/__init__.py 84%
115. medium Semgrep Be careful with `flask.make_response()`. If this response is rendered onto a webpage, this could create a cross-site scripting (XSS) vulnerability. `flask.make_response()` will not autoescape HTML. If you are rendering HTML, write your HTML in a template file and use `flask.render_template()` which will take care of escaping. If you are returning data from an API, consider using `flask.jsonify()`. /mlflow/server/auth/__init__.py 84%
116. medium Semgrep Be careful with `flask.make_response()`. If this response is rendered onto a webpage, this could create a cross-site scripting (XSS) vulnerability. `flask.make_response()` will not autoescape HTML. If you are rendering HTML, write your HTML in a template file and use `flask.render_template()` which will take care of escaping. If you are returning data from an API, consider using `flask.jsonify()`. /mlflow/server/auth/__init__.py 84%
117. medium Semgrep Be careful with `flask.make_response()`. If this response is rendered onto a webpage, this could create a cross-site scripting (XSS) vulnerability. `flask.make_response()` will not autoescape HTML. If you are rendering HTML, write your HTML in a template file and use `flask.render_template()` which will take care of escaping. If you are returning data from an API, consider using `flask.jsonify()`. /mlflow/server/auth/__init__.py 84%
118. medium Semgrep Be careful with `flask.make_response()`. If this response is rendered onto a webpage, this could create a cross-site scripting (XSS) vulnerability. `flask.make_response()` will not autoescape HTML. If you are rendering HTML, write your HTML in a template file and use `flask.render_template()` which will take care of escaping. If you are returning data from an API, consider using `flask.jsonify()`. /mlflow/server/auth/__init__.py 84%
119. medium Semgrep Be careful with `flask.make_response()`. If this response is rendered onto a webpage, this could create a cross-site scripting (XSS) vulnerability. `flask.make_response()` will not autoescape HTML. If you are rendering HTML, write your HTML in a template file and use `flask.render_template()` which will take care of escaping. If you are returning data from an API, consider using `flask.jsonify()`. /mlflow/server/auth/__init__.py 84%
120. medium Semgrep Be careful with `flask.make_response()`. If this response is rendered onto a webpage, this could create a cross-site scripting (XSS) vulnerability. `flask.make_response()` will not autoescape HTML. If you are rendering HTML, write your HTML in a template file and use `flask.render_template()` which will take care of escaping. If you are returning data from an API, consider using `flask.jsonify()`. /mlflow/server/auth/__init__.py 84%
121. medium Semgrep Be careful with `flask.make_response()`. If this response is rendered onto a webpage, this could create a cross-site scripting (XSS) vulnerability. `flask.make_response()` will not autoescape HTML. If you are rendering HTML, write your HTML in a template file and use `flask.render_template()` which will take care of escaping. If you are returning data from an API, consider using `flask.jsonify()`. /mlflow/server/auth/__init__.py 84%
122. medium Semgrep Be careful with `flask.make_response()`. If this response is rendered onto a webpage, this could create a cross-site scripting (XSS) vulnerability. `flask.make_response()` will not autoescape HTML. If you are rendering HTML, write your HTML in a template file and use `flask.render_template()` which will take care of escaping. If you are returning data from an API, consider using `flask.jsonify()`. /mlflow/server/auth/__init__.py 84%
123. medium Semgrep Be careful with `flask.make_response()`. If this response is rendered onto a webpage, this could create a cross-site scripting (XSS) vulnerability. `flask.make_response()` will not autoescape HTML. If you are rendering HTML, write your HTML in a template file and use `flask.render_template()` which will take care of escaping. If you are returning data from an API, consider using `flask.jsonify()`. /mlflow/server/auth/__init__.py 84%
124. medium Semgrep Be careful with `flask.make_response()`. If this response is rendered onto a webpage, this could create a cross-site scripting (XSS) vulnerability. `flask.make_response()` will not autoescape HTML. If you are rendering HTML, write your HTML in a template file and use `flask.render_template()` which will take care of escaping. If you are returning data from an API, consider using `flask.jsonify()`. /mlflow/server/auth/__init__.py 84%
125. medium Semgrep Be careful with `flask.make_response()`. If this response is rendered onto a webpage, this could create a cross-site scripting (XSS) vulnerability. `flask.make_response()` will not autoescape HTML. If you are rendering HTML, write your HTML in a template file and use `flask.render_template()` which will take care of escaping. If you are returning data from an API, consider using `flask.jsonify()`. /mlflow/server/auth/__init__.py 84%
126. medium Semgrep Be careful with `flask.make_response()`. If this response is rendered onto a webpage, this could create a cross-site scripting (XSS) vulnerability. `flask.make_response()` will not autoescape HTML. If you are rendering HTML, write your HTML in a template file and use `flask.render_template()` which will take care of escaping. If you are returning data from an API, consider using `flask.jsonify()`. /mlflow/server/auth/__init__.py 84%
127. medium Semgrep Be careful with `flask.make_response()`. If this response is rendered onto a webpage, this could create a cross-site scripting (XSS) vulnerability. `flask.make_response()` will not autoescape HTML. If you are rendering HTML, write your HTML in a template file and use `flask.render_template()` which will take care of escaping. If you are returning data from an API, consider using `flask.jsonify()`. /mlflow/server/auth/__init__.py 84%
128. medium Semgrep Be careful with `flask.make_response()`. If this response is rendered onto a webpage, this could create a cross-site scripting (XSS) vulnerability. `flask.make_response()` will not autoescape HTML. If you are rendering HTML, write your HTML in a template file and use `flask.render_template()` which will take care of escaping. If you are returning data from an API, consider using `flask.jsonify()`. /mlflow/server/auth/__init__.py 84%
129. medium Semgrep Be careful with `flask.make_response()`. If this response is rendered onto a webpage, this could create a cross-site scripting (XSS) vulnerability. `flask.make_response()` will not autoescape HTML. If you are rendering HTML, write your HTML in a template file and use `flask.render_template()` which will take care of escaping. If you are returning data from an API, consider using `flask.jsonify()`. /mlflow/server/auth/__init__.py 84%
130. medium Semgrep Be careful with `flask.make_response()`. If this response is rendered onto a webpage, this could create a cross-site scripting (XSS) vulnerability. `flask.make_response()` will not autoescape HTML. If you are rendering HTML, write your HTML in a template file and use `flask.render_template()` which will take care of escaping. If you are returning data from an API, consider using `flask.jsonify()`. /mlflow/server/auth/__init__.py 84%
131. medium Semgrep Be careful with `flask.make_response()`. If this response is rendered onto a webpage, this could create a cross-site scripting (XSS) vulnerability. `flask.make_response()` will not autoescape HTML. If you are rendering HTML, write your HTML in a template file and use `flask.render_template()` which will take care of escaping. If you are returning data from an API, consider using `flask.jsonify()`. /mlflow/server/auth/__init__.py 84%
132. medium Semgrep Be careful with `flask.make_response()`. If this response is rendered onto a webpage, this could create a cross-site scripting (XSS) vulnerability. `flask.make_response()` will not autoescape HTML. If you are rendering HTML, write your HTML in a template file and use `flask.render_template()` which will take care of escaping. If you are returning data from an API, consider using `flask.jsonify()`. /mlflow/server/auth/__init__.py 84%
133. medium Semgrep Be careful with `flask.make_response()`. If this response is rendered onto a webpage, this could create a cross-site scripting (XSS) vulnerability. `flask.make_response()` will not autoescape HTML. If you are rendering HTML, write your HTML in a template file and use `flask.render_template()` which will take care of escaping. If you are returning data from an API, consider using `flask.jsonify()`. /mlflow/server/auth/__init__.py 84%
134. medium Semgrep Service 'minio' is running with a writable root filesystem. This may allow malicious applications to download and run additional payloads, or modify container files. If an application inside a container has to save something temporarily consider using a tmpfs. Add 'read_only: true' to this service to prevent this. /examples/mlflow_artifacts/docker-compose.yml 81%
135. medium Semgrep Service 'minio-create-bucket' is running with a writable root filesystem. This may allow malicious applications to download and run additional payloads, or modify container files. If an application inside a container has to save something temporarily consider using a tmpfs. Add 'read_only: true' to this service to prevent this. /examples/mlflow_artifacts/docker-compose.yml 79%
136. medium Semgrep Service 'postgres' allows for privilege escalation via setuid or setgid binaries. Add 'no-new-privileges:true' in 'security_opt' to prevent this. /examples/mlflow_artifacts/docker-compose.yml 74%
137. medium Semgrep Service 'postgres' is running with a writable root filesystem. This may allow malicious applications to download and run additional payloads, or modify container files. If an application inside a container has to save something temporarily consider using a tmpfs. Add 'read_only: true' to this service to prevent this. /examples/mlflow_artifacts/docker-compose.yml 65%
138. medium Semgrep RegExp() called with a `filter` function argument, this might allow an attacker to cause a Regular Expression Denial-of-Service (ReDoS) within your application as RegExP blocks the main thread. For this reason, it is recommended to use hardcoded regexes instead. If your regex is run on user-controlled input, consider performing input validation or use a regex checking/sanitization library such as https://www.npmjs.com/package/recheck to verify that the regex does not appear vulnerable to ReDoS. /mlflow/server/js/src/experiment-tracking/components/runs-charts/components/sections/RunsChartsSectionAccordion.tsx 62%
139. medium Dependency checker Unpinned dependency: 'azure-storage-file-datalake' has no version lock — supply chain risk pyproject.toml 55%
140. medium Dependency checker Unpinned dependency: 'numpy' has no version lock — supply chain risk pyproject.toml 54%
141. medium Dependency checker Unpinned dependency: 'botocore' has no version lock — supply chain risk pyproject.toml 54%
142. medium Dependency checker Unpinned dependency: 'pyarrow' has no version lock — supply chain risk pyproject.toml 54%
143. medium Dependency checker Unpinned dependency: 'uvicorn' has no version lock — supply chain risk pyproject.toml 54%
144. medium Dependency checker Unpinned dependency: 'starlette' has no version lock — supply chain risk pyproject.toml 54%
145. medium Dependency checker Unpinned dependency: 'skops' has no version lock — supply chain risk pyproject.toml 54%
146. medium Dependency checker Unpinned dependency: 'scipy' has no version lock — supply chain risk pyproject.toml 54%
147. medium Dependency checker Unpinned dependency: 'pandas' has no version lock — supply chain risk pyproject.toml 54%
148. medium Dependency checker Unpinned dependency: 'packaging' has no version lock — supply chain risk pyproject.toml 54%
149. medium Dependency checker Unpinned dependency: 'PyMySQL' has no version lock — supply chain risk pyproject.toml 54%
150. medium Dependency checker Unpinned dependency: 'matplotlib' has no version lock — supply chain risk pyproject.toml 54%
151. medium Dependency checker Unpinned dependency: 'graphene' has no version lock — supply chain risk pyproject.toml 54%
152. medium Dependency checker Unpinned dependency: 'fastapi' has no version lock — supply chain risk pyproject.toml 54%
153. medium Dependency checker Unpinned dependency: 'cloudpickle' has no version lock — supply chain risk pyproject.toml 54%
154. medium Dependency checker Unpinned dependency: 'Flask' has no version lock — supply chain risk pyproject.toml 54%
155. medium Dependency checker Unpinned dependency: 'Flask-CORS' has no version lock — supply chain risk pyproject.toml 54%
156. medium Dependency checker Unpinned dependency: 'pysftp' has no version lock — supply chain risk pyproject.toml 54%
157. medium Dependency checker Unpinned dependency: 'pymssql' has no version lock — supply chain risk pyproject.toml 54%
158. medium Dependency checker Unpinned dependency: 'boto3' has no version lock — supply chain risk pyproject.toml 54%
159. medium Dependency checker Unpinned dependency: 'botocore' has no version lock — supply chain risk pyproject.toml 54%
160. medium Dependency checker Unpinned dependency: 'fastapi' has no version lock — supply chain risk pyproject.toml 54%
161. medium Dependency checker Unpinned dependency: 'tiktoken' has no version lock — supply chain risk pyproject.toml 54%
162. medium Dependency checker Unpinned dependency: 'watchfiles' has no version lock — supply chain risk pyproject.toml 54%
163. medium Dependency checker Unpinned dependency: 'fastapi' has no version lock — supply chain risk pyproject.toml 54%
164. medium Dependency checker Unpinned dependency: 'tiktoken' has no version lock — supply chain risk pyproject.toml 54%
165. medium Dependency checker Unpinned dependency: 'watchfiles' has no version lock — supply chain risk pyproject.toml 54%
166. medium Dependency checker Unpinned dependency: 'click' has no version lock — supply chain risk pyproject.toml 54%
167. medium Dependency checker Unpinned dependency: 'Flask-WTF' has no version lock — supply chain risk pyproject.toml 54%
168. medium Dependency checker Unpinned dependency: 'alembic' has no version lock — supply chain risk pyproject.toml 54%
169. medium Dependency checker Unpinned dependency: 'aliyunstoreplugin' has no version lock — supply chain risk pyproject.toml 54%
170. medium Dependency checker Unpinned dependency: 'mlflow-jfrog-plugin' has no version lock — supply chain risk pyproject.toml 54%
171. medium Dependency checker Unpinned dependency: 'uvicorn' has no version lock — supply chain risk pyproject.toml 54%
172. medium Dependency checker Unpinned dependency: 'gunicorn' has no version lock — supply chain risk pyproject.toml 54%
173. medium Dependency checker Unpinned dependency: 'waitress' has no version lock — supply chain risk pyproject.toml 54%
174. medium Dependency checker Unpinned dependency: 'prometheus-flask-exporter' has no version lock — supply chain risk pyproject.toml 54%
175. medium Dependency checker Unpinned dependency: 'uvicorn' has no version lock — supply chain risk pyproject.toml 54%
176. medium Dependency checker Unpinned dependency: 'boto3' has no version lock — supply chain risk pyproject.toml 54%
177. medium Dependency checker Unpinned dependency: 'psycopg2-binary' has no version lock — supply chain risk pyproject.toml 54%
178. medium Dependency checker Unpinned dependency: 'requests-auth-aws-sigv4' has no version lock — supply chain risk pyproject.toml 54%
179. medium Dependency checker Unpinned dependency: 'scikit-learn' has no version lock — supply chain risk pyproject.toml 53%
180. medium Dependency checker Unpinned dependency: 'mlflow-dbstore' has no version lock — supply chain risk pyproject.toml 53%
181. medium Dependency checker Unpinned dependency: 'kubernetes' has no version lock — supply chain risk pyproject.toml 51%
182. medium Dependency checker Unpinned dependency: 'kubernetes' has no version lock — supply chain risk pyproject.toml 51%
183. medium Semgrep Data is being piped into `bash` from a `curl` command. An attacker with control of the server in the `curl` command could inject malicious code into the pipe, resulting in a system compromise. Avoid piping untrusted data into `bash` or any other shell if you can. If you must do this, consider checking the SHA sum of the content returned by the server to verify its integrity. /dev/dev-env-setup.sh 51%
184. medium Semgrep CORS policy allows any origin (using wildcard '*'). This is insecure and should be avoided. /mlflow/server/fastapi_security.py 51%
185. medium Semgrep Detected SHA1 hash algorithm which is considered insecure. SHA1 is not collision resistant and is therefore not suitable as a cryptographic signature. Use SHA256 or SHA3 instead. /mlflow/pyfunc/__init__.py 49%
186. medium Semgrep Detected SHA1 hash algorithm which is considered insecure. SHA1 is not collision resistant and is therefore not suitable as a cryptographic signature. Use SHA256 or SHA3 instead. /mlflow/utils/conda.py 49%
187. medium Semgrep Detected SHA1 hash algorithm which is considered insecure. SHA1 is not collision resistant and is therefore not suitable as a cryptographic signature. Use SHA256 or SHA3 instead. /mlflow/utils/conda.py 49%
188. medium Semgrep Detected SHA1 hash algorithm which is considered insecure. SHA1 is not collision resistant and is therefore not suitable as a cryptographic signature. Use SHA256 or SHA3 instead. /mlflow/utils/environment.py 49%
189. medium Semgrep Detected a dynamic value being used with urllib. urllib supports 'file://' schemes, so a dynamic value controlled by a malicious actor may allow them to read arbitrary files. Audit uses of urllib calls to ensure user data cannot control the URLs, or consider using the 'requests' library instead. /dev/check_whitespace_only.py 49%
190. medium Semgrep Detected a dynamic value being used with urllib. urllib supports 'file://' schemes, so a dynamic value controlled by a malicious actor may allow them to read arbitrary files. Audit uses of urllib calls to ensure user data cannot control the URLs, or consider using the 'requests' library instead. /mlflow/tracking/context/jupyter_notebook_context.py 49%
191. medium Semgrep Detected a dynamic value being used with urllib. urllib supports 'file://' schemes, so a dynamic value controlled by a malicious actor may allow them to read arbitrary files. Audit uses of urllib calls to ensure user data cannot control the URLs, or consider using the 'requests' library instead. /dev/update_ml_package_versions.py 49%
192. medium Semgrep Detected a dynamic value being used with urllib. urllib supports 'file://' schemes, so a dynamic value controlled by a malicious actor may allow them to read arbitrary files. Audit uses of urllib calls to ensure user data cannot control the URLs, or consider using the 'requests' library instead. /dev/generate_protos.py 49%
193. medium Semgrep Detected a dynamic value being used with urllib. urllib supports 'file://' schemes, so a dynamic value controlled by a malicious actor may allow them to read arbitrary files. Audit uses of urllib calls to ensure user data cannot control the URLs, or consider using the 'requests' library instead. /dev/check_whitespace_only.py 49%
194. medium Semgrep Detected a dynamic value being used with urllib. urllib supports 'file://' schemes, so a dynamic value controlled by a malicious actor may allow them to read arbitrary files. Audit uses of urllib calls to ensure user data cannot control the URLs, or consider using the 'requests' library instead. /bin/install.py 49%
195. medium Bandit Use of unsafe PyTorch load /mlflow/pytorch/__init__.py 48%
196. medium Bandit Use of unsafe PyTorch load /mlflow/pytorch/__init__.py 48%
197. medium Bandit Use of unsafe PyTorch load /mlflow/pytorch/__init__.py 48%
198. medium Bandit Use of unsafe PyTorch load /mlflow/pytorch/_lightning_autolog.py 48%
199. medium Bandit Use of unsafe PyTorch load /examples/pytorch/CaptumExample/Titanic_Captum_Interpret.py 48%
200. medium Semgrep Detected the use of exec(). exec() can be dangerous if used to evaluate dynamic content. If this content can be input from outside the program, this may be a code injection vulnerability. Ensure evaluated content is not definable by external sources. /mlflow/genai/scorers/scorer_utils.py 47%
201. medium Bandit Audit url open for permitted schemes. Allowing use of file:/ or custom schemes is often unexpected. /mlflow/tracking/context/jupyter_notebook_context.py 46%
202. medium Bandit Audit url open for permitted schemes. Allowing use of file:/ or custom schemes is often unexpected. /dev/update_ml_package_versions.py 46%
203. medium Bandit Audit url open for permitted schemes. Allowing use of file:/ or custom schemes is often unexpected. /bin/install.py 46%
204. medium Bandit Audit url open for permitted schemes. Allowing use of file:/ or custom schemes is often unexpected. /dev/check_whitespace_only.py 46%
205. medium Bandit Audit url open for permitted schemes. Allowing use of file:/ or custom schemes is often unexpected. /dev/check_whitespace_only.py 46%
206. medium Bandit Audit url open for permitted schemes. Allowing use of file:/ or custom schemes is often unexpected. /dev/generate_protos.py 46%
207. medium Bandit Audit url open for permitted schemes. Allowing use of file:/ or custom schemes is often unexpected. /dev/remove_experimental_decorators.py 46%
208. medium Semgrep This link points to a plaintext HTTP URL. Prefer an encrypted HTTPS URL if possible. /docs/api_reference/theme/mlflow/layout_old.html 45%
209. medium Semgrep This link points to a plaintext HTTP URL. Prefer an encrypted HTTPS URL if possible. /docs/api_reference/theme/mlflow/versions.html 45%
210. medium Semgrep Detected direct use of jinja2. If not done properly, this may bypass HTML escaping which opens up the application to cross-site scripting (XSS) vulnerabilities. Prefer using the Flask method 'render_template()' and templates with a '.html' extension in order to prevent XSS. /mlflow/genai/judges/optimizers/memalign/utils.py 45%
211. medium Semgrep Detected direct use of jinja2. If not done properly, this may bypass HTML escaping which opens up the application to cross-site scripting (XSS) vulnerabilities. Prefer using the Flask method 'render_template()' and templates with a '.html' extension in order to prevent XSS. /mlflow/genai/judges/optimizers/memalign/utils.py 45%
212. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/pytorch/__init__.py 44%
213. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/agno/utils.py 44%
214. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/agno/utils.py 44%
215. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/crewai/__init__.py 44%
216. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/crewai/__init__.py 44%
217. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/langchain/databricks_dependencies.py 44%
218. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/langchain/utils/logging.py 44%
219. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/langchain/utils/logging.py 44%
220. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/langchain/utils/logging.py 44%
221. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/llama_index/serialize_objects.py 44%
222. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/llama_index/serialize_objects.py 44%
223. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/pyfunc/__init__.py 44%
224. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/pyfunc/__init__.py 44%
225. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/utils/lazy_load.py 44%
226. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/utils/class_utils.py 44%
227. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/utils/autologging_utils/versioning.py 44%
228. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/utils/autologging_utils/__init__.py 44%
229. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/utils/autologging_utils/__init__.py 44%
230. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/utils/_capture_modules.py 44%
231. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/utils/_capture_modules.py 44%
232. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/tracking/fluent.py 44%
233. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/tracing/utils/warning.py 44%
234. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/tensorflow/__init__.py 44%
235. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/tensorflow/__init__.py 44%
236. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/tensorflow/__init__.py 44%
237. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/sklearn/utils.py 44%
238. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/server/jobs/utils.py 44%
239. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/server/jobs/_job_subproc_entry.py 44%
240. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/server/auth/__init__.py 44%
241. medium Semgrep Untrusted user input in `importlib.import_module()` function allows an attacker to load arbitrary code. Avoid dynamic values in `importlib.import_module()` or use a whitelist to prevent running untrusted code. /mlflow/server/__init__.py 44%
242. medium Semgrep Found non static data as an index to 'globals()'. This is extremely dangerous because it allows an attacker to execute arbitrary code on the system. Refactor your code not to use 'globals()'. /mlflow/models/dependencies_schemas.py 44%
243. medium Semgrep Found non static data as an index to 'globals()'. This is extremely dangerous because it allows an attacker to execute arbitrary code on the system. Refactor your code not to use 'globals()'. /mlflow/models/dependencies_schemas.py 44%
244. medium Semgrep Found non static data as an index to 'globals()'. This is extremely dangerous because it allows an attacker to execute arbitrary code on the system. Refactor your code not to use 'globals()'. /mlflow/models/model_config.py 44%
245. medium Semgrep Detection of dangerouslySetInnerHTML from non-constant definition. This can inadvertently expose users to cross-site scripting (XSS) attacks if this comes from user-provided input. If you have to use dangerouslySetInnerHTML, consider using a sanitization library such as DOMPurify to sanitize your HTML. /docs/src/components/OpenAICompatibleGatewayDoc/index.tsx 44%
246. medium Semgrep Detection of dangerouslySetInnerHTML from non-constant definition. This can inadvertently expose users to cross-site scripting (XSS) attacks if this comes from user-provided input. If you have to use dangerouslySetInnerHTML, consider using a sanitization library such as DOMPurify to sanitize your HTML. /docs/src/components/OpenAICompatibleGatewayDoc/index.tsx 44%
247. medium Semgrep Detection of dangerouslySetInnerHTML from non-constant definition. This can inadvertently expose users to cross-site scripting (XSS) attacks if this comes from user-provided input. If you have to use dangerouslySetInnerHTML, consider using a sanitization library such as DOMPurify to sanitize your HTML. /docs/src/components/Card/index.tsx 44%
248. medium Semgrep Detection of dangerouslySetInnerHTML from non-constant definition. This can inadvertently expose users to cross-site scripting (XSS) attacks if this comes from user-provided input. If you have to use dangerouslySetInnerHTML, consider using a sanitization library such as DOMPurify to sanitize your HTML. /mlflow/server/js/src/common/components/EditableNote.tsx 44%
249. medium Bandit Function call with shell=True parameter identified, possible security issue. /mlflow/utils/virtualenv.py 42%
250. medium Bandit Function call with shell=True parameter identified, possible security issue. /mlflow/utils/virtualenv.py 42%
251. medium Semgrep Avoid using `pickle`, which is known to lead to code execution vulnerabilities. When unpickling, the serialized data could be manipulated to run arbitrary code. Instead, consider serializing the relevant data as JSON or a similar text-based serialization format. /mlflow/models/evaluation/artifacts.py 42%
252. medium Semgrep Avoid using `pickle`, which is known to lead to code execution vulnerabilities. When unpickling, the serialized data could be manipulated to run arbitrary code. Instead, consider serializing the relevant data as JSON or a similar text-based serialization format. /dev/clint/src/clint/index.py 42%
253. medium Semgrep Avoid using `pickle`, which is known to lead to code execution vulnerabilities. When unpickling, the serialized data could be manipulated to run arbitrary code. Instead, consider serializing the relevant data as JSON or a similar text-based serialization format. /dev/clint/src/clint/index.py 42%
254. medium Semgrep Avoid using `pickle`, which is known to lead to code execution vulnerabilities. When unpickling, the serialized data could be manipulated to run arbitrary code. Instead, consider serializing the relevant data as JSON or a similar text-based serialization format. /examples/sktime/flavor.py 42%
255. medium Semgrep Avoid using `pickle`, which is known to lead to code execution vulnerabilities. When unpickling, the serialized data could be manipulated to run arbitrary code. Instead, consider serializing the relevant data as JSON or a similar text-based serialization format. /examples/sktime/flavor.py 42%
256. medium Semgrep Avoid using `pickle`, which is known to lead to code execution vulnerabilities. When unpickling, the serialized data could be manipulated to run arbitrary code. Instead, consider serializing the relevant data as JSON or a similar text-based serialization format. /mlflow/models/evaluation/_shap_patch.py 42%
257. medium Semgrep Avoid using `pickle`, which is known to lead to code execution vulnerabilities. When unpickling, the serialized data could be manipulated to run arbitrary code. Instead, consider serializing the relevant data as JSON or a similar text-based serialization format. /mlflow/models/evaluation/artifacts.py 42%
258. medium Semgrep Avoid using `pickle`, which is known to lead to code execution vulnerabilities. When unpickling, the serialized data could be manipulated to run arbitrary code. Instead, consider serializing the relevant data as JSON or a similar text-based serialization format. /mlflow/sklearn/__init__.py 42%
259. medium Semgrep Avoid using `pickle`, which is known to lead to code execution vulnerabilities. When unpickling, the serialized data could be manipulated to run arbitrary code. Instead, consider serializing the relevant data as JSON or a similar text-based serialization format. /mlflow/pmdarima/__init__.py 42%
260. medium Semgrep Avoid using `pickle`, which is known to lead to code execution vulnerabilities. When unpickling, the serialized data could be manipulated to run arbitrary code. Instead, consider serializing the relevant data as JSON or a similar text-based serialization format. /mlflow/pmdarima/__init__.py 42%
261. medium Semgrep Avoid using `pickle`, which is known to lead to code execution vulnerabilities. When unpickling, the serialized data could be manipulated to run arbitrary code. Instead, consider serializing the relevant data as JSON or a similar text-based serialization format. /mlflow/models/evaluation/default_evaluator.py 42%
262. medium Bandit Possible SQL injection vector through string-based query construction. /tests/db/check_migration.py 42%
263. medium Bandit Possible SQL injection vector through string-based query construction. /tests/db/check_migration.py 42%
264. medium Bandit Possible SQL injection vector through string-based query construction. /tests/db/check_migration.py 42%
265. medium Bandit Possible SQL injection vector through string-based query construction. /mlflow/store/tracking/sqlalchemy_store.py 42%
266. medium Bandit Possible SQL injection vector through string-based query construction. /mlflow/store/fs2db/__init__.py 42%
267. medium Bandit Possible SQL injection vector through string-based query construction. /mlflow/genai/judges/instructions_judge/constants.py 42%
268. medium Bandit Possible SQL injection vector through string-based query construction. /mlflow/gateway/uc_function_utils.py 42%
269. medium Bandit Possible SQL injection vector through string-based query construction. /tests/store/fs2db/test_migration.py 42%
270. medium Bandit Possible SQL injection vector through string-based query construction. /tests/store/tracking/test_sqlalchemy_store.py 42%
271. medium Bandit Use of possibly insecure function - consider using safer ast.literal_eval. /tests/dspy/test_dspy_autolog.py 39%
272. medium Bandit Use of possibly insecure function - consider using safer ast.literal_eval. /tests/dspy/test_dspy_autolog.py 39%
273. medium Bandit Use of possibly insecure function - consider using safer ast.literal_eval. /tests/dspy/test_dspy_autolog.py 39%
274. medium Bandit Use of possibly insecure function - consider using safer ast.literal_eval. /tests/dspy/test_dspy_autolog.py 39%
275. medium Bandit Use of exec detected. /tests/genai/scorers/test_serialization.py 37%
276. medium Bandit Use of exec detected. /mlflow/genai/scorers/scorer_utils.py 37%
277. medium Semgrep Detected possible user input going into a `path.join` or `path.resolve` function. This could possibly lead to a path traversal vulnerability, where the attacker can access arbitrary files stored in the file system. Instead, be sure to sanitize or validate user input first. /mlflow/server/js/craco.config.js 34%
278. medium Semgrep Detected possible user input going into a `path.join` or `path.resolve` function. This could possibly lead to a path traversal vulnerability, where the attacker can access arbitrary files stored in the file system. Instead, be sure to sanitize or validate user input first. /mlflow/server/js/craco.config.js 34%
279. medium Semgrep Detected possible user input going into a `path.join` or `path.resolve` function. This could possibly lead to a path traversal vulnerability, where the attacker can access arbitrary files stored in the file system. Instead, be sure to sanitize or validate user input first. /mlflow/server/js/craco.config.js 34%
280. medium Semgrep Detected possible user input going into a `path.join` or `path.resolve` function. This could possibly lead to a path traversal vulnerability, where the attacker can access arbitrary files stored in the file system. Instead, be sure to sanitize or validate user input first. /docs/eslint-plugin-mlflow-docs/rules/valid-notebook-url.js 34%
281. medium Semgrep Detected possible user input going into a `path.join` or `path.resolve` function. This could possibly lead to a path traversal vulnerability, where the attacker can access arbitrary files stored in the file system. Instead, be sure to sanitize or validate user input first. /.github/workflows/snapshots.js 34%
282. medium Semgrep Detected possible user input going into a `path.join` or `path.resolve` function. This could possibly lead to a path traversal vulnerability, where the attacker can access arbitrary files stored in the file system. Instead, be sure to sanitize or validate user input first. /.github/workflows/snapshots.js 34%
283. medium Semgrep This tag is missing an 'integrity' subresource integrity attribute. The 'integrity' attribute allows for the browser to verify that externally hosted files (for example from a CDN) are delivered without unexpected manipulation. Without this attribute, if an attacker can modify the externally hosted resource, this could lead to XSS and other types of attacks. To prevent this, include the base64-encoded cryptographic hash of the resource (file) you’re telling the browser to fetch in the 'integrity' attribute for all externally hosted files. /mlflow/models/notebook_resources/agent_evaluation_template.html 34%
284. medium Semgrep This tag is missing an 'integrity' subresource integrity attribute. The 'integrity' attribute allows for the browser to verify that externally hosted files (for example from a CDN) are delivered without unexpected manipulation. Without this attribute, if an attacker can modify the externally hosted resource, this could lead to XSS and other types of attacks. To prevent this, include the base64-encoded cryptographic hash of the resource (file) you’re telling the browser to fetch in the 'integrity' attribute for all externally hosted files. /docs/api_reference/theme/mlflow/layout.html 34%
285. medium Semgrep This tag is missing an 'integrity' subresource integrity attribute. The 'integrity' attribute allows for the browser to verify that externally hosted files (for example from a CDN) are delivered without unexpected manipulation. Without this attribute, if an attacker can modify the externally hosted resource, this could lead to XSS and other types of attacks. To prevent this, include the base64-encoded cryptographic hash of the resource (file) you’re telling the browser to fetch in the 'integrity' attribute for all externally hosted files. /docs/api_reference/theme/mlflow/layout.html 34%
286. medium Semgrep This tag is missing an 'integrity' subresource integrity attribute. The 'integrity' attribute allows for the browser to verify that externally hosted files (for example from a CDN) are delivered without unexpected manipulation. Without this attribute, if an attacker can modify the externally hosted resource, this could lead to XSS and other types of attacks. To prevent this, include the base64-encoded cryptographic hash of the resource (file) you’re telling the browser to fetch in the 'integrity' attribute for all externally hosted files. /mlflow/models/notebook_resources/agent_evaluation_template.html 34%
287. medium Bandit Possible binding to all interfaces. /tests/pyfunc/test_scoring_server.py 34%
288. medium Bandit Possible binding to all interfaces. /tests/webhooks/app.py 34%
289. medium Bandit Possible binding to all interfaces. /tests/pyfunc/test_scoring_server.py 34%
290. medium Bandit Possible binding to all interfaces. /tests/pyfunc/test_mlserver.py 34%
291. medium Bandit Possible binding to all interfaces. /tests/pyfunc/test_mlserver.py 34%
292. medium Bandit Possible binding to all interfaces. /tests/pyfunc/test_mlserver.py 34%
293. medium Bandit Possible binding to all interfaces. /mlflow/server/security_utils.py 34%
294. medium Bandit Possible binding to all interfaces. /mlflow/genai/agent_server/server.py 34%
295. medium Bandit Possible binding to all interfaces. /tests/pyfunc/test_mlserver.py 34%
296. medium Bandit Pickle and modules that wrap it can be unsafe when used to deserialize untrusted data, possible security issue. /tests/utils/test_async_logging_queue.py 33%
297. medium Bandit Pickle and modules that wrap it can be unsafe when used to deserialize untrusted data, possible security issue. /tests/utils/test_async_logging_queue.py 33%
298. medium Bandit Pickle and modules that wrap it can be unsafe when used to deserialize untrusted data, possible security issue. /tests/utils/test_async_artifacts_logging_queue.py 33%
299. medium Bandit Pickle and modules that wrap it can be unsafe when used to deserialize untrusted data, possible security issue. /tests/utils/test_async_artifacts_logging_queue.py 33%
300. medium Bandit Pickle and modules that wrap it can be unsafe when used to deserialize untrusted data, possible security issue. /tests/test_exceptions.py 33%
301. medium Bandit Pickle and modules that wrap it can be unsafe when used to deserialize untrusted data, possible security issue. /tests/pyfunc/test_responses_agent.py 33%
302. medium Bandit Pickle and modules that wrap it can be unsafe when used to deserialize untrusted data, possible security issue. /tests/pyfunc/test_model_export_with_loader_module_and_data_path.py 33%
303. medium Bandit Pickle and modules that wrap it can be unsafe when used to deserialize untrusted data, possible security issue. /tests/pyfunc/test_chat_model.py 33%
304. medium Bandit Pickle and modules that wrap it can be unsafe when used to deserialize untrusted data, possible security issue. /tests/pyfunc/custom_model/loader.py 33%
305. medium Bandit Pickle and modules that wrap it can be unsafe when used to deserialize untrusted data, possible security issue. /tests/integration/async_logging/test_async_logging_integration.py 33%
306. medium Bandit Pickle and modules that wrap it can be unsafe when used to deserialize untrusted data, possible security issue. /tests/db/check_migration.py 33%
307. medium Bandit Pickle and modules that wrap it can be unsafe when used to deserialize untrusted data, possible security issue. /mlflow/sklearn/__init__.py 33%
308. medium Bandit Pickle and modules that wrap it can be unsafe when used to deserialize untrusted data, possible security issue. /mlflow/pmdarima/__init__.py 33%
309. medium Bandit Pickle and modules that wrap it can be unsafe when used to deserialize untrusted data, possible security issue. /mlflow/models/evaluation/artifacts.py 33%
310. medium Bandit Pickle and modules that wrap it can be unsafe when used to deserialize untrusted data, possible security issue. /examples/sktime/flavor.py 33%
311. medium Bandit Pickle and modules that wrap it can be unsafe when used to deserialize untrusted data, possible security issue. /dev/clint/src/clint/index.py 33%
312. medium Semgrep In Kubernetes, each pod runs in its own isolated environment with its own set of security policies. However, certain container images may contain `setuid` or `setgid` binaries that could allow an attacker to perform privilege escalation and gain access to sensitive resources. To mitigate this risk, it's recommended to add a `securityContext` to the container in the pod, with the parameter `allowPrivilegeEscalation` set to `false`. This will prevent the container from running any privileged processes and limit the impact of any potential attacks. By adding a `securityContext` to your Kubernetes pod, you can help to ensure that your containerized applications are more secure and less vulnerable to privilege escalation attacks. /examples/docker/kubernetes_job_template.yaml 29%
313. medium Bandit Probable insecure usage of temp file/directory. /tests/store/model_registry/test_databricks_workspace_model_registry_store.py 25%
314. medium Bandit Probable insecure usage of temp file/directory. /tests/server/test_handlers.py 25%
315. medium Bandit Probable insecure usage of temp file/directory. /tests/spark/test_spark_model_export.py 25%
316. medium Bandit Probable insecure usage of temp file/directory. /tests/store/artifact/test_hdfs_artifact_repo.py 25%
317. medium Bandit Probable insecure usage of temp file/directory. /tests/store/artifact/test_hdfs_artifact_repo.py 25%
318. medium Bandit Probable insecure usage of temp file/directory. /tests/store/artifact/test_hdfs_artifact_repo.py 25%
319. medium Bandit Probable insecure usage of temp file/directory. /tests/store/artifact/test_hdfs_artifact_repo.py 25%
320. medium Bandit Probable insecure usage of temp file/directory. /tests/store/artifact/test_http_artifact_repo.py 25%
321. medium Bandit Probable insecure usage of temp file/directory. /tests/store/artifact/test_local_artifact_repo.py 25%
322. medium Bandit Probable insecure usage of temp file/directory. /tests/store/artifact/test_unity_catalog_models_artifact_repo.py 25%
323. medium Bandit Probable insecure usage of temp file/directory. /tests/store/artifact/test_unity_catalog_models_artifact_repo.py 25%
324. medium Bandit Probable insecure usage of temp file/directory. /tests/store/artifact/test_unity_catalog_models_artifact_repo.py 25%
325. medium Bandit Probable insecure usage of temp file/directory. /tests/store/artifact/test_unity_catalog_models_artifact_repo.py 25%
326. medium Bandit Probable insecure usage of temp file/directory. /tests/store/artifact/test_unity_catalog_oss_models_artifact_repo.py 25%
327. medium Bandit Probable insecure usage of temp file/directory. /tests/store/model_registry/test_databricks_workspace_model_registry_store.py 25%
328. medium Bandit Probable insecure usage of temp file/directory. /mlflow/utils/file_utils.py 25%
329. medium Bandit Probable insecure usage of temp file/directory. /tests/store/model_registry/test_databricks_workspace_model_registry_store.py 25%
330. medium Bandit Probable insecure usage of temp file/directory. /tests/store/model_registry/test_databricks_workspace_model_registry_store.py 25%
331. medium Bandit Probable insecure usage of temp file/directory. /tests/store/model_registry/test_databricks_workspace_model_registry_store.py 25%
332. medium Bandit Probable insecure usage of temp file/directory. /tests/store/model_registry/test_databricks_workspace_model_registry_store.py 25%
333. medium Bandit Probable insecure usage of temp file/directory. /tests/store/model_registry/test_databricks_workspace_model_registry_store.py 25%
334. medium Bandit Probable insecure usage of temp file/directory. /tests/store/tracking/test_gateway_sql_store.py 25%
335. medium Bandit Probable insecure usage of temp file/directory. /tests/store/tracking/test_gateway_sql_store.py 25%
336. medium Bandit Probable insecure usage of temp file/directory. /tests/telemetry/test_tracked_events.py 25%
337. medium Bandit Probable insecure usage of temp file/directory. /tests/tracking/fluent/test_fluent.py 25%
338. medium Bandit Probable insecure usage of temp file/directory. /tests/tracking/test_rest_tracking.py 25%
339. medium Bandit Probable insecure usage of temp file/directory. /tests/utils/test_data.py 25%
340. medium Bandit Probable insecure usage of temp file/directory. /tests/utils/test_file_utils.py 25%
341. medium Bandit Probable insecure usage of temp file/directory. /tests/utils/test_file_utils.py 25%
342. medium Bandit Probable insecure usage of temp file/directory. /tests/utils/test_uri.py 25%
343. medium Bandit Probable insecure usage of temp file/directory. /tests/server/assistant/test_api.py 25%
344. medium Bandit Probable insecure usage of temp file/directory. /tests/data/test_artifact_dataset_sources.py 25%
345. medium Bandit Probable insecure usage of temp file/directory. /mlflow/utils/file_utils.py 25%
346. medium Bandit Probable insecure usage of temp file/directory. /mlflow/server/__init__.py 25%
347. medium Bandit Probable insecure usage of temp file/directory. /mlflow/server/__init__.py 25%
348. medium Bandit Probable insecure usage of temp file/directory. /mlflow/pyfunc/scoring_server/client.py 25%
349. medium Bandit Probable insecure usage of temp file/directory. /mlflow/pyfunc/__init__.py 25%
350. medium Bandit Probable insecure usage of temp file/directory. /mlflow/environment_variables.py 25%
351. medium Bandit Probable insecure usage of temp file/directory. /tests/data/test_artifact_dataset_sources.py 25%
352. medium Bandit Probable insecure usage of temp file/directory. /tests/data/test_artifact_dataset_sources.py 25%
353. medium Bandit Probable insecure usage of temp file/directory. /tests/data/test_meta_dataset.py 25%
354. medium Bandit Probable insecure usage of temp file/directory. /tests/entities/test_experiment.py 25%
355. medium Bandit Probable insecure usage of temp file/directory. /tests/entities/test_experiment.py 25%
356. medium Bandit Probable insecure usage of temp file/directory. /tests/entities/test_experiment.py 25%
357. medium Bandit Probable insecure usage of temp file/directory. /tests/models/test_container.py 25%
358. medium Bandit Probable insecure usage of temp file/directory. /tests/models/test_container.py 25%
359. medium Bandit Probable insecure usage of temp file/directory. /tests/models/test_container.py 25%
360. medium Bandit Probable insecure usage of temp file/directory. /tests/models/test_container.py 25%
361. medium Bandit Probable insecure usage of temp file/directory. /tests/models/test_container.py 25%
362. medium Bandit Probable insecure usage of temp file/directory. /tests/optuna/test_storage.py 25%
363. medium Bandit Probable insecure usage of temp file/directory. /tests/projects/test_docker_projects.py 25%
364. medium Bandit Probable insecure usage of temp file/directory. /tests/projects/test_docker_projects.py 25%
365. medium Bandit Probable insecure usage of temp file/directory. /tests/projects/test_docker_projects.py 25%
366. medium Bandit Probable insecure usage of temp file/directory. /tests/projects/test_docker_projects.py 25%
367. medium Bandit Probable insecure usage of temp file/directory. /tests/projects/test_docker_projects.py 25%
368. medium Bandit Probable insecure usage of temp file/directory. /tests/projects/test_docker_projects.py 25%
369. medium Bandit Probable insecure usage of temp file/directory. /tests/projects/test_docker_projects.py 25%
370. medium Bandit Probable insecure usage of temp file/directory. /tests/pyfunc/test_spark.py 25%
371. medium Bandit Probable insecure usage of temp file/directory. /tests/pyfunc/test_spark.py 25%
372. medium Bandit Probable insecure usage of temp file/directory. /tests/server/assistant/test_api.py 25%
373. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
374. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
375. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
376. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
377. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
378. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
379. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
380. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
381. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
382. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
383. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
384. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
385. medium Bandit Call to requests without timeout /tests/pyfunc/docker/test_docker_flavors.py 21%
386. medium Bandit Call to requests without timeout /tests/pyfunc/docker/test_docker_flavors.py 21%
387. medium Bandit Call to requests without timeout /tests/pyfunc/docker/conftest.py 21%
388. medium Bandit Call to requests without timeout /tests/helper_functions.py 21%
389. medium Bandit Call to requests without timeout /tests/helper_functions.py 21%
390. medium Bandit Call to requests without timeout /tests/helper_functions.py 21%
391. medium Bandit Call to requests without timeout /tests/helper_functions.py 21%
392. medium Bandit Call to requests without timeout /tests/helper_functions.py 21%
393. medium Bandit Call to requests without timeout /tests/helper_functions.py 21%
394. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
395. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
396. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
397. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
398. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
399. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
400. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
401. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
402. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
403. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
404. medium Bandit Call to requests without timeout /tests/gateway/tools.py 21%
405. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
406. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
407. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
408. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
409. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
410. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
411. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
412. medium Bandit Call to requests without timeout /tests/server/auth/test_auth.py 21%
413. medium Bandit Call to requests without timeout /examples/flower_classifier/score_images_rest.py 21%
414. medium Bandit Call to requests without timeout /examples/transformers/whisper.py 21%
415. medium Bandit Call to requests without timeout /examples/sktime/score_model.py 21%
416. medium Bandit Call to requests without timeout /examples/rest_api/mlflow_tracking_rest_api.py 21%
417. medium Bandit Call to requests without timeout /examples/rest_api/mlflow_tracking_rest_api.py 21%
418. medium Bandit Call to requests without timeout /examples/rest_api/mlflow_tracking_rest_api.py 21%
419. medium Bandit Call to requests without timeout /examples/rest_api/mlflow_tracking_rest_api.py 21%
420. medium Bandit Call to requests without timeout /examples/multistep_workflow/load_raw_data.py 21%
421. medium Bandit Call to requests without timeout /examples/flower_classifier/train.py 21%
422. medium Bandit Call to requests without timeout /tests/demo/test_api_routes.py 21%
423. medium Bandit Call to requests without timeout /docs/api_reference/broken_links.py 21%
424. medium Bandit Call to requests without timeout /dev/update_requirements.py 21%
425. medium Bandit Call to requests without timeout /dev/update_changelog.py 21%
426. medium Bandit Call to requests without timeout /dev/set_matrix.py 21%
427. medium Bandit Call to requests without timeout /dev/check_patch_prs.py 21%
428. medium Bandit Call to requests without timeout /dev/check_patch_prs.py 21%
429. medium Bandit Call to requests without timeout /dev/check_patch_prs.py 21%
430. medium Bandit Call to requests without timeout /tests/conftest.py 21%
431. medium Bandit Call to requests without timeout /tests/demo/test_api_routes.py 21%
432. medium Bandit Call to requests without timeout /tests/demo/test_api_routes.py 21%
433. medium Bandit Call to requests without timeout /tests/demo/test_api_routes.py 21%
434. medium Bandit Call to requests without timeout /tests/demo/test_api_routes.py 21%
435. medium Bandit Call to requests without timeout /tests/demo/test_api_routes.py 21%
436. medium Bandit Call to requests without timeout /tests/demo/test_api_routes.py 21%
437. medium Bandit Call to requests without timeout /mlflow/deployments/openai/__init__.py 21%
438. medium Bandit Call to requests without timeout /tests/demo/test_api_routes.py 21%
439. medium Bandit Call to requests without timeout /mlflow/store/artifact/http_artifact_repo.py 21%
440. medium Bandit Call to requests without timeout /mlflow/pyfunc/scoring_server/client.py 21%
441. medium Bandit Call to requests without timeout /mlflow/pyfunc/scoring_server/client.py 21%
442. medium Bandit Call to requests without timeout /mlflow/pyfunc/scoring_server/client.py 21%
443. medium Bandit Call to requests without timeout /mlflow/projects/utils.py 21%
444. medium Bandit Call to requests without timeout /mlflow/deployments/openai/__init__.py 21%
445. medium Bandit Call to requests without timeout /tests/demo/test_api_routes.py 21%
446. low Semgrep Detected a request using 'http://'. This request will be unencrypted. Use 'https://' instead. /mlflow/webhooks/delivery.py 98%
447. low Semgrep The 'FTP' class sends information unencrypted. Consider using the 'FTP_TLS' class instead. /mlflow/store/artifact/ftp_artifact_repo.py 97%
448. low Semgrep Detected a call to `replaceAll()` in an attempt to HTML escape the string `window.translations[`kind_${t.kind}`]`. Manually sanitizing input through a manually built list can be circumvented in many situations, and it's better to use a well known sanitization library such as `sanitize-html` or `DOMPurify`. /libs/typescript/integrations/openai/docs/assets/main.js 82%
449. low Semgrep Detected a call to `replaceAll()` in an attempt to HTML escape the string `window.translations.folder`. Manually sanitizing input through a manually built list can be circumvented in many situations, and it's better to use a well known sanitization library such as `sanitize-html` or `DOMPurify`. /libs/typescript/integrations/openai/docs/assets/main.js 82%
450. low Semgrep Detected a call to `replaceAll()` in an attempt to HTML escape the string `window.translations[`kind_${c.kind}`]`. Manually sanitizing input through a manually built list can be circumvented in many situations, and it's better to use a well known sanitization library such as `sanitize-html` or `DOMPurify`. /libs/typescript/integrations/openai/docs/assets/main.js 82%
451. low Semgrep Detected string concatenation with a non-literal variable in a util.format / console.log function. If an attacker injects a format specifier in the string, it will forge the log message. Try to use constant values for the format string. /.github/workflows/advice.js 31%
452. low Semgrep Detected string concatenation with a non-literal variable in a util.format / console.log function. If an attacker injects a format specifier in the string, it will forge the log message. Try to use constant values for the format string. /.github/workflows/preview-comment.js 31%
453. low Semgrep Detected string concatenation with a non-literal variable in a util.format / console.log function. If an attacker injects a format specifier in the string, it will forge the log message. Try to use constant values for the format string. /.github/workflows/rerun.js 31%
454. low Semgrep Detected string concatenation with a non-literal variable in a util.format / console.log function. If an attacker injects a format specifier in the string, it will forge the log message. Try to use constant values for the format string. /libs/typescript/core/src/clients/artifacts/databricks.ts 31%
455. low Semgrep Detected string concatenation with a non-literal variable in a util.format / console.log function. If an attacker injects a format specifier in the string, it will forge the log message. Try to use constant values for the format string. /libs/typescript/core/src/clients/artifacts/databricks.ts 31%
456. low Semgrep Detected string concatenation with a non-literal variable in a util.format / console.log function. If an attacker injects a format specifier in the string, it will forge the log message. Try to use constant values for the format string. /libs/typescript/core/src/exporters/mlflow.ts 31%
457. low Semgrep Detected string concatenation with a non-literal variable in a util.format / console.log function. If an attacker injects a format specifier in the string, it will forge the log message. Try to use constant values for the format string. /libs/typescript/core/src/exporters/mlflow.ts 31%
458. low Semgrep Detected string concatenation with a non-literal variable in a util.format / console.log function. If an attacker injects a format specifier in the string, it will forge the log message. Try to use constant values for the format string. /mlflow/server/js/src/telemetry/TelemetryClient.ts 31%
459. low Semgrep Detected a request using 'http://'. This request will be unencrypted, and attackers could listen into traffic on the network and be able to obtain sensitive information. Use 'https://' instead. /examples/sktime/score_model.py 31%
460. low Semgrep Detected a request using 'http://'. This request will be unencrypted, and attackers could listen into traffic on the network and be able to obtain sensitive information. Use 'https://' instead. /examples/flower_classifier/train.py 31%
461. low Semgrep When running containers in Kubernetes, it's important to ensure that they are properly secured to prevent privilege escalation attacks. One potential vulnerability is when a container is allowed to run applications as the root user, which could allow an attacker to gain access to sensitive resources. To mitigate this risk, it's recommended to add a `securityContext` to the container, with the parameter `runAsNonRoot` set to `true`. This will ensure that the container runs as a non-root user, limiting the damage that could be caused by any potential attacks. By adding a `securityContext` to the container in your Kubernetes pod, you can help to ensure that your containerized applications are more secure and less vulnerable to privilege escalation attacks. /examples/docker/kubernetes_job_template.yaml 28%
462. low Dependency checker Loose version constraint: 'opentelemetry-api<3,>=1.9.0' — attacker could push malicious update pyproject.toml 4%
463. low Dependency checker Loose version constraint: 'python-dotenv<2,>=0.19.0' — attacker could push malicious update pyproject.toml 4%
464. low Dependency checker Loose version constraint: 'protobuf<8,>=3.12.0' — attacker could push malicious update pyproject.toml 2%
465. low Dependency checker Loose version constraint: 'azure-identity>=1.6.1' — attacker could push malicious update pyproject.toml 2%
466. low Dependency checker Loose version constraint: 'aiohttp<4,>=3.7.0' — attacker could push malicious update pyproject.toml 2%
467. low Dependency checker Loose version constraint: 'cachetools<8,>=5.0.0' — attacker could push malicious update pyproject.toml 2%
468. low Dependency checker Loose version constraint: 'click<9,>=7.0' — attacker could push malicious update pyproject.toml 2%
469. low Dependency checker Loose version constraint: 'cryptography<51,>=43.0.0' — attacker could push malicious update pyproject.toml 2%
470. low Dependency checker Loose version constraint: 'databricks-sdk<1,>=0.20.0' — attacker could push malicious update pyproject.toml 2%
471. low Dependency checker Loose version constraint: 'docker<8,>=4.0.0' — attacker could push malicious update pyproject.toml 2%
472. low Dependency checker Loose version constraint: 'gitpython<4,>=3.1.9' — attacker could push malicious update pyproject.toml 2%
473. low Dependency checker Loose version constraint: 'huey<4,>=2.5.4' — attacker could push malicious update pyproject.toml 2%
474. low Dependency checker Loose version constraint: 'importlib_metadata<10,>=3.7.0,!=4.7.0' — attacker could push malicious update pyproject.toml 2%
475. low Dependency checker Loose version constraint: 'opentelemetry-proto<3,>=1.9.0' — attacker could push malicious update pyproject.toml 2%
476. low Dependency checker Loose version constraint: 'opentelemetry-sdk<3,>=1.9.0' — attacker could push malicious update pyproject.toml 2%
477. low Dependency checker Loose version constraint: 'pyarrow<26,>=4.0.0' — attacker could push malicious update pyproject.toml 2%
478. low Dependency checker Loose version constraint: 'pydantic<3,>=2.0.0' — attacker could push malicious update pyproject.toml 2%
479. low Dependency checker Loose version constraint: 'pyyaml<7,>=5.1' — attacker could push malicious update pyproject.toml 2%
480. low Dependency checker Loose version constraint: 'sqlalchemy<3,>=1.4.0' — attacker could push malicious update pyproject.toml 2%
481. low Dependency checker Loose version constraint: 'requests<3,>=2.17.3' — attacker could push malicious update pyproject.toml 2%
482. low Dependency checker Loose version constraint: 'langchain>=1.0.0,<=1.3.14' — attacker could push malicious update pyproject.toml 2%
483. low Dependency checker Loose version constraint: 'azure-storage-blob>=12' — attacker could push malicious update pyproject.toml 2%
484. low Dependency checker Loose version constraint: 'fastmcp<4,>=2.7.0' — attacker could push malicious update pyproject.toml 2%
485. low Dependency checker Loose version constraint: 'slowapi<1,>=0.1.9' — attacker could push malicious update pyproject.toml 2%
486. low Dependency checker Loose version constraint: 'boto3<2,>=1.28.56' — attacker could push malicious update pyproject.toml 2%
487. low Dependency checker Loose version constraint: 'slowapi<1,>=0.1.9' — attacker could push malicious update pyproject.toml 2%
488. low Dependency checker Loose version constraint: 'databricks-agents>=1.2.0,<2.0' — attacker could push malicious update pyproject.toml 2%
489. low Dependency checker Loose version constraint: 'google-cloud-storage>=1.30.0' — attacker could push malicious update pyproject.toml 2%
490. low Dependency checker Loose version constraint: 'azureml-core>=1.2.0' — attacker could push malicious update pyproject.toml 2%
491. low Dependency checker Loose version constraint: 'google-cloud-storage>=1.30.0' — attacker could push malicious update pyproject.toml 2%
492. low Dependency checker Loose version constraint: 'typing-extensions<5,>=4.0.0' — attacker could push malicious update pyproject.toml 2%
493. low Dependency checker Loose version constraint: 'sqlparse<1,>=0.4.0' — attacker could push malicious update pyproject.toml 2%
494. low Dependency checker Loose version constraint: 'boto3<2,>=1.28.56' — attacker could push malicious update pyproject.toml 2%
495. low YARA YARA rule matched: detect_downloader — Downloads a remote resource - common and low-signal alone; see detect_download_and_execute for the composite version /mlflow/pyfunc/scoring_server/client.py 0%
496. low YARA YARA rule matched: detect_downloader — Downloads a remote resource - common and low-signal alone; see detect_download_and_execute for the composite version /dev/flavors/src/flavors/_update.py 0%
497. low YARA YARA rule matched: detect_downloader — Downloads a remote resource - common and low-signal alone; see detect_download_and_execute for the composite version /dev/flavors/src/flavors/_matrix.py 0%
498. low YARA YARA rule matched: detect_downloader — Downloads a remote resource - common and low-signal alone; see detect_download_and_execute for the composite version /dev/check_whitespace_only.py 0%
499. low YARA YARA rule matched: detect_downloader — Downloads a remote resource - common and low-signal alone; see detect_download_and_execute for the composite version /dev/generate_protos.py 0%
500. low YARA YARA rule matched: detect_downloader — Downloads a remote resource - common and low-signal alone; see detect_download_and_execute for the composite version /dev/run_dev_server.py 0%
501. low YARA YARA rule matched: detect_downloader — Downloads a remote resource - common and low-signal alone; see detect_download_and_execute for the composite version /dev/update_model_catalog.py 0%
502. low YARA YARA rule matched: detect_downloader — Downloads a remote resource - common and low-signal alone; see detect_download_and_execute for the composite version /dev/remove_experimental_decorators.py 0%
503. low YARA YARA rule matched: detect_downloader — Downloads a remote resource - common and low-signal alone; see detect_download_and_execute for the composite version /dev/update_requirements.py 0%
504. low YARA YARA rule matched: detect_downloader — Downloads a remote resource - common and low-signal alone; see detect_download_and_execute for the composite version /dev/check_patch_prs.py 0%
505. low YARA YARA rule matched: detect_downloader — Downloads a remote resource - common and low-signal alone; see detect_download_and_execute for the composite version /.github/actions/setup-pyenv/action.yml 0%
506. low YARA YARA rule matched: detect_downloader — Downloads a remote resource - common and low-signal alone; see detect_download_and_execute for the composite version /dev/benchmarks/gateway/run.py 0%
507. low YARA YARA rule matched: detect_downloader — Downloads a remote resource - common and low-signal alone; see detect_download_and_execute for the composite version /dev/dev-env-setup.sh 0%
508. low YARA YARA rule matched: detect_downloader — Downloads a remote resource - common and low-signal alone; see detect_download_and_execute for the composite version /mlflow/deployments/openai/__init__.py 0%
509. low YARA YARA rule matched: detect_downloader — Downloads a remote resource - common and low-signal alone; see detect_download_and_execute for the composite version /mlflow/genai/mcp_servers.py 0%
510. low YARA YARA rule matched: detect_downloader — Downloads a remote resource - common and low-signal alone; see detect_download_and_execute for the composite version /mlflow/transformers/__init__.py 0%
511. low YARA YARA rule matched: detect_downloader — Downloads a remote resource - common and low-signal alone; see detect_download_and_execute for the composite version /mlflow/assistant/providers/ollama.py 0%
512. low YARA YARA rule matched: detect_downloader — Downloads a remote resource - common and low-signal alone; see detect_download_and_execute for the composite version /mlflow/tracking/context/jupyter_notebook_context.py 0%
513. low YARA YARA rule matched: detect_downloader — Downloads a remote resource - common and low-signal alone; see detect_download_and_execute for the composite version /mlflow/telemetry/client.py 0%
514. low YARA YARA rule matched: detect_downloader — Downloads a remote resource - common and low-signal alone; see detect_download_and_execute for the composite version /mlflow/telemetry/utils.py 0%
515. low YARA YARA rule matched: detect_downloader — Downloads a remote resource - common and low-signal alone; see detect_download_and_execute for the composite version /mlflow/projects/utils.py 0%
516. low YARA YARA rule matched: detect_downloader — Downloads a remote resource - common and low-signal alone; see detect_download_and_execute for the composite version /mlflow/utils/providers.py 0%
517. low YARA YARA rule matched: detect_downloader — Downloads a remote resource - common and low-signal alone; see detect_download_and_execute for the composite version /mlflow/utils/file_utils.py 0%
518. low YARA YARA rule matched: detect_downloader — Downloads a remote resource - common and low-signal alone; see detect_download_and_execute for the composite version /mlflow/tracing/fluent.py 0%
519. low YARA YARA rule matched: detect_downloader — Downloads a remote resource - common and low-signal alone; see detect_download_and_execute for the composite version /bin/install.py 0%
520. low YARA YARA rule matched: detect_downloader — Downloads a remote resource - common and low-signal alone; see detect_download_and_execute for the composite version /.claude/skills/src/skills/github/uploads.py 0%