Scan report

theagentrouter / agent-router

View on GitHub (opens in a new tab)
Go
2192 stars
Scanned 07 Oct 2026, 10:10

Report Rescan

Vulnerability Medium

Could an attacker exploit mistakes in this code?

74 risk score

Real issues worth reviewing before you rely on this code.

High: 6
Medium: 17
Low: 0

Sources: Bandit, Semgrep, pip-audit

Malicious pattern Low

Does this code look like it is trying to cause harm?

3 risk score

Minor issues. Worth a glance, unlikely to be urgent.

High: 9
Medium: 0
Low: 57

Sources: YARA, ClamAV, GuardDog, dependency checker

Findings overview

89 total findings

Likely real: 11
Uncertain: 15
Likely noise: 63

The risk classifier rates every finding for how likely it is to be a real issue. Likely noise still counts, just much less.

What we found, in plain English

This repository has a medium vulnerability score of 74, which means there are several insecure coding patterns that an attacker could exploit to break into your system. The most serious issues involve gRPC connections that lack encryption and secrets being passed to workflows without proper restrictions, allowing attackers to tamper with data or steal credentials. While some findings suggest the code might be malicious, many of these are actually common mistakes in Go development rather than intentional attacks, such as using variable interpolation or writing directly to HTTP response handlers. The low score for malicious patterns indicates that the code does not appear to be intentionally harmful, but it still requires attention to fix the security gaps before deployment.

Written by a local language model from the findings below. The risk scores come from the classifier, not from this summary.

Detections by engine

YARA 63

Malware signature rules · Malicious pattern
Semgrep 23

Pattern-based code analysis · Vulnerability
GuardDog 3

Supply-chain attack heuristics · Malicious pattern

Score over time

Overall score each time this repository was scanned.

Findings

Highest severity first. Select a finding to see the code and what it means.

Engine
Semgrep · Pattern-based code analysis

Counts towards
Vulnerability

File
/cmd/extproc/mainlib/admin.go line 34

Likely real
Yes, 99% confidence

Found an insecure gRPC connection using 'insecure.NewCredentials()'. This creates a connection without encryption to a gRPC server. A malicious attacker could tamper with the gRPC message, which could compromise the machine. Instead, establish a secure connection with an SSL certificate using the 'grpc.WithTransportCredentials()' function. You can create a create credentials using a 'tls.Config{}' struct with 'credentials.NewTLS()'. The final fix looks like this: 'grpc.WithTransportCredentials(credentials.NewTLS(<config>))'.
```
opts = append(opts, grpc.WithTransportCredentials(insecure.NewCredentials()))
```
Engine
Semgrep · Pattern-based code analysis

Counts towards
Vulnerability

File
/cmd/aigw/run.go line 177

Likely real
Yes, 99% confidence

Found an insecure gRPC server without 'grpc.Creds()' or options with credentials. This allows for a connection without encryption to this server. A malicious attacker could tamper with the gRPC message, which could compromise the machine. Include credentials derived from an SSL certificate in order to create a secure gRPC connection. You can create credentials using 'credentials.NewServerTLSFromFile("cert.pem", "cert.key")'.
```
s := grpc.NewServer()
```
Engine
Semgrep · Pattern-based code analysis

Counts towards
Vulnerability

File
/internal/ratelimit/runner/runner.go line 63

Likely real
Yes, 99% confidence

Found an insecure gRPC server without 'grpc.Creds()' or options with credentials. This allows for a connection without encryption to this server. A malicious attacker could tamper with the gRPC message, which could compromise the machine. Include credentials derived from an SSL certificate in order to create a secure gRPC connection. You can create credentials using 'credentials.NewServerTLSFromFile("cert.pem", "cert.key")'.
```
r.grpcServer = grpc.NewServer()
```
Engine
Semgrep · Pattern-based code analysis

Counts towards
Vulnerability

File
/.github/workflows/release.yaml line 11

Likely real
Yes, 87% confidence

This workflow uses `secrets: inherit` to pass all of the calling workflow's secrets to a reusable workflow. This violates the principle of least privilege because the called workflow receives access to every secret in the repository, not just the ones it needs. If the called workflow is compromised or sourced from a third party, an attacker gains access to all repository secrets. Instead, explicitly pass only the secrets that the called workflow requires using the `secrets:` map, e.g. `secrets: { MY_SECRET: ${{ secrets.MY_SECRET }} }`.
```
secrets: inherit
```
Engine
Semgrep · Pattern-based code analysis

Counts towards
Vulnerability

File
/.github/workflows/docker_build_job.yaml line 78

Likely real
Yes, 57% confidence

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".
```
run: |
          make docker-build.${{ matrix.command_name }} CMD_PATH_PREFIX=${{ matrix.cmd_path_prefix }} ENABLE_MULTI_PLATFORMS=true TAG=${{ inputs.tag }} DOCKER_BUILD_ARGS="--push"
```
Engine
Semgrep · Pattern-based code analysis

Counts towards
Vulnerability

File
/cmd/aigw/stdio2http.go line 51

Likely real
Uncertain, 46% confidence

Detected non-static command inside Command. Audit the input to 'exec.Command'. If unverified user data can reach this call site, this is a code injection vulnerability. A malicious actor can inject a malicious script to execute arbitrary code.
```
cmd := exec.Command(command, args...)
```
Engine
Semgrep · Pattern-based code analysis

Counts towards
Vulnerability

File
/site/src/plugins/llmsTxtPlugin.ts line 75

Likely real
Yes, 100% confidence

RegExp() called with a `k` 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.
```
const attr = (attrs: string, k: string) => attrs.match(new RegExp(`\\b${k}="([^"]*)"`))?.[1] ?? '';
```
Engine
Semgrep · Pattern-based code analysis

Counts towards
Vulnerability

File
/site/.npmrc line 1

Likely real
Yes, 97% confidence

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/
```
# Enforce Node/npm version requirements from package.json
engine-strict=true

# Allow semver ranges (caret/tilde) for flexibility
save-exact=false

# Skip audits during install (faster builds, can audit separately)
audit=false

# Hide funding messages for cleaner output
fund=false

# Reduce noise in CI/Netlify logs
loglevel=error
```
Engine
Semgrep · Pattern-based code analysis

Counts towards
Vulnerability

File
/internal/autoconfig/config.go line 16

Likely real
Yes, 51% confidence

When working with web applications that involve rendering user-generated content, it's important to properly escape any HTML content to prevent Cross-Site Scripting (XSS) attacks. In Go, the `text/template` package does not automatically escape HTML content, which can leave your application vulnerable to these types of attacks. To mitigate this risk, it's recommended to use the `html/template` package instead, which provides built-in functionality for HTML escaping. By using `html/template` to render your HTML content, you can help to ensure that your web application is more secure and less susceptible to XSS vulnerabilities.
```
"text/template"
```
Engine
Semgrep · Pattern-based code analysis

Counts towards
Vulnerability

File
/site/src/components/ApiField.tsx line 77

Likely real
Uncertain, 47% confidence

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.
```
<div className="api-field__description" dangerouslySetInnerHTML={{ __html: processDescription(description) }}/>
```
Engine
Semgrep · Pattern-based code analysis

Counts towards
Vulnerability

File
/site/src/components/ApiField.tsx line 63

Likely real
Uncertain, 47% confidence

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.
```
__html: processDescription(type).replace(
                  /\[([^\]]+)\]$([^)]+)$/g,
                  '<a href="$2">$1</a>'
                )
```
Engine
Semgrep · Pattern-based code analysis

Counts towards
Vulnerability

File
/site/src/components/ApiField.tsx line 47

Likely real
Uncertain, 47% confidence

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.
```
<div className="api-field__description" dangerouslySetInnerHTML={{ __html: processDescription(description) }}/>
```
Engine
Semgrep · Pattern-based code analysis

Counts towards
Vulnerability

File
/internal/mcpproxy/legacy.go line 785

Likely real
Uncertain, 46% confidence

Detected directly writing or similar in 'http.ResponseWriter.write()'. This bypasses HTML escaping that prevents cross-site scripting vulnerabilities. Instead, use the 'html/template' package and render data using 'template.Execute()'.
```
_, _ = w.Write(body)
```
Engine
Semgrep · Pattern-based code analysis

Counts towards
Vulnerability

File
/internal/mcpproxy/modern.go line 707

Likely real
Uncertain, 46% confidence

Detected directly writing or similar in 'http.ResponseWriter.write()'. This bypasses HTML escaping that prevents cross-site scripting vulnerabilities. Instead, use the 'html/template' package and render data using 'template.Execute()'.
```
_, _ = w.Write(encoded)
```
Engine
Semgrep · Pattern-based code analysis

Counts towards
Vulnerability

File
/internal/mcpproxy/legacy.go line 1173

Likely real
Uncertain, 46% confidence

Detected directly writing or similar in 'http.ResponseWriter.write()'. This bypasses HTML escaping that prevents cross-site scripting vulnerabilities. Instead, use the 'html/template' package and render data using 'template.Execute()'.
```
if _, err = w.Write(encodedResp); err != nil {
```
Engine
Semgrep · Pattern-based code analysis

Counts towards
Vulnerability

File
/internal/mcpproxy/legacy.go line 537

Likely real
Uncertain, 46% confidence

Detected directly writing or similar in 'http.ResponseWriter.write()'. This bypasses HTML escaping that prevents cross-site scripting vulnerabilities. Instead, use the 'html/template' package and render data using 'template.Execute()'.
```
_, err = w.Write(data)
```
Engine
Semgrep · Pattern-based code analysis

Counts towards
Vulnerability

File
/internal/mcpproxy/handlers.go line 55

Likely real
Uncertain, 46% confidence

Detected directly writing or similar in 'http.ResponseWriter.write()'. This bypasses HTML escaping that prevents cross-site scripting vulnerabilities. Instead, use the 'html/template' package and render data using 'template.Execute()'.
```
_, _ = w.Write([]byte(msg))
```
Engine
Semgrep · Pattern-based code analysis

Counts towards
Vulnerability

File
/site/src/plugins/latestBlogsPlugin.ts line 35

Likely real
Uncertain, 37% confidence

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.
```
const filePath = path.join(blogDir, file);
```
Engine
Semgrep · Pattern-based code analysis

Counts towards
Vulnerability

File
/site/src/plugins/llmsTxtPlugin.ts line 72

Likely real
Uncertain, 37% confidence

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.
```
? JSON.parse(fs.readFileSync(path.resolve(path.dirname(file), varsImport[1].replace(/\\/g, '')), 'utf-8'))
```
Engine
Semgrep · Pattern-based code analysis

Counts towards
Vulnerability

File
/site/src/plugins/latestBlogsPlugin.ts line 35

Likely real
Uncertain, 37% confidence

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.
```
const filePath = path.join(blogDir, file);
```
Engine
Semgrep · Pattern-based code analysis

Counts towards
Vulnerability

File
/site/src/plugins/latestBlogsPlugin.ts line 27

Likely real
Uncertain, 37% confidence

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.
```
const blogDir = path.join(context.siteDir, 'blog');
```
Engine
Semgrep · Pattern-based code analysis

Counts towards
Vulnerability

File
/site/src/plugins/llmsTxtPlugin.ts line 140

Likely real
Uncertain, 37% confidence

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.
```
fs.writeFileSync(path.join(outDir, 'llms.txt'), header + index);
```
Engine
Semgrep · Pattern-based code analysis

Counts towards
Vulnerability

File
/site/src/plugins/llmsTxtPlugin.ts line 141

Likely real
Uncertain, 37% confidence

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.
```
fs.writeFileSync(path.join(outDir, 'llms-full.txt'), header + full.join(''));
```
Engine
GuardDog · Supply-chain attack heuristics

Counts towards
Malicious pattern

File
/cmd/aigw/main.go line 129

Likely real
Yes, 93% confidence

Detects reading of environment variables (credential access, often contains secrets) [threat-runtime-environment-read]
```
}
	if c.Path == "" && os.Getenv("OPENAI_API_KEY") == "" && os.Getenv("AZURE_OPENAI_API_KEY") == "" && os.Getenv("ANTHROPIC_API_KEY") == "" && c.McpConfig == ""...
```
Engine
GuardDog · Supply-chain attack heuristics

Counts towards
Malicious pattern

File
/cmd/aigw/config.go line 46

Likely real
Yes, 93% confidence

Detects reading of environment variables (credential access, often contains secrets) [threat-runtime-environment-read]
```
// Add OpenAI config from ENV if available (takes precedence over Anthropic)
	if os.Getenv("OPENAI_API_KEY") != "" || os.Getenv("AZURE_OPENAI_API_KEY") != "" {
		if err := autoconfig.PopulateOpenAIEnvConfig(&data); err != nil {
			return "", err
```
Engine
GuardDog · Supply-chain attack heuristics

Counts towards
Malicious pattern

File
/cmd/aigw/config.go line 50

Likely real
Yes, 93% confidence

Detects reading of environment variables (credential access, often contains secrets) [threat-runtime-environment-read]
```
}
	} else if os.Getenv("ANTHROPIC_API_KEY") != "" {
		// Add Anthropic config from ENV if available (only when OpenAI is not configured)
		if err := autoconfig.PopulateAnthropicEnvConfig(&data); err != nil {
```