From e0777ab227591a68c082fc6483343a86e5be5235 Mon Sep 17 00:00:00 2001 From: Translator Date: Mon, 28 Jul 2025 10:28:08 +0000 Subject: [PATCH] Translated ['src/mobile-pentesting/android-app-pentesting/bypass-biometr --- ...bypass-biometric-authentication-android.md | 57 +++++++++++++++++-- 1 file changed, 52 insertions(+), 5 deletions(-) diff --git a/src/mobile-pentesting/android-app-pentesting/bypass-biometric-authentication-android.md b/src/mobile-pentesting/android-app-pentesting/bypass-biometric-authentication-android.md index 545fba7fe..fd6622364 100644 --- a/src/mobile-pentesting/android-app-pentesting/bypass-biometric-authentication-android.md +++ b/src/mobile-pentesting/android-app-pentesting/bypass-biometric-authentication-android.md @@ -1,7 +1,8 @@ -# Umgehung der biometrischen Authentifizierung (Android) +# Bypass Biometric Authentication (Android) {{#include ../../banners/hacktricks-training.md}} + ## **Methode 1 – Umgehung ohne Verwendung von CryptoObject** Der Fokus liegt hier auf dem _onAuthenticationSucceeded_ Callback, der im Authentifizierungsprozess entscheidend ist. Forscher von WithSecure entwickelten ein [Frida-Skript](https://github.com/WithSecureLABS/android-keystore-audit/blob/master/frida-scripts/fingerprint-bypass.js), das die Umgehung des NULL _CryptoObject_ in _onAuthenticationSucceeded(...)_ ermöglicht. Das Skript erzwingt eine automatische Umgehung der Fingerabdruckauthentifizierung bei der Aufruf des Verfahrens. Unten ist ein vereinfachter Ausschnitt, der die Umgehung im Kontext von Android Fingerabdruck zeigt, mit der vollständigen Anwendung verfügbar auf [GitHub](https://github.com/St3v3nsS/InsecureBanking). @@ -37,8 +38,8 @@ Hooking FingerprintManager.authenticate()... Instrumentierungs-Frameworks wie Xposed oder Frida können verwendet werden, um zur Laufzeit in Anwendungs-Methoden einzugreifen. Für die Fingerabdruck-Authentifizierung können diese Frameworks: -1. **Die Authentifizierungs-Callbacks nachahmen**: Durch das Hooken in die Methoden `onAuthenticationSucceeded`, `onAuthenticationFailed` oder `onAuthenticationError` der `BiometricPrompt.AuthenticationCallback` können Sie den Ausgang des Fingerabdruck-Authentifizierungsprozesses steuern. -2. **SSL-Pinning umgehen**: Dies ermöglicht es einem Angreifer, den Datenverkehr zwischen dem Client und dem Server abzufangen und zu modifizieren, was potenziell den Authentifizierungsprozess verändern oder sensible Daten stehlen kann. +1. **Die Authentifizierungs-Callbacks fälschen**: Durch das Hooken in die Methoden `onAuthenticationSucceeded`, `onAuthenticationFailed` oder `onAuthenticationError` des `BiometricPrompt.AuthenticationCallback` können Sie den Ausgang des Fingerabdruck-Authentifizierungsprozesses steuern. +2. **SSL-Pinning umgehen**: Dies ermöglicht es einem Angreifer, den Datenverkehr zwischen dem Client und dem Server abzufangen und zu modifizieren, wodurch der Authentifizierungsprozess potenziell verändert oder sensible Daten gestohlen werden können. Beispielbefehl für Frida: ```bash @@ -54,14 +55,60 @@ Reverse Engineering-Tools wie `APKTool`, `dex2jar` und `JD-GUI` können verwende ## **Methode 5 – Verwendung von benutzerdefinierten Authentifizierungswerkzeugen** -Es gibt spezialisierte Tools und Skripte, die entwickelt wurden, um Authentifizierungsmechanismen zu testen und zu umgehen. Zum Beispiel: +Es gibt spezialisierte Werkzeuge und Skripte, die entwickelt wurden, um Authentifizierungsmechanismen zu testen und zu umgehen. Zum Beispiel: 1. **MAGISK-Module**: MAGISK ist ein Tool für Android, das es Benutzern ermöglicht, ihre Geräte zu rooten und Module hinzuzufügen, die hardwarebezogene Informationen, einschließlich Fingerabdrücke, modifizieren oder fälschen können. 2. **Benutzerdefinierte Skripte**: Skripte können geschrieben werden, um mit dem Android Debug Bridge (ADB) oder direkt mit dem Backend der Anwendung zu interagieren, um die Fingerabdruckauthentifizierung zu simulieren oder zu umgehen. +--- + +## **Methode 6 – Universeller Frida-Hook für `BiometricPrompt` (API 28-34)** + +Im Jahr 2023 erschien ein Community-Frida-Skript mit dem Namen **Universal-Android-Biometric-Bypass** auf CodeShare. Das Skript hookt jede Überladung von `BiometricPrompt.authenticate()` sowie das veraltete `FingerprintManager.authenticate()` und löst direkt `onAuthenticationSucceeded()` mit einem **gefälschten `AuthenticationResult`, das ein null `CryptoObject` enthält**, aus. Da es sich dynamisch an API-Ebenen anpasst, funktioniert es weiterhin auf Android 14 (API 34), wenn die Zielanwendung **keine kryptografischen Überprüfungen des zurückgegebenen `CryptoObject`** durchführt. +```bash +# Install the script from CodeShare and run it against the target package +frida -U -f com.target.app --no-pause -l universal-android-biometric-bypass.js +``` +Key ideas +* Alles geschieht im Benutzerspeicher – kein Kernel-Exploit oder Root ist erforderlich. +* Der Angriff bleibt für die Benutzeroberfläche vollständig still: Der biometrische Dialog des Systems erscheint niemals. +* Minderung: **überprüfen Sie immer `result.cryptoObject` und dessen Verschlüsselung/Signatur, bevor Sie sensible Funktionen entsperren**. + +## **Methode 7 – Downgrade / Fallback-Manipulation** + +Beginnend mit Android 11 können Entwickler angeben, welche Authentifizierer über `setAllowedAuthenticators()` (oder das ältere `setDeviceCredentialAllowed()`) akzeptabel sind. Ein **Runtime-Hooking**-Angriff kann das `allowedAuthenticators`-Bitfeld auf den schwächeren +`BIOMETRIC_WEAK | DEVICE_CREDENTIAL`-Wert zwingen: +```javascript +// Frida one-liner – replace strong-only policy with weak/device-credential +var PromptInfoBuilder = Java.use('androidx.biometric.BiometricPrompt$PromptInfo$Builder'); +PromptInfoBuilder.setAllowedAuthenticators.implementation = function(flags){ +return this.setAllowedAuthenticators(0x0002 | 0x8000); // BIOMETRIC_WEAK | DEVICE_CREDENTIAL +}; +``` +Wenn die App das zurückgegebene `AuthenticationResult` **nicht** anschließend validiert, kann ein Angreifer einfach die _PIN/Pattern_ Fallback-Taste drücken oder sogar einen neuen schwachen biometrischen Zugang registrieren, um Zugriff zu erhalten. + +## **Methode 8 – Vendor / Kernel-Level CVEs** + +Behalten Sie die Android-Sicherheitsbulletins im Auge: Mehrere aktuelle Kernel-seitige Fehler ermöglichen eine lokale Privilegieneskalation über das Fingerabdruck-HAL und **deaktivieren oder überbrücken effektiv die Sensorpipeline**. Beispiele sind: + +* **CVE-2023-20995** – Logikfehler in `captureImage` von `CustomizedSensor.cpp` (Pixel 8, Android 13), der das Umgehen der Entsperrung ohne Benutzerinteraktion ermöglicht. +* **CVE-2024-53835 / CVE-2024-53840** – „möglicher biometrischer Umgehung aufgrund einer ungewöhnlichen Grundursache“, die im **Dezember 2024 Pixel Bulletin** gepatcht wurde. + +Obwohl diese Schwachstellen den Sperrbildschirm anvisieren, kann ein gerooteter Tester sie mit App-Level-Fehlern verketten, um biometrische Authentifizierung in der App zu umgehen. + +--- + +### Härtungs-Checkliste für Entwickler (Schnelle Pentester-Notizen) + +* Erzwingen Sie `setUserAuthenticationRequired(true)` und `setInvalidatedByBiometricEnrollment(true)`, wenn Sie **Keystore**-Schlüssel generieren. Ein gültiger biometrischer Nachweis ist dann erforderlich, bevor der Schlüssel verwendet werden kann. +* Lehnen Sie ein `CryptoObject` mit **null oder unerwartetem Cipher / Signatur** ab; behandeln Sie dies als einen fatalen Authentifizierungsfehler. +* Bevorzugen Sie bei der Verwendung von `BiometricPrompt` `BIOMETRIC_STRONG` und **fallen Sie niemals auf `BIOMETRIC_WEAK` oder `DEVICE_CREDENTIAL`** für hochriskante Aktionen zurück. +* Fixieren Sie die neueste `androidx.biometric` Version (≥1.2.0-beta02) – aktuelle Versionen fügen automatische Null-Cipher-Prüfungen hinzu und verschärfen die zulässigen Authentifizierer-Kombinationen. + ## Referenzen -- [https://securitycafe.ro/2022/09/05/mobile-pentesting-101-bypassing-biometric-authentication/](https://securitycafe.ro/2022/09/05/mobile-pentesting-101-bypassing-biometric-authentication/) +- [Universal Android Biometric Bypass – Frida CodeShare](https://codeshare.frida.re/@ax/universal-android-biometric-bypass/) +- [Android Pixel Security Bulletin 2024-12-01](https://source.android.com/security/bulletin/pixel/2024-12-01) {{#include ../../banners/hacktricks-training.md}}