Taking Apart Nexus: An India-Targeted Android Banking Trojan
A static analysis of a two-stage Android banker that sinkholes Play Protect, phishes UPI PINs, steals every OTP, and forwards your calls — all rented out as malware-as-a-service.
You install what looks like a dating app. Minutes later, with no further action from you, a second app you never agreed to is on your phone — Google Play Protect was blindfolded at the exact moment it should have caught it. That app now reads every SMS you receive, forwards every incoming call to a stranger, and waits for you to type your UPI PIN into a screen that looks exactly like your bank’s. By the time money leaves your account, the attacker has already intercepted the OTP meant to stop it.
That’s not a hypothetical. It’s the designed behavior of a live, India-targeted Android banking trojan I spent the last few days taking apart.
Most Android bankers are boring in the same way: fake login overlay, accessibility-service abuse, SMS theft, done. This one — a family I’ll call Nexus, after its operator panel, built on a Firebase project named ghostx-panel — is a different animal. It’s a clean two-stage design that goes out of its way to blind Google Play Protect before it installs the real payload, it owns every channel your bank could use to reach you, and it’s sold as a multi-tenant product rented out to different operators. I pulled it apart statically. Here’s what’s inside.
A note on method before anything else: this was static analysis. Nothing was installed, run, or emulated. The one piece of live contact was a single unauthenticated read of a public Firebase config document to resolve the current C2 URL — the authenticated backend returned PERMISSION_DENIED, and I didn’t try to bypass it. Everything below comes from the code, strings, and resources.
Two stages, one job
The sample is a dropper carrying an encrypted second-stage APK.
Stage one (net.mobile.finance) poses as a dating/chat app. Its only real job is to get stage two onto the device. It ships the real payload as assets/onnx_model.bin — a complete APK, XOR-encrypted with a 32-byte repeating key, dressed up to look like a machine-learning model file. The key lives in a native library (libpayload.so, exported through JNI as getSecretKey), with a copy in Java. Decrypt the asset, write it to cache, and install it with PackageInstaller.
Stage two (com.veltrix.connect) is the actual financial-fraud implant, and it’s aimed squarely at Indian users: UPI PIN phishing, fake card screens, and fake e-Challan (traffic-fine) payment pages.
Splitting it this way is deliberate. The lure app that lands on the device looks nearly inert — the dangerous permissions and the fraud UI all live in the second APK, which only materializes after decryption. Anyone statically scanning the first stage sees a dating app with a suspicious binary asset and not much else.
The clever bit: sinkholing Play Protect
This is the part that made me stop and re-read the smali.
While the dropper installs stage two, it starts a local VPN — a VpnService it disguises with a foreground notification reading “Network Service / Securing connection.” A VPN on an Android malware sample usually means traffic interception. Not here. This VPN never reads from its own tunnel file descriptor. Every packet that enters it is simply dropped.
And it’s not applied to the whole device. It calls addAllowedApplication for exactly three packages:
com.android.vending(the Play Store)com.google.android.gms(Play Services)com.google.android.gsf(Google Services Framework)
So the “VPN” is really a targeted sinkhole. For the brief window during install, those three apps — and only those three — lose network access. Play Protect’s cloud-side checks can’t phone home, so the real-time scan that might flag the incoming APK never completes. The rest of the device’s traffic is untouched, so nothing looks obviously wrong. It’s a precise denial-of-service aimed at the single component standing between the victim and the payload — the device’s own antivirus, muzzled for exactly as long as it takes to get the trojan installed. I don’t say this often about malware, but it’s a genuinely elegant piece of evasion.
The package list, incidentally, isn’t sitting in plain strings. It’s built character-by-character at runtime, like most of the sample’s sensitive strings, specifically so a strings dump won’t reveal it.
What stage two actually does
Once it’s in, the implant is a full OTP-interception and payment-phishing kit. The headline capabilities:
Payment phishing. Fake paywall flows lead to UPI PIN entry (collected three times, with staged “wrong PIN, try again” retries to make sure it got a clean capture), card screens harvesting number/CVV/expiry/holder name, and fake traffic-fine payment pages. The e-Challan lure is a nice touch of local social engineering — an official-looking “pay your fine” screen is a very effective way to get someone to type a card number.
SMS theft. A real-time receiver uploads every incoming message as it arrives, and the entire inbox history gets batched up and exfiltrated separately. That’s the OTP pipeline: whatever the bank sends, the operator sees.
Call forwarding. This is the one people underestimate, and it’s the quiet masterstroke. The implant silently dials the USSD code *21*<number># to unconditionally forward all calls to an attacker-controlled number (and ##21# to cancel, *#21# to check). A lot of banks fall back to a voice OTP call when SMS fails. Forward the calls and you’ve welded that escape hatch shut too. Stack it against the SMS theft and the result is total: there is no out-of-band channel the bank can use to reach the victim that the attacker doesn’t also hold. The fraud-prevention call warning you about a suspicious transaction rings on the attacker’s phone instead.
Remote SMS sending. An outbox queue lets the operator send SMS from the victim’s phone — choosing the text, the recipient, and even the SIM slot. Useful for spreading, or for approving things via the victim’s own number.
Everything else. A notification listener reading all notifications, plus harvesting of contacts, call logs, device accounts/emails, SIM details (with SIM-change monitoring), and IP address. And aggressive persistence: start on boot and on charger connect, foreground services with WorkManager watchdogs, battery-optimization exemption, and it specifically opens the autostart settings pages for MIUI, ColorOS, Vivo, and Huawei — the OEM skins that most aggressively kill background apps.
It’s a product, not a one-off
The detail that reframes the whole thing: this is malware-as-a-service.
Command and control runs over Firebase (Firestore, Realtime Database, and FCM push) as the bootstrap layer, with a REST + WebSocket panel as the main channel. Every build carries a per-operator CUSTOMER_ID — which has the exact format of a Firebase Auth UID — and the implant subscribes to an FCM topic keyed to that ID. The Firestore collections (customers, devices, sms, payments, …) are structured as a multi-tenant backend.
The live panel URL isn’t even hardcoded anymore. The implant reads it at runtime from a public Firestore config document, falling back to a baked-in domain only if that fails. When I resolved it, the config pointed at a different, newer domain than the hardcoded fallback — the operators had migrated their infrastructure and pushed the new address out to every existing install through config, without shipping a new build. That’s an operator panel with real lifecycle management behind it, not a hobbyist’s one-shot.
REST requests are HMAC-signed (X-Customer-ID, X-Device-ID, X-Timestamp, X-Sig), which is more API hygiene than you’d expect from commodity malware and, again, points at something sold and maintained.
And it appears to still be running. WHOIS on the live C2 domain shows a creation date of 2026-03-07 18:40:34 UTC and a last update of 2026-03-07 23:29:58 UTC — registered roughly eight months before I looked at this sample — which, combined with the live infrastructure migration above, suggests an operation that’s been continuously active rather than a burned, abandoned panel. If you’re reading this close to publication, assume the backend is still taking victim data.
Detection and cleanup
The durable signals for this family aren’t the hashes or the HMAC key — those rotate per operator and per build. The sturdier indicators are the route strings and header names in stage two (devices/call_forwarding/ack, data/sms/batch/historical, outbox/pull, X-Customer-ID), the com.sanaminfo.payload code namespace in stage one, and the ghostx-panel Firebase project. I wrote YARA for both stages against those.
On a live device, the behavioral tells are specific enough to be useful:
- An app holding an active VPN whose allowed-apps list contains only Google Play components. That configuration has no legitimate purpose — it exists solely to blind Play Protect.
- An app dialling
*21*USSD codes. - A “video chat” app sitting on SMS access, notification-listener access, and a battery-optimization exemption all at once.
If a device is already infected, the first move is to cancel call forwarding immediately (dial ##21#) — that’s the channel actively bleeding OTPs right now. Then revoke the stage-two app’s permissions, remove its VPN profile, uninstall both com.veltrix.connect and net.mobile.finance, and treat every OTP received since installation as compromised. Call the bank, block the cards, reset the UPI PIN. In India, the fraud goes to cybercrime.gov.in or helpline 1930, and the IOCs to CERT-In.
What I took away from it
No single trick here is new — XOR’d payloads, USSD call forwarding, and SMS theft are all old. What makes this sample worth writing up is how well the pieces are engineered together: the surgical Play Protect sinkhole, the clean stage separation, the runtime-resolved C2 that let operators migrate infrastructure live, and the multi-tenant signed API underneath it all. This isn’t someone’s weekend project. It’s a maintained product with paying customers and an eight-month-old backend that’s very likely still collecting, and the target — Indian UPI and card users — was chosen for a reason.
But the part that should bother you isn’t the malware. It’s the assumption it exploits. We’ve trained an entire financial system to treat “did you get the OTP?” as proof of identity — and this trojan quietly owns every channel that OTP can arrive on: the SMS, the fallback voice call, the notification shade, all of it. Once that’s true, the second factor isn’t a second factor; it’s a formality the attacker fills in for you. No amount of better malware detection fixes that, because the weakness isn’t the phone. It’s the fact that we’re still delivering secrets to a device the attacker already controls. The real fix is to stop — to move off SMS- and call-delivered 2FA and onto factors that can’t be forwarded, intercepted, or read off a lock screen.
Full IOCs, the ATT&CK mapping, and the YARA rules are in the analysis report — reach out if you want the detailed writeup.
← all posts