Back to Intelligence

Bazuka Android Malware Framework: Detecting and Defeating Overlay-Based Credential Theft and LLM-Driven Device Control

SA
Security Arsenal Team
November 20, 2026
11 min read

In late October 2026, ThreatFabric's mobile threat intelligence team uncovered Bazuka during an investigation into an NFC-relay banking Trojan — and what they found was far more than another one-off banker. Bazuka is a full malware-as-a-service (MaaS) framework for Android that combines classic overlay-based credential theft with large language model (LLM) integration for victim management and command-and-control at scale. That combination matters. Overlay attacks have been the workhorse of Android banking fraud for a decade, but bolting an LLM onto the operator side changes the economics: a single low-skill operator can now manage hundreds of concurrent victim sessions, with the model generating convincing social-engineering dialogue, prioritizing high-value victims, and automating responses that previously required a human on the other end.

If your organization has a mobile workforce, supports BYOD, or your customers bank through an Android app, Bazuka is directly relevant to your risk model today. This post breaks down how the framework operates, what your SOC can realistically detect, and the concrete steps to protect devices and customers.

Technical Analysis

What Bazuka Is

Bazuka is a modular Android malware framework sold or rented to criminal operators. Per ThreatFabric's disclosure, it surfaced while researchers were tracking an NFC-relay banking Trojan campaign — a strong indicator that Bazuka is being deployed alongside or as a successor capability to existing mobile fraud tooling in active criminal operations.

Attack Chain (Defender's View)

Based on the disclosed capabilities, the Bazuka kill chain follows a pattern defenders should recognize from prior Android banking families, with modern twists:

  1. Delivery / Installation. Like most Android bankers, Bazuka relies on sideloading — dropper apps distributed via smishing (SMS phishing), malicious ads, or fake apps impersonating banks, utilities, or delivery services. The dropper requests installation from unknown sources and then baits the victim into granting elevated permissions.

  2. Permission Escalation. The critical milestone is Accessibility Services abuse. Once the victim grants Accessibility access, the malware can read screen content, perform gestures, auto-grant itself further permissions, and prevent its own removal. This is the single highest-value control point for defenders.

  3. Overlay Injection (Fake Screen Attack). Bazuka draws attacker-controlled windows on top of legitimate banking and payment apps. The victim sees a pixel-perfect replica of their bank's login form; every credential, PIN, and MFA code entered is harvested and exfiltrated to the operator's C2. Because the overlay sits above the real app, traditional in-app anti-phishing indicators are invisible to the user.

  4. Device Control / On-Device Fraud. With Accessibility and often Notification access, operators can read one-time passcodes from SMS and notifications, dismiss security warnings, and drive on-device fraud (ODF) — initiating transactions inside the already-authenticated banking session so that backend fraud engines see a 'legitimate' device and session.

  5. LLM-Integrated Victim Management. This is Bazuka's differentiator. The framework integrates a large language model into the operator console to manage victims at scale: generating contextual lure messages, keeping victims engaged during multi-step fraud (e.g., coaching them through 'security verification' flows), triaging victims by account value, and automating chat in the victim's language. Expect faster, more convincing, multilingual social engineering than human operators typically sustain.

Exploitation Status

  • No CVE is associated with this threat. Bazuka does not exploit an OS vulnerability — it abuses legitimate Android features (Accessibility Services, overlay/SYSTEM_ALERT_WINDOW-class capabilities, sideloading) through social engineering. That is precisely why patching alone cannot stop it.
  • Status: confirmed in-the-wild. ThreatFabric identified the framework during active incident investigation, meaning real deployments exist. Treat this as an active threat to Android fleets and customer-facing mobile banking channels.
  • CISA KEV: Not applicable (no underlying CVE).

Detection & Response

This is a technical threat, and mobile malware is notoriously under-instrumented in enterprise SOCs. The honest reality: most overlay and Accessibility abuse happens on the device, and unless you run mobile EDR/MTD (Zimperium, Lookout, Microsoft Defender for Endpoint on Android, etc.) or ingest Android telemetry into your SIEM, you will not see it. The detections below target the telemetry you can collect — MTD/EDR event streams, network egress from mobile devices, and the corporate-side artifacts of mobile fraud.

Sigma Rules

These rules assume Android security telemetry is being forwarded to your SIEM (via MTD vendor syslog/CEF integration or Defender for Endpoint mobile). Tune the log source to your ingestion pipeline.

YAML
---
title: Android Accessibility Service Enabled by Non-System Sideloaded App
id: 9f2b7c41-3a58-4e19-b6d2-7c8e1f4a5b33
status: experimental
description: Detects Accessibility Service activation granted to an app installed outside Google Play, a hallmark of Android banking trojans such as Bazuka that abuse Accessibility for overlay injection, permission auto-granting, and uninstall blocking.
references:
  - https://thehackernews.com/2026/11/bazuka-android-malware-uses-fake-screen.html
  - https://attack.mitre.org/techniques/T1517/
author: Security Arsenal
date: 2026/11/10
tags:
  - attack.persistence
  - attack.privilege_escalation
  - attack.t1517
logsource:
  product: android
  service: security_events
detection:
  selection:
    event_type: 'accessibility_service_enabled'
    install_source|contains:
      - 'sideloaded'
      - 'unknown_sources'
      - 'com.android.packageinstaller'
  filter_play_store:
    install_source: 'com.android.vending'
  condition: selection and not filter_play_store
falsepositives:
  - Legitimate accessibility tools sideloaded in testing/MDM environments
  - Enterprise apps distributed via private MDM channels
level: high
---
title: Android Overlay Permission Granted to High-Risk Application
id: 4d8e2f16-7b3c-4a91-8e55-2f6c9d1b7a44
status: experimental
description: Detects an application obtaining display-over-other-apps (SYSTEM_ALERT_WINDOW) capability shortly after installation from a non-Play source. Overlay permission combined with sideloaded origin is a strong pre-credential-theft indicator consistent with Bazuka-style fake screen attacks against banking apps.
references:
  - https://thehackernews.com/2026/11/bazuka-android-malware-uses-fake-screen.html
  - https://attack.mitre.org/techniques/T1417/
author: Security Arsenal
date: 2026/11/10
tags:
  - attack.collection
  - attack.credential_access
  - attack.t1417
logsource:
  product: android
  service: security_events
detection:
  selection:
    event_type|contains:
      - 'overlay_permission_granted'
      - 'system_alert_window_granted'
      - 'draw_over_apps_enabled'
    install_source|contains:
      - 'sideloaded'
      - 'unknown_sources'
falsepositives:
  - Legitimate chat-head style apps (rare on modern Android)
  - Screen-recording or accessibility utilities approved by IT
level: high
---
title: Outbound Connection from Mobile Device to Newly Registered or Low-Reputation C2 Domain
id: 6c1a9e38-2d47-4f82-b913-8e5f3a6c2d71
status: experimental
description: Detects mobile devices (Android user agents or MTD-identified devices) communicating with domains flagged as newly registered or associated with malware C2 infrastructure. Bazuka operators rely on C2 for credential exfiltration, overlay template delivery, and LLM-assisted victim management sessions.
references:
  - https://thehackernews.com/2026/11/bazuka-android-malware-uses-fake-screen.html
  - https://attack.mitre.org/techniques/T1071.001/
author: Security Arsenal
date: 2026/11/10
tags:
  - attack.command_and_control
  - attack.t1071
logsource:
  category: proxy
detection:
  selection:
    c-useragent|contains:
      - 'Android'
      - 'Dalvik'
    threat_category|contains:
      - 'newly_registered_domain'
      - 'malware_c2'
      - 'phishing'
      - 'low_reputation'
falsepositives:
  - Overly aggressive threat intel feeds; tune to high-confidence TI sources only
level: medium

KQL — Microsoft Sentinel / Defender

This query hunts Defender for Endpoint mobile telemetry (if your Android fleet is onboarded to MDE) for the permission-abuse pattern, and pairs it with a network-side hunt for mobile devices reaching low-reputation infrastructure. Run both; the join at the end correlates devices that trip both signals within 24 hours — a strong Bazuka candidate.

KQL — Microsoft Sentinel / Defender
// Part 1: Android devices with Accessibility/overlay-style abuse signals from MDE mobile
let SuspiciousMobileDevices =
    DeviceInfo
    | where OSPlatform =~ "Android"
    | summarize by DeviceId, DeviceName;
AlertInfo
| where TimeGenerated > ago(24h)
| where Title has_any ("accessibility", "overlay", "display over other apps", "banker", "trojan")
   or Category =~ "Malware"
| join kind=inner SuspiciousMobileDevices on DeviceId
| summarize AlertCount = count(), AlertTitles = make_set(Title) by DeviceId, DeviceName
| where AlertCount >= 1;
// Part 2: Network egress from Android devices to low-reputation / newly seen domains
DeviceNetworkEvents
| where TimeGenerated > ago(24h)
| join kind=inner (DeviceInfo | where OSPlatform =~ "Android" | summarize by DeviceId) on DeviceId
| where RemoteUrl !contains "google" and RemoteUrl !contains "microsoft" and RemoteUrl !contains "play.googleapis"
| where ActionType == "ConnectionSuccess"
| summarize ConnectionCount = count(), RemoteUrls = make_set(RemoteUrl, 20) by DeviceId, RemoteIP, bin(TimeGenerated, 1h)
| where ConnectionCount > 200  // beaconing-like cadence from a mobile device is anomalous
| sort by ConnectionCount desc

Velociraptor VQL

Velociraptor does not natively run on Android handsets, but if you manage Android emulator-based analysis, mobile device lab machines, or Windows/macOS workstations where Bazuka dropper APKs land for analysis (email attachments, downloaded smishing payloads), this artifact hunts analyst workstations and file servers for staged APK artifacts and ADB sideload traces.

VQL — Velociraptor
-- Hunt for Android APK droppers and ADB sideloading activity on endpoints
-- Relevant for malware analysis workstations, build servers, and endpoints that received smishing payloads
SELECT Pid, Name, CommandLine, Exe, Username, CreateTime
FROM pslist()
WHERE CommandLine =~ '(?i)adb\s+(install|sideload|push)'
   OR Name =~ '(?i)adb\.exe'

-- Companion file hunt: recently written APK files outside approved tooling paths
SELECT FullPath, Size, Mtime, Ctime
FROM glob(globs=[
  'C:/Users/*/Downloads/*.apk',
  'C:/Users/*/Desktop/*.apk',
  '/home/*/Downloads/*.apk',
  '/tmp/*.apk'
])
WHERE Mtime > (now() - 86400 * 7)
ORDER BY Mtime DESC

Remediation & Hardening Script

For organizations managing Android devices via ADB-capable tooling or MDM enrollment scripts, this Bash script audits devices for the two permission patterns Bazuka depends on: non-Play installs with Accessibility enabled, and apps holding overlay permission. Run it against enrolled/lab devices or adapt the checks into your MDM compliance policy.

Bash / Shell
#!/bin/bash
# Bazuka Android malware - device audit for overlay & accessibility abuse
# Run against an ADB-connected device. Review output; do NOT auto-remove without validation.

echo "=== [1] Packages installed from non-Play sources ==="
for pkg in $(adb shell pm list packages -3 | sed 's/package://'); do
  installer=$(adb shell pm get-install-location "$pkg" 2>/dev/null >/dev/null; \
              adb shell dumpsys package "$pkg" 2>/dev/null | grep -i "installerPackageName" | head -1)
  if ! echo "$installer" | grep -q "com.android.vending"; then
    echo "NON-PLAY INSTALL: $pkg  ($installer)"
  fi
done

echo ""
echo "=== [2] Enabled Accessibility Services ==="
adb shell settings get secure enabled_accessibility_services
# Any entry here that is not an approved IT/accessibility app is a Bazuka-class red flag.

echo ""
echo "=== [3] Apps holding 'draw over other apps' (overlay) permission ==="
adb shell appops query-op SYSTEM_ALERT_WINDOW allow 2>/dev/null || \
adb shell dumpsys appops | grep -A2 "SYSTEM_ALERT_WINDOW" | grep "mode=allow"
# Cross-reference every package listed against your approved app inventory.

echo ""
echo "=== [4] Notification listener services (OTP/SMS theft surface) ==="
adb shell settings get secure enabled_notification_listeners

echo ""
echo "=== [5] Verify Play Protect + unknown sources lockdown ==="
adb shell settings get secure package_verifier_enable
adb shell settings get global install_non_market_apps 2>/dev/null
adb shell settings get secure install_non_market_apps 2>/dev/null
# Expected hardened state: verifier=1, non_market_apps=0 (or MDM-enforced)

Remediation

There is no patch for Bazuka — it abuses legitimate Android capabilities. Defense is architectural and behavioral:

  1. Block sideloading on managed devices. Enforce via MDM/EMM (Android Enterprise): disable installation from unknown sources, enforce Google Play Protect, and restrict app installs to managed Play. This single control kills the majority of the delivery chain.

  2. Lock down Accessibility Services. Through Android Enterprise policy, restrict which packages can be bound as Accessibility Services. On the customer-facing side, banking app developers should use the Accessibility API to detect when unexpected services are active while the app is in the foreground and refuse to render sensitive screens.

  3. Harden banking/payment apps against overlays. If you ship an Android app, implement overlay detection: check MotionEvent flags (FLAG_WINDOW_IS_OBSCURED / FLAG_WINDOW_IS_PARTIALLY_OBSCURED on touch events) to detect taps passing through an overlay, and consider blocking input or warning the user. Move high-risk authentication away from on-screen credential entry toward app-bound passkeys and device-bound cryptographic attestations (Play Integrity API).

  4. Deploy mobile threat defense. MTD/EDR on Android (Defender for Endpoint, Zimperium, Lookout, or equivalent) is the only reliable way to get the permission-abuse telemetry the detections above depend on. Forward those events to your SIEM — most organizations currently send mobile telemetry nowhere.

  5. Backend fraud controls for on-device fraud. Because Bazuka can operate inside an authenticated session, perimeter trust is not enough. Enforce transaction-signing with step-up authentication, behavioral biometrics, and anomaly detection on session characteristics (new Accessibility events mid-session, sudden gesture-timing changes).

  6. User awareness tuned to the LLM angle. Brief helpdesk and fraud teams: expect highly fluent, multilingual, persistent social engineering generated by the operator console. Establish a canonical rule — the bank will never ask a customer to install an app or grant Accessibility permissions — and make it a customer-facing message.

  7. Incident response for suspected infection. Isolate the device from corporate resources, revoke its sessions and tokens (IdP, banking, email), boot to safe mode to strip third-party Accessibility/overlay permissions, uninstall the malicious package, and perform a factory reset before re-enrollment. Rotate any credentials entered on the device after suspected compromise — assume harvested.

Monitor ThreatFabric's disclosure and your MTD vendor for published IOCs (package names, hashes, C2 domains) and feed them into your blocklists as they become available.

Related Resources

Security Arsenal Incident Response Services AlertMonitor Platform Book a SOC Assessment incident-response Intel Hub

Is your security operations ready?

Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.

Bazuka Android Malware Framework: Detecting and Defeating Overlay-Based Credential Theft and LLM-Driven Device Control | Security Arsenal | Security Arsenal