From 15ba4068a8759244b7a25603f8e6983cc15b73d7 Mon Sep 17 00:00:00 2001 From: Translator Date: Thu, 21 Aug 2025 04:10:22 +0000 Subject: [PATCH] Translated ['src/mobile-pentesting/android-app-pentesting/android-anti-i --- src/SUMMARY.md | 1 + .../android-app-pentesting/README.md | 78 +++---- ...-instrumentation-and-ssl-pinning-bypass.md | 203 ++++++++++++++++++ 3 files changed, 246 insertions(+), 36 deletions(-) create mode 100644 src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md diff --git a/src/SUMMARY.md b/src/SUMMARY.md index 432bf44fc..e7e49e187 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -326,6 +326,7 @@ - [Android APK Checklist](mobile-pentesting/android-checklist.md) - [Android Applications Pentesting](mobile-pentesting/android-app-pentesting/README.md) - [Accessibility Services Abuse](mobile-pentesting/android-app-pentesting/accessibility-services-abuse.md) + - [Android Anti Instrumentation And Ssl Pinning Bypass](mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md) - [Android Applications Basics](mobile-pentesting/android-app-pentesting/android-applications-basics.md) - [Android Task Hijacking](mobile-pentesting/android-app-pentesting/android-task-hijacking.md) - [ADB Commands](mobile-pentesting/android-app-pentesting/adb-commands.md) diff --git a/src/mobile-pentesting/android-app-pentesting/README.md b/src/mobile-pentesting/android-app-pentesting/README.md index a75ae23c2..21af3a85d 100644 --- a/src/mobile-pentesting/android-app-pentesting/README.md +++ b/src/mobile-pentesting/android-app-pentesting/README.md @@ -75,7 +75,7 @@ Preste atenção especial às **URLs do firebase** e verifique se estão mal con A **examinação dos arquivos _Manifest.xml_ e **_strings.xml_** de uma aplicação pode revelar potenciais vulnerabilidades de segurança**. Esses arquivos podem ser acessados usando decompiladores ou renomeando a extensão do arquivo APK para .zip e, em seguida, descompactando-o. -**Vulnerabilidades** identificadas a partir do **Manifest.xml** incluem: +**Vulnerabilidades** identificadas no **Manifest.xml** incluem: - **Aplicações Debugáveis**: Aplicações configuradas como debuggable (`debuggable="true"`) no arquivo _Manifest.xml_ representam um risco, pois permitem conexões que podem levar à exploração. Para uma melhor compreensão sobre como explorar aplicações debuggable, consulte um tutorial sobre como encontrar e explorar aplicações debuggable em um dispositivo. - **Configurações de Backup**: O atributo `android:allowBackup="false"` deve ser explicitamente definido para aplicações que lidam com informações sensíveis para evitar backups de dados não autorizados via adb, especialmente quando a depuração USB está habilitada. @@ -85,7 +85,7 @@ A **examinação dos arquivos _Manifest.xml_ e **_strings.xml_** de uma aplicaç - **Broadcast Receivers e Esquemas de URL**: Esses componentes podem ser aproveitados para exploração, com atenção especial a como os esquemas de URL são gerenciados para vulnerabilidades de entrada. - **Versões do SDK**: Os atributos `minSdkVersion`, `targetSDKVersion` e `maxSdkVersion` indicam as versões do Android suportadas, destacando a importância de não suportar versões do Android desatualizadas e vulneráveis por razões de segurança. -A partir do arquivo **strings.xml**, informações sensíveis como chaves de API, esquemas personalizados e outras notas de desenvolvedor podem ser descobertas, sublinhando a necessidade de uma revisão cuidadosa desses recursos. +Do arquivo **strings.xml**, informações sensíveis como chaves de API, esquemas personalizados e outras notas de desenvolvedor podem ser descobertas, sublinhando a necessidade de uma revisão cuidadosa desses recursos. ### Tapjacking @@ -121,7 +121,7 @@ No Android, arquivos **armazenados** no **armazenamento interno** são **projeta **Armazenamento Externo** -Ao lidar com arquivos no **armazenamento externo**, como Cartões SD, certas precauções devem ser tomadas: +Ao lidar com arquivos no **armazenamento externo**, como cartões SD, certas precauções devem ser tomadas: 1. **Acessibilidade**: - Arquivos no armazenamento externo são **globalmente legíveis e graváveis**. Isso significa que qualquer aplicação ou usuário pode acessar esses arquivos. @@ -131,7 +131,7 @@ Ao lidar com arquivos no **armazenamento externo**, como Cartões SD, certas pre 3. **Manipulação de Dados do Armazenamento Externo**: - Sempre **realize validação de entrada** nos dados recuperados do armazenamento externo. Isso é crucial porque os dados vêm de uma fonte não confiável. - Armazenar executáveis ou arquivos de classe no armazenamento externo para carregamento dinâmico é fortemente desencorajado. -- Se sua aplicação precisar recuperar arquivos executáveis do armazenamento externo, assegure-se de que esses arquivos sejam **assinados e verificados criptograficamente** antes de serem carregados dinamicamente. Este passo é vital para manter a integridade de segurança da sua aplicação. +- Se sua aplicação precisar recuperar arquivos executáveis do armazenamento externo, assegure-se de que esses arquivos sejam **assinados e verificados criptograficamente** antes de serem carregados dinamicamente. Essa etapa é vital para manter a integridade de segurança da sua aplicação. O armazenamento externo pode ser **acessado** em `/storage/emulated/0`, `/sdcard`, `/mnt/sdcard` @@ -154,7 +154,7 @@ sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); ``` Uma boa maneira de testar isso é tentar capturar o tráfego usando algum proxy como Burp sem autorizar o Burp CA dentro do dispositivo. Além disso, você pode gerar com o Burp um certificado para um hostname diferente e usá-lo. -### Quebra de Criptografia +### Criptografia Quebrada **Processos de Gerenciamento de Chaves Ruins** @@ -162,7 +162,7 @@ Alguns desenvolvedores salvam dados sensíveis no armazenamento local e os cript **Uso de Algoritmos Inseguros e/ou Obsoletos** -Os desenvolvedores não devem usar **algoritmos obsoletos** para realizar **verificações de autorização**, **armazenar** ou **enviar** dados. Alguns desses algoritmos são: RC4, MD4, MD5, SHA1... Se **hashes** forem usados para armazenar senhas, por exemplo, devem ser usados hashes resistentes a **brute-force** com sal. +Os desenvolvedores não devem usar **algoritmos obsoletos** para realizar **verificações de autorização**, **armazenar** ou **enviar** dados. Alguns desses algoritmos são: RC4, MD4, MD5, SHA1... Se **hashes** forem usados para armazenar senhas, por exemplo, devem ser usados hashes resistentes a força bruta com sal. ### Outras verificações @@ -192,7 +192,7 @@ Leia a página a seguir para aprender como acessar facilmente o código C# de ap De acordo com este [**post de blog**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/), superpacked é um algoritmo Meta que comprime o conteúdo de uma aplicação em um único arquivo. O blog fala sobre a possibilidade de criar um aplicativo que descompacte esse tipo de aplicativo... e uma maneira mais rápida que envolve **executar a aplicação e coletar os arquivos descompactados do sistema de arquivos.** -### Análise Estática Automatizada de Código +### Análise de Código Estática Automatizada A ferramenta [**mariana-trench**](https://github.com/facebook/mariana-trench) é capaz de encontrar **vulnerabilidades** ao **escanear** o **código** da aplicação. Esta ferramenta contém uma série de **fontes conhecidas** (que indicam ao ferramenta os **lugares** onde a **entrada** é **controlada pelo usuário**), **sinks** (que indicam ao ferramenta **lugares perigosos** onde a entrada maliciosa do usuário pode causar danos) e **regras**. Essas regras indicam a **combinação** de **fontes-sinks** que indica uma vulnerabilidade. @@ -272,7 +272,7 @@ Você precisa ativar as opções de **depuração** e será legal se você puder 4. Pressione **Número da versão** 7 vezes. 5. Volte e você encontrará as **Opções de desenvolvedor**. -> Uma vez que você tenha instalado a aplicação, a primeira coisa que você deve fazer é testá-la e investigar o que ela faz, como funciona e se familiarizar com ela.\ +> Uma vez que você tenha instalado a aplicação, a primeira coisa que deve fazer é testá-la e investigar o que ela faz, como funciona e se familiarizar com ela.\ > Sugiro que **realize esta análise dinâmica inicial usando a análise dinâmica do MobSF + pidcat**, para que possamos **aprender como a aplicação funciona** enquanto o MobSF **captura** muitos **dados interessantes** que você pode revisar mais tarde. ### Vazamento de Dados Não Intencionais @@ -287,7 +287,7 @@ Os desenvolvedores devem ter cuidado ao expor **informações de depuração** p **Cache de Buffer de Copiar/Colar** -O framework **baseado em clipboard** do Android permite funcionalidade de copiar e colar em aplicativos, mas apresenta um risco, pois **outros aplicativos** podem **acessar** o clipboard, potencialmente expondo dados sensíveis. É crucial **desabilitar funções de copiar/colar** para seções sensíveis de uma aplicação, como detalhes de cartão de crédito, para evitar vazamentos de dados. +O framework **baseado em clipboard** do Android permite a funcionalidade de copiar e colar em aplicativos, mas apresenta um risco, pois **outros aplicativos** podem **acessar** o clipboard, potencialmente expondo dados sensíveis. É crucial **desativar funções de copiar/colar** para seções sensíveis de uma aplicação, como detalhes de cartão de crédito, para evitar vazamentos de dados. **Logs de Crash** @@ -344,28 +344,28 @@ adb shell am start -n com.example.demo/com.example.test.MainActivity Se o tapjacking não for prevenido, você pode abusar da atividade exportada para fazer o **usuário realizar ações inesperadas**. Para mais informações sobre [**o que é Tapjacking siga o link**](#tapjacking). -### Explorando Content Providers - Acessando e manipulando informações sensíveis +### Explorando Provedores de Conteúdo - Acessando e manipulando informações sensíveis -[**Leia isso se você quiser relembrar o que é um Content Provider.**](android-applications-basics.md#content-provider)\ -Content providers são basicamente usados para **compartilhar dados**. Se um aplicativo tiver content providers disponíveis, você pode ser capaz de **extrair dados sensíveis** deles. Também é interessante testar possíveis **injeções SQL** e **Path Traversals**, pois podem ser vulneráveis. +[**Leia isso se você quiser relembrar o que é um Provedor de Conteúdo.**](android-applications-basics.md#content-provider)\ +Provedores de conteúdo são basicamente usados para **compartilhar dados**. Se um aplicativo tiver provedores de conteúdo disponíveis, você pode ser capaz de **extrair dados sensíveis** deles. Também é interessante testar possíveis **injeções SQL** e **Path Traversals**, pois podem ser vulneráveis. -[**Aprenda como explorar Content Providers com Drozer.**](drozer-tutorial/index.html#content-providers) +[**Aprenda como explorar Provedores de Conteúdo com Drozer.**](drozer-tutorial/index.html#content-providers) -### **Explorando Services** +### **Explorando Serviços** -[**Leia isso se você quiser relembrar o que é um Service.**](android-applications-basics.md#services)\ -Lembre-se de que as ações de um Service começam no método `onStartCommand`. +[**Leia isso se você quiser relembrar o que é um Serviço.**](android-applications-basics.md#services)\ +Lembre-se de que as ações de um Serviço começam no método `onStartCommand`. -Um service é basicamente algo que **pode receber dados**, **processá-los** e **retornar** (ou não) uma resposta. Então, se um aplicativo estiver exportando alguns serviços, você deve **verificar** o **código** para entender o que ele está fazendo e **testá-lo** **dinamicamente** para extrair informações confidenciais, contornar medidas de autenticação...\ -[**Aprenda como explorar Services com Drozer.**](drozer-tutorial/index.html#services) +Um serviço é basicamente algo que **pode receber dados**, **processá-los** e **retornar** (ou não) uma resposta. Então, se um aplicativo estiver exportando alguns serviços, você deve **verificar** o **código** para entender o que ele está fazendo e **testá-lo** **dinamicamente** para extrair informações confidenciais, contornar medidas de autenticação...\ +[**Aprenda como explorar Serviços com Drozer.**](drozer-tutorial/index.html#services) -### **Explorando Broadcast Receivers** +### **Explorando Receptores de Broadcast** -[**Leia isso se você quiser relembrar o que é um Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\ -Lembre-se de que as ações de um Broadcast Receiver começam no método `onReceive`. +[**Leia isso se você quiser relembrar o que é um Receptor de Broadcast.**](android-applications-basics.md#broadcast-receivers)\ +Lembre-se de que as ações de um Receptor de Broadcast começam no método `onReceive`. -Um broadcast receiver estará aguardando um tipo de mensagem. Dependendo de como o receiver lida com a mensagem, ele pode ser vulnerável.\ -[**Aprenda como explorar Broadcast Receivers com Drozer.**](#exploiting-broadcast-receivers) +Um receptor de broadcast estará aguardando um tipo de mensagem. Dependendo de como o receptor lida com a mensagem, ele pode ser vulnerável.\ +[**Aprenda como explorar Receptores de Broadcast com Drozer.**](#exploiting-broadcast-receivers) ### **Explorando Schemes / Deep links** @@ -374,7 +374,7 @@ Você pode **abrir** um **scheme** declarado usando **adb** ou um **navegador**: ```bash adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name] ``` -_Observe que você pode **omitir o nome do pacote** e o celular chamará automaticamente o aplicativo que deve abrir esse link._ +_Observe que você pode **omitir o nome do pacote** e o dispositivo móvel chamará automaticamente o aplicativo que deve abrir esse link._ ```html Click me @@ -402,7 +402,7 @@ Um [relatório de bug bounty interessante](https://hackerone.com/reports/855618) ### Inspeção e Falhas de Verificação da Camada de Transporte -- **Os certificados nem sempre são inspecionados corretamente** por aplicativos Android. É comum que esses aplicativos ignorem avisos e aceitem certificados autoassinados ou, em alguns casos, revertam para o uso de conexões HTTP. +- **Os certificados nem sempre são inspecionados corretamente** por aplicativos Android. É comum que esses aplicativos ignorem avisos e aceitem certificados autoassinados ou, em alguns casos, revertam para usar conexões HTTP. - **As negociações durante o handshake SSL/TLS às vezes são fracas**, empregando suítes de cifra inseguras. Essa vulnerabilidade torna a conexão suscetível a ataques man-in-the-middle (MITM), permitindo que atacantes decriptografem os dados. - **Vazamento de informações privadas** é um risco quando aplicativos se autenticam usando canais seguros, mas depois se comunicam por canais não seguros para outras transações. Essa abordagem não protege dados sensíveis, como cookies de sessão ou detalhes do usuário, de interceptação por entidades maliciosas. @@ -418,15 +418,15 @@ SSL Pinning é uma medida de segurança onde o aplicativo verifica o certificado Para inspecionar o tráfego HTTP, é necessário **instalar o certificado da ferramenta proxy** (por exemplo, Burp). Sem instalar esse certificado, o tráfego criptografado pode não ser visível através do proxy. Para um guia sobre como instalar um certificado CA personalizado, [**clique aqui**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). -Aplicativos que visam **API Level 24 e acima** requerem modificações na Configuração de Segurança da Rede para aceitar o certificado CA do proxy. Este passo é crítico para inspecionar tráfego criptografado. Para instruções sobre como modificar a Configuração de Segurança da Rede, [**consulte este tutorial**](make-apk-accept-ca-certificate.md). +Aplicativos que visam **API Level 24 e acima** requerem modificações na Configuração de Segurança da Rede para aceitar o certificado CA do proxy. Essa etapa é crítica para inspecionar tráfego criptografado. Para instruções sobre como modificar a Configuração de Segurança da Rede, [**consulte este tutorial**](make-apk-accept-ca-certificate.md). Se **Flutter** estiver sendo usado, você precisa seguir as instruções nesta [**página**](flutter.md). Isso ocorre porque, apenas adicionar o certificado ao armazenamento não funcionará, pois o Flutter tem sua própria lista de CAs válidas. -#### Contornando o SSL Pinning +#### Bypass de SSL Pinning Quando o SSL Pinning é implementado, contorná-lo se torna necessário para inspecionar o tráfego HTTPS. Vários métodos estão disponíveis para esse propósito: -- Modificar automaticamente o **apk** para **contornar** o SSL Pinning com [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). O melhor pró dessa opção é que você não precisará de root para contornar o SSL Pinning, mas precisará excluir o aplicativo e reinstalar o novo, e isso nem sempre funcionará. +- Modifique automaticamente o **apk** para **contornar** SSLPinning com [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). O melhor pró dessa opção é que você não precisará de root para contornar o SSL Pinning, mas precisará excluir o aplicativo e reinstalar o novo, e isso nem sempre funcionará. - Você pode usar **Frida** (discutido abaixo) para contornar essa proteção. Aqui está um guia para usar Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/) - Você também pode tentar **contornar automaticamente o SSL Pinning** usando [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"` - Você também pode tentar **contornar automaticamente o SSL Pinning** usando **análise dinâmica do MobSF** (explicado abaixo) @@ -448,11 +448,17 @@ Se você quiser fazer pentesting em aplicativos Android, precisa saber como usar - Você pode encontrar alguns scripts Frida incríveis aqui: [**https://codeshare.frida.re/**](https://codeshare.frida.re) - Tente contornar mecanismos de anti-debugging / anti-frida carregando o Frida como indicado em [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (ferramenta [linjector](https://github.com/erfur/linjector-rs)) +#### Fluxo de trabalho de contorno de anti-instrumentação e SSL pinning + +{{#ref}} +android-anti-instrumentation-and-ssl-pinning-bypass.md +{{#endref}} + ### **Dump de Memória - Fridump** Verifique se o aplicativo está armazenando informações sensíveis na memória que não deveria estar armazenando, como senhas ou mnemônicos. -Usando [**Fridump3**](https://github.com/rootbsd/fridump3), você pode despejar a memória do aplicativo com: +Usando [**Fridump3**](https://github.com/rootbsd/fridump3), você pode despejar a memória do app com: ```bash # With PID python3 fridump3.py -u @@ -489,7 +495,7 @@ No entanto, se esse instantâneo contiver **informações sensíveis**, alguém Os instantâneos geralmente são armazenados em: **`/data/system_ce/0/snapshots`** -O Android fornece uma maneira de **prevenir a captura de tela definindo o parâmetro de layout FLAG_SECURE**. Ao usar essa flag, o conteúdo da janela é tratado como seguro, impedindo que apareça em capturas de tela ou seja visualizado em displays não seguros. +O Android fornece uma maneira de **prevenir a captura de tela definindo o parâmetro de layout FLAG_SECURE**. Ao usar essa flag, o conteúdo da janela é tratado como seguro, impedindo que apareça em capturas de tela ou que seja visualizado em displays não seguros. ```bash getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE); ``` @@ -553,7 +559,7 @@ A partir das versões **Android > 5**, ele **iniciará automaticamente o Frida** **Frida** -Por padrão, ele também usará alguns Scripts Frida para **contornar o SSL pinning**, **detecção de root** e **detecção de depurador** e para **monitorar APIs interessantes**.\ +Por padrão, ele também usará alguns Scripts Frida para **contornar a verificação de SSL**, **detecção de root** e **detecção de depurador** e para **monitorar APIs interessantes**.\ O MobSF também pode **invocar atividades exportadas**, capturar **capturas de tela** delas e **salvá-las** para o relatório. Para **iniciar** o teste dinâmico, pressione o botão verde: "**Start Instrumentation**". Pressione "**Frida Live Logs**" para ver os logs gerados pelos scripts Frida e "**Live API Monitor**" para ver todas as invocações para métodos conectados, argumentos passados e valores retornados (isso aparecerá após pressionar "Start Instrumentation").\ @@ -588,7 +594,7 @@ receivers Quando o tráfego http é capturado, você pode ver uma visão feia do tráfego capturado no "**Tráfego HTTP(S)**" na parte inferior ou uma visão mais agradável no botão verde "**Iniciar HTTPTools**". A partir da segunda opção, você pode **enviar** as **requisições capturadas** para **proxies** como Burp ou Owasp ZAP.\ Para fazer isso, _ligue o Burp -->_ _desative o Intercept --> no MobSB HTTPTools selecione a requisição_ --> pressione "**Enviar para Fuzzer**" --> _selecione o endereço do proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)). -Uma vez que você termine a análise dinâmica com MobSF, você pode pressionar em "**Iniciar Web API Fuzzer**" para **fuzz http requests** e procurar vulnerabilidades. +Uma vez que você termine a análise dinâmica com MobSF, você pode pressionar em "**Iniciar Web API Fuzzer**" para **fuzz http requests** e procurar por vulnerabilidades. > [!TIP] > Após realizar uma análise dinâmica com MobSF, as configurações do proxy podem estar mal configuradas e você não conseguirá corrigi-las pela GUI. Você pode corrigir as configurações do proxy fazendo: @@ -644,7 +650,7 @@ super-analyzer {apk_file} StaCoAn é uma ferramenta **multiplataforma** que ajuda desenvolvedores, caçadores de bugs e hackers éticos a realizar [análise de código estático](https://en.wikipedia.org/wiki/Static_program_analysis) em aplicativos móveis. -O conceito é que você arrasta e solta seu arquivo de aplicativo móvel (um arquivo .apk ou .ipa) na aplicação StaCoAn e ela gerará um relatório visual e portátil para você. Você pode ajustar as configurações e listas de palavras para obter uma experiência personalizada. +O conceito é que você arraste e solte seu arquivo de aplicativo móvel (um arquivo .apk ou .ipa) na aplicação StaCoAn e ela gerará um relatório visual e portátil para você. Você pode ajustar as configurações e listas de palavras para obter uma experiência personalizada. Baixe a [última versão](https://github.com/vincentcox/StaCoAn/releases): ``` @@ -652,7 +658,7 @@ Baixe a [última versão](https://github.com/vincentcox/StaCoAn/releases): ``` ### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework) -AndroBugs Framework é um sistema de análise de vulnerabilidades Android que ajuda desenvolvedores ou hackers a encontrar potenciais vulnerabilidades de segurança em aplicações Android.\ +O AndroBugs Framework é um sistema de análise de vulnerabilidades para Android que ajuda desenvolvedores ou hackers a encontrar potenciais vulnerabilidades de segurança em aplicações Android.\ [Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases) ``` python androbugs.py -f [APK file] @@ -695,7 +701,7 @@ Observe que dependendo do serviço e configuração que você usa para ofuscar o Do [Wikipedia](): **ProGuard** é uma ferramenta de linha de comando de código aberto que reduz, otimiza e ofusca código Java. É capaz de otimizar bytecode, bem como detectar e remover instruções não utilizadas. ProGuard é software livre e é distribuído sob a Licença Pública Geral GNU, versão 2. -ProGuard é distribuído como parte do SDK do Android e é executado ao construir o aplicativo em modo de lançamento. +ProGuard é distribuído como parte do SDK do Android e é executado ao construir a aplicação em modo de lançamento. ### [DexGuard](https://www.guardsquare.com/dexguard) @@ -735,7 +741,7 @@ APKiD fornece informações sobre **como um APK foi feito**. Ele identifica muit ### [Androl4b](https://github.com/sh4hin/Androl4b) -AndroL4b é uma máquina virtual de segurança Android baseada em ubuntu-mate que inclui a coleção dos últimos frameworks, tutoriais e labs de diferentes especialistas e pesquisadores de segurança para engenharia reversa e análise de malware. +AndroL4b é uma máquina virtual de segurança Android baseada em ubuntu-mate que inclui a coleção dos últimos frameworks, tutoriais e labs de diferentes especialistas em segurança e pesquisadores para engenharia reversa e análise de malware. ## Referências diff --git a/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md b/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md new file mode 100644 index 000000000..95e721e2d --- /dev/null +++ b/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md @@ -0,0 +1,203 @@ +# Android Anti-Instrumentation & SSL Pinning Bypass (Frida/Objection) + +{{#include ../../banners/hacktricks-training.md}} + +Esta página fornece um fluxo de trabalho prático para recuperar a análise dinâmica contra aplicativos Android que detectam/bloqueiam a instrumentação ou impõem o pinning TLS. Foca em triagem rápida, detecções comuns e hooks/táticas copiáveis para contorná-las sem recompilar quando possível. + +## Superfície de Detecção (o que os aplicativos verificam) + +- Verificações de root: binário su, caminhos do Magisk, valores getprop, pacotes de root comuns +- Verificações de Frida/debugger (Java): Debug.isDebuggerConnected(), ActivityManager.getRunningAppProcesses(), getRunningServices(), escaneando /proc, classpath, libs carregadas +- Anti-debug nativo: ptrace(), syscalls, anti-attach, breakpoints, inline hooks +- Verificações de early init: Application.onCreate() ou hooks de início de processo que travam se a instrumentação estiver presente +- Pinning TLS: TrustManager/HostnameVerifier personalizados, OkHttp CertificatePinner, pinning Conscrypt, pins nativos + +## Passo 1 — Vitória rápida: ocultar root com Magisk DenyList + +- Ative o Zygisk no Magisk +- Ative o DenyList, adicione o pacote alvo +- Reinicie e reteste + +Muitos aplicativos apenas procuram indicadores óbvios (caminhos su/Magisk/getprop). O DenyList frequentemente neutraliza verificações ingênuas. + +Referências: +- Magisk (Zygisk & DenyList): https://github.com/topjohnwu/Magisk + +## Passo 2 — Testes de Frida Codeshare em 30 segundos + +Tente scripts comuns antes de se aprofundar: + +- anti-root-bypass.js +- anti-frida-detection.js +- hide_frida_gum.js + +Exemplo: +```bash +frida -U -f com.example.app -l anti-frida-detection.js +``` +Esses normalmente interrompem verificações de root/debug em Java, varreduras de processo/serviço e ptrace() nativo. Útil em aplicativos levemente protegidos; alvos endurecidos podem precisar de ganchos personalizados. + +- Codeshare: https://codeshare.frida.re/ + +## Passo 3 — Bypass de detectores de tempo de inicialização anexando-se tardiamente + +Muitas detecções só são executadas durante a criação do processo/onCreate(). A injeção no tempo de criação (-f) ou gadgets são detectados; anexar-se após o carregamento da UI pode passar despercebido. +```bash +# Launch the app normally (launcher/adb), wait for UI, then attach +frida -U -n com.example.app +# Or with Objection to attach to running process +aobjection --gadget com.example.app explore # if using gadget +``` +Se isso funcionar, mantenha a sessão estável e prossiga para mapeamento e verificações de stub. + +## Passo 4 — Mapear a lógica de detecção via Jadx e busca de strings + +Palavras-chave de triagem estática no Jadx: +- "frida", "gum", "root", "magisk", "ptrace", "su", "getprop", "debugger" + +Padrões típicos de Java: +```java +public boolean isFridaDetected() { +return getRunningServices().contains("frida"); +} +``` +APIs comuns para revisar/enganchar: +- android.os.Debug.isDebuggerConnected +- android.app.ActivityManager.getRunningAppProcesses / getRunningServices +- java.lang.System.loadLibrary / System.load (ponte nativa) +- java.lang.Runtime.exec / ProcessBuilder (comandos de sondagem) +- android.os.SystemProperties.get (heurísticas de root/emulador) + +## Passo 5 — Stubbing em tempo de execução com Frida (Java) + +Substitua guardas personalizados para retornar valores seguros sem reempacotar: +```js +Java.perform(() => { +const Checks = Java.use('com.example.security.Checks'); +Checks.isFridaDetected.implementation = function () { return false; }; + +// Neutralize debugger checks +const Debug = Java.use('android.os.Debug'); +Debug.isDebuggerConnected.implementation = function () { return false; }; + +// Example: kill ActivityManager scans +const AM = Java.use('android.app.ActivityManager'); +AM.getRunningAppProcesses.implementation = function () { return java.util.Collections.emptyList(); }; +}); +``` +Triagem de falhas iniciais? Despeje classes pouco antes de morrer para identificar namespaces de detecção prováveis: +```js +Java.perform(() => { +Java.enumerateLoadedClasses({ +onMatch: n => console.log(n), +onComplete: () => console.log('Done') +}); +}); +``` +Registre e neutralize métodos suspeitos para confirmar o fluxo de execução: +```js +Java.perform(() => { +const Det = Java.use('com.example.security.DetectionManager'); +Det.checkFrida.implementation = function () { +console.log('checkFrida() called'); +return false; +}; +}); +``` +## Passo 6 — Siga a trilha JNI/nativa quando os hooks Java falharem + +Rastreie os pontos de entrada JNI para localizar carregadores nativos e inicialização de detecção: +```bash +frida-trace -n com.example.app -i "JNI_OnLoad" +``` +Triagem nativa rápida de arquivos .so empacotados: +```bash +# List exported symbols & JNI +nm -D libfoo.so | head +objdump -T libfoo.so | grep Java_ +strings -n 6 libfoo.so | egrep -i 'frida|ptrace|gum|magisk|su|root' +``` +Reversão interativa/nativa: +- Ghidra: https://ghidra-sre.org/ +- r2frida: https://github.com/nowsecure/r2frida + +Exemplo: neutrar ptrace para derrotar um simples anti‑debug em libc: +```js +const ptrace = Module.findExportByName(null, 'ptrace'); +if (ptrace) { +Interceptor.replace(ptrace, new NativeCallback(function () { +return -1; // pretend failure +}, 'int', ['int', 'int', 'pointer', 'pointer'])); +} +``` +Veja também: {{#ref}} +reversing-native-libraries.md +{{#endref}} + +## Etapa 7 — Patching do Objection (gadget embutido / noções básicas de strip) + +Quando você preferir repackaging a hooks de tempo de execução, tente: +```bash +objection patchapk --source app.apk +``` +Notas: +- Requer apktool; assegure-se de ter uma versão atual do guia oficial para evitar problemas de construção: https://apktool.org/docs/install +- A injeção de gadgets permite instrumentação sem root, mas ainda pode ser detectada por verificações mais rigorosas no tempo de inicialização. + +Referências: +- Objection: https://github.com/sensepost/objection + +## Passo 8 — Fallback: Corrigir o pinning TLS para visibilidade de rede + +Se a instrumentação estiver bloqueada, você ainda pode inspecionar o tráfego removendo o pinning estaticamente: +```bash +apk-mitm app.apk +# Then install the patched APK and proxy via Burp/mitmproxy +``` +- Ferramenta: https://github.com/shroudedcode/apk-mitm +- Para truques de configuração de rede CA‑trust (e confiança de CA do usuário no Android 7+), veja: +{{#ref}} +make-apk-accept-ca-certificate.md +{{#endref}} +{{#ref}} +install-burp-certificate.md +{{#endref}} + +## Folha de dicas de comandos úteis +```bash +# List processes and attach +frida-ps -Uai +frida -U -n com.example.app + +# Spawn with a script (may trigger detectors) +frida -U -f com.example.app -l anti-frida-detection.js + +# Trace native init +frida-trace -n com.example.app -i "JNI_OnLoad" + +# Objection runtime +objection --gadget com.example.app explore + +# Static TLS pinning removal +apk-mitm app.apk +``` +## Dicas e advertências + +- Prefira anexar tarde em vez de criar processos quando os aplicativos travam na inicialização +- Algumas detecções são reexecutadas em fluxos críticos (por exemplo, pagamento, autenticação) — mantenha os hooks ativos durante a navegação +- Misture estático e dinâmico: procure strings no Jadx para selecionar classes; depois, conecte métodos para verificar em tempo de execução +- Aplicativos endurecidos podem usar empacotadores e pinagem TLS nativa — espere reverter código nativo + +## Referências + +- [Reversing Android Apps: Bypassing Detection Like a Pro](https://www.kayssel.com/newsletter/issue-12/) +- [Frida Codeshare](https://codeshare.frida.re/) +- [Objection](https://github.com/sensepost/objection) +- [apk-mitm](https://github.com/shroudedcode/apk-mitm) +- [Jadx](https://github.com/skylot/jadx) +- [Ghidra](https://ghidra-sre.org/) +- [r2frida](https://github.com/nowsecure/r2frida) +- [Apktool install guide](https://apktool.org/docs/install) +- [Magisk](https://github.com/topjohnwu/Magisk) + +{{#include ../../banners/hacktricks-training.md}}