DEV Community

Nuria Manuel
Nuria Manuel

Posted on Edited on

A Trusted Software Dependency Was Compromised. What Should You Review Next?

Four engineering questions for investigating third-party software exposure.

On 16 Nov 2026, attackers exploited a vulnerability in Optimizely Web Experimentation, allowing them to impersonate customer users and inject malicious JavaScript into legitimate website scripts.

Researchers at Report URI identified 188 affected scripts across 178 orgs, including major international brands. The malicious code was capable of stealing payment information, manipulating cryptocurrency transactions and targeting browser-accessible information.

Optimizely has since fixed the vulnerability and removed the injected code (forensic investigation is ongoing).

But containing the incident doesn't automatically establish what happened on every affected website.

If your application loads a compromised third-party component, how do you establish what it could access and whether anything was actually exposed?

Here are 4 questions engineering teams should investigate:

1. Where does the dependency enter your system?

Start by identifying which applications and pages loaded the affected component.

For the Optimizely incident, the reported exposure window was 07:51–22:24 UTC on 16 November, although individual customer exposure windows may differ.

Review:

  • Public websites and customer-facing applications.
  • Login, account-management and administrative pages.
  • Checkout, payment and cryptocurrency workflows.
  • Shared templates and tag managers that load the same script.

Optimizely has confirmed that Web Experimentation was affected, rather than its other experimentation products. Customers should confirm their individual exposure status and window directly with Optimizely.

What to establish: Which pages loaded the script, when it was active and whether visitors could have received the malicious version.

Historical deployments, tag-manager configurations, archived script responses and browser monitoring records can help reconstruct that picture.

2. What could that dependency access?

Knowing that a script was present doesn't tell you what it could do.

Third-party JavaScript running in a website's context may be able to interact with page content, form fields, browser-readable storage and outbound requests, subject to browser security controls.

For this incident, researchers observed malicious capabilities including payment-card skimming and crypto address manipulation.

That makes the execution context particularly important.

Consider:

  • Could the script access payment details entered directly into the page?
  • Were sensitive tokens or session-related values accessible to JavaScript?
  • Could it send data to unexpected external destinations?
  • Did browser security controls restrict those actions?

Payment details entered inside properly isolated third-party payment iframes are generally inaccessible to scripts running on the parent page. Optimizely's initial investigation also identified that distinction.

What to establish: The information and functionality available to the script, not simply whether the dependency existed.

Importantly, browser-level exposure does not automatically mean an org's backend infrastructure was compromised.

3. Which trust boundaries and safeguards matter?

This is where understanding the wider architecture becomes useful. A third-party script may be supplied by an external organisation but execute within the context of your own website. That creates a trust relationship worth examining.

Review the controls that determine what it can reach and where information can travel.

Content Security Policy (CSP): Does your policy restrict executable scripts and outbound connections? Are directives overly permissive?

Session protection: Are sensitive cookies protected with HttpOnly? Is confidential information unnecessarily exposed to browser-side code?

Data flows: Which payment, authentication and customer-information workflows operate on affected pages?

Isolation: Are sensitive interactions separated from third-party scripts through appropriate browser and application boundaries?

A dependency might have legitimate access to an application while still creating exposure if that access is broader than necessary.

What to establish: Which safeguards were present, whether they were effective and what an attacker could potentially reach through the affected component.

4. What evidence do you actually have?

An architecture diagram can help identify potential exposure, but it can't prove that malicious code executed or that information was stolen.

Incident investigations need historical evidence to examine:

Question Evidence to examine
Was the script loaded? Page captures, deployment records, tag-manager history
Was malicious code delivered? Archived script responses, browser telemetry, monitoring records
Did suspicious communication occur? CSP reports, browser network telemetry, relevant security logs
What could the script access? Page structure, browser controls, application data flows
Was data stolen? Incident-specific forensic evidence and relevant transaction records

It's useful to separate findings into three categories:

  • Confirmed: Direct evidence supports the conclusion.
  • Potentially exposed: The architecture and execution context make exposure technically plausible.
  • Unknown: There isn't enough evidence to determine what happened.

The absence of suspicious logs is not necessarily proof that nothing happened. Some browser-side activity may not appear in server-side monitoring.

For affected Optimizely customers, preserving relevant logs, reviewing payment activity and following the vendor's incident guidance should be immediate priorities.

Where architectural understanding helps

Architectural understanding supports incident-response work by showing how an affected component relates to the wider application.

It helps answer questions such as:

  • Which systems and workflows depend on this component?
  • Where might sensitive information be accessible?
  • Which security boundaries could be affected?
  • What should investigators prioritise?

At Veriom, we're building technology that maintains a living model of software architecture across code, cloud and infrastructure, helping engineering teams understand dependencies, data flows and trust boundaries.

That context can help teams investigate and prioritise structural risks. It doesn't replace browser forensics, incident response or specialist security testing.

The engineering takeaway

When a trusted dependency is compromised, start with four questions:

  1. Where was it loaded, and when?
  2. What could it access or communicate with?
  3. Which trust boundaries and safeguards were involved?
  4. What evidence confirms the impact, and what remains unknown?

A dependency inventory tells you what software you're using. Understanding how that software interacts with the rest of your system helps you assess what a compromise could actually affect.

For teams looking to improve their architectural visibility, explore Veriom.


Sources

Top comments (0)