Experiments

What the Optimizely attack says about the software we trust

What the Optimizely attack says about the software we trust

Why is everything breaking all of a sudden?

There is a particular kind of technology story that makes you reset your passwords, check on your 2FA, and mentally run through every website you've visited lately.

The latest Optimizely story is one of them.

Today it was announced that malicious JavaScript was delivered through Optimizely, which is used by many very large organizations. The affected snippets were associated with names including the BBC, Zoom, CNN, GitLab, Salesforce, and HSBC.

Depending on the page, device, and what a visitor did, the code could replace cryptocurrency addresses, skim payment-card details, steal browser-accessible information, or deliver an iPhone exploit kit.

The unsettling thing is how ordinary the whole chain is: You visit a familiar site. The site loads a tool it uses on purpose. That tool sends code from a legitimate domain, and your browser runs it. Somewhere in that boring, approved sequence, the instructions changed.

The reported Optimizely attack

Where the trust broke

  1. Legitimate website

    The site loads an approved experimentation snippet.

  2. Approved vendor snippet

    Still delivered from the trusted vendor domain.

    Project JavaScript modifiedCustomer project configuration changed upstream.
  3. Visitor browser

    The browser runs the snippet, including the injected instructions.

Initial access method: unknown. The reported change was to customer project configuration; this was not CDN cache poisoning.

The malicious code arrived through an approved script

An experimentation snippet has a good reason to change a page.

You install it to test a headline, show a different layout, or run additional code. Your browser loads the snippet and applies whatever the team has configured.

In the Optimizely incident investigated by Report URI, attackers modified a field called Project JavaScript. It lets customers add code that runs across pages using their project. The researchers found malicious code there in multiple customer projects.

Most of the snippet could stay intact, and arrive from Optimizely's legitimate domain, with a valid certificate, through the arrangement the website had already approved. The site was already configured to load code from that source.

Some affected customers served the snippet through their own domains. They could still receive the malicious content because the modified project was upstream of that arrangement. By itself, putting your domain in front of a file doesn't give you control over who changes it.

Once delivered, the payload had several ways to cause harm:

  • It could substitute attacker-controlled cryptocurrency addresses for the ones a visitor expected to copy.
  • It could look for payment-card details in a site's own form fields and outgoing requests.
  • Under certain conditions, it could collect non-HttpOnly cookies and screenshots.
  • On relevant Apple mobile devices, it attempted to deliver additional exploit chains.

The people investigating and cleaning this up have difficult work ahead of them. The rest of us can start by looking at where we've granted the same capability.

How many people were harmed?

As of today, this is still an open question.

Report URI checked 1,611 distinct Optimizely snippets and found malicious code in 188 of them, associated with 178 organizations.

Some organizations have multiple snippets, and some names refer to subsidiaries or regional operations. The list describes identified snippets and associated organizations, but it doesn't establish that 178 independent parent companies had their entire infrastructure breached.

It also doesn't give us a victim count. To determine that, we’d need to know which pages loaded the code, when people visited, what protections they had, and what they did while it was active. But I suspect the headline would be horrifying.

There is already evidence of financial harm, as well: the researchers identified cryptocurrency transactions into attacker-controlled wallets. It also describes a changing payload and substantial cleanup on November 16. The damage assessment is still catching up with an incident that was changing as people investigated it.

For a visitor who received that code, the distinction between a compromised vendor project and a compromised company server is probably of limited comfort. They used a website they trusted, and something harmful arrived through it.

Shrink the attack surface

Learn how fewer data copies, narrower credentials, and deliberate deployment choices can reduce your company’s exposure.

Read More

Why is everything breaking all of a sudden?

On October 21, PHP released emergency fixes for two critical vulnerabilities, CVE-2026-109618 and CVE-2026-109619. Successful exploitation could let an unauthenticated attacker execute code on a vulnerable system. By October 27, the Canadian Centre for Cyber Security was reporting exploitation in the wild.

OpenAI's account of the coordinated response says Calif found a critical flaw using GPT-5.6 Sol. Wiz independently discovered and reported both vulnerabilities. PHP's maintainers led the fixes, with other organizations helping prepare protections.

I'm glad that work happened on the defensive side. Finding a critical vulnerability before an attacker does is an excellent use of AI. It also gives us a fairly uncomfortable demonstration of what these tools can now help people find.

On October 27, Anthropic published research on AI-assisted discovery and exploitation of vulnerabilities in browsers and operating systems. In one example, after initial prompting, Claude constructed an exploit for a Linux kernel networking vulnerability. On a vulnerable server with a Multipath TCP listener, it could execute a command as root, without credentials or interaction from a user.

The proof-of-concept attack took about 53 minutes to run across its two stages. That's the attack's run time, not the time Claude took to discover the vulnerability or write the exploit. The vulnerability was patched upstream, and AWS's November 12 bulletin update said it had no evidence the issue had been leveraged at that time.

This was a research demonstration against a particular vulnerable setup. It still involved a model helping turn a difficult networking flaw into a working route to privileged command execution.

Even the freezers got hacked

The rest of the technology news hasn't been especially soothing either.

On November 13, the FAA halted departures nationwide after instability in its telecommunications network. Aircraft already in the air landed safely. A problem in the underlying network was enough to interrupt departures across the country.

The official statement was that a contractor was replacing a copper wire, and also there was a faulty router, these both somehow led to the entire country being grounded for hours.

I’m not saying that’s a lie… just super weird timing. 👀

And today, on November 16, Chase reports a software bug in its on-premise hardware systems that is affecting transactions.

Also today, United Airlines had a separate technology problem affecting departing flights. Both Chase and United reported no indication that their disruptions were cybersecurity-related—just suspicious timing until we know more.

Then there are the supermarket freezers in France. During the night of October 11–12, attackers targeted refrigeration controllers at more than 700 French retail sites. The French government's account describes equipment damage, fires, and food losses estimated in the tens of millions of euros.

I hate that “the freezers got hacked” is a real sentence that we have to contend with.

The real sentiment—whether or not all of these are legitimate cyberattacks—is that our technology infrastructure feels profoundly less safe than it did a couple short months ago.

__wf_reserved_inherit
Me and my freezer lately.

“What did we actually give this thing access to?”

A few weeks ago, Graham McNicoll wrote “Protecting your company from the future”.

His argument was that reducing the number of systems holding your data can reduce your exposure. Deployment choices and credential scope deserve more attention as attacking software becomes easier.

The Optimizely incident adds code execution to that conversation. A tool can hold your data, query your database, publish changes to your website, or control equipment. “We use this vendor” leaves out most of the information I'd want before deciding whether the arrangement makes sense.

Picture a website with a tag manager, an experimentation tool, a chat widget, and a few marketing integrations. In this hypothetical, every addition had a reasonable business case.

Now try to explain the combined setup to someone outside your team. They'll need to know who can publish changes, what information those changes can reach, and whether anyone notices when the configuration changes.

The upside is that this is a place where product and marketing people can do useful security work. You probably know why a tool was installed and whether anyone still uses it. Engineering and security can explain its access. Put those people in the same conversation before an incident forces everyone to reconstruct the history at once.

The refrigeration example makes this very tangible. A remote control panel helps a legitimate operator maintain equipment. After the French attacks, CERT-FR advised removing public internet exposure and restoring access through a protected network or secure VPN. The operator still gets to do the job, with a narrower route to the controls.

And, yes, it’s time to really start scrutinizing “But this code has been on our website forever.”

How to keep your company, data, and customers safe

If you’re auditing your site and product (like most of us right now), I'd start with an unglamorous review of the tools already installed. Work out what each one can read, change, and control, then remove the access it no longer needs.

Find out who can ship code to your website

List the third-party scripts and tag-manager containers on your site, and get a real answer to these questions for each:

  • Why is it still here, and who owns it?
  • Which pages load it?
  • Who can change the code or configuration?
  • Who can stop loading it during an incident?

On a page you manage, open your browser's developer console and run this read-only snippet. It lists the script elements currently present, giving you a starting point for figuring out who owns each one.

console.table([...document.scripts].map(script => {
  const url = script.src ? new URL(script.src) : null;

  return {
    source: url ? url.origin + url.pathname : "[inline]",
    integrity: script.integrity ? "present" : "not set"
  };
}));

Pick a source you don't recognize and find its owner. This is an inventory snapshot, not a malware scan. It misses some dependencies, including code inside frames and workers, and neither a familiar domain nor an integrity attribute proves that code is safe.

Permission to publish custom JavaScript belongs in a production-access review. A setting in a vendor dashboard can affect every browser that receives the resulting code, even if nobody touches your application repository.

Content Security Policy can restrict script loading and outbound connections, but the details of the policy matter. An allowlist that trusts a vendor domain doesn't verify the contents of scripts from that domain. Report-only mode records violations without blocking them. You need to know which protection is actually in place.

Subresource Integrity checks can reject unexpected changes when you can pin a script to known content. A frequently changing snippet needs a deliberate update process for that to work. Monitoring can help reveal changes worth investigating, too; OWASP's guidance on managing third-party JavaScript is a good starting point for the security discussion.

Try walking through the response to a trusted script behaving strangely. At the very minimum, someone needs to notice, know how to disable it, and understand what breaks when they do.

Look at what the credentials allow

Imagine an integration that reads a few tables. During setup, someone gave it write access across the warehouse because that was the quickest way to get it working.

Does it still exist six months later?

Periodic permission reviews are how you catch that accumulation. Give people and integrations the datasets and actions they need, and revisit that access when the work changes.

Opt for short-lived credentials wherever you can, and make sure someone can revoke access when an integration is removed or suspected of compromise. OWASP's secrets-management guidance covers those lifecycle and access-control practices.

Be sure to look at the data copies as well. An old export that nobody uses is still another place holding information you may have to account for during an incident. Check whether the copy is needed, whether a smaller dataset would do, and how long it should be retained.

Warehouse-native analysis can help by running analysis against existing warehouse data without requiring another raw-event silo. You still need to inspect the credentials, the results leaving the warehouse, and what the tool stores.

Choose a setup your team can maintain

Self-hosting gives you control over network access, updates, and where sensitive systems run.

You also take responsibility for patching, monitoring, backups, and recovery. If your team can't maintain those things, the control you gained may be less useful than it sounded during the evaluation.

A managed service may be the practical choice, especially going forward. Look closely at the provider's access controls, incident response, update process, and the data you need to share. In either arrangement, someone has to do the work of operating it securely.

At GrowthBook, our cloud and self-hosted deployment options, warehouse-native analysis, and security controls are relevant to these decisions. I'd want people to ask us the same questions: what data moves, what permissions exist, what is exposed to the network, and who is responsible for keeping the system running?

Finally, practice losing a dependency. Decide who can disable it, whether the essential service can continue, and what evidence you'd need to investigate. Discovering that your team can't turn something off is much less alarming while it's still behaving itself.

Curious about self-hosting?

If you’d like more control over where your experiments run and how they're managed, our self-hosting guide is a good place to start.

Explore Self-Hosting
Jack Virag

Jack Virag

Senior Marketing Manager, GrowthBook

Table of Contents

Related articles

See All Articles
Experiments
Standing on the shoulders of giants: 13 pioneers who made A/B testing possible
How AI Visual Editing Helps Teams Run More Experiments Without Engineering
Experiments
AI
How AI Visual Editing Helps Teams Run More Experiments Without Engineering
Experiments
Jev Applied: Scoring experiment quality with a decision model

Ready to ship faster?

No credit card required. Start with feature flags, experimentation, and product analytics — free.

Simplified white illustration of a right angle ruler or carpenter's square tool.White checkmark symbol with a scattered pixelated effect around its edges on a transparent background.