Android phone hacking course

Lesson 1 • APK Structure and Components

Dissects APK file format, manifest declarations, and four core components. Understanding component exposure is prerequisite for intent-based attack techniques.

Lesson 2 • Android Permission and Sandbox Model

Explains UID-based app isolation, permission groups, and runtime permission enforcement. Provides the conceptual basis for privilege escalation attacks covered later.

Lesson 3 • Android Security Model Threat Landscape

Surveys common Android threat categories including malware, privilege escalation, and data leakage. Frames the attack taxonomy learners will explore in subsequent chapters.

Lesson 1 • ADB and Fastboot Mastery

Teaches ADB shell commands, file transfer, logcat, and fastboot flashing. These tools are the primary interface for device interaction throughout the course.

Lesson 2 • Network Interception Lab Configuration

Sets up a controlled Wi-Fi access point and installs proxy certificates on the test device. This network environment is reused in all traffic analysis and SSL pinning exercises.

Lesson 3 • Core Security Toolchain Installation

Installs and validates Frida, Objection, Burp Suite, and MobSF on the host machine. A verified toolchain is required before any dynamic or static analysis can begin.

Lesson 1 • Hardcoded Secrets and Sensitive Data

Locates API keys, credentials, and cryptographic material embedded in code and resources. Findings directly feed into exploitation and responsible disclosure workflows.

Lesson 2 • Decompilation and Disassembly Techniques

Uses JADX, apktool, and dex2jar to recover Java and Smali source from APKs. Accurate decompilation is the foundation for all subsequent code-level analysis.

Lesson 3 • Insecure Code Pattern Identification

Detects weak cryptography, insecure random number usage, and improper input validation in decompiled code. Pattern recognition here directly informs dynamic exploitation strategies.

Lesson 4 • Automated Static Analysis with MobSF

Runs MobSF static scans, interprets severity ratings, and correlates findings with manual review. Automation accelerates coverage while manual review reduces false positives.

Lesson 1 • Memory Analysis and Data Extraction

Searches process memory for plaintext credentials, tokens, and encryption keys during runtime. Memory artefacts often expose secrets that static analysis cannot find.

Lesson 2 • Logic and Authentication Bypass

Hooks authentication methods to force success returns and bypass PIN, biometric, and licence checks. Demonstrates how runtime control undermines client-side security assumptions.

Lesson 3 • Objection for Rapid Runtime Testing

Uses Objection's command interface to explore file systems, bypass root detection, and dump memory without writing custom scripts. Speeds up reconnaissance during time-limited assessments.

Lesson 4 • Tracing and Behavioural Profiling

Uses method tracing and strace to build a behavioural map of app actions during specific user flows. Behavioural profiles reveal hidden functionality and sensitive data pathways.

Lesson 1 • API Endpoint Discovery and Fuzzing

Extracts API endpoints from intercepted traffic and decompiled code, then fuzzes parameters for injection flaws. Bridges mobile client analysis with server-side vulnerability discovery.

Lesson 2 • SSL Pinning Detection and Bypass

Identifies SSL pinning implementations in code and bypasses them using Frida and Objection scripts. Pinning bypass is required before encrypted traffic from hardened apps can be inspected.

Lesson 3 • Certificate Transparency and Trust Stores

Examines how Android evaluates certificate chains and how user-installed CA trust is restricted. Understanding trust store behaviour is essential for bypassing modern certificate controls.

Lesson 1 • Backup and Logcat Data Leakage

Exploits ADB backup to extract app data and mines logcat output for leaked tokens and PII. Both vectors are frequently overlooked in development and yield high-value findings.

Lesson 2 • SQLite Database Exploitation

Extracts and queries SQLite databases from app data directories to recover stored credentials and tokens. Databases are the most common location for sensitive persistent data in Android apps.

Lesson 3 • Shared Preferences and KeyStore Abuse

Reads plaintext shared preferences files and evaluates Android KeyStore implementation weaknesses. Improper KeyStore usage leaves cryptographic keys recoverable at runtime.

Lesson 1 • Pending Intent and Task Hijacking

Exploits mutable pending intents and task affinity misconfigurations to intercept app actions. These advanced IPC flaws are common in notification and payment integration code.

Lesson 2 • Intent Mechanics and Attack Surface

Explains explicit and implicit intents, intent filters, and how exported components receive them. Mastery of intent mechanics is prerequisite for all component-level exploitation techniques.

Lesson 3 • Content Provider Exploitation

Queries, inserts, and updates exported content providers to read and modify app data stores. Content providers are a high-value target due to their structured data access interface.

Lesson 4 • Broadcast Receiver and Service Attacks

Sends crafted broadcasts to trigger unauthorised actions and interacts with exported services. These attacks can manipulate app state, trigger payments, or exfiltrate data.

Lesson 1 • APK Backdooring and Repackaging

Injects malicious Smali payloads into legitimate APKs and re-signs them for deployment. Repackaging is a primary malware distribution technique and a key forensic indicator.

Lesson 2 • Data Exfiltration Techniques

Demonstrates covert exfiltration of contacts, SMS, location, and files over multiple channels. Exfiltration technique knowledge is essential for both offensive simulation and defensive detection.

Lesson 3 • Malware Implant Development Basics

Builds a minimal Android RAT demonstrating persistence, C2 communication, and data collection. Understanding implant mechanics enables defenders to detect and analyse real-world malware.

Lesson 4 • Full Attack Chain Simulation

Executes an end-to-end attack from initial access through persistence and exfiltration on a lab target. Integrates all prior skills into a realistic adversary simulation exercise.