CVE-2026-73425

Executive Summary

CVE-2026-73425 is a regex-based authorization bypass in Astro's Netlify adapter. When Astro converts image.remotePatterns entries into a regular expression allowlist for Netlify's Image CDN, literal pathname components containing regular expression metacharacters are not escaped. This allows an attacker to request images from an already-permitted host whose optimized path falls outside the intended pathname namespace. The issue affects Astro deployments using the Netlify adapter prior to version 8.1.2 and has a CVSS score of 3.7, reflecting low confidentiality impact and high attack complexity.

Technical Analysis

The vulnerability lives in the integration between Astro and the Netlify Image CDN. Netlify's Image CDN enforces an allowlist named images.remote_images, written by the Astro Netlify adapter to .netlify/v1/config.json. This file controls which remote image sources may be fetched, transformed, and served by Netlify.

The relevant code path is in packages/integrations/netlify/src/index.ts. The adapter converts each configured image.remotePatterns entry into a regular expression. The remotePatternToRegex() helper is called to perform this conversion. According to the NVD description, the function correctly escapes dots in hostname values, but does not escape regular expression metacharacters in the pathname component. Characters such as ., +, ?, (, and [ are interpolated literally into the generated regular expression.

A concrete example is a configured pathname such as /img/v1.0/file. The dot in v1.0 is treated as a regex wildcard, meaning the generated allowlist also matches paths like /img/v1X0/file or /img/v1-0/file. If the pathname includes .* or other metacharacter sequences, the regex can match paths that cross segment boundaries, effectively expanding the set of image paths Netlify will process beyond the pathname the developer intended to allow.

Netlify enforces the generated regular expression directly. Astro's own matchPattern() helper is not used to revalidate the incoming request before optimization occurs. Therefore, if the Netlify-level regex accepts the request, the attacker's path is processed even though Astro's original path-pattern logic would have rejected it. The root cause is a classic CWE-185: Incorrect Regular Expression, where attacker-influenceable input is incorporated into a security-sensitive regular expression without proper sanitization or validation of expression semantics.

The vulnerability is server-side configuration generation and server-side regex enforcement. No client-side flaw is involved, and no authentication is required to exploit it. The attacker must be able to reach Netlify's image optimization endpoint and must be able to identify or guess image filenames on a host already allowed by remotePatterns.

Exploitation Scenarios

No public proof-of-concept or exploit code is currently available. The following attack chain is inferred from the vulnerability class and the NVD description.

1. Target Identification

An attacker locates an Astro site that uses the Netlify adapter with image optimization enabled. The site must be configured with at least one image.remotePatterns entry that includes a hostname and a restrictive pathname. The attacker may infer this configuration by observing image URLs served through Netlify's image CDN, or by detecting the presence of Netlify headers and Astro-generated markup. The attack surface is the public-facing Netlify Image CDN endpoint, so no prior access to the backend or administrative interface is required.

2. Vulnerability Trigger

The attacker identifies a pathname in the allowlist that contains a regex metacharacter. For example, if the configured pathname is /img/v1.0/file, the unescaped dot expands the regular expression. The attacker crafts a modified image path that is still matched by the generated regex but is not a literal match for the intended pathname. If the configured pathname contains a .* or .+ sequence, the attacker can construct paths that cross into adjacent directories or bypass a path-segment boundary.

3. Payload and Execution

The attacker sends an HTTP request to Netlify's image optimization endpoint with the modified path. The request path resembles a legitimate image optimization path but includes characters that exploit the permissive regex. Because Netlify uses the generated regular expression as the authoritative allowlist and Astro does not revalidate, the request is accepted. The vulnerable character classes named in the NVD description — ., +, ?, (, and [ — are the primary enablers, and a single affected pathname can make the allowlist substantially broader than intended.

4. Post-Exploitation Impact

After the request succeeds, Netlify fetches the image from the permitted host and returns the optimized version to the attacker. The attacker gains access to optimized copies of image files that are on the same allowed host but outside the intended pathname include. This can expose image content in directories the developer intended to exclude. The impact is limited to read-only disclosure of image files; there is no evidence of code execution, integrity compromise, or availability impact.

Impact Assessment

The CVSS assessment for CVE-2026-73425 is CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:N/A:N, which evaluates to a score of 3.7.

• Attack Vector (AV:N): The vulnerability is exploitable remotely over the network.
• Attack Complexity (AC:H): Exploitation requires specific configuration conditions, namely a pathname containing regex metacharacters and an attacker who can craft a path that still matches the generated allowlist.
• Privileges Required (PR:N): No authentication or special privileges are required.
• User Interaction (UI:N): No victim interaction is needed.
• Scope (S:U): The exploit affects only the image allowlist logic; it does not cross a security boundary between separate principals.
• Confidentiality (C:L): The impact is limited to unauthorized retrieval of image files.
• Integrity (I:N): No data can be modified or forged.
• Availability (A:N): No denial-of-service or resource exhaustion is described.

The affected systems are Astro sites that integrate the Netlify adapter and use image.remotePatterns with pathnames containing regex metacharacters. Sites that do not use the Netlify adapter, or that use only hostname-only pattern matching, are not affected. The business impact is primarily a compliance and data-exposure risk: image assets intended to be private or restricted may be retrievable by unauthorised parties. The blast radius is constrained to image files on hosts already permitted in remotePatterns, so data on unrelated hosts cannot be accessed.

Detection Guidance

The following detection content is heuristic. Because no public exploit exists and the vulnerable configuration is written to a deployment artifact, detection should focus on both the generated .netlify/v1/config.json file and anomalous image-optimization requests containing regex metacharacters.

Sigma Rule

title: CVE-2026-73425 Astro Netlify Image Allowlist Regex Bypass
id: 0f2a19c6-7342-45b2-9e1b-8c3d2e7f1a2b
status: experimental
description: Detects HTTP image requests to paths containing regex metacharacters that may trigger the Astro Netlify adapter allowlist bypass, and detects generated Netlify configs containing unescaped pathname metacharacters.
author: Threat Intelligence
date: 2026-04-14
logsource:
  category: web
  product: netlify
detection:
  selection_http:
    http.url|contains:
      - '/img/'
      - '/images/'
    http.url|re:
      - '/img/[^?]*[.+?(\[]'
      - '/images/[^?]*[.+?(\[]'
  selection_config:
    file.path|contains|all:
      - '.netlify'
      - 'config.json'
    file.content|contains: 'remote_images'
  condition: selection_http or selection_config
level: medium
falsepositives:
  - Legitimate image URLs that naturally include plus signs or parentheses in filenames
  - Automated scanners exercising image endpoints with punctuation

YARA Rule

rule astro_netlify_remote_images_unescaped_regex {
 meta:
   author = "Threat Intelligence"
   description = "Detects Netlify config files generated by Astro containing image.remote_images allowlist entries with unescaped regular expression metacharacters in pathname components, indicating CVE-2026-73425 exposure."
   cve = "CVE-2026-73425"
   date = "2026-04-14"
   reference = "https://nvd.nist.gov/vuln/detail/CVE-2026-73425"
 strings:
   $config_marker = "remote_images"
   $dot_unescaped = /image[a-zA-Z_]*\s*=\s*[^\\]\./
   $plus_unescaped = /image[a-zA-Z_]*\s*=\s*[^\\]\+/
   $question_unescaped = /image[a-zA-Z_]*\s*=\s*[^\\]\?/
   $paren_unescaped = /image[a-zA-Z_]*\s*=\s*[^\\]\(/
   $bracket_unescaped = /image[a-zA-Z_]*\s*=\s*[^\\]\x5B/
 condition:
   $config_marker and any of ($dot_unescaped, $plus_unescaped, $question_unescaped, $paren_unescaped, $bracket_unescaped)
}

Suricata IDS Rule

alert http any any -> any any (
  msg:"CVE-2026-73425 Astro Netlify image allowlist regex bypass request";
  flow:established,to_server;
  content:"GET"; http_method;
  pcre:"/^\/[^\r\n]*(img|images)\/[^\r\n]*[.+?(\x5B][^\r\n]*$/Ui";
  reference:cve,2026-73425;
  classtype:attempted-recon;
  sid:273425;
  rev:1;
)

Elastic Detection

network where network.protocol == "http" and
  url.path rlike ".*/(img|images)/.*[.+?(\x5B].*" and
  url.path rlike ".*/[^.]+\\..*"

Splunk SPL Query

index=proxy OR index=netflow
| search url_path IN ("/img/*", "/images/*")
| regex url_path="(?i)(/img/|/images/)[^?]*[.+?(\x5B]"
| stats count by src_ip, dest_ip, url_path, http_status
| where count > 5

Wazuh OSSEC Rule

<rule id="100273" level="8">
  <if_sid>550</if_sid>
  <field name="file" type="pcre2">\.netlify/v1/config\.json</field>
  <description>Astro Netlify image allowlist config modified; potential CVE-2026-73425 exposure</description>
  <group>syscheck,access-control,cve-2026-73425,</group>
</rule>

<rule id="100274" level="10">
  <match>remote_images</match>
  <regex type="pcre2">\.netlify/v1/config\.json</regex>
  <description>Netlify config contains remote_images allowlist; validate for unescaped regex metacharacters associated with CVE-2026-73425</description>
  <group>syscheck,access-control,cve-2026-73425,</group>
</rule>

Mitigation & Patch Guidance

Patch confidence is 2/4 (CLAIMED). Only the OSV advisory source claims the fix; no independent confirmation is currently available. No vendor-provided workaround (Vendor Fix: N/A, Workarounds: N/A) is documented.

Immediate Mitigations

• If the Astro Netlify adapter is in use, review each entry in image.remotePatterns for pathname values containing regex metacharacters such as ., +, ?, (, [, ], {, }, *, ^, $, or \. Replace them with literal-safe path representations if the framework allows alternate syntax.
• If such pathnames are required, consider disabling Netlify Image CDN for those patterns, or restrict access at Netlify's edge with an additional host or path rule that does not rely on the generated regex.
• Monitor image-optimization request logs for paths containing the metacharacter classes listed above, especially when the requests are directed at a hostname from remotePatterns.

Patch / Upgrade Steps

• Upgrade Astro to version 8.1.2 or later. The fix is claimed for 8.1.2 and is tracked via OSV advisory.
• After upgrading, redeploy the site and inspect the generated .netlify/v1/config.json to confirm that pathname metacharacters in images.remote_images are now escaped or that the configuration structure has changed.
• Because patch confidence is not independently confirmed, verify the fix by testing a previously failing image path against the Netlify Image CDN endpoint. If the unauthorized path still returns an optimized image, continue to apply edge-level restrictions and vendor workarounds.

Long-Term Hardening

• Treat generated configuration files as security artifacts. Include .netlify/v1/config.json in code review and CI validation.
• Add a regression test that feeds pathnames containing regex metacharacters into the adapter and asserts that the generated regex does not exceed the intended path prefix.
• Avoid embedding user-controlled pathname strings into security-relevant regex generation unless the framework guarantees escaping.
• Keep Astro and its official adapters updated, since adapter-level issues are frequently fixed outside the main framework release cadence.
• Apply least-privilege access control to image storage so that even a regex allowlist bypass does not expose sensitive content.

References

• NVD entry: https://nvd.nist.gov/vuln/detail/CVE-2026-73425
• OSV advisory: https://osv.dev/vulnerability/CVE-2026-73425
• CVE record: https://www.cve.org/CVERecord?id=CVE-2026-73425
• Source file referenced in NVD description: packages/integrations/netlify/src/index.ts (Astro repository; exact advisory commit URL not provided)
• CISA KEV: Not listed — no known exploitation-in-the-wild evidence at the time of writing.

No public exploit code, Nuclei template, or third-party researcher analysis is currently available. No threat actor campaign has been publicly attributed to this CVE as of this report.