The checkout is the most sensitive page of any online shop: this is exactly where customers enter their card number, address and payment details – and exactly where Magecart groups strike. In so-called web skimming, attackers inject a few lines of JavaScript into the payment page that silently read every entry and send it off to a foreign domain. The threat remains high: security researchers record around 30 new skimmer signatures per day (Sansec). This article covers entry points, warning signs, the introduction of CSP and SRI, operations and the incident procedure.
What Magecart and Web Skimming Actually Are
Magecart is not a single tool but an umbrella term for numerous criminal groups that have been stealing payment data directly from buyers' browsers for about a decade. The method is called web skimming or formjacking: attackers place tampered JavaScript on the checkout or payment page that reads the entered card and address data in real time and sends it to a server they control. The term alludes to the classic card readers on ATMs – only here the capture is purely digital and completely invisible to the customer.
In its effect, web skimming is a client-side attack: the malicious code reads along in the visitor's browser. The break-in that puts it there, however, often happens on the server – through a vulnerable extension, a stolen password or a misconfiguration. Of 234 cases examined, Sansec attributed around 64% to the backend or server (Sansec 2022). This explains why skimmers often remain undetected for months: a network that Silent Push exposed in January 2026 had been active since at least January 2022 and targeted at least six major card networks (Silent Push).
The payment page is naturally where personal and financial data converge. A single compromised script is enough to grab the card number, expiry date and security code on every purchase. Because modern shops embed numerous third-party scripts – analytics, chat, tag managers, payment SDKs –, each additional inclusion enlarges the checkout's attack surface.
How the Threat Landscape Is Developing in 2026
Web skimming is an industrially run business model: Sansec adds an average of 30 new skimmer signatures to its scanner every day (Sansec). For 2025, Recorded Future counted more than 10,500 active skimming infections, through which more than 23 million transactions were compromised (Recorded Future). According to the same analysis, the impact of Magecart did not visibly decrease after the new PCI requirements took effect in early 2025 (Recorded Future). The PCI Security Standards Council also states that e-skimming attacks have increased significantly in recent years (PCI SSC).
Every embedded third-party resource is a potential entry point. Skimming kits are cheap and easy to operate: a single kit offered on the dark web accounted for 26% of all observed infections in 2025 (Recorded Future). At the same time, campaigns hide their code in invisible graphics or disguise it as an analytics or tag manager script. Anyone keeping an eye on the Cyber Resilience Act and its obligations quickly sees that product security goes beyond mere server configuration.
A compromised checkout costs more than stolen card data. Add chargebacks, possible penalties from payment providers, notification duties under the GDPR and – often most expensive – the loss of customer trust. Because skimmers tend to remain undetected for a long time, the damage accumulates over the entire duration of the infection.
How a Skimmer Reaches the Checkout
The cases from 2024 to 2026 show five recurring entry points:
- Vulnerable shop software and extensions: known vulnerabilities in the shop system, plugins or themes are the standard entry point: at the end of March 2026, 471 stores were compromised within one hour through a single vulnerability (Sansec). At the end of August 2026, Shopware also closed a vulnerability in the Store API through which an unauthenticated attacker with a sales channel key could manipulate database queries (Shopware). Anyone still using an end-of-life version should not postpone the migration away from Shopware 5.
- Hijacked third-party scripts: if the domain of an embedded script changes hands, the code changes with it: in June 2024, a widely used polyfill library delivered malware to more than 100,000 websites after its domain had been sold (Sansec). At the end of October 2026, attackers appended a skimmer to the tracking script of an outdated analytics server that every checkout of a shop platform loaded (Sansec).
- Admin accounts without a second factor: a guessed or phished password opens the administration and with it the theme and content blocks. Security researchers recommend two-factor authentication along with training against targeted phishing (Sansec); more on this in the article Zero Trust for online shops.
- Supply chain and central platforms: a tampered dependency hits many shops at once. In 2025, a skimmer reached more than 160 business customers through the code repositories of a reservation platform (Recorded Future). How to secure package sources is shown in the article on supply chain attacks on the shop stack.
- Faked payment infrastructure: one skimmer network ran more than 4,800 fake shop storefronts on .shop domains that imitated well-known brands (Sansec).
Several of these routes require no break-in to the shop server. Where there is a break-in, the malicious code often sits not in a file but in the database – for example in CMS pages and content blocks into which attackers write obfuscated JavaScript (Sansec). Purely file-based checks therefore fall short.
Warning Signs: How to Spot a Compromised Checkout
Because the malicious code runs in the browser, monitoring the delivered page is decisive. A pure server scan is not enough, because the malicious third-party script often does not sit on your server at all. These signals point to a compromise:
- Unexpected outbound connections: the payment page contacts an unknown domain.
- Changed script contents: the checksum (hash) of an embedded script deviates from the approved version.
- Unknown script tags in the checkout source code – including event attributes such as
onloadon inconspicuous elements. - Script code in the database: JavaScript in content blocks or theme settings that no one approved.
- Unknown administrator accounts: new users, unusual password resets or API access that cannot be attributed.
- Content Security Policy violations in the browser or in reports.
- A cluster of fraud reports: customers report fraudulent card charges. A systematic fraud detection approach makes such patterns visible earlier.
A file integrity check on the server detects changes to your own files – but neither a script that is tampered with on a foreign domain nor malicious code in the database. The checkout needs both: checks on the server and monitoring of the page as it is actually delivered in the browser.
Protection with a Script Inventory, CSP and SRI
No single measure defeats web skimming; it takes an interplay of several building blocks. They all pursue the same goal: only explicitly approved scripts may run in the checkout, and any unauthorized change stands out promptly.
Script inventory
A documented list of all scripts loaded on the payment page – with a justification for why each one is needed. Anything not on the list has no business in the checkout.
Content Security Policy
A CSP header defines which domains scripts may be loaded from and to which destinations data may be sent. A skimmer trying to exfiltrate to a foreign domain is thus blocked by the browser.
Subresource Integrity
With an SRI hash the browser checks whether an external script exactly matches the approved version. If the file was tampered with, the browser refuses to execute it.
Tamper monitoring
Ongoing monitoring of the payment page reports as soon as scripts, HTTP headers or page content change without authorization – the prerequisite for detecting an incident quickly.
Content Security Policy and Subresource Integrity are standard mechanisms in modern browsers and can be introduced step by step. Careful maintenance matters: if a payment provider changes its script, the stored hash must be updated with it. In the programming and development of your shop, these rules therefore belong firmly in the release process. An example of a restrictive policy and an inclusion secured by hash:
<!-- CSP header: only own and explicitly allowed sources -->
<!-- Content-Security-Policy:
default-src 'self';
script-src 'self' https://js.paymentprovider.example;
connect-src 'self' https://api.paymentprovider.example -->
<!-- External script secured via Subresource Integrity -->
<script src="https://js.paymentprovider.example/checkout.js"
integrity="sha384-oqVuAfXRKap7fdgcCY5uykM6+R9GqQ8K9dEXamplEhaSh"
crossorigin="anonymous"></script> It also helps to keep the number of third-party scripts fundamentally small. Every script that is not loaded cannot be compromised either. Anyone who trims their shop of unnecessary third-party scripts improves both the load time and the security of the checkout at the same time.
Introduce CSP in Report-Only Mode First
A policy that is enforced without testing can block the checkout itself, for example when a payment provider loads another domain for the bank's authentication step. The practical route is report-only mode: the Content-Security-Policy-Report-Only header makes the browser report every violation without blocking anything. Real orders thus produce the list of sources the checkout actually needs.
- Draft: derive the required domains for
script-src,connect-src,frame-srcandform-actionfrom the script inventory. - Roll out in report-only mode: first for the cart, checkout and order confirmation.
- Walk through every path: each payment method, guest checkout, vouchers and the bank authentication there and back.
- Evaluate: add expected sources, clarify unknown destinations – a report about a foreign domain may be the first sign of a skimmer.
- Enforce: set the tested policy as
Content-Security-Policyand keep evaluating reports viareport-urior the newerreport-to.
# 1. report-only mode
Content-Security-Policy-Report-Only:
default-src 'self';
script-src 'self' 'nonce-{random-value}' https://js.paymentprovider.example;
connect-src 'self' https://api.paymentprovider.example;
frame-src https://pay.paymentprovider.example;
form-action 'self' https://pay.paymentprovider.example;
report-uri /csp-reports
# 2. enforce after evaluation
Content-Security-Policy: ... Nonces Instead of unsafe-inline in the Shopware Theme
A strict policy usually gets difficult with inline scripts. Allowing them across the board with 'unsafe-inline' opens the door skimmers use: the SVG campaign of April 2026 placed the entire malicious code in the onload attribute of an invisible element to avoid conspicuous external script references (Sansec) and hit 99 stores that way (Sansec). A policy without 'unsafe-inline' blocks such inline event attributes.
The clean route is nonces: the server generates a random value per page request and writes it into the CSP header and into the nonce attribute of every approved script tag. In Shopware, the defaults for Content Security Policies are set via the container parameter shopware.security.csp_templates and can be adjusted there (Shopware). For your own theme, this means:
- Find inline scripts: search the Twig templates of the theme and plugins for
<script>blocks and event attributes such asonclick. - Move out or mark: move inline code into JavaScript files; whatever must stay inline gets the nonce of the request.
- Mind the page cache: if a reverse proxy serves the same response several times, the nonce is reused and loses most of its protective effect.
- Check plugin updates: test new versions in report-only mode on the staging environment first.
Tag Managers: The Open Flank of the Policy
Tag managers load scripts that can be changed in the provider's portal at any time – bypassing your approval. An SRI hash is not possible for this, and 'strict-dynamic' passes trust on to everything an approved script loads. In May 2026, attackers disguised a skimmer as a tag manager loader that looked like ordinary analytics next to the real marketing tags (Sansec); as early as 2025, tag containers served as a loading and relay stage for skimmers (Recorded Future).
- Keep them away from the checkout: deliver the payment steps without a container, measure conversions only on the order confirmation.
- Treat containers like code: few publishing rights, two-factor authentication, changes only with approval.
- Add them to the script inventory: every tag with its purpose and a responsible person.
In March 2026, researchers described a skimmer that exfiltrated card data via WebRTC data channels – connections that lie outside the scope of Content Security Policy and are not covered by connect-src (Sansec). The policy is therefore one building block, not a substitute for an inventory, change detection and prompt updates.
PCI DSS 6.4.3 and 11.6.1: Checkout Integrity Is Mandatory
For merchants that accept card payments, protecting the payment page is a requirement of the card brands. The relevant version today is PCI DSS 4.0.1; the previous version 4.0 was retired on 31 December 2024 (PCI SSC). Two requirements target web skimming directly and have applied since 31 March 2025 (PCI SSC). Our article PCI DSS 4.0 for online shops summarizes the remaining obligations.
| Requirement | What it demands | Goal |
|---|---|---|
| 6.4.3 | Authorization, integrity assurance and a justified inventory of all payment-page scripts | Only authorized scripts run |
| 11.6.1 | Tamper detection for the HTTP headers and content of the payment page as received by the browser | Changes stand out promptly |
Requirement 6.4.3 demands that all payment-page scripts loaded and executed in the browser are authorized, that their integrity is assured and that an inventory with a written justification for each script exists (PCI SSC). Requirement 11.6.1 demands a mechanism that detects unauthorized changes to the HTTP headers and content of the payment page and reports them – at least once every seven days or at the frequency of a targeted risk analysis (PCI SSC). Version 4.0.1 added applicability notes to 6.4.3; it contains no new or deleted requirements (PCI SSC).
Embedded Payment Fields and SAQ A: What Changed in 2025
Shops with card fields in a payment service provider's iframe often use the short Self-Assessment Questionnaire (SAQ) A. In January 2025, the PCI SSC removed requirements 6.4.3 and 11.6.1 from SAQ A (PCI SSC). Instead, the merchant must confirm that its site is not susceptible to attacks from scripts that could affect its e-commerce systems (PCI SSC).
The requirements in the standard are neither removed nor diminished by this (PCI SSC). The confirmation can be given in two ways: with techniques such as those in 6.4.3 and 11.6.1, or with a confirmation from the payment provider that its solution protects against script attacks when implemented correctly (PCI SSC). The criterion only applies to embedded payment forms such as iframes (PCI SSC). Which questionnaire applies is determined by the card brands and the acquirer – not by the PCI SSC itself (PCI SSC).
| Integration | Typical validation | What remains for the checkout |
|---|---|---|
| Payment field as the provider's iframe | SAQ A with the new eligibility criterion | Confirm protection against script attacks – own measures or confirmation from the provider |
| Redirect to the provider's payment page | SAQ A, script criterion does not apply | Protect the page before the redirect, because a skimmer can insert a fake intermediate page |
| Own page affects the payment form | SAQ A-EP | 6.4.3 and 11.6.1 apply directly |
SAQ A-EP is intended for merchants whose website does not receive card data but affects the security of the payment or the integrity of the entry page (PCI SSC).
An iframe keeps the card number out of your page code, but not the skimmer off your page: it can place a fake form over the real one and then quietly redirect the customer to the real payment page (Sansec). That is why the entire payment page belongs in the inventory and under monitoring.
A Defense Concept Step by Step
The individual building blocks become resilient protection when they are implemented in a fixed order and maintained continuously. The following sequence has proven itself in practice:
- Inventory: record all scripts on checkout and payment pages and justify for each entry why it is needed.
- Minimize: remove scripts that are no longer needed or duplicated and deliberately keep the number of external inclusions small.
- Harden access: two-factor authentication for the administration, hosting, tag manager and payment portal; remove old accounts.
- Introduce CSP: test a restrictive Content Security Policy in report-only mode first, then enforce it.
- Set SRI: secure external scripts with a Subresource Integrity hash and update the hash with every change.
- Monitor: set up change detection that reports changes to scripts and page content in the delivered state.
- Patch: keep the shop system and extensions up to date at a fixed cadence; an experienced Shopware agency can roll out updates in a planned and tested manner.
- Respond: define a procedure for an emergency – from preserving the evidence to a restore from a tested backup.
No single step replaces the others. Only the interplay of reduction, rules and monitoring makes the checkout resilient. And because attacks and embedded services change constantly, security is not a one-off project but an ongoing operational process – comparable to the continuous shop monitoring for availability and performance.
In Operation: Integrity Checks, Monitoring and Update Cadence
Every plugin update and every new marketing tag shifts the target state of the checkout. For critical vulnerabilities, PCI DSS 4.0.1 provides for installing patches within 30 days (PCI SSC); for actively exploited vulnerabilities, a much shorter cadence is advisable. This rhythm has proven itself:
| Routine | Cadence | What matters |
|---|---|---|
| Integrity check on the server | daily and after every update | Checksums of core, plugin and theme files plus database fields in which scripts can be stored |
| Change detection on the payment page | at least once every seven days, preferably daily | Check scripts and headers as the browser receives them; every alert has an owner |
| Security advisories and patches | continuously; critical patches within 30 days | Close actively exploited vulnerabilities immediately |
| Reconcile the script inventory | with every change to the checkout | New tags and plugin scripts only after approval |
| CSP reports, accounts and access | weekly to monthly | Clarify unknown destinations, users and tokens |
How tight this cadence needs to be is shown by the Store API vulnerability of August 2026: affected were Shopware 6.7.0.0 through 6.7.13.0 and all releases before 6.6.10.23, and it is fixed in 6.7.13.1 and 6.6.10.23 (Shopware). According to its discoverers, it allowed an administrator account to be taken over and code to be run on the server (Sansec). In headless shops, the sales channel key is public by design and offers no protection (Shopware); more on this under securing the Store API. The vendor also recommends keeping the Security Plugin active and up to date (Shopware).
Part of this – updates tested in a staging environment first and security patches with high priority – is covered by our Shopware maintenance, along with daily backups in addition to your own data backup and uptime monitoring. The update process with a test environment and a way back is described in the article installing updates and patches in a planned way.
Incident Procedure: What to Do After a Finding
After a finding, the order of the next steps determines the damage – and whether it can later be proven which data was affected. The following procedure serves as guidance and does not replace legal advice:
- Contain: temporarily put the payment page into maintenance mode or disable the affected payment method.
- Preserve evidence: before any cleanup, secure files, database, logs and the delivered checkout page with a timestamp.
- Close the entry point: install updates, change all admin and database passwords, remove suspicious accounts, revoke unknown access tokens (Sansec).
- Clean up: search for backdoors the attackers may have installed in addition (Sansec) and restore from a backup that predates the infection.
- Inform the payment provider and acquirer: PCI DSS requires an incident response plan with communication channels for suspected or confirmed incidents – including notification of the card brands and acquirers (PCI SSC).
- Inform the supervisory authority: under Article 33 GDPR, a data breach must be reported without undue delay and, where feasible, within 72 hours of becoming aware of it, unless it is unlikely to result in a risk to the people affected (GDPR); with card data including names, that can hardly be assumed. A service provider running the shop or server on your behalf must notify you of breaches without undue delay (GDPR).
- Notify the people affected: if a high risk to them is likely, the affected customers must be notified without undue delay (GDPR) – in clear and plain language, with the nature and likely consequences of the breach, a contact point for further information and the measures taken or proposed (GDPR).
- Document and tighten: every breach must be documented with the facts, its effects and the remedial action taken (GDPR); then adjust the inventory, policy and monitoring.
Anyone who deletes before files, database and logs have been secured loses the basis for the notification: among other things, it should state the categories and approximate number of the people affected (GDPR). Without evidence, both are hard to determine.
Anchoring Checkout Security in Operations Now
Web skimming does not only hit big brands – on the contrary, smaller shops become targets because they less often have their own security processes. The good news is that the checkout can be hardened significantly with manageable, proven measures. What matters is that the script inventory, CSP, SRI, update cadence and incident procedure are firmly anchored in day-to-day operations.
Checkout hardening
We set up the script inventory, Content Security Policy and SRI hashes to match your theme and payment methods.
Hosting and updates
In the hosting and maintenance by XICTRON, we keep servers, the shop system and extensions up to date and install security patches by priority.
Payment-page monitoring
Uptime monitoring is part of maintenance. How change detection for scripts and headers under PCI DSS 11.6.1 fits into your shop is something we clarify in the initial consultation.
A prepared emergency
A documented incident procedure with responsibilities and reporting channels shortens the response time.
Automated and regulatory checks are increasing as well – anyone who takes technical diligence seriously is also better prepared for reviews such as the automated BFSG scan. We review the state of your payment page, set up CSP, SRI and a script inventory and anchor updates and checks in Shopware maintenance. Talk to our team to set up your shop's checkout security in a planned way.
This article draws on analyses by Sansec (signatures, case shares in 2022, polyfill in 2024, skimmer campaigns in 2026), Silent Push (network active since 2022), Recorded Future (infections and kits in 2025), the security advisory and documentation of Shopware, the publications of the PCI Security Standards Council on PCI DSS 4.0.1, requirements 6.4.3, 11.6.1 and 12.10.1 and SAQ A, and Articles 33 and 34 of the GDPR. Figures may change; this article does not replace legal advice. As of November 2026.
Attackers inject JavaScript into a shop's payment page that reads card and address data and sends it to a foreign server; Magecart is the umbrella term for the groups behind it. The code runs in the customer's browser, but the break-in often happens via the server, for example through a vulnerable extension. That is why checks are needed on both sides.
First contain it and secure files, database and logs before any cleanup. Then close the entry point, change passwords and restore from a clean backup. Inform the payment provider and acquirer early. The data breach usually has to be reported to the supervisory authority without undue delay and, where feasible, within 72 hours (GDPR); in the case of a high risk, the people affected must be notified as well.
The policy defines where scripts may load from and where data may flow; Subresource Integrity only lets the approved version of an external script run. Typically, the policy starts in report-only mode, which reports violations without blocking, and is enforced once all payment methods run cleanly.
Requirement 6.4.3 demands authorized scripts on the payment page, assured integrity and a justified inventory. Requirement 11.6.1 demands tamper detection for the HTTP headers and content of the payment page, performed at least once every seven days or according to a targeted risk analysis (PCI SSC). Both have applied since 31 March 2025.
The PCI SSC removed both requirements from SAQ A in January 2025. In return, merchants confirm that their site is not susceptible to attacks from scripts – with their own protective measures or a confirmation from the payment provider (PCI SSC). The requirements in the standard itself remain in place.
We record the scripts on your payment page, remove unnecessary inclusions and set up Content Security Policy and Subresource Integrity. As part of Shopware maintenance, we keep the shop system and extensions up to date and install security patches by priority after testing; how change detection and the incident procedure fit your shop is something we clarify in the initial consultation.