Crypto Malware Attack: What the 178-Site Breach Means
Learn how the Optimizely script attack exposed visitors to crypto wallet substitution and card theft, and what users and website operators should do next.

How a Script Attack Put 178 Major Websites at Risk
Seeing a familiar brand in your browser doesn't mean everything behind the scenes is safe. In a reported attack, malicious code was injected into scripts delivered through Optimizely, a website optimization platform. Researchers linked affected scripts to 178 organizations, including Ledger, the BBC, IKEA, Salesforce, Zoom, and CNN.
The threat wasn't theoretical. The malware was designed to tamper with cryptocurrency wallet addresses copied by visitors and to capture payment card details entered into forms. That doesn't mean every visitor was affected, or that every exposed detail turned into theft - but it does mean a trusted site can become a route for malicious code the site didn't intend to serve.
This incident is a clear example of third-party risk: when shared web infrastructure is compromised, the blast radius can cross organizational boundaries. It also shows why crypto users are especially vulnerable to clipboard-style attacks, and why both visitors and site teams should take "just a script" seriously.
What happened in the Optimizely malware attack?
Security researchers reported that attackers injected malicious code into scripts delivered through Optimizely. The campaign - researcher Amirul Iman dubbed "Optimjack" - affected scripts tied to 178 organizations, according to Report URI's investigation. StepSecurity also analyzed the behavior, including credit card data capture.
The organizations named in the reporting span multiple industries. They include cryptocurrency hardware wallet company Ledger, as well as trading platforms IG, Interactive Investor, TMS Brokers, and OANDA / Coinpass. The affected list also includes the BBC, CNN, IKEA, Salesforce, and Zoom.
One important caveat: these names describe organizations whose website scripts were reported as affected. They don't, by themselves, prove that every organization's internal systems or customer databases were breached.
The reported timing suggests the code was served for much of Monday. The BBC was observed serving the injection at about 4:21 am UTC. Ledger's affected snippet was cleaned at about 8:41 pm UTC, and most of the malicious code had been removed by about 9:52 pm UTC. Those timestamps reflect what researchers saw and when the injection appeared to be removed - they don't automatically tell you exactly when every visitor was exposed.
And that distinction matters. Having a compromised script creates an opportunity, but it doesn't tell you how many people loaded it, whether it ran in each browser, or how much data - if any - attackers actually obtained. What's supported by the reporting is what the malware was designed to do and which organizations' scripts were flagged; what's not established is a confirmed total of stolen funds or payment details.
What "178 affected organizations" does and does not mean
A shared service can deliver code to many different websites. If the delivery path gets compromised, the number of "affected" organizations can rise quickly - even if attackers didn't individually break into each company.
At the same time, being listed as affected shouldn't be treated as proof that every visitor got infected or that every organization suffered the same impact.
For users, the key question is whether you interacted with a vulnerable page while the malicious code was being served. For organizations, the questions are more specific: which scripts and pages were affected, what data those pages handled, and whether evidence shows the payload actually executed or data left the site.
Those are the investigation questions. You can't answer them from the organization's name alone, and the incident report doesn't establish one single outcome for every brand on the list.
How can website malware steal crypto and card details?
The two reported behaviors target different moments during a visit.
One focuses on payment card details entered into forms. A malicious script can watch inputs as a user types, and depending on how the code is written and what defenses are in place, it may capture card data before or during submission. StepSecurity reported the injected code was capable of capturing credit card information. Capability isn't the same thing as proof that every submission was captured - or that any specific card was used fraudulently.
The crypto angle is easy to miss because it can look like the user is doing everything normally. A user copies a wallet address, but malware can swap the clipboard contents for an attacker-controlled address. If the user pastes it into a wallet and sends without double-checking, the transaction goes to the wrong place.
Why crypto address substitution is hard to reverse
Once blockchain transactions are confirmed, they're designed to be final. A card charge can sometimes be disputed through the issuer. An on-chain transfer doesn't have a central "undo" button in the way people often hope. Whether funds can be returned depends on control of the destination address and whether the attacker cooperates - which is, in a theft scenario, unlikely.
So the best control is prevention: verify the address. Checking just the first and last characters can catch some mistakes, but it won't reliably stop malware that's engineered to look similar. For bigger transfers, compare the full address using a trusted source, and confirm on the receiving device or application where possible.
A hardware wallet can help you verify transaction details on its own screen, but it doesn't guarantee every step is safe. You still need to make sure the destination shown on the device is the one you intend to use. The device protects the private key; it can't make an incorrect recipient address correct.
Why a trusted brand doesn't neutralize the threat
People often assume big companies have already checked every piece of their website. In reality, modern sites pull in code from a mix of first-party systems and external providers. If a third-party script is compromised, it can run in the context of the page that includes it - potentially accessing what a visitor enters or tampering with what the user sees.
That's why a familiar logo isn't a safety check. If you're sending crypto, verify the destination independently before you sign. If you're paying by card, rely on the card issuer's alerts and review transactions if you entered details on a page later reported as affected.
What does this incident reveal about third-party website risk?
The main lesson is simple: a website isn't only the code its owner wrote. It can depend on analytics, experimentation tools, advertising, customer support widgets, payment components, and content delivery services. Those dependencies can help teams run faster and iterate - but they also add more code that can execute in front of customers.
An optimization platform like Optimizely is built to help teams test or personalize experiences. The broader risk isn't specific to one vendor. Any service that supplies executable code to a customer-facing page can become part of that page's security boundary. If the vendor, an account, a deployment process, or a script delivery path is compromised, the impact can spread to many sites that rely on it.
This is a supply-chain problem in a practical sense: one compromised dependency can create exposure across multiple organizations. It doesn't require every affected company to share infrastructure - or to have suffered a separate intrusion into its own internal network. That mismatch is one reason the incident can be confusing for users and hard to scope quickly for response teams.
Why script access deserves the same attention as server access
A third-party script can potentially observe or change what happens in the browser. Exactly what it can do depends on where it's loaded and how it's allowed to run, but a script on a checkout or crypto-related page could have access to sensitive interactions.
So script inclusion should be treated as a security decision, not just a front-end implementation detail.
The trade-off is operational. Remove every external script and you may reduce exposure - but you can also break analytics, experiments, support tools, or even business-critical flows. The practical goal isn't "use no vendors." It's knowing what scripts are present, why they're there, which pages they can affect, and how quickly they can be disabled if something goes wrong.
How teams can make dependencies more manageable
A useful inventory includes the service owner, its business purpose, the pages where it runs, what data it might encounter, and who's authorized to remove it. That's what makes incident response faster - so your team doesn't learn during an active event that an "abandoned" experiment is still loading code on a payment page.
Where it's feasible, teams can also constrain scripts using controls like a restrictive Content Security Policy, integrity checks for static files, and tighter access to sensitive pages. These controls have limits. Integrity checks can be difficult for dynamic scripts that change often, and a policy that's too broad won't help much. The right approach depends on how the vendor integrates and how sensitive the page is.
The incident also underscores that vendor review can't end at procurement. A service might be reasonable at purchase time and still need ongoing monitoring, access control, and a tested way to disable it. The real operational question is: if someone suspects a script at 3 a.m., can the team stop serving it quickly without taking down the customer journey?
What should users and website operators do?
What you should do depends on what happened, not just whether a brand appears in a report.
Visitors should focus on what they did while the site may have been serving the code. Organizations should define the scope, contain the delivery path, and communicate clearly - without overstating what's been proven.
If you visited an affected website
Just visiting a site doesn't automatically mean your wallet was drained or your card details were stolen. If you didn't enter payment information, connect a wallet, copy an address, or submit a transaction, there may be nothing specific to act on beyond staying alert. The risk depends on the page, timing, and whether the payload ran in your browser.
If you copied a crypto address from a page that might have been affected, check the destination you used in any transaction. If a transfer went to an address you didn't intend, contact the exchange or service involved promptly and keep the transaction details. Be skeptical of anyone promising guaranteed recovery. Public blockchain transfers generally aren't reversible through normal customer support requests.
If you entered card details, review recent transactions and set up or review issuer alerts. Contact your card issuer if you see an unfamiliar charge or want guidance on whether to replace the card. Use the issuer's official app or official contact methods - not a number or link that you weren't expecting.
For wallet security, don't share a seed phrase or private key with anyone claiming to investigate the incident. A legitimate support team doesn't need those secrets to check a transaction. If you suspect compromise, move remaining assets only after you understand the risk and verify the destination on a trusted device - an improvised transfer can create a second loss.
If you operate a website that may be affected
A practical response sequence looks like this:
- Contain the delivery path. Disable or remove the suspect script where possible, using your incident process. Don't make unrelated production changes that muddy the evidence.
- Preserve evidence. Capture relevant script versions, deployment and vendor logs, affected pages, and the times when removal happened. Coordinate with the vendor and security team so information survives before log rotation clears it out.
- Establish scope. Determine when the code was served, which pages included it, what users could enter there, and whether there's evidence of data collection or transmission. Separate confirmed facts from plausible exposure.
- Assess user impact. Coordinate security, legal, privacy, support, and payments. Notification duties vary by jurisdiction and by what data was involved - don't assume one approach fits every situation.
- Communicate precisely. Explain what's known, what's still under investigation, and what users should do next. Avoid premature reassurance and avoid claiming confirmed theft without evidence.
- Test recovery. After containing the issue, verify the replacement code, review access to vendor accounts and deployment systems, and confirm monitoring would catch similar changes.
Speed matters, but so does scope. Moving too fast can destroy logs or lead to incorrect guidance. Use a rehearsed process so you can contain quickly and update users as the evidence becomes clearer.
Conclusion
The Optimizely-related campaign shows how a compromise in shared website infrastructure can put many brands in the same incident - without proving that every organization or visitor suffered the same loss. The payload targeted two high-value behaviors: entering card details and copying cryptocurrency addresses.
For users, the takeaway is practical: verify wallet destinations before signing, and review payment activity if you entered details on a potentially affected page. For website operators, the durable fix is operational: know which scripts run on sensitive pages, limit their access where possible, and be ready to remove them without losing the evidence you'll need to investigate.
Third-party tools are often unavoidable. Treat them as part of your security boundary - not as harmless add-ons - and the risk is easier to manage.