diff --git a/src/mobile-pentesting/android-app-pentesting/android-task-hijacking.md b/src/mobile-pentesting/android-app-pentesting/android-task-hijacking.md
index 12f809ed3..ab55abc6d 100644
--- a/src/mobile-pentesting/android-app-pentesting/android-task-hijacking.md
+++ b/src/mobile-pentesting/android-app-pentesting/android-task-hijacking.md
@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Tarefa, Pilha de Atividades e Atividades em Primeiro Plano
+## Tarefas, Pilha de Atividades e Atividades em Primeiro Plano
 
 No Android, uma **tarefa** é essencialmente um conjunto de atividades com as quais os usuários interagem para completar um trabalho específico, organizadas dentro de uma **pilha de atividades**. Esta pilha ordena as atividades com base em quando foram abertas, com a atividade mais recente exibida no topo como a **atividade em primeiro plano**. A qualquer momento, apenas esta atividade é visível na tela, tornando-se parte da **tarefa em primeiro plano**.
 
@@ -30,14 +30,20 @@ O atributo `launchMode` direciona o manuseio das instâncias de atividade dentro
 1. **Instalação do Aplicativo Malicioso**: A vítima instala o aplicativo do atacante em seu dispositivo.
 2. **Ativação Inicial**: A vítima abre primeiro o aplicativo malicioso, preparando o dispositivo para o ataque.
 3. **Tentativa de Lançamento do Aplicativo Alvo**: A vítima tenta abrir o aplicativo alvo.
-4. **Execução do Sequestro**: Devido à afinidade de tarefa correspondente, o aplicativo malicioso é lançado no lugar do aplicativo alvo.
+4. **Execução do Sequestro**: Em algum momento, o aplicativo tenta abrir a visualização **singleTask**. Devido à afinidade de tarefa correspondente, o aplicativo malicioso é lançado no lugar do aplicativo alvo.
 5. **Engano**: O aplicativo malicioso apresenta uma tela de login falsa semelhante ao aplicativo alvo, enganando o usuário para inserir informações sensíveis.
 
+> [!TIP]
+> Observe que, para que este ataque funcione, a visualização vulnerável **não precisa ter exportado para true** nem precisa ser a atividade principal.
+
 Para uma implementação prática deste ataque, consulte o repositório Task Hijacking Strandhogg no GitHub: [Task Hijacking Strandhogg](https://github.com/az0mb13/Task_Hijacking_Strandhogg).
 
 ### Medidas de Prevenção
 
-Para prevenir tais ataques, os desenvolvedores podem definir `taskAffinity` como uma string vazia e optar pelo modo de lançamento `singleInstance`, garantindo o isolamento de seu aplicativo em relação a outros. Personalizar a função `onBackPressed()` oferece proteção adicional contra sequestro de tarefas.
+Para prevenir tais ataques, os desenvolvedores podem:
+- Definir **`**taskAffinity`** da visualização **singleTask** como uma string vazia (`android:taskAffinity=""`)
+- Optar pelo modo de lançamento **`singleInstance`**, garantindo o isolamento de seu aplicativo em relação a outros.
+- Personalizar a função **`onBackPressed()`** oferece proteção adicional contra sequestro de tarefas.
 
 ## **Referências**
 
diff --git a/src/mobile-pentesting/android-app-pentesting/react-native-application.md b/src/mobile-pentesting/android-app-pentesting/react-native-application.md
index 47231d52a..d7e034307 100644
--- a/src/mobile-pentesting/android-app-pentesting/react-native-application.md
+++ b/src/mobile-pentesting/android-app-pentesting/react-native-application.md
@@ -10,21 +10,29 @@ Para confirmar se a aplicação foi construída no framework React Native, siga
 
 3. Use o comando `find . -print | grep -i ".bundle$"` para procurar o arquivo JavaScript.
 
-Para analisar ainda mais o código JavaScript, crie um arquivo chamado `index.html` no mesmo diretório com o seguinte código:
+## Código Javascript
+
+Se ao verificar o conteúdo do `index.android.bundle` você encontrar o código JavaScript da aplicação (mesmo que minificado), você pode **analisá-lo para encontrar informações sensíveis e vulnerabilidades**.
+
+Como o bundle contém na verdade todo o código JS da aplicação, é possível **dividi-lo em diferentes arquivos** (potencialmente facilitando sua engenharia reversa) usando a **ferramenta [react-native-decompiler](https://github.com/numandev1/react-native-decompiler)**.
+
+### Webpack
+
+Para analisar ainda mais o código JavaScript, você pode fazer o upload do arquivo para [https://spaceraccoon.github.io/webpack-exploder/](https://spaceraccoon.github.io/webpack-exploder/) ou seguir estes passos:
+
+1. Crie um arquivo chamado `index.html` no mesmo diretório com o seguinte código:
 ```html
 <script src="./index.android.bundle"></script>
 ```
-Você pode fazer o upload do arquivo para [https://spaceraccoon.github.io/webpack-exploder/](https://spaceraccoon.github.io/webpack-exploder/) ou seguir estas etapas:
+2. Abra o arquivo `index.html` no Google Chrome.
 
-1. Abra o arquivo `index.html` no Google Chrome.
+3. Abra a Developer Toolbar pressionando **Command+Option+J para OS X** ou **Control+Shift+J para Windows**.
 
-2. Abra a Developer Toolbar pressionando **Command+Option+J para OS X** ou **Control+Shift+J para Windows**.
+4. Clique em "Sources" na Developer Toolbar. Você deve ver um arquivo JavaScript que está dividido em pastas e arquivos, formando o pacote principal.
 
-3. Clique em "Sources" na Developer Toolbar. Você deve ver um arquivo JavaScript que está dividido em pastas e arquivos, formando o pacote principal.
+Se você encontrar um arquivo chamado `index.android.bundle.map`, poderá analisar o código-fonte em um formato não minificado. Os arquivos de mapa contêm mapeamento de origem, que permite mapear identificadores minificados.
 
-Se você encontrar um arquivo chamado `index.android.bundle.map`, poderá analisar o código-fonte em um formato não minimizado. Os arquivos de mapa contêm mapeamento de origem, que permite mapear identificadores minimizados.
-
-Para procurar credenciais sensíveis e endpoints, siga estas etapas:
+Para procurar credenciais e endpoints sensíveis, siga estas etapas:
 
 1. Identifique palavras-chave sensíveis para analisar o código JavaScript. Aplicações React Native costumam usar serviços de terceiros como Firebase, endpoints de serviço AWS S3, chaves privadas, etc.
 
@@ -32,8 +40,42 @@ Para procurar credenciais sensíveis e endpoints, siga estas etapas:
 
 3. Foi uma sorte que credenciais sensíveis codificadas foram encontradas no código JavaScript durante o processo de reconhecimento.
 
+### Mudar o código JS e reconstruir
+
+Neste caso, mudar o código é fácil. Você só precisa renomear o aplicativo para usar a extensão `.zip` e extraí-lo. Então você pode **modificar o código JS dentro deste pacote e reconstruir o aplicativo**. Isso deve ser suficiente para permitir que você **injete código** no aplicativo para fins de teste.
+
+## Hermes bytecode
+
+Se o pacote contiver **Hermes bytecode**, você **não poderá acessar o código Javascript** do aplicativo (nem mesmo a versão minificada).
+
+Você pode verificar se o pacote contém Hermes bytecode executando o seguinte comando:
+```bash
+file index.android.bundle
+index.android.bundle: Hermes JavaScript bytecode, version 96
+```
+No entanto, você pode usar as ferramentas **[hbctool](https://github.com/bongtrop/hbctool)**, **[hermes-dec](https://github.com/P1sec/hermes-dec)** ou **[hermes_rs](https://github.com/Pilfer/hermes_rs)** para **desmontar o bytecode** e também para **decompilá-lo para algum código JS pseudo**. Para fazer isso, por exemplo, esses comandos:
+```bash
+hbc-disassembler ./index.android.bundle /tmp/my_output_file.hasm
+hbc-decompiler ./index.android.bundle /tmp/my_output_file.js
+```
+### Mudar código e reconstruir
+
+Idealmente, você deve ser capaz de modificar o código desmontado (mudando uma comparação, ou um valor ou qualquer coisa que você precise modificar) e então **reconstruir o bytecode** e depois reconstruir o aplicativo.
+
+A ferramenta **[hbctool](https://github.com/bongtrop/hbctool)** suporta a desmontagem do pacote e a reconstrução após as alterações serem realizadas, no entanto, ela **suporta apenas versões antigas** do bytecode Hermes.
+
+A ferramenta **[hermes-dec](https://github.com/P1sec/hermes-dec)** não suporta a reconstrução do bytecode.
+
+A ferramenta **[hermes_rs](https://github.com/Pilfer/hermes_rs)** suporta a reconstrução do bytecode, mas na verdade é uma biblioteca e não uma ferramenta CLI.
+
+## Análise Dinâmica
+
+Você pode tentar analisar dinamicamente o aplicativo usando o Frida para habilitar o modo de desenvolvedor do aplicativo React e usar **`react-native-debugger`** para se conectar a ele. No entanto, para isso, você aparentemente precisa do código-fonte do aplicativo. Você pode encontrar mais informações sobre isso em [https://newsroom.bedefended.com/hooking-react-native-applications-with-frida/](https://newsroom.bedefended.com/hooking-react-native-applications-with-frida/).
+
 ## Referências
 
 - [https://medium.com/bugbountywriteup/lets-know-how-i-have-explored-the-buried-secrets-in-react-native-application-6236728198f7](https://medium.com/bugbountywriteup/lets-know-how-i-have-explored-the-buried-secrets-in-react-native-application-6236728198f7)
+- [https://www.assetnote.io/resources/research/expanding-the-attack-surface-react-native-android-applications](https://www.assetnote.io/resources/research/expanding-the-attack-surface-react-native-android-applications)
+- [https://payatu.com/wp-content/uploads/2023/02/Mastering-React-Native-Application-Pentesting-A-Practical-Guide-2.pdf](https://payatu.com/wp-content/uploads/2023/02/Mastering-React-Native-Application-Pentesting-A-Practical-Guide-2.pdf)
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/mobile-pentesting/android-app-pentesting/tapjacking.md b/src/mobile-pentesting/android-app-pentesting/tapjacking.md
index d25d3f27f..b7e733c73 100644
--- a/src/mobile-pentesting/android-app-pentesting/tapjacking.md
+++ b/src/mobile-pentesting/android-app-pentesting/tapjacking.md
@@ -4,18 +4,20 @@
 
 ## **Informações Básicas**
 
-**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 a aplicação vítima, sua interface de usuário é projetada de tal forma a enganar o usuário para interagir com ela, enquanto passa a interação para a aplicação vítima.\
-Na prática, isso **cega o usuário para que ele não saiba que está realmente realizando ações na aplicação vítima**.
+**Tapjacking** é um ataque onde um **aplicativo malicioso** é lançado e **se posiciona em cima de um aplicativo vítima**. Uma vez que ele obscurece visivelmente o aplicativo vítima, sua interface de usuário é projetada de tal forma a enganar o usuário para interagir com ele, enquanto passa a interação para o aplicativo vítima.\
+Na prática, isso **cega o usuário para que ele não saiba que está realmente realizando ações no aplicativo vítima**.
 
 ### Detecção
 
-Para detectar aplicativos vulneráveis a este ataque, você deve procurar por **atividades exportadas** no manifesto do android (note que uma atividade com um intent-filter é automaticamente exportada por padrão). Uma vez que você tenha encontrado as atividades exportadas, **verifique se elas requerem alguma permissão**. Isso ocorre porque a **aplicação maliciosa também precisará dessa permissão**.
+Para detectar aplicativos vulneráveis a este ataque, você deve procurar por **atividades exportadas** no manifesto do android (note que uma atividade com um intent-filter é automaticamente exportada por padrão). Uma vez que você tenha encontrado as atividades exportadas, **verifique se elas requerem alguma permissão**. Isso ocorre porque o **aplicativo malicioso também precisará dessa permissão**.
+
+Você também pode verificar a versão mínima do SDK do aplicativo, checando o valor de **`android:minSdkVersion`** no arquivo **`AndroidManifest.xml`**. Se o valor for **menor que 30**, o aplicativo é vulnerável ao Tapjacking.
 
 ### Proteção
 
 #### Android 12 (API 31,32) e superior
 
-[**De acordo com esta fonte**](https://www.geeksforgeeks.org/tapjacking-in-android/)**,** ataques de tapjacking são automaticamente prevenidos pelo Android a partir do Android 12 (API 31 & 30) e superior. Portanto, mesmo que a aplicação seja vulnerável, você **não poderá explorá-la**.
+[**De acordo com esta fonte**](https://www.geeksforgeeks.org/tapjacking-in-android/)**,** ataques de tapjacking são automaticamente prevenidos pelo Android a partir do Android 12 (API 31 & 30) e superior. Portanto, mesmo que o aplicativo seja vulnerável, você **não poderá explorá-lo**.
 
 #### `filterTouchesWhenObscured`
 
@@ -23,7 +25,7 @@ Se **`android:filterTouchesWhenObscured`** estiver definido como **`true`**, a `
 
 #### **`setFilterTouchesWhenObscured`**
 
-O atributo **`setFilterTouchesWhenObscured`** definido como true também pode prevenir a exploração dessa vulnerabilidade se a versão do Android for inferior.\
+O atributo **`setFilterTouchesWhenObscured`** definido como verdadeiro também pode prevenir a exploração dessa vulnerabilidade se a versão do Android for inferior.\
 Se definido como **`true`**, por exemplo, um botão pode ser automaticamente **desativado se estiver obscurecido**:
 ```xml
 <Button android:text="Button"
@@ -48,15 +50,14 @@ Um projeto de exemplo implementando **FloatingWindowApp**, que pode ser usado pa
 ### Qark
 
 > [!CAUTION]
-> Parece que este projeto agora não está mais sendo mantido e essa funcionalidade não está funcionando corretamente
+> Parece que este projeto agora não está mais sendo mantido e essa funcionalidade não está funcionando corretamente.
 
 Você pode usar [**qark**](https://github.com/linkedin/qark) com os parâmetros `--exploit-apk` --sdk-path `/Users/username/Library/Android/sdk` para criar um aplicativo malicioso para testar possíveis vulnerabilidades de **Tapjacking**.\
 
 A mitigação é relativamente simples, pois o desenvolvedor pode optar por não receber eventos de toque quando uma visualização está coberta por outra. Usando a [Referência do Desenvolvedor Android](https://developer.android.com/reference/android/view/View#security):
 
-> Às vezes, é essencial que um aplicativo possa verificar se uma ação está sendo realizada com o pleno conhecimento e consentimento do usuário, como conceder um pedido de permissão, fazer uma compra ou clicar em um anúncio. Infelizmente, um aplicativo malicioso poderia tentar enganar o usuário para realizar essas ações, sem saber, ocultando o propósito pretendido da visualização. Como remédio, o framework oferece um mecanismo de filtragem de toque que pode ser usado para melhorar a segurança de visualizações que fornecem acesso a funcionalidades sensíveis.
+> Às vezes, é essencial que um aplicativo possa verificar se uma ação está sendo realizada com o pleno conhecimento e consentimento do usuário, como conceder um pedido de permissão, fazer uma compra ou clicar em um anúncio. Infelizmente, um aplicativo malicioso poderia tentar enganar o usuário para realizar essas ações, sem saber, ocultando o propósito pretendido da visualização. Como remédio, o framework oferece um mecanismo de filtragem de toque que pode ser usado para melhorar a segurança das visualizações que fornecem acesso a funcionalidades sensíveis.
 >
 > Para habilitar a filtragem de toque, chame [`setFilterTouchesWhenObscured(boolean)`](https://developer.android.com/reference/android/view/View#setFilterTouchesWhenObscured%28boolean%29) ou defina o atributo de layout android:filterTouchesWhenObscured como true. Quando habilitado, o framework descartará toques que forem recebidos sempre que a janela da visualização estiver obscurecida por outra janela visível. Como resultado, a visualização não receberá toques sempre que um toast, diálogo ou outra janela aparecer acima da janela da visualização.
 
-
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/theme/ht_searcher.js b/theme/ht_searcher.js
index 1cee01a8c..52e150d9a 100644
--- a/theme/ht_searcher.js
+++ b/theme/ht_searcher.js
@@ -471,12 +471,13 @@ window.search = window.search || {};
         showResults(true);
     }
 
-    fetch(path_to_root + 'searchindex.json')
+    var branch = lang === "en" ? "master" : lang
+    fetch(`https://raw.githubusercontent.com/HackTricks-wiki/hacktricks/refs/heads/${branch}/searchindex.json`)
         .then(response => response.json())
         .then(json => init(json))        
         .catch(error => { // Try to load searchindex.js if fetch failed
             var script = document.createElement('script');
-            script.src = path_to_root + 'searchindex.js';
+            script.src = `https://raw.githubusercontent.com/HackTricks-wiki/hacktricks/refs/heads/${branch}/searchindex.js`;
             script.onload = () => init(window.search);
             document.head.appendChild(script);
         });
diff --git a/theme/index.hbs b/theme/index.hbs
index 166e177c4..70b70a68a 100644
--- a/theme/index.hbs
+++ b/theme/index.hbs
@@ -55,6 +55,7 @@
         <!-- Provide site root to javascript -->
         <script>
             var path_to_root = "{{ path_to_root }}";
+            var lang = "{{ language }}";
             var default_theme = window.matchMedia("(prefers-color-scheme: dark)").matches ? "{{ preferred_dark_theme }}" : "{{ default_theme }}";
         </script>
         <!-- Start loading toc.js asap -->