Listen to this Post
Introduction:
Static analysis tells you what an app should do. Dynamic instrumentation tells you what it actually does — and more often than not, those two stories don’t match. When you hook into cryptographic functions at runtime, encryption keys, initialization vectors, and plaintext data become visible in memory, exposing the gap between secure design and real-world implementation. This walkthrough demonstrates how to intercept Android encryption processes using Frida, turning “trust the code” into “verify the runtime” — an essential capability for any serious mobile penetration test.
Learning Objectives:
- Understand the difference between static decompilation and dynamic instrumentation for Android security analysis
- Hook `javax.crypto.Cipher.init()` and `doFinal()` to extract encryption keys, algorithms, and operational modes in real time
- Differentiate between secure hardware-backed keys and software-accessible keys using `KeyInfo.isInsideSecureHardware()`
– Identify weak cryptographic implementations — such as hardcoded keys or reused IVs — through runtime observation - Apply Frida scripting to bypass certificate pinning and root detection for deeper mobile app testing
- Static Reconnaissance — Mapping the Attack Surface with Jadx-GUI
Before you can instrument an application, you need to understand its cryptographic architecture. Jadx-GUI decompiles DEX bytecode into readable Java source code, allowing you to locate encryption routines, identify the `Cipher` class usage, and trace how keys are generated or retrieved.
Step‑by‑step guide:
- Decompile the APK: Launch Jadx-GUI and open the target APK file. Navigate through the package structure to locate the encryption-related activities.
- Locate the encryption function: Search for
Cipher.getInstance(),KeyStore, or `SecretKeySpec` within the decompiled source. In the OWASP MSTG-Hacking-Playground app (sg.vp.owasp_mobile.OMTG_Android), the `encrypt()` function pulls a public key from the Android KeyStore, builds a `Cipher` object with algorithm parameters, and executes `cipher.init()` followed bydoFinal(). - Identify weak patterns: Look for hardcoded keys, static IVs, or deprecated algorithms like DES or MD5. Use command-line grepping for rapid scanning:
grep -r "DES|MD5|SHA1" app-decompiled/sources/ grep -r "rawQuery|execSQL" app-decompiled/sources/
-
Map the call chain: Note which classes invoke encryption and whether keys come from
KeyStore,SharedPreferences, or are generated on the fly.
Static analysis provides the blueprint. Dynamic instrumentation validates whether that blueprint is actually followed — or circumvented.
2. Dynamic Instrumentation — Hooking Cipher.init() with Frida
Every encryption call in Android’s `javax.crypto.Cipher` flows through the `init()` method. By hooking this method, you can intercept the operation mode, algorithm, and — critically — the key material at the moment it’s loaded into memory.
Step‑by‑step guide:
1. Set up Frida on your testing environment:
- Install Frida on your host machine: `pip install frida-tools`
– Download the appropriate Frida server for your Android device architecture from the official releases - Push the server to the device: `adb push frida-server /data/local/tmp/`
– Start the server with root privileges: `adb shell su -c /data/local/tmp/frida-server &`
2. Write the Frida hook script:
'use strict';
Java.perform(() => {
const Cipher = Java.use('javax.crypto.Cipher');
// Hook the init() overload that takes (int, Key)
Cipher.init.overload('int', 'java.security.Key')
.implementation = function(opmode, key) {
console.log("[] Cipher.init() called");
console.log(" Opmode: " + this.getOpmodeString(opmode));
console.log(" Algorithm: " + this.getAlgorithm());
console.log(" Key algorithm: " + key.getAlgorithm());
// Attempt to extract raw key bytes
try {
const encoded = key.getEncoded();
if (encoded) {
console.log(" Key bytes (hex): " + bytesToHex(encoded));
}
} catch (e) {
console.log(" [!] Cannot extract key bytes — possibly hardware-backed");
}
// Call the original method to avoid breaking the app
return this.init.overload('int', 'java.security.Key')
.call(this, opmode, key);
};
// Helper: convert byte array to hex string
function bytesToHex(bytes) {
var hex = '';
for (var i = 0; i < bytes.length; i++) {
hex += ('0' + (bytes[bash] & 0xFF).toString(16)).slice(-2);
}
return hex;
}
});
- Hook additional overloads: Cipher.init() has multiple overloads —
(int, Key),(int, Key, AlgorithmParameterSpec), and(int, Key, SecureRandom). Hook all relevant ones to capture IVs and other parameters.
4. Execute the script:
frida -U -f sg.vp.owasp_mobile.OMTG_Android -l hook.js --1o-pause
- Interact with the app: Trigger the encryption buttons (“RANDOM KEY ENCRYPT” and “ENCRYPT”) and observe the console output. The fresh IV + Secret Key per run will appear distinct from reused static values.
⚠️ Critical warning: If you hook `init()` but fail to call the original implementation, the app will throw an exception and crash. Always `return this.init.overload(…).call(this, …)` to preserve normal execution flow.
- Extracting Key Material — What You Can and Cannot Recover
The `java.security.Key` object passed to `Cipher.init()` contains the cryptographic material. The `getEncoded()` method returns the raw key bytes — but only if the key is software-accessible.
Step‑by‑step guide:
- Determine key origin: Keys generated within the Android KeyStore and flagged as secure hardware-backed will not expose private material via
getEncoded(). The `KeyInfo.isInsideSecureHardware()` method confirms whether a key resides in the Trusted Execution Environment (TEE) or Secure Element (SE).
2. Extract what’s available:
- Algorithm: `key.getAlgorithm()` returns the cipher family (e.g., “RSA”, “AES”)
- Encoded bytes: `key.getEncoded()` returns the raw key material for software keys
- Format: `key.getFormat()` indicates the encoding format (e.g., “PKCS8”, “RAW”)
3. Hook doFinal() for plaintext/ciphertext:
Cipher.doFinal.overload('[B').implementation = function(input) {
console.log("[] Cipher.doFinal() called");
console.log(" Input (hex): " + bytesToHex(input));
var result = this.doFinal.overload('[B').call(this, input);
console.log(" Output (hex): " + bytesToHex(result));
return result;
};
This reveals plaintext before encryption and ciphertext after decryption.
- Log the operation mode: Implement `getOpmodeString(opmode)` to translate numeric constants:
Cipher.getOpmodeString = function(opmode) { if (opmode === 1) return "ENCRYPT_MODE"; if (opmode === 2) return "DECRYPT_MODE"; if (opmode === 3) return "WRAP_MODE"; if (opmode === 4) return "UNWRAP_MODE"; return "UNKNOWN"; };
Why this matters: Two buttons, two behaviors. “RANDOM KEY ENCRYPT” produces a fresh IV and Secret Key per execution — a secure pattern. “ENCRYPT” reuses static values — a textbook indicator of weak or hardcoded cryptography. Frida exposes this difference in seconds, transforming a black-box app into a transparent runtime environment.
- Bypassing SSL Pinning and Root Detection — Removing Obstacles
Modern Android apps often implement certificate pinning and root detection to hinder dynamic analysis. Frida provides battle-tested scripts to bypass these protections, enabling uninterrupted instrumentation.
Step‑by‑step guide:
- SSL Pinning bypass: Use a comprehensive Frida script that hooks certificate validation methods across multiple frameworks (OkHttp, TrustManager, X509TrustManager):
// Universal SSL Pinning Bypass (excerpt) Java.perform(function() { var TrustManager = Java.use('javax.net.ssl.X509TrustManager'); TrustManager.checkServerTrusted.implementation = function(chain, authType) { // Accept all certificates }; }); -
Root detection bypass: Hide root indicators — `su` binaries, Magisk, test-keys, and debug builds:
Java.perform(function() { var File = Java.use('java.io.File'); File.exists.implementation = function() { var path = this.getAbsolutePath(); if (path.indexOf("su") !== -1 || path.indexOf("magisk") !== -1) { return false; } return this.exists.call(this); }; }); -
Combine techniques: Use pre-built scripts from repositories like `frida-interception-and-unpinning` or `Frida-Android-SSL-Pinning-Script` to handle multiple detection vectors simultaneously.
-
Automate with Objection: Objection wraps Frida with a friendly REPL interface, offering one-command bypasses for common protections:
objection -g sg.vp.owasp_mobile.OMTG_Android explore objection> android sslpinning disable objection> android root disable
Removing these barriers allows you to focus on the cryptographic logic rather than fighting the app’s defensive measures.
- Advanced Tracing — Monitoring System Calls and Native Libraries
Encryption doesn’t always happen in Java. Many apps offload crypto operations to native libraries (.so files) for performance or obfuscation. Frida’s `frida-trace` and `frida-strace` enable system‑call level tracing to catch these low‑level operations.
Step‑by‑step guide:
- Trace system calls: Use `frida-strace` to monitor file I/O, socket operations, and process interactions:
frida-strace -U -f sg.vp.owasp_mobile.OMTG_Android -i "open" -i "read" -i "write"
-
Hook native functions: If the app uses OpenSSL or BoringSSL, hook
EVP_CipherInit_ex,EVP_EncryptUpdate, andEVP_DecryptUpdate:Interceptor.attach(Module.findExportByName("libcrypto.so", "EVP_EncryptUpdate"), { onEnter: function(args) { console.log("[bash] EVP_EncryptUpdate called"); console.log(" Input length: " + args[bash]); } }); -
Trace with Frida’s built-in tools: `frida-trace` can generate handler templates for any function:
frida-trace -U -f sg.vp.owasp_mobile.OMTG_Android -i "javax.crypto.Cipher"
-
Combine Java and native hooks: Create a unified script that logs both Java-level `Cipher` calls and native OpenSSL operations, giving you complete visibility into the encryption pipeline.
6. Real-World Implications — From Lab to Production
The techniques demonstrated here aren’t theoretical. In real-world assessments, Frida has uncovered:
– Hardcoded API keys embedded in `SharedPreferences`
– Reused AES IVs across multiple sessions
– RSA private keys extractable from memory before secure hardware enrollment
– Custom crypto implementations with fatal flaws in padding or mode selection
Step‑by‑step guide for production-grade testing:
- Automate key extraction: Write Python scripts using Frida’s Python bindings to automate the hooking process and log results to a file for later analysis.
-
Integrate into CI/CD: Run Frida-based security tests as part of the mobile app build pipeline to catch crypto weaknesses before release.
-
Document findings: For each vulnerability, produce a clear report with:
– The affected class and method
– The extracted key or IV (if software-accessible)
– The recommended fix (e.g., move to KeyStore, use dynamic IVs, implement certificate pinning)
- Remediate and retest: After fixes are applied, re-run the Frida scripts to confirm that keys are no longer exposed and that encryption patterns are secure.
What Undercode Say:
- Key Takeaway 1: Static analysis provides a map; dynamic instrumentation reveals the actual terrain. Hooking `Cipher.init()` with Frida exposes encryption keys, algorithms, and modes in real time — turning abstract security promises into observable facts.
- Key Takeaway 2: The distinction between secure hardware-backed keys and software-accessible keys is critical. `KeyInfo.isInsideSecureHardware()` tells you whether private material is truly protected, but even hardware-backed keys leak algorithm details and operational modes that can inform an attacker’s next move.
- Key Takeaway 3: Weak cryptographic implementations — such as hardcoded keys, reused IVs, or deprecated algorithms — are easily identified through runtime instrumentation. The OWASP MSTG-Hacking-Playground app’s two-button demo perfectly illustrates how a single Frida script can differentiate between secure and insecure patterns in seconds.
- Key Takeaway 4: Frida’s ecosystem — including
frida-trace,frida-strace, and Objection — provides a comprehensive toolkit for mobile pentesting, from bypassing SSL pinning and root detection to tracing native library calls. Mastering these tools elevates any security professional’s capability to assess Android applications thoroughly.
Prediction:
- +1 The democratization of dynamic instrumentation tools like Frida will continue to lower the barrier to entry for mobile security testing, enabling more developers and security teams to catch crypto vulnerabilities early in the SDLC.
- +1 As Android’s KeyStore and hardware-backed security (TEE, StrongBox) become more prevalent, attackers will shift focus from extracting keys to exploiting the cryptographic protocols themselves — making runtime analysis of algorithms and modes even more valuable.
- -1 The same tools that empower ethical hackers are increasingly used by malicious actors to reverse-engineer banking, messaging, and enterprise apps. The arms race between defensive hardening and offensive instrumentation will intensify, with Frida remaining a central battleground.
- -1 Apps that rely solely on obfuscation or root detection for protection will face increasing compromise as Frida scripts for bypassing these measures become commoditized. True security must come from cryptographic robustness, not obscurity.
- +1 The integration of Frida with automated testing frameworks and CI/CD pipelines will mature, enabling continuous security validation of mobile apps — shifting security left and reducing the cost of fixing vulnerabilities post-release.
▶️ Related Video (80% Match):
🎯Let’s Practice For Free:
🎓 Live Courses & Certifications:
Join Undercode Academy for Verified Certifications
🚀 Request a Custom Project:
Secure, high-velocity infrastructure and disruptive technological engineering. Contact our engineering team for high-tier development and proprietary systems:
[email protected]
💎 Smart Architecture | 🛡️ Secure by Design | ⭐ Trusted by Thousands
IT/Security Reporter URL:
Reported By: Zlatanh Analyzing – Hackers Feeds
Extra Hub: Undercode MoN
Basic Verification: Pass ✅
