Skip to content

Conversation

@christopherholland-workday

Overview

Part of advisory https://github.com/FlowiseAI/Flowise/security/advisories/GHSA-2x8m-83vc-6wv4

This PR fixes multiple SSRF bypass issues in the HTTP security wrappers by eliminating DNS rebinding (TOCTOU) vulnerabilities and enforcing deny-list validation at request time.

The changes ensure that every outbound HTTP request uses a DNS-pinned connection that matches the validated IP, including across redirects, and that insecure default behavior is removed.

Solution

1. Default insecure configuration

Previously, if HTTP_DENY_LIST was unset, requests were allowed without restriction, including access to localhost and private IP ranges.

Fix:
Requests now fail fast when HTTP_DENY_LIST is not defined, ensuring SSRF protections are always enforced.

DNS rebinding (TOCTOU) vulnerability

The previous implementation validated hostnames using dns.lookup, but the HTTP client would perform a second DNS resolution when opening the socket. This allowed attackers to return a safe IP during validation and switch to a blocked IP during connection. This seemed to be the case for both the secureFetch and secureAxiosRequest methods.

Callers of these methods, like utils#crawl should be protected via strengthening of these methods

Fix:
DNS resolution and validation now occur immediately before each request, and the resolved IP is pinned into the socket using a custom http.Agent / https.Agent. This guarantees the request connects to the same IP that was validated.

Redirect safety

Redirects were previously followed automatically by the HTTP client, allowing bypass of validation on redirected URLs.

Fix:
Automatic redirects are disabled. Each redirect target is:

  • explicitly resolved,
  • validated against the deny list,
  • and connected using a newly pinned agent.

Redirect method rewriting (e.g. POST → GET on 303) follows HTTP specifications.

node-fetch agent handling

When using [email protected], passing an Agent instance directly may not guarantee it is used, potentially allowing DNS re-resolution.

Fix:
The agent is now passed as a function (agent: () => agent), which node-fetch v2 reliably invokes, ensuring the pinned agent is always used.

Part of advisory https://github.com/FlowiseAI/Flowise/security/advisories/GHSA-2x8m-83vc-6wv4

Ensures that the validated host/ip is the same one used when resolving later on. Refactoring methods secureFetch and secureAxiosRequest to use resolver helper methods
@gemini-code-assist
Copy link
Contributor

Summary of Changes

Hello @christopherholland-workday, I'm Gemini Code Assist1! I'm currently reviewing this pull request and will post my feedback shortly. In the meantime, here's a summary to help you and other reviewers quickly get up to speed!

This pull request addresses critical Server-Side Request Forgery (SSRF) bypass vulnerabilities by implementing robust security measures for outbound HTTP requests. It focuses on eliminating DNS rebinding (TOCTOU) issues, enforcing deny-list validation at the point of connection, and securing redirect handling. The changes ensure that all requests utilize DNS-pinned connections that match validated IP addresses, thereby removing insecure default behaviors and significantly strengthening the application's defense against network-based attacks.

Highlights

  • Enforced Deny List Configuration: Requests now explicitly fail if the "HTTP_DENY_LIST" environment variable is not defined, ensuring that Server-Side Request Forgery (SSRF) protections are always active and preventing unrestricted access to local and private networks.
  • DNS Rebinding (TOCTOU) Prevention: The system now performs DNS resolution and validation immediately before each HTTP request, pinning the resolved IP address to the socket using custom "http.Agent" or "https.Agent" instances. This eliminates the time-of-check-to-time-of-use (TOCTOU) vulnerability where an attacker could switch IPs between validation and connection.
  • Enhanced Redirect Handling: Automatic redirects are disabled for both "axios" and "node-fetch" requests. Each redirect target is now manually resolved, validated against the deny list, and connected using a newly pinned agent, preventing bypasses through redirect chains. HTTP specification-compliant method rewriting (e.g., POST to GET on 303) is also implemented.
  • Reliable node-fetch Agent Usage: For "node-fetch" v2, the custom agent is now passed as a function ("agent: () => agent") to ensure it is reliably invoked and used, guaranteeing that the pinned agent is always applied and preventing unintended DNS re-resolution.
Using Gemini Code Assist

The full guide for Gemini Code Assist can be found on our documentation page, here are some quick tips.

Invoking Gemini

You can request assistance from Gemini at any point by creating a comment using either /gemini <command> or @gemini-code-assist <command>. Below is a summary of the supported commands on the current page.

Feature Command Description
Code Review /gemini review Performs a code review for the current pull request in its current state.
Pull Request Summary /gemini summary Provides a summary of the current pull request in its current state.
Comment @gemini-code-assist Responds in comments when explicitly tagged, both in pull request comments and review comments.
Help /gemini help Displays a list of available commands.

Customization

To customize Gemini Code Assist for GitHub experience, repository maintainers can create a configuration file and/or provide a custom code review style guide (such as PEP-8 for Python) by creating and adding files to a .gemini/ folder in the base of the repository. Detailed instructions can be found here.

Limitations & Feedback

Gemini Code Assist may make mistakes. Please leave feedback on any instances where its feedback is incorrect or counter productive. You can react with 👍 and 👎 on @gemini-code-assist comments. If you're interested in giving your feedback about your experience with Gemini Code Assist for Github and other Google products, sign up here.

You can also get AI-powered code generation, chat, as well as code reviews directly in the IDE at no cost with the Gemini Code Assist IDE Extension.

Footnotes

  1. Review the Privacy Notices, Generative AI Prohibited Use Policy, Terms of Service, and learn how to configure Gemini Code Assist in GitHub here. Gemini can make mistakes, so double check it and use code with caution.

Copy link
Contributor

@gemini-code-assist gemini-code-assist bot left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Code Review

This pull request effectively addresses a critical DNS Rebinding (TOCTOU) vulnerability in secureAxiosRequest and secureFetch by implementing DNS pinning. The changes ensure that outbound requests connect to the same IP that was validated, even across redirects. I also appreciate the move to a secure-by-default configuration that requires HTTP_DENY_LIST to be set. The code is much cleaner and more secure. I have a few minor suggestions to improve code consistency and clarity.

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>
Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>
Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>
const resolved = await resolveAndValidate(currentUrl)
const agent = createPinnedAgent(resolved)

const response = await fetch(currentUrl, { ...currentInit, agent: () => agent })

Check failure

Code scanning / CodeQL

Server-side request forgery Critical

The
URL
of this request depends on a
user-provided value
.

Copilot Autofix

AI about 12 hours ago

General strategy: ensure that user-controlled URLs cannot resolve to internal or loopback IP ranges, even if HTTP_DENY_LIST is unset or misconfigured. The existing mechanism (checkDenyList + isDeniedIP) is already the central guard used both at the service boundary and inside redirect-aware helpers (secureFetch, secureAxiosRequest). The best fix is to make checkDenyList always enforce a baseline deny-list of private/loopback ranges (RFC1918, loopback, link‑local, etc.) in addition to any values provided via HTTP_DENY_LIST. This keeps the flow unchanged (req.query.url → service → webCrawl/xmlScrapesecureFetch), but makes the guard robust enough that the tainted URL cannot reach sensitive internal destinations.

Concretely, in packages/components/src/httpSecurity.ts:

  • Update checkDenyList so that it no longer early‑returns when HTTP_DENY_LIST is undefined or empty; instead, it always builds an effective deny-list composed of a default list of dangerous IP ranges plus any extra entries from HTTP_DENY_LIST.
  • The default deny-list should include at least:
    • 127.0.0.0/8 (loopback)
    • 10.0.0.0/8
    • 172.16.0.0/12
    • 192.168.0.0/16
    • 169.254.0.0/16 (link‑local)
    • ::1/128 (IPv6 loopback)
    • fc00::/7 (IPv6 unique local)
    • fe80::/10 (IPv6 link‑local)
  • Keep the rest of checkDenyList logic (hostname resolution and calls to isDeniedIP) unchanged, just feed it the combined deny-list instead of one derived solely from the environment.

These changes are confined to packages/components/src/httpSecurity.ts. No new imports are required and no callers need to change, so existing functionality (including the ability to add more blocked ranges via HTTP_DENY_LIST) remains, with stronger default protections that directly address the SSRF concern.


Suggested changeset 1
packages/components/src/httpSecurity.ts

Autofix patch

Autofix patch
Run the following command in your local git repository to apply this patch
cat << 'EOF' | git apply
diff --git a/packages/components/src/httpSecurity.ts b/packages/components/src/httpSecurity.ts
--- a/packages/components/src/httpSecurity.ts
+++ b/packages/components/src/httpSecurity.ts
@@ -34,14 +34,32 @@
 
 /**
  * Checks if a URL is allowed based on HTTP_DENY_LIST environment variable
+ * and a built-in deny list of private/loopback address ranges.
  * @param url - URL to check
  * @throws Error if URL hostname resolves to a denied IP
  */
 export async function checkDenyList(url: string): Promise<void> {
     const httpDenyListString: string | undefined = process.env.HTTP_DENY_LIST
-    if (!httpDenyListString) return
 
-    const httpDenyList = httpDenyListString.split(',').map((ip) => ip.trim())
+    // Built-in deny list to protect against SSRF to internal networks,
+    // even if HTTP_DENY_LIST is not configured.
+    const defaultDenyList: string[] = [
+        '127.0.0.0/8',    // IPv4 loopback
+        '10.0.0.0/8',     // IPv4 private
+        '172.16.0.0/12',  // IPv4 private
+        '192.168.0.0/16', // IPv4 private
+        '169.254.0.0/16', // IPv4 link-local
+        '::1/128',        // IPv6 loopback
+        'fc00::/7',       // IPv6 unique local
+        'fe80::/10'       // IPv6 link-local
+    ]
+
+    const envDenyList: string[] = httpDenyListString
+        ? httpDenyListString.split(',').map((ip) => ip.trim()).filter((ip) => ip.length > 0)
+        : []
+
+    const httpDenyList: string[] = [...defaultDenyList, ...envDenyList]
+
     const urlObj = new URL(url)
     const hostname = urlObj.hostname
 
EOF
@@ -34,14 +34,32 @@

/**
* Checks if a URL is allowed based on HTTP_DENY_LIST environment variable
* and a built-in deny list of private/loopback address ranges.
* @param url - URL to check
* @throws Error if URL hostname resolves to a denied IP
*/
export async function checkDenyList(url: string): Promise<void> {
const httpDenyListString: string | undefined = process.env.HTTP_DENY_LIST
if (!httpDenyListString) return

const httpDenyList = httpDenyListString.split(',').map((ip) => ip.trim())
// Built-in deny list to protect against SSRF to internal networks,
// even if HTTP_DENY_LIST is not configured.
const defaultDenyList: string[] = [
'127.0.0.0/8', // IPv4 loopback
'10.0.0.0/8', // IPv4 private
'172.16.0.0/12', // IPv4 private
'192.168.0.0/16', // IPv4 private
'169.254.0.0/16', // IPv4 link-local
'::1/128', // IPv6 loopback
'fc00::/7', // IPv6 unique local
'fe80::/10' // IPv6 link-local
]

const envDenyList: string[] = httpDenyListString
? httpDenyListString.split(',').map((ip) => ip.trim()).filter((ip) => ip.length > 0)
: []

const httpDenyList: string[] = [...defaultDenyList, ...envDenyList]

const urlObj = new URL(url)
const hostname = urlObj.hostname

Copilot is powered by AI and may make mistakes. Always verify output.

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This is by design/an artifact from a previous commit: https://github.com/FlowiseAI/Flowise/blob/main/packages/components/src/httpSecurity.ts#L178

Will check with the team if there are other actions required to fix this

}

async function resolveAndValidate(url: string): Promise<ResolvedTarget> {
const denyListString = process.env.HTTP_DENY_LIST
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

By forcing every users to specify HTTP_DENY_LIST, its not user/begineer friendly.

The decision we took is to allow users to have the option to specify if needed, otherwise its not blocking by default. Its not secured by default. We have also documented here

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

3 participants