NEWNightwatch is live. Autonomous hunting and detection engineering. See how it works →
Back

Detecting the skimmers behind AI driven retail intrusions

Tim Peck

Written by Tim Peck · Director of Threat Research

Detecting the skimmers behind AI driven retail intrusions
Share on social
November 13, 20268 minute read

Tim Peck, Director of Threat Research, detections.ai

Matt Brady, Technical Advisor, detections.ai

A checkout page can keep processing orders while its JavaScript changes underneath it. That is the detection problem at the center of the retail intrusion campaign Gambit Security disclosed on September 22. The attacker used Strix, Cairn, and Hermes to automate intrusions and deploy payment skimmers through several parts of the application stack. [1]

For detection engineers, the useful question is what changed between the approved application and the page a customer received. Answering it requires visibility into browser behavior, served content, and the systems that can modify that content. An alert for an unfamiliar domain covers only part of that problem.

Gambit reported more than 600,000 stolen card records from two companies, alongside separate skimmer deployments. Those totals should not be treated as a count of cards captured by browser skimmers. The headline cost also needs context: $25.46 was the operator's mean across 101 completed scans, not a measured price for every successful breach. Its interim findings combine direct evidence with logs and agent claims. [1]

Additional hashes extend the investigation

We reviewed public urlscan records and identified ten JavaScript response hashes, associated with ten paths on reported skimmer infrastructure, that are absent from Gambit's IOC table. The inspected records span September 2–22. Nine of the ten fingerprints appear in September 21–22 records; the remaining fingerprint comes from a September 2 capture.

These are archive-reported SHA-256 fingerprints with verified URL associations. They are candidates for sample retrieval and retrospective hunting; independent confirmation of the payloads' behavior is still needed before labeling every hash a confirmed skimmer. Three examples illustrate the evidence:

Archived resource

SHA-256

static-js[.]com/js/cg.js [2]

99398c4bd377edd6422ef070903677efe39736994697eae92b95a1a35d808eea

static-js[.]com/js/jmj.js [3]

1e99200e6c2e114c947eacf0765c30926b2aca2b8b624c13cd2372d9199e40fd

cdn.jsnetlify[.]com/js/wsl.js [4]

6a4f5b1e7ec3930954f82778d4fd1184ce0d332f1b3a5bd75a7380c169f1ff9a

The jmj.js fingerprint appears in a September 21 storefront scan as a loaded script and in a September 22 direct resource scan. That connects a delivered browser resource to a reproducible content identifier. It does not establish a new victim count or prove that payment data was transmitted. [3, 5]

We also excluded a hash shared by 404 responses and the SHA-256 of an empty response. Both appeared on the investigated infrastructure. Carrying either into a malware hash feed would create misleading matches. The accompanying research notes preserve all ten candidates, their capture times, and their source records.

Start with the page the customer receives

Gambit describes injections in existing JavaScript, inline analytics code, S3 content, database fields, Kubernetes initialization, and cached pages. [1] A source repository alone cannot represent all of those delivery paths.

Build an inventory for the checkout journey that records the page, loaded script URL, content hash, initiating script where available, and approved release. Exercise the steps that reveal payment components using synthetic customer data. Compare the resources actually delivered after the CDN and application caches have done their work.

A useful browser analytic looks for an unapproved script origin or changed script content on a payment page, then adds context from a recent infrastructure change. Once a payload has been examined, its payment-field access and outbound requests can become additional signals. Merely reading a form field is too broad: validation libraries, fraud tools, and payment integrations also do that.

Content Security Policy reports can add visibility into attempted loads and connections that violate a policy. Preserve the affected document, blocked origin, effective directive, and enforcement disposition. Report-only observations indicate a policy violation without establishing that the browser blocked the request. Cross-origin reports may omit the resource path, so a domain analytic should not depend on seeing /js/jmj.js in every report. [6]

CSP has a specific visibility limit here: a changed script served from an allowed origin may generate no violation. Likewise, the retailer's reverse-proxy logs usually do not contain a shopper's direct request to a third-party skimmer host. Corporate DNS logs cover customers only when their requests traverse that monitored resolver. Browser telemetry and synthetic monitoring close different parts of this gap.

Detect content changes even when timestamps look normal

The reported loader combines new Function, atob, and a seven-character prefix removed with .slice(7). Gambit also observed restoration of the original file timestamp. [1]

Use that combination for a focused content hunt across served bundles, templates, cached page representations, and database fields that render into HTML. A collector can identify literal strings, remove the prefix, and decode Base64 as data for inspection. There is no need to execute the decoded JavaScript to inspect its destination.

Keep the narrow campaign pattern separate from the broader behavior. Minified applications can legitimately use Base64 or construct functions dynamically. Raise confidence when a previously approved asset acquires a decoding sequence that introduces an unapproved script origin, especially when no corresponding release explains the change.

File integrity monitoring should compare content against a trusted build manifest. Modification time is supporting evidence. Join a changed hash to the writing process, user, parent process, and deployment history where the sensor exposes them. A web application worker modifying a served bundle warrants a different investigation from an approved build publishing the expected artifact.

This is also where the new hashes help: they offer exact-match pivots for captured responses and collected files. They cannot cover a variant with different bytes, and they should not replace a comparison against your own approved application.

Watch the systems that publish checkout content

For S3-backed assets, monitor successful object writes to buckets and prefixes that serve the storefront. Collect the object key, principal, source address, request time, and operation. Compare writes with the expected deployment identity and release artifacts, then verify whether the changed object reached the checkout page.

There is a practical prerequisite: S3 object operations such as PutObject are CloudTrail data events, which are not logged by default and are absent from Event history. Confirm that the relevant buckets have data-event collection before declaring this detection covered. Include applicable copy and multipart completion operations so an overwrite does not disappear simply because it used a different API. [7]

An approved principal is useful context, but a compromised deployment identity can still publish malicious content. Content verification remains necessary. Avoid suppressing every write from a familiar role or an entire release window.

For Kubernetes, inspect successful changes to storefront workloads for newly added or modified init containers, commands, and shared volume mounts. Prioritize a change that can write assets consumed by the application and lacks a matching approved manifest.

Audit configuration determines what can be detected. Metadata-only Kubernetes audit events do not include request or response bodies. Retain the bodies needed to examine workload changes, and account for JSON Patch arrays as well as object-shaped requests. Comparing the resulting workload with the approved manifest avoids assuming every patch contains a complete Deployment object. [8]

Find what puts the skimmer back

At one victim, Gambit observed a job that restored the injection every two minutes after a clean deployment removed it. [1] That makes the period immediately after remediation a useful detection window.

Correlate a clean deployment with an unexpected rewrite of the same asset, then trace the process responsible. Combine scheduled-task changes, process execution, and file modifications where available. A recurring process launched from an application log directory and writing into the web content tree is a strong investigation lead.

The exact two-minute interval should enrich the alert, not become its only condition. A changed schedule would otherwise defeat the rule. Also distinguish ordinary asset generation and cache warming from a process that reintroduces an unauthorized loader.

After removal, repeat the browser collection across a restart, deployment, and cache refresh. A clean file on one host does not establish that every delivery path is clean. Keep monitoring for content reappearing while the persistence investigation proceeds.

Correlate by the affected application

Rotating network sources make an IP-only correlation fragile. Join observations around the storefront, workload, asset path, cloud principal, and release identifier. Those relationships connect an infrastructure change to what a customer later receives.

Consider an unexpected object write followed by a changed checkout bundle and an unapproved script load. Each event supplies a different part of the evidence. Use event timestamps and accommodate collection delay; a rigid short window can split the sequence before delayed cloud logs arrive. Start with a locally tested window and tune it against actual release and log-delivery behavior.

Retain a parallel database analytic. The reported activity included payment-data theft and destructive cleanup. [1] Hunt for unusual exports or reads followed by broad updates or table deletion, using database audit telemetry that actually records those operations. Application access logs alone do not provide that coverage. Suppress approved migrations and retention work narrowly by identity, objects, and expected operations.

Build detections the community can test

For detections.ai, this campaign fits a Threat Report that links the original investigation, the additional archive evidence, and a small set of behavior-specific detections. Start with script-origin changes on checkout pages, unexplained content drift, unauthorized object or workload changes, and reinjection after deployment. Keep exact IOC matches available for scoping while those broader analytics mature.

Each detection should state its required fields, confidence limits, and expected false positives. Validate it with a harmless script change in an isolated checkout environment, then replay ordinary releases, tag updates, cache rebuilds, and workload changes. Confirm that the alert identifies the affected application and gives the responder enough evidence to find the writer or publisher.

AI Assistant and language translation can help contributors adapt that logic across supported tools. The telemetry assumptions need to travel with it: a translated query cannot create browser observations or cloud data events that were never collected.

The most useful community contribution is a detection that survives a new skimmer hostname and still explains the unauthorized change. Pairing the evidence with its collection requirements gives the next team something concrete to deploy, test, and improve.

Sources

1. Gambit Security campaign report, September 22, 2026

2. urlscan capture of cg.js, September 22, 2026

3. urlscan direct capture of jmj.js, September 22, 2026

4. urlscan script-load evidence for wsl.js, September 21, 2026

5. urlscan script-load evidence for jmj.js, September 21, 2026

6. MDN documentation for CSP violation reports

7. AWS documentation for S3 CloudTrail events

8. Kubernetes audit documentation


Read more

Subscribe

Stay connected

Join the community that moves faster than the threat.

Subscribe to our newsletter