
Course content:
- Understand the Android System Architecture and AOSP source code
- Learn about the Android Boot sequence, and Rooting processes
- Learn about the Binder IPC on Android
- Learn how to perform Crash Analysis on Android
- Acquire skills in ARM Reverse Engineering
- Get an understanding of latest ARM64 instruction set
- Learn how to customize and build Android OS and Kernel for Vulnerability Research
- Gain knowledge about Android Platform Permission, DAC, CAP, RKP, MTE, SELinux, and more
- Reverse engineering Android binaries (Apps and system binaries)
- Learn how to extract and decrypt boot images for Android devices
- Get an introduction to memory allocation and Scudo allocator
- Learn how to symbolicate the Android kernel
- Learn about Privilege Escalation on Android
- Learn using Case Study of Public Exploits
- Reverse engineer and trace Android JNI bindings, including RegisterNatives
- Use tools like JNINinja, Frida, and Medusa to hook and monitor JNI methods at runtime
- Build a functional JVM environment and AFL++ Frida-mode to fuzz JNI bindings and validate crashes
- Become a Certified Android Security Researcher (CASR)
01 Course Preview
- Offensive Android Internals - Trailer
02 Welcome to the course
- Getting Started
- Ethical Use Note
- Ask the Instructors
03 Introduction to Android
- About this Module
- Glossary
- Overview of Android Ecosystem and Architecture
- Introduction to Android Components
- Setting Up Android Emulator
- Understanding Android Debug Bridge (ADB)
- Extract APK using Third Party Sources & Automated Techniques
- Extract APK manually using ADB
- Handling Split APK in Android
- Quiz 3.1
- Homework
04 Setting up Research Devices
- About this Module
- Glossary
- Compile AOSP from scratch - Part I
- Compile AOSP from scratch - Part II
- Setting up Host machine to run Compiled Custom AOSP Images
- Compiling Custom Kernels for Physical Devices & Exploitation
- Setting up Physical Devices for Security Research
- Rooting Android Physical Devices
- Rooting Android Emulators
- Quiz 4.1
- Homework
05 AOSP Source Tree Walkthrough
- About this Module
- Glossary
- AOSP Source Tree Walkthrough 1 (art, bionic, bootable, build, cts, dalvik, developer, development, device, external)
- AOSP Source Tree Walkthrough 2 (framework, activitymanager)
- AOSP Source Tree Walkthrough 3 (packagemanager)
- AOSP Source Tree Walkthrough 4 (av, native)
- AOSP Source Tree Walkthrough 5 (hardware, kernel, libcore, libnativehelper, packages, sdk, system, test, tools, trust)
- Quiz 5.1
- Homework
06 Boot Sequence
- About this Module
- Glossary
- Demystifying Android Boot Sequence
- Quiz 6.1
- Homework
07 Android Zygote and JVM
- About this Module
- Glossary
- Introduction to Zygote in Android
- Android Zygote Deepdive
- Quiz 7.1
- Homework
08 Understanding Android GKI
- About this Module
- Glossary
- Demystifying Android GKI
- Quiz 8.1
- Homework
09 Android OS File System
- About this Module
- Glossary
- File System Monitoring on Android
- Android Sandbox and Filesystem Explained
- Quiz 9.1
- Homework
10 ARM64 Architecture and Assembly
- About this Module
- Glossary
- ARM64 Calling Convention
- Understanding ARM64 Registers - Part 1
- Understanding ARM64 Registers - Part 2
- Understanding ARM64 Registers - Part 3
- Understanding ARM64 Architecture
- Walkthrough of ARM64 Instructions - Part 1
- Walkthrough of ARM64 Instructions - Part 2
- Quiz 10.1
- Homework
11 Android Development Support
- About this Module
- Glossary
- Introduction To Android Studio and Building Android Code
- Quiz 11.1
- Homework
12 Android Reverse Engineering
- About this Module
- Glossary
- Introduction to Android Application Reversing
- Apktool Deep dive
- Smali Bytecode DeepDive
- Quiz 12.1
- Reverse Engineering Android APK
- Application Patching and Re-signing on Android
- Quiz 12.2
- Android Accessibility Services & Malwares
- Quiz 12.3
- Deepdive into Common Android Obfuscation Techniques
- Reverse Engineering Obfuscated Android APK
- Quiz 12.4
- Homework
13 Crash Analysis on Android
- About this Module
- Glossary
- Introduction to Android Crash Logs
- JVM Exception Stack Trace in Android
- Practical Analysis of Exception Stack Trace Logs
- Introduction to ANR Dumps in Android
- Practical Analysis of ANR Dumps in Android
- Tombstone Files on Android
- Practical Analysis of Tombstone files
- Symbolicating Crashes using ndk-stack and addr2line
- Quiz 13.1
- Homework
14 SELinux in Android
- About this Module
- Glossary
- Deep Dive into Android SELinux and Security Domains
- Understanding SELinux Policy Language and .te Files
- Interacting with SELinux Policy File
- Quiz 14.1
- Homework
15 Package Manager Service and Internals
- About this Module
- Glossary
- Introduction to Preferred Packages in Android
- Android System-Level Preferred Packages
- Deep Dive into Android User-specified Defaults and Preferred-Packages
- PackageManagerService Deepdive
- Internals of packages.xml inside PackageManagerService in Android
- Internals of packages.list inside PackageManagerService in Android
- Quiz 15.1
- Homework
16 Exploiting run-as
- About this Module
- Glossary
- Technical Implications of Leaving Applications Debuggable
- Using run-as to Exploit Debuggable Applications
- Understanding CVE-2024-0044
- Reading Sandbox Data of Android applications exploiting CVE-2024-0044
- Reading Sandbox Data of Privapps exploiting CVE-2024-0044
- Quick Feedback Form
- Quiz 16.1
- Homework
17 Binder IPC
- About this Module
- Glossary
- Introduction to Inter-process communication and Android Binder IPC
- Understanding Android Binder IPC
- Binder Framework Concepts
- Binder Framework Concepts - Extended
- Deep Dive Binder Inter-process Communication Flow
- Quiz 17.1
- Homework
18 Debugging Tools and Techniques
- About this Module
- Glossary
- Introduction to LLDB on Android
- LLDB Process Debugging
- LLDB Commands Deepdive & Application Debugging using LLDB
- Quiz 18.1
- Homework
19 Live Debugging and Code Injection
- About this Module
- Glossary
- Live Debugging and Patching Code using Jadx-Gui
- Dynamic Linking in Android & Code Injection using LD_PRELOAD
- Tracing Native Android Library Code
- Quiz 19.1
- Homework
20 Android Firmware Analysis
- About this Module
- Glossary
- Extracting Android Boot Images and Firmware Files
- Extract and Decrypt Boot Images for OnePlus and Oppo Firmwares
- Extract Android Kernel from Boot Image
- Symbolicating the Android Kernel
- Quiz 20.1
- Homework
21 Compiling Exploits and Porting
- About this Module
- Glossary
- Cross Compile Native Code and Exploits for Android Platform
- Porting Android Exploits Across Devices
- Quiz 21.1
- Homework
22 Privilege Escalation Techniques
- About this Module
- Glossary
- Deepdive Task_Struct and Cred in Privilege Escalation
- Analyzing Android Kernel Data Structures
- How to Escalate Privileges on Android
- Quiz 22.1
- Homework
23 Memory Allocators and Protection
- About this Module
- Glossary
- Limitations and Attacks on Traditional Android Allocators like dlmalloc & jemalloc
- Deepdive into Scudo Chunk Headers
- Purpose of Checksum Field in Scudo Chunk
- Checksum Setup and Verification in Scudo Chunk Header
- Quiz 23.1
- Homework
24 KDP and RKP Security Mechanisms
- About this Module
- Glossary
- Introduction to Samsung KDP and RKP
- Enhanced Reference Counting and Safeguards in RKP
- KDP and RKP Security Mechanism Explained Part 1
- KDP and RKP Security Mechanism Explained Part 2
- Concluding KDP and RKP Security
- Quiz 24.1
- Homework
25 Memory Tagging and Protection
- About this Module
- Glossary
- Enabling Memory Tagging on Android Devices
- MTE in Action Detecting UAF
- Quiz 25.1
- Homework
26 CVE-2023-26083: Kernel Pointer Leakage in Mali GPU's Timeline Stream Message Buffers
- About this Module
- Glossary
- Introduction to CVE-2023-26083
- Background of Mali GPU
- Internals of Mali GPU Driver and Context
- Understanding the Role of Timeline Streams and Vulnerability deep dive
- Walkthrough of PoC code to Exploit CVE-2023-26083
- Exploiting CVE-2023-26083 using PoC
- Quiz 26.1
- Homework
27 JNI Reversing and Native Fuzzing
- About this Module
- Glossary
- Fuzzing - What we'll cover
- JNI Fundamentals
- Reversing JNI Functions Exposed to Java
- Beautifying JNI Code and Retyping
- Reversing JNI RegisterNatives
- Intro to Finding & Tracing JNI Bindings
- Finding & Tracing JNI Bindings using JNINinja
- Finding & Tracing JNI Bindings using Frida
- Quiz 27.1
- Hooking and Tracing JNI methods at Runtime
- Exploring JNI Signatures using Medusa
- Overcoming Fuzz restrictions using functional JVM Environment
- Building AFL++ Frida-mode for Android
- Fuzzing using AFL Frida Mode
- Validating crashes in AFL Frida Mode
- Custom Object-based JNI binding Fuzzing
- Quiz 27.2
- Share Your Feedback
- Homework
28 CASR Mock Exam
29 Certified Android Security Researcher (CASR) Exam
- CASR Exam details
- Next steps
- Schedule Exam
- Certificate of Completion

FAQ – Offensive Android Internals (On-Demand)
How much does the course cost?
The course costs NOK 13,500 excluding VAT. With 25% Norwegian VAT, the total price is NOK 16,875 including VAT. One attempt at the Certified Android Security Researcher (CASR) certification exam is included.
How is the course delivered?
The course is delivered as self-paced, on-demand e-learning through 8kSec Academy. Participants can access recorded lessons, practical exercises and self-assessments and study at their own pace.
How long does the course take?
The course includes approximately 19.5 hours of video instruction across 114 videos. The estimated completion time is 3–5 months, depending on experience and study pace.
How long will I have access to the course?
Participants receive 365 days of access after purchase, allowing time to complete the lessons, work through the labs and prepare for certification.
Who should attend this course?
The course is designed for professionals who want to understand Android operating system internals, identify security weaknesses and develop practical vulnerability research skills.
- Android vulnerability researchers
- Penetration testers and ethical hackers
- Mobile security researchers
- Malware analysts and reverse engineers
- Android developers
- Security engineers
- Cybersecurity professionals interested in low-level mobile security
What prerequisites are required?
Participants should have basic knowledge of the Android platform, Linux command-line skills and an understanding of programming concepts in Java, Kotlin, C, C++ or a similar language.
Do I need previous experience with ARM64 assembly?
Basic knowledge of ARM or AARCH64 assembly and exploitation concepts is recommended but not required. The course includes dedicated modules introducing ARM64 architecture and assembly instructions.
What will I learn during the course?
You will develop practical knowledge of Android operating system internals, reverse engineering and vulnerability research. After completing the course, you will be able to:
- Understand Android system architecture and the AOSP source code
- Explain Android boot processes and rooting concepts
- Explore Android Binder inter-process communication
- Analyse Android crashes and debugging information
- Understand ARM64 architecture and reverse engineering techniques
- Compile and customise Android operating system and kernel builds for research
- Investigate Android security mechanisms including SELinux, RKP and MTE
- Reverse engineer Android applications and system binaries
- Analyse Android firmware and extract kernel components
- Understand memory allocation and privilege escalation concepts
- Examine publicly documented Android vulnerabilities and exploitation case studies
- Analyse JNI bindings and conduct native fuzz testing
Is the course hands-on?
Yes. The programme includes practical exercises, debugging labs, reverse-engineering activities, vulnerability research scenarios, firmware analysis and hands-on fuzz testing in controlled research environments.
Which topics are covered?
The course covers a broad range of Android security research topics, including:
- Android architecture and AOSP internals
- Research device and emulator configuration
- Android boot sequence and Zygote
- Generic Kernel Image (GKI)
- Android filesystem and sandboxing
- ARM64 assembly and reverse engineering
- APK analysis, Smali and code obfuscation
- Crash analysis and kernel debugging
- SELinux policies and Android permissions
- Package Manager Service internals
- Binder IPC architecture
- LLDB debugging and native code analysis
- Android firmware extraction and kernel symbolication
- Privilege escalation and memory protection
- Scudo memory allocator
- Kernel Data Protection (KDP) and Runtime Kernel Protection (RKP)
- Memory Tagging Extension (MTE)
- Public vulnerability and exploit case studies
- JNI reverse engineering and fuzzing with AFL++ Frida-mode
Does the course cover Android kernel security?
Yes. The course introduces Android kernel architecture, firmware analysis, kernel symbolication, memory allocators, privilege escalation concepts and security mechanisms such as KDP, RKP and MTE.
Does the course cover reverse engineering?
Yes. Participants learn to analyse Android applications, system binaries and native libraries. The curriculum includes APK analysis, Smali, obfuscated code, ARM64 instructions and techniques for investigating Android software behaviour.
Does the course cover Android rooting?
Yes. The course explores Android rooting processes, research device configuration, custom operating system builds and the role of elevated privileges in security research.
Does the course cover JNI and native fuzzing?
Yes. The programme includes JNI reverse engineering, tracing native bindings with tools such as Frida, JNINinja and Medusa, and fuzz testing using AFL++ Frida-mode.
Is this an Android application penetration testing course?
Not primarily. Offensive Android Internals focuses on operating system internals, vulnerability research and low-level security mechanisms. Participants primarily interested in mobile application security assessments may prefer Practical Mobile Application Exploitation.
Which tools are used during the course?
The curriculum includes Android Debug Bridge (ADB), Apktool, JADX, LLDB, Frida, JNINinja, Medusa, AFL++ Frida-mode and tools for firmware extraction and crash analysis.
What equipment do I need?
Participants need a laptop with at least 8 GB RAM, 40 GB of available disk space and administrative access. Completing the labs also requires a rooted physical Android device running Android 12 or later, or access to a suitable virtualised environment such as Corellium or an emulator.
What language is the course delivered in?
The video instruction is in English. Subtitles are available in English, German, Spanish, French, Arabic and Japanese.
Does the course prepare me for certification?
Yes. The course prepares participants for the Certified Android Security Researcher (CASR) certification from 8kSec Academy. The certification assesses knowledge and practical skills in advanced Android security, including userland and kernel components.
Is the certification exam included?
Yes. The Certified Android Security Researcher (CASR) certification exam is included in the course price. Participants must pass the assessment to earn the certification.
How is the certification exam structured?
The CASR certification exam is a 24-hour hands-on assessment designed to evaluate practical Android security research skills.
Will I receive a certificate of completion?
Yes. Participants receive a certificate of course completion. The CASR certification is awarded separately after successfully passing the certification exam.
Can the course be purchased for a team or organisation?
Yes. Group enrolment is available for organisations wishing to train multiple employees. The training provider offers group pricing and optional learner progress tracking for larger teams.
What makes this course valuable?
The course goes beyond conventional mobile application testing to explore how Android works internally. Through AOSP analysis, ARM64 reverse engineering, kernel security, practical labs and real-world vulnerability research examples, participants develop specialist skills for understanding and investigating Android security at a deeper technical level.