Back to Intelligence

N0n Extortion Group Leak Hits JPMorgan, Visa, Mastercard via Third-Party Providers — Detection and Third-Party Risk Remediation Guide

SA
Security Arsenal Team
November 21, 2026
13 min read

Introduction

JPMorgan Chase, Visa, and Mastercard are all pointing the finger at third-party providers after the N0n extortion group leaked data allegedly tied to their customers. The pattern here is one I've watched repeat across dozens of IR engagements over the past decade and a half: the financial institutions' own perimeter defenses held, but an attacker found the soft underbelly — a vendor, processor, marketing partner, or service provider with access to customer data and a fraction of the security maturity.

This is not a hypothetical supply-chain risk exercise. This is a live extortion event in 2026 affecting three of the most heavily regulated, best-resourced financial entities on the planet. If third-party exposure can touch JPMorgan, Visa, and Mastercard simultaneously, your organization's vendor ecosystem is carrying the same risk — likely with far less visibility.

Defenders need to act on two fronts immediately: (1) hunt for indicators of upstream compromise and data staging within your own environment and your vendors' access paths, and (2) remediate the structural third-party risk gaps that make these incidents possible. This post covers both.

Technical Analysis

What Happened

Per the SecurityWeek reporting, the N0n extortion group published leaked data it claims is tied to customers of JPMorgan, Visa, and Mastercard. Critically, the affected companies have attributed the incidents to third-party providers — not to breaches of their own core systems. This attribution pattern tells practitioners several important things:

  1. The data was likely accessed through a trusted relationship. Vendors handling marketing, analytics, collections, payment-adjacent services, or customer communications routinely hold PII, account metadata, or cardholder-adjacent data under contract. Attackers know these providers often have weaker controls, flat networks, and broad data access.
  2. The extortion model is encryption-optional. Groups like N0n increasingly skip ransomware deployment entirely. Pure data-theft extortion — steal quietly, leak publicly, demand payment to suppress — generates fewer forensic artifacts, no encryption events to trigger EDR, and no operational disruption to alert the victim. Detection depends entirely on catching the staging and exfiltration phase.
  3. Downstream customers absorb the impact while the breached vendor may not even be named. This is the visibility problem at the heart of third-party incidents: the brand-name companies bear the regulatory, legal, and reputational exposure for a compromise they didn't directly suffer and may have learned about from a leak site.

The Attack Chain (Defender's View)

While specific TTPs for the N0n intrusion into the third-party provider(s) have not been publicly detailed, the extortion-group playbook against service providers is well-established and maps cleanly to MITRE ATT&CK:

PhaseTypical TechniqueATT&CK
Initial AccessPhishing, exposed remote services, compromised vendor credentials, purchased access from IABsT1566, T1133, T1078
PersistenceWebshells, rogue accounts, RMM tooling (AnyDesk, ScreenConnect, Atera)T1505.003, T1136, T1219
DiscoveryEnumerating file shares, databases, cloud storage buckets, customer data repositoriesT1083, T1213, T1530
CollectionMass archiving of customer data with 7-Zip/WinRAR, database dumps (mysqldump, pg_dump, sqlcmd)T1560.001, T1005
ExfiltrationRclone/MEGA/curl to cloud storage, large egress over HTTPS, SFTP to attacker infrastructureT1567.002, T1048
ImpactLeak-site publication, extortion emails to the victim's downstream customersT1657

The two highest-fidelity detection opportunities are bulk archive creation and anomalous outbound data volume — both are nearly universal in extortion operations and both are detectable with content your SOC likely already collects.

Exploitation Status

  • CVEs: None are cited in the reporting, and none should be assumed. Third-party extortion incidents of this type most commonly begin with valid credentials, phishing, or internet-facing service exposure rather than a named vulnerability. Do not chase a CVE that doesn't exist — hunt the behaviors.
  • Active exploitation: Confirmed — the data leak is public, and extortion is ongoing.
  • CISA KEV: Not applicable as of this writing; no CVE has been associated with this campaign.

Why Financial-Sector Vendors Are the Target

Attackers conduct their own third-party risk assessments — inverted. They map which vendors touch which tier-one brands, then attack the weakest link. A single compromised marketing analytics firm or document processor can yield data attributable to dozens of marquee clients, multiplying extortion leverage. Every organization in the financial supply chain should assume it is being actively mapped this way in 2026.

Detection & Response

The detections below target the behaviors that matter in this class of incident: mass data staging, unsanctioned exfiltration tooling, anomalous vendor-session behavior, and egress volume anomalies. They are written to be high-fidelity — tune the thresholds to your baseline before deploying at high severity.

Sigma Rules

YAML
---
title: Mass Archive Creation of Customer Data by Compression Utility
id: 3f8a1c47-2b9d-4e5a-9c61-7d4e2f8a0b13
status: experimental
description: Detects compression utilities (7-Zip, WinRAR) creating archives with password protection or targeting directories consistent with customer data repositories. Common staging behavior in data-theft extortion operations such as the N0n group campaign against third-party providers.
references:
  - https://www.securityweek.com/jpmorgan-visa-mastercard-cite-third-party-incidents-amid-data-leak/
  - https://attack.mitre.org/techniques/T1560/001/
author: Security Arsenal
date: 2026/04/06
tags:
  - attack.collection
  - attack.t1560.001
logsource:
  category: process_creation
  product: windows
detection:
  selection_tool:
    Image|endswith:
      - '\7z.exe'
      - '\7za.exe'
      - '\rar.exe'
      - '\winrar.exe'
  selection_flags:
    CommandLine|contains:
      - ' -p'
      - ' -hp'
      - ' a -t7z'
      - ' a -trar'
      - ' -mhe'
  condition: selection_tool and selection_flags
falsepositives:
  - Backup administrators creating encrypted archives during maintenance windows
  - Software packaging activity from known build servers
level: high
---
title: Unsanctioned Cloud Exfiltration Tool Execution
id: 8c2d5e91-4a7b-4f3c-b1d8-6e9a0c5f2d47
status: experimental
description: Detects execution of Rclone, MEGAcmd, or similar cloud-sync exfiltration tooling frequently abused by extortion groups to move stolen data off third-party provider networks.
references:
  - https://www.securityweek.com/jpmorgan-visa-mastercard-cite-third-party-incidents-amid-data-leak/
  - https://attack.mitre.org/techniques/T1567/002/
author: Security Arsenal
date: 2026/04/06
tags:
  - attack.exfiltration
  - attack.t1567.002
logsource:
  category: process_creation
  product: windows
detection:
  selection_img:
    Image|endswith:
      - '\rclone.exe'
      - '\MEGAcmd.exe'
      - '\mega-cmd.exe'
      - '\megacmdserver.exe'
      - '\filezilla.exe'
      - '\winscp.exe'
  selection_cmd:
    CommandLine|contains:
      - ' copy '
      - ' sync '
      - ' move '
      - ' --transfers'
      - ' --bwlimit'
  condition: selection_img and selection_cmd
falsepositives:
  - Sanctioned cloud backup workflows using Rclone (maintain an allowlist of approved hosts)
  - IT file-transfer tooling on jump boxes
level: high
---
title: Database Dump Utility Execution by Non-Standard Account
id: 5e1b9f23-8d4c-4a6e-93b2-1c7f0a3d8e56
status: experimental
description: Detects native database dump utilities executing outside of scheduled backup windows or by accounts not in the DBA group — a hallmark of extortion actors harvesting customer databases from compromised third-party systems.
references:
  - https://www.securityweek.com/jpmorgan-visa-mastercard-cite-third-party-incidents-amid-data-leak/
  - https://attack.mitre.org/techniques/T1005/
author: Security Arsenal
date: 2026/04/06
tags:
  - attack.collection
  - attack.t1005
logsource:
  category: process_creation
  product: windows
detection:
  selection:
    Image|endswith:
      - '\mysqldump.exe'
      - '\pg_dump.exe'
      - '\sqlcmd.exe'
      - '\osql.exe'
      - '\mongoexport.exe'
  filter_dba_ou:
    User|contains: 'svc_sqlbackup'
  filter_backup_window:
    ParentImage|endswith:
      - '\sqlagent.exe'
      - '\Veeam.Backup.Service.exe'
  condition: selection and not 1 of filter_*
falsepositives:
  - Developers running ad-hoc exports (restrict and audit export rights instead of suppressing)
  - ETL pipeline service accounts not yet added to the allowlist
level: high

KQL — Microsoft Sentinel / Defender Hunt Queries

Hunt 1: Identify anomalous egress volume per device — the single most reliable extortion indicator. Baseline deviation is what matters; a third-party provider's file server pushing 50 GB outbound to an unfamiliar destination is the incident.

KQL — Microsoft Sentinel / Defender
// Anomalous outbound data volume - potential bulk exfiltration
let Lookback = 14d;
let Baseline = DeviceNetworkEvents
| where TimeGenerated > ago(Lookback) and TimeGenerated < ago(1d)
| where RemoteIPType == "Public"
| summarize AvgDailyBytes = avg(tolong(0)) by DeviceName;  // placeholder - replace with BytesSent if using custom ingestion
let Today = CommonSecurityLog
| where TimeGenerated > ago(1d)
| where isnotempty(SentBytes)
| summarize TotalSentMB = sum(SentBytes)/1048576 by DeviceName, DestinationIP, DestinationHostName
| where TotalSentMB > 10240  // >10 GB egress in 24h - tune to your baseline
| order by TotalSentMB desc;
Today
// Secondary: correlate large egress with non-sanctioned destinations
| where DestinationHostName !has_any ("microsoft.com", "windows.net", "amazonaws.com", "your-backup-vendor.com")

Hunt 2: Detect data staging and exfiltration process chains — compression or exfil tooling spawned by Office apps, browsers, or script hosts (consistent with phishing-driven initial access at a vendor).

KQL — Microsoft Sentinel / Defender
// Compression/exfil tooling spawned by user-facing processes (phishing follow-on activity)
DeviceProcessEvents
| where TimeGenerated > ago(7d)
| where FileName in~ ("7z.exe", "7za.exe", "rar.exe", "rclone.exe", "megacmd.exe", "winscp.exe", "filezilla.exe")
| extend Parent = tostring(parse_json(InitiatingProcessCommandLine))
| where InitiatingProcessFileName in~ ("winword.exe", "excel.exe", "outlook.exe", "chrome.exe", "msedge.exe", "powershell.exe", "wscript.exe", "mshta.exe", "rundll32.exe")
| project TimeGenerated, DeviceName, AccountName, FileName, ProcessCommandLine, InitiatingProcessFileName, InitiatingProcessCommandLine
| order by TimeGenerated desc

Hunt 3: Vendor and third-party account anomaly review — catch misuse of legitimate vendor credentials, the most common initial-access vector in third-party breaches.

KQL — Microsoft Sentinel / Defender
// Third-party / vendor account logons from new geographies or unusual hours
SigninLogs
| where TimeGenerated > ago(7d)
| where UserPrincipalName has_any ("vendor", "partner", "ext_", "-ext", "svc_")  // tune to your vendor account naming convention
| summarize SigninCount = count(),
            Locations = make_set(Location),
            IPs = make_set(IPAddress),
            Apps = make_set(AppDisplayName)
         by UserPrincipalName, bin(TimeGenerated, 1h)
| where array_length(Locations) > 1
   or SigninCount > 20
| order by SigninCount desc

Velociraptor VQL — Endpoint Hunt

Deploy this hunt across servers that host customer data or that vendors can reach. It enumerates recently created archives and staging directories — the physical residue of extortion collection.

VQL — Velociraptor
-- Hunt for recently created archives and exfil staging artifacts on servers
LET archive_globs = {
  SELECT FullPath, Mtime, Size
  FROM glob(globs=[
    'C:/Users/*/Desktop/*.zip',
    'C:/Users/*/Downloads/*.7z',
    'C:/Users/*/Downloads/*.rar',
    'C:/Temp/*.zip',
    'C:/Temp/*.7z',
    'C:/Windows/Temp/*.zip',
    'C:/Windows/Temp/*.7z',
    'C:/ProgramData/*.7z',
    'C:/ProgramData/*.rar',
    'D:/staging/**',
    'D:/export/**'
  ])
}

SELECT FullPath,
       Mtime,
       Size / 1048576 AS SizeMB,
       Mtime > (now() - 604800) AS CreatedLast7Days
FROM archive_globs
WHERE Size > 104857600   -- archives larger than 100 MB
ORDER BY Mtime DESC

Pair the archive hunt with a process hunt for the tooling itself:

VQL — Velociraptor
-- Hunt for running or recently executed compression/exfiltration tooling
SELECT Pid, Name, CommandLine, Exe, Username, CreateTime
FROM pslist()
WHERE Name =~ '(?i)(7z|7za|rar|winrar|rclone|megacmd|winscp|filezilla)'
   OR CommandLine =~ '(?i)(rclone (copy|sync|move)| -p\S+ | -mhe)'

Remediation / Verification Script

The following PowerShell audits a Windows server estate for the artifacts and tooling associated with extortion staging, and verifies logging coverage needed to catch it. Run it against any server holding customer data — and require your third-party providers to run equivalent audits contractually.

PowerShell
# Third-Party Extortion Exposure Audit - Security Arsenal
# Run as Administrator on servers hosting customer data

$Report = @()

# 1. Hunt for large archives created in the last 14 days in common staging paths
$StagingPaths = @('C:\Temp','C:\Windows\Temp','C:\ProgramData',"$env:PUBLIC",'D:\staging','D:\export')
foreach ($Path in $StagingPaths) {
    if (Test-Path $Path) {
        Get-ChildItem -Path $Path -Recurse -Include *.zip,*.7z,*.rar,*.tar.gz -ErrorAction SilentlyContinue |
            Where-Object { $_.LastWriteTime -gt (Get-Date).AddDays(-14) -and $_.Length -gt 100MB } |
            ForEach-Object {
                $Report += [PSCustomObject]@{
                    Check = 'LargeRecentArchive'; Path = $_.FullName
                    SizeMB = [math]::Round($_.Length/1MB,2); LastWrite = $_.LastWriteTime }
            }
    }
}

# 2. Detect presence of unsanctioned exfiltration tooling
$ExfilTools = @('rclone.exe','megacmd.exe','MEGAcmd.exe','winscp.exe','filezilla.exe')
foreach ($Tool in $ExfilTools) {
    $Found = Get-ChildItem -Path 'C:\','D:\' -Filter $Tool -Recurse -ErrorAction SilentlyContinue -Depth 4 |
             Select-Object -First 5
    foreach ($F in $Found) {
        $Report += [PSCustomObject]@{
            Check = 'ExfilToolPresent'; Path = $F.FullName
            SizeMB = [math]::Round($F.Length/1MB,2); LastWrite = $F.LastWriteTime }
    }
}

# 3. Verify process creation auditing with command line is enabled (Event ID 4688 cmdline)
$CmdLineAudit = (Get-ItemProperty 'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System\Audit' -Name 'ProcessCreationIncludeCmdLine_Enabled' -ErrorAction SilentlyContinue).ProcessCreationIncludeCmdLine_Enabled
if ($CmdLineAudit -ne 1) {
    $Report += [PSCustomObject]@{ Check = 'FIX REQUIRED'; Path = 'CmdLine auditing DISABLED - enable ProcessCreationIncludeCmdLine_Enabled'; SizeMB = 0; LastWrite = $null }
    Set-ItemProperty 'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System\Audit' -Name 'ProcessCreationIncludeCmdLine_Enabled' -Value 1
    Write-Host '[REMEDIATED] Enabled command-line process auditing.' -ForegroundColor Yellow
}

# 4. Audit local accounts created in the last 30 days (rogue persistence accounts)
Get-LocalUser | Where-Object { $_.PasswordLastSet -gt (Get-Date).AddDays(-30) -and $_.Enabled } |
    ForEach-Object {
        $Report += [PSCustomObject]@{ Check = 'RecentLocalAccount'; Path = $_.Name; SizeMB = 0; LastWrite = $_.PasswordLastSet }
    }

$Report | Format-Table -AutoSize
$Report | Export-Csv -Path "C:\ExtortionExposureAudit_$(Get-Date -Format 'yyyyMMdd_HHmm').csv" -NoTypeInformation
Write-Host "Audit complete. Findings exported to C:\ExtortionExposureAudit_*.csv" -ForegroundColor Green

Remediation

There is no patch for a third-party breach — remediation is architectural and contractual. These are the steps I'd put in front of a CISO this week, based on exactly the failure mode in this story.

Immediate (0–72 hours)

  1. Inventory every third party holding customer data. Not the procurement spreadsheet — the actual data-flow inventory. Which vendors store, process, or transmit PII, cardholder-adjacent data, or account metadata? Where does it live? If you cannot answer this in 24 hours, that is your first gap.
  2. Hunt your own environment with the detections above. Assume a vendor has already been popped and look for the blast radius reaching you: vendor accounts authenticating from new infrastructure, unusual API call volumes against your data-sharing integrations, unexpected file transfers from vendor-managed systems.
  3. Force password/session resets on all vendor-connected accounts and validate MFA enforcement — phishing-resistant MFA (FIDO2) on any external party with data access, no exceptions.
  4. Activate your extortion playbook, not just your breach playbook. Extortion-only incidents have different decision points: leak-site monitoring, negotiation posture, legal privilege strategy, regulator notification timing, and customer communication sequencing. If your IR plan doesn't distinguish them, update it now.

Short-Term (2–4 weeks)

  1. Contractual detection requirements. Your vendor agreements must include: minimum logging standards (process creation with command line, authentication logs, egress NetFlow), 24-hour incident notification SLAs, the right to forensic evidence (disk images, logs) — not just a notification email, and attestations of EDR coverage on systems holding your data.
  2. Data minimization enforcement. The single most effective control: vendors should hold the minimum data for the minimum time. Tokenize or pseudonymize before sharing where possible. If this breach leaked customer data your vendor didn't operationally need, that's a governance failure, not a security failure.
  3. Egress controls and DLP on vendor-facing segments. Alert on any single-destination transfer exceeding a tuned threshold (start at 5–10 GB/day for file servers), and block unsanctioned cloud storage destinations (MEGA, personal OneDrive/Google Drive, rclone-reachable endpoints) from servers holding customer data.
  4. Continuous vendor monitoring over point-in-time questionnaires. Annual SIG questionnaires did not prevent this incident. Move to continuous external posture monitoring of critical vendors (exposed services, credential leaks, dark-web chatter mentioning vendor names).

Strategic (Quarter)

  1. Tier vendors by data access, not spend. A $40K marketing vendor with a full customer extract is a Tier-1 risk. Map vendor criticality to data sensitivity and apply your own control requirements (CIS Controls v8, NIST CSF 2.0 Supply Chain Risk Management category) proportionally.
  2. Tabletop the exact scenario. "A third-party provider is extorted; our customer data is on a leak site; the vendor is unresponsive." Run it with Legal, Comms, Privacy, and the business owners of the vendor relationship. Measure time-to-decision, not time-to-detect.
  3. Regulatory alignment. Financial-sector entities should map notification obligations (GLBA, state breach statutes, NYDFS 500, PCI-DSS 12.10 for cardholder-adjacent data, and SEC disclosure rules where applicable) to the third-party scenario specifically — the clock may start when you learn of it, regardless of when the vendor was breached.

Bottom Line

The JPMorgan/Visa/Mastercard–N0n incident is the 2026 version of a lesson the industry keeps re-learning: your security perimeter extends to the least-defended vendor holding your customers' data, and extortion groups are mapping that perimeter more carefully than most enterprises are. Detection lives in the staging and exfiltration phases — archives, dump utilities, rclone, egress anomalies — and prevention lives in data minimization, contractual telemetry rights, and continuous vendor monitoring. Deploy the hunts, audit the estate, and fix the contracts before the next leak site post has your name in it.

Related Resources

Security Arsenal Managed SOC Services AlertMonitor Platform Book a SOC Assessment soc-mdr Intel Hub

Is your security operations ready?

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