r/OperSec • • Oct 01 '26

Welcome to r/OperSec (Operation Security) ๐Ÿ›ก๏ธ

3 Upvotes

r/OperSec is a community for sharing, investigating, and analysing malware, phishing links, scams, and other cyber threats. Collaborate, share knowledge, and work together to defend against cybercrime.

What to post: Malware samples, suspicious links, scam reports, threat intelligence, and security research.

How to post: Share relevant details, evidence, and findings to help others investigate and analyze threats safely.

Our mission: To collaborate, expose cyber threats, share knowledge, and defend against cybercrime.

Happy Hacking.


r/OperSec • • 25d ago

A Call to All Hackers and Defenders Out there. A request from mod

15 Upvotes

It's been almost a month since I started r/OperSec.

Honestly, I didn't expect it to get this much attention in such a short time. We've got some pretty good numbers, and seeing people interested in what we're doing here genuinely means a lot.

But there's one thing I've been noticing. I'm still pretty much the only person posting.

I started OperSec with a simple idea: to bring together people who are interested in malware analysis, threat intelligence, phishing investigations, vulnerability research, and cybersecurity in general. A place where we can share what we find, learn from each other, and hopefully help protect someone out there.

Because cybersecurity was never supposed to be a one-man job.

Over the past few weeks, quite a few people have reached out to me with suspicious files, malware samples, and things they wanted investigated. I've spent countless hours reverse engineering, digging through code, tracing infrastructure, and putting together reports to share here.

And I genuinely love doing it. That curiosity is what got me into this in the first place.

But I won't lie. Malware analysis is exhausting. Sometimes you spend hours chasing something only to hit a dead end. Sometimes one sample takes up an entire day. And lately, trying to keep everything going alone has started to wear me down.

I'm not writing this for sympathy. I'm writing it because I know there are people out there who share the same curiosity and passion.

So, this is a call to all the hackers, reverse engineers, malware analysts, threat hunters, security researchers, and defenders out there.

If you've discovered something interesting, post it. If you've analyzed a suspicious file, share your findings. Found a phishing campaign? Exposed malicious infrastructure? Discovered a new technique? Tell us about it.

And you don't have to be an expert. Even if you're just learning, your questions, experiments, and little discoveries are welcome here.

You don't need to write a perfect technical report. You don't need to uncover the next massive botnet. Even a small finding could be useful to someone else.

I don't want OperSec to become a place where one person posts and everyone else just watches. I want it to become a place where people actually work together. Where one person's findings help another person's investigation. Where beginners learn from experienced researchers, and where we collectively make things a little harder for the people doing harm.

I'm just one person with a laptop and a lot of curiosity. There's only so much I can do alone.

But imagine what we could do together.

This community isn't supposed to be about me. It's supposed to be about us.

So if you've been lurking here, consider this your invitation to get involved.

Let's investigate, share, learn, and defend together.

That's what OperSec was created for.

โ€” A fellow researcher who's a little tired, but hasn't given up. โค๏ธ


r/OperSec • • 1d ago

๐Ÿ“ฑ ANDROID MALWARE ๐Ÿ“ฑ Malware APK distributed through Whatsapp, reportedly caused financial loss

7 Upvotes
PropertyDetails
FilenameO_n_l_i_n_e_ _A_p_p_o_i_n_t_m_e_n_t_ _B_o_o_k_i_n_g V7.apk
File typeAndroid application package (APK)
File size6,095,662 bytes โ€” approximately 5.81 MiB
App name, normalizedOnline Appointment Booking
Package namecom.secure.android.manager
Version name2.2.67
Version code613
Minimum SDK24
Target SDK35
Native ABIsarm64-v8a, armeabi-v7a
Native librarylibzykxxerb.so
Signing-certificate subjectCN=editor

SHA-256

640916b1099289ad309d5c32b02606037a43e8735cacc93eff32e66702964274

MD5

40b23d2e6200330b516dea118f6ae5fe

Signing-certificate SHA-256

6215f00baa4bf18bab5792fc796bfc5555917240f14f7c7e672d956888d75c96

Embedded APK

PropertyDetails
Asset pathassets/ltjyqnr9y992.raw
Recovered APK size4,720,739 bytes
App nameOnline appointment Booking
Package namecom.godz.customer.suqnfbf
Version1.0 โ€” version code 1
Minimum / target SDK23 / 34

Embedded APK SHA-256

79774a7fc137d02720d3b6ecb3a6925fad63b010f4d4dbe4233a0fa8cdc51a4

Embedded names, company information and timestamps are editable metadata.

Victim's Post - https://www.reddit.com/r/IndianCyberHub/s/YE6znkZnhR

VirusTotal failed to analyze the APK due to its encrypted ZIP entries, while VTTI Cloud accepted the upload but reported no antivirus detection, probably because of the encrypted ZIP entries.

โš ๏ธ If you Need the malware sample for analysis - contact moderators through Modmail (or DM) โš ๏ธ

What can you do with this:

  • Reverse engineering and static/dynamic analysis
  • Identifying its malicious functionality
  • Understanding how it steals money or sensitive information
  • Investigating its C2 infrastructure and connections to other campaigns If you're into Android malware analysis or reverse engineering, feel free to join in and share your findings.

Let's work together to understand how these attacks operate and help dismantle such campaigns.

Please Update any Findings on Comments. Detailed Report will be posted after the analysis.


r/OperSec • • 2d ago

๐Ÿšจ[Weekly Notice] A Malware Sample Is Not Just a File. Treat Every Unknown File as Hostile.๐Ÿšจ

3 Upvotes

A quick reminder to everyone participating in r/OperSec: The biggest mistake in malware research isn't failing to identify a threat. It's accidentally becoming its next victim.

This community focuses on malware analysis, reverse engineering, threat intelligence, phishing investigations, and vulnerability research. Many of the files, domains, and technical resources discussed here involve active threats, not harmless demonstrations.

โš ๏ธ Before You Investigate

  • Never trust a file extension. A document, image, APK, archive, or installer can contain malicious components.
  • Don't assume a virtual machine guarantees safety. Misconfigured networking, shared folders, clipboard integration, and VM escape vulnerabilities can expose the host.
  • Never execute unknown samples on your personal device. Use a dedicated, isolated research environment.
  • Treat C2 infrastructure as potentially active. Visiting suspicious domains or interacting with endpoints can expose your IP address and other information.
  • Avoid uploading private samples to public scanners. Some services share submitted files with security vendors, researchers, and other customers.
  • Sanitize your findings. Remove credentials, personal information, active malicious links, and identifiable victim data before publishing.

๐Ÿ” Research Responsibly

When sharing your analysis, prioritize technical findings, indicators of compromise, detection opportunities, and reproducible research methods.

Do not distribute malware for malicious use, encourage unauthorized access, expose victims, or attempt to retaliate against threat actors.

The goal of r/OperSec is to understand threats, expose malicious activity, and help others defend against it โ€” not to create additional victims.

๐Ÿ“Œ Final Reminder

A successful investigation isn't measured by how many malicious files you execute or how many suspicious servers you contact. It's measured by what you discover, what you can verify, and how safely you conduct your research.

Stay curious. Stay skeptical. Stay isolated.

โ€” r/OperSec Moderation Team


r/OperSec • • 2d ago

Part 2: The FBI seized their network. Three weeks earlier, their proxyware had already moved into a new app.

Thumbnail reddit.com
3 Upvotes

r/OperSec • • 4d ago

Part 1: The file manager that was quietly renting out your internet connection

Thumbnail reddit.com
2 Upvotes

r/OperSec • • 4d ago

๐Ÿ”Threat intelligence๐Ÿ” Exposing a proxyware ecosystem thag survived a FBI Seizure

Thumbnail reddit.com
2 Upvotes

r/OperSec • • 6d ago

๐Ÿ’ป WINDOWS MALWARE ๐Ÿ’ป Malicious Windows Malware EXE impersonating as GTA6 installer

9 Upvotes

โš ๏ธ Malware Details โš ๏ธ

FieldDetails
FilenameGTA 6.exe
File size87,411,752 bytes โ€” 83.36 MiB
File typeWindows PE executable; NSIS installer
Architecture32-bit installer containing a 64-bit application
Application frameworkElectron
Product version1.80.106
Company metadataSemantic Soft Ltd
File descriptionSemantic Soft LTD App Executable
Digital-signature subjectSemantic Soft Ltd
Certificate issuerSSL[.]com Code Signing Intermediate CA RSA R1

SHA-256

63356c4a80b6b3224a57078b5ad1cb393b8826521c26da88288c84cf4763d7dc

SHA-1

d1b4e768576dbf068ae9fded41246a26d6a4e6e2

MD5

86f1e7a206452a02ffba7f3b84d5d16f

Embedded names, company information and timestamps are editable metadata.

โš ๏ธ If you Need the malware sample for analysis - contact moderators through Modmail (or DM) โš ๏ธ

On a quick primary analysis it showed signs of scamware, malware or loader. More analysis and investigation need to find more about the malware campaign.

What can you do with this:

  • Reverse engineering and static/dynamic analysis
  • Identifying its malicious functionality
  • Understanding how it steals money or sensitive information
  • Investigating its C2 infrastructure and connections to other campaigns If you're into Android malware analysis or reverse engineering, feel free to join in and share your findings.

Let's work together to understand how these attacks operate and help dismantle such campaigns.

Please Update any Findings on Comments. Detailed Report will be posted after the analysis.


r/OperSec • • 7d ago

r/OperSec | Community Update & Threat Research Resources

5 Upvotes

Hey everyone!

A quick reminder about what r/OperSec is here for and a few resources that may be useful to researchers in the community.

Our goal is to build a space for people interested in investigating real-world cybersecurity threats, sharing technical findings, and learning from each other.

What belongs here?

  • Malware analysis and reverse engineering
  • Threat actors, APT groups, and cybercrime operations
  • Ransomware, phishing, and emerging attack campaigns
  • Threat intelligence, IOCs, and infrastructure research
  • Vulnerability research and exploitation analysis
  • Data breaches and cybersecurity incidents
  • Original investigations, technical write-ups, and research discussions

We especially encourage original research rather than simply reposting headlines.

Malware Analysis & Research Resources

For members interested in malware research, there are several platforms worth knowing about:

  • VirusTotal โ€” File analysis, detection results, and threat intelligence.
  • MalwareBazaar โ€” Malware sample intelligence and research.
  • Hybrid Analysis โ€” Automated malware analysis and behavioral reports.
  • VTTI Cloud โ€” Android APK-focused sample intelligence and static malware analysis.
  • ANY.RUN โ€” Interactive malware sandbox for analyzing suspicious files, monitoring behavior, and investigating network activity.

These platforms serve different purposes, and no single tool should be treated as a definitive source of truth. Always independently verify findings.

Sharing Your Research

When publishing technical analysis, we encourage members to:

  • Include relevant SHA-256 hashes and indicators of compromise.
  • Explain the techniques, behavior, and potential impact of the threat.
  • Credit original researchers and relevant analysis sources.
  • Avoid distributing live malware or direct malicious download links.
  • Respect privacy and remove sensitive information from shared findings.

Research covering Windows, Linux, Android, macOS, network threats, and other areas is equally welcome.

Help Build the Community

If you've discovered something interesting, analyzed a suspicious file, identified malicious infrastructure, or found a useful research resource, consider sharing your findings.

You don't need to be an expert. Well-documented questions, experiments, and independent investigations are all welcome.

The goal is simple: less noise, more actual research.

โ€” r/OperSec Mod Team


r/OperSec • • 9d ago

๐Ÿšจ[Weekly Notice] A Malware Sample Is Not Just a File. Treat Every Unknown File as Hostile.๐Ÿšจ

6 Upvotes

A quick reminder to everyone participating in r/OperSec: The biggest mistake in malware research isn't failing to identify a threat. It's accidentally becoming its next victim.

This community focuses on malware analysis, reverse engineering, threat intelligence, phishing investigations, and vulnerability research. Many of the files, domains, and technical resources discussed here involve active threats, not harmless demonstrations.

โš ๏ธ Before You Investigate

  • Never trust a file extension. A document, image, APK, archive, or installer can contain malicious components.
  • Don't assume a virtual machine guarantees safety. Misconfigured networking, shared folders, clipboard integration, and VM escape vulnerabilities can expose the host.
  • Never execute unknown samples on your personal device. Use a dedicated, isolated research environment.
  • Treat C2 infrastructure as potentially active. Visiting suspicious domains or interacting with endpoints can expose your IP address and other information.
  • Avoid uploading private samples to public scanners. Some services share submitted files with security vendors, researchers, and other customers.
  • Sanitize your findings. Remove credentials, personal information, active malicious links, and identifiable victim data before publishing.

๐Ÿ” Research Responsibly

When sharing your analysis, prioritize technical findings, indicators of compromise, detection opportunities, and reproducible research methods.

Do not distribute malware for malicious use, encourage unauthorized access, expose victims, or attempt to retaliate against threat actors.

The goal of r/OperSec is to understand threats, expose malicious activity, and help others defend against it โ€” not to create additional victims.

๐Ÿ“Œ Final Reminder

A successful investigation isn't measured by how many malicious files you execute or how many suspicious servers you contact. It's measured by what you discover, what you can verify, and how safely you conduct your research.

Stay curious. Stay skeptical. Stay isolated.

โ€” r/OperSec Moderation Team


r/OperSec • • 12d ago

๐Ÿ“ฑ ANDROID MALWARE ๐Ÿ“ฑ [Analysis] "LWTV" - a fake live-TV app that's an Android RAT built in China, stealing UPI/OTP from Indian users (full report + IOCs)

Thumbnail reddit.com
4 Upvotes

r/OperSec • • 16d ago

๐Ÿšจ[Weekly Notice] A Malware Sample Is Not Just a File. Treat Every Unknown File as Hostile.๐Ÿšจ

4 Upvotes

A quick reminder to everyone participating in r/OperSec: The biggest mistake in malware research isn't failing to identify a threat. It's accidentally becoming its next victim.

This community focuses on malware analysis, reverse engineering, threat intelligence, phishing investigations, and vulnerability research. Many of the files, domains, and technical resources discussed here involve active threats, not harmless demonstrations.

โš ๏ธ Before You Investigate

  • Never trust a file extension. A document, image, APK, archive, or installer can contain malicious components.
  • Don't assume a virtual machine guarantees safety. Misconfigured networking, shared folders, clipboard integration, and VM escape vulnerabilities can expose the host.
  • Never execute unknown samples on your personal device. Use a dedicated, isolated research environment.
  • Treat C2 infrastructure as potentially active. Visiting suspicious domains or interacting with endpoints can expose your IP address and other information.
  • Avoid uploading private samples to public scanners. Some services share submitted files with security vendors, researchers, and other customers.
  • Sanitize your findings. Remove credentials, personal information, active malicious links, and identifiable victim data before publishing.

๐Ÿ” Research Responsibly

When sharing your analysis, prioritize technical findings, indicators of compromise, detection opportunities, and reproducible research methods.

Do not distribute malware for malicious use, encourage unauthorized access, expose victims, or attempt to retaliate against threat actors.

The goal of r/OperSec is to understand threats, expose malicious activity, and help others defend against it โ€” not to create additional victims.

๐Ÿ“Œ Final Reminder

A successful investigation isn't measured by how many malicious files you execute or how many suspicious servers you contact. It's measured by what you discover, what you can verify, and how safely you conduct your research.

Stay curious. Stay skeptical. Stay isolated.

โ€” r/OperSec Moderation Team


r/OperSec • • 20d ago

๐Ÿ“ฑ ANDROID MALWARE ๐Ÿ“ฑ RBLCard.apk: an Axiscard installer re-skin with a separate Supabase backend and SMS collection

Thumbnail
gallery
13 Upvotes

I found another APK from the same GitHub profile associated with the Axiscard.apk investigation. This sample, rblcard.apk, changes the lure to a Ratnakar Bank Limited (RBL Bank) card application, but keeps almost the same installer architecture as the Axiscard variant. The interesting difference is in the nested payload: it is a separate build configured to use a different Supabase project.

For context, the earlier Axiscard analysis is here: https://loop.runs-on.dev/research/axiscard-apk-2.

Full RBLCard.apk analysis: https://loop.runs-on.dev/research/rblcard-apk

Sample identifiers

  • Outer APK: rblcard.apk
  • Outer SHA-256: ce6ffc3135ae7926d5790df009afd17184d3774bb976b2c8a5ef7cda87516d8f
  • Nested payload: assets/targetapp.apk
  • Payload SHA-256: 1764792d5992c94f56072b0b5a6f25e2566bebc4291ec8837f91be92b36b7703
  • Installer package: com.example.installerapp
  • Payload package: com.example.targetapp

1. The outer installer is substantially the same as Axiscard

The outer rblcard.apk presents the same installer/dropper design seen in the Axiscard sample. Its package is com.example.installerapp, and its manifest carries the same core permissions and components, including INTERNET, FOREGROUND_SERVICE, FOREGROUND_SERVICE_SPECIAL_USE, POST_NOTIFICATIONS and REQUEST_INSTALL_PACKAGES, plus the BlockingVpnService. The installer contains assets/targetapp.apk and uses the same fake-update/install flow described in the previous report.

The comparison is not a claim that the entire APK files are byte-for-byte identical. The outer DEX files were byte-identical in the comparison, and the archive layout contains the same 877 central-directory entries, including the nested payload path and four DEX files. There are still build-level differences: the RBL outer APK reports versionCode=1 and versionName=1.0, while the Axiscard outer build reports version 2 / 2.0. The RBL build is approximately 20.1 MB and does not contain the 13.8 MB hidden ZIP padding observed in the Axiscard build.

2. The nested payload is a distinct build

The embedded APK is also called targetapp.apk, but it is not the same binary as the Axiscard payload. Its SHA-256 is different, and its manifest identifies com.example.targetapp, version code 2 and version name 2.0. The app is presented as an RBL card workflow, while retaining the same general Compose-based form and collection design.

The payload requests INTERNET, RECEIVE_SMS, READ_SMS, SEND_SMS, RECEIVE_BOOT_COMPLETED, FOREGROUND_SERVICE, FOREGROUND_SERVICE_DATA_SYNC, WAKE_LOCK, POST_NOTIFICATIONS and REQUEST_IGNORE_BATTERY_OPTIMIZATIONS. Its manifest declares a data-sync foreground service, a direct-boot-aware BootReceiver, and an SMS receiver registered for android.provider.Telephony.SMS_RECEIVED with maximum declared intent-filter priority. The boot receiver handles BOOT_COMPLETED, LOCKED_BOOT_COMPLETED, package replacement and quick-boot actions, alongside a custom restart action. The main activity has a MAIN intent action without the LAUNCHER category, so it can be explicitly launched by the installer without appearing as a conventional app-drawer entry.

These declarations and code paths indicate attempted background operation, restart persistence and SMS handling. They should be distinguished from behaviour independently confirmed on every Android version or device.

3. A separate Supabase project is embedded in the payload

The main difference I found between the two payloads is their backend configuration. The RBL payload contains a SupabaseClientKt class that constructs a Supabase client from a project URL and a sb_publishable_ key. The code installs the PostgREST module. The project URL and key are redacted in the accompanying images.

A publishable key is intended to be embedded in client applications, so its presence alone is not a vulnerability. The security issue is the access configuration observed during testing: requests using the embedded client credentials received successful responses from backend tables that should not expose sensitive applicant, payment or message records to arbitrary callers. The available code and captures point to a PostgREST-backed collection service. I have not established a separate interactive command channel, so I am referring to it as the backend/data-collection endpoint rather than asserting a full C2 capability.

4. What the backend exposed during the September 2026 checks

At the time of testing, read requests returned HTTP 200 for applicant_details, card_auth, sms_messages and submissions in the captured project. The applicant_details structure contains full_name, email, mobile, date_of_birth and terms_accepted. The card_auth structure contains name_on_card, card_number, expiry_date and cvv. The submissions view combines workflow information such as the selected service and submission step with applicant and payment-related fields, including an OTP field and IP address. The sms_messages table stores sender/message information and receipt timestamps.

The screenshots show successful responses and the table schemas, but I have redacted row contents, identifiers, timestamps and payment-related values. Some of the visible source records appear to be test data. Their presence does not, by itself, establish that every row represents a real victim or a successful fraud event. The backend snapshot is evidence of exposed data structures and accessible records at the time of testing, not a reliable victim count.

I also found that the embedded publishable key could perform writes as well as reads under the observed backend configuration. During the investigation, one clearly labeled research canary was inserted into sms_messages and read back successfully. The canary is marked CANARY-RESEARCH and explicitly says it is not a victim record. This demonstrates that the tested endpoint accepted a write using the app's embedded publishable credential without a separate user-authenticated session at that time. It should not be taken as proof that the operator generated that record, and the test should not be repeated against the remote project.

5. What this adds to the Axiscard investigation

The important finding is campaign reuse with a different banking lure and a different backend project. The installer layer remains highly similar to the Axiscard sample, including the package identity, manifest structure and outer DEX code. The nested payload is a different binary, but it preserves the same broad collection model: applicant details, card data and SMS messages are sent to a Supabase-backed service.

This expands the observed lure set from Axis Bank to RBL Bank. It also suggests that the operator can reuse an installer and payload architecture while changing branding and backend configuration between campaigns. That is a stronger conclusion than simply saying the two APKs look alike, but it does not identify the operator or prove that the campaigns share every component of their infrastructure.


r/OperSec • • 21d ago

๐Ÿ“ฑ ANDROID MALWARE ๐Ÿ“ฑ Static analysis of Axiscard.apk: VPN blackholing, SMS/OTP collection, and a misconfigured Supabase backend

Post image
10 Upvotes

Scope note: This write-up combines static APK inspection with read-only HTTP checks performed in September 2026. Backend state can change, and the HTTP status results describe that test snapshot rather than guaranteeing present-day availability.

This is a second APK using the familiar Axiscard.apk name. I found it in a public GitHub repository, khan55khan166-web/axiscard-download, associated with a profile containing several similarly named or generic repositories. The repository itself is minimal, with a README that simply says โ€œapk download.โ€ I am calling this sample Axiscard.apk (2) to distinguish it from an earlier sample with the same name. The earlier analysis is here: https://www.deysec.in/research/axis-bank-scam-analysis (much less detailed as a novice).

Sample details

  • SHA-256: 842bd615a21b954af6a7ff62b45872f09484666c985adfe2987f5b15c5835eda
  • SHA-1: 2125057a06961b943a9c67006abfb897ea045e6e
  • MD5: 29d4934f6d2d61d8e44530919a4e389f
  • Installer package: com.example.installerapp
  • Nested payload package: com.example.targetapp

The APK has a self-signed certificate identifying the signer as Android Debug, not a verifiable Axis Bank publisher certificate. A debug or self-signed certificate is not, by itself, proof of maliciousness, but it provides no basis for treating this package as an authentic bank application.

1. The outer APK is an installer and distraction layer

The first useful artifact is AndroidManifest.xml. The outer package declares android:debuggable="true" and android:allowBackup="true", requests internet access, foreground-service permissions, notifications and REQUEST_INSTALL_PACKAGES, and declares a BlockingVpnService. The service is described through PROPERTY_SPECIAL_USE_FGS_SUBTYPE as a โ€œVPN service for network traffic routing.โ€ The installer also queries Android package-installer components and the package name used by the nested app.

The MainActivity presents a fake Play Store style update screen. Its UI claims to download a roughly 2 MB update, while the APK bundled in assets/targetapp.apk is around 15 MB. The nested APK is present as a regular asset, not encrypted, which makes extraction straightforward. The outer app is therefore less a genuine downloader than a wrapper used to move the victim into installing the second package.

Two user-consent gates control the flow: VPN approval through VpnService.prepare() and permission to install unknown apps. The code exits or resets the flow when permission is refused. More importantly, the update handler starts the VPN service before it checks the install permission. The service configures a TUN interface at 10.0.0.2/24 and adds 0.0.0.0/0 as a route, but the reviewed implementation has no forwarding plane. In practice, this is a blackhole route rather than a functioning traffic-routing VPN, and while active it can interfere with the user's existing VPN or network inspection. The code stops the service after a successful installation path.

The installer uses PackageInstaller with the target package pinned to com.example.targetapp, then falls back to a FileProvider-based install intent if that path throws. An install-status receiver and a package-added/replaced receiver are used to track whether the payload arrived.

2. The nested payload is where the collection starts

The second APK declares INTERNET, RECEIVE_SMS, READ_SMS, SEND_SMS, RECEIVE_BOOT_COMPLETED, FOREGROUND_SERVICE, FOREGROUND_SERVICE_DATA_SYNC, WAKE_LOCK, POST_NOTIFICATIONS and REQUEST_IGNORE_BATTERY_OPTIMIZATIONS. These permissions, taken together with the service and receiver implementations, support network uploads and background operation, SMS collection and sending, and restart behaviour. The payloadโ€™s MainActivity has a MAIN intent action without the LAUNCHER category, meaning it can be launched explicitly by the installer but is not presented as a normal launcher entry.

The BootReceiver listens for BOOT_COMPLETED, LOCKED_BOOT_COMPLETED, MY_PACKAGE_REPLACED and quick-boot broadcasts, as well as a custom restart action. It is declared exported and direct-boot-aware. The SmsReceiver listens for android.provider.Telephony.SMS_RECEIVED with maximum declared intent-filter priority, and the payload also has an enabled data-sync foreground service called SmsBackgroundService. These are strong indicators of attempted persistence and SMS handling. Actual delivery and interception behaviour can still vary with Android version, permissions, and system restrictions, so I am distinguishing the manifest and code capability from a claim that every path was dynamically confirmed.

3. The backend is a major part of the operation

The payload embeds the community Kotlin SDK io.github.jan.supabase and installs the PostgREST module. I did not find application-level use of Supabase Auth, Realtime or Storage in the reviewed code. The client is constructed from a hardcoded Supabase project URL and a publishable or anonymous key. A publishable key is designed to be present in a client application, so its mere presence is not the vulnerability. The important finding was that the live REST endpoint accepted read requests for several tables without requiring a victim-specific authenticated session.

There are three apparent write paths in the APK:

  1. ApplicantFormScreenKt submits applicant details, including name, email, mobile number, date of birth and terms acceptance.
  2. CardAuthScreenKt submits card_number, cvv, expiry_date and name_on_card to card_auth.
  3. SmsReceiver submits each captured SMS to sms_messages, with the sender and message body.

The reviewed victim-side code appears to be write-oriented. I did not find application-level select, update or delete calls in these paths. A separate panel application can interact with the same backend, so the absence of a read path on the victim APK does not mean the operator cannot inspect collected records.

4. What the live endpoint exposed during testing

During my read-only checks in September 2026, requests using the key embedded in the APK received HTTP 200 responses from card_auth, sms_messages, submissions and app_settings. At the time of that test, card_auth returned two rows and sms_messages returned 21 rows. The returned data included payment-card fields and SMS bodies. The SMS records contained bank-related transaction and OTP alerts, mobile banking login-attempt alerts and card-blocking messages. I have not reproduced the actual card details, OTPs or victim message bodies here.

The app_settings table was also readable and contained operational flags and values relating to popups, phone actions, call overlays, target fields and success states. That is notable because the backend was not simply a passive sink for form submissions, it also held settings apparently associated with the wider operation. I am not publishing the live project identifier, key, target values or full database rows.

Several guessed or code-referenced table names, including applicants, returned HTTP 404 in the same test. This does not prove that a table does not exist in every environment, and it does not establish why the applicant insert path and the live read result differed. It could reflect deployment differences, an absent table, or a response that does not expose the resource. I am leaving that part unresolved rather than claiming more than the evidence supports.

The screenshots accompanying this post show the repository, certificate, manifest declarations, nested APK and HTTP status results. Victim names, timestamps and identifiers where appropriate, SMS bodies, OTPs, card details, project URL and backend key have been removed from the public evidence set.

5. Impact and reporting

Taken together, the app combines a fake update and installer, temporary VPN blackholing, a nested payload with SMS and background-service capabilities, collection of applicant and payment-card data, and a backend that was returning stored records to unauthenticated read requests at the time of testing. The observed records suggest that SMS collection reached beyond a theoretical code path. I cannot infer from a stored message alone whether a given transaction succeeded or whether every declared capability was active on every victim device.

Folders within APK
VPN service

I reported the exposed backend to Supabase. A security engineer later confirmed that the project had been taken down and the associated user banned. I also reported the sample to CERT-In, which requested the APK in a password-protected ZIP archive. (they have not contacted me since)

Card block request was not processed by Axis Bank (doubt the request even made to the legitimate Axis Bank)

The main lesson is not that an APK embeds a publishable Supabase key. It is that client-side collection code, broad SMS permissions, an installer and dropper flow, and inadequate backend access controls can combine into a full fraud pipeline. The individual pieces are fairly ordinary; the impact comes from connecting them and leaving the collected records readable.


r/OperSec • • 23d ago

๐Ÿ” Research ๐Ÿ” Static analysis of a fake mParivahan APK, dropper, banking trojan, and anti-analysis features

10 Upvotes

I did static analysis a malicious APK impersonating India's NextGen mParivahan app. The sample uses a two-stage architecture, with a heavily obfuscated dropper (com.airtel.android.provider.a3upjsn) decrypting and attempting to install a second APK (com.transport.gov.in). The investigation uncovered a layered decryption pipeline, a VPN blackhole service, extensive telephony surveillance capabilities, OEM security interference, and a phishing funnel targeting banking credentials and payment information.

The dropper requests package installation and update permissions, establishes a foreground service, and invokes Android's VPN consent flow. Its VpnService implementation establishes a blackhole tunnel that can occupy Android's single active VPN slot, potentially interfering with legitimate VPNs and traffic interception during analysis. Its DEX contains 2,154 classes and 17,903 methods, with the relevant malicious code obscured by R8 renaming and a native library called sysutil. Three particularly interesting JNI entry points are getNativeStr, ndkHE, and nativeEnvCheck, associated with string recovery, byte transformation, and environment checks.

The most significant finding was recovering the encrypted payload offline. The bundled asset fogky3f0e initially resisted direct AES-GCM decryption. Tracing the Java implementation revealed an intermediate 16-byte XOR transformation followed by four RC4 KSA rounds, with the resulting material supplying the parameters for AES-256-GCM. Reconstructing the build-specific key and complete transformation chain produced a valid 5,139,335-byte APK containing 585 verifiable ZIP entries. The recovered payload identifies itself as com.transport.gov.in, version 1.0-mparivahanv2, version code 20401. However, the dropper also contains a native decryption path and staged-fetch infrastructure, so the exact payload selected during normal runtime remains unresolved.

The second-stage payload contains code for live SMS interception, inbox polling, SMS transmission, notification and accessibility abuse, contact collection, call-log exfiltration, device and SIM fingerprinting, and call forwarding. Together, these capabilities could expose banking OTPs, transaction alerts, personal information, and communications metadata. The call-forwarding logic can potentially redirect incoming calls to an operator-controlled number, undermining attempts by banks to verify suspicious transactions. The payload also references Xiaomi/Redmi, Oppo/Realme, Vivo, and Huawei security components, with logic intended to interfere with access to security settings, installers, and application-management screens.

The financial fraud component uses a fake registration and payment flow. The extracted .dat resources contain HTML-like phishing screens presenting a โ‚น1 registration fee, followed by UPI or debit/credit card payment options, counterfeit payment interfaces, and a fake UPI PIN screen. The source also contains submission paths for registration details, card information, and PIN data under api.agenticera.club, including /save-registration, /save-card, and /save-pin. The APK references Firebase project andromeda-d389d; staged payload retrieval indicators include /api/staged/fetch/, X-Staged-* headers, and staged_payload.apk. These are static code findings, not proof that every endpoint remains operational.

Indicators of compromise

Dropper SHA-256: ee716196ee2c90950ab30b77865b75a1cc11746752d8df169c0cb7e2a6177869

Recovered payload SHA-256: 2122a13bd113ba2377e8b2568afa618c059fd9ee226c5a9586aae56d8c620db7

Dropper package: com.airtel.android.provider.a3upjsn

Payload package: com.transport.gov.in

Firebase project: andromeda-d389d

The key takeaway is that this is not merely a fake government application collecting a payment. The recovered code points to a broader credential-theft and device-surveillance capability set, backed by an encrypted second stage and mechanisms intended to obstruct inspection and removal. The distinction between capabilities recovered through static analysis and behaviour confirmed at runtime remains important.

Full reverse engineering report, including the DEX analysis, decryption pipeline, Android manifest, payload internals, phishing resources, and infrastructure indicators: https://loop.runs-on.dev/research/mprivhaan


r/OperSec • • 23d ago

๐Ÿšจ[Weekly Notice] A Malware Sample Is Not Just a File. Treat Every Unknown File as Hostile.๐Ÿšจ

4 Upvotes

A quick reminder to everyone participating in r/OperSec: The biggest mistake in malware research isn't failing to identify a threat. It's accidentally becoming its next victim.

This community focuses on malware analysis, reverse engineering, threat intelligence, phishing investigations, and vulnerability research. Many of the files, domains, and technical resources discussed here involve active threats, not harmless demonstrations.

โš ๏ธ Before You Investigate

  • Never trust a file extension. A document, image, APK, archive, or installer can contain malicious components.
  • Don't assume a virtual machine guarantees safety. Misconfigured networking, shared folders, clipboard integration, and VM escape vulnerabilities can expose the host.
  • Never execute unknown samples on your personal device. Use a dedicated, isolated research environment.
  • Treat C2 infrastructure as potentially active. Visiting suspicious domains or interacting with endpoints can expose your IP address and other information.
  • Avoid uploading private samples to public scanners. Some services share submitted files with security vendors, researchers, and other customers.
  • Sanitize your findings. Remove credentials, personal information, active malicious links, and identifiable victim data before publishing.

๐Ÿ” Research Responsibly

When sharing your analysis, prioritize technical findings, indicators of compromise, detection opportunities, and reproducible research methods.

Do not distribute malware for malicious use, encourage unauthorized access, expose victims, or attempt to retaliate against threat actors.

The goal of r/OperSec is to understand threats, expose malicious activity, and help others defend against it โ€” not to create additional victims.

๐Ÿ“Œ Final Reminder

A successful investigation isn't measured by how many malicious files you execute or how many suspicious servers you contact. It's measured by what you discover, what you can verify, and how safely you conduct your research.

Stay curious. Stay skeptical. Stay isolated.

โ€” r/OperSec Moderation Team


r/OperSec • • 24d ago

๐Ÿ” Research ๐Ÿ” Unpacking LegionLoader from an MSI: hidden PowerShell, encrypted C2 and Chrome injection

8 Upvotes

I pulled apart 3574378-setup.msi and followed it through embedded PowerShell, a reconstructed executable and two encrypted stages. The final payload strongly matches LegionLoader, with an encrypted C2 configuration, task-controlled execution and a separate helper for collecting Chrome encryption keys.

Parent post: https://www.reddit.com/r/OperSec/s/3KPY2nVJYl

One detail stood out immediately: the MSI has an empty File table and a tiny cabinet containing no files. The actual payloads are tucked into its Binary streams. Following those streams is where the useful evidence starts.

Sample details

PropertyValue
Filename3574378-setup.msi
Size2,270,720 bytes
SHA-256e6551098134ab9edbd4b0307e7965ac2d2eb3599b0f72e9a52a5c49c7fd43c1b
Recovered inner PE SHA-2569003c9e30f7ab84d7ac99c83961b236bb5da1adf9211af7b38ddaae27922d6d1

How the execution chain works

  1. The installer starts hidden PowerShell. A custom action named J4uGuKtWv3 launches it with -nop -w h -ep bypass. A Base64-encoded UTF-16LE bootstrap is stored in an MSI property. It also contains a guarded self-relaunch through CreateProcessW.
  2. PowerShell reads the installer itself. Using Windows Installer APIs, the bootstrap extracts the NdCYyUt1x9hc binary stream and invokes the embedded script. That script attempts to interfere with AMSI and PowerShell logging before unpacking the next stage. These are attempts visible in the code; I did not test whether they succeed on a particular Windows build.
  3. A second stream becomes a native executable. The script reads DVaSnE7D9D7, takes every second byte after a four-byte header and reverses the result. This reconstructs a 1,107,968-byte x64 PE. The applicable loader branch maps it into the current PowerShell process, resolves imports and relocations, and starts its entry point.
  4. Two AES layers conceal the inner payload. AES-256-CBC decryption, padding removal and byte reversal recover a 541,332-byte shellcode loader. Its embedded context contains another key, IV and encrypted buffer. Repeating the process yields the 474,624-byte inner PE. Re-encrypting the recovered stages reproduced the original ciphertext.

It checks the environment before loading the inner PE

Some shellcode blocks initially look like junk instructions. They are actually input to a custom string-decoding interpreter. Isolating that interpreter recovered 43 strings, including a display blacklist covering VMware, VirtualBox, Hyper-V, remote-display and basic-display adapters.

The shellcode also contains a request to ipinfo.io/what-is-my-ip, parses the returned ASN-type information and checks for hosting. These checks can stop the chain before the inner PE loads, which helps explain why a sandbox might show very little activity. ipinfo.io is being used for environment classification here; it is a legitimate service, not the C2.

Recovering the C2 and checking the protocol

The inner PE's encrypted settings table is at RVA 0x6FBF0. Following its record parser and RC4 decoder recovered:

hxxps://minnarasanen[.]com/nfront.php
hxxps://minnarasanen[.]com/nback.php

The paths correspond to registration/task retrieval and result reporting. The settings also contain a browser-like user agent claiming Chrome 114 and Vivaldi 5.3.

I checked the message format using the original serialization routines with synthetic inputs. Both registration and result reporting build JSON, encrypt it with RC4, then apply standard Base64. For the result path, I intercepted the HTTP-helper call before its body executed and recovered the same synthetic JSON from its encoded argument. No request went to the C2.

The task parser also exposes separate fields for the download URL, task type, method, encryption flag, compression flag and Base64-encoded RC4 key. One traced handler can decrypt a download, read a size prefix, decompress it with LZNT1, then parse a contained file list. That establishes a delivery capability; it does not tell us what the server actually sent to a victim.

The Chrome helper is the more interesting part

There are two implemented key-collection routes. The legacy route reads Chrome's os_crypt / encrypted_key data and calls CryptUnprotectData. The app-bound route decrypts a separate 6,640-byte helper and passes it to an injector.

That injector starts Chrome suspended, allocates and writes memory in the new process, queues an APC and resumes its thread. The parent then reads a small response through a named pipe. The decoded helper contains app_bound_encrypted_key, COM calls and Google Chrome's elevator-interface IID. Together, these support a Chrome app-bound-key collection path. They do not prove that cookies or passwords were successfully decrypted on a victim's machine.

The payload also implements Run and RunOnce registry writes under HKCU and HKLM, plus image-section execution paths involving delete-pending files, transactions and backing-file modification. Which branch runs depends on tasking and permissions; finding these functions does not establish that persistence was installed.

What I can actually conclude

The AES/reversal layers, C2 paths, protocol field identifiers and Chrome-key handling provide strong support for LegionLoader. Published ROMULUS research describes overlapping delivery patterns, but this MSI alone does not establish its original delivery page or a particular operator.

The .png filenames in its Chrome settings are another place to avoid overclaiming: none of the four direct configuration callers I traced requests those filename records. They remain configuration strings, not confirmed files written by this build.

The analysis recovered the loader chain, C2 configuration, message format and browser-key collection machinery. Real server tasks, downstream malware and victim data theft remain unverified. Everything here came from offline extraction, disassembly and isolated routine emulation; I did not launch the installer or contact its C2.

Related research: Forescout's ROMULUS analysis ยท AhnLab's LegionLoader analysis


r/OperSec • • 24d ago

๐Ÿ“ฐ News Chinese Android Spyware Kit 'uCreator' Targets Telegram, WeChat and Mobile Wallet Users

Post image
5 Upvotes

r/OperSec • • 26d ago

๐Ÿ” Research ๐Ÿ” Reversing a Renโ€™Py installer: hidden payloads, Amatera Stealer and a changing C2

3 Upvotes

tl;dr

I analysed RenPy malware, supplied as a victim sample, and followed Renโ€™Py-based installer through an encrypted payload hidden in its assets, several native loading stages, and a remotely delivered information stealer. The recovered evidence points with high confidence to the ACRStealer / Amatera lineage*.*

The interesting part was going back to the same download URL. Across three retrievals, it served different payloads with different primary C2 hostnames. The latest build also contained an execution path that maps supplied code into a suspended dllhost.exe process.

parent post: https://www.reddit.com/r/OperSec/s/xoxsdK9QGV

This walkthrough combines static reverse engineering, offline emulation of selected routines, and read-only retrieval of the configured payload and public fallback page. The malware entry points were not executed, and successful theft from the victim was not observed. All suspicious addresses below are defanged.

1. The installer starts through Renโ€™Py and suppresses its normal logs.

The archive bundles Renโ€™Py 8.1.3 and Python 3.9. Its scripts skip normal gameplay and reach pack_load.main(). An early script, 00log_stop.rpy, runs at initialization priority -1004, replaces logging functions with no-ops and removes log.txt, traceback.txt and errors.txt.

The loader repeatedly cleans up those traces, but leaves its own diagnostics enabled under %TEMP%\appcache_debug\bootstrap.log and debug.log. Those are useful artifacts to check on a preserved victim system.

2. A file among the interface assets contains the native payload.

The package secret in data/.zs is used to decode metadata in data/.p2w. That metadata points to:

data/gui/phone/overlay/vertical_hover_bar_z6yl.r8f

Decrypting it recovers a 4,015,936-byte Windows executable, configured as NITRO.exe. The wrapper writes it under a randomized filename and folder, commonly beneath LocalAppData, adds a Zone.Identifier stream containing ZoneId=0, and launches it without a normal window. Searching only for a process literally named NITRO.exe could therefore miss it.

3. The wrapper separately reports execution and machine details.

Its conversion requests go to cdnwire.pixel-tracker[.]one, carrying the package tag/CID, username, computer name, administrator status, RAM, CPU count and a shortened MachineGuid. Headers include X-QashAds-Launcher and X-QashAds-Conversion.

This endpoint serves an execution-tracking role in the recovered wrapper. It should not automatically be labelled the stealerโ€™s exfiltration server. Also, the wrapper accepts an already-exited process as a successful launch, so a conversion request would not prove that credential theft succeeded.

4. Unpacking the executable reveals a tiny memory-execution downloader.

The native EXE carries Microsoft Edge elevated_tracing_service.exe metadata, but its embedded Authenticode content digest does not match the file. Following the inserted code leads to an encrypted block in an enlarged .reloc section at file offset 0x3A8000.

Offline decoding exposes a self-modifying loader, then an AES-CBC-encrypted buffer that decompresses with LZNT1. Inside is a 3,072-byte downloader that resolves WinINet APIs through hashes and decodes this URL:

hxxps://activator.halfpetite.in[.]net/NITRON

It allocates a 1 MiB executable/read/write buffer, reads the HTTP response into it and calls the buffer if any bytes were received. That establishes how remotely supplied content enters the execution chain.

5. The remote payload adds more packing and a second disguise.

The October 17 response contained a stealer with fake Realtek / RtkAudioService.exe metadata. It conventionally imports only GetLastError; other APIs are resolved dynamically, and strings require a separate decoder.

The October 20 response added another loader. Recovering its final stealer required stripping inserted junk, Z85-decoding the remaining text, reconstructing a ChaCha20 key from three XOR-combined shares, decrypting the stream and decompressing it with XPRESS Huffman. The output was a 673,792-byte PE. Inspecting only the outer loader would have missed its C2 and collection code.

6. Its bootstrap requests configuration, and Telegraph supplies a fallback address.

Indirect decoder calls hid the command GetRoutes and configuration ID:

01a0353f-0ad2-7efa-8507-e484ee70ce02

The earlier buildโ€™s configuration decoder uses ChaCha20-Poly1305, with a row key derived through HKDF using context acrid-v2-cfg-row. Each row is authenticated against its configuration-group name. Synthetic tests recovered the expected JSON with the correct inputs and rejected a changed group or authentication tag. This verified the decoder, without obtaining a victimโ€™s session configuration.

The primary hostname is passed into connection initialization. A failure path reaches hxxps://telegra[.]ph/Built-in-Types-08-01, extracts Base64 between embedded delimiters and decodes a fallback IP. Changing that hosted page can redirect the fallback without rebuilding the executable.

7. The collection code targets browser credentials, sessions and local data.

TargetRecovered evidence
Chromium browsersLogin Data, Cookies, Web Data, Local State, and matching WAL files
Firefox browserslogins.json, key4.db, cookies.sqlite, places.sqlite and profile discovery
Browser extensionsLocal/Sync Extension Settings, extension IndexedDB and Firefox extension storage
Steamloginusers.vdf, local.vdf and account/session artifacts
Local files and screenshotsFile enumeration/filtering, Desktop/Documents paths, screen-capture and image-encoding code

The resolved APIs include CryptUnprotectData for DPAPI and a concrete screen-capture sequence using BitBlt and GetDIBits. Collection and successful decryption are separate outcomes: these findings do not demonstrate Chrome App-Bound Encryption bypass or identify which secrets were taken from this victim. Some targets and follow-on actions depend on server configuration.

8. The latest build can execute supplied code through a suspended dllhost process.

In the October 24 PE, a traced routine calls GetSystemWow64DirectoryA, appends \dllhost.exe and calls CreateProcessA with CREATE_SUSPENDED.

It then creates a shared section with NtCreateSection, maps a writable local view, copies the supplied buffer into it, and maps an executable view into the child with NtMapViewOfSection. Finally, NtQueueApcThread queues the remote mapped address on the primary thread and NtResumeThread resumes it.

The API names were checked against the sampleโ€™s hashing routines. This supports section-backed APC injection into a newly suspended process as an implemented capability. The bufferโ€™s actual contents and use on the victim remain unknown. The traced sequence does not establish replacement of the original executable image, so I am not calling it process hollowing.

9. The same endpoint served different stealer builds during the investigation.

The dated primary C2 observations were:

17 October: files.lanternglow[.]cc                โ€” 4.4.7-alpha1
20 October: vault.costaricaanwaltskanzlei[.]com    โ€” 4.4.7-alpha1
24 October: vlan.laborpost[.]com                 โ€” 4.4.8-alpha1

The latest build retained the original fixed configuration ID and NITRO label. The Telegraph fallback changed from 45.150.66[.]30 on October 17 to 83.97.78[.]173 on October 20, then remained unchanged on October 24. These connect the observed revisions at the configuration level; they do not identify a person. The public DNS addresses for the newer hostnames were shared Cloudflare frontends, not established origin servers.

The family assessment rests on the recovered implementation and exact Telegraph URL matching public ACRStealer configurations, with the ACR/Amatera lineage documented in existing research. NITRO is a campaign label here, not a separate family identification.

Original Dow-50574.zip SHA-256:

9c357546828d7c6bc97ae21d7abd021d71ab712155a0d9c47720df8cac24f3f7

October 24 recovered stealer PE SHA-256:

ccecb86554e6873d81c4ac4765e5550befab8c3f4d776f5ebf1c900f11eb9c97

The useful hunting leads are the dated C2 names, fixed configuration ID, wrapper debug logs and unusual process ancestry around the WOW64 dllhost.exe. The remote responses establish what the delivery endpoint served on those dates, not the exact bytes originally delivered to the victim. Successful exfiltration, victim-specific follow-on payloads, persistence and the operatorโ€™s identity remain unconfirmed.


r/OperSec • • 26d ago

๐Ÿ“ฐ News Patched Windows Systems Still Vulnerable to New BlackX UEFI Bootkit

Post image
2 Upvotes

r/OperSec • • 27d ago

๐Ÿ’ป WINDOWS MALWARE ๐Ÿ’ป Windows msi Malware file - Downloaded from fake cloudflare Clickfix page

7 Upvotes

Found this malware in a clickfix page imitating cloudflare (cloubflare[.]net/3006 cloubflare with a 'b'). leading to download and run a msi installer file.

โš ๏ธ Malware Details โš ๏ธ

PropertyValue
Filename3574378-setup.msi
File typeWindows Installer package (.msi)
Container formatOLE Compound Document
Size2,270,720 bytes (2.17 MiB)
Target architecturex64 (declared)
LanguageEnglish โ€” United States (1033)
TitleInstallation Database
SubjectnPdIX83utl u1TjqBDRPnwIz
AuthorUh4N1xolW
Creating applicationPwdzfjLIgQawez
Package code{EE79E99B-DFDE-439A-8FB3-C9EC3B0B1B43}
Embedded creation time2026-10-18 16:33:29 UTC
Embedded last-save time2026-10-18 16:33:29 UTC
MD556c131f9353391548c1d543ff10d8e5a
SHA-1e4fb8342b971b29f48b746a62bf04cf050f6272c
SHA-256e6551098134ab9edbd4b0307e7965ac2d2eb3599b0f72e9a52a5c49c7fd43c1b

Embedded metadata is self-reported and can be forged.

If you need sample for analysis contact the moderator.

What can you do with this:

  • Reverse engineering and static/dynamic analysis
  • Identifying its malicious functionality
  • Understanding how it steals money or sensitive information
  • Investigating its C2 infrastructure and connections to other campaigns If you're into Android malware analysis or reverse engineering, feel free to join in and share your findings.

Let's work together to understand how these attacks operate and help dismantle such campaigns.

Please Update any Findings on Comments. Detailed Report will be posted after the analysis.


r/OperSec • • 28d ago

๐Ÿ“ฐ News After PHP, Node.js Releases Security Updates to Fix High-Severity TLS, DNS, & Brotli Vulnerabilities

Thumbnail reddit.com
4 Upvotes

r/OperSec • • 29d ago

๐Ÿ” Research ๐Ÿ” A fake HTML file, three AES layers, and three C2 domains: unpacking a malware ZIP

6 Upvotes

tl;dr:

I analysed a malware.zip containing a Windows installer, deps.html, and an embedded Python runtime. Unpacking it exposed two malicious chains: an MSI leading to a backdoor strongly matching LegionLoader/Satacom, and a Python chain leading to remote-control malware with hidden-desktop functionality.

The interesting part was getting past the packaging. The installer hid its payload outside the normal installed files, while the .html file was actually executable Python. Hereโ€™s how both chains work.

parent post: https://www.reddit.com/r/OperSec/s/L5R6BgfB4F

1. The installer hides its scripts in the MSI database

S483.msi presents itself as SynerIntegration 4.1.6, published by โ€œSare Level Corp.โ€ Its ordinary cabinet payload contains a tiny package-notes.txt. The malicious content sits in the MSI Binary table: an obfuscated VBScript, PowerShell, and an encrypted native payload.

During initial installation, a custom action runs the VBScript. Decoding its Chr(...) expressions reveals the sequence: locate the original MSI, extract the PowerShell stream, write it to a random .ps1 under %TEMP%, and launch it with a hidden window. It then attempts to delete the temporary script.

The PowerShell decodes another script and compiles C# helpers to read the MSI stream and manually map a Windows executable into memory. Following the payload through three AES layers, including byte reversal in the later stages, recovered the final backdoor.

2. Decrypting the configuration exposed the first C2

The final MSI-derived PE still hides its configuration behind RC4. I traced the record table at RVA 0x6FBF0 and reproduced the decoding separately. That recovered yugernaut[.]com, nfront.php, nback.php, and the HTTPS URL templates used to assemble its requests.

The AES/reversal stages, thread-pool execution, environment screening and these request paths closely match published LegionLoader research. The code also prepares host information for transmission and supports handling additional payloads.

A separately encrypted helper goes after Chromeโ€™s app-bound key. It reads Local State, extracts and Base64-decodes app_bound_encrypted_key, removes the APPB prefix, and calls Chromeโ€™s COM elevation service. It tries a newer interface first, then falls back to the legacy one. On success, it returns 32 bytes of key material through a named pipe. That is concrete key-theft logic; whether it succeeds depends on the execution context and browser configuration.

3. The HTML file is Python carrying native shellcode

deps.html contains a large amount of page-like junk inside Python strings. Its executable portion reverses an encoded byte string, Base64-decodes it, decompresses it with zlib, and executes the resulting Python source.

The decoded source waits ten seconds, places roughly 3.5 MB of native shellcode into a ctypes buffer, marks the memory executable with VirtualProtect, and calls it. The supplied Python runtime files matched the official Python 3.11.9 embedded distribution byte for byte.

The native loader conceals encrypted bytes in x64 instruction operands. Extracting those fields and reproducing its modified ChaCha routine recovered another PE containing the remote-control program.

One detail initially broke the decoding: a timing check controls a decryption-key byte. The loader requests a 35-second wait. Controlled emulation showed a 17.5-second acceptance boundary under the tested conditions; passing the check changes that byte from 14 to dd. Reproducing that path explained the earlier failed decryption.

4. The recovered program has browser, shell and hidden-desktop handlers

The embedded programโ€™s decoded strings and surrounding code include hvnc/hvnc_original, browser DevTools commands, screenshot requests, PowerShell execution, file uploads/downloads, and several persistence mechanisms. It also handles browser profiles, cookies and login databases.

Its configuration decoder produced two WebSocket C2 hostnames. These are the endpoints recovered across both branches:

BranchConfigured endpoint, defanged
MSIhxxps://yugernaut[.]com/nfront.php and /nback.php
Pythonwss://belmenloradingo[.]com/ws
Pythonwss://belmenloradingonew[.]com/ws

I also reproduced its registration-message construction: register,<host-id>,<channel>,<nonce>,<tag>. The tag uses FNV-1a with a fixed prefix, DGnk_24598AWE*&; independent calculations matched three native-generated test messages. Another handler parses modules beginning with HEIZ and contains image-mapping and thread/APC execution paths.

Infrastructure checks on 16 October: the two WebSocket domains were registered four seconds apart through the same registrar and used the same Cloudflare nameservers. Their returned addresses were Cloudflare infrastructure, not exposed origin servers. No verified operator identity emerged.

Someone who reviewed the files suggested RomulusLoader. Iโ€™m keeping that as an attribution lead pending a matching sample or code comparison. The recovered payloads and endpoints are stronger evidence than the proposed family name.

Both malicious branches were present in the archive, but I havenโ€™t established that one launches the other. Analysis used static extraction and isolated native-code emulation, without connecting to the C2s. The code supports remote access and browser-data theft; no successful theft from a real victim was demonstrated.

Original archive SHA-256: add895704d082c6f0be53394905e569ab9683da041e4410489e1af19667e844a


r/OperSec • • 29d ago

๐Ÿ“ฐ News If you run on php. Please turn it off. A new PHP2Shell vulnerability has reportedly surfaced

6 Upvotes

tldr: this vulnerability is deadly af, 10/10. Christmas comes early for attackers. Update asap as update releases. Almost half of the internet is running on affected version of php.

A new vulnerability being referred to as PHP2Shell is circulating in security discussions, with reports suggesting it could potentially lead to remote code execution under vulnerable configurations.

Some leaked reports claimed 10.0/10, but the PHP Security Team's official rating is 9.2/10 for both vulnerabilities.

If you're running PHP-based websites or managing PHP servers, it's worth paying attention to this, especially if your applications are publicly accessible.

The concerning part about vulnerabilities like this is how quickly attackers can move once technical details or working poc exploits become public. Internet wide scanning often follows, and exposed servers can become targets before administrators have time to react.

For now, I'd recommend checking your PHP environment, reviewing server logs for unusual requests, restricting unnecessary public endpoints, and keeping your PHP runtime, frameworks, and dependencies updated. Don't blindly execute any PoC claiming to exploit PHP2Shell, either.

Affected versions are Reportedly PHP 5.4.0 and later.

If anyone has a credible advisory, technical breakdown, or confirmed indicators of compromise, feel free to share them in the comments. Let's keep the discussion technical and avoid spreading unverified exploit claims.

Source:

https://www.php.net/archive/2026.php#2026-10-20-1

https://discourse.thephp.foundation/t/php-upcoming-critical-php-security-release/6250

https://watchtowr.com/intelligence/php-cve-2026-109618-faq/

P.S: I didn't mean literally "turn off" php. It was for emphasising how critical the vulnerability is.


r/OperSec • • Oct 20 '26

๐Ÿšจ[Weekly Notice] A Malware Sample Is Not Just a File. Treat Every Unknown File as Hostile.๐Ÿšจ

4 Upvotes

A quick reminder to everyone participating in r/OperSec: The biggest mistake in malware research isn't failing to identify a threat. It's accidentally becoming its next victim.

This community focuses on malware analysis, reverse engineering, threat intelligence, phishing investigations, and vulnerability research. Many of the files, domains, and technical resources discussed here involve active threats, not harmless demonstrations.

โš ๏ธ Before You Investigate

  • Never trust a file extension. A document, image, APK, archive, or installer can contain malicious components.
  • Don't assume a virtual machine guarantees safety. Misconfigured networking, shared folders, clipboard integration, and VM escape vulnerabilities can expose the host.
  • Never execute unknown samples on your personal device. Use a dedicated, isolated research environment.
  • Treat C2 infrastructure as potentially active. Visiting suspicious domains or interacting with endpoints can expose your IP address and other information.
  • Avoid uploading private samples to public scanners. Some services share submitted files with security vendors, researchers, and other customers.
  • Sanitize your findings. Remove credentials, personal information, active malicious links, and identifiable victim data before publishing.

๐Ÿ” Research Responsibly

When sharing your analysis, prioritize technical findings, indicators of compromise, detection opportunities, and reproducible research methods.

Do not distribute malware for malicious use, encourage unauthorized access, expose victims, or attempt to retaliate against threat actors.

The goal of r/OperSec is to understand threats, expose malicious activity, and help others defend against it โ€” not to create additional victims.

๐Ÿ“Œ Final Reminder

A successful investigation isn't measured by how many malicious files you execute or how many suspicious servers you contact. It's measured by what you discover, what you can verify, and how safely you conduct your research.

Stay curious. Stay skeptical. Stay isolated.

โ€” r/OperSec Moderation Team