From 60c15441f6f49ec9c87abeddad8e747da7557d32 Mon Sep 17 00:00:00 2001 From: Translator Date: Wed, 3 Sep 2025 12:21:32 +0000 Subject: [PATCH] Translated ['', 'src/mobile-pentesting/android-app-pentesting/README.md' --- .../android-app-pentesting/README.md | 621 ++++++++++-------- 1 file changed, 338 insertions(+), 283 deletions(-) diff --git a/src/mobile-pentesting/android-app-pentesting/README.md b/src/mobile-pentesting/android-app-pentesting/README.md index 20ce2818d..3606b6d1b 100644 --- a/src/mobile-pentesting/android-app-pentesting/README.md +++ b/src/mobile-pentesting/android-app-pentesting/README.md @@ -1,10 +1,11 @@ -# Teste de Penetração em Aplicações Android +# Aplicações Android Pentesting {{#include ../../banners/hacktricks-training.md}} -## Fundamentos de Aplicações Android +## Fundamentos das Aplicações Android + +É altamente recomendado começar lendo esta página para conhecer as **partes mais importantes relacionadas à segurança do Android e os componentes mais perigosos em uma aplicação Android**: -É altamente recomendável começar a ler esta página para conhecer as **partes mais importantes relacionadas à segurança do Android e os componentes mais perigosos em uma aplicação Android**: {{#ref}} android-applications-basics.md @@ -12,22 +13,22 @@ android-applications-basics.md ## ADB (Android Debug Bridge) -Esta é a principal ferramenta que você precisa para se conectar a um dispositivo Android (emulado ou físico).\ -**ADB** permite controlar dispositivos tanto via **USB** quanto **Rede** a partir de um computador. Esta utilidade possibilita a **cópia** de arquivos em ambas as direções, **instalação** e **desinstalação** de aplicativos, **execução** de comandos de shell, **backup** de dados, **leitura** de logs, entre outras funções. +Esta é a ferramenta principal que você precisa para conectar-se a um dispositivo Android (emulado ou físico).\ +**ADB** permite controlar dispositivos via **USB** ou **rede** a partir de um computador. Esta utilidade possibilita a **cópia** de arquivos em ambas as direções, a **instalação** e **desinstalação** de apps, a **execução** de comandos shell, o **backup** de dados, a **leitura** de logs, entre outras funções. -Dê uma olhada na lista de [**Comandos ADB**](adb-commands.md) para aprender como usar o adb. +Confira a seguinte lista de [**ADB Commands**](adb-commands.md) para aprender a usar o adb. ## Smali -Às vezes, é interessante **modificar o código da aplicação** para acessar **informações ocultas** (talvez senhas ou flags bem ofuscadas). Então, pode ser interessante descompilar o apk, modificar o código e recompilá-lo.\ -[**Neste tutorial** você pode **aprender como descompilar um APK, modificar o código Smali e recompilar o APK** com a nova funcionalidade](smali-changes.md). Isso pode ser muito útil como uma **alternativa para vários testes durante a análise dinâmica** que serão apresentados. Então, **mantenha sempre em mente essa possibilidade**. +Às vezes é interessante **modificar o código da aplicação** para acessar **informações ocultas** (talvez senhas bem ofuscadas ou flags). Então, pode ser interessante decompilar o apk, modificar o código e recompilá-lo.\ +[**In this tutorial** you can **learn how to decompile and APK, modify Smali code and recompile the APK** with the new functionality](smali-changes.md). Isto pode ser muito útil como uma **alternativa para vários testes durante a dynamic analysis** que serão apresentados. Então, **mantenha sempre em mente essa possibilidade**. ## Outros truques interessantes -- [Falsificando sua localização na Play Store](spoofing-your-location-in-play-store.md) -- [API Privilegiada Shizuku (acesso privilegiado não-root baseado em ADB)](shizuku-privileged-api.md) -- [Explorando Mecanismos Inseguros de Atualização In-App](insecure-in-app-update-rce.md) -- [Abusando de Serviços de Acessibilidade (Android RAT)](accessibility-services-abuse.md) +- [Spoofing your location in Play Store](spoofing-your-location-in-play-store.md) +- [Shizuku Privileged API (ADB-based non-root privileged access)](shizuku-privileged-api.md) +- [Exploiting Insecure In-App Update Mechanisms](insecure-in-app-update-rce.md) +- [Abusing Accessibility Services (Android RAT)](accessibility-services-abuse.md) - **Baixar APKs**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd) - Extrair APK do dispositivo: ```bash @@ -39,7 +40,7 @@ package:/data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk adb pull /data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk ``` -- Mescle todos os splits e apks base com [APKEditor](https://github.com/REAndroid/APKEditor): +- Mescle todos os splits e os apks base com [APKEditor](https://github.com/REAndroid/APKEditor): ```bash mkdir splits adb shell pm path com.android.insecurebankv2 | cut -d ':' -f 2 | xargs -n1 -i adb pull {} splits @@ -48,7 +49,7 @@ java -jar ../APKEditor.jar m -i splits/ -o merged.apk # after merging, you will need to align and sign the apk, personally, I like to use the uberapksigner java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed ``` -## Estudos de Caso & Vulnerabilidades +## Estudos de Caso e Vulnerabilidades {{#ref}} @@ -62,121 +63,121 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed ## Análise Estática -Primeiramente, para analisar um APK você deve **dar uma olhada no código Java** usando um decompilador.\ -Por favor, [**leia aqui para encontrar informações sobre diferentes decompiladores disponíveis**](apk-decompilers.md). +Primeiro de tudo, para analisar um APK você deve **dar uma olhada no código Java** usando um decompilador.\ +Por favor, [**leia aqui para encontrar informação sobre diferentes decompiladores disponíveis**](apk-decompilers.md). ### Procurando informações interessantes -Apenas dando uma olhada nas **strings** do APK você pode procurar por **senhas**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **chaves** **api**, **criptografia**, **bluetooth uuids**, **tokens** e qualquer coisa interessante... procure até por **backdoors** de execução de código ou backdoors de autenticação (credenciais de admin hardcoded para o app). +Apenas olhando as **strings** do APK você pode procurar por **senhas**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** e qualquer coisa interessante... procure até por **backdoors** de execução de código ou backdoors de autenticação (credenciais admin hardcoded no app). **Firebase** -Preste atenção especial às **URLs do firebase** e verifique se está mal configurado. [Mais informações sobre o que é o Firebase e como explorá-lo aqui.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) +Preste atenção especial às **Firebase URLs** e verifique se estão mal configuradas. [Mais informações sobre o que é Firebase e como explorá-lo aqui.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) -### Compreensão básica da aplicação - Manifest.xml, strings.xml +### Entendimento básico da aplicação - Manifest.xml, strings.xml -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. +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 o arquivo APK para .zip e descompactando-o. -**Vulnerabilidades** identificadas a partir do **Manifest.xml** incluem: +As **vulnerabilidades** identificadas a partir do **Manifest.xml** incluem: -- **Aplicações Debugáveis**: Aplicações definidas 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 debuggables, consulte um tutorial sobre como encontrar e explorar aplicações debuggables 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. -- **Segurança de Rede**: Configurações de segurança de rede personalizadas (`android:networkSecurityConfig="@xml/network_security_config"`) em _res/xml/_ podem especificar detalhes de segurança como pins de certificado e configurações de tráfego HTTP. Um exemplo é permitir tráfego HTTP para domínios específicos. -- **Atividades e Serviços Exportados**: Identificar atividades e serviços exportados no manifesto pode destacar componentes que podem ser mal utilizados. Uma análise adicional durante testes dinâmicos pode revelar como explorar esses componentes. -- **Content Providers e FileProviders**: Content providers expostos podem permitir acesso ou modificação não autorizada de dados. A configuração de FileProviders também deve ser analisada. -- **Broadcast Receivers e URL Schemes**: 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. +- **Debuggable Applications**: Aplicações definidas como debuggable (`debuggable="true"`) no arquivo _Manifest.xml_ apresentam risco, pois permitem conexões que podem levar à exploração. Para entender melhor como explorar aplicações debuggable, consulte um tutorial sobre encontrar e explorar aplicações debuggable em um dispositivo. +- **Backup Settings**: O atributo `android:allowBackup="false"` deve ser explicitamente definido para aplicações que lidam com informações sensíveis para evitar backups não autorizados via adb, especialmente quando usb debugging está habilitado. +- **Network Security**: Configurações customizadas de network security (`android:networkSecurityConfig="@xml/network_security_config"`) em _res/xml/_ podem especificar detalhes de segurança como certificate pins e configurações de tráfego HTTP. Um exemplo é permitir tráfego HTTP para domínios específicos. +- **Exported Activities and Services**: Identificar activities e services exportados no manifest pode evidenciar componentes que podem ser mal utilizados. Análises adicionais durante testes dinâmicos podem revelar como explorar esses componentes. +- **Content Providers and FileProviders**: Content providers expostos podem permitir acesso ou modificação não autorizada de dados. A configuração de FileProviders também deve ser cuidadosamente verificada. +- **Broadcast Receivers and URL Schemes**: Esses componentes podem ser aproveitados para exploração, com atenção particular à forma como os URL schemes são gerenciados quanto a vulnerabilidades de input. +- **SDK Versions**: Os atributos `minSdkVersion`, `targetSDKVersion` e `maxSdkVersion` indicam as versões do Android suportadas, ressaltando a importância de não suportar versões antigas e vulneráveis do Android 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**, podem ser descobertas informações sensíveis como API keys, custom schemas e outras notas de desenvolvedor, reforçando a necessidade de revisão cuidadosa desses recursos. ### Tapjacking -**Tapjacking** é um ataque onde uma **aplicação maliciosa** é lançada e **se posiciona em cima de uma aplicação vítima**. Uma vez que obscurece visivelmente o app vítima, sua interface de usuário é projetada de tal forma a enganar o usuário a interagir com ela, enquanto passa a interação para o app vítima.\ -Na prática, isso **cega o usuário para saber que ele está realmente realizando ações no app vítima**. +**Tapjacking** é um ataque onde uma **aplicação maliciosa** é lançada e **se posiciona por cima de uma aplicação vítima**. Uma vez que obscurece visivelmente o app vítima, sua interface é projetada de forma a enganar o usuário para interagir com ela, enquanto está repassando a interação para o app vítima.\ +Na prática, isso **cega o usuário quanto ao fato de estar, na verdade, executando ações no app vítima**. -Encontre mais informações em: +Encontre mais informação em: {{#ref}} tapjacking.md {{#endref}} -### Sequestro de Tarefa +### Task Hijacking -Uma **atividade** com o **`launchMode`** definido como **`singleTask` sem qualquer `taskAffinity`** definido é vulnerável ao sequestro de tarefa. Isso significa que uma **aplicação** pode ser instalada e, se lançada antes da aplicação real, pode **sequestrar a tarefa da aplicação real** (portanto, o usuário estará interagindo com a **aplicação maliciosa pensando que está usando a real**). +Uma **activity** com o **`launchMode`** definido como **`singleTask` sem qualquer `taskAffinity`** definida é vulnerável a Task Hijacking. Isso significa que uma **aplicação** pode ser instalada e, se iniciada antes da aplicação real, ela pode **hijackar a task da aplicação real** (fazendo com que o usuário interaja com a **aplicação maliciosa achando que está usando a aplicação legítima**). -Mais informações em: +Mais info em: {{#ref}} android-task-hijacking.md {{#endref}} -### Armazenamento de dados inseguros +### Armazenamento de dados inseguro -**Armazenamento Interno** +**Internal Storage** -No Android, arquivos **armazenados** no **armazenamento interno** são **projetados** para serem **acessíveis** exclusivamente pela **aplicação** que os **criou**. Essa medida de segurança é **imposta** pelo sistema operacional Android e geralmente é adequada para as necessidades de segurança da maioria das aplicações. No entanto, os desenvolvedores às vezes utilizam modos como `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` para **permitir** que arquivos sejam **compartilhados** entre diferentes aplicações. No entanto, esses modos **não restringem o acesso** a esses arquivos por outras aplicações, incluindo aquelas potencialmente maliciosas. +No Android, arquivos **armazenados** no **internal** storage são **projetados** para serem **acessíveis** exclusivamente pela **app** que os **criou**. Essa medida de segurança é **aplicada** pelo sistema operacional Android e é geralmente suficiente para a maioria das aplicações. No entanto, desenvolvedores às vezes utilizam modos como `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` para **permitir** que arquivos sejam **compartilhados** entre diferentes aplicações. Esses modos, entretanto, **não restringem o acesso** a esses arquivos por outras aplicações, incluindo potencialmente maliciosas. 1. **Análise Estática:** -- **Assegure-se** de que o uso de `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` seja **cuidadosamente analisado**. Esses modos **podem potencialmente expor** arquivos a **acessos não intencionais ou não autorizados**. +- **Assegure-se** de que o uso de `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` seja **cuidadosamente revisado**. Esses modos **podem expor** arquivos a **acesso não intencional ou não autorizado**. 2. **Análise Dinâmica:** -- **Verifique** as **permissões** definidas em arquivos criados pela aplicação. Especificamente, **verifique** se algum arquivo está **definido para ser legível ou gravável globalmente**. Isso pode representar um risco significativo à segurança, pois permitiria que **qualquer aplicação** instalada no dispositivo, independentemente de sua origem ou intenção, **lesse ou modificasse** esses arquivos. +- **Verifique** as **permissões** definidas nos arquivos criados pelo app. Especificamente, **confirme** se algum arquivo está **configurado para ser legível ou gravável mundialmente**. Isso pode representar um risco significativo de segurança, pois permitiria que **qualquer aplicação** instalada no dispositivo, independentemente de sua origem ou intenção, **leia ou modifique** esses arquivos. -**Armazenamento Externo** +**External Storage** -Ao lidar com arquivos no **armazenamento externo**, como cartões SD, certas precauções devem ser tomadas: +Ao lidar com arquivos em **external storage**, como SD Cards, 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. +- Arquivos no external storage são **globalmente legíveis e graváveis**. Isso significa que qualquer aplicação ou usuário pode acessar esses arquivos. 2. **Preocupações de Segurança**: -- Dada a facilidade de acesso, é aconselhável **não armazenar informações sensíveis** no armazenamento externo. -- O armazenamento externo pode ser removido ou acessado por qualquer aplicação, tornando-o menos seguro. -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. +- Dada a facilidade de acesso, é recomendado **não armazenar informações sensíveis** no external storage. +- O external storage pode ser removido ou acessado por qualquer aplicação, tornando-o menos seguro. +3. **Tratamento de Dados vindos do External Storage**: +- Sempre **execute validação de input** nos dados recuperados do external storage. Isso é crucial porque os dados vêm de uma fonte não confiável. +- Armazenar executáveis ou arquivos de classe no external storage para carregamento dinâmico é fortemente desaconselhado. +- Se sua aplicação precisa recuperar arquivos executáveis do external storage, garanta que esses arquivos sejam **assinados e verificados criptograficamente** antes de serem carregados dinamicamente. Esse passo é vital para manter a integridade de segurança da aplicação. -O armazenamento externo pode ser **acessado** em `/storage/emulated/0`, `/sdcard`, `/mnt/sdcard` +External storage pode ser **acessado** em `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard` > [!TIP] -> A partir do Android 4.4 (**API 17**), o cartão SD possui uma estrutura de diretórios que **limita o acesso de um app ao diretório que é especificamente para aquele app**. Isso impede que aplicações maliciosas ganhem acesso de leitura ou gravação aos arquivos de outro app. +> A partir do Android 4.4 (**API 17**), o SD card possui uma estrutura de diretórios que **limita o acesso de um app ao diretório que é especificamente para aquele app**. Isso impede que aplicações maliciosas ganhem acesso de leitura ou escrita aos arquivos de outro app. -**Dados sensíveis armazenados em texto claro** +**Dados sensíveis armazenados em texto simples** -- **Preferências compartilhadas**: O Android permite que cada aplicação salve facilmente arquivos xml no caminho `/data/data//shared_prefs/` e às vezes é possível encontrar informações sensíveis em texto claro nessa pasta. -- **Bancos de dados**: O Android permite que cada aplicação salve facilmente bancos de dados sqlite no caminho `/data/data//databases/` e às vezes é possível encontrar informações sensíveis em texto claro nessa pasta. +- **Shared preferences**: O Android permite que cada aplicação salve facilmente arquivos xml no caminho `/data/data//shared_prefs/` e às vezes é possível encontrar informações sensíveis em clear-text nessa pasta. +- **Databases**: O Android permite que cada aplicação salve facilmente bancos sqlite no caminho `/data/data//databases/` e às vezes é possível encontrar informações sensíveis em clear-text nessa pasta. -### TLS Quebrado +### Broken TLS -**Aceitar Todos os Certificados** +**Accept All Certificates** -Por algum motivo, às vezes os desenvolvedores aceitam todos os certificados, mesmo que, por exemplo, o nome do host não corresponda a linhas de código como a seguinte: +Por alguma razão, às vezes desenvolvedores aceitam todos os certificados mesmo se, por exemplo, o hostname não corresponder, com linhas de código como a seguinte: ```java SSLSocketFactory sf = new cc(trustStore); 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. +Uma boa forma de testar isso é tentar capturar o tráfego usando algum proxy como Burp sem autorizar o Burp CA dentro do dispositivo. Também, você pode gerar com o Burp um certificado para um hostname diferente e usá-lo. -### Quebra de Criptografia +### Criptografia fraca -**Processos de Gerenciamento de Chaves Ruins** +**Processos pobres de gerenciamento de chaves** -Alguns desenvolvedores salvam dados sensíveis no armazenamento local e os criptografam com uma chave hardcoded/predizível no código. Isso não deve ser feito, pois alguma engenharia reversa pode permitir que atacantes extraiam as informações confidenciais. +Alguns desenvolvedores salvam dados sensíveis no armazenamento local e os criptografam com uma chave hardcoded/preditiva no código. Isso não deveria ser feito, pois algum reversing pode permitir que atacantes extraiam a informação confidencial. -**Uso de Algoritmos Inseguros e/ou Obsoletos** +**Uso de algoritmos inseguros e/ou depreciados** -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. +Desenvolvedores não deveriam usar **algoritmos depreciados** para realizar **checks** de autorização, **armazenar** ou **enviar** dados. Alguns desses algoritmos são: RC4, MD4, MD5, SHA1... Se **hashes** são usados para armazenar senhas por exemplo, hashes resistentes a brute-force deveriam ser usados com salt. -### Outras verificações +### Outros checks -- É recomendado **ofuscar o APK** para dificultar o trabalho de engenharia reversa para os atacantes. -- Se o aplicativo for sensível (como aplicativos bancários), ele deve realizar suas **próprias verificações para ver se o celular está rooteado** e agir em consequência. -- Se o aplicativo for sensível (como aplicativos bancários), ele deve verificar se um **emulador** está sendo usado. -- Se o aplicativo for sensível (como aplicativos bancários), ele deve **verificar sua própria integridade antes de executar** para checar se foi modificado. -- Use [**APKiD**](https://github.com/rednaga/APKiD) para verificar qual compilador/pacote/ofuscador foi usado para construir o APK. +- É recomendado **ofuscar o APK** para dificultar o trabalho de reverse engineer para atacantes. +- Se o app for sensível (como apps bancários), ele deveria executar seus **próprios checks para ver se o mobile está rooted** e agir em consequência. +- Se o app for sensível (como apps bancários), ele deveria checar se um **emulador** está sendo usado. +- Se o app for sensível (como apps bancários), ele deveria **checar sua própria integridade antes de executar** para verificar se foi modificado. +- Use [**APKiD**](https://github.com/rednaga/APKiD) para verificar qual compiler/packer/obfuscator foi usado para construir o APK -### Aplicação React Native +### React Native Application Leia a página a seguir para aprender como acessar facilmente o código javascript de aplicações React: @@ -185,7 +186,7 @@ Leia a página a seguir para aprender como acessar facilmente o código javascri react-native-application.md {{#endref}} -### Aplicações Xamarin +### Xamarin Applications Leia a página a seguir para aprender como acessar facilmente o código C# de aplicações xamarin: @@ -194,21 +195,21 @@ Leia a página a seguir para aprender como acessar facilmente o código C# de ap ../xamarin-apps.md {{#endref}} -### Aplicações Superempacotadas +### Superpacked Applications -De acordo com este [**post de blog**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/), superempacotado é 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.** +De acordo com este [**blog post**](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 app que descomprima esse tipo de apps... e uma forma mais rápida que envolve **executar a aplicação e coletar os arquivos descomprimidos do filesystem.** -### Análise Estática de Código Automatizada +### Análise Estática Automatizada de Código -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. +A ferramenta [**mariana-trench**](https://github.com/facebook/mariana-trench) é capaz de encontrar **vulnerabilidades** escaneando o **code** da aplicação. Essa ferramenta contém uma série de **known sources** (que indicam ao tool os **lugares** onde a **input** é **controlada pelo usuário**), **sinks** (que indicam ao tool **lugares perigosos** onde input maliciosa do usuário poderia causar danos) e **rules**. Essas rules indicam a **combinação** de **sources-sinks** que sinaliza uma vulnerabilidade. -Com esse conhecimento, **mariana-trench revisará o código e encontrará possíveis vulnerabilidades nele**. +Com esse conhecimento, **mariana-trench irá revisar o code e encontrar possíveis vulnerabilidades nele**. -### Segredos vazados +### Secrets leaked -Uma aplicação pode conter segredos (chaves de API, senhas, URLs ocultas, subdomínios...) dentro dela que você pode ser capaz de descobrir. Você poderia usar uma ferramenta como [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks). +Uma aplicação pode conter segredos (API keys, passwords, hidden urls, subdomains...) dentro dela que você pode ser capaz de descobrir. Você pode usar uma ferramenta como [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) -### Bypass de Autenticação Biométrica +### Bypass Biometric Authentication {{#ref}} @@ -217,12 +218,12 @@ bypass-biometric-authentication-android.md ### Outras funções interessantes -- **Execução de código**: `Runtime.exec(), ProcessBuilder(), native code:system()` -- **Enviar SMSs**: `sendTextMessage, sendMultipartTestMessage` -- **Funções nativas** declaradas como `native`: `public native, System.loadLibrary, System.load` -- [Leia isso para aprender **como reverter funções nativas**](reversing-native-libraries.md) +- **Code execution**: `Runtime.exec(), ProcessBuilder(), native code:system()` +- **Send SMSs**: `sendTextMessage, sendMultipartTestMessage` +- **Native functions** declaradas como `native`: `public native, System.loadLibrary, System.load` +- [Leia isto para aprender **como reverter native functions**](reversing-native-libraries.md) -### **Outras dicas** +### **Outros truques** {{#ref}} @@ -235,23 +236,23 @@ content-protocol.md ## Análise Dinâmica -> Primeiro de tudo, você precisa de um ambiente onde possa instalar a aplicação e todo o ambiente (certificado Burp CA, Drozer e Frida principalmente). Portanto, um dispositivo rooteado (emulado ou não) é extremamente recomendado. +> Antes de tudo, você precisa de um ambiente onde possa instalar a aplicação e todo o ambiente (Burp CA cert, Drozer e Frida principalmente). Portanto, um dispositivo rooted (emulado ou não) é altamente recomendado. -### Análise dinâmica online +### Análise dinâmica Online -Você pode criar uma **conta gratuita** em: [https://appetize.io/](https://appetize.io). Esta plataforma permite que você **faça upload** e **execute** APKs, então é útil para ver como um apk está se comportando. +Você pode criar uma **conta gratuita** em: [https://appetize.io/](https://appetize.io/). Essa plataforma permite **upload** e **execução** de APKs, então é útil para ver como um apk está se comportando. -Você pode até **ver os logs da sua aplicação** na web e se conectar através do **adb**. +Você pode até **ver os logs da sua aplicação** na web e conectar via **adb**. ![](<../../images/image (831).png>) -Graças à conexão ADB, você pode usar **Drozer** e **Frida** dentro dos emuladores. +Graças à conexão ADB você pode usar **Drozer** e **Frida** dentro dos emuladores. -### Análise dinâmica local +### Análise Dinâmica Local #### Usando um emulador -- [**Android Studio**](https://developer.android.com/studio) (Você pode criar dispositivos **x86** e **arm**, e de acordo com [**isso**](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**as últimas versões x86** **suportam bibliotecas ARM** sem precisar de um emulador arm lento). +- [**Android Studio**](https://developer.android.com/studio) (Você pode criar dispositivos **x86** e **arm**, e de acordo com [**isso**](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**as versões x86 mais recentes** **suportam ARM libraries** sem precisar de um emulador arm lento). - Aprenda a configurá-lo nesta página: @@ -259,131 +260,131 @@ Graças à conexão ADB, você pode usar **Drozer** e **Frida** dentro dos emula avd-android-virtual-device.md {{#endref}} -- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Versão gratuita:** Edição Pessoal, você precisa criar uma conta. _É recomendado **baixar** a versão **COM**_ _**VirtualBox** para evitar erros potenciais._) +- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(versão gratuita:** Personal Edition, você precisa criar uma conta. _É recomendado **baixar** a versão **COM**_ _**VirtualBox** para evitar potenciais erros._) - [**Nox**](https://es.bignox.com) (Gratuito, mas não suporta Frida ou Drozer). -> [!DICA] -> Ao criar um novo emulador em qualquer plataforma, lembre-se de que quanto maior a tela, mais lento o emulador funcionará. Portanto, selecione telas pequenas, se possível. +> [!TIP] +> Ao criar um novo emulador em qualquer plataforma lembre-se que quanto maior a tela, mais lento o emulador irá rodar. Então selecione telas pequenas se possível. -Para **instalar os serviços do google** (como AppStore) no Genymotion, você precisa clicar no botão marcado em vermelho da imagem a seguir: +Para **instalar google services** (como AppStore) no Genymotion você precisa clicar no botão marcado em vermelho da imagem a seguir: ![](<../../images/image (277).png>) -Além disso, note que na **configuração da VM Android no Genymotion** você pode selecionar o **modo de rede Bridge** (isso será útil se você estiver se conectando à VM Android de uma VM diferente com as ferramentas). +Além disso, note que na **configuração da VM Android no Genymotion** você pode selecionar **Bridge Network mode** (isso será útil se você for conectar na VM Android a partir de uma VM diferente com as ferramentas). -#### Usar um dispositivo físico +#### Use um dispositivo físico -Você precisa ativar as opções de **depuração** e será legal se você puder **rootear**: +Você precisa ativar as opções de **debugging** e será interessante se você puder **rootear** ele: -1. **Configurações**. -2. (A partir do Android 8.0) Selecione **Sistema**. -3. Selecione **Sobre o telefone**. -4. Pressione **Número da versão** 7 vezes. -5. Volte e você encontrará as **Opções de desenvolvedor**. +1. **Settings**. +2. (FromAndroid 8.0) Selecione **System**. +3. Selecione **About phone**. +4. Pressione **Build number** 7 vezes. +5. Volte e você encontrará as **Developer options**. -> 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. +> Uma vez que você instalou a aplicação, a primeira coisa que deveria fazer é testá-la e investigar o que ela faz, como funciona e ficar confortável com ela.\ +> Sugiro **realizar essa análise dinâmica inicial usando MobSF dynamic analysis + pidcat**, assim seremos capazes de **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 -**Registro** +**Logging** -Os desenvolvedores devem ter cuidado ao expor **informações de depuração** publicamente, pois isso pode levar a vazamentos de dados sensíveis. As ferramentas [**pidcat**](https://github.com/JakeWharton/pidcat) e `adb logcat` são recomendadas para monitorar logs de aplicações para identificar e proteger informações sensíveis. **Pidcat** é preferido por sua facilidade de uso e legibilidade. +Desenvolvedores devem ter cuidado ao expor **informações de debugging** publicamente, pois isso pode levar a vazamento de dados sensíveis. As ferramentas [**pidcat**](https://github.com/JakeWharton/pidcat) e `adb logcat` são recomendadas para monitorar os logs da aplicação para identificar e proteger informação sensível. **Pidcat** é preferido por sua facilidade de uso e legibilidade. -> [!AVISO] -> Note que a partir de **versões mais recentes que Android 4.0**, **as aplicações só podem acessar seus próprios logs**. Portanto, as aplicações não podem acessar os logs de outros aplicativos.\ -> De qualquer forma, ainda é recomendado **não registrar informações sensíveis**. +> [!WARNING] +> Note que a partir de **versões posteriores ao Android 4.0**, **aplicações só podem acessar seus próprios logs**. Portanto aplicações não podem acessar logs de outros apps.\ +> De qualquer forma, ainda é recomendado **não logar informações sensíveis**. -**Cache do Buffer de Copiar/Colar** +**Cache do Clipboard / Copy-Paste** -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. +O framework baseado em **clipboard** do Android habilita a funcionalidade de copy-paste em apps, mas representa um risco já que **outras aplicações** podem **acessar** o clipboard, potencialmente expondo dados sensíveis. É crucial **desabilitar funções de copy/paste** em seções sensíveis de uma aplicação, como detalhes de cartão de crédito, para evitar vazamentos de dados. -**Logs de Crash** +**Crash Logs** -Se uma aplicação **crash** e **salvar logs**, esses logs podem ajudar atacantes, especialmente quando a aplicação não pode ser revertida. Para mitigar esse risco, evite registrar em crashes, e se os logs precisarem ser transmitidos pela rede, assegure-se de que sejam enviados através de um canal SSL para segurança. +Se uma aplicação **crasha** e **salva logs**, esses logs podem auxiliar atacantes, particularmente quando a aplicação não pode ser reverse-engineered. Para mitigar esse risco, evite logar em crashes, e se os logs devem ser transmitidos pela rede, assegure que sejam enviados via canal SSL para segurança. Como pentester, **tente dar uma olhada nesses logs**. -**Dados de Análise Enviados a Terceiros** +**Dados de Analytics enviados para 3rd Parties** -As aplicações frequentemente integram serviços como Google Adsense, que podem inadvertidamente **vazar dados sensíveis** devido à implementação inadequada pelos desenvolvedores. Para identificar potenciais vazamentos de dados, é aconselhável **interceptar o tráfego da aplicação** e verificar se há informações sensíveis sendo enviadas para serviços de terceiros. +Aplicações frequentemente integram serviços como Google Adsense, que podem inadvertidamente **vazar dados sensíveis** devido a implementação incorreta pelos desenvolvedores. Para identificar potenciais vazamentos, é aconselhável **interceptar o tráfego da aplicação** e checar por qualquer informação sensível sendo enviada para serviços de terceiros. -### Bancos de Dados SQLite +### SQLite DBs -A maioria das aplicações usará **bancos de dados SQLite internos** para salvar informações. Durante o pentest, dê uma **olhada** nos **bancos de dados** criados, os nomes das **tabelas** e **colunas** e todos os **dados** salvos, pois você pode encontrar **informações sensíveis** (o que seria uma vulnerabilidade).\ -Os bancos de dados devem estar localizados em `/data/data/the.package.name/databases` como `/data/data/com.mwr.example.sieve/databases`. +A maioria das aplicações irá usar **internal SQLite databases** para salvar informação. Durante o pentest dê uma **olhada** nas **databases** criadas, os nomes das **tables** e **columns** e todos os **dados** salvos porque você pode encontrar **informação sensível** (o que seria uma vulnerabilidade).\ +As databases devem estar localizadas em `/data/data/the.package.name/databases` como `/data/data/com.mwr.example.sieve/databases` -Se o banco de dados estiver salvando informações confidenciais e estiver **criptografado**, mas você conseguir **encontrar** a **senha** dentro da aplicação, ainda é uma **vulnerabilidade**. +Se a database está salvando informação confidencial e está **encrypted** mas você pode **find** a **password** dentro da application, isso ainda é uma **vulnerabilidade**. -Enumere as tabelas usando `.tables` e enumere as colunas das tabelas fazendo `.schema `. +Enumere as tables usando `.tables` e enumere as columns das tables fazendo `.schema ` -### Drozer (Exploit Activities, Content Providers e Services) +### Drozer (Exploit Activities, Content Providers and Services) -Do [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** permite que você **assuma o papel de um aplicativo Android** e interaja com outros aplicativos. Ele pode fazer **qualquer coisa que um aplicativo instalado pode fazer**, como fazer uso do mecanismo de Comunicação Inter-Processo (IPC) do Android e interagir com o sistema operacional subjacente.\ -Drozer é uma ferramenta útil para **explorar atividades exportadas, serviços exportados e Content Providers**, como você aprenderá nas seções seguintes. +Dos [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** permite que você **assuma o papel de um app Android** e interaja com outros apps. Ele pode fazer **qualquer coisa que uma aplicação instalada pode fazer**, como usar o mecanismo de Inter-Process Communication (IPC) do Android e interagir com o sistema operacional subjacente. .\ +Drozer é uma ferramenta útil para **explorar exported activities, exported services e Content Providers** como você irá aprender nas seções seguintes. -### Explorando Atividades Exportadas +### Explorando Activities exportadas -[**Leia isso se você quiser refrescar o que é uma Atividade Android.**](android-applications-basics.md#launcher-activity-and-other-activities)\ -Além disso, lembre-se de que o código de uma atividade começa no método **`onCreate`**. +[**Leia isto se você quiser revisar o que é uma Android Activity.**](android-applications-basics.md#launcher-activity-and-other-activities)\ +Lembre também que o código de uma activity começa no método **`onCreate`**. -**Bypass de Autorização** +**Bypass de autorização** -Quando uma Atividade é exportada, você pode invocar sua tela de um aplicativo externo. Portanto, se uma atividade com **informações sensíveis** for **exportada**, você poderia **burlar** os mecanismos de **autenticação** **para acessá-la.** +Quando uma Activity está exported você pode invocar sua tela a partir de um app externo. Assim, se uma activity com **informação sensível** está **exported** você poderia **bypassar** os mecanismos de **authentication** **para acessá-la.** -[**Aprenda como explorar atividades exportadas com Drozer.**](drozer-tutorial/index.html#activities) +[**Aprenda como explorar exported activities com Drozer.**](drozer-tutorial/index.html#activities) -Você também pode iniciar uma atividade exportada a partir do adb: +Você também pode iniciar uma exported activity a partir do adb: -- PackageName é com.example.demo -- Exported ActivityName é com.example.test.MainActivity +- PackageName is com.example.demo +- Exported ActivityName is com.example.test.MainActivity ```bash adb shell am start -n com.example.demo/com.example.test.MainActivity ``` -**NOTA**: O MobSF detectará como malicioso o uso de _**singleTask/singleInstance**_ como `android:launchMode` em uma atividade, mas devido a [isso](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), aparentemente isso é perigoso apenas em versões antigas (versões da API < 21). +**NOTA**: MobSF detectará como malicioso o uso de _**singleTask/singleInstance**_ como `android:launchMode` em uma activity, mas devido a [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), aparentemente isso é perigoso apenas em versões antigas (API < 21). -> [!DICA] -> Note que uma bypass de autorização nem sempre é uma vulnerabilidade, isso dependerá de como o bypass funciona e quais informações são expostas. +> [!TIP] +> Observe que um authorisation bypass nem sempre é uma vulnerabilidade; depende de como o bypass funciona e quais informações são expostas. **Vazamento de informações sensíveis** -**Atividades também podem retornar resultados**. Se você conseguir encontrar uma atividade exportada e desprotegida chamando o método **`setResult`** e **retornando informações sensíveis**, há um vazamento de informações sensíveis. +**Activities também podem retornar resultados**. Se você conseguir encontrar uma activity exportada e desprotegida que chama o método **`setResult`** e **retorna informações sensíveis**, há um vazamento de informações sensíveis. #### Tapjacking -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). +Se o Tapjacking não for prevenido, você pode abusar da activity exportada para fazer o **usuário executar ações inesperadas**. Para mais informações sobre [**o que é Tapjacking siga o link**](#tapjacking). -### Explorando Provedores de Conteúdo - Acessando e manipulando informações sensíveis +### Exploiting Content Providers - Accessing and manipulating sensitive information -[**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. +[**Leia isto se quiser relembrar o que é um Content Provider.**](android-applications-basics.md#content-provider)\ +Content providers são basicamente usados para **compartilhar dados**. Se um app disponibiliza content providers você pode ser capaz de **extrair dados sensíveis** deles. Também é interessante testar possíveis **SQL injections** e **Path Traversals**, pois eles podem ser vulneráveis. -[**Aprenda como explorar Provedores de Conteúdo com Drozer.**](drozer-tutorial/index.html#content-providers) +[**Aprenda como explorar Content Providers com Drozer.**](drozer-tutorial/index.html#content-providers) -### **Explorando Serviços** +### **Exploiting Services** -[**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`. +[**Leia isto se quiser relembrar o que é um Service.**](android-applications-basics.md#services)\ +Lembre-se que as ações de um Service começam no método `onStartCommand`. -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) +Um Service é basicamente algo que **pode receber dados**, **processá-los** e **retornar** (ou não) uma resposta. Então, se uma aplicação está exportando alguns services você deve **verificar** o **código** para entender o que ele faz 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) -### **Explorando Broadcast Receivers** +### **Exploiting Broadcast Receivers** -[**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 isto se quiser relembrar o que é um Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\ +Lembre-se que as ações de um Broadcast Receiver começam no método `onReceive`. -Um broadcast receiver estará aguardando um tipo de mensagem. Dependendo de como o receptor lida com a mensagem, ele pode ser vulnerável.\ +Um Broadcast Receiver ficará esperando por 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) -### **Explorando Schemes / Deep links** +### **Exploiting Schemes / Deep links** -Você pode procurar por deep links manualmente, usando ferramentas como MobSF ou scripts como [este](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\ -Você pode **abrir** um **scheme** declarado usando **adb** ou um **navegador**: +Você pode procurar por deep links manualmente, usando ferramentas como MobSF ou scripts como [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\ +Você pode **abrir** um **scheme** declarado usando **adb** ou um **browser**: ```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 app que deve abrir esse link._ ```html Click me @@ -392,82 +393,133 @@ _Observe que você pode **omitir o nome do pacote** e o celular chamará automat ``` **Código executado** -Para encontrar o **código que será executado no App**, vá para a atividade chamada pelo deeplink e procure a função **`onNewIntent`**. +Para encontrar o **código que será executado no App**, vá para a activity chamada pelo deeplink e procure a função **`onNewIntent`**. ![](<../../images/image (436) (1) (1) (1).png>) -**Informações sensíveis** +**Informação sensível** -Toda vez que você encontrar um deep link, verifique se **não está recebendo dados sensíveis (como senhas) via parâmetros de URL**, porque qualquer outro aplicativo poderia **impersonar o deep link e roubar esses dados!** +Sempre que encontrar um deep link verifique que **não está recebendo dados sensíveis (como senhas) via parâmetros de URL**, porque qualquer outra aplicação poderia **se passar pelo deep link e roubar esses dados!** -**Parâmetros no caminho** +**Parameters in path** -Você **também deve verificar se algum deep link está usando um parâmetro dentro do caminho** da URL como: `https://api.example.com/v1/users/{username}`, nesse caso você pode forçar uma travessia de caminho acessando algo como: `example://app/users?username=../../unwanted-endpoint%3fparam=value`.\ -Note que se você encontrar os endpoints corretos dentro da aplicação, pode ser capaz de causar um **Open Redirect** (se parte do caminho for usada como nome de domínio), **assumir a conta** (se você puder modificar os detalhes dos usuários sem token CSRF e o endpoint vulnerável usar o método correto) e qualquer outra vulnerabilidade. Mais [info sobre isso aqui](http://dphoeniixx.com/2020/12/13-2/). +Você **deve também verificar se algum deep link está usando um parâmetro dentro do path** da URL como: `https://api.example.com/v1/users/{username}`, nesse caso você pode forçar um path traversal acessando algo como: `example://app/users?username=../../unwanted-endpoint%3fparam=value`.\ +Note que se você encontrar os endpoints corretos dentro da aplicação pode ser possível causar um **Open Redirect** (se parte do path for usada como domain name), **account takeover** (se você conseguir modificar detalhes de usuários sem CSRF token e o vuln endpoint usar o método correto) e qualquer outra vuln. Mais [info about this here](http://dphoeniixx.com/2020/12/13-2/). -**Mais exemplos** +**More examples** -Um [relatório de bug bounty interessante](https://hackerone.com/reports/855618) sobre links (_/.well-known/assetlinks.json_). +Um [interesting bug bounty report](https://hackerone.com/reports/855618) sobre links (_/.well-known/assetlinks.json_). -### Inspeção e Falhas de Verificação da Camada de Transporte +### Inspeção da Camada de Transporte e Falhas de Verificação -- **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. -- **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. -- **O vazamento de informações privadas** é um risco quando os aplicativos se autenticam usando canais seguros, mas depois se comunicam por canais não seguros para outras transações. Essa abordagem falha em proteger dados sensíveis, como cookies de sessão ou detalhes do usuário, de interceptação por entidades maliciosas. +- **Certificates are not always inspected properly** por aplicações Android. É comum que essas aplicações ignorem avisos e aceitem certificados self-signed ou, em alguns casos, retornem a usar conexões HTTP. +- **Negotiations during the SSL/TLS handshake are sometimes weak**, empregando cipher suites inseguros. Essa vulnerabilidade torna a conexão suscetível a ataques man-in-the-middle (MITM), permitindo que atacantes decifrem os dados. +- **Leakage of private information** é um risco quando aplicações 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 session cookies ou detalhes do usuário, da interceptação por entidades maliciosas. #### Verificação de Certificado -Focaremos na **verificação de certificado**. A integridade do certificado do servidor deve ser verificada para aumentar a segurança. Isso é crucial porque configurações TLS inseguras e a transmissão de dados sensíveis por canais não criptografados podem representar riscos significativos. Para etapas detalhadas sobre como verificar certificados de servidor e abordar vulnerabilidades, [**este recurso**](https://manifestsecurity.com/android-application-security-part-10/) fornece orientações abrangentes. +Vamos focar na **verificação de certificados**. A integridade do certificado do servidor deve ser verificada para aumentar a segurança. Isso é crucial porque configurações TLS inseguras e a transmissão de dados sensíveis por canais não encriptados podem representar riscos significativos. Para passos detalhados sobre verificar certificados do servidor e corrigir vulnerabilidades, [**este recurso**](https://manifestsecurity.com/android-application-security-part-10/) fornece orientação abrangente. #### SSL Pinning -SSL Pinning é uma medida de segurança onde o aplicativo verifica o certificado do servidor contra uma cópia conhecida armazenada dentro do próprio aplicativo. Esse método é essencial para prevenir ataques MITM. Implementar SSL Pinning é fortemente recomendado para aplicativos que lidam com informações sensíveis. +SSL Pinning é uma medida de segurança onde a aplicação verifica o certificado do servidor contra uma cópia conhecida armazenada dentro da própria aplicação. Esse método é essencial para prevenir ataques MITM. Implementar SSL Pinning é fortemente recomendado para aplicações que lidam com informação sensível. #### Inspeção de Tráfego -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). +Para inspecionar tráfego HTTP, é necessário **instalar o certificado da ferramenta proxy** (por exemplo, Burp). Sem instalar esse certificado, o tráfego encriptado pode não ser visível através do proxy. Para um guia sobre instalar um certificado CA customizado, [**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). +Aplicações direcionadas a **API Level 24 and above** requerem modificações no Network Security Config para aceitar o certificado CA do proxy. Esse passo é crítico para inspecionar tráfego encriptado. Para instruções sobre como modificar o Network Security Config, [**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. +Se **Flutter** estiver sendo usado, você precisa seguir as instruções em [**esta página**](flutter.md). Isso é porque apenas adicionar o certificado ao store não funcionará, já que Flutter tem sua própria lista de CAs válidas. -#### Contornando o SSL Pinning +#### Detecção estática de SSL/TLS 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: +Antes de tentar bypasses em runtime, mapeie rapidamente onde o pinning é aplicado no APK. A descoberta estática ajuda a planejar hooks/patches e a focar nos caminhos de código corretos. -- Modifique 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á. -- 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) -- Se você ainda acha que há algum tráfego que não está capturando, pode tentar **encaminhar o tráfego para o burp usando iptables**. Leia este blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62) +Tool: SSLPinDetect +- Utilitário open-source de análise estática que decompila o APK para Smali (via apktool) e escaneia por padrões regex curados de implementações de SSL/TLS pinning. +- Reporta o caminho de arquivo exato, número da linha e um trecho de código para cada correspondência. +- Cobre frameworks comuns e caminhos de código customizados: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init com TrustManagers/KeyManagers customizados, e pins em Network Security Config XML. -#### Procurando Vulnerabilidades Comuns na Web +Install +- Pré-requisitos: Python >= 3.8, Java on PATH, apktool +```bash +git clone https://github.com/aancw/SSLPinDetect +cd SSLPinDetect +pip install -r requirements.txt +``` +Uso +```bash +# Basic +python sslpindetect.py -f app.apk -a apktool.jar -É importante também procurar vulnerabilidades comuns na web dentro da aplicação. Informações detalhadas sobre como identificar e mitigar essas vulnerabilidades estão além do escopo deste resumo, mas são amplamente cobertas em outros lugares. +# Verbose (timings + per-match path:line + snippet) +python sslpindetect.py -a apktool_2.11.0.jar -f sample/app-release.apk -v +``` +Exemplo de regras de padrão (JSON) +Use ou estenda signatures para detectar estilos proprietários/personalizados de pinning. Você pode carregar seu próprio JSON e scan em escala. +```json +{ +"OkHttp Certificate Pinning": [ +"Lcom/squareup/okhttp/CertificatePinner;", +"Lokhttp3/CertificatePinner;", +"setCertificatePinner" +], +"TrustManager Override": [ +"Ljavax/net/ssl/X509TrustManager;", +"checkServerTrusted" +] +} +``` +Notas e dicas +- Escaneamento rápido em apps grandes via multithreading e I/O mapeada em memória; regex pré-compiladas reduzem overhead/falsos positivos. +- Coleção de padrões: https://github.com/aancw/smali-sslpin-patterns +- Alvos típicos de detecção para triagem a seguir: +- OkHttp: uso de CertificatePinner, setCertificatePinner, referências ao pacote okhttp3/okhttp +- TrustManagers personalizados: javax.net.ssl.X509TrustManager, sobrescritas de checkServerTrusted +- SSL contexts personalizados: SSLContext.getInstance + SSLContext.init com managers personalizados +- Pins declarativos em res/xml network security config e referências no manifest +- Use as localizações correspondentes para planejar Frida hooks, patches estáticos, ou revisões de configuração antes de testes dinâmicos. + + + +#### Contornando SSL Pinning + +When SSL Pinning is implemented, bypassing it becomes necessary to inspect HTTPS traffic. Various methods are available for this purpose: + +- Automatically **modify** the **apk** to **bypass** SSLPinning with [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). A maior vantagem dessa opção é que você não precisará de root para contornar o SSLPinning, mas será necessário apagar o aplicativo e reinstalar a nova versão, e isso nem sempre funcionará. +- You could use **Frida** (discussed below) to bypass this protection. Here you have a guide to use 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/) +- You can also try to **automatically bypass SSL Pinning** using [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"` +- You can also try to **automatically bypass SSL Pinning** using **MobSF dynamic analysis** (explained below) +- If you still think that there is some traffic that you aren't capturing you can try to **forward the traffic to burp using iptables**. Read this blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62) + +#### Procurando Vulnerabilidades Web Comuns + +É importante também procurar por vulnerabilidades web comuns dentro da aplicação. Informações detalhadas sobre identificação e mitigação dessas vulnerabilidades estão além do escopo deste resumo, mas são amplamente abordadas em outros lugares. ### Frida -[Frida](https://www.frida.re) é uma ferramenta de instrumentação dinâmica para desenvolvedores, engenheiros reversos e pesquisadores de segurança.\ -**Você pode acessar aplicativos em execução e conectar métodos em tempo de execução para mudar o comportamento, alterar valores, extrair valores, executar códigos diferentes...**\ -Se você quiser fazer pentesting em aplicativos Android, precisa saber como usar o Frida. +[Frida](https://www.frida.re) é um toolkit de instrumentação dinâmica para desenvolvedores, reverse-engineers, e pesquisadores de segurança.\ +**Você pode acessar a aplicação em execução e hookar métodos em tempo de execução para alterar o comportamento, mudar valores, extrair valores, executar código diferente...**\ +Se você quer pentest aplicações Android você precisa saber como usar Frida. -- Aprenda a usar o Frida: [**Tutorial Frida**](frida-tutorial/index.html) +- Aprenda a usar o Frida: [**Frida tutorial**](frida-tutorial/index.html) - Algumas "GUI" para ações com Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security) - Ojection é ótimo para automatizar o uso do Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon) -- 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)) +- Você pode encontrar alguns scripts Awesome para Frida aqui: [**https://codeshare.frida.re/**](https://codeshare.frida.re) +- Tente contornar mecanismos anti-debugging / anti-frida carregando o Frida conforme indicado em [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (tool [linjector](https://github.com/erfur/linjector-rs)) -#### Fluxo de trabalho de contorno de anti-instrumentação e SSL pinning +#### Anti-instrumentation & SSL pinning bypass workflow {{#ref}} android-anti-instrumentation-and-ssl-pinning-bypass.md {{#endref}} -### **Dump de Memória - Fridump** +### **Dump Memory - 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. +Verifique se a aplicação está armazenando informações sensíveis na memória que não deveria, 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 fazer dump da memória do app com: ```bash # With PID python3 fridump3.py -u @@ -476,35 +528,35 @@ python3 fridump3.py -u frida-ps -Uai python3 fridump3.py -u "" ``` -Isso irá despejar a memória na pasta ./dump, e lá você pode usar grep com algo como: +Isto irá fazer o dump da memória na pasta ./dump, e lá você pode grep com algo como: ```bash strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+$" ``` ### **Dados sensíveis no Keystore** -No Android, o Keystore é o melhor lugar para armazenar dados sensíveis, no entanto, com privilégios suficientes, ainda é **possível acessá-lo**. Como as aplicações tendem a armazenar aqui **dados sensíveis em texto claro**, os pentests devem verificar isso como usuário root ou alguém com acesso físico ao dispositivo poderia ser capaz de roubar esses dados. +No Android o Keystore é o melhor lugar para armazenar dados sensíveis, porém, com privilégios suficientes ainda é **possível acessá-lo**. Como as aplicações tendem a armazenar aqui **dados sensíveis em texto claro**, os pentests devem verificar isso com privilégios de root — alguém com acesso físico ao dispositivo poderia conseguir roubar esses dados. -Mesmo que um aplicativo armazene dados no keystore, os dados devem ser criptografados. +Mesmo que um app armazene dados no Keystore, esses dados devem ser criptografados. -Para acessar os dados dentro do keystore, você pode usar este script Frida: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js) +Para acessar os dados dentro do Keystore você pode usar este script Frida: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js) ```bash frida -U -f com.example.app -l frida-scripts/tracer-cipher.js ``` -### **Bypass de Impressão Digital/Biometria** +### **Fingerprint/Biometrics Bypass** -Usando o seguinte script Frida, pode ser possível **bypassar a autenticação por impressão digital** que aplicativos Android podem estar realizando para **proteger certas áreas sensíveis:** +Usando o seguinte script Frida, pode ser possível **bypass fingerprint authentication** que aplicações Android possam estar executando para **proteger certas áreas sensíveis:** ```bash frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f ``` ### **Imagens de Fundo** -Quando você coloca um aplicativo em segundo plano, o Android armazena um **instantâneo do aplicativo** para que, quando ele for recuperado para o primeiro plano, comece a carregar a imagem antes do aplicativo, fazendo parecer que o aplicativo foi carregado mais rápido. +Quando você coloca um aplicativo em segundo plano, o Android armazena um **snapshot da aplicação** para que, quando ele for restaurado para o primeiro plano, comece carregando a imagem antes do app, fazendo com que pareça que o aplicativo foi carregado mais rapidamente. -No entanto, se esse instantâneo contiver **informações sensíveis**, alguém com acesso ao instantâneo pode **roubar essas informações** (note que você precisa de root para acessá-lo). +No entanto, se esse snapshot contiver **informações sensíveis**, alguém com acesso ao snapshot pode **roubar essas informações** (observe que é necessário root para acessá-lo). -Os instantâneos geralmente são armazenados em: **`/data/system_ce/0/snapshots`** +Os snapshots 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 forma de **impedir a captura de screenshots configurando o parâmetro de layout FLAG_SECURE**. Ao usar essa flag, o conteúdo da janela é tratado como seguro, evitando que apareça em screenshots ou que seja visualizado em displays não seguros. ```bash getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE); ``` @@ -512,28 +564,28 @@ getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE); Esta ferramenta pode ajudar você a gerenciar diferentes ferramentas durante a análise dinâmica: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer) -### Injeção de Intent +### Intent Injection -Os desenvolvedores frequentemente criam componentes proxy como atividades, serviços e receptores de broadcast que manipulam esses Intents e os passam para métodos como `startActivity(...)` ou `sendBroadcast(...)`, o que pode ser arriscado. +Developers often create proxy components like activities, services, and broadcast receivers that handle these Intents and pass them to methods such as `startActivity(...)` or `sendBroadcast(...)`, which can be risky. -O perigo reside em permitir que atacantes acionem componentes de aplicativo não exportados ou acessem provedores de conteúdo sensíveis ao redirecionar esses Intents. Um exemplo notável é o componente `WebView` convertendo URLs em objetos `Intent` via `Intent.parseUri(...)` e, em seguida, executando-os, potencialmente levando a injeções de Intent maliciosas. +O perigo está em permitir que atacantes disparem componentes não-exportados do app ou acessem content providers sensíveis redirecionando esses Intents. Um exemplo notável é o componente `WebView` convertendo URLs em objetos `Intent` via `Intent.parseUri(...)` e então executando-os, potencialmente levando a injeções maliciosas de Intent. -### Principais Conclusões +### Pontos Essenciais -- **Injeção de Intent** é semelhante ao problema de Redirecionamento Aberto da web. -- Explorações envolvem passar objetos `Intent` como extras, que podem ser redirecionados para executar operações inseguras. -- Pode expor componentes não exportados e provedores de conteúdo a atacantes. -- A conversão de URL para `Intent` do `WebView` pode facilitar ações não intencionais. +- **Intent Injection** is similar to web's Open Redirect issue. +- Exploits involve passing `Intent` objects as extras, which can be redirected to execute unsafe operations. +- It can expose non-exported components and content providers to attackers. +- `WebView`’s URL to `Intent` conversion can facilitate unintended actions. -### Injeções do Lado do Cliente Android e outros +### Injeções no Lado do Cliente Android e outros -Provavelmente você conhece esse tipo de vulnerabilidades da Web. Você deve ter cuidado especial com essas vulnerabilidades em uma aplicação Android: +Provavelmente você conhece esse tipo de vulnerabilidade da Web. Você deve ter cuidado especial com essas vulnerabilidades em uma aplicação Android: -- **Injeção SQL:** Ao lidar com consultas dinâmicas ou Content-Providers, certifique-se de usar consultas parametrizadas. -- **Injeção de JavaScript (XSS):** Verifique se o suporte a JavaScript e Plugins está desativado para qualquer WebView (desativado por padrão). [Mais informações aqui](webview-attacks.md#javascript-enabled). -- **Inclusão de Arquivo Local:** WebViews devem ter acesso ao sistema de arquivos desativado (ativado por padrão) - `(webview.getSettings().setAllowFileAccess(false);)`. [Mais informações aqui](webview-attacks.md#javascript-enabled). -- **Cookies Eternos**: Em vários casos, quando a aplicação android finaliza a sessão, o cookie não é revogado ou pode até ser salvo no disco. -- [**Secure Flag** em cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags) +- **SQL Injection:** When dealing with dynamic queries or Content-Providers ensure you are using parameterized queries. +- **JavaScript Injection (XSS):** Verifique que o suporte a JavaScript e Plugins esteja desabilitado para quaisquer WebViews (desabilitado por padrão). [More info here](webview-attacks.md#javascript-enabled). +- **Local File Inclusion:** WebViews should have access to the file system disabled (enabled by default) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled). +- **Eternal cookies**: Em vários casos, quando a aplicação Android finaliza a sessão o cookie não é revogado ou pode até ser salvo em disco +- [**Secure Flag** in cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags) --- @@ -545,51 +597,51 @@ Provavelmente você conhece esse tipo de vulnerabilidades da Web. Você deve ter ![](<../../images/image (866).png>) -**Avaliação de vulnerabilidades da aplicação** usando uma interface web agradável. Você também pode realizar análise dinâmica (mas precisa preparar o ambiente). +**Avaliação de vulnerabilidades da aplicação** usando uma interface web agradável. Você também pode realizar análise dinâmica (mas é necessário preparar o ambiente). ```bash docker pull opensecurity/mobile-security-framework-mobsf docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest ``` -Observe que o MobSF pode analisar **Android**(apk)**, IOS**(ipa) **e Windows**(apx) aplicações (_As aplicações do Windows devem ser analisadas a partir de um MobSF instalado em um host Windows_).\ -Além disso, se você criar um arquivo **ZIP** com o código-fonte de um aplicativo **Android** ou **IOS** (vá para a pasta raiz do aplicativo, selecione tudo e crie um arquivo ZIP), ele também poderá analisá-lo. +Notice that MobSF can analyse **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\ +Also, if you create a **ZIP** file with the source code if an **Android** or an **IOS** app (go to the root folder of the application, select everything and create a ZIPfile), it will be able to analyse it also. -O MobSF também permite que você **diff/Compare** análises e integre **VirusTotal** (você precisará definir sua chave de API em _MobSF/settings.py_ e habilitá-la: `VT_ENABLED = TRUE` `VT_API_KEY = ` `VT_UPLOAD = TRUE`). Você também pode definir `VT_UPLOAD` como `False`, então o **hash** será **upload** em vez do arquivo. +MobSF also allows you to **diff/Compare** analysis and to integrate **VirusTotal** (you will need to set your API key in _MobSF/settings.py_ and enable it: `VT_ENABLED = TRUE` `VT_API_KEY = ` `VT_UPLOAD = TRUE`). You can also set `VT_UPLOAD` to `False`, then the **hash** will be **upload** instead of the file. -### Análise Dinâmica Assistida com MobSF +### Assisted Dynamic analysis with MobSF -**MobSF** também pode ser muito útil para **análise dinâmica** em **Android**, mas nesse caso você precisará instalar o MobSF e **genymotion** em seu host (uma VM ou Docker não funcionará). _Nota: Você precisa **iniciar primeiro uma VM no genymotion** e **depois o MobSF.**_\ -O **analisador dinâmico do MobSF** pode: +**MobSF** can also be very helpful for **dynamic analysis** in **Android**, but in that case you will need to install MobSF and **genymotion** in your host (a VM or Docker won't work). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\ +The **MobSF dynamic analyser** can: -- **Dump de dados da aplicação** (URLs, logs, área de transferência, capturas de tela feitas por você, capturas de tela feitas por "**Exported Activity Tester**", e-mails, bancos de dados SQLite, arquivos XML e outros arquivos criados). Tudo isso é feito automaticamente, exceto pelas capturas de tela, você precisa pressionar quando quiser uma captura de tela ou precisa pressionar "**Exported Activity Tester**" para obter capturas de tela de todas as atividades exportadas. -- Capturar **tráfego HTTPS** -- Usar **Frida** para obter **informações em tempo de execução** +- **Dump application data** (URLs, logs, clipboard, screenshots made by you, screenshots made by "**Exported Activity Tester**", emails, SQLite databases, XML files, and other created files). All of this is done automatically except for the screenshots, you need to press when you want a screenshot or you need to press "**Exported Activity Tester**" to obtain screenshots of all the exported activities. +- Capture **HTTPS traffic** +- Use **Frida** to obtain **runtime** **information** -A partir das versões **Android > 5**, ele **iniciará automaticamente o Frida** e definirá configurações de **proxy** globais para **capturar** o tráfego. Ele capturará apenas o tráfego do aplicativo testado. +From android **versions > 5**, it will **automatically start Frida** and will set global **proxy** settings to **capture** traffic. It will only capture traffic from the tested application. **Frida** -Por padrão, ele também usará alguns Scripts Frida para **bypass SSL pinning**, **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. +By default, it will also use some Frida Scripts to **bypass SSL pinning**, **root detection** and **debugger detection** and to **monitor interesting APIs**.\ +MobSF can also **invoke exported activities**, grab **screenshots** of them and **save** them for the report. -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 hookados, argumentos passados e valores retornados (isso aparecerá após pressionar "Start Instrumentation").\ -O MobSF também permite que você carregue seus próprios **scripts Frida** (para enviar os resultados dos seus scripts Frida para o MobSF, use a função `send()`). Ele também possui **vários scripts pré-escritos** que você pode carregar (você pode adicionar mais em `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), basta **selecioná-los**, pressionar "**Load**" e pressionar "**Start Instrumentation**" (você poderá ver os logs desses scripts dentro de "**Frida Live Logs**"). +To **start** the dynamic testing press the green bottom: "**Start Instrumentation**". Press the "**Frida Live Logs**" to see the logs generated by the Frida scripts and "**Live API Monitor**" to see all the invocation to hooked methods, arguments passed and returned values (this will appear after pressing "Start Instrumentation").\ +MobSF also allows you to load your own **Frida scripts** (to send the results of your Friday scripts to MobSF use the function `send()`). It also has **several pre-written scripts** you can load (you can add more in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), just **select them**, press "**Load**" and press "**Start Instrumentation**" (you will be able to see the logs of that scripts inside "**Frida Live Logs**"). ![](<../../images/image (419).png>) -Além disso, você tem algumas funcionalidades auxiliares do Frida: +Moreover, you have some Auxiliary Frida functionalities: -- **Enumerar Classes Carregadas**: Ele imprimirá todas as classes carregadas -- **Capturar Strings**: Ele imprimirá todas as strings capturadas enquanto usa o aplicativo (muito barulhento) -- **Capturar Comparações de Strings**: Pode ser muito útil. Ele **mostrará as 2 strings sendo comparadas** e se o resultado foi Verdadeiro ou Falso. -- **Enumerar Métodos de Classe**: Coloque o nome da classe (como "java.io.File") e ele imprimirá todos os métodos da classe. -- **Pesquisar Padrão de Classe**: Pesquisar classes por padrão -- **Rastrear Métodos de Classe**: **Rastrear** uma **classe inteira** (ver entradas e saídas de todos os métodos da classe). Lembre-se de que, por padrão, o MobSF rastreia vários métodos interessantes da API Android. +- **Enumerate Loaded Classes**: It will print all the loaded classes +- **Capture Strings**: It will print all the capture strings while using the application (super noisy) +- **Capture String Comparisons**: Could be very useful. It will **show the 2 strings being compared** and if the result was True or False. +- **Enumerate Class Methods**: Put the class name (like "java.io.File") and it will print all the methods of the class. +- **Search Class Pattern**: Search classes by pattern +- **Trace Class Methods**: **Trace** a **whole class** (see inputs and outputs of all methods of th class). Remember that by default MobSF traces several interesting Android Api methods. -Uma vez que você tenha selecionado o módulo auxiliar que deseja usar, você precisa pressionar "**Start Intrumentation**" e verá todas as saídas em "**Frida Live Logs**". +Once you have selected the auxiliary module you want to use you need to press "**Start Intrumentation**" and you will see all the outputs in "**Frida Live Logs**". **Shell** -O Mobsf também traz um shell com alguns comandos **adb**, **comandos MobSF** e comandos comuns de **shell** na parte inferior da página de análise dinâmica. Alguns comandos interessantes: +Mobsf also brings you a shell with some **adb** commands, **MobSF commands**, and common **shell** **commands** at the bottom of the dynamic analysis page. Some interesting commands: ```bash help shell ls @@ -600,22 +652,22 @@ receivers ``` **Ferramentas HTTP** -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)). +Quando o tráfego http é capturado você pode ver uma vista bruta do tráfego capturado no botão inferior "**HTTP(S) Traffic**" ou uma vista mais agradável no botão verde "**Start HTTPTools**". Pela segunda opção, você pode **enviar** as **captured requests** para **proxies** como Burp ou Owasp ZAP.\ +Para isso, _ligue o Burp -->_ _desative o Intercept --> em MobSF HTTPTools selecione a request_ --> pressione "**Send to Fuzzer**" --> _selecione o proxy address_ ([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 "**Start 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: +> Após realizar uma análise dinâmica com MobSF as configurações de proxy podem ficar mal configuradas e você não conseguirá corrigi-las pela GUI. Você pode corrigir as configurações de proxy fazendo: > > ``` > adb shell settings put global http_proxy :0 > ``` -### Análise Dinâmica Assistida com Inspeckage +### Assisted Dynamic Analysis with Inspeckage -Você pode obter a ferramenta de [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\ -Esta ferramenta usará alguns **Hooks** para te informar **o que está acontecendo na aplicação** enquanto você realiza uma **análise dinâmica**. +Você pode obter a ferramenta em [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\ +Esta ferramenta vai usar alguns **Hooks** para informar **o que está acontecendo na aplicação** enquanto você realiza uma **análise dinâmica**. ### [Yaazhini](https://www.vegabird.com/yaazhini/) @@ -625,7 +677,7 @@ Esta é uma **ótima ferramenta para realizar análise estática com uma GUI** ### [Qark](https://github.com/linkedin/qark) -Esta ferramenta é projetada para procurar várias **vulnerabilidades relacionadas à segurança em aplicações Android**, seja no **código fonte** ou em **APKs empacotados**. A ferramenta também é **capaz de criar um APK "Proof-of-Concept" implantável** e **comandos ADB**, para explorar algumas das vulnerabilidades encontradas (Atividades expostas, intents, tapjacking...). Assim como com o Drozer, não há necessidade de rootear o dispositivo de teste. +Esta ferramenta foi projetada para procurar várias vulnerabilidades relacionadas à segurança em aplicações Android, seja no **source code** ou em **packaged APKs**. A ferramenta também é **capaz de criar um "Proof-of-Concept" deployable APK** e **comandos ADB**, para explorar algumas das vulnerabilidades encontradas (Exposed activities, intents, tapjacking...). Como com Drozer, não é necessário dar root no dispositivo de teste. ```bash pip3 install --user qark # --user is only needed if not using a virtualenv qark --apk path/to/my.apk @@ -634,10 +686,10 @@ qark --java path/to/specific/java/file.java ``` ### [**ReverseAPK**](https://github.com/1N3/ReverseAPK.git) -- Exibe todos os arquivos extraídos para fácil referência +- Exibe todos os arquivos extraídos para referência fácil - Descompila automaticamente arquivos APK para os formatos Java e Smali -- Analisa AndroidManifest.xml em busca de vulnerabilidades e comportamentos comuns -- Análise estática de código-fonte para vulnerabilidades e comportamentos comuns +- Analisa AndroidManifest.xml para common vulnerabilities e behavior +- Análise estática do source code para common vulnerabilities e behavior - Informações do dispositivo - e mais ```bash @@ -645,9 +697,9 @@ reverse-apk relative/path/to/APP.apk ``` ### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super) -SUPER é um aplicativo de linha de comando que pode ser usado no Windows, MacOS X e Linux, que analisa arquivos _.apk_ em busca de vulnerabilidades. Ele faz isso descompactando APKs e aplicando uma série de regras para detectar essas vulnerabilidades. +SUPER é uma aplicação de linha de comando que pode ser usada no Windows, MacOS X e Linux, e que analisa arquivos _.apk_ em busca de vulnerabilidades. Faz isso descomprimindo APKs e aplicando uma série de regras para detectar essas vulnerabilidades. -Todas as regras estão centradas em um arquivo `rules.json`, e cada empresa ou testador pode criar suas próprias regras para analisar o que precisam. +Todas as regras estão centralizadas em um arquivo `rules.json`, e cada empresa ou testador pode criar suas próprias regras para analisar o que precisam. Baixe os binários mais recentes na [download page](https://superanalyzer.rocks/download.html) ``` @@ -657,17 +709,17 @@ super-analyzer {apk_file} ![](<../../images/image (297).png>) -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. +StaCoAn é uma ferramenta **multiplataforma** que auxilia desenvolvedores, bugbounty hunters e ethical hackers na realização de [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) em aplicações móveis. -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. +O conceito é que você arraste e solte o arquivo da sua aplicação móvel (um arquivo .apk ou .ipa) na aplicação StaCoAn e ela irá gerar um relatório visual e portátil para você. Você pode ajustar as configurações e wordlists para obter uma experiência personalizada. -Baixe a [última versão](https://github.com/vincentcox/StaCoAn/releases): +Baixar[ latest release](https://github.com/vincentcox/StaCoAn/releases): ``` ./stacoan ``` ### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework) -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.\ +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] @@ -675,11 +727,11 @@ androbugs.exe -f [APK file] ``` ### [Androwarn](https://github.com/maaaaz/androwarn) -**Androwarn** é uma ferramenta cujo principal objetivo é detectar e alertar o usuário sobre comportamentos potencialmente maliciosos desenvolvidos por um aplicativo Android. +**Androwarn** é uma ferramenta cujo objetivo principal é detectar e avisar o usuário sobre potenciais comportamentos maliciosos desenvolvidos por um aplicativo Android. -A detecção é realizada com a **análise estática** do bytecode Dalvik do aplicativo, representado como **Smali**, com a biblioteca [`androguard`](https://github.com/androguard/androguard). +A detecção é realizada com a **static analysis** do Dalvik bytecode da aplicação, representado como **Smali**, com a biblioteca [`androguard`](https://github.com/androguard/androguard). -Esta ferramenta procura por **comportamentos comuns de aplicativos "ruins"** como: exfiltração de identificadores de telefonia, interceptação de fluxo de áudio/vídeo, modificação de dados PIM, execução de código arbitrário... +Esta ferramenta procura por **comportamento comum de "aplicações maliciosas"** como: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution... ``` python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ``` @@ -687,7 +739,7 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ![](<../../images/image (595).png>) -**MARA** é um **M**obile **A**pplication **R**everse engineering e **A**nalysis Framework. É uma ferramenta que reúne ferramentas comumente usadas para engenharia reversa e análise de aplicativos móveis, para auxiliar na testagem de aplicativos móveis contra as ameaças de segurança móvel da OWASP. Seu objetivo é tornar essa tarefa mais fácil e amigável para desenvolvedores de aplicativos móveis e profissionais de segurança. +**MARA** é um **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. É uma ferramenta que reúne ferramentas comumente usadas para mobile application reverse engineering e analysis, para auxiliar no teste de aplicações móveis contra as ameaças de segurança mobile da OWASP. Seu objetivo é tornar essa tarefa mais fácil e amigável para desenvolvedores de aplicações móveis e profissionais de segurança. Ele é capaz de: @@ -696,72 +748,75 @@ Ele é capaz de: - Extrair informações privadas do APK usando regexps. - Analisar o Manifest. - Analisar domínios encontrados usando: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) e [whatweb](https://github.com/urbanadventurer/WhatWeb) -- Deofuscar APK via [apk-deguard.com](http://www.apk-deguard.com) +- Deobfuscar APK via [apk-deguard.com](http://www.apk-deguard.com) ### Koodous -Útil para detectar malware: [https://koodous.com/](https://koodous.com) +Útil para detectar malware: [https://koodous.com/](https://koodous.com/) -## Ofuscando/Deofuscando código +## Obfuscating/Deobfuscating code -Observe que dependendo do serviço e configuração que você usa para ofuscar o código. Segredos podem ou não acabar ofuscados. +Observe que, dependendo do serviço e da configuração usados para ofuscar o código, segredos podem ou não acabar ofuscados. ### [ProGuard]() -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. +Segundo a [Wikipedia](): **ProGuard** é uma ferramenta open source de linha de comando que reduz, otimiza e ofusca código Java. É capaz de otimizar bytecode assim como detectar e remover instruções não utilizadas. ProGuard é software livre e é distribuído sob a GNU General Public License, 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 Android SDK e é executado ao construir a aplicação em modo release. ### [DexGuard](https://www.guardsquare.com/dexguard) -Encontre um guia passo a passo para deofuscar o apk em [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) +Encontre um guia passo a passo para deobfuscar o apk em [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) -(Daquele guia) Na última vez que verificamos, o modo de operação do Dexguard era: +(Do guia) Da última vez que verificamos, o modo de operação do Dexguard era: - carregar um recurso como um InputStream; -- alimentar o resultado a uma classe que herda de FilterInputStream para descriptografá-lo; -- fazer alguma ofuscação inútil para desperdiçar alguns minutos de tempo de um reversor; -- alimentar o resultado descriptografado a um ZipInputStream para obter um arquivo DEX; -- finalmente carregar o DEX resultante como um Recurso usando o método `loadDex`. +- passar o resultado para uma classe que herda de FilterInputStream para decriptá-lo; +- fazer alguma obfuscação inútil para gastar alguns minutos do tempo de um reverser; +- passar o resultado decriptado para um ZipInputStream para obter um arquivo DEX; +- finalmente carregar o DEX resultante como um Resource usando o método `loadDex`. ### [DeGuard](http://apk-deguard.com) -**DeGuard reverte o processo de ofuscação realizado por ferramentas de ofuscação do Android. Isso permite inúmeras análises de segurança, incluindo inspeção de código e previsão de bibliotecas.** +**DeGuard reverte o processo de ofuscação realizado por ferramentas de ofuscação Android. Isso possibilita diversas análises de segurança, incluindo inspeção de código e identificação de bibliotecas.** Você pode enviar um APK ofuscado para a plataforma deles. -### [Deobfuscate android App](https://github.com/In3tinct/deobfuscate-android-app) +### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app -Esta é uma ferramenta LLM para encontrar quaisquer vulnerabilidades de segurança potenciais em aplicativos android e deofuscar o código do aplicativo android. Usa a API pública Gemini do Google. +Esta é uma ferramenta LLM para encontrar potenciais vulnerabilidades de segurança em android apps e deobfuscar o código de apps android. Usa a Gemini public API do Google. ### [Simplify](https://github.com/CalebFenton/simplify) -É um **deofuscador android genérico.** Simplify **executa virtualmente um aplicativo** para entender seu comportamento e então **tenta otimizar o código** para que se comporte de forma idêntica, mas seja mais fácil para um humano entender. Cada tipo de otimização é simples e genérico, então não importa qual o tipo específico de ofuscação utilizada. +É um **deobfuscator genérico para android.** Simplify **virtualmente executa um app** para entender seu comportamento e então **tenta otimizar o código** para que se comporte de forma idêntica, mas seja mais fácil para um humano entender. Cada tipo de otimização é simples e genérico, então não importa qual tipo específico de ofuscação foi usado. ### [APKiD](https://github.com/rednaga/APKiD) -APKiD fornece informações sobre **como um APK foi feito**. Ele identifica muitos **compiladores**, **empacotadores**, **ofuscadores** e outras coisas estranhas. É o [_PEiD_](https://www.aldeid.com/wiki/PEiD) para Android. +APKiD fornece informações sobre **como um APK foi criado**. Identifica muitos **compilers**, **packers**, **obfuscators**, e outras coisas estranhas. É o [_PEiD_](https://www.aldeid.com/wiki/PEiD) para Android. ### Manual -[Leia este tutorial para aprender algumas dicas sobre **como reverter ofuscação personalizada**](manual-deobfuscation.md) +[Leia este tutorial para aprender alguns truques sobre **como reverter ofuscação personalizada**](manual-deobfuscation.md) ## Labs ### [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 uma coleção dos frameworks, tutoriais e labs mais recentes de diferentes entusiastas e pesquisadores de segurança para reverse engineering e análise de malware. -## Referências +## References - [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/) - [https://appsecwiki.com/#/](https://appsecwiki.com/#/) É uma ótima lista de recursos -- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Curso rápido de Android +- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) curso rápido de Android - [https://manifestsecurity.com/android-application-security/](https://manifestsecurity.com/android-application-security/) - [https://github.com/Ralireza/Android-Security-Teryaagh](https://github.com/Ralireza/Android-Security-Teryaagh) - [https://www.youtube.com/watch?v=PMKnPaGWxtg\&feature=youtu.be\&ab_channel=B3nacSec](https://www.youtube.com/watch?v=PMKnPaGWxtg&feature=youtu.be&ab_channel=B3nacSec) +- [SSLPinDetect: Advanced SSL Pinning Detection for Android Security Analysis](https://petruknisme.medium.com/sslpindetect-advanced-ssl-pinning-detection-for-android-security-analysis-1390e9eca097) +- [SSLPinDetect GitHub](https://github.com/aancw/SSLPinDetect) +- [smali-sslpin-patterns](https://github.com/aancw/smali-sslpin-patterns) -## Ainda a tentar +## Yet to try - [https://www.vegabird.com/yaazhini/](https://www.vegabird.com/yaazhini/) - [https://github.com/abhi-r3v0/Adhrit](https://github.com/abhi-r3v0/Adhrit)