/

CVE-2025-13371

Severity:

HIGH RISK

(8.6)

Sensitive Information Exposure in MoneySpace WordPress

CVE-2025-13371

Awaiting Analysis

Vulnerability type

Category:

Sensitive Information Exposure

CWE:

CWE-200

Impact:

Exposure of Full Payment Card Data (PAN + CVV)

Severity:

HIGH RISK

(8.6)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

The MoneySpace plugin for WordPress exposes highly sensitive payment card data by embedding full card details in inline JavaScript on a publicly accessible payment link page.

An unauthenticated attacker who can guess or enumerate an order_id can request the mspaylink endpoint and retrieve full credit card numbers, expiry dates, and CVV codes directly from the HTML/JS response, leading to severe privacy, fraud, and PCI-DSS compliance impacts.

Affected context

This vulnerability affects WordPress sites using the MoneySpace plugin where:

  • Payment transactions store full card data (PAN, cardholder name, expiry, CVV) in post_meta.
  • The plugin generates a public-facing mspaylink page that can be accessed using an order_id parameter.
  • Inline JavaScript on the mspaylink page embeds card data sourced directly from post_meta without redaction.

The risk is present whenever the mspaylink endpoint is reachable over the internet and order identifiers can be guessed, enumerated, or intercepted.

Exploit preconditions

  • Attack surface: Public web endpoint (mspaylink) on the affected WordPress site.
  • Required access: No authentication required; only HTTP(S) access to the site.
  • Attacker knowledge: Ability to know, guess, or systematically enumerate valid order_id values.
  • Trigger point: HTTP GET or POST request to the mspaylink endpoint with a valid order_id.
  • Why exploitation is possible: The plugin persists full card data in WordPress post_meta and injects it into inline JavaScript on a page that is not gated by any authentication, authorization, or access token mechanism. Base64 encoding is used, which is reversible and does not provide any cryptographic protection.

Why this happens

The core issue aligns with CWE-200: Exposure of Sensitive Information to an Unauthorized Actor and stems from treating extremely sensitive payment card data as ordinary application data.

Insecure design decisions include:

  • Persisting full cardholder data (including PAN and CVV) in the standard WordPress database layer (post_meta) instead of using a secure, segregated storage or, ideally, not storing such data at all.
  • Treating base64 encoding as if it were a security control, rather than a reversible data representation.
  • Rendering raw card data into client-side JavaScript variables on a publicly accessible endpoint, with no authentication, authorization, or one-time token controls.

Abstractly, this represents a pattern where sensitive data is:

  1. Collected in full,
  2. Stored in an environment not designed for such data, and
  3. Exposed to all callers through a predictable, unauthenticated API or page render.

Potential impact

  • Theft of full primary account numbers (PAN), expiry dates, and CVV values.
  • Large-scale card-not-present fraud using harvested card data.
  • Long-term compromise of customers' financial information if data is logged, cached, or scraped.
  • Severe PCI-DSS non-compliance with potential fines, mandated audits, and loss of card processing privileges.
  • Legal and regulatory exposure under data protection laws (e.g., privacy regulations) due to unauthorized disclosure of financial data.
  • Significant reputational damage and loss of customer trust for affected merchants and site owners.

General mitigation guidance

Effective mitigation focuses on data minimization, segregated secure storage, and access control by design:

  • Eliminate storage of full card data:
  • Avoid storing PAN and CVV in the application database altogether; offload payment handling to PCI-compliant payment gateways using tokenization.
  • If some card data must be retained for user experience or reconciliation, store only truncated or tokenized values (e.g., last 4 digits) without CVV.
  • Redesign client-server boundaries:
  • Ensure sensitive data is never rendered into HTML or JavaScript on client-facing pages.
  • Use opaque tokens or references that the backend resolves securely, without sending raw card data to the browser.
  • Apply strong access control around any sensitive artifacts:
  • Gate all order-related endpoints behind authentication and robust authorization checks, not just knowledge of an order_id.
  • Use unguessable, high-entropy identifiers or signed tokens for any public payment links to prevent enumeration.
  • Harden data handling in the application stack:
  • Treat cardholder data as highly sensitive: restrict database access, disable unnecessary logging, and avoid including it in caches or analytics.
  • Apply strict data retention and deletion policies for any payment-related records.
  • Follow PCI-DSS-aligned patterns:
  • Rely on PCI-compliant providers and SDKs for payment flows, leveraging client-side tokenization or hosted payment pages where possible.
  • Limit the application's role to handling tokens and non-sensitive metadata rather than raw card details.

How teams detect issues like this

Detection can combine code-centric and operational approaches:

  • Static and configuration analysis:
  • Scan source code for patterns where PAN-like data, CVV, or other payment fields are:
  • Stored directly in application database models, post_meta, or generic key-value stores.
  • Passed to templates, JavaScript variables, or client-side rendering logic.
  • Flag any use of base64_encode or similar transforms on sensitive fields as potential obfuscation of secret data rather than real encryption.
  • Code review practices:
  • Incorporate explicit checks for handling of payment data in pull requests, ensuring no raw card data surfaces in views, logs, or front-end code.
  • Review access control around payment-related endpoints, verifying that identifiers alone (e.g., order_id) are not used as authorization.
  • Dynamic testing and scanning:
  • Use automated scanners or DAST tools tuned to look for credit card number patterns in HTTP responses, particularly on order or payment pages.
  • Perform manual tests by loading public payment links and inspecting page source and network traffic for card-like data.
  • Policy and tooling integration:
  • Adopt data classification rules in CI/CD that treat payment fields as "restricted" and prevent merging changes that expose them to templates or client-side code.
  • Use centralized secrets and data-loss-prevention (DLP) tooling to detect card data in logs, HTML responses, and database exports.

Sources

SourceLink
github.comgithub.com/MoneySpace-net/money-space-for-Woocommerce/blob/e79d96cfc1b12cece15c6f0b309045403cc6a9d2/view/mspaylink.php#L164
github.comgithub.com/MoneySpace-net/money-space-for-Woocommerce/blob/e79d96cfc1b12cece15c6f0b309045403cc6a9d2/view/mspaylink.php#L232
plugins.trac.wordpress.orgplugins.trac.wordpress.org/browser/money-space/tags/2.13.9/view/mspaylink.php#L232
plugins.trac.wordpress.orgplugins.trac.wordpress.org/browser/money-space/trunk/view/mspaylink.php#L232
plugins.trac.wordpress.orgplugins.trac.wordpress.org/changeset?sfp_email=&sfph_mail=&reponame=&old=3426909%40money-space&new=3426909%40money-space&sfp_email=&sfph_mail=
wordfence.comwordfence.com/threat-intel/vulnerabilities/id/77db827d-9afd-4b59-b0ad-1ad562634c52?source=cve

Frequently asked

questions

Yes. Any remote, unauthenticated user who can reach the affected WordPress site and guess or enumerate valid order_id values can attempt to access the mspaylink endpoint and retrieve embedded payment card data.

No. The described behavior does not enforce authentication or authorization on the mspaylink endpoint. Knowledge or guessing of a valid order_id is sufficient to access the exposed information.

The safest approach is to stop collecting and storing full cardholder data within the application and delegate payment processing to a PCI-compliant provider using tokenization. Any remaining payment-related endpoints should avoid rendering raw card data to the client and must enforce strong, explicit access controls.

Adopt a data-minimization mindset: treat payment information and other secrets as "toxic" data that should not be stored or exposed unless absolutely necessary. Use tokenization and PCI-compliant gateways, implement strict access control on all order/payment endpoints, avoid embedding sensitive data in client-side code, and enforce these rules via secure design reviews, code review checklists, and automated scanning in CI pipelines.

Find out what's already
exploitable in your codebase.