Retadup USB Worm on Old Drives Now Delivers CoffeeLoader


What this means for your clients: An old USB stick from a drawer can still infect a computer years after authorities shut the malware down, so ask your IT provider whether USB drives are restricted and old ones scanned or retired.
In July 2019, French law enforcement took over the Retadup botnet's servers and told every infected computer that checked in to wipe the worm. Within weeks, more than 850,000 machines were disinfected. Kaspersky says copies may have survived on flash drives. On November 16, Kaspersky reported that since 2024 someone has been re-registering Retadup's old C2 domains, so a 2017 copy of the USB worm still reaches its server. Since early 2025, those servers have handed out CoffeeLoader.
Kaspersky says its solutions blocked Retadup infection attempts on around 15,000 systems in the first three quarters of 2026, mostly in Peru, Angola, Russia and Bolivia. That is what its telemetry blocked, not a count of infections. The lesson is not that Retadup is big again. A takedown does not clean your media, dead malware domains can come back, and a clicked shortcut still opens the door. Kaspersky does not know who revived the servers, and neither do we.
How the Retadup USB worm delivers CoffeeLoader
Retadup was written in AutoIt and AutoHotkey. It copied itself to connected USB and external drives as hidden files and LNK shortcuts, and when someone clicked the shortcut on another PC, the worm moved in. It checks in over HTTP with a WinHttp user agent and a path starting with 32 hex characters. The revived servers first served SmokeLoader, then CoffeeLoader; in Kaspersky's 2026 traffic, the server told the worm to download update.exe.
In the new CoffeeLoader variant Kaspersky detected in August, an NSIS installer drops 7z.dll into a temporary folder and runs it through rundll32.exe. That 7z.dll is a patched 7-Zip library carrying a new Armoury packer, which decrypts the next stage on the GPU, now through OpenGL instead of OpenCL. Kaspersky says the GPU step helps it evade detection in virtual environments.
The decrypted CoffeeLoader downloader copies the DLL into a folder under ProgramData or AppData\Local. The folder, the DLL and a Run key value share eight hex digits, such as b79faace, and the Run value starts the DLL through rundll32.exe with the SetCodecs export. A matching StartupApproved value stops the user disabling that autorun in Task Manager. The downloader then launches dllhost.exe, WerFault.exe, svchost.exe, OpenWith.exe or AtBroker.exe, uses process injection to run inside it, and fetches the main body over HTTPS from a /payload?md5= path. That module can inject a payload, save and run an executable, or run a DLL through rundll32.exe.
Why a small campaign still matters
Kaspersky says CoffeeLoader downloads other malware, such as stealers or ransomware, but does not say ransomware was delivered here. In our judgment, one employee clicking a shortcut on an old drive could hand an operator a loader that survives reboot, resists the Task Manager fix, and can pass control to anything. Old drives circulate through shops, warehouses, schools and vendors, so MSPs should treat removable media as client exposure.
Close the USB door, then clean up
There is no vendor patch to apply. Kaspersky advises updating the operating system and security software, disabling autorun for removable media, scanning drives before opening files, showing file extensions, avoiding shortcuts, programs or scripts from old drives, and keeping a backup protected from modification.
Our additions: Kaspersky describes infection through a clicked shortcut, so turning off autorun is not enough. Use device control in Intune, Group Policy or your EDR to block removable storage, with an allow list where USB is needed. Turn on the Defender rule "Block untrusted and unsigned processes that run from USB". Retire drives nobody can vouch for, and block the listed C2 domains at DNS and proxy.
If you find an infection, isolate the host and preserve evidence. In our view, cleanup means removing the Run value, the StartupApproved value and the eight-hex folder together; if CoffeeLoader fetched anything further, reimage.
How to hunt
We have not run these in a live SIEM; tune them to your field names and test before trusting a clean result. Every search comes in Splunk, Elastic, CrowdStrike and Microsoft KQL versions. We start hunts at 2026-01-01T00:00:00Z, our choice to match Kaspersky's numbers; widen if retention allows, since CoffeeLoader arrived in early 2025. Splunk assumes Sysmon, Elastic assumes Elastic Defend, and KQL assumes Defender for Endpoint. Confirm registry and file telemetry before reading silence as clean. Every YOUR_ name is a placeholder.
Test 1: your removable media exposure
This 30-day baseline, our choice of window, shows which hosts mount USB drives or run programs from them. It measures exposure, not infection; Hunt 3 catches an infection already in place, because the Run value fires at every logon.
Field mapping: Defender and Falcon record USB mounts, Splunk and Elastic use process paths, and treating D: to Z: as removable is our choice, so mapped drives appear too. Falcon's YOUR_SYSTEM_VOLUME_NUMBER comes from any ImageFileName under \Windows and can differ per host.
Splunk
index=YOUR_SYSMON_INDEX (source="XmlWinEventLog:Microsoft-Windows-Sysmon/Operational" OR sourcetype="XmlWinEventLog:Microsoft-Windows-Sysmon/Operational") EventCode=1 earliest=-30d latest=now
| eval img=lower(Image)
| where match(img, "^[d-z]:\\\\")
| eval drive=substr(img, 1, 2)
| stats count AS runs dc(Image) AS programs values(Image) AS images max(_time) AS last_seen BY host drive
| convert ctime(last_seen)Elastic
FROM logs-endpoint.events.process-*
| WHERE @timestamp >= NOW() - 30 days AND event.action == "start"
| EVAL exe = TO_LOWER(process.executable)
| WHERE exe RLIKE """[d-z]:\\.*"""
| EVAL drive = SUBSTRING(exe, 1, 2)
| STATS runs = COUNT(*), images = VALUES(process.executable), last_seen = MAX(@timestamp) BY host.name, drive
| SORT host.nameCrowdStrike
// set the time picker to the last 30 days
#event_simpleName=/^(RemovableMediaVolumeMounted|ProcessRollup2)$/
| case {
#event_simpleName=RemovableMediaVolumeMounted | kind := "usb mount" ;
#event_simpleName=ProcessRollup2 | ImageFileName=/^\\Device\\HarddiskVolume(?<vol>\d+)\\/ | vol!="YOUR_SYSTEM_VOLUME_NUMBER" | kind := "process off system volume" }
| default(field=ImageFileName, value="n/a")
| groupBy([aid, kind], function=[count(as=events), collect([ImageFileName]), max(@timestamp, as=last_seen)])Microsoft KQL
union
(DeviceEvents
| where Timestamp > ago(30d) and ActionType == "UsbDriveMounted"
| extend Kind = "usb mount", Detail = tostring(AdditionalFields)),
(DeviceProcessEvents
| where Timestamp > ago(30d) and FolderPath matches regex @"(?i)^[d-z]:\\"
| extend Kind = "process off system drive", Detail = FolderPath)
| summarize Events = count(), Details = make_set(Detail, 20), LastSeen = max(Timestamp) by DeviceName, Kind
| order by DeviceName ascHunt 1: 7z.dll run from a temp folder
This core hunt finds rundll32.exe running 7z.dll from a temp folder, plus, by our choice, any rundll32.exe whose parent runs from a temp path.
Field mapping: Falcon gives the parent's name, not its path, so CrowdStrike tests the command line only.
False positives: real installers do this too, so check the DLL.
Splunk
index=YOUR_SYSMON_INDEX (source="XmlWinEventLog:Microsoft-Windows-Sysmon/Operational" OR sourcetype="XmlWinEventLog:Microsoft-Windows-Sysmon/Operational") EventCode=1 earliest=1767225600 latest=now
| eval child=lower(mvindex(split(Image, "\\"), -1)), cl=lower(CommandLine), pimg=lower(ParentImage)
| where child=="rundll32.exe" AND (match(cl, "\\\\temp\\\\.*7z[.]dll") OR match(pimg, "\\\\temp\\\\"))
| fillnull value="unknown" User
| stats count AS runs values(CommandLine) AS commands values(ParentImage) AS parents min(_time) AS first_seen max(_time) AS last_seen BY host User
| convert ctime(first_seen) ctime(last_seen)Elastic
FROM logs-endpoint.events.process-*
| WHERE @timestamp >= TO_DATETIME("2026-01-01T00:00:00.000Z") AND event.action == "start"
| EVAL child = TO_LOWER(process.name), cl = TO_LOWER(process.command_line), pexe = TO_LOWER(process.parent.executable)
| WHERE child == "rundll32.exe" AND (cl LIKE """*\\temp\\*7z.dll*""" OR pexe LIKE """*\\temp\\*""")
| STATS runs = COUNT(*), commands = VALUES(process.command_line), parents = VALUES(process.parent.executable), first_seen = MIN(@timestamp), last_seen = MAX(@timestamp) BY host.name, user.nameCrowdStrike
// set the time picker to start on or before 2026-01-01
#event_simpleName=ProcessRollup2
| test(@timestamp >= 1767225600000)
| FileName=/^rundll32\.exe$/i
| CommandLine=/\\Temp\\.*7z\.dll/i
| default(field=[UserName, ParentBaseFileName], value="unknown")
| groupBy([aid, UserName, ParentBaseFileName], function=[count(as=runs), collect([CommandLine]), min(@timestamp, as=first_seen), max(@timestamp, as=last_seen)])Microsoft KQL
DeviceProcessEvents
| where Timestamp >= datetime(2026-01-01T00:00:00Z)
| where FileName =~ "rundll32.exe"
| where ProcessCommandLine matches regex @"(?i)\\temp\\.*7z\.dll" or InitiatingProcessFolderPath contains @"\temp\"
| summarize Runs = count(), Commands = make_set(ProcessCommandLine, 50), Parents = make_set(InitiatingProcessFolderPath, 20), FirstSeen = min(Timestamp), LastSeen = max(Timestamp) by DeviceName, AccountNameHunt 2: eight-hex Run and StartupApproved values, and the DLL copy
This finds a Run or StartupApproved value named like b79faace.dll, plus a DLL written to an eight-hex folder under ProgramData or AppData\Local.
Field mapping: registry and file events only catch writes inside the window, so Hunt 3 covers older infections.
False positives: random hex folders exist, but rarely with a SetCodecs Run value.
Splunk
index=YOUR_SYSMON_INDEX (source="XmlWinEventLog:Microsoft-Windows-Sysmon/Operational" OR sourcetype="XmlWinEventLog:Microsoft-Windows-Sysmon/Operational") (EventCode=13 OR EventCode=11) earliest=1767225600 latest=now
| eval key=lower(TargetObject), tf=lower(TargetFilename)
| where (EventCode==13 AND match(key, "\\\\currentversion\\\\(run|explorer\\\\startupapproved\\\\run)\\\\[0-9a-f]{8}[.]dll$")) OR (EventCode==11 AND match(tf, "\\\\(programdata|appdata\\\\local)\\\\[0-9a-f]{8}\\\\[0-9a-f]{8}[.]dll$"))
| eval item=coalesce(TargetObject, TargetFilename)
| stats count AS events values(Details) AS data values(Image) AS writer min(_time) AS first_seen max(_time) AS last_seen BY host EventCode item
| convert ctime(first_seen) ctime(last_seen)Elastic
FROM logs-endpoint.events.registry-*, logs-endpoint.events.file-*
| WHERE @timestamp >= TO_DATETIME("2026-01-01T00:00:00.000Z")
| EVAL rp = TO_LOWER(registry.path), fp = TO_LOWER(file.path)
| WHERE rp RLIKE """.*\\currentversion\\(run|explorer\\startupapproved\\run)\\[0-9a-f]{8}\.dll"""
OR fp RLIKE """.*\\(programdata|appdata\\local)\\[0-9a-f]{8}\\[0-9a-f]{8}\.dll"""
| EVAL item = COALESCE(registry.path, file.path)
| STATS events = COUNT(*), data = VALUES(registry.data.strings), writer = VALUES(process.name), first_seen = MIN(@timestamp), last_seen = MAX(@timestamp) BY host.name, event.dataset, itemCrowdStrike
// set the time picker to start on or before 2026-01-01
#event_simpleName=/^(AsepValueUpdate|RegGenericValueUpdate|PeFileWritten|NewExecutableWritten)$/
| test(@timestamp >= 1767225600000)
| case {
#event_simpleName=/ValueUpdate$/ | RegObjectName=/\\CurrentVersion\\(Run|Explorer\\StartupApproved\\Run)$/i | RegValueName=/^[0-9a-f]{8}\.dll$/i | item := RegValueName ;
#event_simpleName=/Written$/ | TargetFileName=/\\(ProgramData|AppData\\Local)\\[0-9a-f]{8}\\[0-9a-f]{8}\.dll$/i | item := TargetFileName }
| default(field=[RegObjectName, RegStringValue], value="n/a")
| groupBy([aid, #event_simpleName, item], function=[count(as=events), collect([RegObjectName, RegStringValue]), min(@timestamp, as=first_seen), max(@timestamp, as=last_seen)])Microsoft KQL
union
(DeviceRegistryEvents
| where Timestamp >= datetime(2026-01-01T00:00:00Z)
| where ActionType == "RegistryValueSet"
| where RegistryKey matches regex @"(?i)\\CurrentVersion\\(Run|Explorer\\StartupApproved\\Run)$" and RegistryValueName matches regex @"(?i)^[0-9a-f]{8}\.dll$"
| extend Item = strcat(RegistryKey, @"\", RegistryValueName), Data = RegistryValueData),
(DeviceFileEvents
| where Timestamp >= datetime(2026-01-01T00:00:00Z)
| where FolderPath matches regex @"(?i)\\(ProgramData|AppData\\Local)\\[0-9a-f]{8}\\[0-9a-f]{8}\.dll$"
| extend Item = FolderPath, Data = "")
| summarize Events = count(), Data = make_set(Data, 10), Writers = make_set(InitiatingProcessFileName, 10), FirstSeen = min(Timestamp), LastSeen = max(Timestamp) by DeviceName, ItemHunt 3: rundll32.exe calling SetCodecs
This finds rundll32.exe calling the SetCodecs export from outside the 7-Zip folder. The Run value fires at each logon, so older infections show too.
Field mapping: the 7-Zip exclusion assumes a default Program Files install.
False positives: we expect very few.
Splunk
index=YOUR_SYSMON_INDEX (source="XmlWinEventLog:Microsoft-Windows-Sysmon/Operational" OR sourcetype="XmlWinEventLog:Microsoft-Windows-Sysmon/Operational") EventCode=1 earliest=1767225600 latest=now
| eval child=lower(mvindex(split(Image, "\\"), -1)), cl=lower(CommandLine)
| where child=="rundll32.exe" AND match(cl, ",\\s*setcodecs") AND NOT match(cl, "\\\\program files( [(]x86[)])?\\\\7-zip\\\\")
| fillnull value="unknown" User
| stats count AS runs values(ParentImage) AS parents min(_time) AS first_seen max(_time) AS last_seen BY host User CommandLine
| convert ctime(first_seen) ctime(last_seen)Elastic
FROM logs-endpoint.events.process-*
| WHERE @timestamp >= TO_DATETIME("2026-01-01T00:00:00.000Z") AND event.action == "start"
| EVAL child = TO_LOWER(process.name), cl = TO_LOWER(process.command_line)
| WHERE child == "rundll32.exe" AND cl LIKE "*setcodecs*" AND NOT cl LIKE """*\\program files*\\7-zip\\*"""
| STATS runs = COUNT(*), parents = VALUES(process.parent.name), first_seen = MIN(@timestamp), last_seen = MAX(@timestamp) BY host.name, user.name, process.command_lineCrowdStrike
// set the time picker to start on or before 2026-01-01
#event_simpleName=ProcessRollup2
| test(@timestamp >= 1767225600000)
| FileName=/^rundll32\.exe$/i
| CommandLine=/,\s*SetCodecs/i
| CommandLine!=/\\Program Files( \(x86\))?\\7-Zip\\/i
| default(field=[UserName, ParentBaseFileName], value="unknown")
| groupBy([aid, UserName, CommandLine], function=[count(as=runs), collect([ParentBaseFileName]), min(@timestamp, as=first_seen), max(@timestamp, as=last_seen)])Microsoft KQL
DeviceProcessEvents
| where Timestamp >= datetime(2026-01-01T00:00:00Z)
| where FileName =~ "rundll32.exe" and ProcessCommandLine has "SetCodecs"
| where not(ProcessCommandLine matches regex @"(?i)\\Program Files( \(x86\))?\\7-Zip\\")
| summarize Runs = count(), Parents = make_set(InitiatingProcessFileName, 10), FirstSeen = min(Timestamp), LastSeen = max(Timestamp) by DeviceName, AccountName, ProcessCommandLineHunt 4: injection hosts started by rundll32.exe
This noisy behavior hunt finds dllhost.exe, WerFault.exe, svchost.exe, OpenWith.exe or AtBroker.exe started by rundll32.exe and then connecting out on port 443, which we chose to stand for HTTPS.
Field mapping: Splunk, Elastic and CrowdStrike join process start to network events by process ID; Defender carries the parent on the network event.
False positives: we expect legitimate software to start these from rundll32.exe, so baseline before alerting.
Splunk
index=YOUR_SYSMON_INDEX (source="XmlWinEventLog:Microsoft-Windows-Sysmon/Operational" OR sourcetype="XmlWinEventLog:Microsoft-Windows-Sysmon/Operational") (EventCode=1 OR (EventCode=3 Initiated=true)) earliest=1767225600 latest=now
| eval parent=lower(mvindex(split(ParentImage, "\\"), -1)), proc=lower(mvindex(split(Image, "\\"), -1))
| eval spawned=if(EventCode==1 AND parent=="rundll32.exe" AND in(proc, "dllhost.exe", "werfault.exe", "svchost.exe", "openwith.exe", "atbroker.exe"), 1, 0), https=if(EventCode==3 AND tonumber(DestinationPort)==443, 1, 0)
| stats max(spawned) AS spawned sum(https) AS https_conns values(proc) AS proc values(DestinationIp) AS dests values(CommandLine) AS commands min(_time) AS first_seen BY host ProcessGuid
| where spawned==1 AND https_conns>0
| convert ctime(first_seen)Elastic
FROM logs-endpoint.events.process-*, logs-endpoint.events.network-*
| WHERE @timestamp >= TO_DATETIME("2026-01-01T00:00:00.000Z")
| EVAL parent = TO_LOWER(process.parent.name), proc = TO_LOWER(process.name)
| EVAL spawned = CASE(event.dataset == "endpoint.events.process" AND event.action == "start" AND parent == "rundll32.exe" AND proc IN ("dllhost.exe", "werfault.exe", "svchost.exe", "openwith.exe", "atbroker.exe"), 1, 0),
https = CASE(event.dataset == "endpoint.events.network" AND destination.port == 443, 1, 0)
| STATS spawned = MAX(spawned), https_conns = SUM(https), procs = VALUES(process.name), dests = VALUES(destination.ip), first_seen = MIN(@timestamp) BY host.name, process.entity_id
| WHERE spawned == 1 AND https_conns > 0CrowdStrike
// set the time picker to start on or before 2026-01-01
#event_simpleName=/^(ProcessRollup2|NetworkConnectIP4)$/
| test(@timestamp >= 1767225600000)
| case {
#event_simpleName=ProcessRollup2 | ParentBaseFileName=/^rundll32\.exe$/i | FileName=/^(dllhost|WerFault|svchost|OpenWith|AtBroker)\.exe$/i | ContextProcessId := TargetProcessId | proc := FileName ;
#event_simpleName=NetworkConnectIP4 | RemotePort=443 | https := 1 }
| selfJoinFilter(field=[aid, ContextProcessId], where=[{#event_simpleName=ProcessRollup2}, {#event_simpleName=NetworkConnectIP4}])
| groupBy([aid, ContextProcessId], function=[count(field=proc, as=spawns), collect([proc, RemoteAddressIP4]), sum(https, as=https_conns), min(@timestamp, as=first_seen)], limit=max)
| test(spawns > 0)
| test(https_conns > 0)Microsoft KQL
DeviceNetworkEvents
| where Timestamp >= datetime(2026-01-01T00:00:00Z)
| where InitiatingProcessFileName in~ ("dllhost.exe", "WerFault.exe", "svchost.exe", "OpenWith.exe", "AtBroker.exe") and InitiatingProcessParentFileName =~ "rundll32.exe"
| where RemotePort == 443 and ActionType == "ConnectionSuccess"
| summarize Connections = count(), RemoteUrls = make_set(RemoteUrl, 20), RemoteIPs = make_set(RemoteIP, 20), FirstSeen = min(Timestamp), LastSeen = max(Timestamp) by DeviceName, InitiatingProcessFileName, InitiatingProcessIdHunt 5: C2 domains and request paths
This matches DNS or proxy traffic to the listed domains, the CoffeeLoader /payload?md5= path, and the Retadup path shape with a WinHttp user agent.
Field mapping: proxy fields are CIM, ECS and CommonSecurityLog placeholders, and the CoffeeLoader path only appears where you inspect TLS.
False positives: path patterns alone can match other software, so the Retadup branch also requires WinHttp.
Splunk
(index=YOUR_SYSMON_INDEX (source="XmlWinEventLog:Microsoft-Windows-Sysmon/Operational" OR sourcetype="XmlWinEventLog:Microsoft-Windows-Sysmon/Operational") EventCode=22) OR (index=YOUR_PROXY_INDEX) earliest=1767225600 latest=now
| eval h=lower(coalesce(QueryName, url_domain, dest)), u=lower(coalesce(url, uri, "")), ua=coalesce(http_user_agent, "")
| where match(h, "(^|[.])(alphanoob[.]com|newblackage[.]com|newminersage[.]com|radnewage[.]com|minernewage[.]com|rad2016[.]publicvm[.]com|radpal[.]publicvm[.]com|roro2016[.]linkpc[.]net|internet-speed-check[.]com|rurjfvn[.]rs)$") OR match(u, "/payload[?]md5=") OR (match(u, "^(https?://[^/]+)?/[0-9a-f]{32}/\\d+/\\d+/\\d+/\\d+/") AND match(ua, "(?i)winhttp"))
| eval indicator=case(match(u, "/payload[?]md5="), "coffeeloader path", match(u, "^(https?://[^/]+)?/[0-9a-f]{32}/"), "retadup path", true(), h)
| stats count AS hits values(Image) AS processes values(src) AS sources min(_time) AS first_seen max(_time) AS last_seen BY host indicator
| convert ctime(first_seen) ctime(last_seen)Elastic
FROM logs-endpoint.events.network-*, YOUR_PROXY_INDEX
| WHERE @timestamp >= TO_DATETIME("2026-01-01T00:00:00.000Z")
| EVAL h = TO_LOWER(COALESCE(dns.question.name, url.domain)), u = TO_LOWER(url.original), ua = TO_LOWER(user_agent.original)
| WHERE h RLIKE """(.*\.)?(alphanoob\.com|newblackage\.com|newminersage\.com|radnewage\.com|minernewage\.com|rad2016\.publicvm\.com|radpal\.publicvm\.com|roro2016\.linkpc\.net|internet-speed-check\.com|rurjfvn\.rs)"""
OR u RLIKE """.*/payload\?md5=.*"""
OR (u RLIKE """(https?://[^/]+)?/[0-9a-f]{32}/[0-9]+/[0-9]+/[0-9]+/[0-9]+/.*""" AND ua LIKE "*winhttp*")
| STATS hits = COUNT(*), first_seen = MIN(@timestamp), last_seen = MAX(@timestamp) BY host.name, process.name, h, uCrowdStrike
// set the time picker to start on or before 2026-01-01
#event_simpleName=DnsRequest or #repo=YOUR_PROXY_REPO
| test(@timestamp >= 1767225600000)
| case {
#event_simpleName=DnsRequest | DomainName=/(^|\.)(alphanoob\.com|newblackage\.com|newminersage\.com|radnewage\.com|minernewage\.com|rad2016\.publicvm\.com|radpal\.publicvm\.com|roro2016\.linkpc\.net|internet-speed-check\.com|rurjfvn\.rs)$/i | indicator := DomainName ;
url.original=/\/payload\?md5=/i | indicator := "coffeeloader path" ;
url.original=/^(https?:\/\/[^\/]+)?\/[0-9a-f]{32}\/\d+\/\d+\/\d+\/\d+\//i | user_agent.original=/winhttp/i | indicator := "retadup path" ;
url.domain=/(^|\.)(alphanoob\.com|newblackage\.com|newminersage\.com|radnewage\.com|minernewage\.com|rad2016\.publicvm\.com|radpal\.publicvm\.com|roro2016\.linkpc\.net|internet-speed-check\.com|rurjfvn\.rs)$/i | indicator := url.domain }
| default(field=[aid, source.ip], value="n/a")
| groupBy([aid, source.ip, indicator], function=[count(as=hits), min(@timestamp, as=first_seen), max(@timestamp, as=last_seen)])Microsoft KQL
let doms = dynamic(["alphanoob.com", "newblackage.com", "newminersage.com", "radnewage.com", "minernewage.com", "rad2016.publicvm.com", "radpal.publicvm.com", "roro2016.linkpc.net", "internet-speed-check.com", "rurjfvn.rs"]);
union isfuzzy=true
(DeviceNetworkEvents
| where Timestamp >= datetime(2026-01-01T00:00:00Z)
| where RemoteUrl has_any (doms)
| extend Indicator = RemoteUrl, Source = InitiatingProcessFileName),
(DeviceEvents
| where Timestamp >= datetime(2026-01-01T00:00:00Z)
| where ActionType == "DnsQueryResponse" and tostring(AdditionalFields) has_any (doms)
| extend Indicator = "dns lookup", Source = InitiatingProcessFileName),
(CommonSecurityLog
| where TimeGenerated >= datetime(2026-01-01T00:00:00Z)
| where DestinationHostName has_any (doms) or RequestURL contains "/payload?md5=" or (RequestURL matches regex @"(?i)/[0-9a-f]{32}/\d+/\d+/\d+/\d+/" and RequestClientApplication contains "WinHttp")
| extend Timestamp = TimeGenerated, DeviceName = SourceIP, Indicator = iff(isnotempty(DestinationHostName), DestinationHostName, RequestURL), Source = "proxy")
| summarize Hits = count(), FirstSeen = min(Timestamp), LastSeen = max(Timestamp) by DeviceName, Indicator, SourceHunt 6: scripts and shortcuts run from a removable drive
This finds AutoIt or AutoHotkey interpreters tied to a removable drive, and programs on it started by Explorer, as a clicked shortcut would. The Explorer test and D: to Z: range are our choices.
False positives: portable apps on USB sticks will appear, so check what the drive holds.
Splunk
index=YOUR_SYSMON_INDEX (source="XmlWinEventLog:Microsoft-Windows-Sysmon/Operational" OR sourcetype="XmlWinEventLog:Microsoft-Windows-Sysmon/Operational") EventCode=1 earliest=1767225600 latest=now
| eval img=lower(Image), child=mvindex(split(lower(Image), "\\"), -1), parent=lower(mvindex(split(ParentImage, "\\"), -1)), cl=lower(CommandLine)
| where (match(child, "^(autoit|autohotkey)") AND (match(img, "^[d-z]:\\\\") OR match(cl, "[d-z]:\\\\"))) OR (match(img, "^[d-z]:\\\\") AND parent=="explorer.exe")
| fillnull value="unknown" User
| stats count AS runs values(CommandLine) AS commands min(_time) AS first_seen max(_time) AS last_seen BY host User Image parent
| convert ctime(first_seen) ctime(last_seen)Elastic
FROM logs-endpoint.events.process-*
| WHERE @timestamp >= TO_DATETIME("2026-01-01T00:00:00.000Z") AND event.action == "start"
| EVAL exe = TO_LOWER(process.executable), child = TO_LOWER(process.name), parent = TO_LOWER(process.parent.name), cl = TO_LOWER(process.command_line)
| WHERE ((child LIKE "autoit*" OR child LIKE "autohotkey*") AND (exe RLIKE """[d-z]:\\.*""" OR cl RLIKE """.*[d-z]:\\.*"""))
OR (exe RLIKE """[d-z]:\\.*""" AND parent == "explorer.exe")
| STATS runs = COUNT(*), commands = VALUES(process.command_line), first_seen = MIN(@timestamp), last_seen = MAX(@timestamp) BY host.name, user.name, process.executable, parentCrowdStrike
// set the time picker to start on or before 2026-01-01
#event_simpleName=ProcessRollup2
| test(@timestamp >= 1767225600000)
| ImageFileName=/^\\Device\\HarddiskVolume(?<vol>\d+)\\/
| case {
FileName=/^(AutoIt|AutoHotkey)/i | vol!="YOUR_SYSTEM_VOLUME_NUMBER" ;
FileName=/^(AutoIt|AutoHotkey)/i | CommandLine=/[D-Z]:\\/i ;
vol!="YOUR_SYSTEM_VOLUME_NUMBER" | ParentBaseFileName=/^explorer\.exe$/i }
| default(field=UserName, value="unknown")
| groupBy([aid, UserName, ImageFileName, ParentBaseFileName], function=[count(as=runs), collect([CommandLine]), min(@timestamp, as=first_seen), max(@timestamp, as=last_seen)])Microsoft KQL
DeviceProcessEvents
| where Timestamp >= datetime(2026-01-01T00:00:00Z)
| where ((FileName startswith "AutoIt" or FileName startswith "AutoHotkey") and (FolderPath matches regex @"(?i)^[d-z]:\\" or ProcessCommandLine matches regex @"(?i)[d-z]:\\"))
or (FolderPath matches regex @"(?i)^[d-z]:\\" and InitiatingProcessFileName =~ "explorer.exe")
| summarize Runs = count(), Commands = make_set(ProcessCommandLine, 50), FirstSeen = min(Timestamp), LastSeen = max(Timestamp) by DeviceName, AccountName, FolderPath, InitiatingProcessFileNameIndicators from Kaspersky
Type | Indicator | Kaspersky description |
Domain | alphanoob[.]com | Most active Retadup C2 servers |
Domain | newblackage[.]com | Most active Retadup C2 servers |
Domain | newminersage[.]com | Most active Retadup C2 servers |
Domain | radnewage[.]com | Most active Retadup C2 servers |
Domain | minernewage[.]com | Most active Retadup C2 servers |
Domain | rad2016.publicvm[.]com | Most active Retadup C2 servers |
Domain | radpal.publicvm[.]com | Most active Retadup C2 servers |
Domain | roro2016.linkpc[.]net | Most active Retadup C2 servers |
Domain | internet-speed-check[.]com | CoffeeLoader C2 |
URL | rurjfvn[.]rs/update.exe | Servers hosting CoffeeLoader files |
URL | alphanoob[.]com/update.exe | Servers hosting CoffeeLoader files |
MD5 | 2272dde17925d6179bea6fcf4d543d20 | CoffeeLoader MD5 (DLL files) |
MD5 | dce55eec553f6af16ba6481eaacb8638 | CoffeeLoader MD5 (DLL files) |
MD5 | 449c9e8bc6eb308aa3c46c88959e1a4f | CoffeeLoader MD5 (DLL files) |
MD5 | 58886d45a0c5e802a5d0a7545c36112d | CoffeeLoader MD5 (NSIS-based installers) |
MD5 | cca710c5455c1fe2732771afbac16a09 | CoffeeLoader MD5 (NSIS-based installers) |
Reading the results before you escalate
Test 1 measures exposure, not infection, but it shows where device control matters most.
In our judgment, a Hunt 3 hit or Hunt 2 Run value is close to proof, matching the persistence Kaspersky documented; isolate the host and preserve evidence. A Hunt 1 hit may be the installer stage, so check the DLL. Hunt 4 alone is a noisy lead. A Hunt 5 hit means finding the process and the drive behind it. A Hunt 6 hit means finding that drive and every PC it touched. Escalate to incident response when persistence and a further download appear on the same host.
One next step
If your clients run on Microsoft 365, start with a free Inception Foresight M365 Assessment.



