Back to Intelligence

Third-Party Vendor Breach Hits Chase, Visa, and Mastercard: A Defender's Playbook for Supply-Chain Data Theft

SA
Security Arsenal Team
November 21, 2026
13 min read

J.P. Morgan Chase has begun notifying customers that their personal information and marketing data were exposed — not because Chase's own perimeter failed, but because a third-party service provider was compromised. Visa and Mastercard customer data was caught in the same blast radius. This is the supply-chain breach pattern playing out again in 2025-2026: attackers increasingly skip the hardened front door of a global bank and walk in through a smaller marketing, analytics, or fulfilment vendor that holds the same data with a fraction of the security budget.

If you work in financial services — or any sector that shares customer PII with processors, marketing platforms, print vendors, or analytics firms — this incident is your problem too. The data exposed (names, contact details, and marketing/profile attributes) is exactly the raw material for high-fidelity spear phishing, vishing, and account-takeover pretexting against banking customers. The breach may be 'contained' at the vendor, but the downstream fraud campaigns built on that data are just beginning.

This post breaks down what happened, why vendor breaches are structurally different from direct intrusions, and — most importantly — what your SOC and TPRM program should be doing about it right now.

Technical Analysis

What happened

According to the reporting, J.P. Morgan Chase disclosed that a cyberattack at a third-party service provider resulted in unauthorized access to customer personal information and marketing data. Chase's own systems were not breached — the compromise occurred entirely within the vendor's environment. Visa and Mastercard confirmed that some of their cardholders' information was also exposed through the same vendor, indicating the provider served multiple major financial brands and held commingled customer datasets.

Key characteristics of the incident:

  • Affected parties: Customers of J.P. Morgan Chase, plus cardholders whose data flowed through Visa and Mastercard relationships with the vendor.
  • Data exposed: Personal information and marketing data — typically names, addresses, email addresses, phone numbers, and segmentation/profile attributes. Based on available reporting, full card numbers, CVVs, and banking credentials do not appear to be the primary exposure, but defenders should treat the PII as active phishing ammunition regardless.
  • Attack vector: Intrusion into the vendor's environment. No CVE has been publicly associated with this incident, and no specific exploited vulnerability has been disclosed. This is consistent with the majority of third-party breaches, which tend to involve credential theft, phishing-initial-access, exposed remote services, or abuse of legitimate access rather than a headline zero-day.
  • Exploitation status: Confirmed unauthorized access with confirmed data exposure — this is not a theoretical exposure or a misconfigured bucket. Breach notifications have been issued, which means legal review concluded regulated data was accessed.

Why third-party breaches are structurally harder to defend

From a defender's perspective, a vendor breach breaks almost every assumption baked into a traditional detection program:

  1. You have no telemetry in the vendor's network. Your EDR, your SIEM, your NDR — all blind. Detection depends entirely on the vendor's maturity and the contractual rights you negotiated before the incident.
  2. The access is authorized. The vendor's connections into your environment (SFTP drops, API integrations, marketing automation platforms, support tooling) are allow-listed by design. Malicious use of a legitimate channel looks like Tuesday.
  3. Data minimization usually failed quietly years ago. Marketing data shared in 2019 for one campaign tends to persist, replicate, and grow. When the vendor is breached, the exposure is almost always larger than what the current integration actually needs.
  4. Notification timelines are outside your control. GLBA, state breach statutes (and for some readers, PCI DSS obligation 12.8/12.9 and HIPAA BA requirements) put notification duties on you for data they lost. The clock effectively starts when the vendor decides to tell you.

The realistic attack chain (defender's view)

While the vendor hasn't published TTPs, financially motivated intrusions into service providers that hold marketing/CRM data overwhelmingly follow this pattern (mapped to MITRE ATT&CK):

  • Initial Access (T1078 Valid Accounts / T1566 Phishing): Compromised vendor employee credentials or a phished session token — MFA fatigue and token theft remain the top initial vectors against mid-size service firms.
  • Discovery (T1083 File and Directory Discovery / T1213 Data from Information Repositories): Locating CRM exports, marketing databases, and customer segmentation stores.
  • Collection (T1560 Archive Collected Data): Bulk staging of customer data into compressed archives — this is the single highest-fidelity pre-exfiltration behavior you can detect.
  • Exfiltration (T1567 Exfiltration to Cloud Storage / T1048 Exfiltration Over Alternative Protocol): Push to attacker-controlled cloud storage (MEGA, Dropbox, S3-compatible endpoints) or direct transfer tooling like rclone, curl, or FileZilla from systems that have no business running them.

The detection content below targets stages 3 and 4 — the stages where you still have a chance to catch a vendor-side intrusion before notification letters go out.

Detection & Response

The harsh truth of a third-party breach is that the detection that matters happens in your environment and at your integration boundary: watching what vendor-connected accounts touch, how much data leaves, and whether your own internal systems show pre-exfiltration staging behavior. The rules below are written to be high-signal — tuned against the staging, bulk-access, and exfiltration behaviors that precede exactly this class of breach.

SIGMA Rules

YAML
---
title: Mass Archive Creation in Data Staging Locations
id: 3f8c1a2e-7b9d-4e5f-a1c2-9d8e7f6a5b4c
status: experimental
description: Detects compression utilities creating archives in user-writable or staging directories, a common pre-exfiltration behavior observed in data-theft intrusions against service providers holding customer PII.
references:
  - https://attack.mitre.org/techniques/T1560/001/
  - https://www.bleepingcomputer.com/news/security/vendor-data-breach-exposes-chase-visa-mastercard-customer-info/
author: Security Arsenal
date: 2026/01/09
tags:
  - attack.collection
  - attack.t1560.001
logsource:
  category: process_creation
  product: windows
detection:
  selection_tools:
    Image|endswith:
      - '\7z.exe'
      - '\7za.exe'
      - '\rar.exe'
      - '\winrar.exe'
  selection_switches:
    CommandLine|contains:
      - ' a '
      - ' -r'
  selection_paths:
    CommandLine|contains:
      - '\AppData\Local\Temp\'
      - '\Users\Public\'
      - '\ProgramData\'
      - '$Recycle.Bin'
  condition: selection_tools and selection_switches and selection_paths
falsepositives:
  - IT backup and software packaging activity (allow-list by service account and parent process)
  - Endpoint backup agents performing scheduled compression
level: high
---
title: Data Transfer Utility Execution on Server or Database Host
id: 8b2d4f61-3c7a-4e9b-b5d1-2a6c8e0f4d7a
status: experimental
description: Detects execution of rclone, curl, wget, or FileZilla on servers and database hosts where such tools are not part of the standard build — a strong exfiltration indicator in CRM and marketing-data theft incidents.
references:
  - https://attack.mitre.org/techniques/T1567/002/
  - https://attack.mitre.org/techniques/T1105/
author: Security Arsenal
date: 2026/01/09
tags:
  - attack.exfiltration
  - attack.t1567.002
  - attack.command_and_control
  - attack.t1105
logsource:
  category: process_creation
  product: windows
detection:
  selection:
    Image|endswith:
      - '\rclone.exe'
      - '\filezilla.exe'
      - '\WinSCP.exe'
      - '\pscp.exe'
  selection_loops:
    CommandLine|contains:
      - 'mega.nz'
      - 'dropbox.com'
      - 'transfer.sh'
      - 'file.io'
      - 'anonfiles'
      - '.s3.'
  filter_known_automation:
    ParentImage|endswith:
      - '\svchost.exe'
  condition: selection or (Image|endswith: ['\curl.exe','\wget.exe'] and selection_loops and not filter_known_automation)
falsepositives:
  - Legitimate cloud backup jobs using rclone (baseline by host and schedule, then alert on deviation)
level: high
---
title: Vendor Service Account Accessing Unusual Data Volumes
id: c41e9a07-5f2b-48d6-9a3e-7c1b4d8f2e6b
status: experimental
description: Detects third-party or integration service accounts performing mass file reads on shares containing customer or marketing data. Designed to catch authorized-channel abuse where a compromised vendor identity is used to harvest data.
references:
  - https://attack.mitre.org/techniques/T1213/
  - https://attack.mitre.org/techniques/T1078/
author: Security Arsenal
date: 2026/01/09
tags:
  - attack.collection
  - attack.t1213
  - attack.persistence
  - attack.t1078
logsource:
  category: file_event
  product: windows
detection:
  selection:
    TargetFilename|contains:
      - '\customers\'
      - '\crm\'
      - '\marketing\'
      - '\exports\'
      - '\cardholders\'
  filter_legit:
    Image|endswith:
      - '\backup.exe'
      - '\Veeam.Backup.Service.exe'
      - '\sqlservr.exe'
  condition: selection and not filter_legit
falsepositives:
  - Scheduled ETL and marketing-automation syncs (tune by building a per-account baseline of read volume and alerting on deviation)
level: medium

KQL — Microsoft Sentinel / Defender Hunting

The single most valuable hunt after a vendor breach announcement is outbound data volume deviation tied to vendor integration identities, plus sign-in anomalies on service principals. Run this against the last 30 days and compare against your baseline:

KQL — Microsoft Sentinel / Defender
// Hunt 1: Anomalous outbound bytes from servers with vendor integrations (via firewall CEF ingestion)
let baseline = CommonSecurityLog
    | where TimeGenerated between (ago(60d) .. ago(7d))
    | where DeviceAction == "Allow" and isnotempty(SentBytes)
    | summarize AvgSent = avg(SentBytes), P95 = percentile(SentBytes, 95) by SourceIP, DeviceVendor
    | where P95 > 100000000; // only consider hosts that historically move some data
CommonSecurityLog
| where TimeGenerated > ago(7d)
| where DeviceAction == "Allow" and isnotempty(SentBytes)
| summarize RecentSent = sum(SentBytes), Destinations = dcount(DestinationIP), TopDest = arg_max(SentBytes, DestinationIP, DestinationPort) by SourceIP, DeviceVendor
| join kind=inner baseline on SourceIP, DeviceVendor
| where RecentSent > (P95 * 3)  // 3x historical p95 in a single week
| project SourceIP, DeviceVendor, RecentSent, P95, Destinations, TopDest, DestinationPort
| order by RecentSent desc;

// Hunt 2: Vendor service principals with first-time or rare-resource access in the last 14 days
let knownApps = SigninLogs
    | where TimeGenerated between (ago(90d) .. ago(14d))
    | where isnotempty(ServicePrincipalId)
    | summarize by ServicePrincipalId, AppDisplayName, ResourceDisplayName;
SigninLogs
| where TimeGenerated > ago(14d)
| where isnotempty(ServicePrincipalId)
| where AppDisplayName has_any ("marketing", "vendor", "integration", "sftp", "etl", "crm")
   or ServicePrincipalId != ""
| summarize FirstSeen = min(TimeGenerated), Locations = make_set(Location), IPs = make_set(IPAddress)
    by ServicePrincipalId, AppDisplayName, ResourceDisplayName
| join kind=leftanti knownApps on ServicePrincipalId, ResourceDisplayName
| project FirstSeen, AppDisplayName, ResourceDisplayName, IPs, Locations;

// Hunt 3: Interactive sign-in on accounts that should be non-interactive service accounts
SigninLogs
| where TimeGenerated > ago(30d)
| where UserPrincipalName has_any ("svc-", "vendor", "integration", "sftp")
| where AppDisplayName in~ ("Microsoft Office", "Microsoft Teams", "Office 365 Exchange Online")
   or ClientAppUsed == "Browser"
| project TimeGenerated, UserPrincipalName, IPAddress, Location, AppDisplayName, ClientAppUsed, ResultType
| order by TimeGenerated desc;

Velociraptor VQL

If you have Velociraptor deployed to endpoints or to jump-hosts vendors use, hunt for the staging artifacts that precede exfiltration — fresh archives in non-standard locations and active transfer-tool processes:

VQL — Velociraptor
-- Hunt for recently created archives in staging/temp locations across the fleet
SELECT FullPath, Size, Mtime, Btime,
       basename(path=FullPath) AS FileName
FROM glob(globs=['C:/Users/Public/**/*.zip',
                 'C:/Users/Public/**/*.7z',
                 'C:/Users/Public/**/*.rar',
                 'C:/Windows/Temp/**/*.zip',
                 'C:/Windows/Temp/**/*.7z',
                 'C:/ProgramData/**/*.7z',
                 'C:/ProgramData/**/*.rar'])
WHERE Mtime > now() - 1209600  -- last 14 days
  AND Size > 10485760          -- larger than 10MB
ORDER BY Mtime DESC
VQL — Velociraptor
-- Hunt for live exfiltration tooling and unusual outbound connections from data servers
SELECT Pid, Name, CommandLine, Exe, Username, CreateTime
FROM pslist()
WHERE Name =~ '(?i)rclone|filezilla|winscp|pscp|megacmd'
   OR CommandLine =~ '(?i)mega\.nz|transfer\.sh|file\.io|anonfiles|\.s3\.'
   OR (Name =~ '(?i)curl|wget' AND CommandLine =~ '(?i)https?://')

Remediation & Hardening Script

The most common technical root cause in vendor breaches is an over-privileged integration identity nobody has reviewed since onboarding. This PowerShell audits Microsoft Entra ID (Azure AD) for third-party app registrations and service principals holding broad or high-risk Graph permissions, flags ones with no recent sign-in review, and exports a remediation-ready report:

PowerShell
# Requires: Microsoft.Graph module, signed in with AuditLog.Read.All + Application.Read.All
# Connect-MgGraph -Scopes "Application.Read.All","AuditLog.Read.All","Directory.Read.All"

$highRiskScopes = @('Mail.Read','Mail.ReadWrite','Files.Read.All','Files.ReadWrite.All',
                    'Sites.Read.All','Directory.Read.All','User.Read.All','full_access_as_app')

$report = foreach ($sp in (Get-MgServicePrincipal -All)) {
    $grants = Get-MgServicePrincipalOauth2PermissionGrant -ServicePrincipalId $sp.Id -All -ErrorAction SilentlyContinue
    foreach ($g in $grants) {
        $scopes = $g.Scope -split ' '
        $hits = $scopes | Where-Object { $_ -in $highRiskScopes }
        if ($hits) {
            [PSCustomObject]@{
                AppDisplayName   = $sp.DisplayName
                AppId            = $sp.AppId
                ServicePrincipal = $sp.Id
                HighRiskScopes   = ($hits -join ';')
                ConsentType      = $g.ConsentType
                CreatedDate      = $sp.AdditionalProperties['createdDateTime']
                AccountEnabled   = $sp.AccountEnabled
            }
        }
    }
}

$report | Sort-Object AppDisplayName | Export-Csv .\third_party_app_audit.csv -NoTypeInformation
Write-Host "[*] $($report.Count) high-risk third-party grants found. Review third_party_app_audit.csv." -ForegroundColor Yellow

# Revoke a confirmed-malicious grant (run only after IR scoping):
# Remove-MgOauth2PermissionGrant -OAuth2PermissionGrantId <GrantId>
# Set-MgServicePrincipal -ServicePrincipalId <SpId> -AccountEnabled:$false

# Also export vendor service accounts with no sign-in in 90 days (dormant = attacker-friendly):
$cutoff = (Get-Date).AddDays(-90)
Get-MgServicePrincipal -All | ForEach-Object {
    $lastSignIn = (Get-MgServicePrincipal -ServicePrincipalId $_.Id -Property SignInActivity).SignInActivity.LastSignInDateTime
    if (-not $lastSignIn -or [datetime]$lastSignIn -lt $cutoff) {
        [PSCustomObject]@{ Name = $_.DisplayName; Id = $_.Id; LastSignIn = $lastSignIn }
    }
} | Export-Csv .\dormant_vendor_identities.csv -NoTypeInformation

For Linux-hosted vendor integration endpoints (SFTP drops, ETL servers), audit and lock down outbound egress — the exfiltration chokepoint:

Bash / Shell
# Identify hosts with unexpected outbound transfer tooling installed
for pkg in rclone filezilla winscp megacmd; do
  command -v $pkg >/dev/null 2>&1 && echo "[ALERT] $pkg present on $(hostname)"
done

# List outbound connections not matching your approved vendor egress allow-list
ss -tup state established | grep -Ev '(10\.|172\.(1[6-9]|2[0-9]|3[01])\.|192\.168\.)' | awk '{print $5, $7}'

# Restrict egress on the integration host to approved destinations only (example with iptables)
iptables -A OUTPUT -d sftp.vendor-approved.example -p tcp --dport 22 -j ACCEPT
iptables -A OUTPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -j LOG --log-prefix "EGRESS-DROP: "
iptables -A OUTPUT -j DROP

Remediation

If you are a Chase, Visa, or Mastercard customer, or your organization shares data with the same provider:

  1. For affected organizations (the 'Chase position'):

    • Invoke your incident-notification contract clause immediately. Demand the vendor's forensic scope: exact tables/exports accessed, access timestamps, and the exfiltration method. You cannot assess your exposure without it.
    • Map exactly what data the vendor holds under data-processing agreements, then execute data recall/deletion for anything beyond current operational need.
    • Rotate every credential, API key, certificate, and SFTP account the vendor uses to reach your environment — assume all of them were readable from the compromised network.
    • Engage counsel on GLBA Interagency Guidance and applicable state breach-notification statutes; vendor incidents still trigger your notification duties for your customers.
  2. For organizations assessing their own vendor exposure:

    • Run the Entra ID audit script above against every third-party integration. Any service principal holding Files.Read.All, Sites.Read.All, or mailbox-wide scopes without a documented business justification is a breach waiting for a notification letter.
    • Enforce data minimization by design: marketing vendors get tokenized or hashed identifiers, not raw PII, wherever the use case allows.
    • Require vendors handling regulated data to meet a control baseline (CIS Controls v8 IG2 minimum, or SOC 2 Type II with pen-test attestation) with contractual breach-notification SLAs of 24-72 hours — not 'without undue delay.'
    • Place vendor-facing SFTP/API endpoints in a dedicated egress-monitored segment with default-deny outbound rules (see the Bash hardening above).
  3. For affected customers (and your fraud/comms teams):

    • Expect targeted phishing, smishing, and vishing referencing Chase, Visa, or Mastercard using the stolen marketing data. The pretexts will be polished and personalized — 'we're calling about your account' calls that know your name and contact details.
    • Enable account alerts, use unique passwords with a password manager, enable phishing-resistant MFA (FIDO2/passkeys) where offered, and treat any inbound contact 'from the bank' as untrusted — hang up and call the number on the back of the card.
    • Consider credit freezes and monitor for new-account fraud; exposed PII of this type is routinely used for synthetic identity construction.

The uncomfortable takeaway from this incident: your breach surface is the sum of every vendor who touches your customers' data. Detection engineering on the integration boundary — egress baselining, identity auditing, staging-behavior rules — is no longer optional for organizations in regulated industries.

Related Resources

Security Arsenal Incident Response Services AlertMonitor Platform Book a SOC Assessment incident-response Intel Hub

Is your security operations ready?

Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.