Digital Skimming, Magecart, and Formjacking: How the Attacks Work and a PCI DSS 6.4.3 and 11.6.1 Check Before Black Friday

By Jscrambler 15 min read

According to Recorded Future's Insikt Group, Magecart activity in the first half of 2026 placed greater emphasis on abusing trusted third-party services, such as Google Tag Manager and Stripe, to deliver skimming code and exfiltrate stolen data. That shift matters because a script's source can look legitimate while its behavior is not.

Digital skimming is malicious code that runs in the shopper’s browser and captures payment or personal data as it is entered, before backend controls ever see it. According to Recorded Future’s Insikt Group, Magecart activity in the first half of 2026 placed greater emphasis on abusing trusted third-party services, such as Google Tag Manager and Stripe, to deliver skimming code and exfiltrate stolen data. That shift matters because a script’s source can look legitimate while its behavior is not.

Black Friday falls on November 27 and Cyber Monday on November 30, and many retailers freeze code changes for a peak season that runs through December, so the review window is short. This guide explains how the attacks work, what recent campaigns looked like, where load-time controls stop, what PCI DSS v4 requirements 6.4.3 and 11.6.1 ask for, and an eight-step check you can run on payment pages before and during peak trading.

Key Takeaways

  • Digital skimming is malicious code that runs in the shopper’s browser and captures payment data as it is entered, before backend controls see it.
  • Per Recorded Future’s H1 2026 analysis, Magecart activity placed greater emphasis on abusing trusted third-party services such as Google Tag Manager and Stripe.
  • CSP, SRI, allowlists, and inventories show or constrain what loads. They do not govern what an approved script does once it runs.
  • PCI DSS v4 requirements 6.4.3 and 11.6.1 address payment-page script inventory, authorization, integrity, and tamper detection.
  • A pre-peak review should cover inventory, authorization, field-level access, outbound destinations, behavioral drift, and tamper detection, in that order.

What Is Digital Skimming (and How Do Magecart and Formjacking Fit In)?

Digital skimming, also called web skimming, formjacking, or a Magecart-style attack, uses malicious code on a web page to capture data as a user types it. Most often the target is payment card details at checkout, though personal data can be taken the same way.

The terms overlap and are often used interchangeably:

TermHow it is commonly used
Digital skimming/web skimmingThe general category: code in the page that captures entered data
FormjackingSkimming that targets form fields, such as checkout or login forms
MagecartThe name used for skimming campaigns, originally associated with attacks on online stores, and now used as shorthand for Magecart-style attacks

The mechanism sits at what Jscrambler calls the point of creation: the browser, where customer data is assembled, and application logic executes. Enterprise security has traditionally stopped at the edge, meaning networks, servers, APIs, and cloud platforms. Execution continues beyond it. A skimmer exploits that gap.

Nothing crashes and no alert fires. The checkout works, the order completes, and the data quietly leaves. The consequence is data loss that the business may not see until a card network, a customer, or an assessor raises it.

How Does a Skimmer Capture Card Data in the Browser?

A skimmer needs three things: a way to get code onto the payment page, a way to read the data, and a way to send it out. The delivery varies, but the execution steps are consistent.

  1. Delivery. The malicious code reaches the page. It may be injected into a compromised site, loaded through a third-party tag, or delivered through a service the site already trusts.
  2. Capture. Once running on the page, the code reads values from the DOM (the Document Object Model, the browser’s live representation of the page). It can listen to form events, read field values, or draw a convincing replacement form on top of the real one.
  3. Exfiltration. The captured data is sent to a destination the attacker controls, or to a location the attacker can retrieve later.

Scripts loaded into the page itself, including third-party scripts and tags, run with the same privileges as first-party application logic. Code inside a cross-origin iframe, such as a payment provider’s hosted card field, is isolated from the page, which is why attackers hide or cover those iframes instead of reading them. That is why a script that was approved for analytics or payments can read fields it was never meant to touch. Any control that only looks at where code loads from, or whether it changed before loading, does not address that step.

What Have Recent Skimming Campaigns Looked Like?

The campaign details below come from Recorded Future (Insikt Group), H1 2026 Malware and Vulnerability Trends, published September 3, 2026, which links each campaign to the researchers who first reported it. The report does not give campaign dates. We describe only what it states and add no figures of our own.

PlatformTechniqueDelivery and exfiltrationOriginal research
WooCommerceA long-running campaign hid the legitimate Stripe payment form and injected a counterfeit iframe-based payment form; it checked for the WordPress Admin Bar so administrators did not see the skimmerDelivery not stated in the report; data sent out by HTTP POSTSilent Push, cited by Recorded Future
Magento / Adobe CommerceSkimming code loaded through Google Tag Manager, with the payload stored in Stripe customer metadataCard data exfiltrated through Stripe APIsSansec, cited by Recorded Future
Magento / Adobe CommerceSkimming code hidden in SVG elements and run through SVG onload events, showing a counterfeit “Secure Checkout” overlayData sent to attacker-controlled infrastructureSansec, cited by Recorded Future

A separate incident showed the trusted-service pattern on Shopify. On October 10, 2026, developer Roman Zipp reported that clicking Checkout on a Shopify store sent him to a lookalike payment page that captured card details and then passed him on to the real checkout. The app vendors HulkApps, Logbase (Selleasy) and Swym later said an unauthorized party had changed what their storefront apps loaded on some stores. The redirect fired on the storefront before Shopify’s checkout loaded, and the public reporting does not say Shopify’s own checkout was breached. A similar incident involving two Qikify apps was detected and fixed on July 22, 2026.

Server-side compromise is the other classic delivery route. On October 21, 2026, PHP released fixes for two critical flaws known as PHP2Shell (CVE-2026-109618 and CVE-2026-109619), which allow unauthenticated remote code execution on PHP versions from 5.4 onward. The fixed releases are PHP 8.5.12, 8.4.27, 8.3.36 and 8.2.35; older branches no longer receive official fixes. PHP is the language WooCommerce and Magento / Adobe Commerce run on. Amazon Threat Intelligence reported exploitation attempts from October 17, four days before the fixes, and successful exploitation in the wild has since been reported. The public reporting we have reviewed does not describe skimmers planted through PHP2Shell. The point for payment pages is narrower: patching closes the hole, but it does not remove code an attacker may have added before the patch.

What this suggests (our inference, not a finding of the report). In the Google Tag Manager and Stripe campaign, and in the Shopify incident, the attackers worked through services that sites and security tools already treat as legitimate. The other two campaigns hid code inside the page itself. If the trusted-service pattern holds more broadly, then allow-listing a source does not settle what the code from that source is allowed to do. A control that asks “is this domain trusted?” answers a different question from “should this script read the card number field and send it somewhere?”

Why Do CSP, SRI and Allowlists Miss Runtime Behavior?

Many teams already have good controls in place, and Recorded Future’s recommendations include strict CSP, script inventories, and payment-page integrity monitoring. The report also advises reviewing CSP rules so trusted third-party services do not become broad allowlist paths for skimming, which is what happens when card data leaves through an allowed payment API. Each control does useful work, and each has a limit.

ControlWhat it does wellWhere it stopsRelevance to 6.4.3 and 11.6.1
CSPLimits where scripts can load from and where the page can send data, including for scripts injected laterDoesn’t govern what an allowed script reads on the page; can’t stop data going to a destination the policy allowsSupports part of an inventory and authorization story; violation reports are not a behavior record
SRIConfirms a script wasn’t modified before loadingDoesn’t cover what the script does, or scripts that load other scriptsHelps with integrity at load time only
AllowlistsDefine which sources are approvedDon’t govern behavior of approved sourcesSupports authorization records
Integrity and change monitoringShows when a page, a script or a header changesDepends on a response step after the finding; doesn’t limit what a running script can doSupports 11.6.1 tamper detection
SBOM / SCAAssess components during development and buildThird-party code that arrives after deployment is outside their viewLimited for payment-page scripts
Runtime enforcement (Client-Side Security Platform)Governs which scripts access which data and which destinations are permitted during live sessionsComplements, and doesn’t replace, the controls above; depends on the quality of the policyProvides inventory, enforcement decisions and continuous evidence

CSP and SRI strengthen load integrity. CSP violation reports show what a policy blocked, but neither control produces the script inventory, justification, or behavior record an assessor reviews. A WAF (web application firewall) secures the doorway and does not control what happens inside the room. Visibility tells you what happened. Client-Side Security governs what is allowed to happen. These approaches work together: detection finds what you did not expect, and enforcement constrains what scripts can do while it matters.

What Do PCI DSS v4 Requirements 6.4.3 and 11.6.1 Ask For?

PCI DSS v4 explicitly extends payment security into the browser. Two requirements apply to payment pages, and both are in effect:

  • Requirement 6.4.3 covers payment-page script inventory, authorization, justification, and integrity assurance.
  • Requirement 11.6.1 covers a change- and tamper-detection mechanism that alerts on unauthorized changes to security-impacting HTTP headers and to the script contents of payment pages as the shopper’s browser receives them, run at least weekly or at a frequency set by a targeted risk analysis.

Read them as a loop: know what runs, justify it, keep it intact, and notice when it changes. 6.4.3 asks you to know which scripts run on payment pages and to be able to say why each is there and that it is authorized. 11.6.1 asks you to detect when payment-page scripts or security-impacting headers change in ways nobody authorized.

An inventory and tamper detection are necessary but do not, by themselves, limit what an authorized script can read or send during a live transaction. That is the gap between documented compliance and demonstrable enforcement. Jscrambler supports and accelerates meeting these requirements by adding runtime control over what scripts can access and transmit, and by producing audit-ready evidence. It does not make an organization compliant on its own, and compliance remains an assessment outcome.

How Do You Run a Pre-Peak Check on a Payment Page?

Work through these steps in order, ideally before November 27 and in any case before your peak-season change freeze. Steps 1, 2, and 6 map directly to requirements 6.4.3 and 11.6.1. Steps 3, 4 and 5 go beyond the minimum the requirements set, into what scripts are allowed to do at runtime. Steps 7 and 8 test the result and prepare the evidence.

1. Build the real inventory, including fourth parties

List every script that executes on each payment page as it runs in production. Include scripts loaded by other scripts. Compare the live list against your tag manager configuration, since shadow tags are scripts added outside formal review, often through tag managers. (6.4.3)

2. Authorize and justify each script

Record why each script is on the page and who approved it. Remove anything without a business reason before peak, because every extra script is more surface to govern. (6.4.3)

3. Apply least-privilege access to payment and identity fields

Decide which scripts may read card, login, and form fields, and which may not. Analytics and advertising tags rarely need payment fields. Field-level access controls are the mechanism: they restrict which scripts can see which fields, cookies, storage, and page elements. A page-type policy is a good model. For example, a login page may allow email access, while a payment page allows no vendor to read data. (Beyond the requirement; strengthens 6.4.3)

4. Define permitted outbound destinations

List which data types may go to which destinations, and block the rest. Skimming ends with data leaving the browser, so network exfiltration control is where the policy has effect. (Beyond the requirement)

5. Set a baseline and watch for behavioral drift

Record normal script behavior now, then flag deviations. Vendors update code without notice, and a script approved last quarter may behave differently today. Look beyond the source: a trusted domain or an approved vendor does not settle what its code may do. Decide who responds to a drift alert during the holiday freeze, and how fast. (Beyond the requirement; complements 11.6.1)

6. Cover headers and page tampering, including after server patches

Confirm you detect unauthorized changes to payment pages and to HTTP headers, and that the alerts reach a team that can act. If you patched PHP recently for PHP2Shell, compare what your payment pages serve now against your approved inventory, going back to before the patch date, because exploitation attempts began before the fixes were released and a patch does not remove code added before it. If your SOC uses a SIEM (security information and event management), confirm that client-side events flow into it. (11.6.1)

7. Test the shopper journey, not just the script list

Walk the checkout flow as a shopper would, on the browsers and devices your customers use. Confirm that nothing sends the shopper away from your payment flow, and rehearse how you would block a script’s behavior without waiting on an emergency code release. 

8. Generate evidence now, not at audit time

Export the inventory, authorizations, blocked behaviors, and change history so the evidence is ready for your QSA (Qualified Security Assessor) or SAQ review.

Where Does Runtime Enforcement Fit in This Check?

Jscrambler gives you the runtime layer for steps 1 through 6, and the assessment-ready evidence for step 8. The Jscrambler Client-Side Security Platform governs how applications execute and how sensitive data is accessed and transmitted at the point of creation, inside the browser.

  • Continuous discovery of third-party and fourth-party scripts, with data access mapping across login fields, payment fields, cookies, browser storage, and forms.
  • Granular data access controls and network exfiltration control (Data, Form, Cookie, Browser Storage and Element Fencing), which restricts what each script can see and transfer.
  • Behavioral drift detection, which flags when an approved script starts doing something new.
  • A PCI DSS v4 module addressing 6.4.3 and 11.6.1, with assessment-ready reports for QSAs.
  • Fine-grained blocking that targets problematic behavior while preserving page functionality.
  • Telemetry and SIEM integration (Splunk, Microsoft Sentinel, IBM QRadar, Securonix, Exabeam) so client-side events reach the SOC.

For deployment, you can start agentless for fast discovery and inventory, then deploy the hardened agent for runtime enforcement. The agent deploys like any tag, through Google Tag Manager, Ensighten, CommandersAct, or Tealium. You can go live in days, then tune policies in a staging environment before enforcing them. Delegated Compliance is available if you want Jscrambler to manage script authorization workflows for 6.4.3 and 11.6.1. Jscrambler publishes a 90% reduction in third-party script authorizations and 50K+ runtime events processed per minute.

For payment service providers, Iframe Integrity protects the payment iframes they serve to merchants against hijacking and overlays, the techniques skimmers use against hosted payment fields. Under PCI DSS v4.0.1, PSPs can confirm SAQ A eligibility on their merchants’ behalf (PCI SSC FAQ 1588), and Iframe Integrity gives them the technical basis to do so, with no merchant action required.

FAQ

What is the difference between Magecart, formjacking and digital skimming?

They describe closely related activity. Digital skimming (or web skimming) is the general term for malicious code that captures data entered into a web page. Formjacking refers to skimming that targets form fields. Magecart is the name used for skimming campaigns and is often used as shorthand for Magecart-style attacks.

Do CSP and SRI stop web skimming or satisfy PCI DSS 6.4.3 and 11.6.1?

They reduce exposure and support parts of an authorization and integrity story, such as approved sources and unmodified files at load time, so they are worth having. They do not govern what an approved script reads once it runs, and they neither produce the inventory, justification, nor behavior record an assessor reviews. A skimmer delivered through a source the policy allows can still read fields and send data to a destination the policy allows. Assessors look for inventory, authorization, integrity assurance, and tamper detection, so confirm your approach with your QSA.

How do I know if a skimmer is running on my checkout page?

Skimmers are designed not to disrupt checkout, so the page often looks normal. Useful signals include unexpected scripts in your inventory, changes to scripts or headers, and data being sent to unfamiliar destinations. Continuous inventory and tamper detection help surface these, and runtime telemetry feeds investigation.

Is a skimmer on a trusted third-party service still my responsibility?

In general, a script that runs on your payment page runs in your customer’s session, on your site, so your team needs to control and evidence what it does there. How responsibility is allocated for PCI purposes is a question for your QSA.

Can we get ready before Black Friday if we haven’t started?

You can make meaningful progress in days. Start agentless for fast discovery and inventory, then tune policies and add the agent as you gain confidence. Prioritize payment pages first. Your QSA decides whether your controls meet the requirements, so involve them early.

Conclusion

Skimming is an execution problem in the browser, not only a delivery problem. Policy stops at the edge while execution continues in the browser, and the recent campaigns described here lean on services and code paths that teams already trust. The practical answer is layered: keep inventories, CSP, SRI and integrity monitoring, and add runtime control over what scripts can access and transmit. A few focused steps before and during peak season will leave you with enforced policy and evidence you can show an assessor.

See how Jscrambler enforces payment-page policy in your own environment.

Book a Demo Today