New Exploit Can Crash Chromium Browsers Worldwide

A newly discovered exploit, known as Brash, has exposed a critical architectural weakness in Chromium’s Blink rendering engine, allowing attackers to crash browsers like Google Chrome, Microsoft Edge, Opera, Brave, and others within seconds. 

The vulnerability, disclosed by security researcher Jose Pino (Jofpin), represents a disruptive flaw in modern browser architecture, capable of rendering entire systems unresponsive with nothing more than a single malicious URL.

Not a Memory Bug — A Design Flaw

The Brash exploit leverages the absence of rate limiting on the document.title API, which controls browser tab titles. 

By rapidly updating the document title millions of times per second, the exploit overwhelms the Document Object Model (DOM) and the browser’s user interface (UI) thread, forcing it into a crash state. 

The flaw does not rely on privilege escalation or memory corruption — making it easy to reproduce and difficult to mitigate without changes to the browser’s core architecture.

Pino’s research indicates that the attack can collapse any Chromium-based browser within 15 to 60 seconds, depending on system performance and configuration. 

The exploit consumes massive CPU resources during execution, degrading system performance and freezing concurrent processes.

How Brash Overloads Browsers

The Brash exploit operates in three primary stages that sequentially increase system load until failure:

1. Hash generation phase: The attacker preloads 100 unique hexadecimal strings, each 512 characters long, into memory. These serve as seeds for the document title updates, maximizing the entropy and reducing computational bottlenecks.
2. Burst injection phase: The malicious script performs bursts of three rapid-fire document.title updates every millisecond, resulting in roughly 24 million updates per second in the default configuration.
3. UI thread saturation phase: As updates flood the DOM, the browser’s main UI thread becomes saturated, leading to unresponsiveness and eventual forced termination.

This attack sequence is not only efficient but also highly tunable. 

The exploit can be configured to activate at specific moments using temporal triggers, allowing attackers to program “logic bombs” that detonate at predetermined times. 

Scope of The Vulnerability

The Brash vulnerability affects all browsers built on the Chromium framework — including Chrome, Edge, Opera, Vivaldi, Brave, Arc Browser, Dia Browser, Perplexity Comet, and ChatGPT Atlas. 

Testing has shown that browsers on macOS, Windows, and Linux crash within seconds when exposed to the exploit. 

The impact is significant because Chromium underpins the majority of web browsers, which potentially impacts billions of users.

The following table summarizes crash times across browsers tested by the researcher browsers:

Notably, browsers using non-Chromium engines — such as Mozilla Firefox (Gecko) and Apple Safari (WebKit) are protected from this specific attack. 

All browsers on iOS also remain unaffected, as Apple mandates WebKit usage for third-party browsers on the platform.

How Attackers Could Weaponize Brash

While the Brash exploit requires only a website visit to execute, its potential for harm extends far beyond browser crashes. 

Attackers could conceal the exploit within phishing emails, malicious advertisements (malvertising), or social media links that trigger at precise moments. 

In more targeted applications, Brash could be embedded within scripts used by AI-driven automation tools or headless browsers employed in web scraping and compliance verification. 

How to Stay Secure Before a Fix

At the time of the researcher’s disclosure, Google had not yet issued an official response. 

Pino emphasized that Brash is not a traditional software bug but a design oversight — a failure to implement rate throttling within a critical API. 

Because the exploit exploits normal browser behavior rather than security flaws, traditional antivirus tools and sandboxing are potentially ineffective. Organizations can take the following steps:

• Avoid untrusted sites and links, especially from emails or social media.
• Disable or restrict JavaScript and use extensions like NoScript or uBlock Origin.
• Keep browsers and extensions updated with the latest security patches.
• Use browser isolation or management tools to enforce secure configurations.
• Monitor endpoints and networks for CPU spikes, DOM changes, or malicious domains.
• Train users regularly to spot phishing and suspicious browser activity.

Combining strong technical safeguards with informed users helps organizations limit exposure to browser-based threats. A layered defense strategy ensures resilience even when individual controls are bypassed.

The Brash exploit highlights a growing challenge in modern browser security: as web technologies evolve, even legitimate APIs can be turned into attack vectors. 

It reveals how underlying architectural assumptions about user behavior and system trust can create blind spots that traditional defenses fail to catch.