Tag: Evidencing

  • WordPress PCI Compliance: What Applies to Your Payment Page

    WordPress PCI Compliance: What Applies to Your Payment Page

    What this guide covers

    1. 01Work out what actually applies to you
    2. 02Understand the two requirements that reach your page
    3. 03Decide what to do next

    The short answer, and who it applies to

    PCI DSS certifies a payment environment, not a CMS, and cares about how the payment page is built and operated, not which software renders it. WooCommerce’s own documentation puts it plainly: “PCI DSS compliance is ultimately the responsibility of the store owner.”

    A checkout sits in one of three architectures: a full redirect to the processor’s hosted page, an embedded field on your own page, or self-hosted fields touching the card number directly. Most WooCommerce stores using Stripe Elements, the Stripe Payment Element, or WooPayments sit in the middle case. WooCommerce’s Stripe documentation confirms that “most merchants can use Self-Assessment Questionnaire (SAQ) A for validation,” though the processor or acquirer can still require a different SAQ. PCI DSS is a card brand standard, not a national law, so a UK store and a US store answer the same requirements; only the acquirer relationship and questionnaire differ.

    Who operates the checkout day to day is a separate question, and it is what ongoing WordPress security work covers.

    Verification step

    Check which payment method your store renders, an embedded field from the processor’s domain or a redirect that sends the shopper off-site, before assuming the questionnaire.

    How PCI scope is decided on a WordPress checkout

    Where the card number goes, and why that reduces your scope

    With an embedded field, the card input is rendered inside an iframe served from the processor’s own domain, though it sits inside your checkout page. Your JavaScript receives a token, not a card number, and your server never stores card details.

    The SAQ A e-commerce channel requirement states this directly: “all elements of the payment page(s)/form(s) delivered to the customer’s browser originate only and directly from a PCI DSS compliant TPSP/payment processor.” Meeting it keeps a merchant on the reduced SAQ A path rather than a longer questionnaire.

    Three checkout architectures
    Where PCI scope falls in each

    Full redirect

    Card enteredOn the processor’s own hosted page, off your site
    Your server seesNothing card-related
    Typical SAQOften SAQ A, lower-touch category

    Embedded processor field

    Card enteredIn an iframe from the processor’s domain, inside your page
    Your server seesA token only, never the card number
    Typical SAQSAQ A, with the 2025 script-attack criterion

    Self-hosted fields

    Card enteredDirectly in your own form fields
    Your server seesThe card number touches your code
    Typical SAQA longer questionnaire, outside this guide’s scope
    Shaded across all three: the scripts running on this page are yours, regardless of architecture.

    SAQ labels are typical indications, not guarantees. The acquirer makes the final call on which questionnaire applies, and no NoDrama service is claimed to satisfy any of these requirements.

    Diagram comparing three WordPress checkout architectures and where PCI scope falls in each.

    What changed for SAQ A in 2025

    SAQ A now carries an added eligibility criterion: the merchant has to confirm “that their site is not susceptible to attacks from scripts that could affect the merchant’s e-commerce system(s),” alongside the existing criteria rather than replacing them. The future-dated requirements in PCI DSS v4.x, including this criterion, took effect on 31 March 2025, per the PCI Security Standards Council.

    There are two ways to satisfy it: implement 6.4.3 and 11.6.1 yourself, or rely on written confirmation that the processor’s embedded solution already includes those protections, implemented per its instructions. The PCI SSC’s FAQ and the SAQ A form set out both routes. Neither 6.4.3 nor 11.6.1 has published clause text available outside the standard itself, so this guide describes what each asks for rather than quoting it.

    Verification step

    Ask your processor, in writing, whether it provides the script-attack confirmation for your integration. A written answer is the artefact worth keeping, not a support chat note.

    What requirements 6.4.3 and 11.6.1 ask of the page around the card fields

    What it asks for What it is watching What satisfies it in practice
    6.4.3Script inventory An inventory of every authorised script on the payment page, a justification for each What executes in the browser, not the card data itself A maintained list, and a way to confirm each script’s integrity
    11.6.1Change detection A mechanism that checks the page’s HTTP headers and content against a baseline Unauthorised changes to the served page, at least weekly or per a targeted risk analysis A scheduled diff against the baseline, with an alert someone actually reads
    Table comparing the script inventory requirement and the change detection requirement for a payment page. Description only, since no verbatim clause text of either requirement was sourced.

    6.4.3, the script inventory

    This requirement governs what executes in the browser on the payment page, not the card data. It asks for an inventory of every authorised script, a justification for each, and a way to confirm its integrity. In WordPress terms, every plugin, theme change, or tag manager snippet on the checkout template has to be on a list somebody maintains.

    11.6.1, the change and tamper detection

    This requirement asks for a mechanism that checks the payment page’s HTTP headers and content against a baseline and alerts someone to unauthorised changes, at least weekly or at the frequency a targeted risk analysis sets. Stated plainly, something has to diff the served page on a schedule, and somebody has to receive the alert.

    Why rollback and a CDN are not the same control

    Rollback with tested updates answers whether a change broke the page. Tamper detection answers whether an unauthorised script was added at all, between updates. A CDN serves cached assets and filters some injection at the edge, but it does not inventory checkout scripts, and neither control satisfies 6.4.3 or 11.6.1 alone. A record of authorised changes looks closer to the record NoDrama hands over for other maintenance work. That record is not a claim of 6.4.3 or 11.6.1 coverage.

    Verification step

    Open your checkout page in a browser, view the network requests, and list every domain a script loads from. That is the starting point of the 6.4.3 inventory.

    What good looks like on a WooCommerce checkout

    A few markers separate a checkout page that could answer the new SAQ A criterion from one that could not.


    What a change record on the payment page contains

    • A named list of scripts on the checkout template, with a reason for each and a reviewer for plugin changes.
    • A baseline of the page’s headers and content, checked on a schedule, with an alert someone reads.
    • A change record: what changed, when, and who approved it.
    • Written confirmation from the processor, kept on file, if you rely on that route instead of implementing the requirements yourself.

    Backups and off-site copies fit into that record, at how restores and off-site copies are handled.

    Verification step

    Pick the last plugin update that touched checkout, then answer from a record rather than memory: what changed, who tested it, and when the page was checked.

    What to do about it

    • Confirm which payment architecture your checkout uses: a redirect, an embedded field, or self-hosted fields.
    • Ask your acquirer or processor which SAQ applies, and get the answer in writing.
    • Build the script list for the checkout template from the browser, not the plugin screen.
    • Decide what watches the page between releases and who receives the alert.
    • Decide who tests a plugin update against that page before it goes live.
    Verification step

    Write down the person’s name for each action above. An action with no name is not yet in place.

    Rather not own the update testing yourself? NoDrama tests every update on a staging copy first and sends you a dated monthly record. See the three plans and what each one covers.

    Not sure what is loading on your checkout page?

    Start with NoDrama’s free WordPress audit, no pitch attached.

    Audit My Site

    Common misconceptions

    “Stripe is PCI compliant, so my store is.”

    The processor’s compliance covers its own iframe and infrastructure. Your plugins and theme stay in your scope.

    “A security plugin covers it.”

    A general purpose plugin is not, out of the box, a script inventory or change detection mechanism for the checkout template.

    “Wix would be safer for PCI than WordPress.”

    No primary source compares the platforms on PCI grounds, so this is reasoning from how scope works, not a sourced comparison; scope tracks architecture, not CMS.

    “The site runs fine, so nothing has changed on the page.”

    Fine decays by default, and a script can be added without anything visibly breaking.

    What this does not cover

    This guide is written for merchants using an embedded field or a redirect, self-assessing rather than an external audit. It does not cover merchants whose own code renders card fields, a longer questionnaire, or merchants large enough to need external assessment. It does not carry the verbatim text of requirements 6.4.3 or 11.6.1, linked above rather than quoted. And it cannot tell you which questionnaire your acquirer will accept; that is their call, not something a guide can settle.

    Where this leaves your payment page

    PCI compliance on a WordPress checkout depends on how the payment page is built and whether its scripts are inventoried and watched, not which CMS renders the site. Once you know your architecture and SAQ, the question worth answering is who operates that page between releases.

  • What Are the Security Risks of WordPress?

    What Are the Security Risks of WordPress?

    Contents

    1. 01Understand where the risk actually sits. The short answer, and how it actually works.
    2. 02See why it matters for your site. Why it matters for your situation, and what good security discipline looks like.
    3. 03Know what to do and what still isn’t covered. What to do about it, and the common misconceptions.

    The short answer on WordPress security risks

    Of 11,334 new vulnerabilities disclosed across the WordPress ecosystem in 2025, 91 percent were found in plugins, 9 percent in themes, and only 6 low-priority issues were in core, per Patchstack’s 2026 State of WordPress Security whitepaper. That split is not close. Core’s share is statistically negligible against plugins alone.

    The direct implication follows from the numbers, not from opinion: WordPress the platform is not where the risk sits. The unaudited third-party code running on top of it, chosen and installed by whoever manages the site, is.

    How WordPress security risk actually works

    Why plugins and themes carry the risk core does not

    Core ships from a single, reviewed codebase. It’s maintained by a security team of more than 50 people who backport fixes to older versions rather than forcing every site onto the newest release to stay patched, per the WordPress Security Team’s own review process.

    A plugin or theme is a different situation entirely. It’s an independently authored package, written by a separate developer of whatever skill level they happen to have. WordPress.org’s directory review checks a plugin at submission, but it doesn’t continuously re-audit every version update that ships after that. A plugin that passed review in 2022 can ship a vulnerable update in 2026 with no equivalent second check.

    This is also where the cost math changes. Verified, tested updates catch the failure mode where a legitimate patch breaks something on the live site, which is a different problem from a plugin’s own code carrying a vulnerability in the first place. See what tested, verified updates actually cost to have covered for how that piece works.

    Verify it

    For any plugin you’re evaluating, check whether it names a security team or a documented disclosure process on its own listing page. A plugin with neither has no equivalent of core’s review process behind it.

    The four vulnerability classes behind nearly all plugin and theme issues

    Nearly all of the 91 percent plugin figure and the 9 percent theme figure comes down to four recurring mechanisms, as WordPress’s own definitions of these vulnerability classes lay out.

    SQL injection

    Unsanitized input gets run as a database command instead of passed through a prepared statement.

    Cross-site scripting (XSS)

    Unescaped output lets attacker-supplied JavaScript run in a visitor’s or an admin’s browser.

    Cross-site request forgery (CSRF)

    A state-changing action fires using a logged-in admin’s own session, because the plugin skipped its nonce check.

    Broken access control

    A user reaches an action or a piece of data that should have required a higher capability level.

    Four cards covering SQL injection, XSS, CSRF, and broken access control, each with a one-line description of how it occurs.

    A nonce, in WordPress’s own terminology, is a Number Used Once. It’s the mechanism a plugin is supposed to check before it lets a state-changing action run, and a missing nonce check is what turns a normal admin action into a CSRF opening.

    Verify it

    For a specific plugin, check its own changelog for language like “sanitization,” “escaping,” or “capability check” fixes. That’s usually the tell that one of these four classes got patched in that release.

    Why this matters for a site you are responsible for

    An outdated plugin isn’t a slow decay. It’s a published map. Once a vulnerability is disclosed along with its fix, any site still running the unpatched version becomes identifiable by version fingerprinting and targetable at scale by automated tools, per WordPress’s own hardening guidance, which states plainly that the exploit information for a disclosed vulnerability is almost certainly in the public domain once the fix ships.

    An inactive plugin doesn’t remove that exposure. Its files still execute if they’re present on the server and registered, deactivation just stops the plugin from loading on the front end, it doesn’t delete the code. If you’re not using a plugin, delete it rather than deactivating it and leaving it there.

    The same logic that connects an unmaintained site to slow performance connects it to exploitability: both come from code nobody is watching. See why an unmaintained site slows down the same way it gets exploited for how that overlaps.

    What good security discipline actually looks like

    Running fewer, well-maintained plugins from established developers who patch quickly is a real, measurable reduction in risk. Risk scales with how many separate third-party codebases a site is running, not with running WordPress itself.

    Severity is the other variable worth watching directly. A high-severity vulnerability, 17 percent of 2025’s total per Patchstack, is associated with likely mass-scale, automated exploitation. That’s the practical test for how urgently a given patch matters: a plugin that’s unmaintained, has a large install base, and handles user input or authentication is high-risk regardless of how small it feels in your own stack.

    See what a maintenance plan should actually include for how that discipline gets specified rather than assumed.

    What to do about it

    1. 01Delete plugins you’re not using. Deactivating leaves the files on the server, where they still execute if registered.
    2. 02Check whether a plugin’s developer is still actively patching it. An abandoned plugin stays exploitable no matter how quickly you’d apply an update if one existed.
    3. 03Apply security updates on a defined schedule. Not whenever someone happens to remember.
    4. 04Confirm updates are tested in staging before they go live. A legitimate security patch can still break site functionality when applied blind, which is a different failure than the vulnerability it patches, and both need a fix.

    Not sure how many plugins on your site are still actively maintained?

    Send NoDrama your URL and get a free website audit, no pitch attached.

    Audit My Site

    Verify it

    After any update, confirm the site still renders and the admin dashboard still loads before considering the patch applied. A rollback path only helps if someone checks that it worked.

    Common misconceptions about WordPress security

    “WordPress itself is insecure.”

    Core’s share of 2025’s disclosed vulnerabilities was 6 low-priority issues, statistically negligible against plugins’ 91 percent. The platform isn’t the risk. The unaudited third-party code running on top of it is.

    “A security plugin covers this.”

    A security plugin helps with detection and hardening, but it doesn’t patch a vulnerable plugin’s own code. That code stays vulnerable until its own developer ships a fix, or a virtual-patching rule addresses it in the meantime.

    “Popular plugins are safer.”

    Popularity increases how worthwhile a plugin is to build an automated attack against. It doesn’t guarantee the code was reviewed for the four vulnerability classes above.

    Getting this in writing matters as much as getting it right in practice. See what a maintenance plan should actually specify about updates for the language that closes that gap.

    What this does not solve

    Tested updates and staged rollback catch the case where a legitimate patch breaks something. They don’t find an undisclosed, zero-day vulnerability, and they’re not a substitute for a web application firewall or real-time malware scanning.

    This guide isn’t a claim that any specific site is, or isn’t, currently compromised.

    So, what are the real security risks of running WordPress?

    The risk sits in the plugins and themes running on top of core, not in core itself, and it concentrates further in whatever is outdated, abandoned, or simply numerous. Fewer, actively maintained third-party codebases is the practical lever, not switching platforms.