asamassekou10 / ship-safe

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

1. high Semgrep Detected calls to child_process from a function argument `req`. 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. /benchmarks/corpus/flow/cmd-hop.guarded.js:7 99%
2. high Semgrep Detected calls to child_process from a function argument `req`. 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. /benchmarks/corpus/flow/cmd-hop.tainted.js:6 99%
3. high Semgrep Detected calls to child_process from a function argument `targetPath`. 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. /cli/commands/deps.js:118 99%
4. high Semgrep Detected calls to child_process from a function argument `pm`. 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. /cli/commands/deps.js:201 99%
5. high GuardDog Detects destructive operations (recursive deletion, wiping) [threat-filesystem-destruction] /cli/commands/guard.js:320 99%
6. high Semgrep Unencrypted request over HTTP detected. /benchmarks/corpus/literal/loopback.js:5 99%
7. high Semgrep Untrusted input might be injected into a command executed by the application, which can lead to a command injection vulnerability. An attacker can execute arbitrary commands, potentially gaining complete control of the system. To prevent this vulnerability, avoid executing OS commands with user input. If this is unavoidable, validate and sanitize the user input, and use safe methods for executing the commands. For more information, see [Command injection prevention for JavaScript ] (https://semgrep.dev/docs/cheat-sheets/javascript-command-injection/). /benchmarks/corpus/flow/cmd-hop.guarded.js:7 99%
8. high Semgrep Untrusted input might be injected into a command executed by the application, which can lead to a command injection vulnerability. An attacker can execute arbitrary commands, potentially gaining complete control of the system. To prevent this vulnerability, avoid executing OS commands with user input. If this is unavoidable, validate and sanitize the user input, and use safe methods for executing the commands. For more information, see [Command injection prevention for JavaScript ] (https://semgrep.dev/docs/cheat-sheets/javascript-command-injection/). /benchmarks/corpus/flow/cmd-hop.tainted.js:6 99%
9. high GuardDog Detects keylogging and input capture patterns [threat-runtime-keylogging] /cli/agents/supply-chain-agent.js:34 94%
10. high GuardDog Detects keylogging and input capture patterns [threat-runtime-keylogging] /cli/agents/hermes-security-agent.js:1436 94%
11. high GuardDog Detects keylogging and input capture patterns [threat-runtime-keylogging] /cli/agents/agentic-security-agent.js:120 94%
12. high GuardDog Detects steganography decode followed by code execution [threat-runtime-obfuscation-steganography] /cli/utils/patterns.js:1047 91%
13. high Semgrep Avoiding SQL string concatenation: untrusted input concatenated with raw SQL query can result in SQL Injection. In order to execute raw query safely, prepared statement should be used. SQLAlchemy provides TextualSQL to easily used prepared statement with named parameters. For complex SQL composition, use SQL Expression Language or Schema Definition Language. In most cases, SQLAlchemy ORM will be a better option. /benchmarks/corpus/flow-py-guarded/guarded_dao.py:6 53%
14. high Semgrep Avoiding SQL string concatenation: untrusted input concatenated with raw SQL query can result in SQL Injection. In order to execute raw query safely, prepared statement should be used. SQLAlchemy provides TextualSQL to easily used prepared statement with named parameters. For complex SQL composition, use SQL Expression Language or Schema Definition Language. In most cases, SQLAlchemy ORM will be a better option. /benchmarks/corpus/flow-py/tainted_dao.py:6 53%
15. 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 /benchmarks/corpus/safe/model-load.py:2 51%
16. high Semgrep Insecure WebSocket Detected. WebSocket Secure (wss) should be used for all WebSocket connections. /CHANGELOG.md:1440 51%
17. high Semgrep Insecure WebSocket Detected. WebSocket Secure (wss) should be used for all WebSocket connections. /cli/agents/agent-config-scanner.js:474 51%
18. high Semgrep Insecure WebSocket Detected. WebSocket Secure (wss) should be used for all WebSocket connections. /cli/agents/agent-config-scanner.js:684 51%
19. high Semgrep Insecure WebSocket Detected. WebSocket Secure (wss) should be used for all WebSocket connections. /cli/commands/openclaw.js:218 51%
20. high Semgrep Insecure WebSocket Detected. WebSocket Secure (wss) should be used for all WebSocket connections. /cli/agents/agent-config-scanner.js:465 50%
21. high Semgrep Insecure WebSocket Detected. WebSocket Secure (wss) should be used for all WebSocket connections. /cli/agents/agent-config-scanner.js:587 50%
22. high Semgrep Insecure WebSocket Detected. WebSocket Secure (wss) should be used for all WebSocket connections. /cli/commands/openclaw.js:219 50%
23. high Semgrep Insecure WebSocket Detected. WebSocket Secure (wss) should be used for all WebSocket connections. /cli/commands/openclaw.js:220 50%
24. high Semgrep Insecure WebSocket Detected. WebSocket Secure (wss) should be used for all WebSocket connections. /cli/commands/openclaw.js:304 50%
25. high Semgrep Insecure WebSocket Detected. WebSocket Secure (wss) should be used for all WebSocket connections. /cli/commands/openclaw.js:217 50%
26. high YARA YARA rule matched: detect_base64_exec — Encoded payload decoded and then executed /cli/agents/config-auditor.js 3%
27. high YARA YARA rule matched: detect_base64_exec — Encoded payload decoded and then executed /cli/agents/roblox-security-agent.js 3%
28. high YARA YARA rule matched: detect_base64_exec — Encoded payload decoded and then executed /cli/utils/jwt.js 3%
29. high YARA YARA rule matched: detect_base64_exec — Encoded payload decoded and then executed /cli/utils/patterns.js 3%
30. high YARA YARA rule matched: detect_base64_exec — Encoded payload decoded and then executed /cli/agents/model-scan-agent.js 3%
31. high YARA YARA rule matched: detect_download_and_execute — Downloads a remote resource AND executes it - the actually dangerous combination, not just downloading alone /cli/agents/trust-boundary-agent.js 1%
32. high YARA YARA rule matched: detect_download_and_execute — Downloads a remote resource AND executes it - the actually dangerous combination, not just downloading alone /CHANGELOG.md 1%
33. high YARA YARA rule matched: detect_download_and_execute — Downloads a remote resource AND executes it - the actually dangerous combination, not just downloading alone /cli/agents/config-auditor.js 1%
34. high YARA YARA rule matched: detect_download_and_execute — Downloads a remote resource AND executes it - the actually dangerous combination, not just downloading alone /cli/agents/cicd-scanner.js 1%
35. high YARA YARA rule matched: detect_download_and_execute — Downloads a remote resource AND executes it - the actually dangerous combination, not just downloading alone /cli/agents/agent-config-scanner.js 1%
36. high YARA YARA rule matched: detect_download_and_execute — Downloads a remote resource AND executes it - the actually dangerous combination, not just downloading alone /cli/hooks/patterns.js 1%
37. high YARA YARA rule matched: detect_download_and_execute — Downloads a remote resource AND executes it - the actually dangerous combination, not just downloading alone /cli/agents/install-guard-agent.js 1%
38. high YARA YARA rule matched: detect_download_and_execute — Downloads a remote resource AND executes it - the actually dangerous combination, not just downloading alone /cli/commands/scan-skill.js 1%
39. high YARA YARA rule matched: detect_download_and_execute — Downloads a remote resource AND executes it - the actually dangerous combination, not just downloading alone /benchmarks/false-positives/README.md 1%
40. 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 /cli/agents/roblox-security-agent.js 1%
41. high YARA YARA rule matched: detect_persistence_mechanism — Modifies a startup/scheduling location - legitimate application code essentially never does this /vps/setup.sh 0%
42. medium Semgrep RegExp() called with a `content` 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. /cli/agents/hermes-security-agent.js:1776 100%
43. medium Semgrep RegExp() called with a `regex` 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. /cli/agents/mcp-security-agent.js:943 100%
44. medium Semgrep RegExp() called with a `binding` 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. /cli/agents/mcp-security-agent.js:866 100%
45. medium Semgrep RegExp() called with a `content` 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. /cli/agents/hermes-security-agent.js:1508 100%
46. 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. /cli/agents/hermes-security-agent.js:1686 100%
47. medium Semgrep RegExp() called with a `code` 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. /cli/agents/mcp-security-agent.js:809 100%
48. medium Semgrep RegExp() called with a `scope` 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. /cli/agents/mcp-security-agent.js:809 100%
49. medium Semgrep RegExp() called with a `primary` 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. /cli/agents/install-guard-agent.js:266 100%
50. medium Semgrep RegExp() called with a `credentialName` 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. /cli/agents/hermes-security-agent.js:1776 100%
51. medium Semgrep RegExp() called with a `p` 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. /cli/commands/scan.js:74 100%
52. medium Semgrep RegExp() called with a `envVars` 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. /cli/commands/remediate.js:387 100%
53. medium Semgrep RegExp() called with a `scope` 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. /cli/agents/mcp-security-agent.js:890 100%
54. medium Semgrep RegExp() called with a `code` 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. /cli/agents/mcp-security-agent.js:890 100%
55. medium Semgrep RegExp() called with a `lines` 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. /cli/agents/dataflow-investigator.js:641 100%
56. medium Semgrep RegExp() called with a `providerName` 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. /cli/providers/llm-provider.js:745 100%
57. medium Semgrep RegExp() called with a `context` 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. /cli/agents/supabase-rls-agent.js:122 100%
58. medium Semgrep RegExp() called with a `call` 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. /cli/agents/model-scan-agent.js:283 100%
59. medium Semgrep RegExp() called with a `call` 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. /cli/agents/model-scan-agent.js:242 100%
60. medium Semgrep RegExp() called with a `scope` 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. /cli/agents/mcp-security-agent.js:923 100%
61. medium Semgrep RegExp() called with a `code` 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. /cli/agents/mcp-security-agent.js:923 100%
62. medium Semgrep RegExp() called with a `scope` 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. /cli/agents/mcp-security-agent.js:922 100%
63. medium Semgrep RegExp() called with a `code` 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. /cli/agents/mcp-security-agent.js:922 100%
64. medium Semgrep RegExp() called with a `credentialName` 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. /cli/agents/hermes-security-agent.js:1822 100%
65. medium Semgrep RegExp() called with a `functionName` 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. /cli/agents/hermes-security-agent.js:1811 100%
66. medium Semgrep RegExp() called with a `credentialName` 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. /cli/agents/hermes-security-agent.js:1765 100%
67. medium Semgrep RegExp() called with a `propertyName` 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. /cli/agents/hermes-security-agent.js:1660 100%
68. medium Semgrep RegExp() called with a `sectionName` 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. /cli/agents/hermes-security-agent.js:1653 100%
69. medium Semgrep RegExp() called with a `lang` 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. /cli/agents/dataflow-investigator.js:811 100%
70. medium Semgrep RegExp() called with a `lang` 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. /cli/agents/dataflow-investigator.js:698 100%
71. medium Semgrep RegExp() called with a `extra` 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. /cli/agents/dataflow-investigator.js:698 100%
72. medium Semgrep RegExp() called with a `lang` 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. /cli/agents/dataflow-investigator.js:665 100%
73. medium Semgrep RegExp() called with a `extra` 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. /cli/agents/dataflow-investigator.js:665 100%
74. medium Semgrep RegExp() called with a `moduleName` 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. /cli/agents/base-agent.js:625 100%
75. medium Semgrep RegExp() called with a `applicationName` 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. /cli/agents/hermes-security-agent.js:739 100%
76. medium Semgrep `l.replace` method will only replace the first occurrence when used with a string argument ('*'). If this method is used for escaping of dangerous data then there is a possibility for a bypass. Try to use sanitization library instead or use a Regex with a global flag. /cli/hooks/pre-tool-use.js:157 99%
77. medium Semgrep Running flask app with host 0.0.0.0 could expose the server publicly. /vps/agent-wrapper.py:355 99%
78. medium GuardDog Detects advanced API call obfuscation using introspection and reflection techniques [threat-runtime-obfuscation-api] /cli/commands/benchmark.js:267 99%
79. medium GuardDog Detects URLs to suspicious domains often used for exfiltration or C2 [threat-network-exfiltration] /cli/commands/openclaw.js:349 98%
80. medium GuardDog Detects URLs to suspicious domains often used for exfiltration or C2 [threat-network-exfiltration] /cli/commands/guard.js:374 98%
81. medium GuardDog Detects URLs to suspicious domains often used for exfiltration or C2 [threat-network-exfiltration] /cli/providers/llm-provider.js:450 98%
82. medium GuardDog Detects URLs to URL shorteners, file sharing, and suspicious services [threat-network-outbound-shady-links] /cli/commands/openclaw.js:349 97%
83. medium GuardDog Detects URLs to URL shorteners, file sharing, and suspicious services [threat-network-outbound-shady-links] /cli/commands/guard.js:374 97%
84. medium GuardDog Detects URLs to URL shorteners, file sharing, and suspicious services [threat-network-outbound-shady-links] /cli/commands/guard.js:374 97%
85. medium Semgrep Skill contains a directive to activate an "unrestricted", "debug", "developer", or "god" mode that disables the agent's built-in safety controls. These phrases are a hallmark of prompt injection and jailbreak attacks documented in the ClawHavoc malicious skill campaign. The instruction attempts to convince the agent to bypass content policies and perform unauthorized actions. Review the full skill context; security research skills may reference these phrases as examples. /claude-code-plugin/skills/ship-safe-fix/SKILL.md:27 97%
86. medium Semgrep This .npmrc does not set a minimum release age or sets it too low. Newly published packages can be malicious or unstable. Add `min-release-age = 7` to wait 7 days before resolving newly published package versions. Added in: v11.10 Reference: https://github.blog/changelog/2026-02-18-npm-bulk-trusted-publishing-config-and-script-security-now-generally-available/ /.npmrc:1 97%
87. medium GuardDog Detects LOLBAS usage in install hooks (execution and network tools) [threat-process-hooks] /benchmarks/corpus/safe/package.json:4 87%
88. medium Semgrep RegExp() called with a `name` 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. /cli/agents/dataflow-investigator.js:851 76%
89. medium Semgrep RegExp() called with a `name` 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. /cli/agents/dataflow-investigator.js:903 76%
90. medium Semgrep RegExp() called with a `name` 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. /cli/agents/dataflow-investigator.js:899 76%
91. medium Semgrep RegExp() called with a `name` 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. /cli/agents/dataflow-investigator.js:896 76%
92. medium Semgrep RegExp() called with a `name` 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. /cli/agents/dataflow-investigator.js:890 76%
93. medium Semgrep RegExp() called with a `name` 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. /cli/agents/dataflow-investigator.js:886 76%
94. medium Semgrep RegExp() called with a `name` 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. /cli/agents/dataflow-investigator.js:881 76%
95. medium Semgrep RegExp() called with a `name` 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. /cli/agents/dataflow-investigator.js:709 76%
96. medium Semgrep RegExp() called with a `name` 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. /cli/agents/dataflow-investigator.js:682 76%
97. medium Semgrep RegExp() called with a `name` 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. /cli/agents/mcp-security-agent.js:330 76%
98. medium Semgrep RegExp() called with a `pattern` 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. /cli/commands/scan.js:269 69%
99. medium Semgrep RegExp() called with a `pattern` 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. /cli/commands/score.js:337 69%
100. medium Semgrep RegExp() called with a `pattern` 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. /scripts/hermes-baseline-drift.mjs:67 69%
101. medium Semgrep Detected possible formatted SQL query. Use parameterized queries instead. /benchmarks/corpus/flow-py-guarded/guarded_dao.py:6 52%
102. medium Semgrep Detected possible formatted SQL query. Use parameterized queries instead. /benchmarks/corpus/flow-py/tainted_dao.py:6 52%
103. medium Semgrep Checks for any usage of http servers instead of https servers. Encourages the usage of https protocol instead of http, which does not have TLS and is therefore unencrypted. Using http can lead to man-in-the-middle attacks in which the attacker is able to read sensitive information. /vps/orchestrator/index.js:233 51%
104. medium Semgrep Detected the use of eval(). eval() 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. /benchmarks/corpus/vulnerable/llm-output.js:1 50%
105. medium Bandit Use of unsafe PyTorch load /benchmarks/corpus/vulnerable/model-load.py:2 49%
106. medium Bandit Possible SQL injection vector through string-based query construction. /benchmarks/corpus/flow-py-guarded/guarded_dao.py:5 46%
107. medium Bandit Possible SQL injection vector through string-based query construction. /benchmarks/corpus/flow-py/tainted_dao.py:5 46%
108. medium Bandit Possible binding to all interfaces. /vps/agent-wrapper.py:355 37%
109. 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. /cli/agents/workspace-trust-agent.js:490 37%
110. 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. /cli/commands/agent-fix.js:259 37%
111. 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. /cli/agents/workspace-trust-agent.js:490 37%
112. 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. /cli/agents/workspace-trust-agent.js:651 37%
113. 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. /cli/agents/workspace-trust-agent.js:719 37%
114. 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. /cli/agents/workspace-trust-agent.js:765 37%
115. 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. /cli/agents/workspace-trust-agent.js:768 37%
116. 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. /cli/agents/workspace-trust-agent.js:769 37%
117. 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. /cli/bin/ship-safe.js:387 37%
118. 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. /cli/bin/ship-safe.js:433 37%
119. 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. /cli/commands/abom.js:19 37%
120. 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. /cli/commands/agent-fix.js:67 37%
121. 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. /cli/commands/agent-fix.js:156 37%
122. 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. /cli/commands/agent-fix.js:156 37%
123. 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. /cli/agents/swarm-orchestrator.js:191 37%
124. 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. /cli/agents/workspace-trust-agent.js:486 37%
125. 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. /cli/agents/workspace-trust-agent.js:441 37%
126. 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. /cli/agents/workspace-trust-agent.js:441 37%
127. 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. /cli/agents/workspace-trust-agent.js:410 37%
128. 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. /cli/agents/workspace-trust-agent.js:410 37%
129. 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. /cli/agents/workspace-trust-agent.js:405 37%
130. 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. /cli/agents/workspace-trust-agent.js:369 37%
131. 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. /cli/agents/workspace-trust-agent.js:369 37%
132. 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. /cli/agents/workspace-trust-agent.js:213 37%
133. 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. /cli/agents/workspace-trust-agent.js:213 37%
134. 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. /cli/agents/workspace-trust-agent.js:199 37%
135. 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. /cli/agents/workspace-trust-agent.js:156 37%
136. 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. /cli/agents/trust-boundary-agent.js:162 37%
137. 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. /cli/agents/trust-boundary-agent.js:95 37%
138. 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. /cli/agents/trust-boundary-agent.js:95 37%
139. 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. /cli/commands/audit.js:153 37%
140. 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. /cli/commands/baseline.js:105 37%
141. 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. /cli/commands/baseline.js:92 37%
142. 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. /cli/commands/autofix.js:354 37%
143. 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. /cli/commands/autofix.js:354 37%
144. 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. /cli/commands/autofix.js:189 37%
145. 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. /cli/commands/autofix.js:189 37%
146. 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. /cli/commands/autofix.js:163 37%
147. 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. /cli/commands/autofix.js:163 37%
148. 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. /cli/commands/autofix.js:89 37%
149. 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. /cli/commands/autofix.js:89 37%
150. 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. /cli/commands/autofix.js:52 37%
151. 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. /cli/commands/audit.js:1029 37%
152. 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. /cli/commands/audit.js:1029 37%
153. 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. /cli/commands/audit.js:610 37%
154. 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. /cli/commands/agent-fix.js:259 37%
155. 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. /cli/agents/gpt-red-agent.js:241 37%
156. 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. /cli/commands/audit.js:89 37%
157. 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. /cli/commands/aibom.js:21 37%
158. 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. /cli/commands/agent.js:52 37%
159. 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. /cli/commands/agent-fix.js:746 37%
160. 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. /cli/commands/agent-fix.js:745 37%
161. 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. /cli/commands/agent-fix.js:737 37%
162. 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. /cli/commands/agent-fix.js:736 37%
163. 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. /cli/commands/agent-fix.js:670 37%
164. 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. /cli/commands/agent-fix.js:670 37%
165. 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. /cli/commands/agent-fix.js:516 37%
166. 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. /cli/commands/agent-fix.js:516 37%
167. 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. /cli/commands/agent-fix.js:381 37%
168. 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. /cli/commands/agent-fix.js:381 37%
169. 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. /cli/agents/install-guard-agent.js:242 37%
170. 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. /cli/agents/clickfix-agent.js:96 37%
171. 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. /cli/agents/dataflow-investigator.js:262 37%
172. 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. /cli/agents/dataflow-investigator.js:262 37%
173. 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. /cli/agents/git-history-scanner.js:99 37%
174. 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. /cli/agents/git-history-scanner.js:99 37%
175. 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. /cli/agents/install-guard-agent.js:75 37%
176. 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. /cli/agents/install-guard-agent.js:150 37%
177. 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. /cli/agents/install-guard-agent.js:242 37%
178. 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. /cli/agents/aibom-generator.js:194 37%
179. 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. /cli/agents/install-guard-agent.js:243 37%
180. 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. /cli/agents/install-guard-agent.js:243 37%
181. 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. /cli/agents/legal-risk-agent.js:168 37%
182. 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. /cli/agents/legal-risk-agent.js:208 37%
183. 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. /cli/agents/legal-risk-agent.js:242 37%
184. 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. /cli/agents/legal-risk-agent.js:272 37%
185. 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. /cli/agents/orchestrator.js:97 37%
186. 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. /cli/agents/supply-chain-agent.js:667 37%
187. 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. /cli/agents/aibom-generator.js:183 37%
188. 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. /cli/agents/aibom-generator.js:121 37%
189. 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. /cli/agents/aibom-generator.js:105 37%
190. 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. /cli/agents/aibom-generator.js:83 37%
191. 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. /cli/agents/agentic-supply-chain-agent.js:276 37%
192. 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. /cli/agents/agentic-supply-chain-agent.js:270 37%
193. 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. /cli/agents/agentic-supply-chain-agent.js:256 37%
194. 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. /cli/agents/agent-config-scanner.js:405 37%
195. 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. /cli/agents/agent-config-scanner.js:398 37%
196. 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. /cli/agents/agent-config-scanner.js:367 37%
197. 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. /cli/agents/agent-config-scanner.js:353 37%
198. 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. /cli/agents/abom-generator.js:208 37%
199. 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. /cli/agents/abom-generator.js:116 37%
200. 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. /cli/agents/abom-generator.js:75 37%
201. 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. /cli/agents/abom-generator.js:49 37%
202. 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. /cli/agents/sbom-generator.js:23 37%
203. 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. /cli/agents/swarm-orchestrator.js:191 37%
204. 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. /cli/agents/supply-chain-agent.js:667 37%
205. 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. /cli/agents/supply-chain-agent.js:599 37%
206. 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. /cli/agents/supply-chain-agent.js:589 37%
207. 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. /cli/agents/supply-chain-agent.js:568 37%
208. 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. /cli/agents/supply-chain-agent.js:561 37%
209. 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. /cli/agents/supply-chain-agent.js:494 37%
210. 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. /cli/agents/supply-chain-agent.js:334 37%
211. 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. /cli/agents/supply-chain-agent.js:333 37%
212. 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. /cli/agents/supply-chain-agent.js:333 37%
213. 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. /cli/agents/supply-chain-agent.js:298 37%
214. 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. /cli/agents/supply-chain-agent.js:278 37%
215. 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. /cli/agents/supply-chain-agent.js:198 37%
216. 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. /cli/agents/supply-chain-agent.js:197 37%
217. 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. /cli/agents/supply-chain-agent.js:196 37%
218. 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. /cli/agents/stateful-watcher.js:207 37%
219. 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. /cli/agents/recon-agent.js:145 37%
220. 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. /cli/agents/sbom-generator.js:42 37%
221. 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. /cli/agents/sbom-generator.js:64 37%
222. 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. /cli/agents/sbom-generator.js:88 37%
223. 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. /cli/agents/sbom-generator.js:188 37%
224. 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. /cli/agents/sbom-generator.js:210 37%
225. 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. /cli/agents/sbom-generator.js:230 37%
226. 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. /cli/agents/scoring-engine.js:292 37%
227. 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. /cli/agents/slopsquat-agent.js:142 37%
228. 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. /cli/agents/slopsquat-agent.js:142 37%
229. 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. /cli/agents/slopsquat-agent.js:158 37%
230. 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. /cli/agents/slopsquat-agent.js:159 37%
231. 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. /cli/agents/slopsquat-agent.js:164 37%
232. 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. /cli/agents/supply-chain-agent.js:81 37%
233. 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. /cli/agents/sbom-generator.js:231 37%
234. low Bandit Consider possible security implications associated with the subprocess module. /vps/agent-wrapper.py:18 13%
235. low Dependency checker Loose version constraint: 'write-file-atomic^7.0.0' — attacker could push malicious update package.json 8%
236. low Bandit subprocess call - check for execution of untrusted input. /vps/agent-wrapper.py:205 3%
237. low Dependency checker Loose version constraint: '@eslint/js^10.0.1' — attacker could push malicious update package.json 2%
238. low Dependency checker Loose version constraint: 'chalk^5.3.0' — attacker could push malicious update package.json 2%
239. low Dependency checker Loose version constraint: 'commander^12.1.0' — attacker could push malicious update package.json 2%
240. low Dependency checker Loose version constraint: 'fast-glob^3.3.3' — attacker could push malicious update package.json 2%
241. low Dependency checker Loose version constraint: 'ora^8.0.1' — attacker could push malicious update package.json 2%
242. low Dependency checker Loose version constraint: 'eslint^10.3.0' — attacker could push malicious update package.json 2%
243. low Dependency checker Loose version constraint: 'globals^17.6.0' — attacker could push malicious update package.json 2%
244. 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 /cli/agents/cicd-scanner.js 0%
245. 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 /cli/agents/gpt-red-agent.js 0%
246. 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 /cli/hooks/patterns.js 0%

No findings match these filters. Clear filters