Skip to content
Skillpedia
Misc35k · #6187

reverse-engineering-android-malware-with-jadx

Lets your agent analyze malicious Android applications. It decompiles the code to understand how the malware works. It's useful for investigating threats on mobile devices.

What it does

This tool helps analyze suspicious Android mobile applications (APK files). It decompiles the app's code so you can read how it was made, check the permissions it requests, and find dangerous activities like data theft or communication with malicious servers.

When to use it

  • ✓When a mobile app seems suspicious or has been flagged as dangerous.
  • ✓When investigating apps that steal banking information, spy, or send SMS messages without permission.
  • ✓To find out what data an app collects, where it sends it, and which permissions it abuses.

Example of what to ask your AI

“Analyze this suspicious app to see if it steals data or communicates with malicious servers.”

Want more? Open the sections below.

How to use

The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.

Skill link

https://github.com/mukul975/Anthropic-Cybersecurity-Skills/blob/main/skills/reverse-engineering-android-malware-with-jadx/SKILL.md

Ready-to-paste message

Use this skill to help me: https://github.com/mukul975/Anthropic-Cybersecurity-Skills/blob/main/skills/reverse-engineering-android-malware-with-jadx/SKILL.md Read the SKILL.md file at that link and follow its instructions for my task.
How it works

The tool uses programs like JADX to transform the compiled app code back into something that looks like the original code. It then searches for code patterns that indicate malicious activities, such as accessing SMS, location, or internet communication.

Installation

Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.

In the terminal (Claude Code, Codex, Cursor), in your project folder:

npx skills add mukul975/Anthropic-Cybersecurity-Skills --skill reverse-engineering-android-malware-with-jadx

Or download just the file:

curl -L https://raw.githubusercontent.com/mukul975/Anthropic-Cybersecurity-Skills/main/skills/reverse-engineering-android-malware-with-jadx/SKILL.md -o SKILL.md
Technical content (original SKILL.md)

Original text by the author, straight from GitHub.

Reverse Engineering Android Malware with JADX

When to Use

  • A suspicious Android APK has been reported as malicious or flagged by mobile threat detection
  • Analyzing Android banking trojans, spyware, SMS stealers, or adware samples
  • Determining what data an app collects, where it sends it, and what permissions it abuses
  • Extracting C2 server addresses, encryption keys, and configuration data from Android malware
  • Understanding overlay attack mechanisms used by banking trojans

Do not use for analyzing obfuscated native (.so) libraries within APKs; use Ghidra or IDA for native ARM binary analysis.

Prerequisites

  • JADX 1.5+ installed (download from https://github.com/skylot/jadx/releases)
  • Android SDK with aapt2 and adb tools for APK inspection
  • apktool for full APK disassembly including smali code and resources
  • Python 3.8+ with androguard library for automated APK analysis
  • Frida for dynamic instrumentation (optional, for runtime analysis)
  • Isolated Android emulator (Genymotion or Android Studio AVD) without Google services

Workflow

Step 1: Extract APK Metadata and Permissions

Examine the APK structure and AndroidManifest.xml:

# Get APK basic info
aapt2 dump badging malware.apk

# Extract AndroidManifest.xml
apktool d malware.apk -o apk_extracted/ -f

# Analyze permissions with androguard
python3 << 'PYEOF'
from androguard.core.apk import APK

apk = APK("malware.apk")

print(f"Package:    {apk.get_package()}")
print(f"App Name:   {apk.get_app_name()}")
print(f"Version:    {apk.get_androidversion_name()}")
print(f"Min SDK:    {apk.get_min_sdk_version()}")
print(f"Target SDK: {apk.get_target_sdk_version()}")

# Dangerous permissions
dangerous_perms = {
    "android.permission.READ_SMS": "SMS theft",
    "android.permission.RECEIVE_SMS": "SMS interception",
    "android.permission.SEND_SMS": "Premium SMS fraud",
    "android.permission.READ_CONTACTS": "Contact harvesting",
    "android.permission.READ_CALL_LOG": "Call log theft",
    "android.permission.RECORD_AUDIO": "Audio surveillance",
    "android.permission.CAMERA": "Camera surveillance",
    "android.permission.ACCESS_FINE_LOCATION": "Location tracking",
    "android.permission.READ_PHONE_STATE": "Device fingerprinting",
    "android.permission.SYSTEM_ALERT_WINDOW": "Overlay attacks",
    "android.permission.BIND_ACCESSIBILITY_SERVICE": "Full device control",
    "android.permission.REQUEST_INSTALL_PACKAGES": "Sideloading apps",
    "android.permission.BIND_DEVICE_ADMIN": "Device admin abuse",
}

print("\nDangerous Permissions:")
for perm in apk.get_permissions():
    if perm in dangerous_perms:
        print(f"  [!] {perm}")
        print(f"      Risk: {dangerous_perms[perm]}")
    elif "android.permission" in perm:
        print(f"  [*] {perm}")

# Components
print("\nActivities:")
for act in apk.get_activities():
    print(f"  {act}")

print("\nServices:")
for svc in apk.get_services():
    print(f"  {svc}")

print("\nReceivers:")
for rcv in apk.get_receivers():
    print(f"  {rcv}")
PYEOF

Step 2: Decompile with JADX

Open the APK in JADX for Java/Kotlin source analysis:

# Open in JADX GUI
jadx-gui malware.apk

# Command-line decompilation for scripted analysis
jadx -d jadx_output/ malware.apk --show-bad-code

# Decompile with all options
jadx -d jadx_output/ malware.apk \
  --deobf \
  --deobf-min 3 \
  --deobf-max 64 \
  --show-bad-code \
  --threads-count 4

# The output directory structure:
# jadx_output/
#   sources/           <- Decompiled Java source code
#     com/malware/app/
#       MainActivity.java
#       C2Service.java
#       SMSReceiver.java
#   resources/         <- Decoded resources (layouts, strings, assets)
#     AndroidManifest.xml
#     res/
#     assets/

Step 3: Identify Malicious Functionality

Search for suspicious code patterns in decompiled sources:

# Search for network communication
grep -rn "HttpURLConnection\|OkHttpClient\|Retrofit\|Volley\|URL(" jadx_output/sources/

# Search for SMS operations
grep -rn "SmsManager\|getDefault().sendTextMessage\|SMS_RECEIVED" jadx_output/sources/

# Search for overlay attack code
grep -rn "SYSTEM_ALERT_WINDOW\|TYPE_APPLICATION_OVERLAY\|WindowManager.LayoutParams" jadx_output/sources/

# Search for accessibility service abuse
grep -rn "AccessibilityService\|onAccessibilityEvent\|performAction" jadx_output/sources/

# Search for data exfiltration

…
FAQ

What is an APK file?

APK is the file format used to distribute and install applications on Android devices. It's like a package containing all the app's code and resources.

What does 'reverse engineering' mean?

Reverse engineering is the process of taking something apart (in this case, an app) to understand how it works, often to uncover its secrets or how it was built.

Can I use this on any app?

This tool is specific for analyzing Android apps suspected of being malicious. It's not for general use and might not work well with apps using very advanced obfuscation techniques or native code.

Details

Original description by the author

Reverse engineers malicious Android APK files using the JADX decompiler to read Java/Kotlin source, inspect manifest permissions, receivers, services, and native libraries, and identify data theft, C2 communication, privilege escalation, or overlay-attack behavior. Use when analyzing a suspected Android banking trojan, spyware, SMS stealer, or other flagged APK, or when investigating mobile malwar

repo: mukul975/Anthropic-Cybersecurity-Skills

Popularity

GitHub stars
35k
Ranking position
#6187
License
Apache-2.0
Updated
8/31/2026

Is this skill useful?

0

Sign in to vote.

Comments

  • …

More skills from this repository

Similar skills